/*

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

#include "perfmon_engine.h"

#include "perfmon_powerlistener.h"

#include <coeutils.h>

#include <bautils.h>

#include <eikenv.h>

#include <e32hal.h>

#include <u32std.h>

#include <s32file.h>

#include <akntitle.h> 

#include <eikspane.h>

#include <aknnotewrappers.h>

_LIT(KDefaultLogFilePath, "c:\\data\\PerfMon.log");

const TInt KCalibrationLength = 2;

const TInt KMinimumSamplesLength = 16;

const TInt KCPUTimeMultiplier = 1000000; // used to avoid TReal conversions

const TInt KSettingsDrive = EDriveC;

_LIT(KSettingsFileName, "perfmon_settings.ini");

// --------------------------------------------------------------------------------------------

TInt CPULoadCount(TAny* aPtr)

    {

    TPerfMonNOPCounter& atts = *((TPerfMonNOPCounter*) aPtr);

    // increase the counter

    atts.iCounterValue++;

    return 1;

    }

TInt CPULoadNOPThread(TAny* aPtr)

    {

    // set the thread running in correct CPU

    TPerfMonNOPCounter& atts = *((TPerfMonNOPCounter*) aPtr);

    if (atts.iAmountOfCPUs > 1)

        {

        // request via HAL that the current thread will run in CPU defined in atts.iCPUNumber

        TInt err = UserSvr::HalFunction(EHalGroupKernel, 19 /*EKernelHalLockThreadToCpu*/, (TAny*) atts.iCPUNumber, 0);

        if (err != KErrNone)

            {

            // error, stop this thread

            return err;

            }

        }

    // init trap clean and install active scheduler

    CTrapCleanup* pC = CTrapCleanup::New();

    CActiveScheduler* pS = new CActiveScheduler;

    CActiveScheduler::Install(pS);

    // call the counter to simulate polling the null thread for cpu time

    CIdle* idle = CIdle::NewL(CActive::EPriorityStandard);

    TCallBack cb(CPULoadCount, aPtr);

    idle->Start(cb);

    pS->Start();

    delete idle;

    delete pS;

    delete pC;

    return KErrNone;

    }

// ===================================== MEMBER FUNCTIONS =====================================

