/*

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

#define PROFILER_ITT_SAMPLER_H

#include "GeneralsConfig.h"

#include <kern_priv.h>

#include <piprofiler/ProfilerGenericClassesKrn.h>

#include <piprofiler/ProfilerTraces.h>

#include "GppSamplerImpl.h"

#include "IttEventHandler.h"

// CONSTANTS

const TInt KITTSampleBufferSize = 256;

// flags

#define ITT_EVENT_HANDLER   // enable event based ITT sampling

/*

 *	

 *	ITT sampler definition

 *	

 */

class DIttEventHandler;

/*

 * User side ITT sampler

 */

class IttSamplerImpl

{

public:

	IttSamplerImpl();

	~IttSamplerImpl();

	TInt	SampleImpl(TUint32 pc,TUint32 sampleNum);

	TBool	SampleNeeded(TUint32 sampleNum);

	TInt 	CreateFirstSample();

	void	Reset();

	TInt    ProcessEvent();

	TUint8*         itt_sample;

	TInt            iIttSamplingPeriod;

	TInt            iIttSamplingPeriodDiv2;

	TBool           iTimeToSample;

#ifdef ITT_EVENT_HANDLER

    TBool           iEventReceived;

    TBool           iFirstSampleTaken;

#endif

private:

#ifdef ITT_EVENT_HANDLER    

    TInt            iCount;

#endif

    TInt            currentLibCount;

    TInt            currentProcCount;

	TUint8          sample[KITTSampleBufferSize ];

	TPtr8           sampleDescriptor;

	TBuf8<64>		iVersionData;

	SDblQue* 		codeSegList;

};

/*

 * ITT sampler kernel part

 * 

 */

template <int BufferSize>

class DProfilerIttSampler : public DProfilerGenericSampler<BufferSize>

{

public:

	DProfilerIttSampler(struct TProfilerGppSamplerData* gppSamplerDataIn);

	~DProfilerIttSampler();

	void	Sample();

	TInt	Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset);

	TInt	PostSample();

	TBool	PostSampleNeeded();

private:

#ifdef ITT_EVENT_HANDLER

    DIttEventHandler*               iEventHandler;

#endif

	IttSamplerImpl					ittSamplerImpl;

	struct TProfilerGppSamplerData*     gppSamplerData;

	TBool							sampleInProgress;

	TBool							sampleNeeded;

};

/*  

 *	ITT sampler implementation

 *	

 */ 

template <int BufferSize>

DProfilerIttSampler<BufferSize>::DProfilerIttSampler(struct TProfilerGppSamplerData* gppSamplerDataIn) :

	DProfilerGenericSampler<BufferSize>(PROFILER_ITT_SAMPLER_ID)

{

	this->gppSamplerData = (struct TProfilerGppSamplerData*)gppSamplerDataIn;

	this->sampleInProgress = false;

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

}

/*

 *  DProfilerIttSampler::Reset()

 *  

 *  @param DProfilerSampleStream* sample stream

 *  @param TUint32 Offset 

 */

template <int BufferSize>

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

{

    Kern::Printf("DProfilerIttSampler<%d>::Reset - calling superclass reset",BufferSize);

    DProfilerGenericSampler<BufferSize>::Reset(aStream);

    // check if reset called in stop (by driver)

    if(aSyncOffset != 999999)

        {

#ifdef ITT_EVENT_HANDLER

        // Itt event handler

        if(iEventHandler)

            {

            // stop previous sampling if still running

            Kern::Printf("Stopping DIttEventHandler");

            iEventHandler->Stop();

            iEventHandler->Close();

            iEventHandler = NULL;

            }

        Kern::Printf("Initiating DIttEventHandler");

        iEventHandler = new DIttEventHandler(this->iSampleBuffer, this->gppSamplerData);

        if(iEventHandler)

            {

            Kern::Printf("Creating DIttEventHandler");

            TInt err(iEventHandler->Create());

            if(err != KErrNone)

                {

                Kern::Printf("Error in creation of DIttEventHandler, error %d", err);

                return err;

                }

            }

        else

            {

            Kern::Printf("Could not initiate DIttEventHandler");

            return KErrGeneral;

            }

        // set first sample at the 10 ms, should be enough

        this->ittSamplerImpl.iIttSamplingPeriod = 10;

#else

        this->ittSamplerImpl.iIttSamplingPeriod = this->iSamplingPeriod;

#endif

        this->ittSamplerImpl.iIttSamplingPeriodDiv2 = (TInt)(this->ittSamplerImpl.iIttSamplingPeriod / 2);

        LOGSTRING3("CProfilerIttSampler<%d>::Reset - set ITT sampling period to %d",

                                BufferSize,this->ittSamplerImpl.iIttSamplingPeriod);

        }

    else

        {

        LOGSTRING2("DProfilerIttSampler<%d>::Reset - reset in stop", BufferSize);

#ifdef ITT_EVENT_HANDLER

        // destroy memory event handler

        if(iEventHandler)

            {

            // stop previous sampling if still running

            iEventHandler->Stop();

            iEventHandler->Close();

            iEventHandler = NULL;

            }

#endif

        return KErrNone;    // return if reset called in stop

        }

    TInt length(ittSamplerImpl.CreateFirstSample());

    this->iSampleBuffer->AddSample((TUint8*)&length,1);

    this->iSampleBuffer->AddSample(ittSamplerImpl.itt_sample, length);

    this->sampleInProgress = false;

    this->sampleNeeded = false;

    //LOGSTRING("DProfilerIttSampler::Reset - exit");

	this->ittSamplerImpl.Reset();

    return KErrNone;

}

