// 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\system\t_atomic.h
// 
//

#include <e32atomics.h>

#ifdef __VC32__
#pragma warning( disable : 4244 )	/* conversion to shorter type - possible loss of data */
#endif

const TInt KMaxThreads = 8;

#ifdef __KERNEL_MODE__
#include <kernel/kernel.h>
#undef	DEBUGPRINT
#define	DEBUGPRINT	Kern::Printf
#else
extern void UPrintf(const char*, ...);
#undef	DEBUGPRINT
#define DEBUGPRINT	UPrintf
#endif

#undef	__INT64_ALIGNED__
#if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__EABI__)
#define	__INT64_ALIGNED__
#endif

#ifdef __INT64_ALIGNED__
typedef	TUint64	TUint64A;
typedef	TInt64	TInt64A;
#else

class TUint64A
	{
public:
	inline const TUint64* operator&() const
		{ return ((const TUint64*)((T_UintPtr(this)+7)&~7)); }
	inline TUint64* operator&()
		{ return ((TUint64*)((T_UintPtr(this)+7)&~7)); }
private:
	TUint64 i_Data[2];
	};

class TInt64A
	{
public:
	inline const TInt64* operator&() const
		{ return ((const TInt64*)((T_UintPtr(this)+7)&~7)); }
	inline TInt64* operator&()
		{ return ((TInt64*)((T_UintPtr(this)+7)&~7)); }
private:
	TUint64 i_Data[2];
	};

#endif

struct TDGBase
	{
	TInt Execute();
	void Dump(const char*);

	TUint64	i0;
	TUint64	i1;
	TUint64	i2;
	TUint64	i3;
	TInt	iIndex;
	};

struct TAtomicAction
	{
	TUint64	i0;			// first parameter to operation
	TUint64	i1;			// second parameter to operation
	TUint64	i2;			// third parameter to operation
	TInt	iIndex;		// index of atomic function
	TInt	iThread;	// thread identifier
	};

struct TPerThread
	{
	TUint64	iDiff;		// accumulated difference
	TUint64	iXor;		// accumulated XOR
	TUint64 iFailCount;	// failure count for CAS operations
	TUint64 iCount;		// iteration count
	};

extern "C" TInt DoAtomicAction(TAny* aPtr, TPerThread* aT, TAtomicAction& aA);

enum TMemoryOrder
	{
	EOrderRelaxed=0,
	EOrderAcquire=1,
	EOrderRelease=2,
	EOrderOrdered=3,
	};

enum TAtomicFunc
	{
	EAtomicFuncLOAD=0,
	EAtomicFuncSTORE=1,
	EAtomicFuncSWP=2,
	EAtomicFuncADD=3,
	EAtomicFuncAND=4,
	EAtomicFuncIOR=5,
	EAtomicFuncXOR=6,
	EAtomicFuncAXO=7,
	EAtomicFuncTAU=8,
	EAtomicFuncTAS=9,
	EAtomicFuncCAS=10,
	EAtomicFuncN
	};

enum TFuncType
	{
	EFuncTypeInvalid=0,
	EFuncTypeLoad=1,
	EFuncTypeRmw1=2,
	EFuncTypeRmw2=3,
	EFuncTypeRmw3=4,
	EFuncTypeCas=5,
	};

#define	FUNCS_PER_SIZE			(TUint(EAtomicFuncN)*4)
#define TOTAL_FUNCS				(FUNCS_PER_SIZE*4)
#define	INDEXES_PER_SIZE		(16*4)
#define	TOTAL_INDEXES			(INDEXES_PER_SIZE*4)

#define FUNCATTR(func,size,ord,type)	((TUint(func)<<24)|(TUint(size)<<16)|(TUint(ord)<<8)|(TUint(type)))
#define	ATTR_TO_TYPE(attr)				((attr)&0xff)
#define	ATTR_TO_ORD(attr)				(((attr)>>8)&0xff)
#define	ATTR_TO_SIZE(attr)				(((attr)>>16)&0xff)
#define	ATTR_TO_FUNC(attr)				(((attr)>>24)&0xff)
#define	FUNCATTR2(func,size,type)	\
			FUNCATTR(func,size,EOrderRelaxed,type),	FUNCATTR(func,size,EOrderAcquire,type), FUNCATTR(func,size,EOrderRelease,type), FUNCATTR(func,size,EOrderOrdered,type)
