// 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*/)
	{
	}