/*

 * DProfilerIttSampler::PostSample

 * 

 * Function for finishing sample

 */

template <int BufferSize> 

TInt DProfilerIttSampler<BufferSize>::PostSample()

{

#ifdef ITT_EVENT_HANDLER

    if(!ittSamplerImpl.iFirstSampleTaken)   // if we haven't read the initial state

    {

#endif

        if(sampleNeeded)

        {

            this->sampleNeeded = false;

            //LOGSTRING3("CProfilerIttSampler<%d>::PostSample - state %d",BufferSize,this->iSampleBuffer->GetBufferStatus());

            //Kern::Printf("DProfilerIttSampler<%d>::PostSample - state %d",BufferSize,this->iSampleBuffer->GetBufferStatus());

            TInt length = this->ittSamplerImpl.SampleImpl(this->gppSamplerData->lastPcValue,

                                                          this->gppSamplerData->sampleNumber);

            if(length != 0)

            {		

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

                while(length > 0)

                {

                    this->iSampleBuffer->AddSample(ittSamplerImpl.itt_sample,length);

                    length = this->ittSamplerImpl.SampleImpl( this->gppSamplerData->lastPcValue,

                                                          this->gppSamplerData->sampleNumber );	

                    if(length == 0) 

                    {

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

                    }

                }

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

            }

            this->sampleInProgress = false;

        }

#ifdef ITT_EVENT_HANDLER

    }   

        if(!iEventHandler->Tracking())

            {

            iEventHandler->Start();

            Kern::Printf("DProfilerITTSampler<%d>::PostSample - ITT handler started",BufferSize);

            }

#endif    

    LOGSTRING2("ITT sampler PostSample - finished sampling, time: %d", gppSamplerData->sampleNumber);

	// finally perform superclass postsample

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

	return i;

}

/*

 *  DProfilerIttSampler::PostSampleNeeded()

 *  

 *  Function for deciding if sample handling is needed 

 */

template <int BufferSize> 

TBool DProfilerIttSampler<BufferSize>::PostSampleNeeded()

{

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

	TUint32 status = this->iSampleBuffer->iBufferStatus;

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

	{

		return true;

	}

	return false;

}

/*

 * DProfilerIttSampler::Sample

 * 

 * Function for initiating sampling

 */

template <int BufferSize>

void DProfilerIttSampler<BufferSize>::Sample()

{

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

	//#ifdef ITT_TEST

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

	if(ittSamplerImpl.SampleNeeded(this->gppSamplerData->sampleNumber) && this->sampleInProgress == false) 

	{

		this->sampleInProgress = true;

		this->sampleNeeded = true;

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

	}	

#ifdef ITT_EVENT_HANDLER

    // call this to increase the time stamp

    else if(iEventHandler->SampleNeeded())

        {

        // set the flag for post sampling

        this->sampleNeeded = true;

        }

#endif

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

	return;

}

/*

 * Destructor

 */

template <int BufferSize>

DProfilerIttSampler<BufferSize>::~DProfilerIttSampler()

{

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

#ifdef ITT_EVENT_HANDLER

     if(iEventHandler)

         {

         // stop previous sampling if still running

         iEventHandler->Stop();

         iEventHandler->Close();

         iEventHandler = NULL;

         }

#endif

}

#endif

// end of file