#define	FUNCATTR2A(func,size,type)	\
												0,	FUNCATTR(func,size,EOrderAcquire,type),										0,										0
#define	FUNCATTR2B(func,size,type)	\
												0,										0,	FUNCATTR(func,size,EOrderRelease,type),	FUNCATTR(func,size,EOrderOrdered,type)
#define	FUNCATTR3(size)				\
			FUNCATTR2A(EAtomicFuncLOAD,size,EFuncTypeLoad),		\
			FUNCATTR2B(EAtomicFuncSTORE,size,EFuncTypeRmw1),	\
			FUNCATTR2(EAtomicFuncSWP,size,EFuncTypeRmw1),		\
			FUNCATTR2(EAtomicFuncADD,size,EFuncTypeRmw1),		\
			FUNCATTR2(EAtomicFuncAND,size,EFuncTypeRmw1),		\
			FUNCATTR2(EAtomicFuncIOR,size,EFuncTypeRmw1),		\
			FUNCATTR2(EAtomicFuncXOR,size,EFuncTypeRmw1),		\
			FUNCATTR2(EAtomicFuncAXO,size,EFuncTypeRmw2),		\
			FUNCATTR2(EAtomicFuncTAU,size,EFuncTypeRmw3),		\
			FUNCATTR2(EAtomicFuncTAS,size,EFuncTypeRmw3),		\
			FUNCATTR2(EAtomicFuncCAS,size,EFuncTypeCas),		\
			0,	0,	0,	0,										\
			0,	0,	0,	0,										\
			0,	0,	0,	0,										\
			0,	0,	0,	0,										\
			0,	0,	0,	0


#define	__DO_STRINGIFY__(x)			#x
#define	__STRINGIFY__(x)			__DO_STRINGIFY__(x)
#define __concat3__(a,b,c)			a##b##c
#define __concat5__(a,b,c,d,e)		a##b##c##d##e
#define FUNCNAME(func,size,ord)		__STRINGIFY__(__concat3__(func,size,ord))
#define ATOMICFUNC(func,size,ord)	__concat5__(__e32_atomic_,func,_,ord,size)
#define CONTROLFUNC(func,size,ord)	__concat3__(__nonatomic_,func,size)
#define	FUNCNAME2(func,size)		FUNCNAME(func,size,rlx), FUNCNAME(func,size,acq), FUNCNAME(func,size,rel), FUNCNAME(func,size,ord)
#define	FUNCNAME3(size)	\
			FUNCNAME2(load,size),	\
			FUNCNAME2(store,size),	\
			FUNCNAME2(swp,size),	\
			FUNCNAME2(add,size),	\
			FUNCNAME2(and,size),	\
			FUNCNAME2(ior,size),	\
			FUNCNAME2(xor,size),	\
			FUNCNAME2(axo,size),	\
			FUNCNAME2(tau,size),	\
			FUNCNAME2(tas,size),	\
			FUNCNAME2(cas,size),	\
			"", "", "", "",			\
			"", "", "", "",			\
			"", "", "", "",			\
			"", "", "", "",			\
			"", "", "", ""


#define	ATOMICFUNC2(func,size)		(PFV)&ATOMICFUNC(func,size,rlx), (PFV)&ATOMICFUNC(func,size,acq), (PFV)&ATOMICFUNC(func,size,rel), (PFV)&ATOMICFUNC(func,size,ord)
#define	ATOMICFUNC2A(func,size)									0,	(PFV)&ATOMICFUNC(func,size,acq),								0,							0
#define	ATOMICFUNC2B(func,size)									0,								0,	(PFV)&ATOMICFUNC(func,size,rel), (PFV)&ATOMICFUNC(func,size,ord)
#define	ATOMICFUNC3(size)				\
			ATOMICFUNC2A(load,size),	\
			ATOMICFUNC2B(store,size),	\
			ATOMICFUNC2(swp,size),		\
			ATOMICFUNC2(add,size),		\
			ATOMICFUNC2(and,size),		\
			ATOMICFUNC2(ior,size),		\
			ATOMICFUNC2(xor,size),		\
			ATOMICFUNC2(axo,size),		\
			ATOMICFUNC2(tau,size),		\
			ATOMICFUNC2(tas,size),		\
			ATOMICFUNC2(cas,size),		\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0


