sl@0: // Copyright (c) 2007-2009 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 the License "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: // e32test\nkernsa\tiedevents.cpp
sl@0: // 
sl@0: //
sl@0: 
sl@0: #include <nktest/nkutils.h>
sl@0: 
sl@0: //---------------------------------------------------------------------------------------------------------------------
sl@0: //! @SYMTestCaseID				KBASE-tiedevents-2448
sl@0: //! @SYMTestType				UT
sl@0: //! @SYMTestCaseDesc			Verifying tied events
sl@0: //! @SYMPREQ					PREQ2094
sl@0: //! @SYMTestPriority			High
sl@0: //! @SYMTestActions				
sl@0: //! 	1. 	TiedEventTest: run a reader thread (or several in a group) accessing a
sl@0: //! 		common data block. A timer, IDFC, or interrupt handler writes to the
sl@0: //!			data block concurrently - first incrementing all data from 0 to 1 then
sl@0: //!			decrementing it again.
sl@0: //! 		
sl@0: //! @SYMTestExpectedResults
sl@0: //! 	1.	When the timer/IDFC/interrupt is tied to the thread/group, then the
sl@0: //!			execution of the event should prevent the thread/group from running on
sl@0: //!			any processor, and thus readers should never be able to observe the
sl@0: //!			data being 1. When the event is not tied, the reader should observe
sl@0: //!			the data as being 1 at least some of the time.
sl@0: //---------------------------------------------------------------------------------------------------------------------
sl@0: 
sl@0: #ifdef __SMP__
sl@0: 
sl@0: extern "C" void HijackSystemTimer(NSchedulable* aTieTo);
sl@0: 
sl@0: const TInt FlagCount = 2048;
sl@0: const TInt LoopCount = 100;
sl@0: 
sl@0: volatile TUint32 Flags[FlagCount];
sl@0: volatile TBool Done;
sl@0: volatile TUint32 FlagsSet;
sl@0: NTimer* Timer;
sl@0: TDfc* IDfc;
sl@0: NThreadGroup TG;
sl@0: NFastSemaphore* DoneSem;
sl@0: 
sl@0: enum TTiedMode
sl@0: 	{
sl@0: 	ETimer,
sl@0: 	EInterrupt,
sl@0: 	EIDFC
sl@0: 	};
sl@0: 
sl@0: // Used directly as the IDFC, also called by the timer function
sl@0: void FiddleFlags(TAny*)
sl@0: 	{
sl@0: 	TInt i;
sl@0: 	for (i=0; i<FlagCount; ++i)
sl@0: 		__e32_atomic_add_ord32(&Flags[i], 1);
sl@0: 	for (i=0; i<FlagCount; ++i)
sl@0: 		__e32_atomic_add_ord32(&Flags[i], (TUint32)-1);
sl@0: 	}
sl@0: 
sl@0: // Used for timer/interrupt cases as the timer function
sl@0: void TimerFn(TAny*)
sl@0: 	{
sl@0: 	FiddleFlags(NULL);
sl@0: 	if (!__e32_atomic_load_acq32(&Done))
sl@0: 		Timer->OneShot(10);
sl@0: 	}
sl@0: 
sl@0: // Used for IDFC case as the timer function
sl@0: void IDfcQFn(TAny*)
sl@0: 	{
sl@0: 	IDfc->Add();
sl@0: 	if (!__e32_atomic_load_acq32(&Done))
sl@0: 		Timer->OneShot(10);
sl@0: 	}
sl@0: 
sl@0: // Test thread, just looks for flags being set
sl@0: void TiedEventThread(TAny*)
sl@0: 	{
sl@0: 	TInt cpu, i, j;
sl@0: 	TUint32 set=0;
sl@0: 
sl@0: 	for_each_cpu(cpu)
sl@0: 		{
sl@0: 		NKern::ThreadSetCpuAffinity(NKern::CurrentThread(), cpu);
sl@0: 
sl@0: 		for (i=0; i<LoopCount; ++i)
sl@0: 			{
sl@0: 			for (j=0; j<FlagCount; ++j)
sl@0: 				if (__e32_atomic_load_acq32(&Flags[j]))
sl@0: 					++set;
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: 	__e32_atomic_add_ord32(&FlagsSet, set);
sl@0: 
sl@0: 	NKern::FSSignal(DoneSem);
sl@0: 	NKern::WaitForAnyRequest();
sl@0: 	}
sl@0: 
sl@0: void TiedEventTest(TBool aTied, TInt aThreads, TTiedMode aMode)
sl@0: 	{
sl@0: 	TEST_PRINT3("TiedEventTest aTied=%d aThreads=%d aMode=%d", aTied, aThreads, aMode);
sl@0: 
sl@0: 	// Set up shared parameters
sl@0: 	memclr((void*)&Flags,sizeof(Flags));
sl@0: 	Done = EFalse;
sl@0: 	FlagsSet = 0;
sl@0: 
sl@0: 	// Create test threads to check data
sl@0: 	NFastSemaphore exitSem(0);
sl@0: 	NFastSemaphore doneSem(0);
sl@0: 	DoneSem = &doneSem;
sl@0: 	char name[5]={0x54, 0x45, 0x54, 0x31, 0};
sl@0: 	TInt i;
sl@0: 	NSchedulable* tieTo = NULL;
sl@0: 	NThread* t[16];
sl@0: 	NThreadGroup* group = NULL;
sl@0: 	if (aThreads == 1)
sl@0: 		{
sl@0: 		t[0] = CreateUnresumedThreadSignalOnExit(name, TiedEventThread, 10, NULL, 0, KSmallTimeslice, &exitSem, KCpuAffinityAny);
sl@0: 		if (aTied)
sl@0: 			tieTo = t[0];
sl@0: 		}
sl@0: 	else
sl@0: 		{
sl@0: 		group = &TG;
sl@0: 		if (aTied)
sl@0: 			tieTo = group;
sl@0: 		SNThreadGroupCreateInfo ginfo;
sl@0: 		ginfo.iCpuAffinity = KCpuAffinityAny;
sl@0: 		TInt r = NKern::GroupCreate(group, ginfo);
sl@0: 		TEST_RESULT(r==KErrNone, "Failed creating group");
sl@0: 		for (i=0; i<aThreads; ++i)
sl@0: 			{
sl@0: 			t[i] = CreateUnresumedThreadSignalOnExit(name, TiedEventThread, 10, NULL, 0, KSmallTimeslice, &exitSem, KCpuAffinityAny, group);
sl@0: 			++name[3];
sl@0: 			}
sl@0: 		}
sl@0: 
sl@0: #ifndef __X86__
sl@0: 	// Tie the system timer interrupt to the thread if we're testing interrupts
sl@0: 	// This means the timer function should always be exclusive with the theads
sl@0: 	// even though it's not tied itself.
sl@0: 	if (aMode == EInterrupt && tieTo)
sl@0: 		HijackSystemTimer(tieTo);
sl@0: #endif
sl@0: 
sl@0: 	// Create the IDFC
sl@0: 	NSchedulable* tieDFC = aMode == EIDFC ? tieTo : NULL;
sl@0: 	TDfc idfc(tieDFC, FiddleFlags, NULL);
sl@0: 	IDfc = &idfc;
sl@0: 
sl@0: 	// Create and start NTimer
sl@0: 	// If we're testing timers it will be tied itself
sl@0: 	// If we're testing interrupts it will not be tied itself but will still run
sl@0: 	// exclusively because the interrupt is tied
sl@0: 	// If we're testing IDFCs it's just used to repeatedly queue the IDFC and
sl@0: 	// where the timer itself runs is irrelevant.
sl@0: 	NSchedulable* tieTimer = aMode == ETimer ? tieTo : NULL;
sl@0: 	NTimerFn timerfn = aMode == EIDFC ? IDfcQFn : TimerFn;
sl@0: 	NTimer timer(tieTimer, timerfn, NULL);
sl@0: 	Timer = &timer;
sl@0: 	timer.OneShot(10);
sl@0: 
sl@0: 	// Resume threads
sl@0: 	for (i=0; i<aThreads; ++i)
sl@0: 		NKern::ThreadResume(t[i]);
sl@0: 
sl@0: 	// Wait for threads to be done
sl@0: 	for (i=0; i<aThreads; ++i)
sl@0: 		NKern::FSWait(&doneSem);
sl@0: 
sl@0: 	// Tell timer to stop requeueing itself
sl@0: 	__e32_atomic_store_rel32(&Done, ETrue);
sl@0: 	NKern::Sleep(100);
sl@0: 
sl@0: #ifndef __X86__
sl@0: 	// Restart the normal system timer if we're testing interrupts
sl@0: 	// as otherwise it will get unbound when the thing it's tied to
sl@0: 	// dies.
sl@0: 	if (aMode == EInterrupt && tieTo)
sl@0: 		HijackSystemTimer(NULL);
sl@0: #endif
sl@0: 
sl@0: 	// Clean up threads/group
sl@0: 	for (i=0; i<aThreads; ++i)
sl@0: 		{
sl@0: 		NKern::ThreadRequestSignal(t[i]);
sl@0: 		NKern::FSWait(&exitSem);
sl@0: 		}
sl@0: 	if (group)
sl@0: 		NKern::GroupDestroy(group);
sl@0: 
sl@0: 	// Check that the flag was ok
sl@0: 	TEST_PRINT1("Flag was set %d times", FlagsSet);
sl@0: 	if (aTied)
sl@0: 		TEST_RESULT(FlagsSet == 0, "Flag was set, shouldn't be");
sl@0: 	else
sl@0: 		TEST_RESULT(FlagsSet > 0, "Flag wasn't set, test broken?");
sl@0: 	}
sl@0: #endif
sl@0: 
sl@0: void TestTiedEvents()
sl@0: 	{
sl@0: #ifdef __SMP__
sl@0: 	TiedEventTest(EFalse, 1, ETimer);
sl@0: 	TiedEventTest(ETrue, 1, ETimer);
sl@0: 	TiedEventTest(EFalse, 2, ETimer);
sl@0: 	TiedEventTest(ETrue, 2, ETimer);
sl@0: 
sl@0: #ifndef __X86__
sl@0: 	TiedEventTest(EFalse, 1, EInterrupt);
sl@0: 	TiedEventTest(ETrue, 1, EInterrupt);
sl@0: 	TiedEventTest(EFalse, 2, EInterrupt);
sl@0: 	TiedEventTest(ETrue, 2, EInterrupt);
sl@0: #endif
sl@0: 
sl@0: 	TiedEventTest(EFalse, 1, EIDFC);
sl@0: 	TiedEventTest(ETrue, 1, EIDFC);
sl@0: 	TiedEventTest(EFalse, 2, EIDFC);
sl@0: 	TiedEventTest(ETrue, 2, EIDFC);
sl@0: #endif
sl@0: 	}