--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/sysanadatacapture/piprofiler/piprofiler/plugins/GeneralsPlugin/src/GeneralsPlugin.cpp Thu Feb 11 15:52:57 2010 +0200
@@ -0,0 +1,628 @@
+/*
+* 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 "GeneralsPlugin.h"
+#include <piprofiler/EngineUIDs.h>
+#include <piprofiler/ProfilerTraces.h>
+
+const TInt KMaxSamplerAmount = 20;
+
+// LITERALS
+_LIT8(KEnabled, "enabled");
+_LIT8(KSamplingPeriod, "sampling_period_ms");
+_LIT8(KBracketOpen, "[");
+_LIT8(KBracketClose, "]");
+
+/*
+ *
+ * class CGeneralsPlugin implementation
+ *
+ */
+
+CGeneralsPlugin* CGeneralsPlugin::NewL(const TUid aImplementationUid, TAny* /*aInitParams*/)
+ {
+ LOGTEXT(_L("CGeneralsPlugin::NewL() - entry"));
+ CGeneralsPlugin* self = new (ELeave) CGeneralsPlugin();
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop();
+ LOGTEXT(_L("CGeneralsPlugin::NewL() - exit"));
+ return self;
+ }
+
+CGeneralsPlugin::CGeneralsPlugin() :
+ iVersionDescriptor(&(this->iVersion[1]),0,19)
+ {
+ iSamplerType = PROFILER_KERNEL_MODE_SAMPLER;
+ iSamplerId = PROFILER_GENERALS_SAMPLER_ID;
+ iBufferHandler = NULL;
+ iEnabled = EFalse;
+ LOGTEXT(_L("CGeneralsPlugin::CGeneralsPlugin() - constructor"));
+ }
+
+void CGeneralsPlugin::ConstructL()
+ {
+ LOGTEXT(_L("CGeneralsPlugin::ConstructL() - entry"));
+
+ // create attribute array
+ iSamplerAttributes = new(ELeave) CArrayFixFlat<TSamplerAttributes>(KSubSamplerCount);
+
+ TInt err = InitiateSamplerL();
+ if( err != KErrNone )
+ {
+ LOGTEXT(_L("CGeneralsPlugin::ConstructL - LEAVING, failed to load open sampler device"));
+ User::Leave(err);
+ }
+
+ // initiate sampler attributes, i.e. settings for modification
+ InitiateSamplerAttributesL();
+
+ LOGTEXT(_L("CGeneralsPlugin::ConstructL() - exit"));
+ }
+
+
+CGeneralsPlugin::~CGeneralsPlugin()
+ {
+ // clean all the members
+ CleanSampler(); // clean the created sampler
+ }
+
+TInt CGeneralsPlugin::InitiateSamplerL()
+ {
+ RThread me;
+
+ LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #1"));
+
+ me.SetPriority(EPriorityRealTime);
+
+ LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #2"));
+
+ // create
+ User::FreeLogicalDevice(KPluginSamplerName);
+ TInt err(KErrGeneral);
+
+ LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #3"));
+
+ err = User::LoadLogicalDevice(KPluginSamplerName);
+ if(err != KErrNone)
+ {
+ User::Leave(err);
+ }
+
+ LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #4"));
+
+ err = KErrGeneral;
+
+ err = iGeneralsSampler.Open();
+ if(err != KErrNone)
+ {
+ LOGSTRING2("CGeneralsPlugin::InitiateSamplerL - Could not open sampler device - waiting and trying again: %d", err);
+ User::Leave(err);
+ }
+
+ LOGTEXT(_L("CGeneralsPlugin::InitiateSamplerL - #5"));
+
+ return err;
+ }
+
+/*
+ *
+ * Default sampler attributes
+ *
+ */
+void CGeneralsPlugin::InitiateSamplerAttributesL()
+ {
+
+ //
+ for(TInt i(0);i<KMaxSamplerAmount;i++)
+ {
+ switch(i)
+ {
+// Usage:
+// TSamplerAttributes(TUint32 aUid,
+// const TDesC8& aShortName,
+// const TDesC& aName,
+// const TDesC& aDescription,
+// TInt aSampleRate,
+// TBool aEnabled,
+// TBool aHidden,
+// TUint32 aItemCount);
+ case PROFILER_GPP_SAMPLER_ID:
+ {
+ TSamplerAttributes attr(KSamplerGppPluginUid.iUid,
+ KGPPShortName(),
+ KGPPLongName(),
+ KGPPDescription(),
+ 1,
+ ETrue,
+ ETrue,
+ 0);
+ iSamplerAttributes->AppendL(attr);
+ break;
+ }
+ case PROFILER_GFC_SAMPLER_ID:
+ {
+ TSamplerAttributes attr2(KSamplerGfcPluginUid.iUid,
+ KGFCShortName(),
+ KGFCLongName(),
+ KGFCDescription(),
+ -1,
+ EFalse,
+ EFalse,
+ 0);
+ this->iSamplerAttributes->AppendL(attr2);
+ break;
+ }
+ case PROFILER_ITT_SAMPLER_ID:
+ {
+ TSamplerAttributes attr3(KSamplerIttPluginUid.iUid,
+ KITTShortName(),
+ KITTLongName(),
+ KITTDescription(),
+ -1,
+ EFalse,
+ EFalse,
+ 0);
+ this->iSamplerAttributes->AppendL(attr3);
+ break;
+ }
+ case PROFILER_MEM_SAMPLER_ID:
+ {
+ TSamplerAttributes attr4(KSamplerMemPluginUid.iUid,
+ KMEMShortName(),
+ KMEMLongName(),
+ KMEMDescription(),
+ 3000,
+ EFalse,
+ EFalse,
+ 0);
+ this->iSamplerAttributes->AppendL(attr4);
+ break;
+ }
+ case PROFILER_PRI_SAMPLER_ID:
+ {
+ TSamplerAttributes attr5(KSamplerPriPluginUid.iUid,
+ KPRIShortName(),
+ KPRILongName(),
+ KPRIDescription(),
+ 3000,
+ EFalse,
+ EFalse,
+ 0);
+ this->iSamplerAttributes->AppendL(attr5);
+ break;
+ }
+ }
+ }
+ }
+
+TInt CGeneralsPlugin::CleanSampler()
+ {
+ LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - deleting buffer handler"));
+ // release the buffer handler
+ if(iBufferHandler)
+ {
+ iBufferHandler->Cancel();
+ delete iBufferHandler;
+ iBufferHandler = NULL;
+ }
+
+ LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - closing sampler"));
+ iGeneralsSampler.Close();
+
+ LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - Freeing sampler device"));
+ User::FreeLogicalDevice(KPluginSamplerName);
+
+ // release attribute array
+ if(iSamplerAttributes)
+ {
+ iSamplerAttributes->Reset();
+ }
+ delete iSamplerAttributes;
+ iSamplerAttributes = NULL;
+
+ LOGTEXT(_L("CGeneralsPlugin::CleanSampler() - exit"));
+
+ return KErrNone;
+ }
+
+// returns setting array
+void CGeneralsPlugin::GetAttributesL(CArrayFixFlat<TSamplerAttributes>* aAttributes)
+ {
+ TInt count(iSamplerAttributes->Count());
+ // append all sampler attributes to aAttributes array
+ for(TInt i(0);i<count;i++)
+ {
+ aAttributes->AppendL(iSamplerAttributes->At(i));
+ }
+ }
+
+TInt CGeneralsPlugin::SetAttributesL(TSamplerAttributes aAttributes)
+ {
+ TSamplerAttributes attr;
+
+ TInt count(iSamplerAttributes->Count());
+ // loop the sub sampler attributes (by UID)
+ for(TInt i(0);i<count;i++)
+ {
+ attr = iSamplerAttributes->At(i);
+ // if UIDs match replace the old
+ if(attr.iUid == aAttributes.iUid)
+ {
+ // replace the old attribute container
+ iSamplerAttributes->Delete(i);
+ iSamplerAttributes->InsertL(i, aAttributes);
+ return KErrNone;
+ }
+ }
+ return KErrNotFound;
+ }
+
+/*
+ * Method for parsing and transforming text array settings into TSamplerAttributes (per each sub sampler),
+ * called by CSamplerController class
+ *
+ * @param array of raw text setting lines, e.g. [gpp]\nenabled=true\nsampling_period_ms=1\n
+ */
+TInt CGeneralsPlugin::ConvertRawSettingsToAttributes(CDesC8ArrayFlat* aAllSettingsArray)
+ {
+ // local literals
+ _LIT8(KGPPShort, "gpp");
+ _LIT8(KGFCShort, "gfc");
+ _LIT8(KITTShort, "itt");
+ _LIT8(KMEMShort, "mem");
+ _LIT8(KPRIShort, "pri");
+
+ TInt err(KErrNone);
+
+ TBuf8<16> samplerSearchName;
+
+ // loop previous settings, update value if changed
+ for(TInt i(0);i<KSubSamplerCount;i++)
+ {
+ // go through all the sub samplers
+ switch (i)
+ {
+ case 0:
+ samplerSearchName.Copy(KGPPShort);
+ break;
+ case 1:
+ samplerSearchName.Copy(KGFCShort);
+ break;
+ case 2:
+ samplerSearchName.Copy(KITTShort);
+ break;
+ case 3:
+ samplerSearchName.Copy(KMEMShort);
+ break;
+ case 4:
+ samplerSearchName.Copy(KPRIShort);
+ break;
+ }
+
+ // get sampler specific settings
+ err = DoSetSamplerSettings(aAllSettingsArray, samplerSearchName, i);
+ }
+
+ // returns KErrNone if settings found, otherwise KErrNotFound
+ return err;
+ }
+
+/**
+ * Method for searching sampler specific settings among all settings (raw setting lines read from settings file)
+ *
+ * @param aAllSettings array of all settings from settings file
+ * @param aSamplerName short name of sampler to be searched among the settings
+ * @param aIndex index number of sampler specific sampler attributes (TSamplerAttributes)
+ * @return KErrNone if settings found ok else KErrNotFound
+ */
+TInt CGeneralsPlugin::DoSetSamplerSettings(CDesC8ArrayFlat* aAllSettings, TDesC8& aSamplerName, TInt aIndex)
+ {
+ // sampler name to be searched among the all settings
+ TBuf8<16> samplerSearch;
+ samplerSearch.Copy(KBracketOpen);
+ samplerSearch.Append(aSamplerName);
+ samplerSearch.Append(KBracketClose);
+
+ // read a line from ALL settings array
+ for (TInt i(0); i<aAllSettings->MdcaCount(); i++)
+ {
+ // check if this line has a setting block start, i.e. contains [xxx] in it
+ if (aAllSettings->MdcaPoint(i).CompareF(samplerSearch) == 0)
+ {
+ // right settings block found, now loop until the next block is found
+ for(TInt j(i+1);j<aAllSettings->MdcaCount();j++)
+ {
+ // check if the next settings block was found
+ if(aAllSettings->MdcaPoint(j).Left(1).CompareF(KBracketOpen) != 0)
+ {
+ // save found setting value directly to its owners attributes
+ SaveSettingToAttributes(aAllSettings->MdcaPoint(j), aIndex);
+ }
+ else
+ {
+ // next block found, return KErrNone
+ return KErrNone;
+ }
+ }
+ }
+ }
+ // no settings found for specific sampler
+ return KErrNotFound;
+ }
+
+/**
+ * Method for setting a specific descriptor (from settings file) to attribute structure
+ *
+ * @param aSetting
+ * @param aName
+ */
+void CGeneralsPlugin::SaveSettingToAttributes(const TDesC8& aSetting, TInt aIndex)
+ {
+ // local literals
+ _LIT8(KSettingItemSeparator, "=");
+
+ // find the equal mark from the setting line
+ TInt sepPos = aSetting.Find(KSettingItemSeparator);
+ // check that '=' is found
+ if (sepPos > 0)
+ {
+ // check that the element matches
+ if (aSetting.Left(sepPos).CompareF(KEnabled) == 0)
+ {
+ TBool en;
+ CSamplerPluginInterface::Str2Bool(aSetting.Right(aSetting.Length()-sepPos-1), en);
+ if(en != iSamplerAttributes->At(aIndex).iEnabled)
+ {
+ iSamplerAttributes->At(aIndex).iEnabled = en;
+ }
+ }
+ else if (aSetting.Left(sepPos).CompareF(KSamplingPeriod) == 0)
+ {
+ TInt sr;
+ CSamplerPluginInterface::Str2Int(aSetting.Right(aSetting.Length()-sepPos-1), sr);
+ if(sr != iSamplerAttributes->At(aIndex).iSampleRate)
+ {
+ iSamplerAttributes->At(aIndex).iSampleRate = sr;
+ }
+ }
+ }
+ }
+
+
+TUid CGeneralsPlugin::Id(TInt aSubId) const
+ {
+ if(aSubId == PROFILER_GPP_SAMPLER_ID)
+ return KSamplerGppPluginUid;
+ else if (aSubId == PROFILER_GFC_SAMPLER_ID)
+ return KSamplerGfcPluginUid;
+ else if (aSubId == PROFILER_ITT_SAMPLER_ID)
+ return KSamplerIttPluginUid;
+ else if (aSubId == PROFILER_MEM_SAMPLER_ID)
+ return KSamplerMemPluginUid;
+ else if (aSubId == PROFILER_PRI_SAMPLER_ID)
+ return KSamplerPriPluginUid;
+ else
+ return KSamplerGeneralsPluginUid;
+ }
+
+TInt CGeneralsPlugin::SubId(TUid aId) const
+ {
+/* definitions from ProfilerConfig.h:
+ * #define PROFILER_GPP_SAMPLER_ID 1
+ #define PROFILER_GFC_SAMPLER_ID 2
+ #define PROFILER_ITT_SAMPLER_ID 3
+ #define PROFILER_MEM_SAMPLER_ID 4
+ #define PROFILER_PRI_SAMPLER_ID 5
+ */
+
+ if(aId == KSamplerGppPluginUid)
+ return PROFILER_GPP_SAMPLER_ID;
+ else if (aId == KSamplerGfcPluginUid)
+ return PROFILER_GFC_SAMPLER_ID;
+ else if (aId == KSamplerIttPluginUid)
+ return PROFILER_ITT_SAMPLER_ID;
+ else if (aId == KSamplerMemPluginUid)
+ return PROFILER_MEM_SAMPLER_ID;
+ else if (aId == KSamplerPriPluginUid)
+ return PROFILER_PRI_SAMPLER_ID;
+ else
+ return KErrNotFound;
+ }
+
+TInt CGeneralsPlugin::GetSamplerType()
+ {
+ return iSamplerType;
+ }
+
+//TInt CGeneralsPlugin::GetSubCount()
+// {
+// return (TInt)KSubSamplerCount;
+// }
+
+
+TInt CGeneralsPlugin::GetSamplerUidByName(TDesC8& aName)
+ {
+ if(aName.Compare(KGPPShortName) == 0)
+ {
+ LOGTEXT(_L("GPP trace option"));
+ return KSamplerGppPluginUid.iUid;
+ }
+ else if(aName.Compare(KGFCShortName) == 0)
+ {
+ LOGTEXT(_L("GFC trace option"));
+ return KSamplerGfcPluginUid.iUid;
+ }
+ else if(aName.Compare(KITTShortName) == 0)
+ {
+ LOGTEXT(_L("ITT trace option"));
+ return KSamplerIttPluginUid.iUid;
+ }
+ else if(aName.Compare(KMEMShortName) == 0)
+ {
+ LOGTEXT(_L("MEM trace option"));
+ return KSamplerMemPluginUid.iUid;
+ }
+ else if(aName.Compare(KPRIShortName) == 0)
+ {
+ LOGTEXT(_L("PRI trace option"));
+ return KSamplerPriPluginUid.iUid;
+ }
+
+ return -1;
+
+ }
+
+void CGeneralsPlugin::GetCaption( TDes& aCaption, TInt aType, TInt aSubId ) const
+ {
+ if(aSubId == -1)
+ {
+ aCaption.Copy(_L(""));
+ return;
+ }
+ else if(aSubId == KSamplerGppPluginUid.iUid)
+ {
+ aCaption.Copy(KGPPShortName);
+ }
+ else if(aSubId == KSamplerIttPluginUid.iUid)
+ {
+ aCaption.Copy(KITTShortName);
+ }
+ else if(aSubId == KSamplerGfcPluginUid.iUid)
+ {
+ aCaption.Copy(KGFCShortName);
+ }
+ else if(aSubId == KSamplerMemPluginUid.iUid)
+ {
+ aCaption.Copy(KMEMShortName);
+ }
+ else if(aSubId == KSamplerPriPluginUid.iUid)
+ {
+ aCaption.Copy(KPRIShortName);
+ }
+ else
+ {
+ aCaption.Copy(KGENShortName);
+ }
+
+ aCaption.TrimRight();
+ LOGSTRING2("CGeneralsPlugin::GetCaptionL() - plug-in name: %S", &aCaption);
+ }
+
+
+void CGeneralsPlugin::InstallStreamForActiveTraces(RGeneralsSampler& sampler, CProfilerSampleStream& aStream)
+ {
+ // output mode for this trace is stream
+ if(!iBufferHandler)
+ {
+ // stream object has not been created yet
+ LOGTEXT(_L("CGeneralsPlugin::InstallStreamForActiveTraces - creating stream for trace"));
+
+ // use a 32KB buffer to transfer data from sampler to client
+ // commonStream = new RProfilerSampleStream(sampler,totalPrefix,32768);
+ TRAPD(err, iBufferHandler = CProfilerBufferHandler::NewL(aStream, sampler));
+ if(err != KErrNone)
+ {
+ LOGTEXT(_L("CGeneralsPlugin::InstallStreamForActiveTraces() - No memory"));
+ return;
+ }
+ }
+
+ // initiate receiving of data from the sampler device driver
+ if(iBufferHandler)
+ {
+ iBufferHandler->StartReceivingData();
+ }
+}
+
+void CGeneralsPlugin::SetSettingsToSamplers()
+ {
+ TSamplerAttributes attr;
+
+ // loop through the setting attributes
+ for(TInt i(0);i<iSamplerAttributes->Count();i++)
+ {
+ // get the attribute container
+ attr = iSamplerAttributes->At(i);
+
+ // make changes according to right sampler, NOTE! The old IDs of sub samplers (i+1)!
+ if(attr.iEnabled)
+ {
+ iGeneralsSampler.MarkTraceActive(i+1);
+
+ // set enabled
+ iEnabled = ETrue;
+ }
+ else
+ {
+ iGeneralsSampler.MarkTraceInactive(i+1);
+ }
+ // set sampling period if available
+ if(attr.iSampleRate != KErrNotFound)
+ {
+ iGeneralsSampler.SetSamplingPeriod(i+1, attr.iSampleRate);
+ }
+ }
+ }
+
+TInt CGeneralsPlugin::ResetAndActivateL(CProfilerSampleStream& aStream)
+ {
+ // the sampler starting functionality
+ LOGTEXT(_L("CGeneralsPlugin::ResetAndActivate() - entry"));
+
+ // now before starting the latest settings must be set to samplers itself
+ SetSettingsToSamplers();
+
+ if(Enabled())
+ {
+ LOGTEXT(_L("CGeneralsPlugin::ResetAndActivate() - starting sampling..."));
+ // start sampling process of enabled sub samplers
+ iGeneralsSampler.StartSampling();
+ LOGTEXT(_L("CGeneralsPlugin::ResetAndActivate() - installing stream for an active trace..."));
+
+ // install the trace for enabled samplers
+ InstallStreamForActiveTraces(iGeneralsSampler, aStream);
+ LOGSTRING2("CGeneralsPlugin::ResetAndActivate() - stream installed: 0x%x", aStream);
+ }
+
+ LOGTEXT(_L("CGeneralsPlugin::ResetAndActivate() - exit"));
+ return KErrNone;
+ }
+
+TInt CGeneralsPlugin::StopSampling()
+ {
+ // RDebug::Print(_L("CGeneralsPlugin::StopSampling() - Stopping sampler LDD"));
+ iGeneralsSampler.StopSampling();
+ // RDebug::Print(_L("CGeneralsPlugin::StopSampling() - Sampler LDD stopped"));
+
+ // check if bufferhandler has died
+ if(iBufferHandler)
+ {
+ // RDebug::Print(_L("CGeneralsPlugin::StopSampling() - Canceling the buffer handler"));
+ iBufferHandler->Cancel();
+ delete iBufferHandler;
+ iBufferHandler = NULL;
+ }
+ // set enabled
+ iEnabled = EFalse;
+ // RDebug::Print(_L("CGeneralsPlugin::StopSampling() - exit"));
+ return KErrNone;
+ }
+
+
+