/*

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

*

*/

#include <piprofiler/ProfilerVersion.h>

#include <piprofiler/ProfilerTraces.h>

#include <kern_priv.h>

#include <plat_priv.h>

#include "PriSamplerImpl.h"

#if !defined(__NKERN_H__)

#include <nkern.h>

#endif 

#define TAG(obj) (*(TUint32*)&(obj->iAsyncDeleteNext))

#define PROFILER_THREAD_MARK		((TUint32)0x00000002)

DPriSamplerImpl::DPriSamplerImpl() :

	sampleDescriptor(&(this->sample[1]),0,256)

    {

	LOGTEXT("PriSamplerImpl::PriSamplerImpl() - konstruktori");

	iCountti = 50;	// sample threads 16 cycles before actual MEM and PRI sample time...

	iNewThreadCount = 0;

	iThreadCount = 0;

	iProcessing = ENothingToProcess;

	for(TInt i=0;i<KProfilerMaxThreadAmount;i++)

	    {

		this->threadsToSample[i] = 0;

		this->threadNamesToReport[i] = 0;

        }

    }

DPriSamplerImpl::~DPriSamplerImpl()

    {

    }

TInt DPriSamplerImpl::CreateFirstSample()

    {

	LOGTEXT("PriSamplerImpl::CreateFirstSample - entry");

	this->sampleDescriptor.Zero();

	this->sampleDescriptor.Append(_L8("Bappea_V"));

	this->sampleDescriptor.Append(PROFILER_PRI_SAMPLER_VERSION);

	this->sampleDescriptor.Append(_L8("_PRI"));

	sample[0] = this->sampleDescriptor.Size();

	LOGTEXT("PriSamplerImpl::CreateFirstSample - exit");

	return (TInt)(sample[0]+1);

    }

TBool DPriSamplerImpl::SampleNeeded()

    {

	iCountti++;

	if(iCountti % (iPriSamplingPeriod) == 0) 

	    {

		LOGTEXT("PriSamplerImpl::SampleNeeded - true");

		return true;

        }

	else 

	    {

		return false;

        }

    }

TInt DPriSamplerImpl::SampleImpl()

    {

	/*

	 *

	 *	EKA-2 implementation of PRI trace

	 *

	 */

	if(this->iProcessing == ENothingToProcess)

	    {

	    if((iCountti % iPriSamplingPeriod) != 0 ) return 0;

        LOGTEXT("Processing threads...");

        DObjectCon& threads = *Kern::Containers()[EThread];

        // PRI trace variables

        this->iThreadCount = 0; 

        this->iNewThreadCount = 0;

        TInt totalThreadCount = threads.Count();

        for(TInt i=0;i<totalThreadCount;i++)

            {

            DThread* t = (DThread*)(threads)[i];

            LOGSTRING3("Processing thread %d, tag: 0x%x",i,TAG(t));

            if( (TAG(t) & PROFILER_THREAD_MARK) == 0)

                {

                LOGSTRING2("Marking thread %d",i);

                // this thread's chunk has not been reported yet

                this->threadNamesToReport[iNewThreadCount] = t;

                iNewThreadCount++;

                // tag the thread

                TAG(t) |= PROFILER_THREAD_MARK;

                LOGSTRING2("New Thread %d",i);

                }

            else

                {

                LOGSTRING3("Thread %d marked already - 0x%x",i,TAG(t));

                }

            // the thread has been tagged, add heap chunks to the list

            this->threadsToSample[this->iThreadCount] = t;

            this->iThreadCount++;

            LOGSTRING2("Added thread %d to threads to sample",i);

            }

        if(this->iThreadCount > 0 || this->iNewThreadCount > 0)

            {

            this->iProcessing = EStartingToProcess;

            // process the first sample

            TInt length = this->ProcessChunks();

            if(length == 0)

                {

                this->iProcessing = ENothingToProcess;

                }

            return length;

            }

        else

            {

            // there were no threads, should not take place

            LOGTEXT("PriSamplerImpl::SampleImpl - Error, no threads"); 

            return 0;

            }

	    }

	else

	    {

		TInt length = this->ProcessChunks();

		if(length == 0) 

		    {

			this->iProcessing = ENothingToProcess;

		    }

		return length;

	    }

    }

