/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:  

*

*/

#ifndef PROFILER_GPP_SAMPLER_H

#define PROFILER_GPP_SAMPLER_H

#include "GeneralsConfig.h"

#include <e32cmn.h>

#include <piprofiler/ProfilerGenericClassesKrn.h>

#include <piprofiler/ProfilerTraces.h>

// for RPropertyRef

#include <sproperty.h> 

#include <e32cmn.h>

/*

 *	

 *	GPP sampler definition

 *	

 */

class DGppSamplerImpl //: public DBase

{

public:

	DGppSamplerImpl();

	~DGppSamplerImpl();

	TUint8* EncodeTag(TUint8* aPtr);

	TUint8* EncodeInt(TUint8* aPtr,TInt aValue);

	TUint8* EncodeUint(TUint8* aPtr,TUint aValue);

	TUint8* EncodeText(TUint8* aPtr, const TDesC& aDes);

	TUint8* EncodeName(TUint8* aPtr, DObject& aObject,TUint32 id);

	TUint8* EncodeThread(TUint8* aPtr, DThread& aThread);

	TBool	IsaTaskKnown(TUint8 task);

	TUint8* EncodeIsaTask(TUint8* aPtr, TUint task);

	TUint8* EncodeIsaName(TUint8* aPtr, TUint task,TBool process);

	TUint8* EncodeRepeat(TUint8* aPtr);

	TInt	CreateFirstSample();

	TInt	SampleImpl();

#ifdef __SMP__

    TSpinLock* LockPtr();

#endif

    TInt    iGppSamplingPeriod;

	TUint8	tempBuf[512];

	TUint	iLastPc;

	TBool	iIsaSample;

	TInt	knownIsaTasks[256];

	TUint8	knownIsaTaskCount;

	TInt*	isaOsTaskRunningAddr;

	void	Reset();

    TUint32 iSampleCount;

#ifdef __SMP__

    TInt        iCpuNumber;

    TUint32     iStartTime;

#endif	   

	PROFILER_DEFINE_ISA_TASK_NAME_ARRAY

private:

	enum TState {EStop,ERunning,EStopping};

	const TUint* iInterruptStack;

	TUint		iLastThread;

	TUint		iRepeat;

#ifndef __SMP__

	TUint32 	iStartTime;

#endif

	RPropertyRef iIsaStartAddr;

	RPropertyRef iIsaEndAddr;

	RPropertyRef iIsaPluginStatus;

	RPropertyRef iIsaOsTaskRunning;

	TInt 		iIsaStatus;

	TInt 		iIsaStart;

	TInt 		iIsaEnd;

	TUint32     iMask;

	TUint32     iCpuSelector;

};

struct TProfilerGppSamplerData

{

//public:

	TUint32		lastPcValue;

	TUint32		sampleNumber;

    TInt        samplingPeriod;

};

template <int BufferSize>

class DProfilerGppSampler : public DProfilerGenericSampler<BufferSize>

{

public:

#ifndef __SMP__

	DProfilerGppSampler();

#else

    DProfilerGppSampler(TInt aCpuNumber);

#endif

	~DProfilerGppSampler();

	struct TProfilerGppSamplerData* GetExportData();

	void	Sample();

	TInt	Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset);

	TInt 	GetPeriod();

private:

	DGppSamplerImpl gppSamplerImpl;

	struct TProfilerGppSamplerData exportData;

#ifdef __SMP__

	TInt   iCpuNumber;

#endif

};

/*

 *	

 *	GPP sampler implementation

 *	

 */

#ifndef __SMP__

template <int BufferSize>

DProfilerGppSampler<BufferSize>::DProfilerGppSampler() :

	DProfilerGenericSampler<BufferSize>(PROFILER_GPP_SAMPLER_ID) 

    {

	LOGSTRING2("CProfilerGppSampler<%d>::CProfilerGppSampler",BufferSize);

    }

#else

template <int BufferSize>

DProfilerGppSampler<BufferSize>::DProfilerGppSampler(TInt aCpuNumber) :

    DProfilerGenericSampler<BufferSize>(PROFILER_GPP_SAMPLER_ID+(aCpuNumber*20)), iCpuNumber(aCpuNumber) 

    {

    LOGSTRING2("CProfilerGppSampler<%d>::CProfilerGppSampler",BufferSize);

    }

