--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/prime/t_semutx.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,609 @@
+// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "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:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\prime\t_semutx.cpp
+// Tests the RSemaphore, RMutex and RCriticalSection classes
+// Overview:
+// Tests the RSemaphore, RMutex and RCriticalSection classes
+// API Information:
+// RSemaphore, RMutex, RCriticalSection
+// Details:
+// - Test RSemaphore and RMutex with the producer/consumer scenario.
+// Create two threads, use signal and wait to coordinate the
+// threads. Verify results are as expected.
+// - Calculate the time required to create, resume and close a thread.
+// - Test RSemaphore::Wait(timeout) in a variety ways and timeout
+// values. Verify results are as expected.
+// - Test RMutex via two threads which write to an array. The writing
+// and updating of the index is wrapped within a mutex pair. Verify
+// results are as expected.
+// - Test RCriticalSection via two threads which write to an array. The
+// writing and updating of the index is wrapped within a critical section
+// pair. Verify results are as expected.
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+//
+//
+
+#include <e32test.h>
+
+const TInt KMaxBufferSize=10;
+const TInt KMaxArraySize=10;
+const TInt KNumProducerItems=100;
+
+enum {EThread1ID=1,EThread2ID};
+
+RTest test(_L("T_SEMUTX"));
+RMutex mutex;
+RCriticalSection criticalSn;
+TInt thread1Count,thread2Count;
+TInt arrayIndex;
+TInt array[KMaxArraySize];
+TInt consumerArray[KNumProducerItems];
+RSemaphore slotAvailable,itemAvailable;
+
+class CStack
+ {
+public:
+ CStack() {iCount=0;};
+ void Push(TInt aItem) {iStack[iCount++]=aItem;};
+ TInt Pop(void) {return(iStack[--iCount]);};
+private:
+ TInt iStack[KMaxBufferSize];
+ TInt iCount;
+ };
+CStack stack;
+
+
+TInt Producer(TAny*)
+ {
+ for(TInt ii=0;ii<KNumProducerItems;ii++)
+ {
+ slotAvailable.Wait();
+ mutex.Wait();
+ stack.Push(ii);
+ mutex.Signal();
+ itemAvailable.Signal();
+ }
+ return(KErrNone);
+ }
+
+TInt Consumer(TAny*)
+ {
+ TInt item;
+ for(TInt ii=0;ii<KNumProducerItems;ii++)
+ {
+ itemAvailable.Wait();
+ mutex.Wait();
+ item=stack.Pop();
+ mutex.Signal();
+ slotAvailable.Signal();
+ consumerArray[item]=item;
+ }
+ return(KErrNone);
+ }
+
+void BusyWait(TInt aMicroseconds)
+ {
+ TTime begin;
+ begin.HomeTime();
+ FOREVER
+ {
+ TTime now;
+ now.HomeTime();
+ TTimeIntervalMicroSeconds iv=now.MicroSecondsFrom(begin);
+ if (iv.Int64()>=TInt64(aMicroseconds))
+ return;
+ }
+ }
+
+TInt MutexThreadEntryPoint1(TAny*)
+//
+// Mutex test thread 1
+//
+ {
+
+ thread1Count=0;
+ TBool running=ETrue;
+ do
+ {
+ mutex.Wait();
+ BusyWait(100000);
+ if (arrayIndex<KMaxArraySize)
+ {
+ array[arrayIndex++]=EThread1ID;
+ thread1Count++;
+ }
+ else
+ running=EFalse;
+ mutex.Signal();
+ } while (running);
+ return(KErrNone);
+ }
+
+TInt MutexThreadEntryPoint2(TAny*)
+//
+// Mutex test thread 2
+//
+ {
+
+ thread2Count=0;
+ TBool running=ETrue;
+ do
+ {
+ mutex.Wait();
+ BusyWait(200000);
+ if (arrayIndex<KMaxArraySize)
+ {
+ array[arrayIndex++]=EThread2ID;
+ thread2Count++;
+ }
+ else
+ running=EFalse;
+ mutex.Signal();
+ } while (running);
+ return(KErrNone);
+ }
+
+TInt CriticalSnThreadEntryPoint1(TAny*)
+//
+// Critical Section test thread 1
+//
+ {
+
+ thread1Count=0;
+ TBool running=ETrue;
+ do
+ {
+ criticalSn.Wait();
+ User::After(100000);
+ if (arrayIndex<KMaxArraySize)
+ {
+ array[arrayIndex++]=EThread1ID;
+ thread1Count++;
+ }
+ else
+ running=EFalse;
+ criticalSn.Signal();
+ } while (running);
+ return(KErrNone);
+ }
+
+TInt CriticalSnThreadEntryPoint2(TAny*)
+//
+// Critical Section test thread 2
+//
+ {
+
+ thread2Count=0;
+ TBool running=ETrue;
+ do
+ {
+ criticalSn.Wait();
+ User::After(200000);
+ if (arrayIndex<KMaxArraySize)
+ {
+ array[arrayIndex++]=EThread2ID;
+ thread2Count++;
+ }
+ else
+ running=EFalse;
+ criticalSn.Signal();
+ } while (running);
+ return(KErrNone);
+ }
+
+struct SWaitSem
+ {
+ RSemaphore iSem;
+ TInt iTimeout;
+ };
+
+TInt WaitSemThread(TAny* a)
+ {
+ SWaitSem& ws = *(SWaitSem*)a;
+ return ws.iSem.Wait(ws.iTimeout);
+ }
+
+void StartWaitSemThread(RThread& aT, SWaitSem& aW, TThreadPriority aP=EPriorityLess)
+ {
+ TInt r = aT.Create(KNullDesC, &WaitSemThread, 0x1000, 0x1000, 0x1000, &aW);
+ test(r==KErrNone);
+ aT.SetPriority(aP);
+ aT.Resume();
+ }
+
+void WaitForWaitSemThread(RThread& aT, TInt aResult)
+ {
+ TRequestStatus s;
+ aT.Logon(s);
+ User::WaitForRequest(s);
+ test(aT.ExitType()==EExitKill);
+ test(aT.ExitReason()==aResult);
+ test(s.Int()==aResult);
+ CLOSE_AND_WAIT(aT);
+ }
+
+TInt DummyThread(TAny*)
+ {
+ return 0;
+ }
+
+void TestSemaphore2()
+ {
+ test.Start(_L("Test semaphore wait with timeout"));
+ SWaitSem ws;
+ RThread t;
+ TTime initial;
+ TTime final;
+ TInt elapsed=0;
+ TInt r = ws.iSem.CreateLocal(0);
+ test(r==KErrNone);
+
+ RThread().SetPriority(EPriorityAbsoluteVeryLow);
+ TInt threadcount=0;
+ initial.HomeTime();
+ while (elapsed<1000000)
+ {
+ r = t.Create(KNullDesC, &DummyThread, 0x1000, NULL, NULL);
+ test(r==KErrNone);
+ t.SetPriority(EPriorityMore);
+ t.Resume();
+ t.Close();
+ ++threadcount;
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ }
+ RThread().SetPriority(EPriorityNormal);
+ test.Printf(_L("%d threads in 1 sec\n"),threadcount);
+ TInt overhead = 1000000/threadcount;
+ test.Printf(_L("overhead = %dus\n"),overhead);
+
+ ws.iTimeout=1000000;
+ initial.HomeTime();
+ StartWaitSemThread(t, ws);
+ WaitForWaitSemThread(t, KErrTimedOut);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed>=900000+overhead && elapsed<1500000+overhead);
+
+ ws.iTimeout=-1;
+ initial.HomeTime();
+ StartWaitSemThread(t, ws);
+ WaitForWaitSemThread(t, KErrArgument);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+
+ ws.iTimeout=2000000;
+ initial.HomeTime();
+ StartWaitSemThread(t, ws);
+ User::After(1000000);
+ ws.iSem.Signal();
+ WaitForWaitSemThread(t, KErrNone);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed>=900000+overhead && elapsed<1500000+overhead);
+
+ ws.iTimeout=100000;
+ StartWaitSemThread(t, ws, EPriorityMore);
+ t.Suspend();
+ ws.iSem.Signal();
+ User::After(200000);
+ t.Resume();
+ WaitForWaitSemThread(t, KErrTimedOut);
+ test(ws.iSem.Wait(1)==KErrNone);
+
+ ws.iTimeout=100000;
+ StartWaitSemThread(t, ws, EPriorityMore);
+ t.Suspend();
+ ws.iSem.Signal();
+ User::After(50000);
+ t.Resume();
+ WaitForWaitSemThread(t, KErrNone);
+ test(ws.iSem.Wait(1)==KErrTimedOut);
+
+ RThread t2;
+ ws.iTimeout=100000;
+ StartWaitSemThread(t, ws, EPriorityMuchMore);
+ StartWaitSemThread(t2, ws, EPriorityMore);
+ t.Suspend();
+ ws.iSem.Signal();
+ test(t2.ExitType()==EExitKill);
+ test(t.ExitType()==EExitPending);
+ t.Resume();
+ WaitForWaitSemThread(t, KErrTimedOut);
+ WaitForWaitSemThread(t2, KErrNone);
+ test(ws.iSem.Wait(1)==KErrTimedOut);
+
+ ws.iTimeout=1000000;
+ initial.HomeTime();
+ StartWaitSemThread(t2, ws, EPriorityMore);
+ StartWaitSemThread(t, ws, EPriorityMuchMore);
+ ws.iSem.Signal();
+ WaitForWaitSemThread(t, KErrNone);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ WaitForWaitSemThread(t2, KErrTimedOut);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);
+
+ ws.iTimeout=1000000;
+ initial.HomeTime();
+ StartWaitSemThread(t2, ws, EPriorityMore);
+ StartWaitSemThread(t, ws, EPriorityMuchMore);
+ WaitForWaitSemThread(t, KErrTimedOut);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ WaitForWaitSemThread(t2, KErrTimedOut);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);
+
+ ws.iTimeout=1000000;
+ initial.HomeTime();
+ StartWaitSemThread(t2, ws, EPriorityMore);
+ StartWaitSemThread(t, ws, EPriorityMuchMore);
+ t.Kill(299792458);
+ WaitForWaitSemThread(t2, KErrTimedOut);
+ WaitForWaitSemThread(t, 299792458);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed>=900000+2*overhead && elapsed<1500000+2*overhead);
+
+ ws.iTimeout=1000000;
+ initial.HomeTime();
+ StartWaitSemThread(t, ws, EPriorityMore);
+ StartWaitSemThread(t2, ws, EPriorityMuchMore);
+ test(t.ExitType()==EExitPending);
+ test(t2.ExitType()==EExitPending);
+ ws.iSem.Close();
+ test(t.ExitType()==EExitKill);
+ test(t2.ExitType()==EExitKill);
+ WaitForWaitSemThread(t2, KErrGeneral);
+ WaitForWaitSemThread(t, KErrGeneral);
+ final.HomeTime();
+ elapsed = I64INT(final.Int64()-initial.Int64());
+ test.Printf(_L("Time taken = %dus\n"), elapsed);
+ test(elapsed<=50000+3*overhead);
+
+ test.End();
+ }
+
+void TestSemaphore()
+ {
+/*********** TO DO ************/
+// Check it panics if the count <0
+
+ test.Start(_L("Create"));
+ RSemaphore semaphore;
+ RThread thread1, thread2;
+
+ semaphore.CreateLocal(0); // creates a DPlatSemaphore but casts it to a pointer to a DSemaphore
+ // sets semaphore count to the value of the parameter,
+ // adds object to the K::Semaphores container, sets iHandle
+ // Local sets DSemaphore.iName to NULL & iOwner to Kern::CurrentProcess()
+ // Global sets iName to that passed and iOwner to NULL
+ // Adds a record into CObjectIx containing a pointer to the semaphore object
+/* test.Next(_L("Find"));
+ fullName=semaphore.FullName();
+ find.Find(fullName); // sets iMatch to fullName (misleadingly named method as it doesn't find anything)
+ test(find.Next(fullName)== KErrNone);
+*/
+ test.Next(_L("Producer/Consumer scenario"));
+ // Test Rsemaphore with the producer/consumer scenario RThread thread1, thread2;
+ TRequestStatus stat1, stat2;
+ test(mutex.CreateLocal()==KErrNone);
+ test(slotAvailable.CreateLocal(KMaxBufferSize)==KErrNone);
+ test(itemAvailable.CreateLocal(0)==KErrNone);
+ test(thread1.Create(_L("Thread1"),Producer,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);
+ test(thread2.Create(_L("Thread2"),Consumer,KDefaultStackSize,0x200,0x200,NULL)==KErrNone);
+ thread1.Logon(stat1);
+ thread2.Logon(stat2);
+ test(stat1==KRequestPending);
+ test(stat2==KRequestPending);
+ thread1.Resume();
+ thread2.Resume();
+ User::WaitForRequest(stat1);
+ User::WaitForRequest(stat2);
+ test(stat1==KErrNone);
+ test(stat2==KErrNone);
+ for(TInt jj=0;jj<KNumProducerItems;jj++)
+ test(consumerArray[jj]==jj);
+
+ test.Next(_L("Close"));
+ mutex.Close();
+ CLOSE_AND_WAIT(thread1);
+ CLOSE_AND_WAIT(thread2);
+ test.End();
+ }
+
+void TestMutex2()
+ {
+ RMutex m;
+ test.Start(_L("Create"));
+ test(m.CreateLocal()==KErrNone);
+
+ // Test RMutex::IsHeld()
+ test.Next(_L("IsHeld ?"));
+ test(!m.IsHeld());
+ test.Next(_L("Wait"));
+ m.Wait();
+ test.Next(_L("IsHeld ?"));
+ test(m.IsHeld());
+ test.Next(_L("Signal"));
+ m.Signal();
+ test.Next(_L("IsHeld ?"));
+ test(!m.IsHeld());
+
+ test.End();
+ }
+
+void TestMutex()
+ {
+ test.Start(_L("Create"));
+ test(mutex.CreateLocal()==KErrNone);
+
+ test.Next(_L("Threads writing to arrays test"));
+//
+// Create two threads which write to two arrays. The arrays and indexs
+// are global and each thread writes an identifier to the arrays. For
+// one array the writing and updating of the index is wrapped in a mutex
+// pair. The other array is a control and is not wrapaped within mutex.
+// Each thread records the number of instances it "thinks" it wrote to
+// each array. For the mutex controlled array the actual instances
+// written to the array should always be the same as the threads think.
+//
+ arrayIndex=0;
+ RThread thread1,thread2;
+ test(thread1.Create(_L("Thread1"),MutexThreadEntryPoint1,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);
+ test(thread2.Create(_L("Thread2"),MutexThreadEntryPoint2,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);
+ TRequestStatus stat1,stat2;
+ thread1.Logon(stat1);
+ thread2.Logon(stat2);
+ test(stat1==KRequestPending);
+ test(stat2==KRequestPending);
+ thread1.Resume();
+ thread2.Resume();
+ User::WaitForRequest(stat1);
+ User::WaitForRequest(stat2);
+ test(stat1==KErrNone);
+ test(stat2==KErrNone);
+ TInt thread1ActualCount=0;
+ TInt thread2ActualCount=0;
+ TInt ii=0;
+ while(ii<KMaxArraySize)
+ {
+ if (array[ii]==EThread1ID)
+ thread1ActualCount++;
+ if (array[ii]==EThread2ID)
+ thread2ActualCount++;
+ ii++;
+ }
+ test.Printf(_L("T1 %d T1ACT %d T2 %d T2ACT %d"),thread1Count,thread1ActualCount,thread2Count,thread2ActualCount);
+ test(thread1ActualCount==thread1Count);
+ test(thread2ActualCount==thread2Count);
+ test(thread1Count==thread2Count);
+ test(thread1Count==(KMaxArraySize>>1));
+
+ test.Next(_L("Close"));
+ CLOSE_AND_WAIT(thread1);
+ CLOSE_AND_WAIT(thread2);
+ mutex.Close();
+ test.End();
+ }
+
+void TestCriticalSection()
+//
+//As TestMutex, but for RCriticalSection
+//
+ {
+
+ test.Start(_L("Create"));
+ test(criticalSn.CreateLocal()==KErrNone);
+
+/***************** TO DO ***********************
+
+ test.Next(_L("Find"));
+//
+// Test finding the RCriticalSection
+//
+ TFindCriticalSection find;
+ TFullName fullName;
+ fullName=criticalSn.FullName();
+ find.Find(fullName);
+ test(find.Next(fullName)==KErrNone);
+ test(fullName==criticalSn.FullName());
+
+************************************************/
+
+ test.Next(_L("Threads writing to arrays test"));
+//
+// Create two threads which write to two arrays. The arrays and indexs
+// are global and each thread writes an identifier to the arrays. For
+// one array the writing and updating of the index is wrapped in a critical
+// section pair. The other array is a control and is not wrapaped within
+// a critical section. Each thread records the number of instances it
+// "thinks" it wrote to each array. For the mutex controlled array the
+// actual instances written to the array should always be the same as the
+// threads think.
+//
+ arrayIndex=0;
+ RThread thread1,thread2;
+ test(thread1.Create(_L("Thread1"),CriticalSnThreadEntryPoint1,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);
+ test(thread2.Create(_L("Thread2"),CriticalSnThreadEntryPoint2,KDefaultStackSize,0x2000,0x2000,NULL)==KErrNone);
+ TRequestStatus stat1,stat2;
+ thread1.Logon(stat1);
+ thread2.Logon(stat2);
+ test(stat1==KRequestPending);
+ test(stat2==KRequestPending);
+ thread1.Resume();
+ thread2.Resume();
+ User::WaitForRequest(stat1);
+ User::WaitForRequest(stat2);
+ test(stat1==KErrNone);
+ test(stat2==KErrNone);
+ TInt thread1ActualCount=0;
+ TInt thread2ActualCount=0;
+ TInt ii=0;
+ while(ii<KMaxArraySize)
+ {
+ if (array[ii]==EThread1ID)
+ thread1ActualCount++;
+ if (array[ii]==EThread2ID)
+ thread2ActualCount++;
+ ii++;
+ }
+ test(thread1ActualCount==thread1Count);
+ test(thread2ActualCount==thread2Count);
+ test(thread1Count==thread2Count);
+ test(thread1Count==(KMaxArraySize>>1));
+
+ test.Next(_L("Close"));
+ CLOSE_AND_WAIT(thread1);
+ CLOSE_AND_WAIT(thread2);
+ criticalSn.Close();
+ test.End();
+ }
+
+
+GLDEF_C TInt E32Main()
+ {
+
+ test.Title();
+ __UHEAP_MARK;
+ test.Start(_L("Test RSemaphore"));
+ TestSemaphore();
+ TestSemaphore2();
+ test.Next(_L("Test RMutex"));
+ TestMutex();
+ TestMutex2();
+ test.Next(_L("Test RCriticalSection"));
+ TestCriticalSection();
+ test.End();
+ __UHEAP_MARKEND;
+ return(KErrNone);
+ }
+
+