/*

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

#define PROFILER_MEM_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 MEM trace

#define PROFILER_MAX_THREAD_AMOUNT	512

/*

 *	

 *	MEM sampler definition

 *	

 */

class MemSamplerImpl

{

public:

	enum EProcessingState

	{

		EStartingToProcess,

		EProcessingNames,

		EProcessingData,

		ENothingToProcess

	};

	MemSamplerImpl();

	~MemSamplerImpl();

	TInt	CreateFirstSample();

	TInt	SampleImpl();

	TBool	SampleNeeded();

	void	Reset();

	TInt	ProcessChunks();

	TInt    ProcessThreads();

    TInt    GatherChunks();

    TInt    GatherThreads();

	TInt	EncodeChunkData(DChunk& chunk);

	TInt	EncodeChunkName(DChunk& chunk);

	TInt	EncodeChunkData(DThread& thread);

	TInt	EncodeChunkName(DThread& thread);	

	TInt 	EncodeTotalMemoryName();

	TInt 	EncodeTotalMemory();

	TInt	EncodeNameCode();

	TInt	EncodeDataCode();

	DChunk*		heapChunksToSample[PROFILER_MAX_THREAD_AMOUNT];

	DChunk*		heapChunkNamesToReport[PROFILER_MAX_THREAD_AMOUNT];

	TInt		iCount;

	TInt		iChunkCount;

	TInt		iNewChunkCount;

	TBuf8<0x50> name;

	DThread*	threadsToSample[PROFILER_MAX_THREAD_AMOUNT];

	DThread*	threadNamesToReport[PROFILER_MAX_THREAD_AMOUNT];

	TInt		iThreadCount;

	TInt		iNewThreadCount;

	TInt		iChunksProcessing;

    TInt        iThreadsProcessing;

	TInt		iMemSamplingPeriod;

	TInt		iMemSamplingPeriodDiv2;

	TBool		iSampleThreads;

	TBool       iTimeToSample;

	TBool 		iTotalMemoryOk;

	TBool		iTotalMemoryNameOk;

	TUint8		sample[257];

	TPtr8		sampleDescriptor;

};

template <int BufferSize>

class DProfilerMemSampler : public DProfilerGenericSampler<BufferSize>

{

public:

	DProfilerMemSampler(struct TProfilerGppSamplerData*, TInt id);

	~DProfilerMemSampler();

	void	Sample();

	TInt	Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset);

	TInt	PostSample();

	TBool	PostSampleNeeded();

private:

	MemSamplerImpl			           memSamplerImpl;

	struct TProfilerGppSamplerData*    gppSamplerData;

	TBool                              sampleNeeded;

};

/*

 *	

 *	MEM sampler implementation

 *	

 */

template <int BufferSize>

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

	DProfilerGenericSampler<BufferSize>(PROFILER_MEM_SAMPLER_ID)

    {

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

	this->gppSamplerData = gppSamplerDataIn;

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

    }

template <int BufferSize>

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

    {

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

	DProfilerGenericSampler<BufferSize>::Reset(aStream);

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

	memSamplerImpl.Reset();

	this->memSamplerImpl.iMemSamplingPeriod = this->iSamplingPeriod;

	this->memSamplerImpl.iMemSamplingPeriodDiv2 = (TInt)(this->memSamplerImpl.iMemSamplingPeriod / 2);

	LOGSTRING3("CProfilerMemSampler<%d>::Reset - set mem sampling period to",

							BufferSize,this->memSamplerImpl.iMemSamplingPeriod);

	TInt length = memSamplerImpl.CreateFirstSample();

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

	this->sampleNeeded = false;

	return KErrNone;

    }

template <int BufferSize> 

TInt DProfilerMemSampler<BufferSize>::PostSample()

    {

    this->sampleNeeded = false;

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

    TInt interruptLevel = NKern::DisableInterrupts(0);

    // first collect chunk data

    TInt length = this->memSamplerImpl.SampleImpl();

    if(length != 0)

        {

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

        // then, encode the sample to the buffer

        while(length > 0)

            {

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

            length = this->memSamplerImpl.SampleImpl();

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

            if(length == 0)

                {

                TUint8 number = 0;

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

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

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

                }

            }

        }

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

    NKern::RestoreInterrupts(interruptLevel);

    // finally perform superclass postsample

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

	return i;

    }

template <int BufferSize> 

TBool DProfilerMemSampler<BufferSize>::PostSampleNeeded()

    {

	LOGSTRING3("CProfilerMemSampler<%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 DProfilerMemSampler<BufferSize>::Sample()

    {

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

	if(memSamplerImpl.SampleNeeded()) 

	    {

		this->sampleNeeded = true;

		LOGSTRING2("CProfilerMemSampler<%d>::Sample - sample needed",BufferSize);	

		// start the MEM sample with the sample time

		TUint8 number = 4;    // mem sampler id

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

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

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

	    }	

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

	return;

    }

template <int BufferSize>

DProfilerMemSampler<BufferSize>::~DProfilerMemSampler()

    {

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

    }

#endif