// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

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

// which accompanies this distribution, and is available

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

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\dll\t_tls.cpp

// Overview:

// Test and benchmark TLS (Thread Local Storage) functions

// API Information:

// UserSvr

// Details:

// - Use the UserSvr methods: DllTls, DllSetTls and DllFreeTls to test 

// the thread local storage. Verify the expected results. Verify that 

// the heap was not corrupted by any of the tests.

// - In a separate thread, use the UserSvr methods: DllTls, DllSetTls and 

// DllFreeTls to test the thread local storage. Verify the expected results.

// - Test the TLS cleanup handlers and verify results are as expected. Verify 

// that the heap was not corrupted by any of the tests.

// - Benchmark how many DllSetTls, DllTls and DllFreeTls operations can be

// performed in 1/2 second.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// Tests and benchmarks Tls functions

// 14/10/96 Modified scheme on Arm release

// SetTls - 352	~1300

// Tls - 3510 ~1600

// 15/10/96 Array scheme on Arm release

// Set Tls - ~1900

// Tls - ~2550

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32svr.h>

#include <f32dbg.h>

#include <e32def.h>

#include <e32def_private.h>

#include "u32std.h"

// Can't tell whether allocations will be on the kernel or user heap, so perform all heap check

// operations on both

#define HEAP_MARK			__UHEAP_MARK; __KHEAP_MARK

#define HEAP_MARKEND		__UHEAP_MARKEND; __KHEAP_MARKEND

#define HEAP_RESET			__UHEAP_RESET; __KHEAP_RESET

#define HEAP_CHECK(x)		__UHEAP_CHECK(x); __KHEAP_CHECK(x)

#define HEAP_FAILNEXT(x)	__UHEAP_FAILNEXT(x); __KHEAP_FAILNEXT(x)

TInt const KCheckHandle=67338721;

TUint8* const KCheckValue=(TUint8*)8525124;

LOCAL_D RTest test(_L("T_TLS"));

_LIT(KTestDllName, "t_tlsdll");

const TInt KTestDllOrdSet	= 1;

const TInt KTestDllOrdGet	= 2;

const TInt KTestDllOrdFree	= 3;

typedef TInt (*TTestDllSetFn)(TAny*);

typedef TAny* (*TTestDllGetFn)();

typedef void (*TTestDllFreeFn)();

TInt TestDllSetTls(RLibrary aLib, TAny* aValue)

	{

	TTestDllSetFn f = (TTestDllSetFn)aLib.Lookup(KTestDllOrdSet);

	return (*f)(aValue);

	}

TAny* TestDllGetTls(RLibrary aLib)

	{

	TTestDllGetFn f = (TTestDllGetFn)aLib.Lookup(KTestDllOrdGet);

	return (*f)();

	}

void TestDllFreeTls(RLibrary aLib)

	{

	TTestDllFreeFn f = (TTestDllFreeFn)aLib.Lookup(KTestDllOrdFree);

	(*f)();

	}

#define DISPLAY_PROGRESS	test.Printf(_L("Line %d\n"), __LINE__)

void Test()

	{

	test.Start(_L("Stuff without Setting"));

	HEAP_MARK;

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	UserSvr::DllFreeTls(KCheckHandle);

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	test(UserSvr::DllTls(0)==NULL);

	UserSvr::DllFreeTls(0);

	test(UserSvr::DllTls(0)==NULL);

	HEAP_CHECK(0);

	test.Next(_L("Set"));

	test(UserSvr::DllSetTls(KCheckHandle,KCheckValue)==KErrNone);

	test.Next(_L("Get"));

	test(UserSvr::DllTls(KCheckHandle)==KCheckValue);

	test.Next(_L("Free"));

	UserSvr::DllFreeTls(KCheckHandle);

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	HEAP_CHECK(0);

	test.Next(_L("Set lots"));

	TInt i=0;

	for(;i<1000;i+=3)

		{

		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i)==KErrNone);

		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);

		}

	for(i=999;i>0;i-=3)

		{

		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);

		UserSvr::DllFreeTls(KCheckHandle+i);

		test(UserSvr::DllTls(KCheckHandle+i)==NULL);

		}

	test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);

	UserSvr::DllFreeTls(KCheckHandle+i);

	test(UserSvr::DllTls(KCheckHandle+i)==NULL);

	HEAP_MARKEND;

	test.Next(_L("Test with DLL ID"));

	HEAP_MARK;

	test(UserSvr::DllTls(KCheckHandle, 1)==0);

	test(UserSvr::DllTls(KCheckHandle, 2)==0);

	DISPLAY_PROGRESS;

