// 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
	}