// Copyright (c) 2002-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\t_smpsoakspin.cpp
//

#define __E32TEST_EXTENSION__
#include <e32test.h>
#include <u32hal.h>
#include <f32file.h>


#include "d_smpsoak.h"

#define PRINT(string) if (!gQuiet) test.Printf(string)
#define PRINT1(string,param) if (!gQuiet) test.Printf(string,param)
#define TESTNEXT(string) if (!gQuiet) test.Next(string)

#define DEBUG_PRINT(__args)		test.Printf __args

//------------globals---------------------
LOCAL_D RTest test(_L("T_SMPSOAKSPIN"));
LOCAL_D TBool gQuiet = EFalse;
LOCAL_D TBool gAbort = EFalse;

TInt		TestCpuCount = 0;

const TInt KTimerPeriod = 10000;

const TInt KHeapMinSize=0x1000;
const TInt KHeapMaxSize=0x1000;

// Create a new thread
RThread *spinthread = new RThread;

//Periadic Bip
CPeriodic*	Timer;

TInt SMPSpinThread(TAny*);


struct TThread
	{
	RThread thread;
	TDesC threadName;
	TInt threadPriority;
	TInt cpuAffinity;
	TInt loopCount;
	TInt endLoopDelay;
	TBool fixedCPU;
	TBool endFlag;
	};

TThread ThreadTable[] =
	{
		{ RThread(), _L("Thread1"),  EPriorityAbsoluteHigh,     0, 1000, 100, EFalse,    EFalse}, 	
		{ RThread(), _L("Thread2"),  EPriorityAbsoluteHigh,     0, 1000, 100, EFalse,    EFalse}, 	 
	};

enum 
	{
	KThreads = (TInt)(sizeof(ThreadTable) / sizeof(TThread))
};

void ShowHelp()
	{
	PRINT(_L("***************************************\n"));
	PRINT(_L("The following are available commands\n"));
	PRINT(_L("Esc     to exit\n"));
	PRINT(_L("***************************************\n"));
	}

TInt NumberOfCpus()
	{
	TInt r = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);
	test(r>0);
	return r;
	}


void ParseCommandLine ()
	{
	TBuf<64> c;
	
	User::CommandLine(c);
	c.LowerCase();

	if (c != KNullDesC)
		{
		TLex lex(c);
		TPtrC token;

		while (token.Set(lex.NextToken()), token != KNullDesC)
			{
			if (token.Mid(0) == _L("quiet"))
				{
				gQuiet = ETrue;
				continue;
				}

			if (token.Mid(0) == _L("verbose"))
				{
				gQuiet = EFalse;
				continue;
				}
			}
		}
	}

// CActive class to monitor KeyStrokes from User
class CActiveConsole : public CActive
	{
public:
	CActiveConsole();
	~CActiveConsole();
	void GetCharacter();
	static TInt Callback(TAny* aCtrl);
	static CPeriodic* TimerL();
private:

	
	// Defined as pure virtual by CActive;
	// implementation provided by this class.
	virtual void DoCancel();
	// Defined as pure virtual by CActive;
	// implementation provided by this class,
	virtual void RunL();
	void ProcessKeyPressL(TChar aChar);
	};

// Class CActiveConsole
CActiveConsole::CActiveConsole()
	: CActive(EPriorityHigh)
	{
	CActiveScheduler::Add(this);
	}

CActiveConsole::~CActiveConsole()
	{
    Cancel();
	}

CPeriodic* CActiveConsole::TimerL()
    {
    return(CPeriodic::NewL(EPriorityNormal));
    }

// Callback function for timer expiry
TInt CActiveConsole::Callback(TAny* aControl)
	{
	return KErrNone;
	}

void CActiveConsole::GetCharacter()
	{
	test.Console()->Read(iStatus);
	SetActive();
	}

void CActiveConsole::DoCancel()
	{
	PRINT(_L("CActiveConsole::DoCancel\n"));
	test.Console()->ReadCancel();
	}

void CActiveConsole::ProcessKeyPressL(TChar aChar)
	{
	if (aChar == EKeyEscape)
		{
		PRINT(_L("CActiveConsole: ESC key pressed -> stopping active scheduler...\n"));
		CActiveScheduler::Stop();
		return;
		}
	aChar.UpperCase();
	GetCharacter();
	}

void CActiveConsole::RunL()
	{
	ProcessKeyPressL(static_cast<TChar>(test.Console()->KeyCode()));
	}

TInt E32Main()
	{
	test.Title();
	__UHEAP_MARK;
	test.Start(_L("SMP Soak Test"));

	test.Next(_L("Load device driver"));
	TInt r = User::LoadLogicalDevice(_L("d_smpsoak.ldd"));
	if (r == KErrNotFound)
		{
		test.Printf(_L("Test not supported on this platform because the D_SMPSOAK.LDD Driver is Not Present\n"));
		test.End();
		return 0;
		}

	test.Next(_L("Calling rt.Open"));
	RSMPSoak rt;
	r = rt.Open();
	if (r!=KErrNone)
		{
		test.Printf(_L("Error- Couldn't able to open soak driver:%d"),r);
		return r;
		}
	test.Next(_L("rt.Open called"));

    spinthread->Create(_L("SMPSpinThread"), SMPSpinThread, KDefaultStackSize, KHeapMinSize, KHeapMaxSize, &rt);
	DEBUG_PRINT((_L("SMPSoak Thread is %x\n"), spinthread));

	spinthread->SetPriority(EPriorityAbsoluteLow);

	spinthread->Resume();
	
	ParseCommandLine();
	
	CActiveScheduler* myScheduler = new (ELeave) CActiveScheduler();
	test(myScheduler !=NULL);
	CActiveScheduler::Install(myScheduler);

	CPeriodic* theTimer=NULL;
	TRAPD(ret,theTimer=CActiveConsole::TimerL())
	test_KErrNone(ret);
	theTimer->Start(0,KTimerPeriod,TCallBack(CActiveConsole::Callback));

	CActiveConsole* myActiveConsole = new CActiveConsole();
	test(myActiveConsole !=NULL);
	myActiveConsole->GetCharacter();

	CActiveScheduler::Start();

	delete theTimer;

	 __UHEAP_MARKEND;

	test.End();

	return 0;
	}

TInt SMPSpinThread(TAny* rt)
{
	TInt startCpu = 0x00;
	TInt endCpu = 0x00;
	RTimer timer;
	test(timer.CreateLocal()==KErrNone);
	TRequestStatus s;

	RSMPSoak* pMyDriver = (RSMPSoak*)rt;
	RTest test(_L("SMPSpinThread"));
	test.Title();

	FOREVER
	{
		startCpu = pMyDriver->TryControl(RSMPSoak::KGETCURRENTCPU, 0);
		
		timer.After(s, 250000);			
		User::WaitForRequest(s);
		test(s==KErrNone);
		DEBUG_PRINT((_L("+")));

		endCpu = pMyDriver->TryControl(RSMPSoak::KGETCURRENTCPU, 0);
		
		if(startCpu != endCpu)
		{
			DEBUG_PRINT((_L("\r\nSMPSoakSpin app:- Thread moved from cpu %d to cpu %d ************\n"), startCpu, endCpu));
		}
		if (gAbort)
			break;
	}
	
	timer.Cancel();
	DEBUG_PRINT((_L("MyTimer.Cancel() called\n")));
	return 0x00;	
}