MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/kernelhwsrv/kerneltest/e32test/mmu/paging_info.cpp
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\mmu\paging_info.cpp

    15 // 

    16 //

    17 

    18 #include <e32debug.h>

    19 #include <e32svr.h>

    20 #include <u32hal.h>

    21 #include <hal.h>

    22 #include "paging_info.h"

    23 

    24 

    25 const TUint8* BenchmarkNames[] =

    26 	{

    27 	(const TUint8*)"Read rom page",

    28 	(const TUint8*)"Read code page",

    29 	(const TUint8*)"Decompress",

    30 	(const TUint8*)"Set code page free",

    31 	(const TUint8*)"Set code page old",

    32 	(const TUint8*)"Read media",

    33 	(const TUint8*)"Fixup code page",

    34 	(const TUint8*)"Read data page",

    35 	(const TUint8*)"Write data page",

    36 	(const TUint8*)"Del notify data page",

    37 	(const TUint8*)"Read media data page",

    38 	(const TUint8*)"Write media data page",

    39 	};

    40 

    41 __ASSERT_COMPILE(sizeof(BenchmarkNames)/sizeof(TUint8*) == EMaxPagingBm);

    42 

    43 

    44 TInt PagingInfo::ResetConcurrency(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

    45 	{

    46 	TInt r = UserSvr::HalFunction(EHalGroupVM, EVMHalResetConcurrencyInfo, NULL, NULL);

    47 	if (r!=KErrNotSupported && r!=KErrNone)

    48 		return r;

    49 	if(aLocDrvNo>=0)

    50 		r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalResetConcurrencyInfo,(TAny*)aLocDrvNo,(TAny*)aMediaStats);

    51 	if(r==KErrNotSupported)

    52 		r = KErrNone;

    53 	return r;

    54 	}

    55 

    56 

    57 TInt PagingInfo::PrintConcurrency(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

    58 	{

    59 	SPagingConcurrencyInfo info;

    60 	TInt r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetConcurrencyInfo, &info, NULL);

    61 	if (r!=KErrNotSupported && r!=KErrNone)

    62 		return r;

    63 	if (r == KErrNone)

    64 		{

    65 		RDebug::Printf("Concurrency info:");

    66 		RDebug::Printf("  Max waiting threads == %d", info.iMaxWaitingCount);

    67 		RDebug::Printf("  Max paging threads == %d", info.iMaxPagingCount);

    68 		}

    69 	if(aLocDrvNo>=0)

    70 		{

    71 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsRom)

    72 			{

    73 			SMediaROMPagingConcurrencyInfo info;		

    74 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetROMConcurrencyInfo,(TAny*)aLocDrvNo,&info);

    75 			if (r!=KErrNotSupported && r!=KErrNone)

    76 				return r;

    77 			if(r==KErrNone)

    78 				{

    79 				RDebug::Printf("ROM paging media concurrency stats on drive %d:",aLocDrvNo);

    80 				RDebug::Printf("  Total page-in issued whilst processing other page-ins              : %d",info.iTotalConcurrentReqs);

    81 				RDebug::Printf("  Total page-in issued with at least one queue not empty             : %d",info.iTotalReqIssuedNonEmptyQ);

    82 				RDebug::Printf("  Max pending page-in in the main queue                              : %d",info.iMaxReqsInPending);

    83 				RDebug::Printf("  Max pending page-in in the deferred queue                          : %d",info.iMaxReqsInDeferred);

    84 				RDebug::Printf("  Total page-in first-time deferred during this session              : %d",info.iTotalFirstTimeDeferrals);

    85 				RDebug::Printf("  Total page-in re-deferred during this session                      : %d",info.iTotalReDeferrals);

    86 				RDebug::Printf("  Maximum deferrals of any single page-in                            : %d",info.iMaxDeferrals);

    87 				RDebug::Printf("  Total times the main queue was emptied during asynchronous request : %d",info.iTotalSynchEmptiedMainQ);

    88 				RDebug::Printf("  Total page-in serviced from main queue during asynchronous request : %d",info.iTotalSynchServicedFromMainQ);

    89 				RDebug::Printf("  Total page-in deferred from main queue during asynchronous request : %d",info.iTotalSynchDeferredFromMainQ);

    90 				RDebug::Printf("  Total page-in DFC run with an empty main queue                     : %d",info.iTotalRunDry);

    91 				RDebug::Printf("  Total dry runs of paging DFC avoided                               : %d",info.iTotalDryRunsAvoided);

    92 				}

    93 			}

    94 

    95 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsCode)

    96 			{

    97 			SMediaCodePagingConcurrencyInfo infoCode;

    98 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetCodeConcurrencyInfo,(TAny*)aLocDrvNo,&infoCode);

    99 			if(r==KErrNone)

   100 				{

   101 				RDebug::Printf("Media Code Paging concurrency stats on drive %d", aLocDrvNo);

   102 				RDebug::Printf("  Total page-in issued whilst processing other page in requests      : %d", infoCode.iTotalConcurrentReqs);

   103 				RDebug::Printf("  Total page-in issued with at least one queue not empty             : %d", infoCode.iTotalReqIssuedNonEmptyQ);

   104 				RDebug::Printf("  Max pending page-in in the main queue                              : %d", infoCode.iMaxReqsInPending);

   105 				RDebug::Printf("  Max pending page-in requests in the deferred queue                 : %d", infoCode.iMaxReqsInDeferred);

   106 				RDebug::Printf("  Total page-in first-time deferred                                  : %d", infoCode.iTotalFirstTimeDeferrals);

   107 				RDebug::Printf("  Total page-in re-deferred during this session (from deferred queue): %d", infoCode.iTotalReDeferrals);

   108 				RDebug::Printf("  Max number of deferrals of any single page in                      : %d", infoCode.iMaxDeferrals);

   109 				RDebug::Printf("  Total pagein serviced from main queue during asynchronous request  : %d", infoCode.iTotalSynchServicedFromMainQ);

   110 				RDebug::Printf("  Total pagein deferred from main queue during asynchronous request  : %d", infoCode.iTotalSynchDeferredFromMainQ);

   111 				}

   112 			}

   113 		}

   114 	if (r == KErrNotSupported)

   115 		r = KErrNone;

   116 	return r;

   117 	}

   118 

   119 

   120 TInt PagingInfo::ResetEvents()

   121 	{

   122 	return UserSvr::HalFunction(EHalGroupVM,EVMHalResetEventInfo,0,0);

   123 	}

   124 

   125 

   126 TInt PagingInfo::PrintEvents()

   127 	{

   128 	SVMEventInfo info;

   129 	TPckg<SVMEventInfo> infoBuf(info);

   130 	TInt r = UserSvr::HalFunction(EHalGroupVM,EVMHalGetEventInfo,&infoBuf,0);

   131 	if(r!=KErrNone)

   132 		return r;

   133 	RDebug::Printf("Event info:");

   134 	RDebug::Printf("  Page fault events: %Ld", info.iPageFaultCount);

   135 	RDebug::Printf("  Page in events: %Ld", info.iPageInReadCount);

   136 	return KErrNone;

   137 	}

   138 

   139 

   140 TInt PagingInfo::ResetBenchmarks(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

   141 	{

   142 	TInt r = KErrNone;

   143 	for (TInt i = 0 ; r == KErrNone && i < EMaxPagingBm ; ++i)

   144 		{

   145 		r = UserSvr::HalFunction(EHalGroupVM, EVMHalResetPagingBenchmark, (TAny*)i, NULL);

   146 		if (r!=KErrNotSupported && r!=KErrNone)

   147 			return r;

   148 		}

   149 	if(aLocDrvNo>=0)

   150 		r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalResetPagingBenchmark,(TAny*)aLocDrvNo,(TAny*)aMediaStats);

   151 	if(r==KErrNotSupported)

   152 		r = KErrNone;

   153 	return r;

   154 	}

   155 

   156 

   157 TInt PagingInfo::PrintBenchmarks(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

   158 	{

   159 	RDebug::Printf("Paging benchmarks:");

   160 	RDebug::Printf("  Name:                         Count:  Min (us):  Max(us):  Avg(us):");

   161 	

   162 	TInt freq = 0;

   163 	TReal min;

   164 	TReal max;

   165 	TReal avg;

   166 	TInt r = HAL::Get(HAL::EFastCounterFrequency, freq);

   167 	if (r != KErrNone)

   168 		return r;

   169 

   170 	TReal mult = 1000000.0 / freq;

   171 	

   172 	for (TInt i = 0 ; i < EMaxPagingBm ; ++i)

   173 		{

   174 		SPagingBenchmarkInfo info;

   175 		r = UserSvr::HalFunction(EHalGroupVM, EVMHalGetPagingBenchmark, (TAny*)i, &info);

   176 		if (r!=KErrNotSupported && r!=KErrNone)

   177 			return r;

   178 		if (r == KErrNone)

   179 			{

   180 			min = 0.0;

   181 			max = 0.0;

   182 			avg = 0.0;

   183 			if (info.iCount != 0)

   184 				{

   185 				min = info.iMinTime * mult;

   186 				max = info.iMaxTime * mult;

   187 				avg = (info.iTotalTime * mult) / info.iCount;

   188 				}

   189 			const TUint8* name = BenchmarkNames[i];

   190 			RDebug::Printf("  %-30s %6d %9.1f %9.1f %9.1f", name, info.iCount, min, max, avg);

   191 			}

   192 		}

   193 

   194 	if(aLocDrvNo>=0)

   195 		{

   196 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsRom)

   197 			{

   198 			SPagingBenchmarkInfo info;

   199 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetROMPagingBenchmark,(TAny*)aLocDrvNo,&info);

   200 			if (r!=KErrNotSupported && r!=KErrNone)

   201 				return r;

   202 			if(r==KErrNone)

   203 				{

   204 				if (info.iCount != 0)

   205 					{

   206 					min = info.iMinTime * mult;

   207 					max = info.iMaxTime * mult;

   208 					avg = (info.iTotalTime * mult) / info.iCount;

   209 					RDebug::Printf("ROM paging media benchmarks on drive %d:",aLocDrvNo);

   210 					RDebug::Printf("  %-30s %6d %9.1f %9.1f %9.1f", "Page-in latency", info.iCount, min, max, avg);

   211 					}

   212 				}

   213 			}

   214 

   215 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsCode)

   216 			{

   217 			SPagingBenchmarkInfo info;

   218 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetCodePagingBenchmark,(TAny*)aLocDrvNo,&info);

   219 			if (r!=KErrNotSupported && r!=KErrNone)

   220 				return r;

   221 			if(r==KErrNone)

   222 				{

   223 				if (info.iCount != 0)

   224 					{

   225 					min = info.iMinTime * mult;

   226 					max = info.iMaxTime * mult;

   227 					avg = (info.iTotalTime * mult) / info.iCount;

   228 					RDebug::Printf("Code paging media benchmarks on drive %d:",aLocDrvNo);

   229 					RDebug::Printf("  %-30s %6d %9.1f %9.1f %9.1f", "Page-in latency", info.iCount, min, max, avg);

   230 					}

   231 				}

   232 			}

   233 

   234 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsDataIn)

   235 			{

   236 			SPagingBenchmarkInfo info;

   237 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetDataInPagingBenchmark,(TAny*)aLocDrvNo,&info);

   238 			if (r!=KErrNotSupported && r!=KErrNone)

   239 				return r;

   240 			if(r==KErrNone)

   241 				{

   242 				if (info.iCount != 0)

   243 					{

   244 					min = info.iMinTime * mult;

   245 					max = info.iMaxTime * mult;

   246 					avg = (info.iTotalTime * mult) / info.iCount;

   247 					RDebug::Printf("Data page-in media benchmarks on drive %d:",aLocDrvNo);

   248 					RDebug::Printf("  %-30s %6d %9.1f %9.1f %9.1f", "Page-in latency", info.iCount, min, max, avg);

   249 					}

   250 				}

   251 			}

   252 

   253 		if(aMediaStats==EMediaPagingStatsAll || aMediaStats==EMediaPagingStatsDataOut)

   254 			{

   255 			SPagingBenchmarkInfo info;

   256 			r=UserSvr::HalFunction(EHalGroupMedia,EMediaHalGetDataOutPagingBenchmark,(TAny*)aLocDrvNo,&info);

   257 			if (r!=KErrNotSupported && r!=KErrNone)

   258 				return r;

   259 			if(r==KErrNone)

   260 				{

   261 				if (info.iCount != 0)

   262 					{

   263 					min = info.iMinTime * mult;

   264 					max = info.iMaxTime * mult;

   265 					avg = (info.iTotalTime * mult) / info.iCount;

   266 					RDebug::Printf("Data page-out media benchmarks on drive %d:",aLocDrvNo);

   267 					RDebug::Printf("  %-30s %6d %9.1f %9.1f %9.1f", "Page-in latency", info.iCount, min, max, avg);

   268 					}

   269 				}

   270 			}

   271 

   272 		}

   273 

   274 	return KErrNone;

   275 	}

   276 

   277 

   278 TInt PagingInfo::ResetAll(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

   279 	{

   280 	TInt r = ResetEvents();

   281 	if (r == KErrNone || r == KErrNotSupported)

   282 		r = ResetConcurrency(aLocDrvNo,aMediaStats);

   283 	if (r == KErrNone || r == KErrNotSupported)

   284 		r = ResetBenchmarks(aLocDrvNo,aMediaStats);

   285 	if (r == KErrNotSupported)

   286 		r = KErrNone;

   287 	return r;

   288 	}

   289 

   290 

   291 TInt PagingInfo::PrintAll(TInt aLocDrvNo, TMediaPagingStats aMediaStats)

   292 	{

   293 	TInt r = PrintEvents();

   294 	if (r == KErrNone || r == KErrNotSupported)

   295 		r = PrintConcurrency(aLocDrvNo,aMediaStats);

   296 	if (r == KErrNone || r == KErrNotSupported)

   297 		r = PrintBenchmarks(aLocDrvNo,aMediaStats);

   298 	if (r == KErrNotSupported)

   299 		r = KErrNone;

   300 	return r;

   301 	}

   302 

   303
Symaptic