/*

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

	iSampleType = ESampleThreads;

	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"));

    }

    {

#ifdef MEM_EVENT_HANDLER

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

#else

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

#endif

	    {

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

        }

	    {

        }

                {

                }

            else

                {

                }

            }

            {

                {

                // gather first all chunks

                return GatherChunks();

                }

            else

                {

                // gather libraries

                return GatherLibraries();

                }

            }

        else

            {

            }

        }

    // should not reach this point...

    return 0;

    }

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];

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

            {

            // 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++;

        }

    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];

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

            {

            // 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++;

        }

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

        {

        this->iThreadsProcessing = EStartingToProcess;

        TInt length = this->ProcessThreads();

        if(length == 0)

            {

            this->iThreadsProcessing = ENothingToProcess;

            }

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

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

        return length;

        }

    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()

    {

        {