// Copyright (c) 2005-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\bench\d_kernasmbm.cpp

// Device driver providing benchmarking for assmblerised kernel routines

// 

//

#include <kernel/kern_priv.h>

#include <kernel/cache.h>

#include "d_kernasmbm.h"

#include "d_kernbm.h"

RPointerArray<TKernelBenchmark> KernelBenchmarks;

// TKernelBenchmark ////////////////////////////////////////////////////////////

TKernelBenchmark::TKernelBenchmark(const TDesC8& aName)

	{

	iInfo.iName = aName;

	iInfo.iCategories = KCategoryGeneral;

	iInfo.iAlignStep = 0;

	KernelBenchmarks.Append(this);  // Ignores rc

	}

TKernelBenchmark::TKernelBenchmark(const TDesC8& aName, TInt aAlignStep)

	{

	iInfo.iName = aName;

	iInfo.iCategories = KCategoryGeneral | KCategoryMemory;

	iInfo.iAlignStep = aAlignStep;

	KernelBenchmarks.Append(this);  // Ignores rc

	}

const TBmInfo& TKernelBenchmark::Info() const

	{

	return iInfo;

	}

TInt TKernelBenchmark::Run(const TBmParams& aParams, TInt& aResult)

	{

	TUint init, final;

	init = NKern::FastCounter();

	DoRun(aParams);

	final = NKern::FastCounter();

	aResult = final - init;

	return KErrNone;

	}

// TThreadedBenchmark //////////////////////////////////////////////////////////

TThreadedBenchmark::TThreadedBenchmark(const TDesC8& aName, TInt aRelPri) :

	TKernelBenchmark(aName), iRelPri(aRelPri)

	{

	}

TInt TThreadedBenchmark::Run(const TBmParams& aParams, TInt& aResult)

	{

	iIts = aParams.iIts;

	iThread1 = &Kern::CurrentThread();

	SThreadCreateInfo info;

	info.iType=EThreadSupervisor;

	info.iFunction=Thread2Func;

	info.iPtr=this;

	info.iSupervisorStack=NULL;

	info.iSupervisorStackSize=0;	// zero means use default value

	info.iInitialThreadPriority=iThread1->iNThread.iPriority + iRelPri;

	info.iName.Set(_L("bmthread"));

	info.iTotalSize = sizeof(info);

	NKern::ThreadEnterCS();

	TInt r = Kern::ThreadCreate(info);

	NKern::ThreadLeaveCS();

	if (r != KErrNone)

		return r;

	iThread2 = (DThread*)info.iHandle;

	return TKernelBenchmark::Run(aParams, aResult);

	}

TInt TThreadedBenchmark::Thread2Func(TAny* aPtr)

	{

	TThreadedBenchmark* self = (TThreadedBenchmark*)aPtr;

	self->DoRun2(self->iIts);

	return KErrNone;

	}

// Device driver implementation ////////////////////////////////////////////////

class DKernAsmBmFactory : public DLogicalDevice

	{

public:

	virtual TInt Install();						//overriding pure virtual

	virtual void GetCaps(TDes8& aDes) const;	//overriding pure virtual

	virtual TInt Create(DLogicalChannelBase*& aChannel);

	};

class DKernAsmBm : public DLogicalChannel

	{

public:

	virtual ~DKernAsmBm();

	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

	virtual void HandleMsg(TMessageBase *aMsg);

	};

TInt DKernAsmBmFactory::Install()

    {

    return(SetName(&KKernAsmBmLddName));

    }

void DKernAsmBmFactory::GetCaps(TDes8& /*aDes*/) const

    {

    }

TInt DKernAsmBmFactory::Create(DLogicalChannelBase*& aChannel)

	{

	aChannel = new DKernAsmBm;

	if(!aChannel)

		return KErrNoMemory;

	return KErrNone;

	}

DECLARE_STANDARD_LDD()

	{

    return new DKernAsmBmFactory;

    }

DKernAsmBm::~DKernAsmBm()

	{

	CloseData();

	}

TInt DKernAsmBm::DoCreate(TInt /*aUnit*/, const TDesC8* /*anInfo*/, const TVersion& /*aVer*/)

    {

	return InitData();

	}

TInt DKernAsmBm::Request(TInt aFunction, TAny* a1, TAny* a2)

    {

	TInt index = aFunction >> 8;

	aFunction &= 0xff;

	if (aFunction != RKernAsmBmLdd::ECount && (index < 0 || index >= KernelBenchmarks.Count()))

		return KErrArgument;

	switch (aFunction)

		{

		case RKernAsmBmLdd::ECount:

			return KernelBenchmarks.Count();

		case RKernAsmBmLdd::EInfo:

			{

			TPckgC<TBmInfo> info(KernelBenchmarks[index]->Info());

			return Kern::ThreadDesWrite(&Kern::CurrentThread(), a1, info, 0, 0, NULL);

			}

		case RKernAsmBmLdd::ERun:

			{

			TPckgBuf<TBmParams> params;

			Kern::ThreadDesRead(&Kern::CurrentThread(), a1, params, 0, 0);			

			UserPtr = (TUint8*)ALIGN_ADDR(a2);

			TInt delta;

			TInt r = KernelBenchmarks[index]->Run(params(), delta);

			if (r == KErrNone)

				r = Kern::ThreadRawWrite(&Kern::CurrentThread(), a2, &delta, sizeof(TInt));

			return r;

			}

		default:

			return KErrArgument;

		}

	}

void DKernAsmBm::HandleMsg(TMessageBase* /*aMsg*/)

	{

	}