#ifdef _DEBUG

	HEAP_FAILNEXT(1);

	DISPLAY_PROGRESS;

	test(UserSvr::DllSetTls(KCheckHandle, 1, KCheckValue)==KErrNoMemory);

#endif

	test(UserSvr::DllSetTls(KCheckHandle, 1, KCheckValue)==KErrNone);

	test(UserSvr::DllTls(KCheckHandle, 1)==KCheckValue);

	test(UserSvr::DllTls(KCheckHandle, 2)==0);

	DISPLAY_PROGRESS;

	HEAP_FAILNEXT(1);

	DISPLAY_PROGRESS;

	test(UserSvr::DllSetTls(KCheckHandle, 3, KCheckValue)==KErrNone);

#ifdef _DEBUG

	RSemaphore s;

	test(s.CreateLocal(0)==KErrNoMemory);

#endif

	HEAP_RESET;

	test(UserSvr::DllTls(KCheckHandle, 1)==0);

	test(UserSvr::DllTls(KCheckHandle, 2)==0);

	test(UserSvr::DllTls(KCheckHandle, 3)==KCheckValue);

	UserSvr::DllFreeTls(KCheckHandle);

	DISPLAY_PROGRESS;

	HEAP_MARKEND;

	DISPLAY_PROGRESS;

	test.Next(_L("Test reloading DLL"));

	RLibrary l;

	TInt r = l.Load(KTestDllName);

	test(r==KErrNone);

	for (i=0; i<2; ++i)

		{

		test.Printf(_L("i=%d\n"),i);

		test(TestDllGetTls(l)==0);

		test(TestDllSetTls(l, KCheckValue)==KErrNone);

		test(TestDllGetTls(l)==KCheckValue);

		if (i==0)

			{

			TestDllFreeTls(l);

			test(TestDllGetTls(l)==0);

			}

		l.Close();

		r = l.Load(KTestDllName);

		test(r==KErrNone);

		test(TestDllGetTls(l)==0);

		TestDllFreeTls(l);

		}

	l.Close();

	test.End();

	}

TInt TestThread(TAny*)

	{

	RTest test(_L("T_TLS Thread"));

	test.Start(_L("Stuff without Setting"));

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	UserSvr::DllFreeTls(KCheckHandle);

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	test(UserSvr::DllTls(0)==NULL);

	UserSvr::DllFreeTls(0);

	test(UserSvr::DllTls(0)==NULL);

	test.Next(_L("Set"));

	test(UserSvr::DllSetTls(KCheckHandle,KCheckValue)==KErrNone);

	test.Next(_L("Get"));

	test(UserSvr::DllTls(KCheckHandle)==KCheckValue);

	test.Next(_L("Free"));

	UserSvr::DllFreeTls(KCheckHandle);

	test(UserSvr::DllTls(KCheckHandle)==NULL);

	test.Next(_L("Set lots"));

	TInt i=0;

	for(;i<1000;i+=3)

		{

		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i)==KErrNone);

		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);

		}

	for(i=999;i>=0;i-=3)

		{

		test(UserSvr::DllTls(KCheckHandle+i)==KCheckValue-i);

		UserSvr::DllFreeTls(KCheckHandle+i);

		test(UserSvr::DllTls(KCheckHandle+i)==NULL);

		}

	test.Close();

	return KErrNone;

	}

TInt HeapSize(RHeap* aHeap = NULL)

	{

	if (!aHeap)

		aHeap = &User::Heap();

	TInt size;

	aHeap->AllocSize(size);

	return size;

	}

TBool TLSStoredOnUserHeap()

	{

	TInt initCount = HeapSize();

	TInt i;

	const TInt KMax = 2;

	for(i = 0 ; i < KMax ; ++i)

		test(UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) == KErrNone);

	TInt finalCount = HeapSize();

	for(i = 0 ; i < KMax ; ++i)

		UserSvr::DllFreeTls(KCheckHandle+i);

	return initCount != finalCount;

	}

class RDummyAllocator : public RAllocator

	{

public:

	TInt AccessCount() { return iAccessCount; }

	};

RHeap* MainHeap = NULL;

TInt HeapAccessCount(TAny* aHeap)

	{

	RDummyAllocator* heap = (RDummyAllocator*)aHeap;

	return heap->AccessCount();

	}

