sl@0: /*
sl@0: * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: * All rights reserved.
sl@0: * This component and the accompanying materials are made available
sl@0: * under the terms of "Eclipse Public License v1.0"
sl@0: * which accompanies this distribution, and is available
sl@0: * at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: *
sl@0: * Initial Contributors:
sl@0: * Nokia Corporation - initial contribution.
sl@0: *
sl@0: * Contributors:
sl@0: *
sl@0: * Description: 
sl@0: *
sl@0: */
sl@0: 
sl@0: 
sl@0: /**
sl@0:  @file
sl@0:  @test
sl@0:  @internalComponent - Internal Symbian test code
sl@0: */
sl@0: 
sl@0: 
sl@0: #include <e32math.h>
sl@0: #include "egltest_threadmonitor.h"
sl@0: 
sl@0: 
sl@0: //CThreadMonitor creates a new monitor thread and instanciates a CThreadMonitorBackend object.
sl@0: //The thread monitor backend is constructed on the monitor thread's heap and only 
sl@0: //runs in that context. It creates a CThread instance for each thread that it needs
sl@0: //to monitor. The CThread instance reports back to the monitor backend when the
sl@0: //thread that it wraps has exitted. The backend is then responsible for deciding 
sl@0: //how to respond: If the exit type is a panic, it forwards that panic to all the 
sl@0: //other threads, then exits itself. Note: The controller thread MUST be at position
sl@0: //zero in the passed in array.
sl@0: class CThreadMonitorBackend : public CActive
sl@0:     {
sl@0: private:
sl@0:     class CThread : public CActive
sl@0:         {
sl@0:     public:
sl@0:         static CThread* NewL(const TThreadId& aThread, CThreadMonitorBackend& aMonitor);
sl@0:         ~CThread();
sl@0:         void Panic(TInt aExitReason, const TExitCategoryName& aExitCategory);
sl@0:         
sl@0:     private:
sl@0:         CThread(CThreadMonitorBackend& aMonitor);
sl@0:         void ConstructL(const TThreadId& aThread);
sl@0:         void RunL();
sl@0:         void DoCancel();
sl@0:     
sl@0:     private:
sl@0:         CThreadMonitorBackend& iMonitor;
sl@0:         RThread iThread;
sl@0:         };
sl@0: 
sl@0: public:
sl@0:     static CThreadMonitorBackend* NewL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel);
sl@0:     ~CThreadMonitorBackend();
sl@0:     void StartMonitoring();
sl@0:     void ThreadExitted(CThread* aThread, TExitType aExitType, TInt aExitReason, const TExitCategoryName& aExitCategory);
sl@0:     
sl@0: private:
sl@0:     CThreadMonitorBackend(TRequestStatus*& aNotifyCancel);
sl@0:     void ConstructL(const RArray<TThreadId>& aThreadsToMonitor);
sl@0:     TBool ThreadIsController(CThread* aThread) const;
sl@0:     void RunL();
sl@0:     void DoCancel();
sl@0:     
sl@0: private:
sl@0:     RPointerArray<CThread> iThreads;
sl@0:     };
sl@0: 
sl@0: 
sl@0: //CThreadMonitor---------------------------------------------------------------
sl@0: 
sl@0: CThreadMonitor* CThreadMonitor::NewL(const RArray<TThreadId>& aThreadsToMonitor)
sl@0:     {
sl@0:     CThreadMonitor* self = new (ELeave) CThreadMonitor(aThreadsToMonitor);
sl@0:     CleanupStack::PushL(self);
sl@0:     self->ConstructL();
sl@0:     CleanupStack::Pop(self);
sl@0:     return self;
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitor::~CThreadMonitor()
sl@0:     {
sl@0:     //Tell the backend to stop monitoring.
sl@0:     iMonitor.RequestComplete(iNotifyCancel, KErrNone);
sl@0:     iMonitor.Close();
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitor::CThreadMonitor(const RArray<TThreadId>& aThreadsToMonitor) :
sl@0:     iThreadsToMonitor(aThreadsToMonitor)
sl@0:     {
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitor::ConstructL()
sl@0:     {
sl@0:     const TInt KStackSize = 12000;
sl@0:     const TInt KHeapMinSize = 16000;
sl@0:     const TInt KHeapMaxSize = 1000000;
sl@0:     
sl@0:     TUint32 random = Math::Random();
sl@0:     TName threadName;
sl@0:     _LIT(KThreadNameFormat, "%S-%u");
sl@0:     _LIT(KMonitorName, "EpThreadMonitor");
sl@0:     threadName.Format(KThreadNameFormat, &KMonitorName, random);
sl@0:     
sl@0:     User::LeaveIfError(iMonitor.Create(threadName, MonitorThreadEntry, KStackSize, KHeapMinSize, KHeapMaxSize, this, EOwnerThread));
sl@0:     TRequestStatus rendezvous;
sl@0:     iMonitor.Rendezvous(rendezvous);
sl@0:     iMonitor.Resume();
sl@0:     User::WaitForRequest(rendezvous);
sl@0:     User::LeaveIfError(rendezvous.Int());
sl@0:     ASSERT(iNotifyCancel);
sl@0:     }
sl@0: 
sl@0: 
sl@0: TInt CThreadMonitor::MonitorThreadEntry(TAny* aSelf)
sl@0:     {
sl@0:     CThreadMonitor* self = static_cast<CThreadMonitor*>(aSelf);
sl@0:     CTrapCleanup* cleanup = CTrapCleanup::New();
sl@0:     
sl@0:     TRAPD(err, MonitorThreadEntryL(self->iThreadsToMonitor, self->iNotifyCancel));
sl@0:     __ASSERT_ALWAYS(err == KErrNone, User::Invariant());
sl@0: 
sl@0:     delete cleanup;
sl@0:     return KErrNone;
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitor::MonitorThreadEntryL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel)
sl@0:     {
sl@0:     //Create active scheduler.
sl@0:     CActiveScheduler* scheduler = new (ELeave) CActiveScheduler();
sl@0:     CleanupStack::PushL(scheduler);
sl@0:     CActiveScheduler::Install(scheduler);
sl@0: 
sl@0:     //Create the monitor and start monitoring.
sl@0:     CThreadMonitorBackend* monitor = CThreadMonitorBackend::NewL(aThreadsToMonitor, aNotifyCancel);
sl@0:     RThread().Rendezvous(KErrNone);
sl@0:     monitor->StartMonitoring();
sl@0:     delete monitor;
sl@0: 
sl@0:     //Clean up.
sl@0:     CleanupStack::PopAndDestroy(scheduler);
sl@0:     }
sl@0: 
sl@0: //-----------------------------------------------------------------------------
sl@0: 
sl@0: 
sl@0: //CThreadMonitorBackend--------------------------------------------------------
sl@0: 
sl@0: CThreadMonitorBackend* CThreadMonitorBackend::NewL(const RArray<TThreadId>& aThreadsToMonitor, TRequestStatus*& aNotifyCancel)
sl@0:     {
sl@0:     CThreadMonitorBackend* self = new (ELeave) CThreadMonitorBackend(aNotifyCancel);
sl@0:     CleanupStack::PushL(self);
sl@0:     self->ConstructL(aThreadsToMonitor);
sl@0:     CleanupStack::Pop(self);
sl@0:     return self;
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitorBackend::CThreadMonitorBackend(TRequestStatus*& aNotifyCancel) :
sl@0:     CActive(CActive::EPriorityStandard)
sl@0:     {
sl@0:     CActiveScheduler::Add(this);
sl@0:     iStatus = KRequestPending;
sl@0:     SetActive();
sl@0:     
sl@0:     //Pass the cancel TRequestStatus back to the controller thread.
sl@0:     aNotifyCancel = &iStatus;
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::ConstructL(const RArray<TThreadId>& aThreadsToMonitor)
sl@0:     {
sl@0:     //Reserve the space up front so we can gaurantee that the append will not fail.
sl@0:     //This way we don't need to use the cleanup stack to hold the new CThread while
sl@0:     //we attempt to append.
sl@0:     iThreads.ReserveL(aThreadsToMonitor.Count());
sl@0:     for(TInt i=0; i < aThreadsToMonitor.Count(); i++)
sl@0:         {
sl@0:         iThreads.Append(CThread::NewL(aThreadsToMonitor[i], *this));
sl@0:         }
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitorBackend::~CThreadMonitorBackend()
sl@0:     {
sl@0:     Cancel();
sl@0:     iThreads.ResetAndDestroy();
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::StartMonitoring()
sl@0:     {
sl@0:     CActiveScheduler::Start();
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::ThreadExitted(CThread* aThread, TExitType aExitType, TInt aExitReason, const TExitCategoryName& aExitCategory)
sl@0:     {
sl@0:     //If a worker thread exits normally, do nothing.
sl@0:     //If a worker thread panics, forward the panic to all other threads and stop active scheduler.
sl@0:     //If the controller thread exits normally, stop active scheduler.
sl@0:     //If the controller thread panics, forward the panic to all other threads and stop active scheduler.
sl@0:     
sl@0:     //Stop monitoring according to above.
sl@0:     if(ThreadIsController(aThread) || aExitType == EExitPanic)
sl@0:         {
sl@0:         CActiveScheduler::Stop();
sl@0:         }
sl@0: 
sl@0:     //Forward panic according to above. Second condition is for when controller times out.
sl@0:     if(aExitType == EExitPanic || (ThreadIsController(aThread) && aExitType == EExitKill && aExitReason == KErrTimedOut))
sl@0:         {
sl@0:         for(TInt i=0; i < iThreads.Count(); i++)
sl@0:             {
sl@0:             iThreads[i]->Panic(aExitReason, aExitCategory);
sl@0:             }
sl@0:         }
sl@0:     }
sl@0: 
sl@0: 
sl@0: TBool CThreadMonitorBackend::ThreadIsController(CThread* aThread) const
sl@0:     {
sl@0:     //The controller thread must be at index zero in the passed in array.
sl@0:     //Due to way we construct, we gaurantee that it is also at index zero in iThread.
sl@0:     return (iThreads.Count() > 0) && (iThreads[0] == aThread);
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::RunL()
sl@0:     {
sl@0:     //The client has destructed the CThreadMonitor object, 
sl@0:     //so stop the active scheduler so we exit the thread.
sl@0:     CActiveScheduler::Stop();
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::DoCancel()
sl@0:     {
sl@0:     //Not ideal, but we should only get here if the thread that created 
sl@0:     //the original ConitorThread panics, so it should be safe.
sl@0:     TRequestStatus* status =&iStatus;
sl@0:     User::RequestComplete(status, KErrCancel);
sl@0:     }
sl@0: 
sl@0: //-----------------------------------------------------------------------------
sl@0: 
sl@0: 
sl@0: //CThreadMonitorBackend::CThread-----------------------------------------------
sl@0: 
sl@0: CThreadMonitorBackend::CThread* CThreadMonitorBackend::CThread::NewL(const TThreadId& aThread, CThreadMonitorBackend& aMonitor)
sl@0:     {
sl@0:     CThread* self = new (ELeave) CThread(aMonitor);
sl@0:     CleanupStack::PushL(self);
sl@0:     self->ConstructL(aThread);
sl@0:     CleanupStack::Pop(self);
sl@0:     return self;
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitorBackend::CThread::CThread(CThreadMonitorBackend& aMonitor) :
sl@0:     CActive(CActive::EPriorityStandard),
sl@0:     iMonitor(aMonitor)
sl@0:     {
sl@0:     CActiveScheduler::Add(this);
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::CThread::ConstructL(const TThreadId& aThread)
sl@0:     {
sl@0:     User::LeaveIfError(iThread.Open(aThread, EOwnerThread));
sl@0:     iThread.Logon(iStatus);
sl@0:     SetActive();
sl@0:     }
sl@0: 
sl@0: 
sl@0: CThreadMonitorBackend::CThread::~CThread()
sl@0:     {
sl@0:     Cancel();
sl@0:     iThread.Close();
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::CThread::Panic(TInt aExitReason, const TExitCategoryName& aExitCategory)
sl@0:     {
sl@0:     iThread.Panic(aExitCategory, aExitReason);
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::CThread::RunL()
sl@0:     {
sl@0:     //Inform the monitor backend that the thread exitted.
sl@0:     TExitCategoryName category = iThread.ExitCategory();
sl@0:     TInt reason = iThread.ExitReason();
sl@0:     TExitType type = iThread.ExitType();
sl@0:     iMonitor.ThreadExitted(this, type, reason, category);
sl@0:     }
sl@0: 
sl@0: 
sl@0: void CThreadMonitorBackend::CThread::DoCancel()
sl@0:     {
sl@0:     iThread.LogonCancel(iStatus);
sl@0:     }
sl@0: 
sl@0: //-----------------------------------------------------------------------------