// 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\misc\t_stres1.cpp

 // 

 //

 #include <e32test.h>

 #include "u32std.h"

 #include <e32atomics.h>

 #include "../misc/prbs.h"

 RTest test(_L("T_STRES1"));

 _LIT(KLibraryFileName,"STRES1");

 LOCAL_D RMutex Mutex;

 LOCAL_D RSemaphore Semaphore;

 LOCAL_D RChunk Chunk;

 LOCAL_D RLibrary Library;

 LOCAL_D TBool CheckerHasRun=EFalse;

 LOCAL_D TInt TotalChecks=0;

 LOCAL_D TInt CheckerBumped=0;

 LOCAL_D TInt HeapUserIterations=0;

 LOCAL_D TInt CreatorIterations=0;

 LOCAL_D RSemaphore KillerSem;

 LOCAL_C TInt HeapChecker(TAny*)

 	{

 	TInt n=0;

 	FOREVER

 		{

 		User::Allocator().Check();

 		TotalChecks++;

 		CheckerHasRun=ETrue;

 		if (++n==4)

 			{

 			n=0;

 			User::CompressAllHeaps();

 			}

 		RThread().SetPriority(EPriorityMuchLess);

 		}

 	}

 LOCAL_C TAny* HeapAlloc(TUint* aSeed)

 	{

 	TInt size=(Random(aSeed)&0x3ffc)+8;

 	TUint32* p=(TUint32*)User::Alloc(size);

 	if (p)

 		{

 		size=User::Allocator().AllocLen(p);

 		p[0]=aSeed[0];

 		p[1]=aSeed[1];

 		TInt i;

 		for (i=2; i<(size>>2); i++)

 			p[i]=Random(aSeed);

 		}

 	return p;

 	}

 LOCAL_C void HeapFree(TAny* aPtr)

 	{

 	if (!aPtr)

 		return;

 	TInt size=User::Allocator().AllocLen(aPtr);

 	TUint32* p=(TUint32*)aPtr;

 	TUint seed[2];

 	seed[0]=p[0];

 	seed[1]=p[1];

 	TInt i;

 	for (i=2; i<(size>>2); i++)

 		{

 		if (p[i]!=Random(seed))

 			User::Panic(_L("VERIFY"),i);

 		}

 	User::Free(p);

 	}

 LOCAL_C TInt HeapUser(TAny* aSeed)

 	{

 	TUint seed[2];

 	seed[0]=(TUint)aSeed;

 	seed[1]=0;

 	FOREVER

 		{

 		TAny* p0=HeapAlloc(seed);

 		TAny* p1=HeapAlloc(seed);

 		TAny* p2=HeapAlloc(seed);

 		HeapFree(p1);

 		TAny* p3=HeapAlloc(seed);

 		TAny* p4=HeapAlloc(seed);

 		HeapFree(p4);

 		HeapFree(p0);

 		TAny* p5=HeapAlloc(seed);

 		HeapFree(p2);

 		TAny* p6=HeapAlloc(seed);

 		TAny* p7=HeapAlloc(seed);

 		HeapFree(p3);

 		HeapFree(p7);

 		HeapFree(p5);

 		HeapFree(p6);

 		__e32_atomic_add_ord32(&HeapUserIterations, 1);

 		TInt ms=Random(seed)&63;

 		TTimeIntervalMicroSeconds32 wait(1000*ms);

 		User::AfterHighRes(wait);

 		}

 	}

 LOCAL_C TInt KernelObjectCreator(TAny* aSeed)

 	{

 	TUint seed[2];

 	seed[0]=(TUint)aSeed;

 	seed[1]=0;

 	FOREVER

 		{

 		TInt rm=Mutex.CreateLocal(EOwnerThread);

 		TInt rs=Semaphore.CreateLocal(0,EOwnerThread);

 		TInt rc=Chunk.CreateLocal(0x10000,0x100000,EOwnerThread);

 		TInt rl=Library.Load(KLibraryFileName);

 		if (rm==KErrNone)

 			{

 			Mutex.Close();

 			}

 		if (rs==KErrNone)

 			{

 			Semaphore.Close();

 			}

 		if (rc==KErrNone)

 			{

 			Chunk.Close();

 			}

 		if (rl==KErrNone)

 			{

 			Library.Close();

 			}

 		CreatorIterations++;

 		TInt ms=Random(seed)&63;

 		TTimeIntervalMicroSeconds32 wait(1000*ms);

 		User::AfterHighRes(wait);

 		}

 	}

 LOCAL_C TInt KillerThread(TAny* aSeed)

 	{

 	TUint seed[2];

 	seed[0]=(TUint)aSeed;

 	seed[1]=0;

 	FOREVER

 		{

 		KillerSem.Wait();

 		TInt ms=Random(seed)&127;

 		ms+=32;

 		TTimeIntervalMicroSeconds32 wait(1000*ms);

 		User::AfterHighRes(wait);

 		RThread t;

 		TFindThread ft(_L("*Creator"));

 		TFullName fn;

 		TInt r=ft.Next(fn);

 		if (r!=KErrNone)

 			User::Panic(_L("FindErr"),r);

 		r=t.Open(ft);

 		if (r!=KErrNone)

 			User::Panic(_L("OpenErr"),r);

 		t.Kill(1);

 		t.Close();

 		}

 	}

 LOCAL_C TInt StartThread(const TDesC& aName, TThreadFunction aFunction, TAny* aPtr, TThreadPriority aPriority, RThread* aThread)

 	{

 	RThread t;

 	TInt r=t.Create(aName,aFunction,0x1000,NULL,aPtr);

 	if (r!=KErrNone)

 		return r;

 	t.SetPriority(aPriority);

 	t.Resume();

 	if (aThread)

 		aThread->SetHandle(t.Handle());

 	else

 		t.Close();

 	return r;

 	}

 LOCAL_C void Initialise(RThread& aChecker)

 	{

 	TInt r=StartThread(_L("HeapChecker"),HeapChecker,NULL,EPriorityMuchLess,&aChecker);

 	test(r==KErrNone);

 	r=StartThread(_L("HeapUser1"),HeapUser,(TAny*)0xb504f333,EPriorityNormal,NULL);

 	test(r==KErrNone);

 	r=StartThread(_L("HeapUser2"),HeapUser,(TAny*)0xddb3d743,EPriorityNormal,NULL);

 	test(r==KErrNone);

 	r=StartThread(_L("Creator"),KernelObjectCreator,(TAny*)0xadf85458,EPriorityNormal,NULL);

 	test(r==KErrNone);

 	r=KillerSem.CreateLocal(1);

 	test(r==KErrNone);

 	r=StartThread(_L("Killer"),KillerThread,(TAny*)0xb17217f8,EPriorityMore,NULL);

 	test(r==KErrNone);

 	}

 LOCAL_C void Restart(const TDesC&)

 	{

 	FOREVER

 		{

 		TInt r=StartThread(_L("Creator"),KernelObjectCreator,(TAny*)0xadf85458,EPriorityNormal,NULL);

 		if (r==KErrNone)

 			break;

 		User::After(15000);

 		}

 	KillerSem.Signal();

 	}

 GLDEF_C TInt E32Main()

 	{

 	test.Title();

 	RThread().SetPriority(EPriorityMuchMore);

 	RThread checker;

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

 	Initialise(checker);

 	test.Next(_L("Create undertaker"));

 	RUndertaker u;

 	TInt r=u.Create();

 	test(r==KErrNone);

 	test.Next(_L("Create timer"));

 	RTimer timer;

 	r=timer.CreateLocal();

 	test(r==KErrNone);

 	TInt tick=0;

 	TRequestStatus su;

 	TRequestStatus st;

 	TInt h=0;

 	test.Next(_L("Logon to undertaker"));

 	u.Logon(su,h);

 	test.Next(_L("Start timer"));

 	timer.After(st,500000);

 	FOREVER

 		{

 		User::WaitForRequest(su,st);

 		if (su!=KRequestPending)

 			{

 			RThread t;

 			t.SetHandle(h);

 			TName n=t.Name();

 			TExitType exitType=t.ExitType();

 			TInt exitReason=t.ExitReason();

 			TName exitCategory=t.ExitCategory();

 			t.Close();

 			if (exitType==EExitPanic)

 				{

 				test.Printf(_L("Thread %S Panic %S %d\n"),&n,&exitCategory,exitReason);

 				test(0);

 				}

 			if (exitType==EExitKill)

 				{

 				Restart(n);

 				}

 			h=0;

 			u.Logon(su,h);

 			}

 		if (st!=KRequestPending)

 			{

 			if (!CheckerHasRun)

 				{

 				checker.SetPriority(EPriorityMuchMore);

 				CheckerBumped++;

 				}

 			CheckerHasRun=EFalse;

 			if (++tick==4)

 				{

 				tick=0;

 				test.Printf(_L("Heap user iterations %d Creator iterations %d\n"),HeapUserIterations,CreatorIterations);

 				test.Printf(_L("Checks %d Bumped %d\n"),TotalChecks,CheckerBumped);

 				}

 			timer.After(st,500000);

 			}

 		}

 	}