#define	CONTROLFUNC2(func,size)		(PFV)&CONTROLFUNC(func,size,rlx), (PFV)&CONTROLFUNC(func,size,acq), (PFV)&CONTROLFUNC(func,size,rel), (PFV)&CONTROLFUNC(func,size,ord)
#define	CONTROLFUNC2A(func,size)								0,	(PFV)&CONTROLFUNC(func,size,acq),								0,							0
#define	CONTROLFUNC2B(func,size)								0,								0,	(PFV)&CONTROLFUNC(func,size,rel), (PFV)&CONTROLFUNC(func,size,ord)
#define	CONTROLFUNC3(size)				\
			CONTROLFUNC2A(load,size),	\
			CONTROLFUNC2B(store,size),	\
			CONTROLFUNC2(swp,size),		\
			CONTROLFUNC2(add,size),		\
			CONTROLFUNC2(and,size),		\
			CONTROLFUNC2(ior,size),		\
			CONTROLFUNC2(xor,size),		\
			CONTROLFUNC2(axo,size),		\
			CONTROLFUNC2(tau,size),		\
			CONTROLFUNC2(tas,size),		\
			CONTROLFUNC2(cas,size),		\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0,					\
			0, 0, 0, 0


#ifdef __INCLUDE_FUNC_NAMES__
extern "C" const char* FuncName[] =
	{
	FUNCNAME3(8),
	FUNCNAME3(16),
	FUNCNAME3(32),
	FUNCNAME3(64)
	};
#endif

typedef void (*PFV)();

#ifdef __INCLUDE_ATOMIC_FUNCTIONS__
extern "C" const PFV AtomicFuncPtr[] =
	{
	ATOMICFUNC3(8),
	ATOMICFUNC3(16),
	ATOMICFUNC3(32),
	ATOMICFUNC3(64)
	};
#endif

