// 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;
	}