// btrace_cpuusage.cpp

// 

// Copyright (c) 2008 - 2010 Accenture. All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the "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:

// Accenture - Initial contribution

//

#include "btrace_parser.h"

MBtraceCpuUsageObserver::TCpuUsage::TCpuUsage(const TBtraceThreadId& aId)

	: iId(aId), iNumFastTicks(0)

	{

	}

MBtraceCpuUsageObserver::TCpuUsage::TCpuUsage(const TBtraceThreadId& aId, const TBtraceTickCount& aTickCount)

	: iId(aId), iNumFastTicks(0), iSwitchedInAt(aTickCount)

	{

	}

EXPORT_C CBtraceCpuUsage* CBtraceCpuUsage::NewL(CBtraceReader& aReader, CBtraceContext& aContext)

	{

	CBtraceCpuUsage* self = new(ELeave) CBtraceCpuUsage(aReader, aContext);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CBtraceCpuUsage::~CBtraceCpuUsage()

	{

	while (iCpuUsageNotifs.Count())

		{

		iCpuUsageNotifs[0].Close();

		iCpuUsageNotifs.Remove(0);

		}

	iCpuUsageNotifs.Close();

	iContextSwitchNotifs.Close();

	iThreadIdleNotifs.Close();

	iReader.RemoveObserver(BTrace::ECpuUsage, *this);

	iReader.RemoveObserver(KAmTraceCategory, *this);

	}

EXPORT_C void CBtraceCpuUsage::NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver)

	{

	NotifyCpuUsageL(aNanoTickCount, aPeriod, aObserver, ENotificationOneShot);

	}

EXPORT_C void CBtraceCpuUsage::NotifyCpuUsageL(TUint32 aNanoTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence)

	{

	RCpuUsageNotif notif(aNanoTickCount, TBtraceUtils::MicroSecondsToNanoTicks(aPeriod), aObserver, aPersistence);

	User::LeaveIfError(iCpuUsageNotifs.Append(notif));

	}

EXPORT_C void CBtraceCpuUsage::NotifyContextSwitchL(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver)

	{

	TContextSwitchNotif notif(aId, aObserver);

	User::LeaveIfError(iContextSwitchNotifs.InsertInUnsignedKeyOrderAllowRepeats(notif));

	}

EXPORT_C void CBtraceCpuUsage::NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver)

	{

	NotifyThreadIdleL(aId, aFromTickCount, aPeriod, aObserver, ENotificationOneShot);

	}

EXPORT_C void CBtraceCpuUsage::NotifyThreadIdleL(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TTimeIntervalMicroSeconds32 aPeriod, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence)

	{

	TThreadIdleNotif notif(aId, aFromTickCount, TBtraceUtils::MicroSecondsToNanoTicks(aPeriod), aObserver, aPersistence);

	User::LeaveIfError(iThreadIdleNotifs.InsertInUnsignedKeyOrderAllowRepeats(notif));

	}

EXPORT_C void CBtraceCpuUsage::CancelNotifyThreadIdle(MBtraceCpuUsageObserver& aObserver)

	{

	for (TInt i = iThreadIdleNotifs.Count()-1; i>=0; --i)

		{

		if (iThreadIdleNotifs[i].iObserver == &aObserver)

			{

			iThreadIdleNotifs.Remove(i);

			}

		}

	}

CBtraceCpuUsage::CBtraceCpuUsage(CBtraceReader& aReader, CBtraceContext& aContext)

	: iReader(aReader), iContext(aContext)

	{

	}

void CBtraceCpuUsage::ConstructL()

	{

	iReader.AddObserverL(BTrace::ECpuUsage, *this);

	iReader.AddObserverL(KAmTraceCategory, *this); // To ensure we get heartbeat and sync frames, which are needed to flush through and force TestThreadIdlenessL to be called

	}

void CBtraceCpuUsage::HandleBtraceFrameL(const TBtraceFrame& aFrame)

	{

	if (aFrame.iCategory == BTrace::ECpuUsage)

		{

		switch (aFrame.iSubCategory)

			{

			case BTrace::ENewThreadContext:

				{

				++iNumProcessedFrames;

				const TBtraceThreadId* btraceThreadId = iContext.FindThread(aFrame.iThreadContext);

//				__ASSERT_ALWAYS(btraceThreadId, Panic(EBtpPanicUnknownCpuContext));

				if (btraceThreadId)

					{

					HandleContextSwitchL(aFrame.iTickCount, *btraceThreadId);

					}

				else

					{

					iReader.Log(_L("BTrace::ENewThreadContext: Unknown thread context 0x%08x\r\n"), aFrame.iThreadContext);

					}

				break;

				}

			default:

				{

				// Ignore anything we don't know about.

				++iNumIgnoredFrames;

				break;

				}

			}

		}

	TestCpuUsagePeriodL(aFrame.iTickCount);

	TestThreadIdlenessL(aFrame.iTickCount);

	}