#ifdef __INCLUDE_CONTROL_FUNCTIONS__
extern "C" {

// Simulated versions of atomic functions without the atomicity
extern TUint8	__nonatomic_load8(const volatile TAny* a);
extern TUint8	__nonatomic_store8(volatile TAny* a, TUint8 v);
extern TUint8	__nonatomic_swp8(volatile TAny* a, TUint8 v);
extern TBool	__nonatomic_cas8(volatile TAny* a, TUint8* q, TUint8 v);
extern TUint8	__nonatomic_add8(volatile TAny* a, TUint8 v);
extern TUint8	__nonatomic_and8(volatile TAny* a, TUint8 v);
extern TUint8	__nonatomic_ior8(volatile TAny* a, TUint8 v);
extern TUint8	__nonatomic_xor8(volatile TAny* a, TUint8 v);
extern TUint8	__nonatomic_axo8(volatile TAny* a, TUint8 u, TUint8 v);
extern TUint8	__nonatomic_tau8(volatile TAny* a, TUint8 t, TUint8 u, TUint8 v);
extern TInt8	__nonatomic_tas8(volatile TAny* a, TInt8 t, TInt8 u, TInt8 v);

extern TUint16	__nonatomic_load16(const volatile TAny* a);
extern TUint16	__nonatomic_store16(volatile TAny* a, TUint16 v);
extern TUint16	__nonatomic_swp16(volatile TAny* a, TUint16 v);
extern TBool	__nonatomic_cas16(volatile TAny* a, TUint16* q, TUint16 v);
extern TUint16	__nonatomic_add16(volatile TAny* a, TUint16 v);
extern TUint16	__nonatomic_and16(volatile TAny* a, TUint16 v);
extern TUint16	__nonatomic_ior16(volatile TAny* a, TUint16 v);
extern TUint16	__nonatomic_xor16(volatile TAny* a, TUint16 v);
extern TUint16	__nonatomic_axo16(volatile TAny* a, TUint16 u, TUint16 v);
extern TUint16	__nonatomic_tau16(volatile TAny* a, TUint16 t, TUint16 u, TUint16 v);
extern TInt16	__nonatomic_tas16(volatile TAny* a, TInt16 t, TInt16 u, TInt16 v);

extern TUint32	__nonatomic_load32(const volatile TAny* a);
extern TUint32	__nonatomic_store32(volatile TAny* a, TUint32 v);
extern TUint32	__nonatomic_swp32(volatile TAny* a, TUint32 v);
extern TBool	__nonatomic_cas32(volatile TAny* a, TUint32* q, TUint32 v);
extern TUint32	__nonatomic_add32(volatile TAny* a, TUint32 v);
extern TUint32	__nonatomic_and32(volatile TAny* a, TUint32 v);
extern TUint32	__nonatomic_ior32(volatile TAny* a, TUint32 v);
extern TUint32	__nonatomic_xor32(volatile TAny* a, TUint32 v);
extern TUint32	__nonatomic_axo32(volatile TAny* a, TUint32 u, TUint32 v);
extern TUint32	__nonatomic_tau32(volatile TAny* a, TUint32 t, TUint32 u, TUint32 v);
extern TInt32	__nonatomic_tas32(volatile TAny* a, TInt32 t, TInt32 u, TInt32 v);

extern TUint64	__nonatomic_load64(const volatile TAny* a);
extern TUint64	__nonatomic_store64(volatile TAny* a, TUint64 v);
extern TUint64	__nonatomic_swp64(volatile TAny* a, TUint64 v);
extern TBool	__nonatomic_cas64(volatile TAny* a, TUint64* q, TUint64 v);
extern TUint64	__nonatomic_add64(volatile TAny* a, TUint64 v);
extern TUint64	__nonatomic_and64(volatile TAny* a, TUint64 v);
extern TUint64	__nonatomic_ior64(volatile TAny* a, TUint64 v);
extern TUint64	__nonatomic_xor64(volatile TAny* a, TUint64 v);
extern TUint64	__nonatomic_axo64(volatile TAny* a, TUint64 u, TUint64 v);
extern TUint64	__nonatomic_tau64(volatile TAny* a, TUint64 t, TUint64 u, TUint64 v);
extern TInt64	__nonatomic_tas64(volatile TAny* a, TInt64 t, TInt64 u, TInt64 v);

} // extern "C"


extern "C" const PFV ControlFuncPtr[] =
	{
	CONTROLFUNC3(8),
	CONTROLFUNC3(16),
	CONTROLFUNC3(32),
	CONTROLFUNC3(64)
	};
#endif

#ifdef __INCLUDE_FUNCTION_ATTRIBUTES__
extern "C" const TUint FuncAttr[] =
	{
	FUNCATTR3(1),
	FUNCATTR3(2),
	FUNCATTR3(4),
	FUNCATTR3(8)
	};
#endif

template<class T>
struct TLoadFn	//	load
	{
	typedef T (*F)(const volatile TAny*);
	};

template<class T>
struct TRmw1Fn	// store, swp, add, and, ior, xor
	{
	typedef T (*F)(volatile TAny*, T);
	};

template<class T>
struct TRmw2Fn	// axo
	{
	typedef T (*F)(volatile TAny*, T, T);
	};

template<class T>
struct TRmw3Fn	// tau, tas
	{
	typedef T (*F)(volatile TAny*, T, T, T);
	};

template<class T>
struct TCasFn	// cas
	{
	typedef TBool (*F)(volatile TAny*, T*, T);
	};

class TEnclosed
	{
public:
	TEnclosed(TInt aSize);
	TAny* Ptr();
	TInt Next();
	void Init();
	TInt Verify();
	TInt Offset() const {return iOffset;}
private:
	TUint64* iData;
	TUint64* iBackup;
	TUint64	i_Data[17];
	TInt iOffset;
	TInt iSize;
	};

