// Copyright (c) 2007-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\nkernsa\tiedevents.cpp

 // 

 //

 #include <nktest/nkutils.h>

 //---------------------------------------------------------------------------------------------------------------------

 //! @SYMTestCaseID				KBASE-tiedevents-2448

 //! @SYMTestType				UT

 //! @SYMTestCaseDesc			Verifying tied events

 //! @SYMPREQ					PREQ2094

 //! @SYMTestPriority			High

 //! @SYMTestActions				

 //! 	1. 	TiedEventTest: run a reader thread (or several in a group) accessing a

 //! 		common data block. A timer, IDFC, or interrupt handler writes to the

 //!			data block concurrently - first incrementing all data from 0 to 1 then

 //!			decrementing it again.

 //! 		

 //! @SYMTestExpectedResults

 //! 	1.	When the timer/IDFC/interrupt is tied to the thread/group, then the

 //!			execution of the event should prevent the thread/group from running on

 //!			any processor, and thus readers should never be able to observe the

 //!			data being 1. When the event is not tied, the reader should observe

 //!			the data as being 1 at least some of the time.

 //---------------------------------------------------------------------------------------------------------------------

 #ifdef __SMP__

 extern "C" void HijackSystemTimer(NSchedulable* aTieTo);

 const TInt FlagCount = 2048;

 const TInt LoopCount = 100;

 volatile TUint32 Flags[FlagCount];

 volatile TBool Done;

 volatile TUint32 FlagsSet;

 NTimer* Timer;

 TDfc* IDfc;

 NThreadGroup TG;

 NFastSemaphore* DoneSem;

 enum TTiedMode

 	{

 	ETimer,

 	EInterrupt,

 	EIDFC

 	};

 // Used directly as the IDFC, also called by the timer function

 void FiddleFlags(TAny*)

 	{

 	TInt i;

 	for (i=0; i<FlagCount; ++i)

 		__e32_atomic_add_ord32(&Flags[i], 1);

 	for (i=0; i<FlagCount; ++i)

 		__e32_atomic_add_ord32(&Flags[i], (TUint32)-1);

 	}

 // Used for timer/interrupt cases as the timer function

 void TimerFn(TAny*)

 	{

 	FiddleFlags(NULL);

 	if (!__e32_atomic_load_acq32(&Done))

 		Timer->OneShot(10);

 	}

 // Used for IDFC case as the timer function

 void IDfcQFn(TAny*)

 	{

 	IDfc->Add();

 	if (!__e32_atomic_load_acq32(&Done))

 		Timer->OneShot(10);

 	}

 // Test thread, just looks for flags being set

 void TiedEventThread(TAny*)

 	{

 	TInt cpu, i, j;

 	TUint32 set=0;

 	for_each_cpu(cpu)

 		{

 		NKern::ThreadSetCpuAffinity(NKern::CurrentThread(), cpu);

 		for (i=0; i<LoopCount; ++i)

 			{

 			for (j=0; j<FlagCount; ++j)

 				if (__e32_atomic_load_acq32(&Flags[j]))

 					++set;

 			}

 		}

 	__e32_atomic_add_ord32(&FlagsSet, set);

 	NKern::FSSignal(DoneSem);

 	NKern::WaitForAnyRequest();

 	}

 void TiedEventTest(TBool aTied, TInt aThreads, TTiedMode aMode)

 	{

 	TEST_PRINT3("TiedEventTest aTied=%d aThreads=%d aMode=%d", aTied, aThreads, aMode);

 	// Set up shared parameters

 	memclr((void*)&Flags,sizeof(Flags));

 	Done = EFalse;

 	FlagsSet = 0;

 	// Create test threads to check data

 	NFastSemaphore exitSem(0);

 	NFastSemaphore doneSem(0);

 	DoneSem = &doneSem;

 	char name[5]={0x54, 0x45, 0x54, 0x31, 0};

 	TInt i;

 	NSchedulable* tieTo = NULL;

 	NThread* t[16];

 	NThreadGroup* group = NULL;

 	if (aThreads == 1)

 		{

 		t[0] = CreateUnresumedThreadSignalOnExit(name, TiedEventThread, 10, NULL, 0, KSmallTimeslice, &exitSem, KCpuAffinityAny);

 		if (aTied)

 			tieTo = t[0];

 		}

 	else

 		{

 		group = &TG;

 		if (aTied)

 			tieTo = group;

 		SNThreadGroupCreateInfo ginfo;

 		ginfo.iCpuAffinity = KCpuAffinityAny;

 		TInt r = NKern::GroupCreate(group, ginfo);

 		TEST_RESULT(r==KErrNone, "Failed creating group");

 		for (i=0; i<aThreads; ++i)

 			{

 			t[i] = CreateUnresumedThreadSignalOnExit(name, TiedEventThread, 10, NULL, 0, KSmallTimeslice, &exitSem, KCpuAffinityAny, group);

 			++name[3];

 			}

 		}

 #ifndef __X86__

 	// Tie the system timer interrupt to the thread if we're testing interrupts

 	// This means the timer function should always be exclusive with the theads

 	// even though it's not tied itself.

 	if (aMode == EInterrupt && tieTo)

 		HijackSystemTimer(tieTo);

 #endif

 	// Create the IDFC

 	NSchedulable* tieDFC = aMode == EIDFC ? tieTo : NULL;

 	TDfc idfc(tieDFC, FiddleFlags, NULL);

 	IDfc = &idfc;

 	// Create and start NTimer

 	// If we're testing timers it will be tied itself

 	// If we're testing interrupts it will not be tied itself but will still run

 	// exclusively because the interrupt is tied

 	// If we're testing IDFCs it's just used to repeatedly queue the IDFC and

 	// where the timer itself runs is irrelevant.

 	NSchedulable* tieTimer = aMode == ETimer ? tieTo : NULL;

 	NTimerFn timerfn = aMode == EIDFC ? IDfcQFn : TimerFn;

 	NTimer timer(tieTimer, timerfn, NULL);

 	Timer = &timer;

 	timer.OneShot(10);

 	// Resume threads

 	for (i=0; i<aThreads; ++i)

 		NKern::ThreadResume(t[i]);

 	// Wait for threads to be done

 	for (i=0; i<aThreads; ++i)

 		NKern::FSWait(&doneSem);

 	// Tell timer to stop requeueing itself

 	__e32_atomic_store_rel32(&Done, ETrue);

 	NKern::Sleep(100);

 #ifndef __X86__

 	// Restart the normal system timer if we're testing interrupts

 	// as otherwise it will get unbound when the thing it's tied to

 	// dies.

 	if (aMode == EInterrupt && tieTo)

 		HijackSystemTimer(NULL);

 #endif

 	// Clean up threads/group

 	for (i=0; i<aThreads; ++i)

 		{

 		NKern::ThreadRequestSignal(t[i]);

 		NKern::FSWait(&exitSem);

 		}

 	if (group)

 		NKern::GroupDestroy(group);

 	// Check that the flag was ok

 	TEST_PRINT1("Flag was set %d times", FlagsSet);

 	if (aTied)

 		TEST_RESULT(FlagsSet == 0, "Flag was set, shouldn't be");

 	else

 		TEST_RESULT(FlagsSet > 0, "Flag wasn't set, test broken?");

 	}

 #endif

 void TestTiedEvents()

 	{

 #ifdef __SMP__

 	TiedEventTest(EFalse, 1, ETimer);

 	TiedEventTest(ETrue, 1, ETimer);

 	TiedEventTest(EFalse, 2, ETimer);

 	TiedEventTest(ETrue, 2, ETimer);

 #ifndef __X86__

 	TiedEventTest(EFalse, 1, EInterrupt);

 	TiedEventTest(ETrue, 1, EInterrupt);

 	TiedEventTest(EFalse, 2, EInterrupt);

 	TiedEventTest(ETrue, 2, EInterrupt);

 #endif

 	TiedEventTest(EFalse, 1, EIDFC);

 	TiedEventTest(ETrue, 1, EIDFC);

 	TiedEventTest(EFalse, 2, EIDFC);

 	TiedEventTest(ETrue, 2, EIDFC);

 #endif

 	}