TBool HeapExists(RHeap* aHeap)

	{

	RThread thread;

	test_KErrNone(thread.Create(_L("HeapExistsThread"), HeapAccessCount, 0x1000, MainHeap, (TAny*)aHeap));

	TRequestStatus status;

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

	TInt r;

	if (thread.ExitType() == EExitKill)

		{

		r = thread.ExitReason();

		test_NotNegative(r);

		}

	else

		{

		test_Equal(EExitPanic, thread.ExitType());

		test_Equal(3, thread.ExitReason());

		r = 0;

		}

	thread.Close();

	return r != 0;

	}

TInt TestUserSideTls1Thread(TAny*)

	{

	// Ensure TLS uses initial heap

	if (UserSvr::DllSetTls(KCheckHandle,KCheckValue) != KErrNone)

		return __LINE__;

	UserSvr::DllFreeTls(KCheckHandle);

	RHeap* tlsHeap = &User::Heap();

	TInt tlsInitSize = HeapSize(tlsHeap);

	// Switch heap

	RHeap* newHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);

	if (!newHeap)

		return __LINE__;

	TInt newInitSize = HeapSize(newHeap);

	User::SwitchHeap(newHeap);

	tlsHeap->Close();

	// Allocate more TLS data

	for(TInt i = 0 ; i < 100 ; ++i)

		{

		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)

			return __LINE__;

		}

	// Test TLS data was allocated on original heap

	if (!(HeapSize(tlsHeap) > tlsInitSize))

		return __LINE__;

	if (HeapSize(newHeap) != newInitSize)

		return __LINE__;

	return KErrNone;

	}

void TestUserSideTls1()

	{

	test.Next(_L("Test user-side TLS behaviour when switching heaps"));

	RThread thread;

	test_KErrNone(thread.Create(_L("TestUserSideTls1Thread"), TestUserSideTls1Thread, 0x1000, 0x1000, 0x1000, 0));

	TRequestStatus status;

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

	test_Equal(EExitKill, thread.ExitType());

	test_Equal(KErrNone, thread.ExitReason());

	thread.Close();

	}

TInt TestUserSideTls2Thread(TAny*)

	{

	// Allocate some TLS data

	for(TInt i = 0 ; i < 100 ; ++i)

		{

		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)

			return __LINE__;

		}

	// Exit normally

	return KErrNone;

	}

void TestUserSideTls2()

	{

	test.Next(_L("Test user-side TLS data cleanup on thread exit"));

	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);

	test_NotNull(tlsHeap);

	TInt initSize = HeapSize(tlsHeap);

	RThread thread;

	test_KErrNone(thread.Create(_L("TestUserSideTls2Thread"), TestUserSideTls2Thread, 0x1000, tlsHeap, 0));

	TThreadId id = thread.Id();

	TRequestStatus status;

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

	test_Equal(EExitKill, thread.ExitType());

	test_Equal(KErrNone, thread.ExitReason());

	thread.Close();

	// Check TLS data freed

	test_Equal(initSize, HeapSize(tlsHeap));	

	tlsHeap->Close();

	// Check heap no longer exists

	test(!HeapExists(tlsHeap));

	// Check thread no longer exists

	RThread thread2;

	test_Equal(KErrNotFound, thread2.Open(id));

	}

TInt TestUserSideTls3Thread(TAny*)

	{

	// Allocate some TLS data

	for(TInt i = 0 ; i < 100 ; ++i)

		{

		if (UserSvr::DllSetTls(KCheckHandle+i,KCheckValue-i) != KErrNone)

			return __LINE__;

		}

	// Panic

	User::Panic(_L("Test"), 999);

	return KErrNone;

	}

void TestUserSideTls3()

	{

	test.Next(_L("Test user-side TLS data cleanup on thread panic"));

	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);

	test_NotNull(tlsHeap);

	RThread thread;

	test_KErrNone(thread.Create(_L("TestUserSideTls3Thread"), TestUserSideTls3Thread, 0x1000, tlsHeap, 0));

	TThreadId id = thread.Id();

	TRequestStatus status;

	thread.Logon(status);

	thread.Resume();

	User::WaitForRequest(status);

	test_Equal(EExitPanic, thread.ExitType());

	test_Equal(999, thread.ExitReason());

	thread.Close();

	tlsHeap->Close();

	// Check heap no longer exists

	test(!HeapExists(tlsHeap));

	// Check thread no longer exists

	RThread thread2;

	test_Equal(KErrNotFound, thread2.Open(id));

	}

