--- a/perfmon/engine/src/perfmon_engine.cpp Wed Sep 15 12:13:45 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1128 +0,0 @@
-/*
- * 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;
- }
-
- default:
- {
- User::Panic(_L("Wrong tp index"), 276);
- break;
- }
- }
-
- return threadPriority;
- }
-
-// --------------------------------------------------------------------------------------------
-
-void CPerfMonEngine::CreateSamplesDataArrayL()
- {
- TInt maxSamples =
- iSettings.iMaxSamples >= KMinimumSamplesLength ? iSettings.iMaxSamples
- : KMinimumSamplesLength;
-
- // create the data structure to store all samples
- iSampleEntryArray = new (ELeave) CSampleEntryArray(16);
-
- // set sample data array positions for each type
- iCPU0PositionInSamples = 0;
- iRAMPositionInSamples = KMaxCPUs;
- iCDrivePositionInSamples = KMaxCPUs+1;
- iPowerPositionInSamples = iCDrivePositionInSamples + ( ESourceI - ESourceC ) + 1;
-
- // add all CPU source entries
- for (TInt i=0; i<KMaxCPUs; i++)
- {
- TSampleEntry newSampleEntry;
-
- newSampleEntry.iDescription.Copy(_L("CPU"));
- newSampleEntry.iDescription.AppendNum(i);
-
- newSampleEntry.iUnitTypeShort.Copy(KNullDesC);
- newSampleEntry.iUnitTypeLong.Copy(KNullDesC);
- newSampleEntry.iDriveNumber = -1;
- newSampleEntry.iGraphColor = KRgbYellow;
- newSampleEntry.iGraphColor.SetGreen(255-i*75);
- newSampleEntry.iGraphColor.SetBlue(i*75);
-
- newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples);
- iSampleEntryArray->AppendL(newSampleEntry);
- }
-
- // add RAM entry
- {
- TSampleEntry newSampleEntry;
-
- newSampleEntry.iDescription.Copy(_L("RAM"));
- newSampleEntry.iUnitTypeShort.Copy(_L("b"));
- newSampleEntry.iUnitTypeLong.Copy(_L("bytes"));
- newSampleEntry.iDriveNumber = -1;
- newSampleEntry.iGraphColor = KRgbGreen;
-
- newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples);
- iSampleEntryArray->AppendL(newSampleEntry);
- }
-
- // add all disk drives
- for (TInt i=0; i<ESourceI-ESourceC+1; i++)
- {
- TSampleEntry newSampleEntry;
-
- TChar driveLetter = 'C' + i; // C is the first drive
-
- newSampleEntry.iDescription.Append(driveLetter);
- newSampleEntry.iDescription.Append(_L(":"));
- newSampleEntry.iUnitTypeShort.Copy(_L("b"));
- newSampleEntry.iUnitTypeLong.Copy(_L("bytes"));
-
- iEnv->FsSession().CharToDrive(driveLetter,
- newSampleEntry.iDriveNumber);
-
- newSampleEntry.iGraphColor = KRgbCyan;
- newSampleEntry.iGraphColor.SetGreen(255 - (i - ESourceC) * 30);
- newSampleEntry.iGraphColor.SetRed(i * 30);
-
- newSampleEntry.iSampleDataArray = new (ELeave) CSampleDataArray(
- maxSamples);
-
- iSampleEntryArray->AppendL(newSampleEntry);
- }
-
- // add power entry
- {
- TSampleEntry newSampleEntry;
-
- newSampleEntry.iDescription.Copy(_L("Power"));
- newSampleEntry.iUnitTypeShort.Copy(_L("mW"));
- newSampleEntry.iUnitTypeLong.Copy(_L("milliwatts"));
- newSampleEntry.iDriveNumber = -1;
- newSampleEntry.iGraphColor = KRgbRed;
-
- newSampleEntry.iSampleDataArray = new(ELeave) CSampleDataArray(maxSamples);
- iSampleEntryArray->AppendL(newSampleEntry);
- }
-
- // save current time as start time
- iStartTime.HomeTime();
- }
-
-// --------------------------------------------------------------------------------------------
-
-void CPerfMonEngine::UpdateSamplesDataL()
- {
- // reset inactivity timers
- if (iSettings.iKeepBacklightOn)
- User::ResetInactivityTime();
-
- // get current time
- TTime currentTime;
- currentTime.HomeTime();
-
- // calculate time difference
- TTimeIntervalMicroSeconds timeDeltaFromPreviousSample =
- currentTime.MicroSecondsFrom(iPreviousTime);
-
- // remember current time as previous
- iPreviousTime = currentTime;
-
- // get CPU load value for each CPU
- for (TInt i=0;i<iAmountOfCPUs;i++)
- {
- TInt64 cpuLoadDelta(0);
- TInt64 cpuLoadFree(0);
- TInt64 currentCPUValue(0);
-
- if (iCurrentCPUMode == ECPUModeCPUTime || iCurrentCPUMode == ECPUModeNOPs)
- {
- if (iCurrentCPUMode == ECPUModeCPUTime)
- {
- // get CPU time of null thread
- TTimeIntervalMicroSeconds time;
- iNullThreads[i].GetCpuTime(time);
- currentCPUValue = time.Int64();
- }
- else if (iCurrentCPUMode == ECPUModeNOPs)
- {
- // get CPU time from sampler
- currentCPUValue = iCPULoadNOPCounter[i].iCounterValue;
- }
-
- // get delta and store the previous value
- cpuLoadDelta = currentCPUValue - iCPULoadPreviousValue[i];
- iCPULoadPreviousValue[i] = currentCPUValue;
-
- // velocity = distance / time
- cpuLoadFree = cpuLoadDelta * KCPUTimeMultiplier / timeDeltaFromPreviousSample.Int64();
-
- // detect maximum value (this is common to all CPUs)
- if (cpuLoadFree > iCPULoadMaxValue)
- {
- iCPULoadMaxValue = cpuLoadFree;
- }
- }
-
- // save cpu sample data
- TSampleData cpuSample;
- cpuSample.iFree = cpuLoadFree;
- cpuSample.iSize = iCPULoadCalibrating ? cpuLoadFree : iCPULoadMaxValue; // if calibrating, size==free, otherwise store the correct size value
- cpuSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
-
- iSampleEntryArray->At(i).iSampleDataArray->InsertL(0, cpuSample);
- }
-
- // check calibration status, the calibration will be only done against CPU0
- if (iCPULoadCalibrating)
- {
- iCPULoadCalibrationCounter++;
- TInt64 cpuLoadSize = iSampleEntryArray->At(iCPU0PositionInSamples).iSampleDataArray->At(0).iSize;
-
- // check if need to calibrate anymore
- if (iCPULoadCalibrationCounter > KCalibrationLength)
- {
- iCPULoadCalibrating = EFalse;
-
- // from the samples, get the minimum value, and let it be the max value
- for (TInt i=0; i<iSampleEntryArray->At(0).iSampleDataArray->Count(); i++)
- {
- TInt64 newCPULoadMaxValue = iCPULoadMaxValue;
-
- if (iSampleEntryArray->At(0).iSampleDataArray->At(i).iFree < newCPULoadMaxValue)
- {
- newCPULoadMaxValue = iSampleEntryArray->At(0).iSampleDataArray->At(i).iFree;
- }
-
- iCPULoadMaxValue = newCPULoadMaxValue;
- }
-
- // adjust priority of the poller thread
- if (iCurrentCPUMode == ECPUModeNOPs)
- {
- for (TInt i=0; i<iAmountOfCPUs; i++)
- {
- iCPULoadNOPThread[i].SetPriority(EPriorityAbsoluteVeryLow);
- }
- }
-
- }
- }
-
- // get ram memory
- TMemoryInfoV1Buf ramMemory;
- UserHal::MemoryInfo(ramMemory);
-
- TSampleData memorySample;
- memorySample.iFree = ramMemory().iFreeRamInBytes;
- memorySample.iSize = ramMemory().iMaxFreeRamInBytes;
- memorySample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
-
- iSampleEntryArray->At(iRAMPositionInSamples).iSampleDataArray->InsertL(0, memorySample);
-
- // all drives
- for (TInt i = iCDrivePositionInSamples; i < iPowerPositionInSamples; i++)
- {
- TSampleData driveSample;
-
- // get volume info from RFs
- TVolumeInfo volumeInfo;
- if (iEnv->FsSession().Volume(volumeInfo,
- iSampleEntryArray->At(i).iDriveNumber) == KErrNone)
- {
- driveSample.iFree = volumeInfo.iFree;
- driveSample.iSize = volumeInfo.iSize;
- }
- else
- {
- driveSample.iFree = 0;
- driveSample.iSize = 0;
- }
-
- driveSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
-
- iSampleEntryArray->At(i).iSampleDataArray->InsertL(0, driveSample);
- }
-
- // Power data
- TSampleData powerSample;
- if (iSettings.iPowerMonitoringEnabled)
- {
- // Values in milliwatts
- powerSample.iFree = ( iPowerClient->GetMaxPower() - iPowerClient->GetPower() ) / 1000;
- powerSample.iSize = iPowerClient->GetMaxPower() / 1000;
- }
- else
- {
- powerSample.iFree = 0;
- powerSample.iSize = 0;
- }
-
- powerSample.iTimeFromStart = currentTime.MicroSecondsFrom(iStartTime);
-
- iSampleEntryArray->At(iPowerPositionInSamples).iSampleDataArray->InsertL(0, powerSample);
-
- // compress sample data arrays to save memory
- TInt curLength(iSampleEntryArray->At(0).iSampleDataArray->Count());
-
- TInt maxSamples =
- iSettings.iMaxSamples >= KMinimumSamplesLength ? iSettings.iMaxSamples
- : KMinimumSamplesLength;
-
- if (curLength > maxSamples && curLength % 5 == 0)
- {
- for (TInt i = 0; i < iSampleEntryArray->Count(); i++)
- {
- if (SampleEntryArray()->At(i).iSampleDataArray->Count() > 0)
- {
- iSampleEntryArray->At(i).iSampleDataArray->ResizeL(maxSamples); // looses old samples
- iSampleEntryArray->At(i).iSampleDataArray->Compress();
- }
- }
- }
- }
-
-// --------------------------------------------------------------------------------------------
-
-void CPerfMonEngine::AppendLatestSamplesToLogsL()
- {
- if (iSettings.iLoggingEnabled && SampleEntryArray())
- {
- // loop all sources
- for (TInt i = 0; i < SampleEntryArray()->Count(); i++)
- {
- // check if this setting has been enabled and it has some data
- if (iSettings.iLoggingSources.iSrcEnabled[SampleEntryPosToSettingPos(i)]
- && SampleEntryArray()->At(i).iSampleDataArray->Count() > 0)
- {
- // get current sample
- TSampleData& currentSample =
- SampleEntryArray()->At(i).iSampleDataArray->At(0);
-
- TBuf<128> buf;
- buf.Append(_L("PERFMON;"));
- buf.Append(SampleEntryArray()->At(i).iDescription);
- buf.Append(_L(";"));
- buf.AppendNum(currentSample.iTimeFromStart.Int64());
- buf.Append(_L(";"));
- buf.AppendNum(currentSample.iFree);
- buf.Append(_L(";"));
- buf.AppendNum(currentSample.iSize);
-
- // print to RDebug
- if (iSettings.iLoggingMode == ELoggingModeRDebug
- || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)
- {
- RDebug::Print(buf);
- }
-
- // print to log file
- if (iSettings.iLoggingMode == ELoggingModeLogFile
- || iSettings.iLoggingMode == ELoggingModeRDebugLogFile)
- {
- buf.Append(_L("\r\n"));
-
- TBuf8<128> buf8;
- buf8.Copy(buf);
-
- iLogFile.Write(buf8);
- }
- }
- }
- }
- }
-
-void CPerfMonEngine::LoadSettingsL()
- {
- // set defaults
- iSettings.iHeartBeat = 600;
- iSettings.iMaxSamples = 64;
- iSettings.iPriority = EThreadPriorityTypeNormal;
- iSettings.iCPUMode = ECPUModeCPUTime;
- iSettings.iKeepBacklightOn = ETrue;
-
- iSettings.iDataPopupVisibility = EDataPopupVisbilityAlwaysOn;
- iSettings.iDataPopupLocation = EDataPopupLocationTopRight;
- iSettings.iDataPopupSources.SetDefaults1();
-
- iSettings.iGraphsVerticalBarPeriod = 5;
- iSettings.iGraphsSources.SetDefaults2();
-
- iSettings.iLoggingMode = ELoggingModeRDebug;
- iSettings.iLoggingFilePath.Copy(KDefaultLogFilePath);
- iSettings.iLoggingSources.SetDefaults2();
-
- iSettings.iLoggingEnabled = EFalse;
-
- iSettings.iPowerMonitoringEnabled = ETrue;
-
- // make sure that the private path of this app in c-drive exists
- iEnv->FsSession().CreatePrivatePath(KSettingsDrive); // c:\\private\\20011385\\
-
- // handle settings always in the private directory
- if (iEnv->FsSession().SetSessionToPrivate(KSettingsDrive) == KErrNone)
- {
- const TUid KUidPerfMon =
- {
- 0x20011385
- };
- // open or create a dictionary file store
- CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(
- iEnv->FsSession(), KSettingsFileName, KUidPerfMon);
-
- LoadDFSValueL(settingsStore, KPMSettingHeartBeat, iSettings.iHeartBeat);
- LoadDFSValueL(settingsStore, KPMSettingMaxSamples,
- iSettings.iMaxSamples);
- LoadDFSValueL(settingsStore, KPMSettingPriority, iSettings.iPriority);
-
- LoadDFSValueL(settingsStore, KPMSettingCPUMode, iSettings.iCPUMode);
-
- LoadDFSValueL(settingsStore, KPMSettingKeepBackLightOn,
- iSettings.iKeepBacklightOn);
-
- LoadDFSValueL(settingsStore, KPMSettingDataPopupVisbility,
- iSettings.iDataPopupVisibility);
- LoadDFSValueL(settingsStore, KPMSettingDataPopupLocation,
- iSettings.iDataPopupLocation);
- LoadDFSValueL(settingsStore, KPMSettingDataPopupSources,
- iSettings.iDataPopupSources);
-
- LoadDFSValueL(settingsStore, KPMSettingGraphsVerticalBarPeriod,
- iSettings.iGraphsVerticalBarPeriod);
- LoadDFSValueL(settingsStore, KPMSettingGraphsSources,
- iSettings.iGraphsSources);
-
- LoadDFSValueL(settingsStore, KPMSettingLoggingMode,
- iSettings.iLoggingMode);
- LoadDFSValueL(settingsStore, KPMSettingLoggingFilePath,
- iSettings.iLoggingFilePath);
- LoadDFSValueL(settingsStore, KPMSettingLoggingSources,
- iSettings.iLoggingSources);
-
- LoadDFSValueL(settingsStore, KPMSettingPowerMonitoringEnabled,
- iSettings.iPowerMonitoringEnabled);
-
- CleanupStack::PopAndDestroy(); // settingsStore
- }
- }
-
-// --------------------------------------------------------------------------------------------
-
-void CPerfMonEngine::SaveSettingsL()
- {
- // handle settings always in c:\\private\\20011385\\
- if (iEnv->FsSession().SetSessionToPrivate( KSettingsDrive ) == KErrNone)
- {
- // delete existing store to make sure that it is clean and not eg corrupted
- if (BaflUtils::FileExists(iEnv->FsSession(), KSettingsFileName))
- {
- iEnv->FsSession().Delete(KSettingsFileName);
- }
- const TUid KUidPerfMon =
- {
- 0x20011385
- };
- // create a dictionary file store
- CDictionaryFileStore* settingsStore = CDictionaryFileStore::OpenLC(
- iEnv->FsSession(), KSettingsFileName, KUidPerfMon);
-
- SaveDFSValueL(settingsStore, KPMSettingHeartBeat, iSettings.iHeartBeat);
- SaveDFSValueL(settingsStore, KPMSettingMaxSamples,
- iSettings.iMaxSamples);
- SaveDFSValueL(settingsStore, KPMSettingPriority, iSettings.iPriority);
- SaveDFSValueL(settingsStore, KPMSettingCPUMode, iSettings.iCPUMode);
- SaveDFSValueL(settingsStore, KPMSettingKeepBackLightOn,
- iSettings.iKeepBacklightOn);
-
- SaveDFSValueL(settingsStore, KPMSettingDataPopupVisbility,
- iSettings.iDataPopupVisibility);
- SaveDFSValueL(settingsStore, KPMSettingDataPopupLocation,
- iSettings.iDataPopupLocation);
- SaveDFSValueL(settingsStore, KPMSettingDataPopupSources,
- iSettings.iDataPopupSources);
-
- SaveDFSValueL(settingsStore, KPMSettingGraphsVerticalBarPeriod,
- iSettings.iGraphsVerticalBarPeriod);
- SaveDFSValueL(settingsStore, KPMSettingGraphsSources,
- iSettings.iGraphsSources);
-
- SaveDFSValueL(settingsStore, KPMSettingLoggingMode,
- iSettings.iLoggingMode);
- SaveDFSValueL(settingsStore, KPMSettingLoggingFilePath,
- iSettings.iLoggingFilePath);
- SaveDFSValueL(settingsStore, KPMSettingLoggingSources,
- iSettings.iLoggingSources);
-
- SaveDFSValueL(settingsStore, KPMSettingPowerMonitoringEnabled,
- iSettings.iPowerMonitoringEnabled);
-
- settingsStore->CommitL();
- CleanupStack::PopAndDestroy(); // settingsStore
- }
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, TInt& aValue)
- {
- if (aDicFS->IsPresentL(aUid))
- {
- RDictionaryReadStream in;
- in.OpenLC(*aDicFS, aUid);
- aValue = in.ReadInt16L();
- CleanupStack::PopAndDestroy(); // in
- }
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, TDes& aValue)
- {
- if (aDicFS->IsPresentL(aUid))
- {
- RDictionaryReadStream in;
- in.OpenLC(*aDicFS, aUid);
- TInt bufLength = in.ReadInt16L(); // get length of descriptor
- in.ReadL(aValue, bufLength); // get the descriptor itself
- CleanupStack::PopAndDestroy(); // in
- }
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::LoadDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, TPerfMonSources& aValue)
- {
- if (aDicFS->IsPresentL(aUid))
- {
- RDictionaryReadStream in;
- in.OpenLC(*aDicFS, aUid);
- TInt bufLength = in.ReadInt16L(); // get length of the array
-
- if (bufLength < 0 || bufLength > ESourcesLength) // check for validaty
- User::Leave(KErrNotSupported);
-
- for (TInt i = 0; i < bufLength; i++) // get all items
- aValue.iSrcEnabled[i] = in.ReadInt16L();
-
- CleanupStack::PopAndDestroy(); // in
- }
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, const TInt& aValue)
- {
- RDictionaryWriteStream out;
- out.AssignLC(*aDicFS, aUid);
- out.WriteInt16L(aValue);
- out.CommitL();
- CleanupStack::PopAndDestroy(); // out
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, const TDes& aValue)
- {
- RDictionaryWriteStream out;
- out.AssignLC(*aDicFS, aUid);
- out.WriteInt16L(aValue.Length()); // write length of the descriptor
- out.WriteL(aValue, aValue.Length()); // write the descriptor itself
- out.CommitL();
- CleanupStack::PopAndDestroy(); // out
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::SaveDFSValueL(CDictionaryFileStore* aDicFS,
- const TUid& aUid, const TPerfMonSources& aValue)
- {
- RDictionaryWriteStream out;
- out.AssignLC(*aDicFS, aUid);
-
- out.WriteInt16L(ESourcesLength); // write length of the array
-
- for (TInt i = 0; i < ESourcesLength; i++) // write all items
- out.WriteInt16L(aValue.iSrcEnabled[i]);
-
- out.CommitL();
- CleanupStack::PopAndDestroy(); // out
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::ActivatePowerMonitoringL()
- {
- if (iPowerClient == 0)
- {
- iPowerClient = CPerfMonPowerListener::NewL();
- }
-
- // disable power monitoring if initialization fails
- TInt err = iPowerClient->Activate();
- if (err != KErrNone )
- {
- DeActivatePowerMonitoring();
-
- iSettings.iPowerMonitoringEnabled = EFalse;
- }
- }
-
-// ---------------------------------------------------------------------------
-
-void CPerfMonEngine::DeActivatePowerMonitoring()
- {
- if (iPowerClient != 0)
- {
- iPowerClient->DeActivate();
- }
- }
-
-// ---------------------------------------------------------------------------
-
-TInt CPerfMonEngine::SampleEntryPosToSettingPos(TInt aSampleEntryPos)
- {
- TInt settingPos(0); // return position of aSampleEntryPos in settings
-
- if (aSampleEntryPos >= iCPU0PositionInSamples && aSampleEntryPos < iRAMPositionInSamples)
- {
- settingPos = ESourceCPU;
- }
- else if (aSampleEntryPos == iRAMPositionInSamples)
- {
- settingPos = ESourceRAM;
- }
- else
- {
- settingPos = ESourceC + (aSampleEntryPos-iCDrivePositionInSamples);
- }
-
- return settingPos;
- }
-
-// End of File