// Copyright (c) 2008-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\thread\smpsafe.cpp

 // 

 //

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32atomics.h>

 IMPORT_C void DoNothingA();

 IMPORT_C void DoNothingB();

 IMPORT_C void DoNothingC();

 IMPORT_C void DoNothingD();

 IMPORT_C void DoNothingE();

 #ifdef MAKE_DLL

 #ifdef PROVIDE_A

 EXPORT_C void DoNothingA() {}

 #endif

 #ifdef PROVIDE_B

 EXPORT_C void DoNothingB() { DoNothingA(); }

 #endif

 #ifdef PROVIDE_C

 EXPORT_C void DoNothingC() { DoNothingD(); DoNothingE(); }

 #endif

 #ifdef PROVIDE_D

 EXPORT_C void DoNothingD() { DoNothingC(); }

 #endif

 #ifdef PROVIDE_E

 EXPORT_C void DoNothingE() { DoNothingC(); }

 #endif

 #else // !MAKE_DLL

 volatile TInt Affinity;

 RSemaphore Start;

 RSemaphore Stop;

 const TInt KLoopTries = 100;

 // This gets run in a low priority thread. Each time around the loop it waits to be told to go,

 // then sets Affinity to 0, then tells the other thread it's done. If we're actually locked to

 // the same processor as the main thread, however, then we won't get to run until the other thread

 // waits for the Stop semaphore, and thus Affinity will not get set to 0 until the other thread

 // checked it already.

 TInt AffinitySlave(TAny*)

 	{

 	for (TInt i = KLoopTries; i>0; --i)

 		{

 		Start.Wait();

 		Affinity = 0;

 		Stop.Signal();

 		}

 	return KErrNone;

 	}

 TInt CheckAffinity()

 	{

 	RThread t;

 	TInt r = t.Create(_L("AffinitySlave"), AffinitySlave, KDefaultStackSize, NULL, NULL);

 	if (r != KErrNone)

 		return r;

 	Start.CreateLocal(0);

 	Stop.CreateLocal(0);

 	TRequestStatus s;

 	t.Logon(s);

 	t.SetPriority(EPriorityLess);

 	t.Resume();

 	TInt a = 1;

 	for (TInt i = KLoopTries; i>0; --i)

 		{

 		Affinity = 1; // assume we are locked to a single cpu

 		Start.Signal(); // tell the other thread to run

 		TUint32 target = User::NTickCount() + 10;

 		while (User::NTickCount() < target)

 			{

 			// spin, waiting to see if the other thread actually *does* run

 			}

 		a = Affinity;

 		if (a == 0)

 			break;

 		Stop.Wait(); // We didn't see it this time, but try again in case of scheduling fluke

 		}

 	t.Kill(0);

 	User::WaitForRequest(s);

 	t.Close();

 	return a;

 	}

 #ifndef OMIT_MAIN

 GLDEF_C TInt E32Main()

 	{

 #ifdef USE_A

 	DoNothingA();

 #endif

 #ifdef USE_B

 	DoNothingB();

 #endif

 	return CheckAffinity();

 	}

 #endif // OMIT_MAIN

 #endif