CPerfMonEngine::CPerfMonEngine() :

    CActive(EPriorityUserInput)

    {

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::ConstructL()

    {

    iCurrentCPUMode = ECPUModeNotSet;

    iLogFileInitialized = EFalse;

    iAmountOfCPUs = 1;

    iEnv = CEikonEnv::Static();

    User::LeaveIfError(iLs.Connect());

    User::LeaveIfError(iTimer.CreateLocal());

    CActiveScheduler::Add(this);

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::ActivateEngineL()

    {

    // load settings

    TRAP_IGNORE(LoadSettingsL());

    // create data storages for the samples

    CreateSamplesDataArrayL();

    // set default modes

    HandleSettingsChangeL();

    // start sampling data immediately (jump to RunL)    

    iTimer.After(iStatus, 100);

    SetActive();

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::DeActivateEngineL()

    {

    Cancel();

    DeActivatePowerMonitoring();

    DeActivateCPUMonitoring();

    // close log file

    OpenLogFile(EFalse);

    }

// --------------------------------------------------------------------------------------------

CPerfMonEngine::~CPerfMonEngine()

    {

    DeActivatePowerMonitoring();

    if (iPowerClient != 0)

        {

        delete iPowerClient;

        iPowerClient = 0;

        }

    iTimer.Close();

    // clear data storages

    if (iSampleEntryArray)

        {

        for (TInt i = 0; i < iSampleEntryArray->Count(); i++)

            {

            delete iSampleEntryArray->At(i).iSampleDataArray;

            }

        delete iSampleEntryArray;

        }

    iLs.Close();

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::DoCancel()

    {

    iTimer.Cancel();

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::RunL()

    {

    // calculate new values 

    UpdateSamplesDataL();

    // log changes

    AppendLatestSamplesToLogsL();

    // redraw views

    SendDrawEventToContainersL();

    // continue

    iTimer.After(iStatus, iSettings.iHeartBeat * 1000); // convert from milliseconds to microseconds

    SetActive();

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::HandleSettingsChangeL()

    {

    // set priority of the thread

    RThread().SetPriority(SettingItemToThreadPriority(iSettings.iPriority));

    // init cpu monitor if setting has been changed

    if (iCurrentCPUMode != iSettings.iCPUMode)

        {

        DeActivateCPUMonitoring();

        ActivateCPUMonitoringL();

        }

    // Check for power setting changes every time

    if (iSettings.iPowerMonitoringEnabled == true)

        {

        ActivatePowerMonitoringL();

        }

    else

        {

        DeActivatePowerMonitoring();

        }

    // close log file

    OpenLogFile(EFalse);

    // enable log file

    if (iSettings.iLoggingEnabled && (iSettings.iLoggingMode

            == ELoggingModeLogFile || iSettings.iLoggingMode

            == ELoggingModeRDebugLogFile))

        OpenLogFile(ETrue);

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::EnableLogging(TBool aEnable)

    {

    if (aEnable)

        {

        if (iSettings.iLoggingMode == ELoggingModeLogFile

                || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)

            OpenLogFile(ETrue);

        iSettings.iLoggingEnabled = ETrue;

        }

    else // disable

        {

        iSettings.iLoggingEnabled = EFalse;

        OpenLogFile(EFalse);

        }

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::OpenLogFile(TBool aOpen)

    {

    // open log file for writing

    if (aOpen)

        {

        if (!iLogFileInitialized)

            {

            TInt err(KErrNone);

            // open the log file for writing

            if (iLogFile.Open(iEnv->FsSession(), iSettings.iLoggingFilePath,

                    EFileWrite) != KErrNone)

                {

                iEnv->FsSession().MkDirAll(iSettings.iLoggingFilePath);

                err = iLogFile.Replace(iEnv->FsSession(),

                        iSettings.iLoggingFilePath, EFileWrite);

                }

            else

                {

                // file opens correctly, seek to the end

                TInt fileSize = 0;

                iLogFile.Size(fileSize);

                err = iLogFile.Seek(ESeekCurrent, fileSize);

                }

            if (err == KErrNone)

                {

                iLogFileInitialized = ETrue;

                }

            else

                {

                // show error

                CAknErrorNote* note = new (ELeave) CAknErrorNote();

                note->ExecuteLD(_L("Unable to create log file, check settings"));

                }

            }

        }

    // close handle to log file

    else

        {

        if (iLogFileInitialized)

            {

            iLogFile.Flush();

            iLogFile.Close();

            iLogFileInitialized = EFalse;

            }

        }

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::ActivateCPUMonitoringL()

    {

    // reset counter variables

    iCPULoadCalibrating = ETrue;

    iCPULoadCalibrationCounter = 0;

    iCPULoadMaxValue = 999999999;

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

        {

        iCPULoadPreviousValue[i] = 1;

        }

    // use null thread is cpu time is supported and the setting is on

    if (CPUTimeSupported() && iSettings.iCPUMode == ECPUModeCPUTime)

        {

        // try to open handle to null thread

        if (OpenHandleToNullThread())

            {

            // handle is open, get initial value for each CPU

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

                {

                TTimeIntervalMicroSeconds time;

                iNullThreads[i].GetCpuTime(time);

                iCPULoadPreviousValue[i] = time.Int64();

                }

            iPreviousTime.HomeTime();

            iCurrentCPUMode = ECPUModeCPUTime;

            return; // cpu time is succesfully in use

            }

        }

    // otherwise use normal sampling with nops

    iCurrentCPUMode = ECPUModeNotSet;

    // show a warning if cpu time cannot be taken in use

    if (iSettings.iCPUMode == ECPUModeCPUTime)

        {

        CAknInformationNote* note = new (ELeave) CAknInformationNote();

        note->ExecuteLD(

                _L("CPU Time not supported in this system, using NOPs sampling"));

        }

    // get the amount of CPUs

    iAmountOfCPUs = GetAmountOfCPUs();

    // create a thread for CPU load monitoring

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

        {

        // initialize the NOP counter variables

        iCPULoadNOPCounter[i].iCounterValue = 0;

        iCPULoadNOPCounter[i].iCPUNumber = i;

        iCPULoadNOPCounter[i].iAmountOfCPUs = iAmountOfCPUs;

        // create a name for the thread

        TFileName cpuLoadThreadName;

        cpuLoadThreadName.Copy(_L("PerfMonCPULoadNOPThread"));

        cpuLoadThreadName.AppendNum(i);

        // create the thread and resume it

        User::LeaveIfError(iCPULoadNOPThread[i].Create(cpuLoadThreadName,

                CPULoadNOPThread, 0x1000, 0x1000, 0x100000, &iCPULoadNOPCounter[i]));

        iCPULoadNOPThread[i].SetPriority(EPriorityLess);

        iCPULoadNOPThread[i].Resume();

        }

    iCurrentCPUMode = ECPUModeNOPs; // NOPs taken succesfully in use

    }

// --------------------------------------------------------------------------------------------

TBool CPerfMonEngine::OpenHandleToNullThread()

    {

    // find the kernel process and then the null thread

    TFindProcess fp(_L("ekern.exe*"));

    TFullName kernelName;

    if (fp.Next(kernelName) == KErrNone)

        {

        iAmountOfCPUs = 0;

        // find all null threads in the system by following the order ie "Null", "Null1", "Null2", "Null3"

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

            {

            // construct name of the null thread from the process name

            TFullName nullThreadName(kernelName);

            nullThreadName.Append(_L("::Null"));

            if (i >= 1) // add identifier for CPUs higher than zero

                nullThreadName.AppendNum(i);

            TFindThread ft(nullThreadName);

            TFullName threadName;

            if (ft.Next(threadName) == KErrNone)

                {

                if (iNullThreads[i].Open(threadName) != KErrNone)

                    return EFalse;

                iAmountOfCPUs++;

                }

            else

                {

                break;  // break the loop, no more matches can be found

                }

            }

        }

    // process not found

    else

        return EFalse;

    // success!

    return ETrue;

    }

// --------------------------------------------------------------------------------------------

void CPerfMonEngine::DeActivateCPUMonitoring()

    {

    if (iCurrentCPUMode == ECPUModeCPUTime)

        {

        // close handles to null threads

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

            {

            iNullThreads[i].Close();

            }

        }

    else if (iCurrentCPUMode == ECPUModeNOPs)

        {

        // kill the cpu load thread

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

            {

            iCPULoadNOPThread[i].Kill(0);

            iCPULoadNOPThread[i].Close();

            }

        }

    }

// --------------------------------------------------------------------------------------------

TBool CPerfMonEngine::CPUTimeSupported()

    {

    TTimeIntervalMicroSeconds time;

    TInt err = RThread().GetCpuTime(time);

    if (err == KErrNone && time.Int64() > 0)

        return ETrue;

    else

        return EFalse;

    }

// --------------------------------------------------------------------------------------------

TInt CPerfMonEngine::GetAmountOfCPUs()

    {

    // query from HAL the amount of CPUs and then check it returns a valid value

    TInt amountOfCPUs = UserSvr::HalFunction(EHalGroupKernel, 16 /*EKernelHalNumLogicalCpus*/, 0, 0);

    if (amountOfCPUs >= 1 && amountOfCPUs <= KMaxCPUs)

        return amountOfCPUs;

    else

        return 1; // HAL may not support this feature, so just return one CPU

    }

// --------------------------------------------------------------------------------------------

TThreadPriority CPerfMonEngine::SettingItemToThreadPriority(TInt aIndex)

    {

    TThreadPriority threadPriority = EPriorityNull;

    switch (aIndex)

        {

        case EThreadPriorityTypeMuchLess:

            {

            threadPriority = EPriorityMuchLess;

            break;

            }

        case EThreadPriorityTypeLess:

            {

            threadPriority = EPriorityLess;

            break;

            }

        case EThreadPriorityTypeNormal:

            {

            threadPriority = EPriorityNormal;

            break;

            }

        case EThreadPriorityTypeMore:

            {

            threadPriority = EPriorityMore;

            break;

            }

        case EThreadPriorityTypeMuchMore:

            {

            threadPriority = EPriorityMuchMore;

            break;

            }

        case EThreadPriorityTypeRealTime:

            {

            threadPriority = EPriorityRealTime;

            break;

            }

        case EThreadPriorityTypeAbsoluteVeryLow:

            {

            threadPriority = EPriorityAbsoluteVeryLow;

            break;

            }

        case EThreadPriorityTypeAbsoluteLow:

            {

            threadPriority = EPriorityAbsoluteLow;

            break;

            }

        case EThreadPriorityTypeAbsoluteBackground:

            {

            threadPriority = EPriorityAbsoluteBackground;

            break;

            }

        case EThreadPriorityTypeAbsoluteForeground:

            {

            threadPriority = EPriorityAbsoluteForeground;

            break;

            }

        case EThreadPriorityTypeAbsoluteHigh:

            {

            threadPriority = EPriorityAbsoluteHigh;

            break;

            }