void SDL_SYS_WaitThread(SDL_Thread *thread) { RUndertaker taker; taker.Create(); TRequestStatus status; taker.Logon(status, thread->handle); User::WaitForRequest(status); taker.Close(); }
static TInt CatalogsUndertaker() { DLTRACEIN(("")); TFullName catalogsThreadName; TInt err = User::GetDesParameter( 15, catalogsThreadName ); if( err != KErrNone ) { DLERROR(( "Failed to read parameter slot 15, error %d", err )); catalogsThreadName = KNullDesC(); } else { DLINFO(( _L("Read catalogs thread name: %S"), &catalogsThreadName )); } RUndertaker undertaker; TRequestStatus status; TInt deadThreadHandleNumber; undertaker.Create(); for( ;; ) { undertaker.Logon( status, deadThreadHandleNumber ); User::WaitForRequest( status ); RThread deadThread; deadThread.SetHandle( deadThreadHandleNumber ); const TDesC* type; switch( deadThread.ExitType() ) { case EExitKill: type = &KExitTypeKill; break; case EExitTerminate: type = &KExitTypeTerminate; break; case EExitPanic: type = &KExitTypePanic; break; default: type = &KExitTypeUnknown; DLERROR(( "Exit type: %d", (TInt)deadThread.ExitType() )); break; } DLWARNING(( _L("THREAD %S DEATH observed! %S %S %d"), &deadThread.FullName(), type, &deadThread.ExitCategory(), deadThread.ExitReason() )); type = type; // to suppress compiler warning if( catalogsThreadName == deadThread.FullName() ) { DLERROR(( "Catalogs server thread killed, undertaker exits" )); deadThread.Close(); break; } deadThread.Close(); } undertaker.Close(); DLTRACEOUT(("KErrNone")); return KErrNone; }
//! @SYMTestCaseID t_cputime_1 //! @SYMTestType CT //! @SYMTestCaseDesc Thread CPU time tests //! @SYMREQ CR RFID-66JJKX //! @SYMTestActions Tests cpu time when a thread is put through the various states //! @SYMTestExpectedResults Reported cpu time increses only when the thread is running //! @SYMTestPriority High //! @SYMTestStatus Defined void TestThreadCpuTime() { test.Start(_L("CPU thread time unit tests")); TThreadParam threadParam; FailIfError((threadParam.iSem).CreateLocal(0)); threadParam.iCpu = 0; // Later tests will exercise other CPUs RThread thread; RUndertaker u; TInt h; TRequestStatus s; FailIfError(thread.Create(_L("Thread"), ThreadFunction, 1024, NULL, &threadParam)); thread.SetPriority(EPriorityLess); FailIfError(u.Create()); FailIfError(u.Logon(s,h)); test(s==KRequestPending); TTimeIntervalMicroSeconds time, time2; TInt64 us; // Test cpu time is initially zero FailIfError(thread.GetCpuTime(time)); test(time == 0); // Test cpu time is not increased while thread is waiting on semaphore thread.Resume(); User::After(KShortWait); FailIfError(thread.GetCpuTime(time2)); us = time2.Int64(); test.Printf(_L("Time %dus\n"), us); test(us < KTolerance); // wait should happen in less than 1ms // Test cpu time increases when thread allowed to run // We want to allow 2% tolerance for the thread's CPU time, as there could be // something else running on the system during that time which would result lower CPU time than the // actual KShortPeriod or KLongPeriod wait time. // Also User::After(t) might return within the range of <t, t + 1000000/64 + 2*NanoKarnelTickPeriod>. // Given all that - we expect that the the cpu time should be within the range of: // <t - 0.02*t, t + 15625 + 2*NanoKernelTickPeriod> // or <0.98*t, t + 15625 + 2*NanoKernelTickPeriod> TInt user_after_tolerance = 0; HAL::Get(HAL::ENanoTickPeriod, user_after_tolerance); user_after_tolerance += user_after_tolerance + 15625; (threadParam.iSem).Signal(); User::After(KShortWait); FailIfError(thread.GetCpuTime(time)); us = time.Int64() - time2.Int64(); test.Printf(_L("Time %dus\n"), us); test(100*us >= 98*KShortWait); // left limit test(us - KShortWait <= user_after_tolerance); // right limit FailIfError(thread.GetCpuTime(time)); User::After(KLongWait); FailIfError(thread.GetCpuTime(time2)); us = time2.Int64() - time.Int64(); test.Printf(_L("Time %dus\n"), us); test(100*us >= 98*KLongWait); // left limit test(us - KLongWait <= user_after_tolerance); // right limit // Test not increased while suspended thread.Suspend(); FailIfError(thread.GetCpuTime(time)); User::After(KShortWait); FailIfError(thread.GetCpuTime(time2)); test(time == time2); thread.Resume(); // Test not increased while dead thread.Kill(KErrNone); User::WaitForRequest(s); // wait on undertaker since that completes in supervisor thread FailIfError(thread.GetCpuTime(time)); User::After(KShortWait); FailIfError(thread.GetCpuTime(time2)); test(time == time2); RThread t; t.SetHandle(h); test(t.Id()==thread.Id()); t.Close(); u.Close(); thread.Close(); (threadParam.iSem).Close(); test.End(); }