TInt TestUserSideTls4Thread(TAny*)

	{

	// Shouldn't ever run

	return KErrGeneral;

	}

void TestUserSideTls4()

	{

	test.Next(_L("Test user-side TLS data cleanup on early thread kill"));

	RHeap* tlsHeap = User::ChunkHeap(NULL, 0x1000, 0x1000);

	test_NotNull(tlsHeap);

	RThread thread;

	test_KErrNone(thread.Create(_L("TestUserSideTls4Thread"), TestUserSideTls4Thread, 0x1000, tlsHeap, 0));

	TThreadId id = thread.Id();

	thread.Kill(101);

	TRequestStatus status;

	thread.Logon(status);

	User::WaitForRequest(status);

	test_Equal(EExitKill, thread.ExitType());

	test_Equal(101, thread.ExitReason());

	thread.Close();

	tlsHeap->Close();

	// Check heap no longer exists

	test(!HeapExists(tlsHeap));

	// Check thread no longer exists

	RThread thread2;

	test_Equal(KErrNotFound, thread2.Open(id));

	}

#if 0

class CTest : public CBase

	{

public:

	static CTest* New(TInt aSize, TInt aTls, TInt aLinkedTls);

	virtual ~CTest();

public:

	TAny* iAlloc;

	TInt iTls;

	TInt iLinkedTls;

	};

void TlsCleanup2(TAny* a)

	{

	delete ((CTest*)a);

	}

CTest::~CTest()

	{

	RDebug::Print(_L("~CTest %d %d"), iTls, iLinkedTls);

	User::Free(iAlloc);

	UserSvr::DllFreeTls(iTls);

	if (iLinkedTls)

		{

		CTest* p = (CTest*)UserSvr::DllTls(iLinkedTls);

		if (p)

			delete p;

		}

	}

CTest* CTest::New(TInt aSize, TInt aTls, TInt aLinkedTls)

	{

	CTest* p = new CTest;

	test(p!=NULL);

	p->iTls = aTls;

	p->iAlloc = User::Alloc(aSize);

	test(p->iAlloc!=NULL);

	p->iLinkedTls = aLinkedTls;

	test(UserSvr::DllSetTls(aTls, p, TlsCleanup2)==KErrNone);

	return p;

	}

void TlsCleanupCheck(TAny*)

	{

	__UHEAP_MARKEND;

	}

void TlsCleanup1(TAny* a)

	{

	User::Free(a);

	}

TInt TlsCleanupThread1(TAny* a)

	{

	__UHEAP_MARK;

	TInt n = (TInt)a;

	TInt i;

	TInt r = UserSvr::DllSetTls(0, NULL, TlsCleanupCheck);

	if (r!=KErrNone)

		return r;

	for (i=0; i<n; ++i)

		{

		TAny* p = User::Alloc(64);

		if (!p)

			return KErrNoMemory;

		r = UserSvr::DllSetTls(i+1, p, TlsCleanup1);

		if (r!=KErrNone)

			return r;

		}

	return KErrNone;

	}

TInt TlsCleanupThread2(TAny*)

	{

	__UHEAP_MARK;

	TInt r = UserSvr::DllSetTls(0, NULL, TlsCleanupCheck);

	if (r!=KErrNone)

		return r;

	CTest::New(256, 1, 2);

	CTest::New(256, 2, 3);

	CTest::New(256, 3, 0);

	CTest::New(256, 6, 5);

	CTest::New(256, 5, 4);

	CTest::New(256, 4, 0);

	CTest::New(256, 9, 8);

	CTest::New(256, 8, 7);

	CTest::New(256, 7, 9);

	CTest::New(256, 10, 11);

	CTest* p = CTest::New(256, 11, 12);

	CTest::New(256, 12, 0);

	delete p;

	return KErrNone;

	}

void DisplayExitInfo(RThread t)

	{

	TInt exitType = t.ExitType();

	TInt exitReason = t.ExitReason();

	TBuf<32> exitCat = t.ExitCategory();

	test.Printf(_L("Exit Info: %d,%d,%S\n"), exitType, exitReason, &exitCat);

	}

void DoTestCleanupHandler(TThreadFunction aFunc, TAny* aArg)

	{

	RThread t;

	TInt r = t.Create(KNullDesC, aFunc, 0x1000, NULL, aArg);

	test(r==KErrNone);

	TRequestStatus s;

	t.Logon(s);

	t.Resume();

	User::WaitForRequest(s);

	DisplayExitInfo(t);

	test(t.ExitType()==EExitKill);

	test(t.ExitReason()==KErrNone);

	test(s==KErrNone);

	CLOSE_AND_WAIT(t);

	}

