/*

* 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_PRI_SAMPLER_H

#define PROFILER_PRI_SAMPLER_H

#include "GeneralsConfig.h"

#include <kern_priv.h>

#include <piprofiler/ProfilerGenericClassesKrn.h>

#include <piprofiler/ProfilerTraces.h>

#include "GppSamplerImpl.h"

// defines the maximum thread amount that is assumed to

// be possible with PRI trace

const TInt KProfilerMaxThreadAmount = 512;

/*

 *	

 *	PRI sampler definition

 *	

 */

class DPriSamplerImpl //: public DBase

{

public:

	enum EProcessingState

	{

		EStartingToProcess,

		EProcessingNames,

		EProcessingData,

		ENothingToProcess

	};

	DPriSamplerImpl();

	~DPriSamplerImpl();

	TInt	CreateFirstSample();

	TInt	SampleImpl();

	TBool	SampleNeeded();

	void	Reset();

	TInt	ProcessChunks();

	TInt	EncodeChunkData(DThread& thread);

	TInt	EncodeChunkName(DThread& thread);

	TInt	EncodeNameCode();

	TInt	EncodeDataCode();

	TInt		iCountti;

	DThread*	threadsToSample[KProfilerMaxThreadAmount];

	DThread*	threadNamesToReport[KProfilerMaxThreadAmount];

	TInt		iThreadCount;

	TInt		iNewThreadCount;

	TInt		iProcessing;

	TInt		iPriSamplingPeriod;

	TUint8		sample[257];

	TPtr8		sampleDescriptor;

#ifdef __SMP__

    TInt        iCpuNumber;

    TUint32     iStartTime;

#endif   

};

template <int BufferSize>

class DProfilerPriSampler : public DProfilerGenericSampler<BufferSize>

{

public:

	DProfilerPriSampler(struct TProfilerGppSamplerData*, TInt id);

	~DProfilerPriSampler();

	void	Sample();

	TInt	Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset);

	TInt	PostSample();

	TBool	PostSampleNeeded();

private:

	DPriSamplerImpl				 	priSamplerImpl;

	struct TProfilerGppSamplerData* 	    gppSamplerData;

	TBool						 	sampleNeeded;

	TBool							sampleInProgress;

#ifdef __SMP__

    TInt   iCpuNumber;

#endif

};

/*

 *	

 *	PRI sampler implementation

 *	

 */

//#ifndef __SMP__

template <int BufferSize>

DProfilerPriSampler<BufferSize>::DProfilerPriSampler(struct TProfilerGppSamplerData* gppSamplerDataIn, TInt id) :

	DProfilerGenericSampler<BufferSize>(PROFILER_PRI_SAMPLER_ID)

    {

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

	this->gppSamplerData = gppSamplerDataIn;

	this->sampleInProgress = false;

	this->iSamplingPeriod = 3000;	// set default setting

    }

//#else

//template <int BufferSize>

//DProfilerPriSampler<BufferSize>::DProfilerPriSampler(struct TProfilerGppSamplerData* gppSamplerDataIn, TInt id, TInt aCpuNumber) :

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

//    {

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

//    }

//#endif

template <int BufferSize>

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

    {

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

	DProfilerGenericSampler<BufferSize>::Reset(aStream);

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

	priSamplerImpl.Reset();

#ifdef __SMP__

//    this->priSamplerImpl.iCpuNumber = this->iCpuNumber;

//    

//    // set common start time for all CPU samplers

//    this->priSamplerImpl.iStartTime = aSyncOffset;

#endif

	this->priSamplerImpl.iPriSamplingPeriod = this->iSamplingPeriod;

	LOGSTRING3("CProfilerPriSampler<%d>::Reset - set pri sampling period to", 

							BufferSize,this->priSamplerImpl.iPriSamplingPeriod);

	TInt length(priSamplerImpl.CreateFirstSample());

	this->iSampleBuffer->AddSample(priSamplerImpl.sample,length);

	this->sampleInProgress = false;	

	this->sampleNeeded = false;

	return KErrNone;

    }

template <int BufferSize> 

TInt DProfilerPriSampler<BufferSize>::PostSample()

    {

	if(sampleNeeded)

	    {

		this->sampleNeeded = false;

		LOGSTRING3("CProfilerPriSampler<%d>::PostSample - state %d",BufferSize,this->sampleBuffer->GetBufferStatus());

		//TInt interruptLevel = NKern::DisableInterrupts(0);

		TInt length(this->priSamplerImpl.SampleImpl());

		if(length != 0)

		    {

			LOGSTRING("PRI sampler PostSample - starting to sample");

			// then, encode the sample to the buffer

			while(length > 0)

			    {

			    this->iSampleBuffer->AddSample(priSamplerImpl.sample,length);

				length = this->priSamplerImpl.SampleImpl();

				// indicate that the whole PRI sample ends by having a 0x00 in the end

				if(length == 0)

				    {

					TUint8 number(0);

					LOGSTRING("PRI sampler PostSample - all samples generated!");

					this->iSampleBuffer->AddSample(&number,1);

					LOGSTRING("PRI sampler PostSample - end mark added");

                    }

			    }

			LOGSTRING("PRI sampler PostSample - finished sampling");

		    }

		this->sampleInProgress = false;

		//NKern::RestoreInterrupts(interruptLevel);

	    }

	// finally perform superclass postsample

	TInt i(this->DProfilerGenericSampler<BufferSize>::PostSample());

	return i; 

    }

template <int BufferSize> 

TBool DProfilerPriSampler<BufferSize>::PostSampleNeeded()

    {

	LOGSTRING3("CProfilerPriSampler<%d>::PostSampleNeeded - state %d",BufferSize,this->sampleBuffer->GetBufferStatus());

	TUint32 status = this->iSampleBuffer->iBufferStatus;

	if(status == DProfilerSampleBuffer::BufferCopyAsap || status == DProfilerSampleBuffer::BufferFull || this->sampleNeeded == true)

	    {

		return true;

	    }

	return false;

    }

template <int BufferSize>

void DProfilerPriSampler<BufferSize>::Sample()

    {

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

	if(priSamplerImpl.SampleNeeded() && this->sampleInProgress == false) 

	    {

		this->sampleInProgress = true;

		this->sampleNeeded = true;

		// start the PRI sample with the sample time

		TUint8 number(4);

		this->iSampleBuffer->AddSample(&number,1);

		this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);

		// leave the rest of the processing for PostSample()

	    }	

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

	return;

    }

template <int BufferSize>

DProfilerPriSampler<BufferSize>::~DProfilerPriSampler()

    {

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

    }

#endif