// Copyright (c) 1995-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\mmu\t_btb.cpp

 // 

 //

 //! @SYMTestCaseID KBASE/T_BTB

 //! @SYMTestType UT

 //! @SYMTestCaseDesc Make sure processes can't interfere with each other via the BTB.  Make sure the BTB is turned on.

 //! @SYMREQ REQ4095

 //! @SYMTestActions Make concurent processes with code areas and thrash them.

 //! @SYMTestExpectedResults  They shouldn't interfere.  The BTB should be enabled.

 //! @SYMTestPriority Low

 //! @SYMTestStatus Defined

 #include <e32test.h>

 #include "u32std.h"

 #ifdef __CPU_ARM

 extern TInt BranchTest1();

 extern TInt BranchTest2();

 extern TInt BranchTest3();

 void BranchTest4(TInt);

 extern void BranchTest1End();

 extern void BranchTest2End();

 extern void BranchTest3End();

 extern void BranchTest4End();

 typedef TInt (*PFI)(void);

 typedef void (*PFV)(TInt);

 void SecondaryProcess(const TDesC& aCmd, RTest& test)

 	{

 	test.Start(_L("Secondary Process"));

 	TLex lex(aCmd);

 	TUint32 addr;

 	TInt r=lex.Val(addr,EHex);

 	test(r==KErrNone);

 	test.Printf(_L("Primary process says: RAM code at %08x\n"),addr);

 	TInt pageSize;

 	r=UserHal::PageSizeInBytes(pageSize);

 	test(r==KErrNone);

 	RChunk c;

 	r=c.CreateLocalCode(pageSize,0x100000);

 	test(r==KErrNone);

 	PFI pBranchTest2=(PFI)c.Base();

 	test.Printf(_L("Secondary test loop function at %08x\n"),pBranchTest2);

 	test((TUint32)pBranchTest2==addr);

 	TInt fnLength = (TInt)&BranchTest2End-(TInt)&BranchTest2;

 	test.Printf(_L("SecProc: Copying %d bytes from %08x...\n"), (TInt)&BranchTest2End-(TInt)&BranchTest2, (TAny*)&BranchTest2 );

 	Mem::Copy((TAny*)pBranchTest2, (TAny*)&BranchTest2, fnLength);

 	User::IMB_Range((TAny*)pBranchTest2, fnLength+(TUint8*)pBranchTest2);

 	TTime begin;

 	begin.HomeTime();

 	test.Printf(_L("Running secondary loop...\n"));

 	TInt n=0;

 	FOREVER

 		{

 		n=pBranchTest2();

 		if (n)

 			break;

 		TTime now;

 		now.HomeTime();

 		if (now.MicroSecondsFrom(begin).Int64()>20000000)  // ten seconds for each test ought to be long enough

 			break;

 		}

 		test.Printf(_L("Ending secondary loop.\n"));

 		test(n==0);

 		//test.End();

 	}

 GLREF_C TInt E32Main()

 	{

 	RTest test(_L("T_BTB"));

 	test.Title();

 	TBuf<16> cmd;

 	User::CommandLine(cmd);

 	if (cmd.Length()!=0)  // if we get a command line, we're the secondary process

 		{

 		SecondaryProcess(cmd,test);

 		return 0;

 		}

 	test.Start(_L("Create primary process code chunk"));

 	TInt pageSize;

 	TInt r=UserHal::PageSizeInBytes(pageSize);

 	test(r==KErrNone);

 	RChunk c;

 	r=c.CreateLocalCode(pageSize,0x100000);

 	test(r==KErrNone);

 	TUint8* pCode=c.Base();

 	test.Printf(_L("Primary process code chunk at %08x\n"),pCode);

 	// Spawn a secondary process

 	RProcess p;

 	TRequestStatus s;

 	TBuf<16> codeBaseHex;

 	codeBaseHex.Format(_L("%08x"),pCode);

 	r=p.Create(RProcess().FileName(),codeBaseHex);

 	test(r==KErrNone);

 	p.Logon(s);

 	p.Resume();

 	TTime begin, now;

 	TInt n=0, m=0, q=0, fnLength;

 	PFI pBranchTest1=(PFI)pCode;

 	test.Printf(_L("Primary test loop function at %08x\n"),pBranchTest1);

 	fnLength = (TInt)&BranchTest1End-(TInt)&BranchTest1;

 	//test.Printf(_L("PriProc: Copying %d bytes from 0x%08x to 0x%08x for forward-branching test...\n"), fnLength, &BranchTest1, pBranchTest1);

 	Mem::Copy((TAny *)pBranchTest1, (const TAny*)&BranchTest1, fnLength);   // copy in the asm test code

 	User::IMB_Range((TAny*)pBranchTest1, fnLength+(TUint8*)pBranchTest1);

 	test.Printf(_L("Running primary loop...\n"));

 	begin.HomeTime();

 	FOREVER

 		{

 		m++;

 		n=pBranchTest1();

 		if (n)

 			break;	

 		now.HomeTime();

 		if (now.MicroSecondsFrom(begin).Int64()>10000000)  // ten seconds ought to be long enough

 			break;

 		}

 	test(n==0);

 	test.Printf(_L("Ending primary loop.  Ran %d times in 10s.\n"), m);

 	// run the second test

 	PFI pBranchTest3=(PFI)pCode;

 	fnLength = (TInt)&BranchTest3End-(TInt)&BranchTest3;

 	//test.Printf(_L("PriProc: Copying %d bytes from 0x%08x to 0x%08x for back-branching test...\n"), fnLength, &BranchTest3, pBranchTest3);

 	Mem::Copy((TAny *)pBranchTest3, (const TAny*)&BranchTest3, fnLength);   // copy in the asm test code

 	User::IMB_Range((TAny*)pBranchTest3, fnLength+(TUint8*)pBranchTest3);

 	test.Printf(_L("PriProc: Starting back-branch test loop.\n"));

 	m=0;  

 	begin.HomeTime();

 	FOREVER

 		{

 		m++;

 		n=pBranchTest3();

 		if (n)

 			break;	

 		now.HomeTime();

 		if (now.MicroSecondsFrom(begin).Int64()>10000000)  // ten seconds ought to be long enough

 			break;

 		}

 	test(n==0);

 	test.Printf(_L("Ending primary back-branching loop.  Ran %d times in 10s.\n"), m);

 	p.Kill(0);

 	User::WaitForRequest(s);

 	TInt exitType=p.ExitType();

 	TInt exitReason=p.ExitReason();

 	TExitCategoryName exitCat=p.ExitCategory();

 	CLOSE_AND_WAIT(p);

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

 	test(exitType==EExitKill);

 	test(exitReason==KErrNone);

 	// speed test

 	PFV pBranchTest4 = (PFV)pCode;

 	fnLength = (TInt)&BranchTest4End-(TInt)&BranchTest4;

 	//test.Printf(_L("PriProc: Copying %d bytes from 0x%08x to 0x%08x for forward-branching speed test...\n"), fnLength, &BranchTest4, pBranchTest1);

 	Mem::Copy((TAny *)pBranchTest4, (const TAny*)&BranchTest4, fnLength);   // copy in the asm test code

 	User::IMB_Range((TAny*)pBranchTest4, fnLength+(TUint8*)pBranchTest4);

 	test.Printf(_L("Speed test running with f(0)...\n"));

 	m=0;

 	begin.HomeTime();

 	FOREVER

 		{

 		m++;

 		pBranchTest4(0);

 		now.HomeTime();

 		if (now.MicroSecondsFrom(begin).Int64()>10000000)  // ten seconds ought to be long enough

 			break;

 		}

 	test.Printf(_L("Ending f(0) test.  Ran %d times in 10s.\n"), m);

 	test.Printf(_L("PriProc: Starting f(1) run.\n"));

 	q=0;	

 	begin.HomeTime();

 	FOREVER

 		{

 		q++;

 		pBranchTest4(1);

 		now.HomeTime();

 		if (now.MicroSecondsFrom(begin).Int64()>10000000)  // ten seconds ought to be long enough

 			break;

 		}

 	test.Printf(_L("Ending test loop with f(1).  Ran %d times in 10s.\n"), q);

 	test(m-q>m/4);  // the difference between m and q should be large, indicating successful prediction

 	c.Close();

 	test.End();

 	return 0;

 	}

 #else

 GLREF_C TInt E32Main()

 	{

 	return 0;

 	}

 #endif