/*

* 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 "MemSamplerImpl.h"

// for testing precise stack utilization tracing...

// crashes at the moment

#include <nk_cpu.h>

#if !defined(__NKERN_H__)

#include <nkern.h>

#endif 

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

#define PROFILER_CHUNK_MARK		((TUint32)0x00001000)

#define PROFILER_MEM_THREAD_MARK	((TUint32)0x00000001)

#define PROFILER_LIBRARY_MARK    ((TUint32)0x10000000)

#define PROFILER_MEM_THREAD_UNMARK  ~PROFILER_MEM_THREAD_MARK

#ifdef MEM_EVENT_HANDLER

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

_LIT8(KMemVersion,"2.03");

#else

_LIT8(KMemVersion, "2.02");

#endif

#else

_LIT8(KMemVersion, "1.56");

#endif

DMemSamplerImpl::DMemSamplerImpl() :

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

    {

    LOGSTRING("MemSamplerImpl::MemSamplerImpl() - konstruktori");

	iCount = 0;

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

	iSampleType = ESampleThreads;

#else

	iSampleThreads = true;

#endif

	iTimeToSample = false;

	iTotalMemoryOk = false;

	iTotalMemoryNameOk = false;

	iNewChunkCount = 0;

	iChunkCount = 0;

	iChunksProcessing = ENothingToProcess;

    iThreadsProcessing = ENothingToProcess;

	iNewThreadCount = 0;

	iThreadCount = 0;

	// reset data structures

    for(TInt i(0);i<KProfilerMaxChunksAmount;i++)

        {

        // heap chunks

        this->heapChunksToSample[i] = 0;

        this->heapChunkNamesToReport[i] = 0;

        }

    for(TInt i(0);i<KProfilerMaxThreadsAmount;i++)

        {

        // threads

        this->threadsToSample[i] = 0;

        this->threadNamesToReport[i] = 0;

        }

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

    iLibrariesProcessing = ENothingToProcess;

    iNewLibraryCount = 0;

    iLibraryCount = 0;

    for(TInt i(0); i<KProfilerMaxLibrariesAmount; i++)

        {

        // libraries

        this->librariesToSample[i] = 0;

        this->libraryNamesToReport[i] = 0;

        }

#endif

    }

DMemSamplerImpl::~DMemSamplerImpl()

    {

    }

TInt DMemSamplerImpl::CreateFirstSample()

    {

    LOGSTRING("MemSamplerImpl::CreateFirstSample - entry");

	this->sampleDescriptor.Zero();

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

	this->sampleDescriptor.Append(KMemVersion);

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

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

	LOGSTRING("MemSamplerImpl::CreateFirstSample - exit");

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

    }

TBool DMemSamplerImpl::SampleNeeded()

    {

	iCount++;

#ifdef MEM_EVENT_HANDLER

    // make the collection of chunks/threads only once, rest will be collected with mem event handler

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

	if (iCount <= iMemSamplingPeriod && ((iCount % iMemSamplingPeriod) == 0 || (iCount % iMemSamplingPeriodDiv3) == 0))

#else

    if (iCount <= iMemSamplingPeriod && ((iCount % iMemSamplingPeriod) == 0 || (iCount % iMemSamplingPeriodDiv2) == 0))

#endif

#else

	if ((iCount % iMemSamplingPeriod) == 0 || (iCount % iMemSamplingPeriodDiv2) == 0)

#endif

	    {

        LOGSTRING2("MemSamplerImpl::SampleNeeded - time: %d", iCount);

		iTimeToSample = true;

		return true;

        }

	else 

	    {

		return false;

        }

    }

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

TInt DMemSamplerImpl::SampleImpl()

    {    

    // Sample threads:

    if( iSampleType == ESampleThreads )

        {    

        if(this->iThreadsProcessing == ENothingToProcess )

            {     

            if(!iTimeToSample)

                {

                return 0;

                }

            else

                {

                iTimeToSample = false;

                // gather first all thread stacks

                return GatherThreads();

                }

            }

        else

            {

            // process now thread stack list

            TInt length = this->ProcessThreads();

            if(length == 0)

                {

                this->iThreadsProcessing = ENothingToProcess;

                // switch to collect chunk data

                iSampleType = ESampleChunks;

                }

            return length;

            }

        }

    // Sample chunks:

    if( iSampleType == ESampleChunks )

        {

        if(this->iChunksProcessing == ENothingToProcess)

            {

            if(!iTimeToSample)

                {

                return 0;

                }

            else

                {

                iTimeToSample = false;

                // gather first all chunks

                return GatherChunks();

                }

            }

        else

            {

            // still something to go through in lists

            TInt length = this->ProcessChunks();

            if(length == 0) 

            {

                this->iChunksProcessing = ENothingToProcess;

                // switch to collect library data

                iSampleType = ESampleLibraries;

                //iSampleThreads = true;

            }

            return length;

            }

        }

    // Sample libraries:

    if( iSampleType == ESampleLibraries )

        {

        if(this->iLibrariesProcessing == ENothingToProcess )

            {        

            if(!iTimeToSample)

                {             

                return 0;

                }

            else

                {

                iTimeToSample = false;

                // gather libraries

                return GatherLibraries();

                }

            }

        else

            {

            // process now thread stack list

            TInt length = this->ProcessLibraries();

            if(length == 0)

                {

                this->iLibrariesProcessing = ENothingToProcess;

                // switch to collect chunk data

                iSampleType = ESampleThreads;

                }

            return length;

            }

        }

    // should not reach this point...

    return 0;

    }

#else

TInt DMemSamplerImpl::SampleImpl()

    {

    // check if either chunk or thread lists have unprocessed items

    if(this->iChunksProcessing == ENothingToProcess && !iSampleThreads)

        {

        if(!iTimeToSample)

            {

            return 0;

            }

        else

            {

            iTimeToSample = false;

            // gather first all chunks

            return GatherChunks();

            }

        }

    else if(!iSampleThreads)

        {

        // still something to go through in lists

        TInt length = this->ProcessChunks();

        if(length == 0) 

            {

            this->iChunksProcessing = ENothingToProcess;

            // switch to collect thread data

            iSampleThreads = true;

            }

        return length;

        }

    if(this->iThreadsProcessing == ENothingToProcess && iSampleThreads)

        {

        if(!iTimeToSample)

            {

            return 0;

            }

        else

            {

            iTimeToSample = false;

            // gather first all thread stacks

            return GatherThreads();

            }

        }

    else if(iSampleThreads)

        {

        // process now thread stack list

        TInt length = this->ProcessThreads();

        if(length == 0)

            {

            this->iThreadsProcessing = ENothingToProcess;

            // switch to collect chunk data

            iSampleThreads = false;

            }

        return length;

        }

    // should not reach this point...

    return 0;

    }

#endif

inline TInt DMemSamplerImpl::GatherChunks()

    {

    // encode a process binary

    name.Zero();

    NKern::ThreadEnterCS(); // Prevent us from dying or suspending whilst holding a DMutex

    DObjectCon& chunks = *Kern::Containers()[EChunk];

    chunks.Wait();  // Obtain the container mutex so the list does get changed under us

    this->iChunkCount = 0; 

    this->iNewChunkCount = 0;

    this->iTotalMemoryOk = false;

    TInt totalChunkCount(chunks.Count());

    DChunk* c; 

    for(TInt i(0);i<totalChunkCount;i++)

        {

        c = (DChunk*)(chunks)[i];

        LOGSTRING3("Processing chunk %d, tag: 0x%x",i,TAG(c));

        if( (TAG(c) & 0x0000ffff) != PROFILER_CHUNK_MARK)

            {

            LOGSTRING4("Marking chunk %d/%d, old tag 0x%x",i,(totalChunkCount-1), TAG(c));

            // this chunk has not been tagged yet

            name.Zero();

            c->TraceAppendName(name,false);

            TAG(c) = (PROFILER_CHUNK_MARK);

            this->heapChunkNamesToReport[iNewChunkCount] = c;

            iNewChunkCount++;

            }

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

        this->heapChunksToSample[this->iChunkCount] = c;

        this->iChunkCount++;

        LOGSTRING2("Added chunk %d to Chunks",i);

        }

    if(this->iChunkCount > 0 || this->iNewChunkCount > 0)

        {

        this->iChunksProcessing = EStartingToProcess;

        // process the first sample

        TInt length = this->ProcessChunks();

        if(length == 0)

            {

            this->iChunksProcessing = ENothingToProcess;

            }

        chunks.Signal();  // Release the container mutex

        NKern::ThreadLeaveCS();  // End of critical section

        return length;

        }

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

    chunks.Signal();  // Release the container mutex

    NKern::ThreadLeaveCS();  // End of critical section

    return 0;

    }

inline TInt DMemSamplerImpl::GatherThreads()

    {

    // The thread memory consumption

    NKern::ThreadEnterCS(); // Prevent us from dying or suspending whilst holding a DMutex

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

    threads.Wait(); // Obtain the container mutex so the list does get changed under us

    this->iThreadCount = 0; 

    this->iNewThreadCount = 0;

    this->iTotalMemoryOk = false;           

    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_MEM_THREAD_MARK) == 0)

            {

            LOGSTRING4("Marking thread %d/%d, old tag 0x%x",i,(totalThreadCount-1), TAG(t));

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

            this->threadNamesToReport[iNewThreadCount] = t;

            iNewThreadCount++;

            // tag the thread

            TAG(t) |= PROFILER_MEM_THREAD_MARK;

            }

        // the chunk 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->iThreadsProcessing = EStartingToProcess;

        // process the first sample

        TInt length = this->ProcessThreads();

        if(length == 0)

            {

            this->iThreadsProcessing = ENothingToProcess;

            }

        threads.Signal();  // Release the container mutex

        NKern::ThreadLeaveCS();  // End of critical section

        return length;

        }

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

    threads.Signal();  // Release the container mutex

    NKern::ThreadLeaveCS();  // End of critical section

    return 0;

    }

#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS

inline TInt DMemSamplerImpl::GatherLibraries()

    {

    LOGTEXT("MemSamplerImpl::GatherLibraries() - entry");

    // encode a process binary

    name.Zero();

    NKern::ThreadEnterCS(); // Prevent us from dying or suspending whilst holding a DMutex

    DObjectCon& libs = *Kern::Containers()[ELibrary];

    libs.Wait();  // Obtain the container mutex so the list does get changed under us

    this->iLibraryCount = 0; 

    this->iNewLibraryCount = 0;

    this->iTotalMemoryOk = false;

    TInt totalLibCount(libs.Count());

    DLibrary* l; 

    for(TInt i(0);i<totalLibCount;i++)

        {

        l = (DLibrary*)(libs)[i];

        LOGSTRING3("Processing library %d, tag: 0x%x",i,TAG(l));

        if( (TAG(l) & 0xffffffff) != PROFILER_LIBRARY_MARK)

            {

            LOGSTRING4("Marking library %d/%d, old tag 0x%x",i,(totalLibCount-1), TAG(l));

            // this library has not been tagged yet

            name.Zero();

            l->TraceAppendName(name,false);

            TAG(l) = (PROFILER_LIBRARY_MARK);

            this->libraryNamesToReport[iNewLibraryCount] = l;

            iNewLibraryCount++;

            }

        // the library has been tagged, add library to the list

        this->librariesToSample[this->iLibraryCount] = l;

        this->iLibraryCount++;

        LOGSTRING2("Added library %d to Libraries",i);

        }

    if(this->iLibraryCount > 0 || this->iNewLibraryCount > 0)

        {

        this->iLibrariesProcessing = EStartingToProcess;

        // process the first sample

        TInt length = this->ProcessLibraries();

        if(length == 0)

            {

            this->iLibrariesProcessing = ENothingToProcess;

            }

        libs.Signal();  // Release the container mutex

        NKern::ThreadLeaveCS();  // End of critical section

        return length;

        }

    LOGTEXT("MemSamplerImpl::SampleImpl - Error, no libraries"); 

    libs.Signal();  // Release the container mutex

    NKern::ThreadLeaveCS();  // End of critical section

    return 0;

    }

#endif

inline TInt DMemSamplerImpl::ProcessChunks()

    {

    if(iNewChunkCount > 0)

        {

        if(this->iChunksProcessing == EStartingToProcess)

            {

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

            this->iChunksProcessing = EProcessingNames;

            return EncodeNameCode();

            }

        if(iTotalMemoryNameOk == false)

            {

            return EncodeTotalMemoryName();

            }

        // there are new chunk names to report

        iNewChunkCount--;

        DChunk* c = this->heapChunkNamesToReport[iNewChunkCount];

        return EncodeChunkName(*c);

        }

    else if(iChunkCount > 0)

        {

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

            {