#endif

template <int BufferSize>

DProfilerGppSampler<BufferSize>::~DProfilerGppSampler()

    {

	LOGSTRING2("CProfilerGppSampler<%d>::~CProfilerGppSampler",BufferSize);		

    }

template <int BufferSize>

TInt DProfilerGppSampler<BufferSize>::Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset)

        {

	LOGSTRING2("CProfilerGppSampler<%d>::Reset - calling superclass reset",BufferSize);

	DProfilerGenericSampler<BufferSize>::Reset(aStream, 0);

	LOGSTRING2("CProfilerGppSampler<%d>::Reset - called superclass reset",BufferSize);

	this->gppSamplerImpl.Reset();

#ifdef __SMP__

	this->gppSamplerImpl.iCpuNumber = this->iCpuNumber;

	// set common start time for all CPU samplers

	this->gppSamplerImpl.iStartTime = aSyncOffset;

#endif

	this->gppSamplerImpl.iGppSamplingPeriod = this->iSamplingPeriod;

	this->gppSamplerImpl.iSampleCount = 0;

	this->exportData.sampleNumber = 0;

	this->exportData.lastPcValue = 0;

    this->exportData.samplingPeriod = this->gppSamplerImpl.iGppSamplingPeriod;

	TInt length = gppSamplerImpl.CreateFirstSample();

	LOGSTRING3("CProfilerGPPSampler<%d>::Reset - got first sample, size %d",BufferSize,length);	

	this->iSampleBuffer->AddSample(gppSamplerImpl.tempBuf,length);

	// check if sampling period > 1 ms

	// NOTE: feature supported in Performance Investigator 2.01 and above

	if(this->gppSamplerImpl.iGppSamplingPeriod > 1)

	    {

        // For Address/Thread (GPP) version 2.01 or above, the first word is the sampling period in milliseconds

        TUint8* w = gppSamplerImpl.tempBuf;

        (*w++) = (this->gppSamplerImpl.iGppSamplingPeriod >> 24) & 0xFF;

        (*w++) = (this->gppSamplerImpl.iGppSamplingPeriod >> 16) & 0xFF;

        (*w++) = (this->gppSamplerImpl.iGppSamplingPeriod >>  8) & 0xFF;

        (*w++) = (this->gppSamplerImpl.iGppSamplingPeriod) & 0xFF;

        this->iSampleBuffer->AddSample(gppSamplerImpl.tempBuf,4);

	    }

	LOGSTRING2("CProfilerGPPSampler<%d>::Reset finished",BufferSize);

	return KErrNone;

    }

template <int BufferSize>

void DProfilerGppSampler<BufferSize>::Sample()

    {

	LOGSTRING2("CProfilerGppSampler<%d>::Sample",BufferSize);

//	if(this->gppSamplerImpl.iSampleCount % 1000 == 0) 

//	    {

//#ifdef __SMP__

//	    if(this->iCpuNumber == 0)  // print sample tick only from CPU 0 context

//	        {

//#endif

//	        Kern::Printf(("PIPROF SAMPLE TICK, #%d"),exportData.sampleNumber);

//#ifdef __SMP__

//	        }

//#endif

//	    }

	TInt length(gppSamplerImpl.SampleImpl());

    this->gppSamplerImpl.iSampleCount++;

	this->exportData.sampleNumber += this->gppSamplerImpl.iGppSamplingPeriod;

	this->exportData.lastPcValue = gppSamplerImpl.iLastPc;

	if(length > 0)

        {

        this->iSampleBuffer->AddSample(gppSamplerImpl.tempBuf,length);

        }

	LOGSTRING3("CProfilerGppSampler<%d>::Sample - length %d",BufferSize,length);

	return;

    }

template <int BufferSize>

struct TProfilerGppSamplerData* DProfilerGppSampler<BufferSize>::GetExportData()

    {

	LOGSTRING2("CProfilerGppSampler<%d>::GetExportData",BufferSize);

	return &(this->exportData);	

    }

template <int BufferSize>

TInt DProfilerGppSampler<BufferSize>::GetPeriod()

    {

	return this->gppSamplerImpl.iGppSamplingPeriod;

    }

#endif