/** Kills the concurrent session */ LOCAL_C void DoTestKill() { gKillMe = ETrue; User::After(10000000); gSpeedy.Kill(KErrNone); gSpeedy.Close(); gSpeedyII.Kill(KErrNone); gSpeedyII.Close(); }
/** Kills the concurrent session */ LOCAL_C void DoTestKill() { TInt r = 0; gSpeedy.Kill(KErrNone); FailIfError(r); gSpeedy.Close(); gSpeedyII.Kill(KErrNone); FailIfError(r); gSpeedyII.Close(); }
EXPORT_C void KillApplicationL(RWsSession& aWs, TUid aUid, TInt aRetryInterval ) { TTime wait_until; wait_until.HomeTime(); wait_until+=TTimeIntervalSeconds(15); TApaTaskList taskList( aWs ); for(;;) { TApaTask task = taskList.FindApp(aUid); if(! task.Exists()) { break; } TTime now; now.HomeTime(); if (now < wait_until) { task.EndTask(); //DebugMsg(_L("waiting..."), aDebugLog); User::After(TTimeIntervalMicroSeconds32(aRetryInterval*1000) ); } else { break; } } TApaTask task = taskList.FindApp(aUid); if( task.Exists()) { #ifdef __S60V3__ task.KillTask(); #else RThread t; if (t.Open(task.ThreadId())==KErrNone) { //DebugMsg(_L("killing"), aDebugLog); t.Kill(2003); t.Close(); } #endif } }
/* WARNING: This function is really a last resort. * Threads should be signaled and then exit by themselves. * TerminateThread() doesn't perform stack and DLL cleanup. */ void SDL_SYS_KillThread(SDL_Thread *thread) { RThread rthread; rthread.SetHandle(thread->handle); rthread.Kill(KErrDied); rthread.Close(); }
LOCAL_C void RunTest(TInt aSize) { const TInt KTestRunUs = KTestRunSeconds * 1000000; RThread t; TInt r=t.Create(KNullDesC,TestThread,0x1000,NULL,(TAny*)aSize); test(r==KErrNone); t.SetPriority(EPriorityLess); TRequestStatus s; t.Logon(s); t.Resume(); ServerSem.Wait(); test(Server.Handle() != KNullHandle); RMySession sess; TRequestStatus stat; test(sess.Connect(Server,stat) == KErrNone); User::WaitForRequest(stat); // connected Count=0; TPtr8 des((TUint8*)Dest, 0, aSize); sess.Test(des); User::After(KTestRunUs); t.Kill(0); User::WaitForRequest(s); sess.Close(); Server.Close(); CLOSE_AND_WAIT(t); TInt us=10*KTestRunUs/Count; test.Printf(_L("%5d byte writes: %8d/%ds %4d.%01dus\n"),aSize,Count,KTestRunSeconds,us/10,us%10); }
void TestCommitDecommit(RPageMove& pagemove, RChunk& aChunk) { test.Printf(_L("Attempt to move a page while it is being committed and decommited\n")); RThread thread; TRequestStatus s; test_KErrNone(thread.Create(_L("CommitDecommit"), &CommitDecommit, KDefaultStackSize, NULL, (TAny*)&aChunk)); thread.Logon(s); thread.SetPriority(EPriorityMore); thread.Resume(); TUint8* firstpage=(TUint8*)_ALIGN_DOWN((TLinAddr)aChunk.Base(), PageSize); for (TInt i=0; i < Repitions; i++) { TInt r = pagemove.TryMovingUserPage(firstpage, ETrue); // Allow all valid return codes as we are only testing that this doesn't // crash the kernel and the page could be commited, paged out or decommited // at any one time. test_Value(r, r <= KErrNone); } thread.Kill(KErrNone); User::WaitForRequest(s); test_Equal(EExitKill,thread.ExitType()); test_KErrNone(thread.ExitReason()); thread.Close(); }
/* * Creates a Thread that modifies its code in a tight loop while the main * thread moves the functions page around */ LOCAL_C TInt TestCodeModificationAsync(RPageMove& pagemove) { TInt ret; RThread CodeThread; TRequestStatus s; /* Create the Thread to modify the code segment */ test_KErrNone(CodeThread.Create(_L("TestCodeAsync"), TestCodeAsync, KDefaultStackSize, NULL, NULL)); CodeThread.Logon(s); CodeThread.SetPriority(EPriorityMore); CodeThread.Resume(); TestCodeSetupDrive(CodeThread); /* Loop trying to move the code page while the thread (CodeThread) modifies it */ for (TInt i=0; i<Repitions; i++) { test_KErrNone(pagemove.TryMovingUserPage((TAny*)TestCodeModFunc)); } CodeThread.Kill(KErrNone); User::WaitForRequest(s); test_Equal(EExitKill, CodeThread.ExitType()); test_KErrNone(CodeThread.ExitReason()); CodeThread.Close(); ret = TestCodeModFunc(); test(ret == 1 || ret == 2); return KErrNone; }
TInt CTimesliceTestThread::Construct(TUint32 aId, TInt aCpu, TInt aSlice, CircBuf* aBuf) { iId = aId; iCpu = aCpu; iSlice = aSlice; iBuf = aBuf; TInt r = HAL::Get(HAL::EFastCounterFrequency, (TInt&)iFreq); if (r!=KErrNone) return r; iThresh = iFreq / 3000; if (iThresh < 10) iThresh = 10; iThresh2 = iFreq; TBuf<16> name = _L("TSThrd"); name.AppendNum(iId); r = iThread.Create(name, &ThreadFunc, 0x1000, NULL, this); if (r!=KErrNone) return r; iThread.Logon(iExitStatus); if (iExitStatus != KRequestPending) { iThread.Kill(0); iThread.Close(); iThread.SetHandle(0); return iExitStatus.Int(); } return KErrNone; }
// EKA2 much simpler // Just an E32Main and a MainL() LOCAL_C void MainL() /** * Much simpler, uses the new Rendezvous() call to sync with the client */ { // Leave the hooks in for platform security #if (defined __DATA_CAGING__) RProcess().DataCaging(RProcess::EDataCagingOn); RProcess().SecureApi(RProcess::ESecureApiOn); #endif CActiveScheduler* sched=NULL; sched=new(ELeave) CActiveScheduler; CActiveScheduler::Install(sched); CMMFAudioServer* server = NULL; TRAPD(err,server = CMMFAudioServer::NewL()); // Start BT audio server in its own thread here... // Assume that the server's not been started already // RThread btServerThread; TThreadFunction btServerThreadFunc = CA2dpBTHeadsetAudioIfServer::StartThread; TName btServerName(KA2DPAudioServerName); err = btServerThread.Create(btServerName, btServerThreadFunc, KBTAudioServerStackSize, KBTAudioServerInitHeapSize, KBTAudioServerMaxHeapSize, NULL, EOwnerProcess); // NULL => not passing any params to thread if(!err) { // Synchronise with the server TRequestStatus reqStatus; btServerThread.Rendezvous(reqStatus); if (reqStatus != KRequestPending) { btServerThread.Kill(0); } else { // Start the thread btServerThread.Resume(); // Server will call the reciprocal static synchronise call } User::WaitForRequest(reqStatus); // wait for start or death } if(!err) { // Sync with the client and enter the active scheduler RProcess::Rendezvous(KErrNone); sched->Start(); } btServerThread.Close(); delete server; delete sched; }
TInt CTSISHelperStepBase::startSisHelper(Swi::TSisHelperStartParams& aParams) { // To deal with the unique thread (+semaphore!) naming in Symbian OS, and // that we may be trying to restart a server that has just exited we // attempt to create a unique thread name for the server TName name(Swi::KSisHelperServerName); name.AppendNum(Math::Random(), EHex); RThread server; const TInt KSisHelperServerStackSize=0x2000; const TInt KSisHelperServerInitHeapSize=0x1000; const TInt KSisHelperServerMaxHeapSize=0x1000000; TInt err=server.Create(name, sisHelperThreadFunction, KSisHelperServerStackSize, KSisHelperServerInitHeapSize, KSisHelperServerMaxHeapSize, static_cast<TAny*>(&aParams), EOwnerProcess); if (err!=KErrNone) return err; // The following code is the same whether the server runs in a new thread // or process TRequestStatus stat; server.Rendezvous(stat); if (stat!=KRequestPending) server.Kill(0); // abort startup else server.Resume(); // logon OK, start the server User::WaitForRequest(stat); // wait for start or death // we can't use the 'exit reason' if the server panicked as this is the // panic 'reason' and may be 0 which cannot be distinguished from KErrNone err=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); server.Close(); return err; }
/** Old Test CaseID APPFWK-SUS-0008 New Test CaseID DEVSRVS-SSMA-SUS-0013 New Test CaseID DEVSRVS-SSMA-SUS-0014 New Test CaseID DEVSRVS-SSMA-SUS-0015 New Test CaseID DEVSRVS-SSMA-SUS-0016 New Test CaseID DEVSRVS-SSMA-SUS-0017 */ TVerdict CSusPlatsecTest::doTestStepL() { INFO_PRINTF1(_L("Test to make sure UtilityServer refuse connection for clients with incorrect capabilities")); __UHEAP_MARK; RProcess process; const TUint32 sid = process.SecureId(); RThread thread; CleanupClosePushL(thread); TESTL(KErrNone == StartServer(thread, sid)); //Test the RSession RSsmSusCliTest client; TInt connect = client.Connect(KTestServerName); TEST(KErrPermissionDenied == connect); client.Close(); thread.Kill(KErrNone); CleanupStack::PopAndDestroy(&thread); __UHEAP_MARKEND; return TestStepResult(); }
TInt64 runTest(TThreadFunction aFunction,const TDesC& aTitle) { RThread thread; TInt r=thread.Create(aTitle,aFunction,KDefaultStackSize,KHeapSize,KHeapSize,NULL); if(r!=KErrNone) { test.Printf(_L("Failed to create thread with error %d\n"),r); return(r); } thread.Resume(); User::After(1000000); count=0; User::After(KAverageOverInSeconds*1000000); TInt64 result=count; barrier = a; if (!barrier) barrier = c; barrier = b; if (!barrier) barrier = a; barrier = c; if (!barrier) barrier = b; thread.Kill(0); thread.Close(); result*=KNumberOfCalculationsPerLoop; result/=KAverageOverInSeconds; r=I64INT(result); test.Printf(_L("%S executed %d in 1 second\n"),&aTitle,r); return(result); }
static void TestRUpsSubsessionDeathL() { RThread thd; TRequestStatus thdStatus; User::LeaveIfError(thd.Create(_L("MyThread"), ThreadFunction, 4096, 4096, 4096, 0, EOwnerThread)); // thd.SetHandle(666); thd.Rendezvous(thdStatus); thd.Kill(KErrAbort); User::WaitForRequest(thdStatus); test.Start(_L("Testing RUpsSubsession")); RUpsSubsession clientSubsession; TInt r = clientSubsession.Initialise(sTestSession, thd); test(r == KErrNone); test.Next(_L("Query with dead thread id")); TServiceId serviceId = {43}; TUpsDecision dec = EUpsDecYes; TRequestStatus rs; thd.Close(); clientSubsession.Authorise(EFalse, serviceId, _L("req1"), dec, rs); User::WaitForRequest(rs); test(rs == KErrNone); test(dec == EUpsDecNo); clientSubsession.Close(); test.End(); }
static TInt StartServer() // // Start the server process or thread // { const TUidType serverUid(KNullUid,KNullUid,KServerUid3); #ifdef __CDLSERVER_NO_PROCESSES__ // // In EKA1 WINS the server is a DLL, the exported entrypoint returns a TInt // which represents the real entry-point for the server thread // RLibrary lib; TInt r=lib.Load(KCdlServerDllImg,serverUid); if (r!=KErrNone) return r; TLibraryFunction ordinal1=lib.Lookup(1); TThreadFunction serverFunc=reinterpret_cast<TThreadFunction>(ordinal1()); // // To deal with the unique thread (+semaphore!) naming in EPOC, and that we may // be trying to restart a server that has just exited we attempt to create a // unique thread name for the server. // This uses Math::Random() to generate a 32-bit random number for the name // TName name(KCdlServerName); name.AppendNum(Math::Random(),EHex); RThread server; r=server.Create(name,serverFunc, KCdlServerStackSize, NULL,&lib,NULL, KCdlServerInitHeapSize,KCdlServerMaxHeapSize,EOwnerProcess); lib.Close(); // if successful, server thread has handle to library now #else // // EPOC and EKA2 is easy, we just create a new server process. Simultaneous launching // of two such processes should be detected when the second one attempts to // create the server object, failing with KErrAlreadyExists. // RProcess server; TInt r=server.Create(KCdlServerExeImg,KNullDesC,serverUid); #endif if (r!=KErrNone) return r; TRequestStatus stat; server.Rendezvous(stat); if (stat!=KRequestPending) server.Kill(0); // abort startup else server.Resume(); // logon OK - start the server User::WaitForRequest(stat); // wait for start or death // we can't use the 'exit reason' if the server panicked as this // is the panic 'reason' and may be '0' which cannot be distinguished // from KErrNone r=(server.ExitType()==EExitPanic) ? KErrGeneral : stat.Int(); server.Close(); return r; }
// ----------------------------------------------------------------------------- // StartThread Starts the server thread. // Returns: TInt: error code // ----------------------------------------------------------------------------- // EXPORT_C TInt StartThread() { _WIMTRACE(_L("WIM|Scard|CScardServer::StartThread|Begin")); TInt res = KErrNone; // check server not already started TFindServer findSCardServer( KScardServerName ); TFullName name; if ( findSCardServer.Next( name ) != KErrNone ) { // create server thread RThread thread; TThreadParameter threadData; threadData.iSemaphore.CreateLocal( 0 ); res = thread.Create( KScardServerName, // name of thread CScardServer::ThreadFunction, // thread function KDefaultStackSize, KDefaultMinHeapSize, KDefaultMaxHeapSize, &threadData // parameter to thread function ); // If creation was successful, try starting the server if ( res == KErrNone ) { // now start thread thread.SetPriority( EPriorityNormal ); // set its priority thread.Resume(); // kick it into life threadData.iSemaphore.Wait(); // wait until it's got going if ( threadData.iPanicCode ) { // The server did not start properly thread.Kill( threadData.iPanicCode ); res = threadData.iPanicCode; // set the response return res; } // tidy up thread.Close(); // no longer interested in that thread } else { thread.Close(); } threadData.iSemaphore.Close(); // or semaphore } // all well return res; }
GLDEF_C TInt E32Main() { test.Title(); TBuf<256> cmd; TFullName fn; User::CommandLine(cmd); TLex lex(cmd); TPtrC threadSpec(lex.NextToken()); TFindThread ft(threadSpec); TExitType exitType=EExitKill; TInt exitCode=0; if (!lex.Eos()) { TPtrC xtSpec(lex.NextToken()); TPtrC xc(xtSpec); TChar xt0=xtSpec[0]; if (xt0.IsAlpha()) { xt0.LowerCase(); if (xt0==TChar('t')) exitType=EExitTerminate; else if (xt0==TChar('p')) exitType=EExitPanic; new(&xc) TPtrC(lex.NextToken()); } if (xc.Length()) { TLex lex2(xc); lex2.Val(exitCode); } } while (ft.Next(fn)==KErrNone) { test.Printf(_L("Killing %S\n"),&fn); RThread t; TInt r=t.Open(ft); if (r==KErrNone) { // FIXME: SHOULD REMOVE CRITICALNESS - WOULD NEED DEVICE DRIVER switch (exitType) { case EExitKill: t.Kill(exitCode); break; case EExitTerminate: t.Terminate(exitCode); break; case EExitPanic: t.Panic(KPanicCat,exitCode); break; default: break; } t.Close(); } } return 0; }
EXPORT_C TInt RMMFAudioPolicyProxy::Open(RServer2& aPolicyServerHandle) { TServerStart start(aPolicyServerHandle); TInt err = KErrNone; if(aPolicyServerHandle.Handle()) { // Server is already running and attempt to create a session // 4 message slots err = CreateSession(aPolicyServerHandle, TVersion(KMMFAudioPolicyVersion, KMMFAudioPolicyMinorVersionNumber, KMMFAudioPolicyBuildVersionNumber)); if(err != KErrNone) { return err; } } else { TThreadFunction serverFunc = CMMFAudioPolicyServer::StartThread; RThread server; err = server.Create(_L(""),serverFunc, KAudioPolicyServerStackSize, KAudioPolicyServerInitHeapSize, KAudioPolicyServerMaxHeapSize, &start, EOwnerProcess); if(err != KErrNone) return err; // Synchronise with the server TRequestStatus reqStatus; server.Rendezvous(reqStatus); if (reqStatus!=KRequestPending) { server.Kill(0); } else { // Start the test harness server.Resume(); // Server will call the reciprocal static synchronise call } User::WaitForRequest(reqStatus); // wait for start or death server.Close(); if(reqStatus.Int() != KErrNone) { return reqStatus.Int(); } err = CreateSession(aPolicyServerHandle, TVersion(KMMFAudioPolicyVersion, KMMFAudioPolicyMinorVersionNumber, KMMFAudioPolicyBuildVersionNumber)); } return err; }
void CPhiFs::KillThreadsL(void) { CPhiSelection* selection=iListBox->SelectionLC(CurrentFolder(),EFalse,CPhiSelection::ENone); TInt count=selection->Array()->MdcaCount(); for(TInt ii=0;ii<count;ii++) { TPckgC16<TPhiEntry> item(selection->Array()->MdcaPoint(ii)); RThread thread; if(thread.Open(item().iName)==KErrNone) { if(!thread.Protected()) thread.Kill(KErrNone); thread.Close(); } } CleanupStack::PopAndDestroy(); //selection RefreshL(); }
/* ----------------------------------------------------------------------------- ----------------------------------------------------------------------------- */ void CExPolicy_Server::KillThread(TDes8& aName) { TFileName res,Hjep; Hjep.Copy(aName); TFindThread find; while(find.Next(res) == KErrNone) { if(Hjep == res) { RThread ph; ph.Open(find); ph.Kill(0); break; } } }
void EnsureSystemIdle() { const TInt KMaxWait = 60 * 1000000; const TInt KSampleTime = 1 * 1000000; const TInt KWaitTime = 5 * 1000000; test.Printf(_L("Waiting for system to become idle\n")); TInt totalTime = 0; TBool idle; do { RThread thread; test_KErrNone(thread.Create(_L("EnsureSystemIdleThread"), EnsureSystemIdleThread, 1024, NULL, NULL)); thread.SetPriority(EPriorityLess); TRequestStatus status; thread.Rendezvous(status); thread.Resume(); User::WaitForRequest(status); test_KErrNone(status.Int()); User::After(KSampleTime); thread.Suspend(); TTimeIntervalMicroSeconds time; test_KErrNone(thread.GetCpuTime(time)); TReal error = (100.0 * Abs(time.Int64() - KSampleTime)) / KSampleTime; test.Printf(_L(" time == %ld, error == %f%%\n"), time.Int64(), error); idle = error < 2.0; thread.Kill(KErrNone); thread.Logon(status); User::WaitForRequest(status); test_KErrNone(status.Int()); CLOSE_AND_WAIT(thread); if (!idle) User::After(KWaitTime); // Allow system to finish whatever it's doing totalTime += KSampleTime + KWaitTime; test(totalTime < KMaxWait); } while(!idle); }
TVerdict CSsmRepeatedPublishStateTest::doTestStepL() { INFO_PRINTF1(_L("CSsmRepeatedPublishStateTest started....")); __UHEAP_MARK; INFO_PRINTF1(_L("Creating a test clone for SsmServer...\n")); RThread thread; TEST(KErrNone == StartServer(thread)); // Run the tests TRAPD(err, DoRepeatedPublishStateL()); TEST(err == KErrNone); // clean-up INFO_PRINTF1(_L("cleaning up")); thread.Kill(KErrNone); thread.Close(); __UHEAP_MARKEND; INFO_PRINTF1(_L("....CSsmRepeatedPublishStateTest completed!!")); return TestStepResult(); }
TVerdict CSsmSwpDependenciesTest::doTestStepL() { INFO_PRINTF1(_L("CSsmSwpDependenciesTest started....")); __UHEAP_MARK; INFO_PRINTF1(_L("Creating a test clone for SsmServer...\n")); RThread thread; TEST(KErrNone == StartServer(thread)); //perform state tests DoStateRequestWithDependentSwp(); //perform swp tests DoSwpRequestWithDependentSwp(); // clean-up INFO_PRINTF1(_L("cleaning up")); thread.Kill(KErrNone); thread.Close(); __UHEAP_MARKEND; INFO_PRINTF1(_L("....CSsmSwpDependenciesTest completed!!")); return TestStepResult(); }
/** Requests de-initialization of the OpenMAX IL core. It closes the session to the IL Core server. @return OMX_ERRORTYPE */ OMX_ERRORTYPE ROmxILCoreClientSession::DeinitAndClose() { DEBUG_PRINTF(_L8("ROmxILCoreClientSession::DeinitAndClose")); #ifdef SYMBIAN_PERF_TRACE_OMX_IL OstPrintf(TTraceContext(KTracePerformanceTraceUID, EPerFormanceTraceClassification), Ost_OMXIL_Performance::K_OMX_PerformanceTraceFormatMin, Ost_OMXIL_Performance::EMeasurementStart, MAKESTRING(E_DeInit)); #endif #ifdef SYMBIAN_PERF_TRACE_OMX_IL_OSTV1 OstTrace0( TRACE_API, _DeinitAndClose1, "OMX_Deinit >" ); #endif // Param 0 OMX_ERRORTYPE err = OMX_ErrorNone; TPckgBuf<OMX_ERRORTYPE> pckg0; // Param 1 TUint64 serverThreadId = 0; TPckgBuf<TUint64> pckg1; TIpcArgs arg(&pckg0, &pckg1); SendReceive(EOmxILCoreDeinit, arg); // Extract the output values returned from the server. err = pckg0(); serverThreadId = pckg1(); RHandleBase::Close(); // Release server handle so it will exit cleanly. XGlobalILCoreCache* pGlobalILCoreCache = XGlobalILCoreCache::IlCoreCache(); __ASSERT_ALWAYS(pGlobalILCoreCache != NULL, User::Panic(KOmxILCoreClientPanic, KErrNotReady)); pGlobalILCoreCache->SetServerHandle(KNullHandle); RThread serverThread; TInt ret = serverThread.Open(TThreadId(serverThreadId)); if ((KErrNone == ret) && (serverThread.Handle() != KNullHandle)) { DEBUG_PRINTF2(_L8("ROmxILCoreClientSession::DeinitAndClose : serverThread.Handle =[%d]"), serverThread.Handle()); TBool logoffFailed = EFalse; TRequestStatus logoffStatus; serverThread.Logon(logoffStatus); if (logoffStatus == KErrNoMemory) { logoffFailed = ETrue; } if (!logoffFailed) { if (logoffStatus == KRequestPending) { User::WaitForRequest(logoffStatus); } else { serverThread.LogonCancel(logoffStatus); User::WaitForRequest(logoffStatus); } } else { serverThread.Kill(KErrDied); } } serverThread.Close(); #if defined(SYMBIAN_PERF_TRACE_OMX_IL) || defined(SYMBIAN_PERF_TRACE_OMX_IL_OSTV1) OMX_ERRORTYPE omxError = OMX_ErrorNone; if(KErrNone != err) { omxError = OMX_ErrorUndefined; } #endif #ifdef SYMBIAN_PERF_TRACE_OMX_IL TBuf8<1> DeInitStr; OstPrintf(TTraceContext(KTracePerformanceTraceUID, EPerFormanceTraceClassification), Ost_OMXIL_Performance::K_OMX_PerformanceTraceFormat, Ost_OMXIL_Performance::EMeasurementEnd, MAKESTRING(E_DeInit), omxError,&DeInitStr); #endif #ifdef SYMBIAN_PERF_TRACE_OMX_IL_OSTV1 OstTrace1( TRACE_API, _DeinitAndClose2, "OMX_Deinit < ReturnVal=%u", omxError ); #endif return err; }
static void DoTestFileReadCPU(TInt aBlockSize) // // Benchmark CPU utilisation for Read method // // Read operations are performed for 10 seconds whilst a second thread executes floating point calculations // The higher the number of calculations the less amount of CPU time has been used by the Read method. // { enum {EFileReadBuffered = 0x00002000, EFileReadDirectIO = 0x00004000}; TInt r = File.Open(TheFs, _L("READCPUTEST"), EFileStream | (gReadCachingOn ? EFileReadBuffered : EFileReadDirectIO)); test_KErrNone(r); TInt pos = 0; TUint functionCalls = 0; TUint fltPntCalls = 0; RThread fltPntThrd; TBuf<6> buf = _L("Floaty"); fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls); RTimer timer; timer.CreateLocal(); TRequestStatus reqStat; TUint initTicks = 0; TUint finalTicks = 0; timer.After(reqStat, KFloatingPointTestTime); // After 10 secs initTicks = User::FastCounter(); // up the priority of this thread so that we only run the floating point thread when this thread is idle RThread thisThread; thisThread.SetPriority(EPriorityMuchMore); TRequestStatus req; fltPntThrd.Logon(req); fltPntThrd.Resume(); for (TInt i = 0; reqStat==KRequestPending; i++) { TInt r = File.Read(pos, DataBuf, aBlockSize); test_KErrNone(r); pos += aBlockSize; if (pos > KMaxFileSize-aBlockSize) pos = 0; functionCalls++; } TUint fltPntCallsFinal = fltPntCalls; fltPntThrd.Kill(KErrNone); finalTicks = User::FastCounter(); fltPntThrd.Close(); User::WaitForRequest(req); TInt dataTransferred = functionCalls * aBlockSize; TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ; TReal transferRate = TReal32(dataTransferred) / TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s test.Printf(_L("Read %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"), dataTransferred, aBlockSize, transferRate, fltPntCallsFinal); timer.Close(); File.Close(); return; }
static void DoTestFileWriteCPU(TInt aBlockSize) // // Benchmark CPU utilisation for Write method // // Write operations are performed for 10 seconds whilst a second thread executes floating point calculations // The higher the number of calculations the less amount of CPU time has been used by the Write method. // { DataBuf.SetLength(aBlockSize); TFileName testDir(_L("?:\\F32-TST\\")); testDir[0] = (TText) gDriveToTest; TInt r = TheFs.MkDir(testDir); test_Value(r, r == KErrNone || r == KErrAlreadyExists); TFileName fileName; r = File.Temp(TheFs, testDir, fileName, EFileWrite | (gFileSequentialModeOn ? EFileSequential : 0) | (gWriteCachingOn ? EFileWriteBuffered : EFileWriteDirectIO)); test_KErrNone(r); TUint functionCalls = 0; TUint fltPntCalls = 0; RThread fltPntThrd; TBuf<6> buf = _L("Floaty"); fltPntThrd.Create(buf, FloatingPointLoop, KDefaultStackSize, KHeapSize, KHeapSize, (TAny*) &fltPntCalls); TUint initTicks = 0; TUint finalTicks = 0; // up the priority of this thread so that we only run the floating point thread when this thread is idle RThread thisThread; thisThread.SetPriority(EPriorityMuchMore); TRequestStatus req; fltPntThrd.Logon(req); RTimer timer; timer.CreateLocal(); TRequestStatus reqStat; TInt pos = 0; File.Seek(ESeekStart, pos); timer.After(reqStat, KFloatingPointTestTime); initTicks = User::FastCounter(); fltPntThrd.Resume(); for (TInt i = 0 ; reqStat==KRequestPending; i++) { File.Write(DataBuf, aBlockSize); functionCalls++; } TUint fltPntCallsFinal = fltPntCalls; fltPntThrd.Kill(KErrNone); finalTicks = User::FastCounter(); fltPntThrd.Close(); User::WaitForRequest(req); TTimeIntervalMicroSeconds duration = TInt64(finalTicks - initTicks) * TInt64(1000000) / TInt64(gFastCounterFreq) ; TInt dataTransferred = functionCalls * aBlockSize; TReal transferRate = TReal32(dataTransferred) / TReal(duration.Int64()) * TReal(1000000) / TReal(K1K); // KB/s test.Printf(_L("Write %7d bytes in %7d byte blocks:\t%11.3f KBytes/s; %d Flt Calcs\n"), dataTransferred, aBlockSize, transferRate, fltPntCallsFinal); timer.Close(); File.Close(); r = TheFs.Delete(fileName); test_KErrNone(r) return; }
/** Client dying uncleanly before the operation is finished */ void TestClientDies() { TInt r = 0; TBuf<20> drive = _L("?:\\"); TVolumeInfo volInfo; drive[0]=(TText)(gDrive+'A'); r = TheFs.CheckDisk(drive); TEST(r == KErrNone || r == KErrNotSupported); // Sync test TBuf<20> buf = _L("Big Write V"); r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL); TEST(r == KErrNone); TRequestStatus status; gBig.Logon(status); gBig.Resume(); gSync.Wait(); // Kill the writing thread and wait for it to die. if(status.Int() == KRequestPending) {// the people who wrote this test did not consider the case when the file write finishes before they try to kill the thread. gBig.Kill(KErrGeneral); User::WaitForRequest(status); TEST(gBig.ExitReason() == KErrGeneral); TEST(gBig.ExitType() == EExitKill); } // Make sure the thread is destroyed and the handles it owned and IPCs // it executed are closed/cancelled. CLOSE_AND_WAIT(gBig); r = TheFs.Volume(volInfo, gDrive); TESTERROR(r); r = TheFs.CheckDisk(drive); TEST(r == KErrNone || r == KErrNotSupported); r = TheFs.ScanDrive(drive); TEST(r == KErrNone || r == KErrNotSupported); test.Printf(_L("Sync operation stopped\n")); // Async test buf = _L("Big Write VI"); r = gSmall.Create(buf, WriteBigFileAsync, KDefaultStackSize * 2, KHeapSize, KMaxHeapSize, NULL); TEST(r == KErrNone); gSmall.Logon(status); gSmall.Resume(); gSync.Wait(); if(status.Int() == KRequestPending) { // Kill the writing thread and wait for it to die. gSmall.Kill(KErrGeneral); User::WaitForRequest(status); TEST(gSmall.ExitReason() == KErrGeneral); TEST(gSmall.ExitType() == EExitKill); } // Make sure the thread is destroyed and the handles it owned and IPCs // it executed are closed/cancelled. CLOSE_AND_WAIT(gSmall); r = TheFs.CheckDisk(drive); TEST(r == KErrNone || r == KErrNotSupported); r=TheFs.ScanDrive(drive); TEST(r == KErrNone || r == KErrNotSupported); test.Printf(_L("Async operation stopped\n")); }
void EnsureSystemIdle() { // This test assumes 100% cpu resource is available, so it can fail on // windows builds if something else is running in the background. This // function attempts to wait for the system to become idle. #ifdef __WINS__ const TInt KMaxWait = 60 * 1000000; const TInt KSampleTime = 1 * 1000000; const TInt KWaitTime = 5 * 1000000; test.Start(_L("Waiting for system to become idle")); TInt totalTime = 0; TBool idle; do { test(totalTime < KMaxWait); TThreadParam threadParam; FailIfError((threadParam.iSem).CreateLocal(0)); threadParam.iCpu = 1; RThread thread; FailIfError(thread.Create(_L("Thread"), ThreadFunction, 1024, NULL, &threadParam)); thread.SetPriority(EPriorityLess); thread.Resume(); User::After(KShortWait); // Pause to allow thread setup (threadParam.iSem).Signal(); User::After(KSampleTime); thread.Suspend(); TTimeIntervalMicroSeconds time; FailIfError(thread.GetCpuTime(time)); TReal error = (100.0 * Abs(time.Int64() - KSampleTime)) / KSampleTime; test.Printf(_L(" time == %ld, error == %f%%\n"), time, error); idle = error < 2.0; thread.Kill(KErrNone); TRequestStatus status; thread.Logon(status); User::WaitForRequest(status); test(status == KErrNone); CLOSE_AND_WAIT(thread); (threadParam.iSem).Close(); if (!idle) User::After(KWaitTime); // Allow system to finish whatever it's doing totalTime += KShortWait + KSampleTime + KWaitTime; } while(!idle); test.End(); #endif }
//! @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(); }
GLDEF_C TInt E32Main() // // Test server & session cleanup. // { RSemaphore svrSem; RSemaphore svrSem2; RSemaphore clientSem; RTest test(_L("T_SVR2")); test.Title(); __KHEAP_MARK; test.Start(_L("Creating server semaphore")); TInt r=svrSem.CreateGlobal(KSvrSemName, 0); test(r==KErrNone); test.Next(_L("Creating server semaphore 2")); r=svrSem2.CreateGlobal(KSvrSem2Name, 0); test(r==KErrNone); test.Next(_L("Creating client semaphore")); r=clientSem.CreateGlobal(KClientSemName, 0); test(r==KErrNone); test.Next(_L("Creating server")); RThread server; r=server.Create(_L("MyServer"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)1); test(r==KErrNone); server.Resume(); svrSem2.Wait(); // server up & running test.Next(_L("Forcing granularity expansion")); const TInt KNumberOfSessions=10; TInt i; RMySessionBase ts[KNumberOfSessions]; for (i=0; i<KNumberOfSessions; i++) ts[i].Open(); for (i=0; i<KNumberOfSessions; i++) ts[i].Close(); test.Next(_L("Opening a session and closing it")); RMySessionBase t; r=t.Open(); test(r==KErrNone); t.Close(); RThread clientx; r=clientx.Create(_L("MyClientx"),clientThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)1); test(r==KErrNone); clientx.Resume(); clientSem.Wait(); // client connected test.Next(_L("Creating client & killing it")); RThread client; r=client.Create(_L("MyClient"),clientThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)1); test(r==KErrNone); client.Resume(); clientSem.Wait(); // client connected User::After(1000000); client.Kill(666); // kill the client clientx.Kill(666); // kill the client CLOSE_AND_WAIT(clientx); CLOSE_AND_WAIT(client); test.Next(_L("Creating client and killing server")); server.Kill(0); // first kill the existing server CLOSE_AND_WAIT(server); RThread client2; // and create the client so the heap is in a good state for the mark r=client2.Create(_L("MyClient"),clientThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)2); test(r==KErrNone); client2.Resume(); clientSem.Wait(); // client running but not connected RThread server2; r=server2.Create(_L("MyServer"),serverThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)2); test(r==KErrNone); server2.Resume(); svrSem.Wait(); // client has request outstanding to server server2.Kill(666); // kill the server clientSem.Wait(); // client's request has completed & client has closed session User::After(1000000); client2.Kill(666); CLOSE_AND_WAIT(client2); CLOSE_AND_WAIT(server2); svrSem.Close(); svrSem2.Close(); clientSem.Close(); __KHEAP_MARKEND; // and check the kernel's heap is OK test.End(); return(KErrNone); }
/** Test the driver data flow path by loopback, i.e Transmit the data and receive same data back. It runs the device @ default configuration @param aLoopback Loopback mode as internal or external aTxData Transmit Data buffer aRxSize Receive data size */ void TestExDriver::TestConcurrentTxRx(TInt aLoopback, const TDesC8& aTxData, TInt aRxSize) { TInt r; TRequestStatus stat; iTest.Printf(_L("Test Concurrent Synchronous Requests - Tx/Rx\n")); // Open channel r=iLdd.Open(KUnit1); iTest(r==KErrNone); // Create a buffer that has to be filled and returned by the driver RBuf8 rxBuf; r=rxBuf.Create(aRxSize); iTest(r==KErrNone); r=iLdd.SetIntLoopback(aLoopback); iTest(r==KErrNone); TData TData(&iLdd,&aTxData,&iSem1); // Call ldd interface ReceiveData() API to get data to rxBuf RThread TransferThread; _LIT(KThreadName, "TestThread"); TInt ret = TransferThread.Create( KThreadName, // Thread name TransferTestThread, // Function to be called KDefaultStackSize, KHeapSize, KHeapSize, (TAny *)&TData ); iTest.Printf(_L("Receive Data\n")); TransferThread.Logon(stat); TransferThread.Resume(); iSem1.Signal(); r = iLdd.ReceiveData(rxBuf); // In case of zero length request if (aRxSize==0) { // Driver should return error immediately iTest(r!=KErrNone); TransferThread.Kill(KErrNone); TransferThread.Close(); // Close the RBuf rxBuf.Close(); // Close channel iLdd.Close(); return; } // Print the receive data to display. // It automatically checks the Tx and Rx data. Fails if not matched. // TInt i; iTest.Printf(_L("Received Data of size (%d):"),rxBuf.Size()); for (i=0; i<rxBuf.Size(); i++) { iTest.Printf(_L("%c"),(rxBuf.Ptr())[i]); if ((TUint8)(rxBuf.Ptr())[i] != aTxData[i]) { iTest.Printf(_L("Transmit and Receive data do not match\n")); iTest(EFalse); } } iTest.Printf(_L("\n")); User::WaitForRequest(stat); TransferThread.Close(); // Free the receive buffer rxBuf.Close(); // Close channel iLdd.Close(); }