inline TInt DPriSamplerImpl::ProcessChunks()

    {

	/*

	 *

	 *	EKA-2 implementation of PRI trace

	 *

	 */

	if(iNewThreadCount > 0)

	    {

		if(this->iProcessing == EStartingToProcess)

		    {

			// this is the first sample, encode a code for names

			this->iProcessing = EProcessingNames;

			return EncodeNameCode();

            }

		// there are new thread names to report

		iNewThreadCount--;

		DThread* t = this->threadNamesToReport[iNewThreadCount];

		return EncodeChunkName(*t);

        }

	else if(iThreadCount > 0)

	    {

		if(this->iProcessing == EProcessingNames || this->iProcessing == EStartingToProcess)

		    {

			// this is the first data sample, encode a code for data

			this->iProcessing = EProcessingData;

			return EncodeDataCode();

            }

		// there are no new chunks to report

		// thus generate the real report

		iThreadCount--;

		DThread* t = this->threadsToSample[iThreadCount];

		LOGSTRING2("PriSamplerImpl::ProcessChunks - starting to process thread 0x%x",t);

		return EncodeChunkData(*t);

        }

	else

	    {

		// everything is processed

		return 0;

        }

    }

inline TInt DPriSamplerImpl::EncodeNameCode()

    {

	sample[0] = 1;

	sample[1] = 0xbb;	// pri trace name code

	return 2;

    }

inline TInt DPriSamplerImpl::EncodeDataCode()

    {

	sample[0] = 1;

	sample[1] = 0xee;	// pri trace data code

	return 2;

    }

inline TInt DPriSamplerImpl::EncodeChunkName(DThread& t)

    {		

	// the size of the following name is in the first byte

	TUint8* size = &sample[0];

	*size = 0;

	this->sampleDescriptor.Zero();

	t.TraceAppendFullName(this->sampleDescriptor,false);

	*size += this->sampleDescriptor.Size();

	// copy the 4 bytes from the thread id field

	this->sampleDescriptor.Append((TUint8*)&(t.iId),sizeof(TUint));

	*size += sizeof(TUint);

	// the size is the descriptor length + the size field

	LOGSTRING2("Name size - %d",*size);

	return ((TInt)(*size))+1;

    }

inline TInt DPriSamplerImpl::EncodeChunkData(DThread& t)

    {

	LOGTEXT("PriSamplerImpl::EncodeChunkData - entry");

	LOGSTRING2("PriSamplerImpl::EncodeChunkData - processing thread 0x%x ",&t);

	// the size of the following name is in the first byte

	TUint8* size = &sample[0];

	*size = 0;

	this->sampleDescriptor.Zero();

	LOGTEXT("PriSamplerImpl::EncodeChunkData - cleared");

    // append the thread id

    this->sampleDescriptor.Append((TUint8*)&(t.iId),sizeof(TUint));

    *size += sizeof(TUint);

//    NKern::LockSystem();

//    TInt priority(-1);

//    if(&t && t.Open()== KErrNone)

//        {

//       priority = t.iDefaultPriority;

//        }

//    NKern::UnlockSystem();

    // append the priority of the nanokernel fast semaphore

//    this->sampleDescriptor.Append((TUint8*)&priority,sizeof(TUint8));

    // append the priority of the nanokernel fast semaphore

    this->sampleDescriptor.Append((TUint8*)&(t.iNThread.iPriority),sizeof(TUint8));

    // add space because EKA-1 implementation needs it

    this->sampleDescriptor.Append((TUint8)0x0);

    *size += 2*sizeof(TUint8);

    LOGTEXT("PriSamplerImpl::EncodeChunkData - appended priority");

    LOGSTRING2("Data size - %d",*size);

    return ((TInt)(*size))+1;	

    }

void DPriSamplerImpl::Reset()

    {

	/*

	 *

	 *	EKA-2 implementation of PRI trace

	 *

	 */

	LOGTEXT("PriSamplerImpl::Reset");

	iCountti = 50;	// sample threads 16 cycles before actual MEM and PRI sample time...

	this->iThreadCount = 0;

	this->iNewThreadCount = 0;

	this->iProcessing = ENothingToProcess;

	this->sampleDescriptor.Zero();

	// clear all thread tags

	DObjectCon* threads = Kern::Containers()[EThread];

	TInt totalThreadCount = threads->Count();

	for(TInt i=0;i<totalThreadCount;i++)

	    {

		DThread* t = (DThread*)(*threads)[i];

		TAG(t) = (TAG(t) & 0xfffffffd);

	    }

    }