Mercurial Mercurial > oss > FCL > sf > os > kernelhwsrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
kerneltest/e32test/stack/t_stacksize.cpp
changeset 15 4122176ea935
parent 0 a41df078684a
equal deleted inserted replaced
0:a41df078684a 15:4122176ea935 
    61 #include <e32svr.h>
 
    61 #include <e32svr.h>
 
    62 
    62 
    63 LOCAL_D RTest test(_L("T_STACKSIZE"));
 
    63 LOCAL_D RTest test(_L("T_STACKSIZE"));
 
    64 LOCAL_D RTest test2(_L("*** T_STACKSIZE SLAVE ***"));
 
    64 LOCAL_D RTest test2(_L("*** T_STACKSIZE SLAVE ***"));
 
    65 
    65 
    66 const TInt KNumberOfFitIteration = KDefaultStackSize / 2048 - 1;
 
    66 // We are here making the assumption that one quarter of the stack should be sufficient
 
    67 const TInt KNumberOfUnfitIteration = (KDefaultStackSize + 2047) / 2048;
 
    67 // to accommodate for the overhead generated by the recursive calls as well as
 
       
    68 // unpredictable compiler optimisations.
 
       
    69 const TInt KStackGobbleSize = KDefaultStackSize / 4 - 8;
 
       
    70 const TInt KNumberOfFitIteration = 3;
 
       
    71 const TInt KNumberOfUnfitIteration = 4;
 
       
    72 
       
    73 const TInt KImageStackSize = 0x2000; // Test app image stack size (epocstacksize in MMP file)
 
    68 
    74 
    69 enum TTestProcessFunctions
 
    75 enum TTestProcessFunctions
 
    70 	{
 
    76 	{
 
    71 	ETestProcess1,
 
    77 	ETestProcess1,
 
    72 	ETestProcess2,
 
    78 	ETestProcess2,
 
    84 	};
 
    90 	};
 
    85 
    91 
    86 TInt RTestProcess::Create(TTestProcessFunctions aFunction, TInt aStackSize, TInt aArg1,TInt aArg2)
 
    92 TInt RTestProcess::Create(TTestProcessFunctions aFunction, TInt aStackSize, TInt aArg1,TInt aArg2)
 
    87 	{
 
    93 	{
 
    88 	
    94 	
    89 	test.Printf(_L("RTestProcess::Create started with stack size:%d bytes\n") 
    95 	test.Printf(_L("RTestProcess::Create started with stack size:%d bytes\n"), aStackSize);
 
    90 								, (0 == aStackSize ? KDefaultStackSize : aStackSize )
 
       
    91 								);
 
       
    92 	if(aArg1==-1)
 
    96 	if(aArg1==-1)
 
    93 		aArg1 = RProcess().Id();
 
    97 		aArg1 = RProcess().Id();
 
    94 	TBuf<512> commandLine;
 
    98 	TBuf<512> commandLine;
 
    95 	commandLine.Num((TInt)aFunction);
 
    99 	commandLine.Num((TInt)aFunction);
 
    96 	commandLine.Append(_L(" "));
 
   100 	commandLine.Append(_L(" "));
 
   151 	}
 
   155 	}
 
   152 
   156 
   153 
   157 
   154 TInt DummyRecursion(TInt aA)
 
   158 TInt DummyRecursion(TInt aA)
 
   155 	{
 
   159 	{
 
   156 	TBuf8<2040> gobble;	// gobble 2K of stack
 
   160 	TBuf8<KStackGobbleSize> gobble;	// gobble 1/4 of the stack
 
   157 	gobble.Append(TChar(aA));	// stop compiler optimising out gobble buffer
 
   161 	gobble.Append(TChar(aA));	// stop compiler optimising out gobble buffer
 
   158 	if (aA <= 1)
 
   162 	if (aA <= 1)
 
   159 		return aA;
 
   163 		return aA;
 
   160 	return 1 + DummyRecursion(aA-1);
 
   164 	return 1 + DummyRecursion(aA-1);
 
   161 	}
 
   165 	}
 
   162 
   166 
       
   167 // Make these global so we don't push too much stuff on the stack
 
       
   168 TThreadStackInfo ThreadStackInfo;
 
       
   169 _LIT(KStackSizeText, "Stack size is %d bytes\n");
 
       
   170 
   163 TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)
 
   171 TInt DoTestProcess(TInt aTestNum,TInt aArg1,TInt aArg2)
 
   164 	{
 
   172 	{
 
   165 	(void)aArg1;
 
   173 	(void)aArg1;
 
   166 	(void)aArg2;
 
   174 	(void)aArg2;
 
   167 
   175 	RThread().StackInfo(ThreadStackInfo);
 
   168 
   176 
   169 	switch(aTestNum)
 
   177 	switch(aTestNum)
 
   170 		{
 
   178 		{
 
   171 	case ETestProcess1:
 
   179 	case ETestProcess1:
 
   172 		{
 
   180 		{
 
   173 		test2.Printf(_L("ETestProcess1 started with %d recursion...\n"), KNumberOfFitIteration);
 
   181 		test2.Printf(_L("ETestProcess1 started with %d recursion...\n"), KNumberOfFitIteration);
 
       
   182 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
       
   183 #ifndef __WINS__
 
       
   184 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KDefaultStackSize);
 
       
   185 #endif
 
   174 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
   186 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
   175 		break;
 
   187 		break;
 
   176 		}
 
   188 		}
 
   177 		
   189 		
   178 	case ETestProcess2:
 
   190 	case ETestProcess2:
 
   179 		{
 
   191 		{
 
   180 		test2.Printf(_L("ETestProcess2 started with %d recursion...\n"), KNumberOfFitIteration);
 
   192 		test2.Printf(_L("ETestProcess2 started with %d recursion...\n"), KNumberOfFitIteration);
 
       
   193 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
       
   194 #ifndef __WINS__
 
       
   195 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KDefaultStackSize);
 
       
   196 #endif
 
   181 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
   197 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
   182 		break;
 
   198 		break;
 
   183 		}
 
   199 		}
 
   184 		
   200 		
   185 	case ETestProcess3:
 
   201 	case ETestProcess3:
 
   186 		{
 
   202 		{
 
   187 		test2.Printf(_L("ETestProcess3 started with %d recusion...\n"), KNumberOfUnfitIteration);
 
   203 		test2.Printf(_L("ETestProcess3 started with %d recusion...\n"), KNumberOfUnfitIteration);
 
       
   204 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
       
   205 #ifndef __WINS__
 
       
   206 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KDefaultStackSize);
 
       
   207 #endif
 
   188 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   208 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   189 		break;
 
   209 		break;
 
   190 		}
 
   210 		}
 
   191 		
   211 		
   192 	case ETestProcess4:
 
   212 	case ETestProcess4:
 
   193 		{
 
   213 		{
 
   194 		test2.Printf(_L("ETestProcess4 started with %d recursion...\n"), KNumberOfUnfitIteration);
 
   214 		test2.Printf(_L("ETestProcess4 started with %d recursion...\n"), KNumberOfUnfitIteration);
 
       
   215 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
       
   216 #ifndef __WINS__
 
       
   217 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KDefaultStackSize);
 
       
   218 #endif
 
   195 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   219 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   196 		break;
 
   220 		break;
 
   197 		}
 
   221 		}
 
   198 		
   222 		
   199 	case ETestProcess5:
 
   223 	case ETestProcess5:
 
   200 		{
 
   224 		{
 
   201 		test2.Printf(_L("ETestProcess5 started with %d recursion...\n"), KNumberOfUnfitIteration);
 
   225 		test2.Printf(_L("ETestProcess5 started with %d recursion...\n"), KNumberOfUnfitIteration);
 
       
   226 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
       
   227 #ifndef __WINS__
 
       
   228 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KDefaultStackSize * 2);
 
       
   229 #endif
 
   202 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   230 		test2(DummyRecursion(KNumberOfUnfitIteration)==KNumberOfUnfitIteration);
 
   203 		break;
 
   231 		break;
 
   204 		}
 
   232 		}
 
   205 		
   233 		
   206 	case ETestProcess6:
 
   234 	case ETestProcess6:
 
   207 		{
 
   235 		{
 
   208 		test2.Printf(_L("ETestProcess6 started with %d recursion...\n"), KNumberOfFitIteration);
 
   236 		test2(EFalse); // Process creation should have failed
 
   209 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
       
   210 		break;
 
       
   211 		}
 
   237 		}
 
   212 
   238 
   213 	case ETestProcess7:
 
   239 	case ETestProcess7:
 
   214 		{
 
   240 		{
 
   215 	
       
   216 		test2.Printf(_L("ETestProcess7 started with %d recursion\n"), KNumberOfFitIteration);
 
   241 		test2.Printf(_L("ETestProcess7 started with %d recursion\n"), KNumberOfFitIteration);
 
   217 		test2.Printf(_L("(it is raised a Panic with %d bytes stack)...\n"), KDefaultStackSize/2);
 
   242 		test2.Printf(KStackSizeText, ThreadStackInfo.iBase - ThreadStackInfo.iLimit);
 
   218 		test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
   243 #ifndef __WINS__
 
       
   244 		test2((TInt) (ThreadStackInfo.iBase - ThreadStackInfo.iLimit) == KImageStackSize); // Should default to stack size set in image header
 
       
   245 		if (KImageStackSize == KDefaultStackSize) // If this is not the case, results can be a bit unpredictable
 
       
   246 			{
 
       
   247 			test2(DummyRecursion(KNumberOfFitIteration)==KNumberOfFitIteration);
 
       
   248 			}
 
       
   249 #endif
 
   219 		break;
 
   250 		break;
 
   220 		}
 
   251 		}
 
   221 		
   252 		
   222 	default:
 
   253 	default:
 
   223 		User::Panic(_L("T_STACKSIZE"),1);
 
   254 		User::Panic(_L("T_STACKSIZE"),1);
 
   256 
   287 
   257 	RTestProcess rogueP;
 
   288 	RTestProcess rogueP;
 
   258 	TRequestStatus rendezvous;
 
   289 	TRequestStatus rendezvous;
 
   259 
   290 
   260 	test.Start(_L("Create process with original Create and default stack size"));
 
   291 	test.Start(_L("Create process with original Create and default stack size"));
 
   261 	TInt r = rogueP.Create(ETestProcess1, 0 );
 
   292 	TInt r = rogueP.Create(ETestProcess1, KDefaultStackSize);
 
   262 	test(r==KErrNone);
 
   293 	test(r==KErrNone);
 
   263 	rogueP.Rendezvous(rendezvous);
 
   294 	rogueP.Rendezvous(rendezvous);
 
   264 	rogueP.Resume();
 
   295 	rogueP.Resume();
 
   265 	User::WaitForRequest(rendezvous);
 
   296 	User::WaitForRequest(rendezvous);
 
   266 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   297 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   267 	test(rogueP.ExitType()==EExitKill);
 
   298 	test(rogueP.ExitType()==EExitKill);
 
       
   299 	CLOSE_AND_WAIT(rogueP);
 
   268 	
   300 	
   269 	test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
 
   301 	test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
 
   270 	r = rogueP.Create(ETestProcess2, 0 );
 
   302 	r = rogueP.Create(ETestProcess2, KDefaultStackSize);
 
   271 	test(r==KErrNone);
 
   303 	test(r==KErrNone);
 
   272 	rogueP.Rendezvous(rendezvous);
 
   304 	rogueP.Rendezvous(rendezvous);
 
   273 	rogueP.Resume();
 
   305 	rogueP.Resume();
 
   274 	User::WaitForRequest(rendezvous);
 
   306 	User::WaitForRequest(rendezvous);
 
   275 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   307 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   276 	test(rogueP.ExitType()==EExitKill);
 
   308 	test(rogueP.ExitType()==EExitKill);
 
       
   309 	CLOSE_AND_WAIT(rogueP);
 
   277 	
   310 	
   278 	test.Next(_L("Create process with original Create and default stack size"));
 
   311 	test.Next(_L("Create process with original Create and default stack size"));
 
   279 	r = rogueP.Create(ETestProcess3, 0 );
 
   312 	r = rogueP.Create(ETestProcess3, KDefaultStackSize);
 
   280 	test(r==KErrNone);
 
   313 	test(r==KErrNone);
 
   281 	rogueP.Rendezvous(rendezvous);
 
   314 	rogueP.Rendezvous(rendezvous);
 
   282 	rogueP.Resume();
 
   315 	rogueP.Resume();
 
   283 	User::WaitForRequest(rendezvous);
 
   316 	User::WaitForRequest(rendezvous);
 
   284 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   317 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   285 #if !defined(__WINS__)
 
   318 #if !defined(__WINS__)
 
   286 	test(rogueP.ExitType()==EExitPanic);
 
   319 	test(rogueP.ExitType()==EExitPanic);
 
   287 #else
 
   320 #else
 
   288 	test(rogueP.ExitType()==EExitKill);
 
   321 	test(rogueP.ExitType()==EExitKill);
 
   289 #endif
 
   322 #endif
 
       
   323 	CLOSE_AND_WAIT(rogueP);
 
   290 	
   324 	
   291 	test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
 
   325 	test.Next(_L("Create process with CreateWithStackOverride and default stack size"));
 
   292 	r = rogueP.Create(ETestProcess4, 0 );
 
   326 	r = rogueP.Create(ETestProcess4, KDefaultStackSize);
 
   293 	test(r==KErrNone);
 
   327 	test(r==KErrNone);
 
   294 	rogueP.Rendezvous(rendezvous);
 
   328 	rogueP.Rendezvous(rendezvous);
 
   295 	rogueP.Resume();
 
   329 	rogueP.Resume();
 
   296 	User::WaitForRequest(rendezvous);
 
   330 	User::WaitForRequest(rendezvous);
 
   297 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   331 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType());
 
   298 	
       
   299 #if !defined(__WINS__)
 
   332 #if !defined(__WINS__)
 
   300 	test(rogueP.ExitType()==EExitPanic);
 
   333 	test(rogueP.ExitType()==EExitPanic);
 
   301 #else
 
   334 #else
 
   302 	test(rogueP.ExitType()==EExitKill);
 
   335 	test(rogueP.ExitType()==EExitKill);
 
   303 #endif
 
   336 #endif
 
   304 	
   337 	CLOSE_AND_WAIT(rogueP);
 
   305 	
   338 
   306 	test.Next(_L("Create process with CreateWithStackOverride and 2 * KDefaultStackSize stack size"));
 
   339 	test.Next(_L("Create process with CreateWithStackOverride and 2 * KDefaultStackSize stack size"));
 
   307 	r = rogueP.Create(ETestProcess5, 2 * KDefaultStackSize );
 
   340 	r = rogueP.Create(ETestProcess5, 2 * KDefaultStackSize );
 
   308 	test(r==KErrNone);
 
   341 	test(r==KErrNone);
 
   309 	rogueP.Rendezvous(rendezvous);
 
   342 	rogueP.Rendezvous(rendezvous);
 
   310 	rogueP.Resume();
 
   343 	rogueP.Resume();
 
   311 	User::WaitForRequest(rendezvous);
 
   344 	User::WaitForRequest(rendezvous);
 
   312 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   345 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   313 	test(rogueP.ExitType()==EExitKill);
 
   346 	test(rogueP.ExitType()==EExitKill);
 
       
   347 	CLOSE_AND_WAIT(rogueP);
 
   314 
   348 
   315 #if !defined(__WINS__)
 
   349 #if !defined(__WINS__)
 
   316 	test.Next(_L("Create process with CreateWithStackOverride and negative stack size"));
 
   350 	test.Next(_L("Create process with CreateWithStackOverride and negative stack size"));
 
   317 	r = rogueP.Create(ETestProcess6, - 2 * KDefaultStackSize );
 
   351 	r = rogueP.Create(ETestProcess6, - 2 * KDefaultStackSize );
 
   318 	test(r==KErrArgument);
 
   352 	test(r==KErrArgument);
 
   319 #endif
 
   353 #endif
 
   320 
   354 
   321 	test.Next(_L("Create process with CreateWithStackOverride and KDefaultStackSize/2 stack size"));
 
   355 	test.Next(_L("Create process with CreateWithStackOverride and KImageStackSize/2 stack size"));
 
   322 	r = rogueP.Create(ETestProcess7, KDefaultStackSize / 2 );
 
   356 	r = rogueP.Create(ETestProcess7, KImageStackSize / 2 );
 
   323 	test(r==KErrNone);
 
   357 	test(r==KErrNone);
 
   324 	rogueP.Rendezvous(rendezvous);
 
   358 	rogueP.Rendezvous(rendezvous);
 
   325 	rogueP.Resume();
 
   359 	rogueP.Resume();
 
   326 	User::WaitForRequest(rendezvous);
 
   360 	User::WaitForRequest(rendezvous);
 
   327 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   361 	test.Printf(_L("ExitType:%d\n"),rogueP.ExitType() );
 
   328 	test(rogueP.ExitType()==EExitKill);
 
   362 	test(rogueP.ExitType()==EExitKill);
 
       
   363 	CLOSE_AND_WAIT(rogueP);
 
   329 	
   364 	
   330 	test.Printf(_L("Test finished.\n"));
 
   365 	test.Printf(_L("Test finished.\n"));
 
   331 	test.End();
 
   366 	test.End();
 
   332 
   367 
   333 	return(0);
 
   368 	return(0);
FCL/sf/os/kernelhwsrv