FCL/sf/os/osrndtools: comparison perfsrv/piprofiler/plugins/GeneralsPlugin/inc/MemSamplerImpl.h

equal deleted inserted replaced

-:aa2539c91954
+:1c2bb2fc7c87
 const TInt KProfilerMaxChunksAmount = 1024;
 const TInt KProfilerMaxLibrariesAmount = 1024;
 const TInt KProfilerTotalMemorySamplePeriod = 100;
 // flags
+//#ifndef __SMP__
 #define MEM_EVENT_HANDLER
 //#define MEM_EVENT_HANDLER_LIBRARY_EVENTS
+//#endif
 /*
 *
 *	MEM sampler definition
 *
 		EStartingToProcess,
 		EProcessingNames,
 		EProcessingData,
 		ENothingToProcess
 	};
-#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
 	enum ESampleType
 	{
 	    ESampleChunks,
 	    ESampleThreads,
 	    ESampleLibraries
 	};
-#endif
 	DMemSamplerImpl();
 	~DMemSamplerImpl();
 	TInt	CreateFirstSample();
-	TInt	SampleImpl();
+	TInt	SampleImpl(TUint32 sampleNum);
-	TBool	SampleNeeded();
+	TBool	SampleNeeded(TUint32 sampleNum);
 	void	Reset();
 	TInt	ProcessChunks();
 	TInt    ProcessThreads();
 TInt    GatherChunks();
 TInt    GatherThreads();
 	TInt	EncodeNameCode();
 	TInt	EncodeDataCode();
 	DChunk*		heapChunksToSample[KProfilerMaxChunksAmount];
 	DChunk*		heapChunkNamesToReport[KProfilerMaxChunksAmount];
-	TInt		iCount;
+	TUint32		iCount;
 	TInt		iChunkCount;
 	TInt		iNewChunkCount;
 	TBuf8<0x50> name;
 	DThread*	threadsToSample[KProfilerMaxThreadsAmount];
 	DThread*	threadNamesToReport[KProfilerMaxThreadsAmount];
 	TInt		iThreadCount;
 	TInt		iNewThreadCount;
+	TInt        iHandledThreads;
+	TInt        iHandledChunks;
+	TInt        iHandledLibs;
 #ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
 	DLibrary*   librariesToSample[KProfilerMaxLibrariesAmount];
 	DLibrary*   libraryNamesToReport[KProfilerMaxLibrariesAmount];
 	TInt        iLibraryCount;
 	TInt        iNewLibraryCount;
 #endif
 	TInt		iChunksProcessing;
 TInt        iThreadsProcessing;
 	TInt		iMemSamplingPeriod;
-	TInt		iMemSamplingPeriodDiv2;
+	//TInt		iMemSamplingPeriodDiv2;
-	TInt        iMemSamplingPeriodDiv3;
+	//TInt        iMemSamplingPeriodDiv3;
-#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
 	ESampleType iSampleType;
-#else
-	TBool		iSampleThreads;
-#endif
 	TBool       iTimeToSample;
 	TBool 		iTotalMemoryOk;
 	TBool		iTotalMemoryNameOk;
 	TUint8		sample[KSampleBufferSize];
 	TPtr8		sampleDescriptor;
+	TInt        iThreadsHandled;
-	// test
+	TInt        iChunksHandled;
 #ifdef MEM_EVENT_HANDLER
-//	DMemoryEventHandler*   iEventHandler;
 	TBool      iChunksGathered;
 	TBool      iThreadsGathered;
 #ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
 	TBool      iLibrariesGathered;
 #endif
 {
 public:
 	DProfilerMemSampler(struct TProfilerGppSamplerData*, TInt id);
 	~DProfilerMemSampler();
-	void	Sample();
+	void	Sample(TAny* aPtr);
 	TInt	Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset);
 	TInt	PostSample();
 	TBool	PostSampleNeeded();
 private:
 DMemoryEventHandler*               iEventHandler;
 #endif
 	DMemSamplerImpl			           memSamplerImpl;
 	struct TProfilerGppSamplerData*    gppSamplerData;
 	TBool                              sampleNeeded;
+TUint32                         iSyncOffset;
 };
 /*
 *
 *	MEM sampler implementation
 DProfilerMemSampler<BufferSize>::DProfilerMemSampler(struct TProfilerGppSamplerData* gppSamplerDataIn, TInt id) :
 	DProfilerGenericSampler<BufferSize>(PROFILER_MEM_SAMPLER_ID)
 {
 LOGSTRING2("DProfilerMemSampler<%d>::CProfilerMemSampler",BufferSize);
 	this->gppSamplerData = gppSamplerDataIn;
+#ifndef MEM_EVENT_HANDLER
 	this->iSamplingPeriod = 3000;	// set default setting
+#endif
+iSyncOffset = 0;
 }
 template <int BufferSize>
 TInt DProfilerMemSampler<BufferSize>::Reset(DProfilerSampleStream* aStream, TUint32 aSyncOffset)
 {
-//#ifdef MEM_EVENT_HANDLER
+iSyncOffset = aSyncOffset;
-//    Kern::Printf("DProfilerMemSampler<%d>::Reset - calling superclass reset",BufferSize);
-//#endif
 // check if reset called in stop (by driver)
-if(aSyncOffset != 999999)
+if(iSyncOffset != KStateSamplingEnding)
 {
 DProfilerGenericSampler<BufferSize>::Reset(aStream);
 memSamplerImpl.Reset();
 #ifdef MEM_EVENT_HANDLER
 // memory event handler
 if(iEventHandler)
 {
 // stop previous sampling if still running
-//            Kern::Printf("Stopping DMemoryEventHandler");
 iEventHandler->Stop();
-iEventHandler->Close();
+}
-iEventHandler = NULL;
+else
-}
+{
+iEventHandler = new DMemoryEventHandler(this->iSampleBuffer, this->gppSamplerData);
-//        Kern::Printf("Initiating DMemoryEventHandler");
+}
-iEventHandler = new DMemoryEventHandler(this->iSampleBuffer);
 if(iEventHandler)
 {
-//            Kern::Printf("Creating DMemoryEventHandler");
 TInt err(iEventHandler->Create());
 if(err != KErrNone)
 {
 Kern::Printf("Error in creation of DMemoryEventHandler, error %d", err);
 return err;
 return KErrGeneral;
 }
 // set first chunk&thread memory lookup at the 5 ms, should be enough
 #ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
-this->memSamplerImpl.iMemSamplingPeriod = 45;
+this->memSamplerImpl.iMemSamplingPeriod = 10;
 #else
 this->memSamplerImpl.iMemSamplingPeriod = 10;
 #endif
-#else
+#else   // ifdef mem event handler
 this->memSamplerImpl.iMemSamplingPeriod = this->iSamplingPeriod;
 #endif
-this->memSamplerImpl.iMemSamplingPeriodDiv2 = (TInt)(this->memSamplerImpl.iMemSamplingPeriod / 2);
+//        this->memSamplerImpl.iMemSamplingPeriodDiv2 = (TInt)(this->memSamplerImpl.iMemSamplingPeriod / 2);
-#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
+//#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
-this->memSamplerImpl.iMemSamplingPeriodDiv3 = (TInt)(this->memSamplerImpl.iMemSamplingPeriod / 3);
+//        this->memSamplerImpl.iMemSamplingPeriodDiv3 = (TInt)(this->memSamplerImpl.iMemSamplingPeriod / 3);
-#endif
+//#endif
 LOGSTRING3("CProfilerMemSampler<%d>::Reset - set mem sampling period to %d",
 BufferSize,this->memSamplerImpl.iMemSamplingPeriod);
 }
-	else
+	else   // iSyncOffset == KStateSamplingEnding
 {
 LOGSTRING2("DProfilerMemSampler<%d>::Reset - reset in stop", BufferSize);
 #ifdef MEM_EVENT_HANDLER
 // destroy memory event handler
 if(iEventHandler)
 {
 // stop previous sampling if still running
-//            Kern::Printf("Stopping DMemoryEventHandler");
+LOGSTRING("Stopping DMemoryEventHandler");
 iEventHandler->Stop();
-iEventHandler->Close();
-iEventHandler = NULL;
 }
 #endif
 return KErrNone;    // return if reset called in stop
 }
 	// add MEM sample header
 	TInt length(memSamplerImpl.CreateFirstSample());
 	this->iSampleBuffer->AddSample(memSamplerImpl.sample,length);
+TUint8 memSamplerId(4);    // mem sampler id
+this->iSampleBuffer->AddSample(&memSamplerId,1);
+this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);
 	this->sampleNeeded = false;
 	LOGSTRING("DProfilerMemSampler::Reset - exit");
 	return KErrNone;
 }
 #endif
 {
 #endif
 // disable interrupts for checking the kernel containers (EChunk, EThread)
 //        TInt interruptLevel(NKern::DisableInterrupts(0));
 // first collect chunk data
-TInt length(this->memSamplerImpl.SampleImpl());
+TInt length(this->memSamplerImpl.SampleImpl(this->gppSamplerData->sampleNumber));
+LOGSTRING2("DProfilerMemSampler<>::PostSample - in post sample, clock %d", this->memSamplerImpl.iCount );
 if(length != 0)
 {
 // then, encode the sample to the buffer until no further data available
 while(length > 0)
 {
-this->iSampleBuffer->AddSample(memSamplerImpl.sample,length);
+TInt ret =this->iSampleBuffer->AddSample(memSamplerImpl.sample,length);
-length = this->memSamplerImpl.SampleImpl();
+if (ret != 0)
+{
+Kern::Printf(("DProfilerMemSampler<>::PostSample() - add to sample buffer failed, loosing data, error = %d"),ret);                            }
+length = this->memSamplerImpl.SampleImpl(this->gppSamplerData->sampleNumber);
+LOGSTRING("DProfilerMemSampler<>::PostSample - in post sample again");
 // indicate that the whole MEM sample ends by having a 0x00 in the end
 if(length == 0)
 {
-TUint8 number(0);
+TUint8 endMark(0);
 LOGSTRING("MEM sampler PostSample - all samples generated!");
-this->iSampleBuffer->AddSample(&number,1);
+this->iSampleBuffer->AddSample(&endMark,1);
 LOGSTRING2("MEM sampler PostSample - end mark added, time: %d", gppSamplerData->sampleNumber);
+if (memSamplerImpl.iThreadsGathered && !memSamplerImpl.iChunksGathered)
+{
+LOGSTRING("MEM sampler PostSample - creating timestamp for chunks!");
+// add start marker for chunks
+TUint8 memSamplerId(4);    // mem sampler id
+this->iSampleBuffer->AddSample(&memSamplerId,1);
+this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);
+}
+#ifdef MEM_EVENT_HANDLER_LIBRARY_EVENTS
+if (memSamplerImpl.iThreadsGathered && memSamplerImpl.iChunksGathered)
+{
+// add start marker for chunks
+TUint8 memSamplerId(4);    // mem sampler id
+this->iSampleBuffer->AddSample(&memSamplerId,1);
+this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);
+}
+#endif
 }
 }
 }
 // restore interrupts and continue normal execution
 //        NKern::RestoreInterrupts(interruptLevel);
 if(memSamplerImpl.iThreadsGathered && memSamplerImpl.iChunksGathered && memSamplerImpl.iLibrariesGathered)
 #else
 if(memSamplerImpl.iThreadsGathered && memSamplerImpl.iChunksGathered)
 #endif
 {
-// start memory event tracking after checking the current memory status
+if(iSyncOffset != KStateSamplingEnding)
-if(!iEventHandler->Tracking())
+{
-{
+// start memory event tracking after checking the current memory status
-iEventHandler->Start();
+if(!iEventHandler->Tracking())
-//            Kern::Printf("DProfilerMemSampler<%d>::PostSample - memory event handler started",BufferSize);
+{
-}
+LOGSTRING2("MEM sampler PostSample - Starting event handler timestamp : %x", gppSamplerData->sampleNumber);
+memSamplerImpl.iTimeToSample = false;
+iEventHandler->Start();
+LOGSTRING2("DProfilerMemSampler<%d>::PostSample - memory event handler started",BufferSize);
+}
+}
 }
 #endif
 LOGSTRING2("MEM sampler PostSample - finished sampling, time: %d", gppSamplerData->sampleNumber);
 // finally perform superclass postsample
 	TInt i(this->DProfilerGenericSampler<BufferSize>::PostSample());
+// notify event handler
+//iEventHandler->SampleHandled();
 	return i;
 }
 template <int BufferSize>
 TBool DProfilerMemSampler<BufferSize>::PostSampleNeeded()
 {
 	LOGSTRING3("DProfilerMemSampler<%d>::PostSampleNeeded - state %d",BufferSize,this->iSampleBuffer->GetBufferStatus());
-	TUint32 status(this->iSampleBuffer->iBufferStatus);
+	TUint32 status(this->iSampleBuffer->GetBufferStatus());
+if(iEventHandler)
-	if(status == DProfilerSampleBuffer::BufferCopyAsap || status == DProfilerSampleBuffer::BufferFull || this->sampleNeeded == true)
+{
-	    {
+if(iEventHandler->Tracking())
-		return true;
+{
-	    }
+this->sampleNeeded = iEventHandler->SampleNeeded();
+}
-	return false;
+}
+if(status == DProfilerSampleBuffer::BufferCopyAsap || status == DProfilerSampleBuffer::BufferFull || this->sampleNeeded == true)
+{
+return true;
+}
+return false;
 }
 template <int BufferSize>
-void DProfilerMemSampler<BufferSize>::Sample()
+void DProfilerMemSampler<BufferSize>::Sample(TAny* aPtr)
 {
-LOGSTRING2("DProfilerMemSampler<%d>::Sample",BufferSize);
+LOGSTRING3("DProfilerMemSampler<%d>::Sample, time %d",BufferSize, this->memSamplerImpl.iCount);
+if(iEventHandler)
-// check if sample is needed, i.e. the sampling interval is met
+{
-	if(memSamplerImpl.SampleNeeded())
+if(!iEventHandler->Tracking())
-	    {
+{
-// set the flag for post sampling
+// check if sample is needed, i.e. the sampling interval is met
-		this->sampleNeeded = true;
+if(memSamplerImpl.SampleNeeded(gppSamplerData->sampleNumber))
+{
-		// start the MEM sample with the sample time
+// set the flag for post sampling
-		TUint8 number(4);    // mem sampler id
+this->sampleNeeded = true;
-		this->iSampleBuffer->AddSample(&number,1);
+/*
-		this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);
+LOGSTRING2("timestamp : 0x%04x",  gppSamplerData->sampleNumber);
+// start the MEM sample with the sample time
-		// leave the rest of the processing for PostSample()
+TUint8 memSamplerId(4);    // mem sampler id
-	    }
+this->iSampleBuffer->AddSample(&memSamplerId,1);
+this->iSampleBuffer->AddSample((TUint8*)&(gppSamplerData->sampleNumber),4);
-#ifdef MEM_EVENT_HANDLER
+*/
-	// call this to increase the time stamp
+// leave the rest of the processing for PostSample()
-	else if(iEventHandler->SampleNeeded())
+}
-	    {
+}
-// set the flag for post sampling
+//#ifdef MEM_EVENT_HANDLER
-this->sampleNeeded = true;
+//	// call this to increase the time stamp
-	    }
+//	if(iEventHandler->SampleNeeded())
-//	// check if time stamp is divibable with
-//	if((memSamplerImpl.iCount % KProfilerTotalMemorySamplePeriod) == 0 &&
-//	        memSamplerImpl.iCount > 0)
 //	    {
-//        // sample total memory once per 100 ms
+//        // set the flag for post sampling
-//        memSamplerImpl.EncodeTotalMemory();
+//        this->sampleNeeded = true;
-//
-//        // add end mark
-//        TUint8 number(0);
-//        this->iSampleBuffer->AddSample(&number,1);
 //	    }
-#endif
+//#endif
+}
-	LOGSTRING2("CProfilerMemSampler<%d>::Sample",BufferSize);
 	return;
 }
 template <int BufferSize>
 DProfilerMemSampler<BufferSize>::~DProfilerMemSampler()
 #ifdef MEM_EVENT_HANDLER
 // memory event handler
 if(iEventHandler)
 {
 // stop previous sampling if still running
-//         Kern::Printf("Stopping DMemoryEventHandler");
+LOGSTRING("Stopping DMemoryEventHandler");
 iEventHandler->Stop();
 iEventHandler->Close();
 iEventHandler = NULL;
 }
 #endif

changeset 62	1c2bb2fc7c87
parent 51	98307c651589