CBtraceCpuUsage::RCpuUsageNotif::RCpuUsageNotif(TUint32 aStartTickCount, TUint32 aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence)

	: iStartTickCount(aStartTickCount), iNumNanoTicks(aNumNanoTicks), iObserver(&aObserver), iPersistence(aPersistence)

	{

	}

void CBtraceCpuUsage::RCpuUsageNotif::RCpuUsageNotif::Close()

	{

	iUsage.Close();

	}

CBtraceCpuUsage::TContextSwitchNotif::TContextSwitchNotif(const TBtraceThreadId& aId)

	: iId(aId), iObserver(NULL)

	{

	}

CBtraceCpuUsage::TContextSwitchNotif::TContextSwitchNotif(const TBtraceThreadId& aId, MBtraceCpuUsageObserver& aObserver)

	: iId(aId), iObserver(&aObserver)

	{

	}

CBtraceCpuUsage::TThreadIdleNotif::TThreadIdleNotif(const TBtraceThreadId& aId)

	: iId(aId), iNumNanoTicks(0), iObserver(NULL), iEverScheduled(EFalse), iPersistence(ENotificationOneShot)

	{

	}

CBtraceCpuUsage::TThreadIdleNotif::TThreadIdleNotif(const TBtraceThreadId& aId, const TBtraceTickCount& aFromTickCount, TUint aNumNanoTicks, MBtraceCpuUsageObserver& aObserver, TBtraceNotificationPersistence aPersistence)

	: iId(aId), iNumNanoTicks(aNumNanoTicks), iObserver(&aObserver), iLastSwitchedOut(aFromTickCount), iEverScheduled(EFalse), iPersistence(aPersistence)

	{

	}

void CBtraceCpuUsage::HandleContextSwitchL(const TBtraceTickCount& aTickCount, const TBtraceThreadId& aNewBtraceThreadId)

	{

	TBool relevant(EFalse);

	if (iLastBtractThreadId.Value() != 0)

		{

		// Update CPU usage notifications for the thread that has been switched out.

		for (TInt i = (iCpuUsageNotifs.Count() - 1); i >= 0; --i)

			{

			RCpuUsageNotif& notif = iCpuUsageNotifs[i];

			TInt pos = notif.iUsage.FindInUnsignedKeyOrder(MBtraceCpuUsageObserver::TCpuUsage(iLastBtractThreadId));

			if (pos >= 0)

				{

				MBtraceCpuUsageObserver::TCpuUsage& usage = notif.iUsage[pos];

				usage.iNumFastTicks += aTickCount.IntervalInFastTicks(usage.iSwitchedInAt);

				relevant = ETrue;

				}

			}

		}

	// Update CPU usage notifications to store this tick count at which this thread was switched in.

	for (TInt i = (iCpuUsageNotifs.Count() - 1); i >= 0; --i)

		{

		relevant = ETrue;

		RCpuUsageNotif& notif = iCpuUsageNotifs[i];

		TInt pos = notif.iUsage.FindInUnsignedKeyOrder(aNewBtraceThreadId);

		if (pos == KErrNotFound)

			{

			MBtraceCpuUsageObserver::TCpuUsage cpuUsage(aNewBtraceThreadId, aTickCount);

			TInt err = notif.iUsage.InsertInUnsignedKeyOrder(cpuUsage);

			__ASSERT_ALWAYS(err == KErrNone, Panic(EBtpPanicFailedToInsertCpuUsageObject));

			}

		else

			{

			notif.iUsage[pos].iSwitchedInAt = aTickCount;

			}

		}

	// Inform context switch observers that are interested in switches from the previous thread.

	TInt pos = iContextSwitchNotifs.SpecificFindInUnsignedKeyOrder(TContextSwitchNotif(iLastBtractThreadId), EArrayFindMode_First);

	if (pos >= 0)

		{

		const TInt numNotifs = iContextSwitchNotifs.Count();

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

			{

			const TContextSwitchNotif& thisNotif = iContextSwitchNotifs[i];

			if (thisNotif.iId == iLastBtractThreadId)

				{

				relevant = ETrue;

				thisNotif.iObserver->HandleContextSwitchL(aTickCount, iLastBtractThreadId, MBtraceCpuUsageObserver::EFromThisThread);

				}

			else

				{

				break;

				}

			}

		}

	// Inform context switch observers that are interested in switches to this new thread.

	pos = iContextSwitchNotifs.SpecificFindInUnsignedKeyOrder(TContextSwitchNotif(aNewBtraceThreadId), EArrayFindMode_First);

	if (pos >= 0)

		{

		const TInt numNotifs = iContextSwitchNotifs.Count();

		for (TInt i = pos; i < numNotifs; ++i)

			{

			const TContextSwitchNotif& thisNotif = iContextSwitchNotifs[i];

			if (thisNotif.iId == aNewBtraceThreadId)

				{

				relevant = ETrue;

				thisNotif.iObserver->HandleContextSwitchL(aTickCount, aNewBtraceThreadId, MBtraceCpuUsageObserver::EToThisThread);

				}

			else

				{

				break;

				}

			}

		}

	// Update thread idle notifications' last switched out time.

	pos = iThreadIdleNotifs.SpecificFindInUnsignedKeyOrder(TThreadIdleNotif(iLastBtractThreadId), EArrayFindMode_First);

	if (pos >= 0)

		{

		const TInt numNotifs = iThreadIdleNotifs.Count();

		for (TInt i = pos; i < numNotifs; ++i)

			{

			TThreadIdleNotif& thisNotif = iThreadIdleNotifs[i];

			if (thisNotif.iId == iLastBtractThreadId)

				{

				relevant = ETrue;

				thisNotif.iLastSwitchedOut = aTickCount;

				}

			else

				{

				break;

				}

			}

		}

	// Update thread idle notifications' ever scheduled.

	pos = iThreadIdleNotifs.SpecificFindInUnsignedKeyOrder(TThreadIdleNotif(aNewBtraceThreadId), EArrayFindMode_First);

	if (pos >= 0)

		{

		const TInt numNotifs = iThreadIdleNotifs.Count();

		for (TInt i = pos; i < numNotifs; ++i)

			{

			TThreadIdleNotif& thisNotif = iThreadIdleNotifs[i];

			if (thisNotif.iId == aNewBtraceThreadId)

				{

				relevant = ETrue;

				thisNotif.iEverScheduled = ETrue;

				}

			else

				{

				break;

				}

			}

		}

	iLastBtractThreadId = aNewBtraceThreadId;

	if (relevant)

		{

		++iNumRelevantFrames;

		}

	}

