FCL/sf/os/kernelhwsrv: comparison userlibandfileserver/fileserver/sfile/sf_cache

equal deleted inserted replaced

-:94f2adf59133
+:b2826f67641f
 #ifdef __RAMDOM_LOCK_FAILURES__
 #include <e32math.h>
 #endif
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "sf_cache_manTraces.h"
+#endif
 #define CACHE_NUM_TO_ADDR(n) (iBase + (n << iCacheLineSizeLog2))
 #define ADDR_TO_CACHELINE_ADDR(a) ((((a - iBase) >> iCacheLineSizeLog2) << iCacheLineSizeLog2) + iBase)
 #define ADDR_TO_INDEX(a) ((a - iBase) >> iCacheLineSizeLog2)
 #if defined(_DEBUG)
 	// calculate the low-memory threshold below which we fail any attempt to allocate memory
 	TMemoryInfoV1Buf meminfo;
 	TInt r = UserHal::MemoryInfo(meminfo);
 	__ASSERT_ALWAYS(r==KErrNone,Fault(EMemoryInfoFailed));
-	iLowMemoryThreshold = (meminfo().iTotalRamInBytes * TGlobalFileCacheSettings::LowMemoryThreshold()) / 100;
+	iLowMemoryThreshold = (meminfo().iTotalRamInBytes  / 100) * TGlobalFileCacheSettings::LowMemoryThreshold();
 	__CACHE_PRINT4(_L("CACHEMAN: totalRAM %d freeRAM %d KDefaultLowMemoryThresholdPercent %d iLowMemoryThreshold %d"),
 		meminfo().iTotalRamInBytes, meminfo().iFreeRamInBytes, KDefaultLowMemoryThreshold, iLowMemoryThreshold);
 	__CACHE_PRINT1(_L("CACHEMAN: iCacheSize %d"), iCacheSize);
 	TChunkCreateInfo createInfo;
 	createInfo.SetCache(iCacheSize);
 	createInfo.SetOwner(EOwnerProcess);
 	r = iChunk.Create(createInfo);
 	User::LeaveIfError(r);
