FCL/sf/os/persistentdata: comparison persistentstorage/sql/OsLayer/FileBuf64.cpp

equal deleted inserted replaced

-:ba32e40d9f36
+:c4e342fcf0c8
-// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
 // All rights reserved.
 // This component and the accompanying materials are made available
 // under the terms of "Eclipse Public License v1.0"
 // which accompanies this distribution, and is available
 // at the URL "http://www.eclipse.org/legal/epl-v10.html".
 #ifdef _SQLPROFILER
 extern TBool TheOsCallTimeDetailedProfileEnabled;//If true, the OS porting layer call details are enabled and for each call an entry will be added to the log file (epocwind.out).
-#define PROFILE_READ(pos,amount) \
+#define PROFILE_READ(pos, amount, err) \
 	do \
 		{ \
 		if(TheOsCallTimeDetailedProfileEnabled) \
 			{ \
 			++iFileReadCount; iFileReadAmount += (amount); \
-			RDebug::Print(_L(" -- FRead    this=%X, Cnt=%d, Pos=%ld, Amt=%d, Ttl=%ld\r\n"), (TUint32)this, iFileReadCount,  pos, amount, iFileReadAmount); \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Read¬%d¬%ld¬%d¬%ld¬%d\r\n"), (TUint32)this, iFileReadCount, pos, amount, iFileReadAmount, err); \
 			} \
 		} while(0)
-#define PROFILE_WRITE(pos,amount) \
+#define PROFILE_WRITE(pos, amount, err) \
 	do \
 		{ \
 		if(TheOsCallTimeDetailedProfileEnabled) \
 			{ \
 			++iFileWriteCount; iFileWriteAmount += (amount); \
-			RDebug::Print(_L(" -- FWrite   this=%X, Cnt=%d, Pos=%ld, Amt=%d, Ttl=%ld\r\n"), (TUint32)this, iFileWriteCount, pos, amount, iFileWriteAmount); \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Write¬%d¬%ld¬%d¬%ld¬%d\r\n"), (TUint32)this, iFileWriteCount, pos, amount, iFileWriteAmount, err); \
 			} \
 		} while(0)
-#define PROFILE_SIZE() \
+#define PROFILE_SIZE(size, err) \
 	do \
 		{ \
 		if(TheOsCallTimeDetailedProfileEnabled) \
 			{ \
 			++iFileSizeCount; \
-			RDebug::Print(_L(" -- FSize    this=%X, Cnt=%d\r\n"), (TUint32)this, iFileSizeCount); \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Size¬%d¬%ld¬¬¬%d\r\n"), (TUint32)this, iFileSizeCount, size, err); \
 			} \
 		} while(0)
-#define PROFILE_SETSIZE() \
+#define PROFILE_SETSIZE(size, err) \
 	do \
 		{ \
 		if(TheOsCallTimeDetailedProfileEnabled) \
 			{ \
 			++iFileSetSizeCount; \
-			RDebug::Print(_L(" -- FSetSize this=%X, Cnt=%d\r\n"), (TUint32)this, iFileSetSizeCount); \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬SetSize¬%d¬%ld¬¬¬%d\r\n"), (TUint32)this, iFileSetSizeCount, size, err); \
 			} \
 		} while(0)
-#define PROFILE_FLUSH()	\
+#define PROFILE_FLUSH(err)	\
 	do \
 		{ \
 		if(TheOsCallTimeDetailedProfileEnabled) \
 			{ \
 			++iFileFlushCount; \
-			RDebug::Print(_L(" -- FFlush   this=%X, Cnt=%d\r\n"), (TUint32)this, iFileFlushCount); \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Flush¬%d¬¬¬¬%d\r\n"), (TUint32)this, iFileFlushCount, err); \
 			} \
 		} while(0)
+#define PROFILE_CREATE(fname, err) \
+	do \
+		{ \
+		if(TheOsCallTimeDetailedProfileEnabled) \
+			{ \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Create¬¬¬¬¬%d¬%S\r\n"), (TUint32)this, err, &fname); \
+			} \
+		} while(0)
+#define PROFILE_OPEN(fname, err) \
+	do \
+		{ \
+		if(TheOsCallTimeDetailedProfileEnabled) \
+			{ \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Open¬¬¬¬¬%d¬%S\r\n"), (TUint32)this, err, &fname); \
+			} \
+		} while(0)
+#define PROFILE_TEMP(fname, err) \
+	do \
+		{ \
+		if(TheOsCallTimeDetailedProfileEnabled) \
+			{ \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Temp¬¬¬¬¬%d¬%S\r\n"), (TUint32)this, err, &fname); \
+			} \
+		} while(0)
+#define PROFILE_ADOPT(fname, err) \
+	do \
+		{ \
+		if(TheOsCallTimeDetailedProfileEnabled) \
+			{ \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Adopt¬¬¬¬¬%d¬%S\r\n"), (TUint32)this, err, &fname); \
+			} \
+		} while(0)
+#define PROFILE_CLOSE() \
+	do \
+		{ \
+		if(TheOsCallTimeDetailedProfileEnabled) \
+			{ \
+			RDebug::Print(_L("[SQL-FBUF]¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬\"%X\"¬Close¬¬¬¬¬¬\r\n"), (TUint32)this); \
+			} \
+		} while(0)
 //Resets the profiler counters
 void RFileBuf64::ProfilerReset()
 	{
 	iFileReadCount = 0; iFileReadAmount = 0; iFileWriteCount = 0; iFileWriteAmount = 0; iFileSizeCount = 0; iFileSetSizeCount = 0; iFileFlushCount = 0;
 	}
 #else
-#define PROFILE_READ(pos,amount)	void(0)
+#define PROFILE_READ(pos,amount, err)	void(0)
-#define PROFILE_WRITE(pos,amount)	void(0)
+#define PROFILE_WRITE(pos,amount, err)	void(0)
-#define PROFILE_SIZE()			void(0)
+#define PROFILE_SIZE(size, err)			void(0)
-#define PROFILE_SETSIZE()		void(0)
+#define PROFILE_SETSIZE(size, err)		void(0)
-#define PROFILE_FLUSH()			void(0)
+#define PROFILE_FLUSH(err)				void(0)
+#define PROFILE_CREATE(fname, err)		void(0)
+#define PROFILE_OPEN(fname, err)		void(0)
+#define PROFILE_TEMP(fname, err)		void(0)
+#define PROFILE_ADOPT(fname, err)		void(0)
+#define PROFILE_CLOSE()					void(0)
 #endif//_SQLPROFILER
 /**
 This constant is used for initializing the RFileBuf64::iFileSize data member and means that
 	EFBufPanicNullThis,
 	EFBufPanicDirty,
 	EFBufPanicNextReadFilePos,
 	EFBufPanicNextReadFilePosHits,
 	EFBufPanicFileBlockSize,			//15
+	EFBufPanicRwDataLength,
 	};
 /**
 Helper function used in the implementation of the __FBUF64_ASSERT() macro.
 In case if the expression in __FBUF64_ASSERT() macro evaluates to false,
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /**
 Initializes RFileBuf64 data members with their default values.
-@param aSize Max file buffer size (capacity) in bytes.
+@param aMinCapacity Minimal file buffer size (capacity) in bytes.
-@panic FBuf64 1 In _DEBUG mode - aSize is 0 or negative.
+@panic FBuf64 1 In _DEBUG mode - aMinCapacity is 0 or negative.
 */
-RFileBuf64::RFileBuf64(TInt aSize) :
+RFileBuf64::RFileBuf64(TInt aMinCapacity) :
-	iCapacity(aSize),
+	iCapacity(aMinCapacity),
-	iReadAheadSize(RFileBuf64::KDefaultReadAheadSize)
+	iReadAheadSize(RFileBuf64::KDefaultReadAheadSize),
-	{
+	iOptimized(EFalse)
-	__FBUF64_ASSERT(aSize > 0, EFBufPanicCapacity);
+	{
+	__FBUF64_ASSERT(aMinCapacity > 0, EFBufPanicCapacity);
 	}
 /**
 Initializes the RFileBuf64 object and creates and opens a new file that will be accessed through RFileBuf64 public interface.
 If the file already exists, an error is returned.
 	TInt err = DoPreInit();
 	if(err == KErrNone)
 	    {
 	    err = iFile.Create(aFs, aFileName, aFileMode);
 	    }
+	PROFILE_CREATE(aFileName, err);
 	return DoPostInit(err);
 	}
 /**
 Initializes the RFileBuf64 object and opens an existing file that will be accessed through RFileBuf64 public interface.
 TInt err = DoPreInit();
 if(err == KErrNone)
 {
 err = iFile.Open(aFs, aFileName, aFileMode);
 }
+	PROFILE_OPEN(aFileName, err);
 return DoPostInit(err);
 	}
 /**
 Initializes the RFileBuf64 object and creates and opens a temporary file with unique name that will be accessed through
 TInt err = DoPreInit();
 if(err == KErrNone)
 {
 err = iFile.Temp(aFs, aPath, aFileName, aFileMode);
 }
+	PROFILE_TEMP(aFileName, err);
 return DoPostInit(err);
 	}
 /**
 Initializes the RFileBuf64 object and creates and adopts an already open file from a client that will be accessed through
 TInt err = DoPreInit();
 if(err == KErrNone)
 {
 err = iFile.AdoptFromClient(aMsg, aFsIndex, aFileIndex);
 }
+	PROFILE_ADOPT(KNullDesC, err);
 return DoPostInit(err);
 	}
 /**
 Writes to the file the pending data (if the buffer contains pending data), closes the file and releases
 		(void)DoFileWrite2();
 		}
 	iFile.Close();
 	User::Free(iBase);
 	iBase = 0;
+	PROFILE_CLOSE();
 	}
 /**
 Calculates and sets optimal read-ahead buffer size.
 aBlockSize and aReadRecBufSize values are retrieved by the caller from the file system.
 TInt RFileBuf64::Read(TInt64 aFilePos, TDes8& aDes)
 	{
 	__FBUF64_ASSERT(aFilePos >= 0, EFBufPanicFilePos);
 	__FILEBUF64_INVARIANT();
 	aDes.SetLength(0);
-	//1. The output buffer max len is 0
+	//0. The output buffer max len is 0
 	if(aDes.MaxLength() == 0)
 		{
 		__FILEBUF64_INVARIANT();
 		return KErrNone;
 		}
-	//2. Initialize the "iFileSize" if it is not initialized yet
+	//1. Initialize the "iFileSize" if it is not initialized yet
 	TInt err = DoFileSize();
 	if(err != KErrNone)
 		{
 		__FILEBUF64_INVARIANT();
 		return err;
 		}
+	//2. Optimize the buffer capacity
+	TInt len = aDes.MaxLength();
+	if((err = DoSetCapacity(len)) != KErrNone)
+		{
+		return err;
+		}
 	//3. Too big "read" request - read directly from the file
-	TInt len = aDes.MaxLength();
 	if(len > iCapacity)
 		{
 		if((aFilePos + len) > iFilePos && aFilePos < (iFilePos + iLength))
 			{//Write the pending data if the iDirty flag is set, otherwise preserve the buffer content.
 			err = DoFileWrite1(aFilePos);
 			}
 		if(err == KErrNone)
 			{
 			err = iFile.Read(aFilePos, aDes);
-			PROFILE_READ(aFilePos, aDes.Size());
+			PROFILE_READ(aFilePos, aDes.Size(), err);
 			}
 		__FILEBUF64_INVARIANT();
 		return err;
 		}
 	//4. The requested data size is smaller than the buffer capacity
 			if(iNextReadFilePos != aFilePos)
 				{//Guessed read ahead was wrong. Direct "file read" operation
 				iNextReadFilePosHits = 0;
 				TPtr8 ptr2(outptr, len);
 				err = iFile.Read(aFilePos, ptr2);
-				PROFILE_READ(aFilePos, ptr2.Size());
+				PROFILE_READ(aFilePos, ptr2.Size(), err);
 				if(err == KErrNone)
 					{
 					iNextReadFilePos = aFilePos + len;
 					len -= ptr2.Length();
 					}
 				break;
 				}
 			//The guessed from the previous "file read" operation file pos is correct. Start reading-ahead.
-			const TInt KMaxReadFilePosHits = 8;//The max read-ahead buffer size can be up to 2^8 times the iReadAheadSize
+			const TInt KMaxReadFilePosHits = 4;//The max read-ahead buffer size can be up to 2^4 times the iReadAheadSize
 			if(iNextReadFilePosHits < KMaxReadFilePosHits)
 				{
 				++iNextReadFilePosHits;
 				}
 			TInt maxReadAhead = iReadAheadSize * (1 << iNextReadFilePosHits);
 				// if read-ahead doesn't cross block boundary do it all
 				readahead = maxReadAhead;
 				}
 			TPtr8 ptr(iBase, Min(iCapacity, (len + readahead)));
 			err = iFile.Read(aFilePos, ptr);
-			PROFILE_READ(aFilePos, ptr.Size());
+			PROFILE_READ(aFilePos, ptr.Size(), err);
 			if(err == KErrNone)
 				{
 				iFilePos = aFilePos;
 				iLength = ptr.Length();
 				iNextReadFilePos = iFilePos + iLength;
 	TInt err = DoFileSize();
 	if(err != KErrNone)
 		{
 		__FILEBUF64_INVARIANT();
 		return err;
+		}
+	if((err = DoSetCapacity(aData.Length())) != KErrNone)
+		{
+		return err;
 		}
 	DoDiscardBufferedReadData();
 	const TUint8* data = aData.Ptr();
 	for(TInt len = aData.Length(); len > 0 && err == KErrNone;)
 		{
 	if(iFileSize != KFileSizeNotSet)
 		{
 		__FILEBUF64_INVARIANT();
 		return KErrNone;
 		}
-	PROFILE_SIZE();
 	TInt err = iFile.Size(iFileSize);
+	PROFILE_SIZE(iFileSize, err);
 	if(err != KErrNone)
 		{
 		DoDiscard();
 		}
 	__FILEBUF64_INVARIANT();
 	//If the new file size is "in" the buffer then change the "iLength"
 	else if(aFileSize < (iFilePos + iLength))
 		{
 		iLength = aFileSize - iFilePos;
 		}
-	PROFILE_SETSIZE();
 	TInt err = iFile.SetSize(aFileSize);
+	PROFILE_SETSIZE(aFileSize, err);
 	if(err != KErrNone)
 		{
 		DoDiscard();
 		}
 	else
 	if(err != KErrNone)
 		{
 		__FILEBUF64_INVARIANT();
 		return err;
 		}
-	PROFILE_FLUSH();
 	err = iFile.Flush();
+	PROFILE_FLUSH(err);
 	if(err != KErrNone)
 		{
 		DoDiscard();
 		}
 	iLength = 0;
 	if(iLength == 0)
 		{
 		__FILEBUF64_INVARIANT();
 		return KErrNone;
 		}
-	PROFILE_WRITE(iFilePos, iLength);
 	TPtrC8 data(iBase, iLength);
 	TInt err = iFile.Write(iFilePos, data);
+	PROFILE_WRITE(iFilePos, iLength, err);
 	if(err == KErrNone)
 		{
 		iFileSize = Max(iFileSize, (iFilePos + iLength));
 		}
 	else
 		iNextReadFilePosHits = 0;
 		}
 	__FILEBUF64_INVARIANT();
 	}
+/**
+Sets the most appropriate buffer capacity based on the database page size.
+The function does a lazy evaluation. The first time the function is called and
+aRwDataLength parameter is recognized to be a database or journal page size, the new (optimal)
+buffer capacity is calculated and set. All next DoSetCapacity() calls will detect that the new
+capacity is already set and will return KErrNone.
+@param  aRwDataLength The length of the data being read or written.
+@return KErrNone The new capacity was set successfully,
+KErrNoMemory Out of memory.
+*/
+TInt RFileBuf64::DoSetCapacity(TInt aRwDataLength)
+	{
+	const TInt KMinPageCount = 4;//the buffer capacity should be at least (KMinPageCount * page size)
+	                             //but not less than the original capacity.
+	const TInt KDefaultPageSize = 1024;//The journal header size is equal to 512 bytes, so it is not easy
+//to detect the 512 bytes page size.
+	__FBUF64_ASSERT(aRwDataLength > 0, EFBufPanicRwDataLength);
+	__FILEBUF64_INVARIANT();
+	if(iOptimized)
+		{
+		__FILEBUF64_INVARIANT();
+		return KErrNone;
+		}
+	if((aRwDataLength & (aRwDataLength - 1)) != 0 || aRwDataLength < KDefaultPageSize)
+		{
+		__FILEBUF64_INVARIANT();
+		return KErrNone;
+		}
+	//Here: aRwDataLength is power of 2 and is bigger than the default db page size.
+	//aRwDataLength is the size of the db page.
+	const TInt pageSize = aRwDataLength;
+	TInt cnt = iCapacity / pageSize;//how many pages can fit in the buffer now
+	TInt pageCount = Max(cnt, KMinPageCount);//the number of pages that should fit in the new buffer
+	TInt newBufCapacity = pageCount * pageSize;
+	if(newBufCapacity != iCapacity)
+		{
+		TUint8* newBase = static_cast <TUint8*> (User::ReAlloc(iBase, newBufCapacity));
+		if(!newBase)
+			{
+			__FILEBUF64_INVARIANT();
+			return KErrNoMemory;
+			}
+		iBase = newBase;
+		iCapacity = newBufCapacity;
+		//Adjust the initial read-ahead size to be multiple of the page size.
+		if((iReadAheadSize % pageSize) != 0)
+			{
+			TInt q = iReadAheadSize / pageSize;
+			iReadAheadSize = q != 0 ? pageSize * q : pageSize;
+			}
+		}
+	iOptimized = ETrue;
+	__FILEBUF64_INVARIANT();
+	return KErrNone;
+	}
 #ifdef _DEBUG
 /**
 RFileBuf64 invariant. Called in _DEBUG mode at the beginning and before the end of every RFileBuf64 method
 (except the init/destroy methods).
 @panic FBuf64   4 In _DEBUG mode - negative iFilePos value.
 @panic FBuf64   5 In _DEBUG mode - set but negative iFileSize value.
 @panic FBuf64   6 In _DEBUG mode - null file handle (the RFile64 object is not created or already destroyed).
 @panic FBuf64  13 In _DEBUG mode - set but negative iNextReadFilePos value.
 @panic FBuf64  14 In _DEBUG mode - negative iNextReadFilePosHits value.
-@panic FBuf64  15 In _DEBUG mode - iReadAheadSize is negative or is not power of two.
+@panic FBuf64  15 In _DEBUG mode - iReadAheadSize is negative or is bigger than iCapacity.
 */
 void RFileBuf64::Invariant() const
 	{
 	__FBUF64_ASSERT(this != 0, EFBufPanicNullThis);
 	__FBUF64_ASSERT(iCapacity > 0, EFBufPanicCapacity);
 	__FBUF64_ASSERT(iFilePos >= 0, EFBufPanicFilePos);
 	__FBUF64_ASSERT(iFileSize == KFileSizeNotSet || iFileSize >= 0, EFBufPanicFileSize);
 	__FBUF64_ASSERT(iFile.SubSessionHandle() != 0, EFBufPanicFileHandle);
 	__FBUF64_ASSERT(iNextReadFilePos == KNextReadFilePosNotSet || iNextReadFilePos >= 0, EFBufPanicNextReadFilePos);
 	__FBUF64_ASSERT(iNextReadFilePosHits >= 0, EFBufPanicNextReadFilePosHits);
-	__FBUF64_ASSERT(iReadAheadSize > 0 && (iReadAheadSize & (iReadAheadSize - 1)) == 0, EFBufPanicFileBlockSize);
+	__FBUF64_ASSERT(iReadAheadSize > 0, EFBufPanicFileBlockSize);
 	}
 #endif

branch	GCC_SURGE
changeset 38	c4e342fcf0c8
parent 35	0d6db0a14001
child 41	3256212fc81f