TInt CompareUsage(const MBtraceCpuUsageObserver::TCpuUsage& aFirst,const MBtraceCpuUsageObserver::TCpuUsage& aSecond)

	{

	if (aFirst.iNumFastTicks > aSecond.iNumFastTicks)

		{

		return -1;

		}

	else if (aFirst.iNumFastTicks < aSecond.iNumFastTicks)

		{

		return 1;

		}

	else

		{

		return 0;

		}

	}

void CBtraceCpuUsage::TestCpuUsagePeriodL(const TBtraceTickCount& aTickCount)

	{

	for (TInt i = (iCpuUsageNotifs.Count() - 1); i >= 0; --i)

		{

		RCpuUsageNotif& thisNotif = iCpuUsageNotifs[i];

		if ((aTickCount.iNano - thisNotif.iStartTickCount) >= thisNotif.iNumNanoTicks)

			{

			thisNotif.iUsage.Sort(TLinearOrder<MBtraceCpuUsageObserver::TCpuUsage>(CompareUsage));

			TArray<MBtraceCpuUsageObserver::TCpuUsage> array(thisNotif.iUsage.Array());

			thisNotif.iObserver->HandleCpuUsageL(aTickCount, array);

			if (thisNotif.iPersistence == ENotificationOneShot)

				{

				thisNotif.Close();

				iCpuUsageNotifs.Remove(i);

				}

			}

		}

	}

void CBtraceCpuUsage::TestThreadIdlenessL(const TBtraceTickCount& aTickCount)

	{

	for (TInt i = (iThreadIdleNotifs.Count() - 1); i >= 0; --i)

		{

		const TThreadIdleNotif& thisNotif = iThreadIdleNotifs[i];

		//iReader.Log(_L("CBtraceCpuUsage::TestThreadIdlenessL: now %d, lastswitch %d, remaining %d\r\n"), aTickCount.iNano, thisNotif.iLastSwitchedOut.iNano, thisNotif.iNumNanoTicks - (aTickCount.iNano - thisNotif.iLastSwitchedOut.iNano));

		if ((aTickCount.iNano > thisNotif.iLastSwitchedOut.iNano) && ((aTickCount.iNano - thisNotif.iLastSwitchedOut.iNano) >= thisNotif.iNumNanoTicks))

			{

			MBtraceCpuUsageObserver* observer = thisNotif.iObserver;

			TBtraceTickCount lastSwitchedOut = thisNotif.iLastSwitchedOut;

			TBtraceThreadId threadId = thisNotif.iId;

			MBtraceCpuUsageObserver::TIdleType idleType = thisNotif.iEverScheduled ? MBtraceCpuUsageObserver::EScheduledAtLeastOnce : MBtraceCpuUsageObserver::ENeverScheduled;

			if (thisNotif.iPersistence == ENotificationOneShot)

				{

				iThreadIdleNotifs.Remove(i);

				}

			observer->HandleThreadIdleL(lastSwitchedOut, threadId, idleType);

			}

		}

	}