+#ifdef	OST_TRACE_COMPILER_IN_USE
+	TName chunkName = iChunk.Name();
+	OstTraceData(TRACE_FILECACHE_MANAGER, FILECACHEMAN_CHUNK_NAME, "Chunk name %S", chunkName.Ptr(), chunkName.Length()<<1);
+	OstTraceExt5(TRACE_FILECACHE_MANAGER, FILECACHEMAN_CHUNK_PARM,
+		"totalRAM %d freeRAM %d KDefaultLowMemoryThresholdPercent %d iLowMemoryThreshold %d iCacheSize %d",
+		meminfo().iTotalRamInBytes, meminfo().iFreeRamInBytes, KDefaultLowMemoryThreshold, iLowMemoryThreshold, iCacheSize);
+#endif	// OST_TRACE_COMPILER_IN_USE
 	TInt mm = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0) & EMemModelTypeMask;
 	if (mm < EMemModelTypeFlexible)
 		{
 		// On memory models before flexible, File System has to register chunks that will be DMA-ed.
 TFileCacheStats& CCacheManager::Stats()
 	{
 	iStats.iFreeCount = iFreeQueue.Count();
 	iStats.iUsedCount = iUsedQueue.Count();
 	iStats.iLockedSegmentCount = iLockedSegmentCount;
+	iStats.iAllocatedSegmentCount = iAllocatedSegmentCount;
 	iStats.iFilesOnClosedQueue = TClosedFileUtils::Count();
 	__ASSERT_DEBUG(iStats.iFreeCount >= 0, Fault(EInvalidStats));
 	__ASSERT_DEBUG(iStats.iUsedCount >= 0, Fault(EInvalidStats));
 	__ASSERT_DEBUG(iStats.iLockedSegmentCount >= 0, Fault(EInvalidStats));
 	__ASSERT_DEBUG(iStats.iFilesOnClosedQueue >= 0, Fault(EInvalidStats));
 	TInt r = UserHal::MemoryInfo(meminfo);
 	__ASSERT_ALWAYS(r==KErrNone,Fault(EMemoryInfoFailed));
 	if (iMemoryLow || (meminfo().iFreeRamInBytes < iLowMemoryThreshold))
 		{
 		__CACHE_PRINT(_L("CACHEMAN: free RAM below threshold !!!"));
+		OstTrace0(TRACE_FILECACHE_MANAGER, FILECACHEMAN_LOW_MEM, "Free RAM below threshold");
 		return KErrNoMemory;
 		}
 	CacheLock();
 #ifdef  __SIMULATE_LOCK_FAILURES__
 	if (SimulatedFailure(iAllocFailureCount))
 		{
 		__CACHE_PRINT(_L("CACHEMAN: simulating allocation failure"));
+		OstTrace0(TRACE_FILECACHE_MANAGER, FILECACHEMAN_SIMULATING_ALLOC_FAILURE, "Simulating alloc failure");
 		CacheUnlock();
 		return KErrNoMemory;
 		}
 #endif
 	cacheLine->iClient = aClient;
 	cacheLine->iPos = aPos;
 	// Remove from free queue
 	iFreeQueue.Remove(0);
+	OstTraceExt2(TRACE_FILECACHE_MANAGER, FILECACHEMAN_ALLOC_CACHELINE, "cachelines: free %d used %d", iFreeQueue.Count(), iUsedQueue.Count());
 	// RChunk will lock segments initially unless explicitly unlocked
 	cacheLine->iLockCount++;
 //	TInt r = iFreeQueue.Append(&aCacheLine);
 	TInt r = iFreeQueue.InsertInAddressOrder(&aCacheLine);
 	__ASSERT_ALWAYS(r == KErrNone, Fault(EAppendToFreeQueueFailed));
 	__CACHE_PRINT2(_L("CACHEMAN: FreeCacheLine, iFreeQueue %d iUsedQueue %d"), iFreeQueue.Count(), iUsedQueue.Count());
+	OstTraceExt2(TRACE_FILECACHE_MANAGER, FILECACHEMAN_FREE_CACHELINE, "cachelines: free %d used %d", iFreeQueue.Count(), iUsedQueue.Count());
 	}
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 void CCacheManager::DumpCacheLine(TCacheLine& aCacheLine)
 #ifdef  __SIMULATE_LOCK_FAILURES__
 	if (SimulatedFailure(iLockFailureCount))
 		{
 		__CACHE_PRINT(_L("CACHEMAN: simulating lock failure"));
+		OstTrace0(TRACE_FILECACHE_MANAGER, FILECACHEMAN_SIMULATING_LOCK_FAILURE, "Simulating lock failure");
 		r = KErrNotFound;
 		}
 #endif
 	if (r == KErrNone)
 		{
 		iLockedSegmentCount+= aSegmentCount;
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_LOCK_SEGMENTS, "Locked segments %d", iLockedSegmentCount);
 		}
 	else
 		{
 		__CACHE_PRINT(_L("CACHEMAN: LOCK FAILED"));
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_LOCK_FAILURE, "Failure r %d", r);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		iStats.iLockFailureCount++;
 #endif
 		}
 	__CACHE_PRINT3(_L("CACHEMAN: UNLOCK %08X %d %d"), aAddr, aSegmentCount, r);
 	if (r == KErrNone)
 		{
 		iLockedSegmentCount-= aSegmentCount;
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_UNLOCK_SEGMENTS, "Locked segments %d", iLockedSegmentCount);
 		}
 	else
 		{
 		__CACHE_PRINT(_L("CACHEMAN: UNLOCK FAILED"));
 		}
 	{
 #ifdef  __SIMULATE_LOCK_FAILURES__
 	if (SimulatedFailure(iCommitFailureCount))
 		{
 		__CACHE_PRINT(_L("CACHEMAN: simulating commit failure "));
+		OstTrace0(TRACE_FILECACHE_MANAGER, FILECACHEMAN_SIMULATING_COMMIT_FAILURE, "Simulating commit failure");
 		return KErrNoMemory;
 		}
 #endif
 	TInt r = iChunk.Commit(aAddr-iBase, aSegmentCount << KSegmentSizeLog2);
 	__CACHE_PRINT3(_L("CACHEMAN: COMMIT: %08X %d %d, "), aAddr, aSegmentCount, r);
 	if (r == KErrNone)
 		{
 		iLockedSegmentCount+= aSegmentCount;
-#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
+		iAllocatedSegmentCount+= aSegmentCount;
-		iStats.iAllocatedSegmentCount+= aSegmentCount;
-#endif
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_COMMIT_SEGMENTS, "Allocated segments %d", iAllocatedSegmentCount);
 		}
 	else
 		{
 		__CACHE_PRINT(_L("CACHEMAN: COMMIT FAILED"));
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_COMMIT_FAILURE, "Failure r %d", r);
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 		iStats.iCommitFailureCount++;
 #endif
 		}
 //RDebug::Print(_L("RChunk::Decommit(%08X, %d), %d"), aAddr-iBase, aSegmentCount << KSegmentSizeLog2, r);
 	__CACHE_PRINT3(_L("CACHEMAN: DECOMMIT: %08X %d %d, "), aAddr, aSegmentCount, r);
 	if (r == KErrNone)
 		{
+		iAllocatedSegmentCount-= aSegmentCount;
+		OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_DECOMMIT_SEGMENTS, "Allocated segments %d", iAllocatedSegmentCount);
+		}
+	else
+		{
+		__CACHE_PRINT(_L("CACHEMAN: DECOMMIT FAILED"));
+		}
+	return r;
+	}
 #if defined(_DEBUG) || defined(_DEBUG_RELEASE)
-		iStats.iAllocatedSegmentCount-= aSegmentCount;
-#endif
-		}
-	else
-		{
-		__CACHE_PRINT(_L("CACHEMAN: DECOMMIT FAILED"));
-		}
-	return r;
-	}
-#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
 void CCacheManager::SimulateLockFailureMode(TBool aEnable)
 	{
 	iSimulateLockFailureMode = aEnable;
-__CACHE_PRINT1(_L("CACHEMAN: SimulateLockFailureMode: %d, "), iSimulateLockFailureMode);
+	__CACHE_PRINT1(_L("CACHEMAN: SimulateLockFailureMode: %d, "), iSimulateLockFailureMode);
+	OstTrace1(TRACE_FILECACHE_MANAGER, FILECACHEMAN_SIMULATE_LOCK_FAILURE_MODE, "aEnable %d", aEnable);
 	}
 void CCacheManager::AllocateMaxSegments(TBool aEnable)
 	{
 	iAllocateMaxSegments = aEnable;
-__CACHE_PRINT1(_L("CACHEMAN: iAllocateMaxSegments: %d, "), iAllocateMaxSegments);
+	__CACHE_PRINT1(_L("CACHEMAN: iAllocateMaxSegments: %d, "), iAllocateMaxSegments);
 	}
 TBool CCacheManager::AllocateMaxSegments()
 	{
 	return iAllocateMaxSegments;

changeset 297	b2826f67641f
parent 176	af6ec97d9189