void TestCleanupHandler()

	{

	HEAP_MARK;

	test.Start(_L("Test TLS cleanup handlers"));

	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)1 );

	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)2 );

	DoTestCleanupHandler(TlsCleanupThread1, (TAny*)3 );

	DoTestCleanupHandler(TlsCleanupThread2, NULL );

	test.End();

	HEAP_MARKEND;

	}

#endif

void Benchmark()

	{

	const TInt KMaxEntries=(512*1024)/sizeof(STls); // limits TLS entries to 512K of storage

	const TInt KMaxTime=500000; // limits time to half a second

	HEAP_MARK;

	test.Start(_L("SetTls()"));//Note: much slower if done in reverse order

	TInt count=0;

	TTime start;

	TTime finish;

	TTime now;

	start.HomeTime();

	finish.HomeTime();

	finish+=TTimeIntervalMicroSeconds(KMaxTime);

	while (now.HomeTime(),now<finish && count<KMaxEntries)

		{

		test(UserSvr::DllSetTls(count,KCheckValue)==KErrNone);

		count++;

		}

	TTimeIntervalMicroSeconds elapsed=now.MicroSecondsFrom(start);

	TInt scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second

	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);

	if (count==KMaxEntries)

		test.Printf(_L("     (%d in %f sec)\n"),count,elapsed.Int64()/1000000.0);

	TInt max=count;

	test.Next(_L("Tls()"));

	TInt i=0;

	count=0;

	finish.HomeTime();

	finish+=TTimeIntervalMicroSeconds(KMaxTime);

	while (now.HomeTime(),now<finish)

		{

		test(UserSvr::DllTls(i)==KCheckValue);

		count++;

		if (++i==max)

			i=0;

		}

	elapsed=now.MicroSecondsFrom(start);

	scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second

	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);

	test.Next(_L("FreeTls()"));//Note: much faster if done in reverse order

	count=0;

	start.HomeTime();

	finish.HomeTime();

	finish+=TTimeIntervalMicroSeconds(KMaxTime);

	while (now.HomeTime(),now<finish)

		{

		UserSvr::DllFreeTls(count++);

		if (count==max)

			break;

		}

	elapsed=now.MicroSecondsFrom(start);

	scount=(TInt)((count*500000.0)/elapsed.Int64()); // scale count up to 1/2 second

	test.Printf(_L("     Done %d in 1/2 sec\n"),scount);

	if (count==max)

		test.Printf(_L("     (%d in %f sec)\n"),count,elapsed.Int64()/1000000.0);

	while (count<max)

		UserSvr::DllFreeTls(--max);

	HEAP_MARKEND;

	test.End();

	}

TInt E32Main()

	{

	test.Title();

	test.Start(_L("Test"));

	// Turn off lazy dll unloading

	RLoader l;

	test(l.Connect()==KErrNone);

	test(l.CancelLazyDllUnload()==KErrNone);

	l.Close();

	Test();

	test.Next(_L("Thread Test"));

	HEAP_MARK;

	RThread thread;

	TInt r=thread.Create(_L("TLS test thread"),TestThread,KDefaultStackSize,0x1000,0x8000,NULL);

	test(r==KErrNone);

	TRequestStatus stat;

	thread.Logon(stat);

	thread.Resume();

	User::WaitForRequest(stat);

	test(stat==KErrNone);

	test(thread.ExitCategory()==_L("Kill"));

	test(thread.ExitType()==EExitKill); 

	test(thread.ExitReason()==KErrNone); 

	CLOSE_AND_WAIT(thread);

	HEAP_MARKEND;

	if (TLSStoredOnUserHeap())

		{

		MainHeap = &User::Heap();

		TestUserSideTls1();

		TestUserSideTls2();

		TestUserSideTls3();

		TestUserSideTls4();		

		}

	User::After(100);

	// On serial screen systems, WSERV may not yet have completed the disconnect

	// from the second thread. This causes the kernel heap check to fail.

	// So we wait here until WSERV can run.

	test.Printf(_L("Wait for WSERV\n"));

//	TestCleanupHandler();

	test.Next(_L("Benchmark"));

	Benchmark();

	test.End();

	return KErrNone;

	}