template<class T>
class Transform
	{
public:
	inline static T A();
	inline static T B();
	static T F(T aOrig);						// return Ax+B mod M (M=2^n, n=number of bits in T)
	static T Pow(T aBase, TUint64 aExp);		// return aBase^aExp mod M
	static T PowerSum(T aBase, TUint64 aExp);	// return 1 + T + T^2 + ... + T^(aExp-1) mod M
	static T F_iter(T aOrig, TUint64 aCount);	// return result of applying F iterated aCount times to aOrig
	};

TEMPLATE_SPECIALIZATION inline TUint8 Transform<TUint8>::A()
	{ return 19; }
TEMPLATE_SPECIALIZATION inline TUint8 Transform<TUint8>::B()
	{ return 29; }

TEMPLATE_SPECIALIZATION inline TUint16 Transform<TUint16>::A()
	{ return 487; }
TEMPLATE_SPECIALIZATION inline TUint16 Transform<TUint16>::B()
	{ return 12983; }

TEMPLATE_SPECIALIZATION inline TUint32 Transform<TUint32>::A()
	{ return 29943829; }
TEMPLATE_SPECIALIZATION inline TUint32 Transform<TUint32>::B()
	{ return 104729; }

TEMPLATE_SPECIALIZATION inline TUint64 Transform<TUint64>::A()
	{ return UI64LIT(2862933555777941757); }
TEMPLATE_SPECIALIZATION inline TUint64 Transform<TUint64>::B()
	{ return UI64LIT(104917093); }

template<class T>
T Transform<T>::F(T aOrig)
	{
	return (T)(aOrig * Transform<T>::A() + Transform<T>::B());
	}

template<class T>
T Transform<T>::Pow(T aBase, TUint64 aExp)
	{
	T result(1);
	T multiplier(aBase);
	while (aExp)
		{
		if (aExp&1)
			result *= multiplier;
		aExp >>= 1;
		if (aExp)
			multiplier *= multiplier;
		}
	return (T)result;
	}

template<class T>
T Transform<T>::PowerSum(T aBase, TUint64 aExp)
	{
	T result(0);
	T multiplier(aBase);
	T inter(1);
	while (aExp)
		{
		if (aExp&1)
			{
			result *= multiplier;
			result += inter;
			}
		aExp >>= 1;
		if (aExp)
			{
			inter *= (multiplier + 1);
			multiplier *= multiplier;
			}
		}
	return (T)result;
	}

template<class T>
T Transform<T>::F_iter(T aOrig, TUint64 aCount)
	{
	return (T)(Pow(A(),aCount)*aOrig + PowerSum(A(),aCount)*B());
	}



#ifdef __EPOC32__
_LIT(KAtomicTestLddName,"D_ATOMIC");

class RTestAtomic : public RBusLogicalChannel
	{
public:
	enum TControl
		{
		ETDGExecuteK=0,
		EInitialise=1,
		ERetrieve=2,
		ESetCurrentThreadTimeslice=3,
		ESwitchExecTables=4,
		EGetKernelMemoryAddress=5,
		EMaxControl
		};

#ifndef __KERNEL_MODE__
public:
	inline TInt Open()
		{ return DoCreate(KAtomicTestLddName,TVersion(),KNullUnit,NULL,NULL); }
public:
	inline TInt TDGExecuteK(TDGBase& a)
		{ return DoControl(ETDGExecuteK, &a); }
	inline TInt Initialise(TUint64 aValue)
		{ return DoControl(EInitialise, &aValue); }
	inline TUint64 Retrieve()
		{ TUint64 x; DoControl(ERetrieve, &x); return x; }
	inline TInt SetCurrentThreadTimeslice(TInt aTimeslice)
		{ return DoControl(ESetCurrentThreadTimeslice, (TAny*)aTimeslice); }
	inline TInt SwitchExecTables(TInt aThread)
		{ return DoControl(ESwitchExecTables, (TAny*)aThread); }
	inline TAny* KernelMemoryAddress()
		{ return (TAny*)DoControl(EGetKernelMemoryAddress); }

	static TInt GetThreadInfo(TPerThread& aInfo);
	static TInt SetThreadInfo(const TPerThread& aInfo);
	static TInt AtomicAction(TAtomicAction& aAction);
	static TInt RestoreExecTable();
#endif
	};
#endif