kerneltest/e32test/dll/t_tls.cpp
changeset 0 a41df078684a
equal deleted inserted replaced
-1:000000000000 0:a41df078684a
       
     1 // Copyright (c) 1996-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\dll\t_tls.cpp
       
    15 // Overview:
       
    16 // Test and benchmark TLS (Thread Local Storage) functions
       
    17 // API Information:
       
    18 // UserSvr
       
    19 // Details:
       
    20 // - Use the UserSvr methods: DllTls, DllSetTls and DllFreeTls to test 
       
    21 // the thread local storage. Verify the expected results. Verify that 
       
    22 // the heap was not corrupted by any of the tests.
       
    23 // - In a separate thread, use the UserSvr methods: DllTls, DllSetTls and 
       
    24 // DllFreeTls to test the thread local storage. Verify the expected results.
       
    25 // - Test the TLS cleanup handlers and verify results are as expected. Verify 
       
    26 // that the heap was not corrupted by any of the tests.
       
    27 // - Benchmark how many DllSetTls, DllTls and DllFreeTls operations can be
       
    28 // performed in 1/2 second.
       
    29 // Platforms/Drives/Compatibility:
       
    30 // All.
       
    31 // Assumptions/Requirement/Pre-requisites:
       
    32 // Failures and causes:
       
    33 // Base Port information:
       
    34 // Tests and benchmarks Tls functions
       
    35 // 14/10/96 Modified scheme on Arm release
       
    36 // SetTls - 352	~1300
       
    37 // Tls - 3510 ~1600
       
    38 // 15/10/96 Array scheme on Arm release
       
    39 // Set Tls - ~1900
       
    40 // Tls - ~2550
       
    41 // 
       
    42 //
       
    43 
       
    44 #define __E32TEST_EXTENSION__
       
    45 
       
    46 #include <e32test.h>
       
    47 #include <e32svr.h>
       
    48 #include <f32dbg.h>
       
    49 #include <e32def.h>
       
    50 #include <e32def_private.h>
       
    51 #include "u32std.h"
       
    52 
       
    53 // Can't tell whether allocations will be on the kernel or user heap, so perform all heap check
       
    54 // operations on both
       
    55 #define HEAP_MARK			__UHEAP_MARK; __KHEAP_MARK
       
    56 #define HEAP_MARKEND		__UHEAP_MARKEND; __KHEAP_MARKEND
       
    57 #define HEAP_RESET			__UHEAP_RESET; __KHEAP_RESET
       
    58 #define HEAP_CHECK(x)		__UHEAP_CHECK(x); __KHEAP_CHECK(x)
       
    59 #define HEAP_FAILNEXT(x)	__UHEAP_FAILNEXT(x); __KHEAP_FAILNEXT(x)
       
    60 
       
    61 TInt const KCheckHandle=67338721;
       
    62 TUint8* const KCheckValue=(TUint8*)8525124;
       
    63 
       
    64 LOCAL_D RTest test(_L("T_TLS"));
       
    65 
       
    66 _LIT(KTestDllName, "t_tlsdll");
       
    67 const TInt KTestDllOrdSet	= 1;
       
    68 const TInt KTestDllOrdGet	= 2;
       
    69 const TInt KTestDllOrdFree	= 3;
       
    70 
       
    71 typedef TInt (*TTestDllSetFn)(TAny*);
       
    72 typedef TAny* (*TTestDllGetFn)();
       
    73 typedef void (*TTestDllFreeFn)();
       
    74 
       
    75 TInt TestDllSetTls(RLibrary aLib, TAny* aValue)
       
    76 	{
       
    77 	TTestDllSetFn f = (TTestDllSetFn)aLib.Lookup(KTestDllOrdSet);
       
    78 	return (*f)(aValue);
       
    79 	}
       
    80 
       
    81 TAny* TestDllGetTls(RLibrary aLib)
       
    82 	{
       
    83 	TTestDllGetFn f = (TTestDllGetFn)aLib.Lookup(KTestDllOrdGet);
       
    84 	return (*f)();
       
    85 	}
       
    86 
       
    87 void TestDllFreeTls(RLibrary aLib)
       
    88 	{
       
    89 	TTestDllFreeFn f = (TTestDllFreeFn)aLib.Lookup(KTestDllOrdFree);
       
    90 	(*f)();
       
    91 	}
       
    92 
       
    93 #define DISPLAY_PROGRESS	test.Printf(_L("Line %d\n"), __LINE__)
       
    94 
       
    95 void Test()
       
    96 	{
       
    97 	test.Start(_L("Stuff without Setting"));
       
    98 
       
    99 	HEAP_MARK;
       
   100 
       
   101 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   102 	UserSvr::DllFreeTls(KCheckHandle);
       
   103 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   104 	test(UserSvr::DllTls(0)==NULL);
       
   105 	UserSvr::DllFreeTls(0);
       
   106 	test(UserSvr::DllTls(0)==NULL);
       
   107 
       
   108 	HEAP_CHECK(0);
       
   109 
       
   110 	test.Next(_L("Set"));
       
   111 	test(UserSvr::DllSetTls(KCheckHandle,KCheckValue)==KErrNone);
       
   112 	test.Next(_L("Get"));
       
   113 	test(UserSvr::DllTls(KCheckHandle)==KCheckValue);
       
   114 	test.Next(_L("Free"));
       
   115 	UserSvr::DllFreeTls(KCheckHandle);
       
   116 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   117 
       
   118 	HEAP_CHECK(0);
       
   119 
       
   120 	test.Next(_L("Set lots"));
       
   121 	TInt i=0;
       
   122 	for(;i<1000;i+=3)
       
   123 		{
       
   124 		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i)==KErrNone);
       
   125 		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);
       
   126 		}
       
   127 	for(i=999;i>0;i-=3)
       
   128 		{
       
   129 		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);
       
   130 		UserSvr::DllFreeTls(KCheckHandle+i);
       
   131 		test(UserSvr::DllTls(KCheckHandle+i)==NULL);
       
   132 		}
       
   133 	test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);
       
   134 	UserSvr::DllFreeTls(KCheckHandle+i);
       
   135 	test(UserSvr::DllTls(KCheckHandle+i)==NULL);
       
   136 
       
   137 	HEAP_MARKEND;
       
   138 
       
   139 
       
   140 	test.Next(_L("Test with DLL ID"));
       
   141 
       
   142 	HEAP_MARK;
       
   143 
       
   144 	test(UserSvr::DllTls(KCheckHandle, 1)==0);
       
   145 	test(UserSvr::DllTls(KCheckHandle, 2)==0);
       
   146 	DISPLAY_PROGRESS;
       
   147 #ifdef _DEBUG
       
   148 	HEAP_FAILNEXT(1);
       
   149 	DISPLAY_PROGRESS;
       
   150 	test(UserSvr::DllSetTls(KCheckHandle, 1, KCheckValue)==KErrNoMemory);
       
   151 #endif
       
   152 	test(UserSvr::DllSetTls(KCheckHandle, 1, KCheckValue)==KErrNone);
       
   153 	test(UserSvr::DllTls(KCheckHandle, 1)==KCheckValue);
       
   154 	test(UserSvr::DllTls(KCheckHandle, 2)==0);
       
   155 	DISPLAY_PROGRESS;
       
   156 	HEAP_FAILNEXT(1);
       
   157 	DISPLAY_PROGRESS;
       
   158 	test(UserSvr::DllSetTls(KCheckHandle, 3, KCheckValue)==KErrNone);
       
   159 
       
   160 #ifdef _DEBUG
       
   161 	RSemaphore s;
       
   162 	test(s.CreateLocal(0)==KErrNoMemory);
       
   163 #endif
       
   164 
       
   165 	HEAP_RESET;
       
   166 
       
   167 	test(UserSvr::DllTls(KCheckHandle, 1)==0);
       
   168 	test(UserSvr::DllTls(KCheckHandle, 2)==0);
       
   169 	test(UserSvr::DllTls(KCheckHandle, 3)==KCheckValue);
       
   170 	UserSvr::DllFreeTls(KCheckHandle);
       
   171 
       
   172 	DISPLAY_PROGRESS;
       
   173 	HEAP_MARKEND;
       
   174 	DISPLAY_PROGRESS;
       
   175 
       
   176 	test.Next(_L("Test reloading DLL"));
       
   177 
       
   178 	RLibrary l;
       
   179 	TInt r = l.Load(KTestDllName);
       
   180 	test(r==KErrNone);
       
   181 	for (i=0; i<2; ++i)
       
   182 		{
       
   183 		test.Printf(_L("i=%d\n"),i);
       
   184 		test(TestDllGetTls(l)==0);
       
   185 		test(TestDllSetTls(l, KCheckValue)==KErrNone);
       
   186 		test(TestDllGetTls(l)==KCheckValue);
       
   187 		if (i==0)
       
   188 			{
       
   189 			TestDllFreeTls(l);
       
   190 			test(TestDllGetTls(l)==0);
       
   191 			}
       
   192 		l.Close();
       
   193 		r = l.Load(KTestDllName);
       
   194 		test(r==KErrNone);
       
   195 		test(TestDllGetTls(l)==0);
       
   196 		TestDllFreeTls(l);
       
   197 		}
       
   198 	l.Close();
       
   199 
       
   200 	test.End();
       
   201 	}
       
   202 
       
   203 TInt TestThread(TAny*)
       
   204 	{
       
   205 	RTest test(_L("T_TLS Thread"));
       
   206 	test.Start(_L("Stuff without Setting"));
       
   207 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   208 	UserSvr::DllFreeTls(KCheckHandle);
       
   209 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   210 	test(UserSvr::DllTls(0)==NULL);
       
   211 	UserSvr::DllFreeTls(0);
       
   212 	test(UserSvr::DllTls(0)==NULL);
       
   213 	test.Next(_L("Set"));
       
   214 	test(UserSvr::DllSetTls(KCheckHandle,KCheckValue)==KErrNone);
       
   215 	test.Next(_L("Get"));
       
   216 	test(UserSvr::DllTls(KCheckHandle)==KCheckValue);
       
   217 	test.Next(_L("Free"));
       
   218 	UserSvr::DllFreeTls(KCheckHandle);
       
   219 	test(UserSvr::DllTls(KCheckHandle)==NULL);
       
   220 	test.Next(_L("Set lots"));
       
   221 	TInt i=0;
       
   222 	for(;i<1000;i+=3)
       
   223 		{
       
   224 		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i)==KErrNone);
       
   225 		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);
       
   226 		}
       
   227 	for(i=999;i>=0;i-=3)
       
   228 		{
       
   229 		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);
       
   230 		UserSvr::DllFreeTls(KCheckHandle+i);
       
   231 		test(UserSvr::DllTls(KCheckHandle+i)==NULL);
       
   232 		}
       
   233 
       
   234 	test.Close();
       
   235 	return KErrNone;
       
   236 	}
       
   237 
       
   238 TInt HeapSize(RHeap* aHeap = NULL)
       
   239 	{
       
   240 	if (!aHeap)
       
   241 		aHeap = &User::Heap();
       
   242 	TInt size;
       
   243 	aHeap->AllocSize(size);
       
   244 	return size;
       
   245 	}
       
   246 
       
   247 TBool TLSStoredOnUserHeap()
       
   248 	{
       
   249 	TInt initCount = HeapSize();
       
   250 	TInt i;
       
   251 	const TInt KMax = 2;
       
   252 	for(i = 0 ; i < KMax ; ++i)
       
   253 		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) == KErrNone);
       
   254 	TInt finalCount = HeapSize();
       
   255 	for(i = 0 ; i < KMax ; ++i)
       
   256 		UserSvr::DllFreeTls(KCheckHandle+i);
       
   257 	return initCount != finalCount;
       
   258 	}
       
   259 
       
   260 class RDummyAllocator : public RAllocator
       
   261 	{
       
   262 public:
       
   263 	TInt AccessCount() { return iAccessCount; }
       
   264 	};
       
   265 
       
   266 RHeap* MainHeap = NULL;
       
   267 
       
   268 TInt HeapAccessCount(TAny* aHeap)
       
   269 	{
       
   270 	RDummyAllocator* heap = (RDummyAllocator*)aHeap;
       
   271 	return heap->AccessCount();
       
   272 	}
       
   273 
       
   274 TBool HeapExists(RHeap* aHeap)
       
   275 	{
       
   276 	RThread thread;
       
   277 	test_KErrNone(thread.Create(_L("HeapExistsThread"), HeapAccessCount, 0x1000, MainHeap, (TAny*)aHeap));
       
   278 	TRequestStatus status;
       
   279 	thread.Logon(status);
       
   280 	thread.Resume();
       
   281 	User::WaitForRequest(status);
       
   282 
       
   283 	TInt r;
       
   284 	if (thread.ExitType() == EExitKill)
       
   285 		{
       
   286 		r = thread.ExitReason();
       
   287 		test_NotNegative(r);
       
   288 		}
       
   289 	else
       
   290 		{
       
   291 		test_Equal(EExitPanic, thread.ExitType());
       
   292 		test_Equal(3, thread.ExitReason());
       
   293 		r = 0;
       
   294 		}
       
   295 	thread.Close();
       
   296 	
       
   297 	return r != 0;
       
   298 	}
       
   299 
       
   300 TInt TestUserSideTls1Thread(TAny*)
       
   301 	{
       
   302 	// Ensure TLS uses initial heap
       
   303 	if (UserSvr::DllSetTls(KCheckHandle,KCheckValue) != KErrNone)
       
   304 		return __LINE__;
       
   305 	UserSvr::DllFreeTls(KCheckHandle);
       
   306 
       
   307 	RHeap* tlsHeap = &User::Heap();
       
   308 	TInt tlsInitSize = HeapSize(tlsHeap);
       
   309 
       
   310 	// Switch heap
       
   311 	RHeap* newHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);
       
   312 	if (!newHeap)
       
   313 		return __LINE__;
       
   314 	TInt newInitSize = HeapSize(newHeap);
       
   315 	User::SwitchHeap(newHeap);
       
   316 	tlsHeap->Close();
       
   317 
       
   318 	// Allocate more TLS data
       
   319 	for(TInt i = 0 ; i < 100 ; ++i)
       
   320 		{
       
   321 		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)
       
   322 			return __LINE__;
       
   323 		}
       
   324 
       
   325 	// Test TLS data was allocated on original heap
       
   326 	if (!(HeapSize(tlsHeap) > tlsInitSize))
       
   327 		return __LINE__;
       
   328 	if (HeapSize(newHeap) != newInitSize)
       
   329 		return __LINE__;
       
   330 	
       
   331 	return KErrNone;
       
   332 	}
       
   333 
       
   334 void TestUserSideTls1()
       
   335 	{
       
   336 	test.Next(_L("Test user-side TLS behaviour when switching heaps"));
       
   337 
       
   338 	RThread thread;
       
   339 	test_KErrNone(thread.Create(_L("TestUserSideTls1Thread"), TestUserSideTls1Thread, 0x1000, 0x1000, 0x1000, 0));
       
   340 	
       
   341 	TRequestStatus status;
       
   342 	thread.Logon(status);
       
   343 	thread.Resume();
       
   344 	User::WaitForRequest(status);
       
   345 	
       
   346 	test_Equal(EExitKill, thread.ExitType());
       
   347 	test_Equal(KErrNone, thread.ExitReason());
       
   348 	thread.Close();
       
   349 	}
       
   350 
       
   351 TInt TestUserSideTls2Thread(TAny*)
       
   352 	{
       
   353 	// Allocate some TLS data
       
   354 	for(TInt i = 0 ; i < 100 ; ++i)
       
   355 		{
       
   356 		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)
       
   357 			return __LINE__;
       
   358 		}
       
   359 
       
   360 	// Exit normally
       
   361 	return KErrNone;
       
   362 	}
       
   363 
       
   364 void TestUserSideTls2()
       
   365 	{
       
   366 	test.Next(_L("Test user-side TLS data cleanup on thread exit"));
       
   367 
       
   368 	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);
       
   369 	test_NotNull(tlsHeap);
       
   370 	TInt initSize = HeapSize(tlsHeap);
       
   371 
       
   372 	RThread thread;
       
   373 	test_KErrNone(thread.Create(_L("TestUserSideTls2Thread"), TestUserSideTls2Thread, 0x1000, tlsHeap, 0));
       
   374 	TThreadId id = thread.Id();
       
   375 	
       
   376 	TRequestStatus status;
       
   377 	thread.Logon(status);
       
   378 	thread.Resume();
       
   379 	User::WaitForRequest(status);
       
   380 	
       
   381 	test_Equal(EExitKill, thread.ExitType());
       
   382 	test_Equal(KErrNone, thread.ExitReason());
       
   383 	thread.Close();
       
   384 
       
   385 	// Check TLS data freed
       
   386 	test_Equal(initSize, HeapSize(tlsHeap));	
       
   387 	tlsHeap->Close();
       
   388 
       
   389 	// Check heap no longer exists
       
   390 	test(!HeapExists(tlsHeap));
       
   391 
       
   392 	// Check thread no longer exists
       
   393 	RThread thread2;
       
   394 	test_Equal(KErrNotFound, thread2.Open(id));
       
   395 	}
       
   396 
       
   397 TInt TestUserSideTls3Thread(TAny*)
       
   398 	{
       
   399 	// Allocate some TLS data
       
   400 	for(TInt i = 0 ; i < 100 ; ++i)
       
   401 		{
       
   402 		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)
       
   403 			return __LINE__;
       
   404 		}
       
   405 
       
   406 	// Panic
       
   407 	User::Panic(_L("Test"), 999);
       
   408 	return KErrNone;
       
   409 	}
       
   410 
       
   411 void TestUserSideTls3()
       
   412 	{
       
   413 	test.Next(_L("Test user-side TLS data cleanup on thread panic"));
       
   414 
       
   415 	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);
       
   416 	test_NotNull(tlsHeap);
       
   417 
       
   418 	RThread thread;
       
   419 	test_KErrNone(thread.Create(_L("TestUserSideTls3Thread"), TestUserSideTls3Thread, 0x1000, tlsHeap, 0));
       
   420 	TThreadId id = thread.Id();
       
   421 	
       
   422 	TRequestStatus status;
       
   423 	thread.Logon(status);
       
   424 	thread.Resume();
       
   425 	User::WaitForRequest(status);
       
   426 	
       
   427 	test_Equal(EExitPanic, thread.ExitType());
       
   428 	test_Equal(999, thread.ExitReason());
       
   429 	
       
   430 	thread.Close();
       
   431 	tlsHeap->Close();
       
   432 	
       
   433 	// Check heap no longer exists
       
   434 	test(!HeapExists(tlsHeap));
       
   435 
       
   436 	// Check thread no longer exists
       
   437 	RThread thread2;
       
   438 	test_Equal(KErrNotFound, thread2.Open(id));
       
   439 	}
       
   440 
       
   441 TInt TestUserSideTls4Thread(TAny*)
       
   442 	{
       
   443 	// Shouldn't ever run
       
   444 	return KErrGeneral;
       
   445 	}
       
   446 
       
   447 void TestUserSideTls4()
       
   448 	{
       
   449 	test.Next(_L("Test user-side TLS data cleanup on early thread kill"));
       
   450 	
       
   451 	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);
       
   452 	test_NotNull(tlsHeap);
       
   453 
       
   454 	RThread thread;
       
   455 	test_KErrNone(thread.Create(_L("TestUserSideTls4Thread"), TestUserSideTls4Thread, 0x1000, tlsHeap, 0));
       
   456 	TThreadId id = thread.Id();
       
   457 	
       
   458 	thread.Kill(101);
       
   459 
       
   460 	TRequestStatus status;
       
   461 	thread.Logon(status);
       
   462 	User::WaitForRequest(status);
       
   463 	
       
   464 	test_Equal(EExitKill, thread.ExitType());
       
   465 	test_Equal(101, thread.ExitReason());
       
   466 	
       
   467 	thread.Close();
       
   468 	tlsHeap->Close();
       
   469 	
       
   470 	// Check heap no longer exists
       
   471 	test(!HeapExists(tlsHeap));
       
   472 
       
   473 	// Check thread no longer exists
       
   474 	RThread thread2;
       
   475 	test_Equal(KErrNotFound, thread2.Open(id));
       
   476 	}
       
   477 
       
   478 #if 0
       
   479 class CTest : public CBase
       
   480 	{
       
   481 public:
       
   482 	static CTest* New(TInt aSize, TInt aTls, TInt aLinkedTls);
       
   483 	virtual ~CTest();
       
   484 public:
       
   485 	TAny* iAlloc;
       
   486 	TInt iTls;
       
   487 	TInt iLinkedTls;
       
   488 	};
       
   489 
       
   490 void TlsCleanup2(TAny* a)
       
   491 	{
       
   492 	delete ((CTest*)a);
       
   493 	}
       
   494 
       
   495 CTest::~CTest()
       
   496 	{
       
   497 	RDebug::Print(_L("~CTest %d %d"), iTls, iLinkedTls);
       
   498 	User::Free(iAlloc);
       
   499 	UserSvr::DllFreeTls(iTls);
       
   500 	if (iLinkedTls)
       
   501 		{
       
   502 		CTest* p = (CTest*)UserSvr::DllTls(iLinkedTls);
       
   503 		if (p)
       
   504 			delete p;
       
   505 		}
       
   506 	}
       
   507 
       
   508 CTest* CTest::New(TInt aSize, TInt aTls, TInt aLinkedTls)
       
   509 	{
       
   510 	CTest* p = new CTest;
       
   511 	test(p!=NULL);
       
   512 	p->iTls = aTls;
       
   513 	p->iAlloc = User::Alloc(aSize);
       
   514 	test(p->iAlloc!=NULL);
       
   515 	p->iLinkedTls = aLinkedTls;
       
   516 	test(UserSvr::DllSetTls(aTls, p, TlsCleanup2)==KErrNone);
       
   517 	return p;
       
   518 	}
       
   519 
       
   520 
       
   521 void TlsCleanupCheck(TAny*)
       
   522 	{
       
   523 	__UHEAP_MARKEND;
       
   524 	}
       
   525 
       
   526 void TlsCleanup1(TAny* a)
       
   527 	{
       
   528 	User::Free(a);
       
   529 	}
       
   530 
       
   531 TInt TlsCleanupThread1(TAny* a)
       
   532 	{
       
   533 	__UHEAP_MARK;
       
   534 	TInt n = (TInt)a;
       
   535 	TInt i;
       
   536 	TInt r = UserSvr::DllSetTls(0, NULL, TlsCleanupCheck);
       
   537 	if (r!=KErrNone)
       
   538 		return r;
       
   539 	for (i=0; i<n; ++i)
       
   540 		{
       
   541 		TAny* p = User::Alloc(64);
       
   542 		if (!p)
       
   543 			return KErrNoMemory;
       
   544 		r = UserSvr::DllSetTls(i+1, p, TlsCleanup1);
       
   545 		if (r!=KErrNone)
       
   546 			return r;
       
   547 		}
       
   548 	return KErrNone;
       
   549 	}
       
   550 
       
   551 TInt TlsCleanupThread2(TAny*)
       
   552 	{
       
   553 	__UHEAP_MARK;
       
   554 	TInt r = UserSvr::DllSetTls(0, NULL, TlsCleanupCheck);
       
   555 	if (r!=KErrNone)
       
   556 		return r;
       
   557 
       
   558 	CTest::New(256, 1, 2);
       
   559 	CTest::New(256, 2, 3);
       
   560 	CTest::New(256, 3, 0);
       
   561 	CTest::New(256, 6, 5);
       
   562 	CTest::New(256, 5, 4);
       
   563 	CTest::New(256, 4, 0);
       
   564 	CTest::New(256, 9, 8);
       
   565 	CTest::New(256, 8, 7);
       
   566 	CTest::New(256, 7, 9);
       
   567 	CTest::New(256, 10, 11);
       
   568 	CTest* p = CTest::New(256, 11, 12);
       
   569 	CTest::New(256, 12, 0);
       
   570 
       
   571 	delete p;
       
   572 
       
   573 	return KErrNone;
       
   574 	}
       
   575 
       
   576 void DisplayExitInfo(RThread t)
       
   577 	{
       
   578 	TInt exitType = t.ExitType();
       
   579 	TInt exitReason = t.ExitReason();
       
   580 	TBuf<32> exitCat = t.ExitCategory();
       
   581 	test.Printf(_L("Exit Info: %d,%d,%S\n"), exitType, exitReason, &exitCat);
       
   582 	}
       
   583 
       
   584 void DoTestCleanupHandler(TThreadFunction aFunc, TAny* aArg)
       
   585 	{
       
   586 	RThread t;
       
   587 	TInt r = t.Create(KNullDesC, aFunc, 0x1000, NULL, aArg);
       
   588 	test(r==KErrNone);
       
   589 	TRequestStatus s;
       
   590 	t.Logon(s);
       
   591 	t.Resume();
       
   592 	User::WaitForRequest(s);
       
   593 	DisplayExitInfo(t);
       
   594 	test(t.ExitType()==EExitKill);
       
   595 	test(t.ExitReason()==KErrNone);
       
   596 	test(s==KErrNone);
       
   597 	CLOSE_AND_WAIT(t);
       
   598 	}
       
   599 
       
   600 void TestCleanupHandler()
       
   601 	{
       
   602 	HEAP_MARK;
       
   603 
       
   604 	test.Start(_L("Test TLS cleanup handlers"));
       
   605 	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)1 );
       
   606 	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)2 );
       
   607 	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)3 );
       
   608 	DoTestCleanupHandler(TlsCleanupThread2, NULL );
       
   609 
       
   610 	test.End();
       
   611 
       
   612 	HEAP_MARKEND;
       
   613 	}
       
   614 #endif
       
   615 
       
   616 void Benchmark()
       
   617 	{
       
   618 	const TInt KMaxEntries=(512*1024)/sizeof(STls); // limits TLS entries to 512K of storage
       
   619 	const TInt KMaxTime=500000; // limits time to half a second
       
   620 	
       
   621 	HEAP_MARK;
       
   622 
       
   623 	test.Start(_L("SetTls()"));//Note: much slower if done in reverse order
       
   624 	TInt count=0;
       
   625 	TTime start;
       
   626 	TTime finish;
       
   627 	TTime now;
       
   628 	start.HomeTime();
       
   629 	finish.HomeTime();
       
   630 	finish+=TTimeIntervalMicroSeconds(KMaxTime);
       
   631 	while (now.HomeTime(),now<finish && count<KMaxEntries)
       
   632 		{
       
   633 		test(UserSvr::DllSetTls(count,KCheckValue)==KErrNone);
       
   634 		count++;
       
   635 		}
       
   636 	TTimeIntervalMicroSeconds elapsed=now.MicroSecondsFrom(start);
       
   637 	TInt scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second
       
   638 	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);
       
   639 	if (count==KMaxEntries)
       
   640 		test.Printf(_L("     (%d in %f sec)\n"),count,elapsed.Int64()/1000000.0);
       
   641 
       
   642 	TInt max=count;
       
   643 
       
   644 	test.Next(_L("Tls()"));
       
   645 	TInt i=0;
       
   646 	count=0;
       
   647 	finish.HomeTime();
       
   648 	finish+=TTimeIntervalMicroSeconds(KMaxTime);
       
   649 	while (now.HomeTime(),now<finish)
       
   650 		{
       
   651 		test(UserSvr::DllTls(i)==KCheckValue);
       
   652 		count++;
       
   653 		if (++i==max)
       
   654 			i=0;
       
   655 		}
       
   656 	elapsed=now.MicroSecondsFrom(start);
       
   657 	scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second
       
   658 	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);
       
   659 
       
   660 	test.Next(_L("FreeTls()"));//Note: much faster if done in reverse order
       
   661 	count=0;
       
   662 	start.HomeTime();
       
   663 	finish.HomeTime();
       
   664 	finish+=TTimeIntervalMicroSeconds(KMaxTime);
       
   665 	while (now.HomeTime(),now<finish)
       
   666 		{
       
   667 		UserSvr::DllFreeTls(count++);
       
   668 		if (count==max)
       
   669 			break;
       
   670 		}
       
   671 	elapsed=now.MicroSecondsFrom(start);
       
   672 	scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second
       
   673 	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);
       
   674 	if (count==max)
       
   675 		test.Printf(_L("     (%d in %f sec)\n"),count,elapsed.Int64()/1000000.0);
       
   676 	
       
   677 	while (count<max)
       
   678 		UserSvr::DllFreeTls(--max);
       
   679 
       
   680 	HEAP_MARKEND;
       
   681 	test.End();
       
   682 	}
       
   683 
       
   684 TInt E32Main()
       
   685 	{
       
   686 
       
   687 	test.Title();
       
   688 	test.Start(_L("Test"));
       
   689 
       
   690 	// Turn off lazy dll unloading
       
   691 	RLoader l;
       
   692 	test(l.Connect()==KErrNone);
       
   693 	test(l.CancelLazyDllUnload()==KErrNone);
       
   694 	l.Close();
       
   695 
       
   696 	Test();
       
   697 	test.Next(_L("Thread Test"));
       
   698 
       
   699 	HEAP_MARK;
       
   700 
       
   701 	RThread thread;
       
   702 	TInt r=thread.Create(_L("TLS test thread"),TestThread,KDefaultStackSize,0x1000,0x8000,NULL);
       
   703 	test(r==KErrNone);
       
   704 	TRequestStatus stat;
       
   705 	thread.Logon(stat);
       
   706 	thread.Resume();
       
   707 	User::WaitForRequest(stat);
       
   708 	test(stat==KErrNone);
       
   709 	test(thread.ExitCategory()==_L("Kill"));
       
   710 	test(thread.ExitType()==EExitKill); 
       
   711 	test(thread.ExitReason()==KErrNone); 
       
   712 	CLOSE_AND_WAIT(thread);
       
   713 	
       
   714 	HEAP_MARKEND;
       
   715 
       
   716 	if (TLSStoredOnUserHeap())
       
   717 		{
       
   718 		MainHeap = &User::Heap();
       
   719 		TestUserSideTls1();
       
   720 		TestUserSideTls2();
       
   721 		TestUserSideTls3();
       
   722 		TestUserSideTls4();		
       
   723 		}
       
   724 	
       
   725 	User::After(100);
       
   726 	
       
   727 	// On serial screen systems, WSERV may not yet have completed the disconnect
       
   728 	// from the second thread. This causes the kernel heap check to fail.
       
   729 	// So we wait here until WSERV can run.
       
   730 	test.Printf(_L("Wait for WSERV\n"));
       
   731 
       
   732 //	TestCleanupHandler();
       
   733 
       
   734 	test.Next(_L("Benchmark"));
       
   735 	Benchmark();
       
   736 	test.End();
       
   737 	return KErrNone;
       
   738 	}