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