Symaptic: os/kernelhwsrv/kerneltest/e32test/system/t

     1 // Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of the License "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // e32test\system\t_atomic.cpp

    15 //

    16 //

    18 #define	__E32TEST_EXTENSION__

    20 #include <e32test.h>

    21 #include <e32atomics.h>

    22 #include <u32hal.h>

    23 #include "u32std.h"

    24 #include <e32svr.h>

    25 #include <hal.h>

    27 RTest test(_L("T_ATOMIC"));

    29 #include "t_atomic.h"

    31 #ifdef __EPOC32__

    32 RTestAtomic	DD;

    33 #endif

    35 extern "C" {

    36 extern const char* FuncName[];

    37 extern const PFV AtomicFuncPtr[];

    38 extern const PFV ControlFuncPtr[];

    39 extern const TUint FuncAttr[];

    40 }

    42 class TestOverflowTruncate2 : public TDes16Overflow

    43 	{

    44 public:

    45 	virtual void Overflow(TDes16 &aDes);

    46 	};

    48 void TestOverflowTruncate2::Overflow(TDes16& /*aDes*/)

    49 	{

    50 	}

    52 void UPrintf(const char* aFmt, ...)

    53 	{

    54 	// Print to a console screen.

    55 	TestOverflowTruncate2 overflow;

    56 	VA_LIST list;

    57 	VA_START(list, aFmt);

    58 	TBuf8<256> fmtBuf8((const TUint8*)aFmt);

    59 	TBuf<256> buf;

    60 	buf.AppendFormatList(fmtBuf8.Expand(), list, &overflow);

    61 	test.Printf(_L("%S\n"),&buf);

    62 	}

    64 /******************************************************************************

    65  * Single thread normal operation tests

    66  ******************************************************************************/

    67 template<class T>

    68 struct TD

    69 	{

    70 	T		i0;

    71 	T		i1;

    72 	T		i2;

    73 	T		i3;

    74 	TInt	iF;

    75 	TInt	iPadding;

    76 	};

    78 struct TDG : public TDGBase

    79 	{

    80 	void Set(const TD<TUint8>	aTD8,	TInt aOrd);

    81 	void Set(const TD<TUint16>	aTD16,	TInt aOrd);

    82 	void Set(const TD<TUint32>	aTD32,	TInt aOrd);

    83 	void Set(const TD<TUint64>	aTD64,	TInt aOrd);

    85 	TInt ExecuteUser();

    86 	TInt ExecuteKernel();

    87 	};

    89 TInt GetAtomicFuncIndex(TInt aFunc, TInt aSize, TInt aOrd)

    90 	{

    91 	test_NotNegative(aFunc);

    92 	test_Compare(aFunc,<,EAtomicFuncN);

    93 	test_NotNegative(aOrd);

    94 	test_Compare(aOrd,<,4);

    95 	aFunc *= 4;

    96 	switch(aSize)

    97 		{

    98 		case 1:	break;

    99 		case 2:	aFunc += INDEXES_PER_SIZE; break;

   100 		case 4:	aFunc += 2*INDEXES_PER_SIZE; break;

   101 		case 8:	aFunc += 3*INDEXES_PER_SIZE; break;

   102 		default: test_Equal(8,aSize); break;

   103 		}

   104 	aFunc += aOrd;

   105 	if (AtomicFuncPtr[aFunc])

   106 		return aFunc;

   107 	return -1;

   108 	}

   110 void TDG::Set(const TD<TUint8> aTD8, TInt aOrd)

   111 	{

   112 	i0 = aTD8.i0;

   113 	i1 = aTD8.i1;

   114 	i2 = aTD8.i2;

   115 	i3 = aTD8.i3;

   116 	iIndex = GetAtomicFuncIndex(aTD8.iF, 1, aOrd);

   117 #ifdef __EXTRA_DEBUG__

   118 	DEBUGPRINT(" 8: iF=%2d aOrd=%1d -> %d", aTD8.iF, aOrd, iIndex);

   119 #endif

   120 	}

   122 void TDG::Set(const TD<TUint16> aTD16, TInt aOrd)

   123 	{

   124 	i0 = aTD16.i0;

   125 	i1 = aTD16.i1;

   126 	i2 = aTD16.i2;

   127 	i3 = aTD16.i3;

   128 	iIndex = GetAtomicFuncIndex(aTD16.iF, 2, aOrd);

   129 #ifdef __EXTRA_DEBUG__

   130 	DEBUGPRINT("16: iF=%2d aOrd=%1d -> %d", aTD16.iF, aOrd, iIndex);

   131 #endif

   132 	}

   134 void TDG::Set(const TD<TUint32> aTD32, TInt aOrd)

   135 	{

   136 	i0 = aTD32.i0;

   137 	i1 = aTD32.i1;

   138 	i2 = aTD32.i2;

   139 	i3 = aTD32.i3;

   140 	iIndex = GetAtomicFuncIndex(aTD32.iF, 4, aOrd);

   141 #ifdef __EXTRA_DEBUG__

   142 	DEBUGPRINT("32: iF=%2d aOrd=%1d -> %d", aTD32.iF, aOrd, iIndex);

   143 #endif

   144 	}

   146 void TDG::Set(const TD<TUint64> aTD64, TInt aOrd)

   147 	{

   148 	i0 = aTD64.i0;

   149 	i1 = aTD64.i1;

   150 	i2 = aTD64.i2;

   151 	i3 = aTD64.i3;

   152 	iIndex = GetAtomicFuncIndex(aTD64.iF, 8, aOrd);

   153 #ifdef __EXTRA_DEBUG__

   154 	DEBUGPRINT("64: iF=%2d aOrd=%1d -> %d", aTD64.iF, aOrd, iIndex);

   155 #endif

   156 	}

   158 TInt TDG::ExecuteUser()

   159 	{

   160 	return Execute();

   161 	}

   163 #ifdef __EPOC32__

   164 TInt TDG::ExecuteKernel()

   165 	{

   166 	return DD.TDGExecuteK(*this);

   167 	}

   168 #endif

   171 #define	DCL_TEST_BLOCK(type,name)			\

   172 	static const TD<type> name[] =

   173 #define	DCL_TEST1(type,func,a0)				\

   174 	{	(type)(a0),	(type)(0),	(type)(0),	(type)(0),	(EAtomicFunc##func),	0	}

   175 #define	DCL_TEST2(type,func,a0,a1)			\

   176 	{	(type)(a0),	(type)(a1),	(type)(0),	(type)(0),	(EAtomicFunc##func),	0	}

   177 #define	DCL_TEST3(type,func,a0,a1,a2)		\

   178 	{	(type)(a0),	(type)(a1),	(type)(a2),	(type)(0),	(EAtomicFunc##func),	0	}

   179 #define	DCL_TEST4(type,func,a0,a1,a2,a3)	\

   180 	{	(type)(a0),	(type)(a1),	(type)(a2),	(type)(a3),	(EAtomicFunc##func),	0	}

   182 DCL_TEST_BLOCK(TUint8,TestData8)

   183 	{

   184 	DCL_TEST1(TUint8,	LOAD,	0x00),

   185 	DCL_TEST1(TUint8,	LOAD,	0xFF),

   187 	DCL_TEST2(TUint8,	STORE,	0xBB, 0x00),

   188 	DCL_TEST2(TUint8,	STORE,	0xBB, 0xFF),

   190 	DCL_TEST2(TUint8,	SWP,	0xBB, 0x00),

   191 	DCL_TEST2(TUint8,	SWP,	0xBB, 0xFF),

   192 	DCL_TEST2(TUint8,	SWP,	0x55, 0x00),

   193 	DCL_TEST2(TUint8,	SWP,	0x55, 0xFF),

   195 	DCL_TEST2(TUint8,	ADD,	0x00, 0x01),

   196 	DCL_TEST2(TUint8,	ADD,	0xFF, 0x01),

   197 	DCL_TEST2(TUint8,	ADD,	0xFE, 0x01),

   198 	DCL_TEST2(TUint8,	ADD,	0xFE, 0x02),

   199 	DCL_TEST2(TUint8,	ADD,	0xFE, 0x03),

   200 	DCL_TEST2(TUint8,	ADD,	0x12, 0x23),

   202 	DCL_TEST2(TUint8,	AND,	0x00, 0x01),

   203 	DCL_TEST2(TUint8,	AND,	0xFF, 0x01),

   204 	DCL_TEST2(TUint8,	AND,	0xFE, 0x01),

   205 	DCL_TEST2(TUint8,	AND,	0xFE, 0xFF),

   206 	DCL_TEST2(TUint8,	AND,	0xFE, 0x03),

   207 	DCL_TEST2(TUint8,	AND,	0x5F, 0xAF),

   209 	DCL_TEST2(TUint8,	IOR,	0x00, 0x01),

   210 	DCL_TEST2(TUint8,	IOR,	0xFF, 0x01),

   211 	DCL_TEST2(TUint8,	IOR,	0xFE, 0x01),

   212 	DCL_TEST2(TUint8,	IOR,	0x0D, 0x5F),

   213 	DCL_TEST2(TUint8,	IOR,	0x30, 0x03),

   214 	DCL_TEST2(TUint8,	IOR,	0x5F, 0xAF),

   216 	DCL_TEST2(TUint8,	XOR,	0x00, 0x01),

   217 	DCL_TEST2(TUint8,	XOR,	0xFF, 0x01),

   218 	DCL_TEST2(TUint8,	XOR,	0xFE, 0x01),

   219 	DCL_TEST2(TUint8,	XOR,	0xFE, 0xFF),

   220 	DCL_TEST2(TUint8,	XOR,	0xFE, 0x03),

   221 	DCL_TEST2(TUint8,	XOR,	0x5F, 0xAF),

   223 	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x00),

   224 	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x33),

   225 	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0x7D),

   226 	DCL_TEST3(TUint8,	AXO,	0x00, 0xFF,	0xBB),

   227 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x00),

   228 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x33),

   229 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0x7D),

   230 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x00,	0xBB),

   231 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x33,	0xF0),

   232 	DCL_TEST3(TUint8,	AXO,	0xAA, 0x33,	0x0F),

   233 	DCL_TEST3(TUint8,	AXO,	0xAA, 0xCC,	0xF0),

   234 	DCL_TEST3(TUint8,	AXO,	0xAA, 0xCC,	0x0F),

   236 	DCL_TEST3(TUint8,	CAS,	0x00, 0xFF,	0xEE),

   237 	DCL_TEST3(TUint8,	CAS,	0x00, 0x01,	0x11),

   238 	DCL_TEST3(TUint8,	CAS,	0x00, 0x00,	0xEE),

   239 	DCL_TEST3(TUint8,	CAS,	0x00, 0x00,	0x23),

   240 	DCL_TEST3(TUint8,	CAS,	0x2A, 0xFF,	0x2B),

   241 	DCL_TEST3(TUint8,	CAS,	0x2A, 0x01,	0x2B),

   242 	DCL_TEST3(TUint8,	CAS,	0x2A, 0x2A,	0x2B),

   243 	DCL_TEST3(TUint8,	CAS,	0x2A, 0x2A,	0x3B),

   245 	DCL_TEST4(TUint8,	TAU,	0x00, 0x00,	0x02, 0x03),

   246 	DCL_TEST4(TUint8,	TAU,	0x01, 0x00,	0x02, 0x03),

   247 	DCL_TEST4(TUint8,	TAU,	0xFF, 0x00,	0x02, 0x03),

   248 	DCL_TEST4(TUint8,	TAU,	0x00, 0x01,	0x02, 0x03),

   249 	DCL_TEST4(TUint8,	TAU,	0x01, 0x01,	0x02, 0x03),

   250 	DCL_TEST4(TUint8,	TAU,	0x02, 0x01,	0x02, 0x03),

   251 	DCL_TEST4(TUint8,	TAU,	0xFF, 0x01,	0x02, 0x03),

   252 	DCL_TEST4(TUint8,	TAU,	0xFE, 0xFE,	0x23, 0x0B),

   253 	DCL_TEST4(TUint8,	TAU,	0xEE, 0xFE,	0x23, 0x0B),

   254 	DCL_TEST4(TUint8,	TAU,	0xFF, 0xFE,	0x23, 0x0B),

   255 	DCL_TEST4(TUint8,	TAU,	0x00, 0xFE,	0x23, 0x0B),

   256 	DCL_TEST4(TUint8,	TAU,	0xFE, 0xFE,	0x80, 0x7F),

   257 	DCL_TEST4(TUint8,	TAU,	0xEE, 0xFE,	0x80, 0x7F),

   258 	DCL_TEST4(TUint8,	TAU,	0xFF, 0xFE,	0x80, 0x7F),

   259 	DCL_TEST4(TUint8,	TAU,	0x00, 0xFE,	0x80, 0x7F),

   260 	DCL_TEST4(TUint8,	TAU,	0xFE, 0x80,	0x81, 0x7E),

   261 	DCL_TEST4(TUint8,	TAU,	0x7F, 0x80,	0x81, 0x7E),

   262 	DCL_TEST4(TUint8,	TAU,	0x80, 0x80,	0x81, 0x7E),

   263 	DCL_TEST4(TUint8,	TAU,	0x81, 0x80,	0x81, 0x7E),

   264 	DCL_TEST4(TUint8,	TAU,	0x00, 0x80,	0x81, 0x7E),

   265 	DCL_TEST4(TUint8,	TAU,	0x7E, 0x7F,	0x81, 0x7E),

   266 	DCL_TEST4(TUint8,	TAU,	0x7F, 0x7F,	0x81, 0x7E),

   267 	DCL_TEST4(TUint8,	TAU,	0x80, 0x7F,	0x81, 0x7E),

   268 	DCL_TEST4(TUint8,	TAU,	0x81, 0x7F,	0x81, 0x7E),

   269 	DCL_TEST4(TUint8,	TAU,	0x00, 0x7F,	0x81, 0x7E),

   271 	DCL_TEST4(TUint8,	TAS,	0x00, 0x00,	0x02, 0x03),

   272 	DCL_TEST4(TUint8,	TAS,	0x01, 0x00,	0x02, 0x03),

   273 	DCL_TEST4(TUint8,	TAS,	0xFF, 0x00,	0x02, 0x03),

   274 	DCL_TEST4(TUint8,	TAS,	0x00, 0x01,	0x02, 0x03),

   275 	DCL_TEST4(TUint8,	TAS,	0x01, 0x01,	0x02, 0x03),

   276 	DCL_TEST4(TUint8,	TAS,	0x02, 0x01,	0x02, 0x03),

   277 	DCL_TEST4(TUint8,	TAS,	0xFF, 0x01,	0x02, 0x03),

   278 	DCL_TEST4(TUint8,	TAS,	0xFE, 0xFE,	0x23, 0x0B),

   279 	DCL_TEST4(TUint8,	TAS,	0xEE, 0xFE,	0x23, 0x0B),

   280 	DCL_TEST4(TUint8,	TAS,	0xFF, 0xFE,	0x23, 0x0B),

   281 	DCL_TEST4(TUint8,	TAS,	0x00, 0xFE,	0x23, 0x0B),

   282 	DCL_TEST4(TUint8,	TAS,	0xFE, 0xFE,	0x80, 0x7F),

   283 	DCL_TEST4(TUint8,	TAS,	0xEE, 0xFE,	0x80, 0x7F),

   284 	DCL_TEST4(TUint8,	TAS,	0xFF, 0xFE,	0x80, 0x7F),

   285 	DCL_TEST4(TUint8,	TAS,	0x00, 0xFE,	0x80, 0x7F),

   286 	DCL_TEST4(TUint8,	TAS,	0xFE, 0x80,	0x81, 0x7E),

   287 	DCL_TEST4(TUint8,	TAS,	0x7F, 0x80,	0x81, 0x7E),

   288 	DCL_TEST4(TUint8,	TAS,	0x80, 0x80,	0x81, 0x7E),

   289 	DCL_TEST4(TUint8,	TAS,	0x81, 0x80,	0x81, 0x7E),

   290 	DCL_TEST4(TUint8,	TAS,	0x00, 0x80,	0x81, 0x7E),

   291 	DCL_TEST4(TUint8,	TAS,	0x7E, 0x7F,	0x81, 0x7E),

   292 	DCL_TEST4(TUint8,	TAS,	0x7F, 0x7F,	0x81, 0x7E),

   293 	DCL_TEST4(TUint8,	TAS,	0x80, 0x7F,	0x81, 0x7E),

   294 	DCL_TEST4(TUint8,	TAS,	0x81, 0x7F,	0x81, 0x7E),

   295 	DCL_TEST4(TUint8,	TAS,	0x00, 0x7F,	0x81, 0x7E)

   296 	};

   298 DCL_TEST_BLOCK(TUint16,TestData16)

   299 	{

   300 	DCL_TEST1(TUint16,	LOAD,	0x0055),

   301 	DCL_TEST1(TUint16,	LOAD,	0xFFAA),

   303 	DCL_TEST2(TUint16,	STORE,	0xBBBB, 0x0055),

   304 	DCL_TEST2(TUint16,	STORE,	0xBBBB, 0xFFAA),

   306 	DCL_TEST2(TUint16,	SWP,	0xBBCC, 0x0055),

   307 	DCL_TEST2(TUint16,	SWP,	0xBBCC, 0xFFAA),

   308 	DCL_TEST2(TUint16,	SWP,	0x55AA, 0x0033),

   309 	DCL_TEST2(TUint16,	SWP,	0x55AA, 0xFFCC),

   311 	DCL_TEST2(TUint16,	ADD,	0x0000, 0x0001),

   312 	DCL_TEST2(TUint16,	ADD,	0xFFFF, 0x0001),

   313 	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0001),

   314 	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0002),

   315 	DCL_TEST2(TUint16,	ADD,	0xFFFE, 0x0003),

   316 	DCL_TEST2(TUint16,	ADD,	0x0012, 0x0023),

   317 	DCL_TEST2(TUint16,	ADD,	0x0012, 0xBCFF),

   319 	DCL_TEST2(TUint16,	AND,	0x0000, 0x0001),

   320 	DCL_TEST2(TUint16,	AND,	0xFFFF, 0x0001),

   321 	DCL_TEST2(TUint16,	AND,	0xFFFE, 0x0001),

   322 	DCL_TEST2(TUint16,	AND,	0xFFFE, 0xFFFF),

   323 	DCL_TEST2(TUint16,	AND,	0xFFFE, 0x0F03),

   324 	DCL_TEST2(TUint16,	AND,	0xBC5F, 0x14AF),

   326 	DCL_TEST2(TUint16,	IOR,	0x0000, 0x0001),

   327 	DCL_TEST2(TUint16,	IOR,	0xFFFF, 0x0001),

   328 	DCL_TEST2(TUint16,	IOR,	0xFFFE, 0x0001),

   329 	DCL_TEST2(TUint16,	IOR,	0x000D, 0x005F),

   330 	DCL_TEST2(TUint16,	IOR,	0x8030, 0x0803),

   331 	DCL_TEST2(TUint16,	IOR,	0x145F, 0x56AF),

   333 	DCL_TEST2(TUint16,	XOR,	0x0000, 0x0001),

   334 	DCL_TEST2(TUint16,	XOR,	0xFFFF, 0x0001),

   335 	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0x0001),

   336 	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0xFFFF),

   337 	DCL_TEST2(TUint16,	XOR,	0xFFFE, 0x0003),

   338 	DCL_TEST2(TUint16,	XOR,	0x145F, 0xBCAF),

   340 	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x0000),

   341 	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x6633),

   342 	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0x827D),

   343 	DCL_TEST3(TUint16,	AXO,	0x0000, 0xFFFF,	0xCCBB),

   344 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x0000),

   345 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x6633),

   346 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0x827D),

   347 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x0000,	0xCCBB),

   348 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0xCC33,	0x0FF0),

   349 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0xCC33,	0xF00F),

   350 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x33CC,	0x0FF0),

   351 	DCL_TEST3(TUint16,	AXO,	0xAAAA, 0x33CC,	0xF00F),

   353 	DCL_TEST3(TUint16,	CAS,	0x0000, 0x00FF,	0x99EE),

   354 	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0001,	0x7711),

   355 	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0000,	0x99EE),

   356 	DCL_TEST3(TUint16,	CAS,	0x0000, 0x0000,	0x1123),

   357 	DCL_TEST3(TUint16,	CAS,	0x832A, 0xFFFF,	0x832B),

   358 	DCL_TEST3(TUint16,	CAS,	0x832A, 0x0001,	0x832B),

   359 	DCL_TEST3(TUint16,	CAS,	0x832A, 0x822A,	0x832B),

   360 	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832B,	0x943B),

   361 	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832A,	0x832B),

   362 	DCL_TEST3(TUint16,	CAS,	0x832A, 0x832A,	0x943B),

   364 	DCL_TEST4(TUint16,	TAU,	0x0000, 0x0000,	0x0002, 0x0003),

   365 	DCL_TEST4(TUint16,	TAU,	0x0001, 0x0000,	0x0002, 0x0003),

   366 	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0x0000,	0x0002, 0x0003),

   367 	DCL_TEST4(TUint16,	TAU,	0x0000, 0x0001,	0x0002, 0x0003),

   368 	DCL_TEST4(TUint16,	TAU,	0x0001, 0x0001,	0x0002, 0x0003),

   369 	DCL_TEST4(TUint16,	TAU,	0x0002, 0x0001,	0x0002, 0x0003),

   370 	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0x0001,	0x0002, 0x0003),

   371 	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0xFFFE,	0x1023, 0x000B),

   372 	DCL_TEST4(TUint16,	TAU,	0xFFEE, 0xFFFE,	0x1423, 0x000B),

   373 	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0xFFFE,	0x1423, 0x000B),

   374 	DCL_TEST4(TUint16,	TAU,	0x0000, 0xFFFE,	0x1423, 0x000B),

   375 	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0xFFFE,	0x8000, 0x7FFF),

   376 	DCL_TEST4(TUint16,	TAU,	0xFFEE, 0xFFFE,	0x8000, 0x7FFF),

   377 	DCL_TEST4(TUint16,	TAU,	0xFFFF, 0xFFFE,	0x8000, 0x7FFF),

   378 	DCL_TEST4(TUint16,	TAU,	0x0000, 0xFFFE,	0x8000, 0x7FFF),

   379 	DCL_TEST4(TUint16,	TAU,	0xFFFE, 0x8000,	0x8001, 0x7FFE),

   380 	DCL_TEST4(TUint16,	TAU,	0x7FFF, 0x8000,	0x8001, 0x7FFE),

   381 	DCL_TEST4(TUint16,	TAU,	0x8000, 0x8000,	0x8001, 0x7FFE),

   382 	DCL_TEST4(TUint16,	TAU,	0x8001, 0x8000,	0x8001, 0x7FFE),

   383 	DCL_TEST4(TUint16,	TAU,	0x0000, 0x8000,	0x8001, 0x7FFE),

   384 	DCL_TEST4(TUint16,	TAU,	0x7FFE, 0x7FFF,	0x8001, 0x7FFE),

   385 	DCL_TEST4(TUint16,	TAU,	0x7FFF, 0x7FFF,	0x8001, 0x7FFE),

   386 	DCL_TEST4(TUint16,	TAU,	0x8000, 0x7FFF,	0x8001, 0x7FFE),

   387 	DCL_TEST4(TUint16,	TAU,	0x8001, 0x7FFF,	0x8001, 0x7FFE),

   388 	DCL_TEST4(TUint16,	TAU,	0x0000, 0x7FFF,	0x8001, 0x7FFE),

   390 	DCL_TEST4(TUint16,	TAS,	0x0000, 0x0000,	0x0002, 0x0003),

   391 	DCL_TEST4(TUint16,	TAS,	0x0001, 0x0000,	0x0002, 0x0003),

   392 	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0x0000,	0x0002, 0x0003),

   393 	DCL_TEST4(TUint16,	TAS,	0x0000, 0x0001,	0x0002, 0x0003),

   394 	DCL_TEST4(TUint16,	TAS,	0x0001, 0x0001,	0x0002, 0x0003),

   395 	DCL_TEST4(TUint16,	TAS,	0x0002, 0x0001,	0x0002, 0x0003),

   396 	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0x0001,	0x0002, 0x0003),

   397 	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0xFFFE,	0x1023, 0x000B),

   398 	DCL_TEST4(TUint16,	TAS,	0xFFEE, 0xFFFE,	0x1423, 0x000B),

   399 	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0xFFFE,	0x1423, 0x000B),

   400 	DCL_TEST4(TUint16,	TAS,	0x0000, 0xFFFE,	0x1423, 0x000B),

   401 	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0xFFFE,	0x8000, 0x7FFF),

   402 	DCL_TEST4(TUint16,	TAS,	0xFFEE, 0xFFFE,	0x8000, 0x7FFF),

   403 	DCL_TEST4(TUint16,	TAS,	0xFFFF, 0xFFFE,	0x8000, 0x7FFF),

   404 	DCL_TEST4(TUint16,	TAS,	0x0000, 0xFFFE,	0x8000, 0x7FFF),

   405 	DCL_TEST4(TUint16,	TAS,	0xFFFE, 0x8000,	0x8001, 0x7FFE),

   406 	DCL_TEST4(TUint16,	TAS,	0x7FFF, 0x8000,	0x8001, 0x7FFE),

   407 	DCL_TEST4(TUint16,	TAS,	0x8000, 0x8000,	0x8001, 0x7FFE),

   408 	DCL_TEST4(TUint16,	TAS,	0x8001, 0x8000,	0x8001, 0x7FFE),

   409 	DCL_TEST4(TUint16,	TAS,	0x0000, 0x8000,	0x8001, 0x7FFE),

   410 	DCL_TEST4(TUint16,	TAS,	0x7FFE, 0x7FFF,	0x8001, 0x7FFE),

   411 	DCL_TEST4(TUint16,	TAS,	0x7FFF, 0x7FFF,	0x8001, 0x7FFE),

   412 	DCL_TEST4(TUint16,	TAS,	0x8000, 0x7FFF,	0x8001, 0x7FFE),

   413 	DCL_TEST4(TUint16,	TAS,	0x8001, 0x7FFF,	0x8001, 0x7FFE),

   414 	DCL_TEST4(TUint16,	TAS,	0x0000, 0x7FFF,	0x8001, 0x7FFE)

   415 	};

   417 DCL_TEST_BLOCK(TUint32,TestData32)

   418 	{

   419 	DCL_TEST1(TUint32,	LOAD,	0x00334455),

   420 	DCL_TEST1(TUint32,	LOAD,	0xFFCCBBAA),

   422 	DCL_TEST2(TUint32,	STORE,	0xBBBBBBBB, 0x00334455),

   423 	DCL_TEST2(TUint32,	STORE,	0xBBBBBBBB, 0xFFCCBBAA),

   425 	DCL_TEST2(TUint32,	SWP,	0xBB1234CC, 0x00EDCB55),

   426 	DCL_TEST2(TUint32,	SWP,	0xBB1234CC, 0xFF9876AA),

   427 	DCL_TEST2(TUint32,	SWP,	0x551971AA, 0x00112233),

   428 	DCL_TEST2(TUint32,	SWP,	0x551971AA, 0xFFEEDDCC),

   430 	DCL_TEST2(TUint32,	ADD,	0x00000000, 0x00000001),

   431 	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFF, 0x00000001),

   432 	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000001),

   433 	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000002),

   434 	DCL_TEST2(TUint32,	ADD,	0xFFFFFFFE, 0x00000003),

   435 	DCL_TEST2(TUint32,	ADD,	0x00009912, 0x00000023),

   436 	DCL_TEST2(TUint32,	ADD,	0x00009912, 0x4937BCFF),

   438 	DCL_TEST2(TUint32,	AND,	0x00000000, 0x00000001),

   439 	DCL_TEST2(TUint32,	AND,	0xFFFFFFFF, 0x00000001),

   440 	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0x00000001),

   441 	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0xFFFFFFFF),

   442 	DCL_TEST2(TUint32,	AND,	0xFFFFFFFE, 0x00000F03),

   443 	DCL_TEST2(TUint32,	AND,	0xEDCBBC5F, 0xDCBA14AF),

   445 	DCL_TEST2(TUint32,	IOR,	0x00000000, 0x00000001),

   446 	DCL_TEST2(TUint32,	IOR,	0xFFFFFFFF, 0x00000001),

   447 	DCL_TEST2(TUint32,	IOR,	0xFFFFFFFE, 0x00000001),

   448 	DCL_TEST2(TUint32,	IOR,	0x0000000D, 0x0000005F),

   449 	DCL_TEST2(TUint32,	IOR,	0x80000030, 0x00000803),

   450 	DCL_TEST2(TUint32,	IOR,	0x89AB145F, 0x415256AF),

   452 	DCL_TEST2(TUint32,	XOR,	0x00000000, 0x00000001),

   453 	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFF, 0x00000001),

   454 	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0x00000001),

   455 	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0xFFFFFFFF),

   456 	DCL_TEST2(TUint32,	XOR,	0xFFFFFFFE, 0x00000003),

   457 	DCL_TEST2(TUint32,	XOR,	0x89AB145F, 0x4152BCAF),

   459 	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x00000000),

   460 	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x99CC6633),

   461 	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0x8000027D),

   462 	DCL_TEST3(TUint32,	AXO,	0x00000000, 0xFFFFFFFF,	0xEEDDCCBB),

   463 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x00000000),

   464 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x99CC6633),

   465 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0x8000027D),

   466 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x00000000,	0xEEDDCCBB),

   467 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x9966CC33,	0x0FF00FF0),

   468 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x9966CC33,	0xF00FF00F),

   469 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x669933CC,	0x0FF00FF0),

   470 	DCL_TEST3(TUint32,	AXO,	0xAAAAAAAA, 0x669933CC,	0xF00FF00F),

   472 	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x000000FF,	0x99ABCDEE),

   473 	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000001,	0x7FFFF711),

   474 	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000000,	0x99ABCDEE),

   475 	DCL_TEST3(TUint32,	CAS,	0x00000000, 0x00000000,	0x11234567),

   476 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0xFFFFFFFF,	0x8000032B),

   477 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x00000001,	0x8000032B),

   478 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000022A,	0x8000032B),

   479 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032B,	0x943BFCD1),

   480 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032A,	0x8000032B),

   481 	DCL_TEST3(TUint32,	CAS,	0x8000032A, 0x8000032A,	0x943BFCD1),

   483 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x00000000,	0x00000002, 0x00000003),

   484 	DCL_TEST4(TUint32,	TAU,	0x00000001, 0x00000000,	0x00000002, 0x00000003),

   485 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0x00000000,	0x00000002, 0x00000003),

   486 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x00000001,	0x00000002, 0x00000003),

   487 	DCL_TEST4(TUint32,	TAU,	0x00000001, 0x00000001,	0x00000002, 0x00000003),

   488 	DCL_TEST4(TUint32,	TAU,	0x00000002, 0x00000001,	0x00000002, 0x00000003),

   489 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0x00000001,	0x00000002, 0x00000003),

   490 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0xFFFFFFFE,	0x1023144F, 0x0000000B),

   491 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFEE, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   492 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   493 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   494 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   495 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFEE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   496 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFF, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   497 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   498 	DCL_TEST4(TUint32,	TAU,	0xFFFFFFFE, 0x80000000,	0x80000001, 0x7FFFFFFE),

   499 	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFF, 0x80000000,	0x80000001, 0x7FFFFFFE),

   500 	DCL_TEST4(TUint32,	TAU,	0x80000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

   501 	DCL_TEST4(TUint32,	TAU,	0x80000001, 0x80000000,	0x80000001, 0x7FFFFFFE),

   502 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

   503 	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFE, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   504 	DCL_TEST4(TUint32,	TAU,	0x7FFFFFFF, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   505 	DCL_TEST4(TUint32,	TAU,	0x80000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   506 	DCL_TEST4(TUint32,	TAU,	0x80000001, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   507 	DCL_TEST4(TUint32,	TAU,	0x00000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   509 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x00000000,	0x00000002, 0x00000003),

   510 	DCL_TEST4(TUint32,	TAS,	0x00000001, 0x00000000,	0x00000002, 0x00000003),

   511 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0x00000000,	0x00000002, 0x00000003),

   512 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x00000001,	0x00000002, 0x00000003),

   513 	DCL_TEST4(TUint32,	TAS,	0x00000001, 0x00000001,	0x00000002, 0x00000003),

   514 	DCL_TEST4(TUint32,	TAS,	0x00000002, 0x00000001,	0x00000002, 0x00000003),

   515 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0x00000001,	0x00000002, 0x00000003),

   516 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0xFFFFFFFE,	0x1023144F, 0x0000000B),

   517 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFEE, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   518 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   519 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0xFFFFFFFE,	0x1423144F, 0x0000000B),

   520 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   521 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFEE, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   522 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFF, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   523 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0xFFFFFFFE,	0x80000000, 0x7FFFFFFF),

   524 	DCL_TEST4(TUint32,	TAS,	0xFFFFFFFE, 0x80000000,	0x80000001, 0x7FFFFFFE),

   525 	DCL_TEST4(TUint32,	TAS,	0x7FFFFFFF, 0x80000000,	0x80000001, 0x7FFFFFFE),

   526 	DCL_TEST4(TUint32,	TAS,	0x80000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

   527 	DCL_TEST4(TUint32,	TAS,	0x80000001, 0x80000000,	0x80000001, 0x7FFFFFFE),

   528 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x80000000,	0x80000001, 0x7FFFFFFE),

   529 	DCL_TEST4(TUint32,	TAS,	0x7FFFFFFE, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   530 	DCL_TEST4(TUint32,	TAS,	0x7FFFFFFF, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   531 	DCL_TEST4(TUint32,	TAS,	0x80000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   532 	DCL_TEST4(TUint32,	TAS,	0x80000001, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE),

   533 	DCL_TEST4(TUint32,	TAS,	0x00000000, 0x7FFFFFFF,	0x80000001, 0x7FFFFFFE)

   534 	};

   536 DCL_TEST_BLOCK(TUint64,TestData64)

   537 	{

   538 	DCL_TEST1(TUint64,	LOAD,	MAKE_TUINT64(0x00000000,0x00000000)),

   539 	DCL_TEST1(TUint64,	LOAD,	MAKE_TUINT64(0xFEDCBA98,0x76543210)),

   541 	DCL_TEST2(TUint64,	STORE,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   542 	DCL_TEST2(TUint64,	STORE,	MAKE_TUINT64(0xFEDCBA98,0x76543210), MAKE_TUINT64(0x06931471,0x80559945)),

   544 	DCL_TEST2(TUint64,	SWP,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   545 	DCL_TEST2(TUint64,	SWP,	MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   546 	DCL_TEST2(TUint64,	SWP,	MAKE_TUINT64(0xDEADBEEF,0xBAD0BEEF), MAKE_TUINT64(0x06931471,0x80559945)),

   547 	DCL_TEST2(TUint64,	SWP,	MAKE_TUINT64(0xFEDCBA98,0x76543210), MAKE_TUINT64(0x06931471,0x80559945)),

   549 	DCL_TEST2(TUint64,	ADD,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001)),

   550 	DCL_TEST2(TUint64,	ADD,	MAKE_TUINT64(0x00000000,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001)),

   551 	DCL_TEST2(TUint64,	ADD,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   552 	DCL_TEST2(TUint64,	ADD,	MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   554 	DCL_TEST2(TUint64,	AND,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001)),

   555 	DCL_TEST2(TUint64,	AND,	MAKE_TUINT64(0x00000000,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001)),

   556 	DCL_TEST2(TUint64,	AND,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   557 	DCL_TEST2(TUint64,	AND,	MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   559 	DCL_TEST2(TUint64,	IOR,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001)),

   560 	DCL_TEST2(TUint64,	IOR,	MAKE_TUINT64(0x00000000,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001)),

   561 	DCL_TEST2(TUint64,	IOR,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   562 	DCL_TEST2(TUint64,	IOR,	MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   563 	DCL_TEST2(TUint64,	IOR,	MAKE_TUINT64(0x11111111,0x22222222), MAKE_TUINT64(0x44444444,0x55555555)),

   565 	DCL_TEST2(TUint64,	XOR,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001)),

   566 	DCL_TEST2(TUint64,	XOR,	MAKE_TUINT64(0x00000000,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001)),

   567 	DCL_TEST2(TUint64,	XOR,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   568 	DCL_TEST2(TUint64,	XOR,	MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFCD1CC9F,0xDB27CC8B)),

   569 	DCL_TEST2(TUint64,	XOR,	MAKE_TUINT64(0x11111111,0x22222222), MAKE_TUINT64(0x44444444,0x77777777)),

   571 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001)),

   572 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   573 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   574 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   575 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0xFACEFEED,0xFEEDFACE), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   576 	DCL_TEST3(TUint64,	AXO,	MAKE_TUINT64(0xBAD8BEEF,0xDEADDEAD), MAKE_TUINT64(0xFACEFEED,0xFEEDFACE), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   578 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   579 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000001,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   580 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   581 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000001,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   582 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000001,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   583 	DCL_TEST3(TUint64,	CAS,	MAKE_TUINT64(0x00000001,0x00000000), MAKE_TUINT64(0x00000001,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED)),

   585 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   586 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   587 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   588 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   589 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   590 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x00000000,0x00000002), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   591 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   592 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0xFFFFFFFF,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   593 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x00000000), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   594 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   595 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x00000002), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   596 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   597 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0x00000000), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   598 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   599 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0x80000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   600 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0x80000002), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   601 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   602 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x7FFFFFFF,0x7FFFFFFF), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   603 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x00000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   604 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x80000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   605 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x80000001), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   606 	DCL_TEST4(TUint64,	TAU,	MAKE_TUINT64(0x80000000,0x80000002), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   608 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   609 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   610 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   611 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x00000000,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   612 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   613 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x00000000,0x00000002), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   614 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0xFFFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   615 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0xFFFFFFFF,0x00000000), MAKE_TUINT64(0x00000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   616 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x00000000), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   617 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   618 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x00000002), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   619 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   620 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0x00000000), MAKE_TUINT64(0x80000000,0x00000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   621 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   622 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0x80000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   623 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0x80000002), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   624 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0xFFFFFFFF), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   625 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x7FFFFFFF,0x7FFFFFFF), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   626 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x00000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   627 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x80000000), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   628 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x80000001), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5)),

   629 	DCL_TEST4(TUint64,	TAS,	MAKE_TUINT64(0x80000000,0x80000002), MAKE_TUINT64(0x7FFFFFFF,0x80000001), MAKE_TUINT64(0xFEEDFACE,0xFACEFEED), MAKE_TUINT64(0xBAD9BEEF,0x00FAECE5))

   630 	};

   634 template<class T>

   635 void DoTestBlock(const TD<T>* aTests, TInt aCount)

   636 	{

   637 	const TD<T>* p = aTests;

   638 	const TD<T>* e = aTests + aCount;

   639 	for (; p<e; ++p)

   640 		{

   641 		TInt ord;

   642 		for (ord=EOrderRelaxed; ord<=EOrderOrdered; ++ord)

   643 			{

   644 			TDG tdg;

   645 			tdg.Set(*p, ord);

   646 			if (tdg.iIndex<0)

   647 				continue;

   648 #ifdef __EXTRA_DEBUG__

   649 			TPtrC8 fname8((const TText8*)FuncName[tdg.iIndex]);

   650 			TBuf<64> fname;

   651 			fname.Copy(fname8);

   652 			test.Printf(_L("%S\n"), &fname);

   653 #endif

   654 			TInt res;

   655 			res = tdg.ExecuteUser();

   656 			if (res!=0)

   657 				{

   658 				tdg.Dump("ExecuteUser");

   659 				test.Printf(_L("FAIL %d\n"),res);

   660 				test(0);

   661 				}

   662 #ifdef __EPOC32__

   663 #ifdef __EXTRA_DEBUG__

   664 			test.Printf(_L("%S K\n"), &fname);

   665 #endif

   666 			res = tdg.ExecuteKernel();

   667 			if (res!=0)

   668 				{

   669 				tdg.Dump("ExecuteKernel");

   670 				test.Printf(_L("FAIL %d\n"),res);

   671 				test(0);

   672 				}

   673 #endif

   674 			}

   675 		}

   676 	}

   678 #define DO_TEST_BLOCK(type,array)	\

   679 	DoTestBlock<type>(&(array)[0],(TInt)(sizeof(array)/sizeof(TD<type>)))

   681 void TestSingleThread()

   682 	{

   683 	test.Next(_L("8 bit, single thread"));

   684 	DO_TEST_BLOCK(TUint8, TestData8);

   685 	test.Next(_L("16 bit, single thread"));

   686 	DO_TEST_BLOCK(TUint16, TestData16);

   687 	test.Next(_L("32 bit, single thread"));

   688 	DO_TEST_BLOCK(TUint32, TestData32);

   689 	test.Next(_L("64 bit, single thread"));

   690 	DO_TEST_BLOCK(TUint64, TestData64);

   691 	}

   695 /******************************************************************************

   696  * Test invalid address handling when called from user mode

   697  ******************************************************************************/

   698 const TLinAddr KSpecialAddr = 0x100u;

   699 const TInt KIndexRead = -1;

   700 const TInt KIndexReadWrite = -2;

   702 struct TE

   703 	{

   704 	static TInt Execute(TInt aIndex, TAny* aPtr1, TAny* aPtr2, TInt aResult);

   705 	TInt DoExecute();

   706 	static TInt ThreadFn(TAny*);

   708 	TInt	iIndex;

   709 	TAny*	iPtr1;

   710 	TAny*	iPtr2;

   711 	};

   713 template<class T> TInt DoLoadErrorTest(TInt aIndex, const T* aPtr)

   714 	{

   715 	typename TLoadFn<T>::F atomic = (typename TLoadFn<T>::F)AtomicFuncPtr[aIndex];

   716 	atomic(aPtr);

   717 	return 0;

   718 	}

   720 template<class T> TInt DoRmw1ErrorTest(TInt aIndex, T* aPtr)

   721 	{

   722 	typename TRmw1Fn<T>::F atomic = (typename TRmw1Fn<T>::F)AtomicFuncPtr[aIndex];

   723 	T a1 = 0;

   724 	atomic(aPtr, a1);

   725 	return 0;

   726 	}

   728 template<class T> TInt DoRmw2ErrorTest(TInt aIndex, T* aPtr)

   729 	{

   730 	typename TRmw2Fn<T>::F atomic = (typename TRmw2Fn<T>::F)AtomicFuncPtr[aIndex];

   731 	T a1 = 0;

   732 	T a2 = 0;

   733 	atomic(aPtr, a1, a2);

   734 	return 0;

   735 	}

   737 template<class T> TInt DoRmw3ErrorTest(TInt aIndex, T* aPtr)

   738 	{

   739 	typename TRmw3Fn<T>::F atomic = (typename TRmw3Fn<T>::F)AtomicFuncPtr[aIndex];

   740 	T a1 = 0;

   741 	T a2 = 0;

   742 	T a3 = 0;

   743 	atomic(aPtr, a1, a2, a3);

   744 	return 0;

   745 	}

   747 template<class T> TInt DoCasErrorTest(TInt aIndex, T* aPtr1, T* aPtr2)

   748 	{

   749 	typename TCasFn<T>::F atomic = (typename TCasFn<T>::F)AtomicFuncPtr[aIndex];

   750 	TLinAddr a1 = (TLinAddr)aPtr1;

   751 	TLinAddr a2 = (TLinAddr)aPtr2;

   752 	T reg;

   753 	T exp;

   754 	T f;

   755 	memset(&f, 0xbb, sizeof(T));

   756 	if ((a1&~0xff)==KSpecialAddr)

   757 		{

   758 		memset(&reg, (a1&0xff), sizeof(T));

   759 		aPtr1 = &reg;

   760 		}

   761 	if ((a2&~0xff)==KSpecialAddr)

   762 		{

   763 		memset(&exp, (a2&0xff), sizeof(T));

   764 		aPtr2 = &exp;

   765 		}

   766 	TInt r = atomic(aPtr1, aPtr2, f);

   767 	return r ? 1 : 0;

   768 	}

   770 TInt TE::DoExecute()

   771 	{

   772 	if (iIndex == KIndexRead)

   773 		{

   774 		return *(volatile TUint8*)iPtr1;

   775 		}

   776 	if (iIndex == KIndexReadWrite)

   777 		{

   778 		volatile TUint8* p = (volatile TUint8*)iPtr1;

   779 		TUint8 x = *p;

   780 		*p = x;

   781 		return 0;

   782 		}

   783 	TUint attr = FuncAttr[iIndex];

   784 	TInt type = ATTR_TO_TYPE(attr);

   785 	TInt size = ATTR_TO_SIZE(attr);

   786 	if (type==EFuncTypeInvalid)

   787 		return KErrNotSupported;

   788 	TInt res;

   789 	switch (type)

   790 		{

   791 		case EFuncTypeLoad:

   792 			{

   793 			switch (size)

   794 				{

   795 				case 1:	res = DoLoadErrorTest<TUint8>(iIndex, (TUint8*)iPtr1); break;

   796 				case 2:	res = DoLoadErrorTest<TUint16>(iIndex, (TUint16*)iPtr1); break;

   797 				case 4:	res = DoLoadErrorTest<TUint32>(iIndex, (TUint32*)iPtr1); break;

   798 				case 8:	res = DoLoadErrorTest<TUint64>(iIndex, (TUint64*)iPtr1); break;

   799 				default: res = KErrNotSupported; break;

   800 				}

   801 			break;

   802 			}

   803 		case EFuncTypeRmw1:

   804 			{

   805 			switch (size)

   806 				{

   807 				case 1:	res = DoRmw1ErrorTest<TUint8>(iIndex, (TUint8*)iPtr1); break;

   808 				case 2:	res = DoRmw1ErrorTest<TUint16>(iIndex, (TUint16*)iPtr1); break;

   809 				case 4:	res = DoRmw1ErrorTest<TUint32>(iIndex, (TUint32*)iPtr1); break;

   810 				case 8:	res = DoRmw1ErrorTest<TUint64>(iIndex, (TUint64*)iPtr1); break;

   811 				default: res = KErrNotSupported; break;

   812 				}

   813 			break;

   814 			}

   815 		case EFuncTypeRmw2:

   816 			{

   817 			switch (size)

   818 				{

   819 				case 1:	res = DoRmw2ErrorTest<TUint8>(iIndex, (TUint8*)iPtr1); break;

   820 				case 2:	res = DoRmw2ErrorTest<TUint16>(iIndex, (TUint16*)iPtr1); break;

   821 				case 4:	res = DoRmw2ErrorTest<TUint32>(iIndex, (TUint32*)iPtr1); break;

   822 				case 8:	res = DoRmw2ErrorTest<TUint64>(iIndex, (TUint64*)iPtr1); break;

   823 				default: res = KErrNotSupported; break;

   824 				}

   825 			break;

   826 			}

   827 		case EFuncTypeRmw3:

   828 			{

   829 			switch (size)

   830 				{

   831 				case 1:	res = DoRmw3ErrorTest<TUint8>(iIndex, (TUint8*)iPtr1); break;

   832 				case 2:	res = DoRmw3ErrorTest<TUint16>(iIndex, (TUint16*)iPtr1); break;

   833 				case 4:	res = DoRmw3ErrorTest<TUint32>(iIndex, (TUint32*)iPtr1); break;

   834 				case 8:	res = DoRmw3ErrorTest<TUint64>(iIndex, (TUint64*)iPtr1); break;

   835 				default: res = KErrNotSupported; break;

   836 				}

   837 			break;

   838 			}

   839 		case EFuncTypeCas:

   840 			{

   841 			switch (size)

   842 				{

   843 				case 1:	res = DoCasErrorTest<TUint8>(iIndex, (TUint8*)iPtr1, (TUint8*)iPtr2); break;

   844 				case 2:	res = DoCasErrorTest<TUint16>(iIndex, (TUint16*)iPtr1, (TUint16*)iPtr2); break;

   845 				case 4:	res = DoCasErrorTest<TUint32>(iIndex, (TUint32*)iPtr1, (TUint32*)iPtr2); break;

   846 				case 8:	res = DoCasErrorTest<TUint64>(iIndex, (TUint64*)iPtr1, (TUint64*)iPtr2); break;

   847 				default: res = KErrNotSupported; break;

   848 				}

   849 			break;

   850 			}

   851 		default:

   852 			res = KErrNotSupported;

   853 			break;

   854 		}

   855 	return res;

   856 	}

   858 TInt TE::ThreadFn(TAny* aPtr)

   859 	{

   860 	return ((TE*)aPtr)->DoExecute();

   861 	}

   863 _LIT(KLitKERNEXEC,"KERN-EXEC");

   864 TInt TE::Execute(TInt aIndex, TAny* aPtr1, TAny* aPtr2, TInt aResult)

   865 	{

   866 	DEBUGPRINT("I=%3d P1=%08x P2=%08x R=%d", aIndex, aPtr1, aPtr2, aResult);

   867 	TE te;

   868 	te.iIndex = aIndex;

   869 	te.iPtr1 = aPtr1;

   870 	te.iPtr2 = aPtr2;

   871 	RThread t;

   872 	TInt r = t.Create(KNullDesC, &ThreadFn, 0x1000, 0, &te);

   873 	test_KErrNone(r);

   874 	TRequestStatus s;

   875 	t.Logon(s);

   876 	test_Equal(KRequestPending, s.Int());

   877 	TBool jit = User::JustInTime();

   878 	User::SetJustInTime(EFalse);

   879 	t.Resume();

   880 	User::WaitForRequest(s);

   881 	User::SetJustInTime(jit);

   882 	TInt xt = t.ExitType();

   883 	TInt xr = t.ExitReason();

   884 	const TDesC& xc = t.ExitCategory();

   885 	DEBUGPRINT("Exit type: %d,%d,%S", xt, xr, &xc);

   886 	TInt res = KErrNone;

   887 	if (aResult == KErrUnknown)

   888 		{

   889 		if (xt==EExitPanic)

   890 			{

   891 			test_Equal(ECausedException, xr);

   892 			test(xc==KLitKERNEXEC);

   893 			res = KErrDied;

   894 			}

   895 		else

   896 			test_Equal(EExitKill, xt);

   897 		}

   898 	else if (aResult == KErrDied)

   899 		{

   900 		test_Equal(EExitPanic, xt);

   901 		test_Equal(ECausedException, xr);

   902 		test(xc==KLitKERNEXEC);

   903 		}

   904 	else

   905 		{

   906 		test_Equal(EExitKill, xt);

   907 		test_Equal(aResult, xr);

   908 		}

   909 	CLOSE_AND_WAIT(t);

   910 	return res;

   911 	}

   913 TInt ThreadAlign(TAny*)

   914 	{

   915 	TUint32 array[2];

   916 	TUint32* p = (TUint32*)(((TLinAddr)array)+1);

   917 	*p = 5;

   918 	return KErrNone;

   919 	}

   921 const TUint64 Zero = UI64LIT(0);

   922 const TUint64 BFBF = UI64LIT(0xbfbfbfbfbfbfbfbf);

   924 void TestInvalidAddresses()

   925 	{

   926 	TAny* bad_addr[11];

   927 	TInt c = 0;

   928 	TInt read_only = 0;

   929 	TInt alignmentEnd = 0;

   930 	TInt mminfo = UserSvr::HalFunction(EHalGroupKernel, EKernelHalMemModelInfo, 0, 0);

   931 //	TInt mmtype = mminfo & EMemModelTypeMask;

   932 #ifdef __EPOC32__

   933 	if (mminfo & EMemModelAttrWriteProt)

   934 		{

   935 		bad_addr[c++] = (TAny*)UserSvr::RomHeaderAddress();

   936 		bad_addr[c++] = (TAny*)&Zero;

   937 		bad_addr[c++] = (TAny*)&BFBF;

   938 		read_only = c;

   939 		}

   940 #endif

   941 	if (mminfo & EMemModelAttrNonExProt)

   942 		{

   943 		bad_addr[c++] = 0;	// address 0 is read only on ARM7 cores, nonexistent on others

   944 		if (TE::Execute(KIndexRead, 0, 0, KErrUnknown)==KErrNone)

   945 			read_only = c;	// address 0 is readable

   946 		TLinAddr nonex = 0;

   947 		do	{

   948 			nonex += 0x1000;

   949 			} while (TE::Execute(KIndexRead, (TAny*)nonex, 0, KErrUnknown)==KErrNone);

   950 		bad_addr[c++] = (TAny*)nonex;

   951 		}

   952 #ifdef __EPOC32__

   953 	if (mminfo & EMemModelAttrKernProt)

   954 		{

   955 		bad_addr[c++] = DD.KernelMemoryAddress();

   956 		}

   957 	// If alignment checking is enabled add alignment tests for 64 bit.

   958 	TUint64A alignArray[2];

   959 	RThread t;

   960 	TInt r = t.Create(KNullDesC, &ThreadAlign, 0x1000, 0, NULL);

   961 	test_KErrNone(r);

   962 	TRequestStatus s;

   963 	t.Logon(s);

   964 	test_Equal(KRequestPending, s.Int());

   965 	TBool jit = User::JustInTime();

   966 	User::SetJustInTime(EFalse);

   967 	t.Resume();

   968 	User::WaitForRequest(s);

   969 	User::SetJustInTime(jit);

   970 	TInt xt = t.ExitType();

   971 	TInt xr = t.ExitReason();

   972 	const TDesC& xc = t.ExitCategory();

   973 	if (EExitPanic == xt)

   974 		{// Took an alignment fault so add alignment test.

   975 		test_Equal(ECausedException, xr);

   976 		test(xc==KLitKERNEXEC);

   977 		alignmentEnd = c;

   978 		bad_addr[alignmentEnd++] = (TAny*)(((TUint)&alignArray[0]) + 1);

   979 		bad_addr[alignmentEnd++] = (TAny*)(((TUint)&alignArray[0]) + 2);

   980 		bad_addr[alignmentEnd++] = (TAny*)(((TUint)&alignArray[0]) + 4);

   981 		}

   983 #endif

   984 	TInt i;

   985 	TInt allBadAddr = (alignmentEnd)? c+3 : c;

   986 	DEBUGPRINT("%d invalid addresses", allBadAddr);

   987 	for (i=0; i < allBadAddr; ++i)

   988 		{

   989 		if (i<read_only)

   990 			{

   991 			DEBUGPRINT("bad_addr[%d]=%08x (RO)", i, bad_addr[i]);

   992 			}

   993 		else

   994 			{

   995 			DEBUGPRINT("bad_addr[%d]=%08x", i, bad_addr[i]);

   996 			}

   997 		}

   998 	if (c==0)

   999 		return;

  1000 	TInt ix;

  1001 	for (ix=0; ix<TOTAL_INDEXES; ++ix)

  1002 		{

  1003 		TUint attr = FuncAttr[ix];

  1004 		TUint func = ATTR_TO_FUNC(attr);

  1005 		TUint type = ATTR_TO_TYPE(attr);

  1006 		if (type==EFuncTypeInvalid)

  1007 			continue;

  1008 		if (func==TUint(EAtomicFuncCAS))

  1009 			{

  1010 			// both addresses OK

  1011 			TE::Execute(ix, (TAny*)(KSpecialAddr+0), (TAny*)(KSpecialAddr+0), 1);	// should do the swap

  1012 			TE::Execute(ix, (TAny*)(KSpecialAddr+0), (TAny*)(KSpecialAddr+1), 0);	// should not do the swap

  1014 			// RMW address OK, expected bad

  1015 			for (i=0; i<c; ++i)

  1016 				{

  1017 				TAny* p = bad_addr[i];

  1018 				TInt res = (bad_addr[i]==(TAny*)&BFBF) ? 1 : KErrDied;

  1019 				TE::Execute(ix, (TAny*)(KSpecialAddr+0xbf), p, res);

  1020 				}

  1022 			// RMW address bad, expected OK

  1023 			for (i=0; i<c; ++i)

  1024 				{

  1025 				TAny* p = bad_addr[i];

  1026 #if defined(__CPU_X86)

  1027 				TInt res = KErrDied;	// on X86 location must be writeable

  1028 #elif defined(__CPU_ARM)

  1029 				TInt res = (i<read_only && bad_addr[i]!=(TAny*)&BFBF) ? 0 : KErrDied;

  1030 				// 64-bit operations on platforms that use a slow exec for 64 bit

  1031 				// will always write to bad_addr[i] but other platforms won't.

  1032 				if (ATTR_TO_SIZE(attr) == 8)

  1033 					res = KErrUnknown;

  1034 #else

  1035 #error CPU?

  1036 #endif

  1037 				TE::Execute(ix, p, (TAny*)(KSpecialAddr+0xbf), res);

  1038 				}

  1040 			// Both addresses bad

  1041 			TInt j;

  1042 			for (i=0; i<c; ++i)

  1043 				{

  1044 				for (j=0; j<c; ++j)

  1045 					{

  1046 					TE::Execute(ix, bad_addr[i], bad_addr[j], KErrDied);

  1047 					}

  1048 				}

  1049 			}

  1050 		else

  1051 			{

  1052 			// just run through all the bad addresses

  1053 			for (i=0; i<c; ++i)

  1054 				{

  1055 				TAny* p = bad_addr[i];

  1056 				TBool ro = (i<read_only);

  1057 				TInt res = ((func == TUint(EAtomicFuncLOAD)) && ro) ? KErrNone : KErrDied;

  1058 				if (func==TUint(EAtomicFuncLOAD) && ATTR_TO_SIZE(attr)==8)

  1059 					res = KErrUnknown;	// 64-bit atomic loads may or may not write as well

  1060 				TE::Execute(ix, p, 0, res);

  1061 				}

  1062 			}

  1063 // Checks for 8 byte alignment not enabled on old gcc (arm4) as it is not eabi compliant.

  1064 #if (defined(__GNUC__) && (__GNUC__ >= 3)) || defined(__EABI__)

  1065 		if (ATTR_TO_SIZE(attr) == 8)

  1066 			{

  1067 			for (i = c; i < alignmentEnd; i++)

  1068 				{// 64 bit unaligned accesses should cause exceptions if

  1069 				// alignment checking is enabled.

  1070 				TE::Execute(ix, bad_addr[i], 0, KErrDied);

  1071 				}

  1072 			}

  1073 #endif

  1074 		}

  1075 	}

  1079 /******************************************************************************

  1080  * Multiple thread normal operation tests

  1081  ******************************************************************************/

  1082 class CThread;

  1083 class CThreads : public CBase

  1084 	{

  1085 public:

  1086 	static CThreads* New();

  1087 	CThreads();

  1088 	~CThreads();

  1089 	CThread* NewThread(TInt aId);

  1090 	void StartTest(TInt aIndex, TBool aKernel);

  1091 	void StopTest();

  1092 	void Finish();

  1093 	TUint32 DoCasTest(TInt aIndex, TBool aKernel, TUint32 aFailLimit);

  1094 	void DoRmwTest(TInt aIndex, TBool aKernel, TInt aTime);

  1095 	inline TInt NumCpus() const {return iNumCpus;}

  1096 private:

  1097 	TInt			iNumCpus;

  1098 	TInt			iNumThreads;

  1099 	CThread*		iThreads[KMaxThreads];

  1100 	RSemaphore		iSem;

  1101 	volatile TInt	iIndex;

  1102 	volatile TBool	iKernel;

  1103 	volatile TBool	iStop;

  1104 	volatile TUint64 iReg;

  1105 	TInt			iFailCount;

  1106 	TInt			iTimeslice;

  1107 private:

  1108 	friend class CThread;

  1109 	};

  1111 class CThread : public CBase

  1112 	{

  1113 private:

  1114 	CThread();

  1115 	~CThread();

  1116 	static TInt ThreadFunction(TAny*);

  1117 	TInt Run();

  1118 	TInt Create();

  1119 	void Start();

  1120 	void DoTest();

  1121 	TUint64 Random();

  1122 	void Kick();

  1123 private:

  1124 	RThread			iThread;

  1125 	TInt			iId;

  1126 	CThreads*		iThreads;

  1127 	TRequestStatus	iStatus;

  1128 	TBool			iStarted;

  1129 	TPerThread		iPerThread;

  1130 	TUint64			iSeed;

  1131 private:

  1132 	friend class CThreads;

  1133 	};

  1135 CThreads::CThreads()

  1136 	{

  1137 	iNumCpus = UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0);

  1138 	iNumThreads = iNumCpus;

  1139 	if (iNumThreads<2)

  1140 		iNumThreads=2;

  1141 	TInt khz;

  1142 	TInt r = HAL::Get(HAL::ECPUSpeed, khz);

  1143 	if (r==KErrNone)

  1144 		iTimeslice = Max(10000000/khz, 100);

  1145 	else if (r==KErrNotSupported)

  1146 		iTimeslice = 227;

  1147 	else

  1148 		User::Panic(_L("TIMESLICE"),r);

  1149 	}

  1151 CThreads::~CThreads()

  1152 	{

  1153 	TInt i;

  1154 	for (i=0; i<iNumThreads; ++i)

  1155 		delete iThreads[i];

  1156 	iSem.Close();

  1157 	}

  1159 CThreads* CThreads::New()

  1160 	{

  1161 	CThreads* p = new CThreads;

  1162 	if (p)

  1163 		{

  1164 		TInt r;

  1165 		r = p->iSem.CreateLocal(0);

  1166 		TInt i;

  1167 		for (i=0; i<p->iNumThreads && r==KErrNone; ++i)

  1168 			{

  1169 			p->iThreads[i] = p->NewThread(i);

  1170 			if (!p->iThreads[i])

  1171 				r = KErrNoMemory;

  1172 			}

  1173 		if (r!=KErrNone)

  1174 			{

  1175 			delete p;

  1176 			return 0;

  1177 			}

  1178 		p->iStop = ETrue;

  1179 		for (i=0; i<p->iNumThreads; ++i)

  1180 			p->iThreads[i]->Start();

  1181 		}

  1182 	return p;

  1183 	}

  1185 CThread* CThreads::NewThread(TInt aId)

  1186 	{

  1187 	CThread* t = new CThread;

  1188 	if (t)

  1189 		{

  1190 		t->iId = aId;

  1191 		t->iThreads = this;

  1192 		TInt r = t->Create();

  1193 		if (r!=KErrNone)

  1194 			{

  1195 			delete t;

  1196 			t = 0;

  1197 			}

  1198 		}

  1199 	return t;

  1200 	}

  1202 void CThreads::StartTest(TInt aIndex, TBool aKernel)

  1203 	{

  1204 	iIndex = aIndex;

  1205 	iKernel = aKernel;

  1206 	iReg = 0;

  1207 	iStop = EFalse;

  1208 #ifdef __EPOC32__

  1209 	if (iKernel)

  1210 		DD.Initialise(iReg);

  1211 #endif

  1212 	TInt i;

  1213 	for (i=0; i<iNumThreads; ++i)

  1214 		iThreads[i]->Kick();

  1215 	}

  1217 void CThreads::StopTest()

  1218 	{

  1219 	iStop = ETrue;

  1220 	TInt i;

  1221 	for (i=0; i<iNumThreads; ++i)

  1222 		iSem.Wait();

  1223 #ifdef __EPOC32__

  1224 	if (iKernel)

  1225 		iReg = DD.Retrieve();

  1226 #endif

  1227 	}

  1229 void CThreads::Finish()

  1230 	{

  1231 	iStop = EFalse;

  1232 	iIndex = -1;

  1233 	TInt i;

  1234 	for (i=0; i<iNumThreads; ++i)

  1235 		{

  1236 		iThreads[i]->Kick();

  1237 		iSem.Wait();

  1238 		}

  1239 	test(iFailCount==0);

  1240 	}

  1242 TUint32 CThreads::DoCasTest(TInt aIndex, TBool aKernel, TUint32 aFailLimit)

  1243 	{

  1244 	TInt i;

  1245 	test.Printf(_L("DoCasTest I=%d K=%1d F=%d\n"), aIndex, aKernel, aFailLimit);

  1246 	TUint32 initial = User::FastCounter();

  1247 	StartTest(aIndex, aKernel);

  1248 	FOREVER

  1249 		{

  1250 		User::AfterHighRes(1000000);

  1251 		TUint64 minf = 0;

  1252 		--minf;

  1253 		for (i=0; i<iNumThreads; ++i)

  1254 			{

  1255 			CThread* t = iThreads[i];

  1256 			test.Printf(_L("T%1d: C=%lu R=%lu\n"), i, t->iPerThread.iDiff, t->iPerThread.iFailCount);

  1257 			TUint64 f = t->iPerThread.iFailCount;

  1258 			if (f<minf)

  1259 				minf=f;

  1260 			}

  1261 		if (minf>=TUint64(aFailLimit))

  1262 			break;

  1263 		if (iNumCpus>1)	// 1 second is enough for SMP, except on VMPlayer

  1264 			break;

  1265 		}

  1266 	StopTest();

  1267 	TUint32 final = User::FastCounter();

  1268 	TUint32 time = final - initial;

  1269 	test.Printf(_L("Time %d\n"), time);

  1270 	TUint64 total = 0;

  1271 	TUint64 txor = 0;

  1272 	for (i=0; i<iNumThreads; ++i)

  1273 		{

  1274 		CThread* t = iThreads[i];

  1275 		test.Printf(_L("T%1d: %lu completed %lu retries\n"), i, t->iPerThread.iDiff, t->iPerThread.iFailCount);

  1276 		total += t->iPerThread.iDiff;

  1277 		txor ^= t->iPerThread.iXor;

  1278 		}

  1279 	TUint size = ATTR_TO_SIZE(FuncAttr[aIndex]);

  1280 	TUint64 expected = 0;

  1281 	switch (size)

  1282 		{

  1283 		case 1:	expected = Transform<TUint8>::F_iter(0, total); break;

  1284 		case 2:	expected = Transform<TUint16>::F_iter(0, total); break;

  1285 		case 4:	expected = Transform<TUint32>::F_iter(0, total); break;

  1286 		case 8:	expected = Transform<TUint64>::F_iter(0, total); break;

  1287 		}

  1288 	test.Printf(_L("Total iterations %lu\n"), total);

  1289 	test.Printf(_L("Expected result %08x %08x\n"), I64HIGH(expected), I64LOW(expected));

  1290 	test.Printf(_L("Actual   result %08x %08x\n"), I64HIGH(iReg), I64LOW(iReg));

  1291 	test.Printf(_L("Tot. XOR result %08x %08x\n"), I64HIGH(txor), I64LOW(txor));

  1292 //	test(expected==iReg);

  1293 //	test(expected==txor);

  1294 	if (expected!=iReg || expected!=txor)

  1295 		{

  1296 		test.Printf(_L("***FAIL***\n"));

  1297 		++iFailCount;

  1298 		}

  1299 	return time;

  1300 	}

  1302 void CThreads::DoRmwTest(TInt aIndex, TBool aKernel, TInt aTime)

  1303 	{

  1304 	TInt i;

  1305 	test.Printf(_L("DoRmwTest I=%d K=%1d T=%d\n"), aIndex, aKernel, aTime);

  1306 	StartTest(aIndex, aKernel);

  1307 	User::AfterHighRes(aTime);

  1308 	StopTest();

  1309 	TUint64 total = 0;

  1310 	TUint64 txor = 0;

  1311 	for (i=0; i<iNumThreads; ++i)

  1312 		{

  1313 		CThread* t = iThreads[i];

  1314 		test.Printf(_L("T%1d: C=%10lu D=%lx X=%lx\n"), i, t->iPerThread.iCount, t->iPerThread.iDiff, t->iPerThread.iXor);

  1315 		total += t->iPerThread.iDiff;

  1316 		txor ^= t->iPerThread.iXor;

  1317 		}

  1318 	TUint size = ATTR_TO_SIZE(FuncAttr[aIndex]);

  1319 	switch (size)

  1320 		{

  1321 		case 1:

  1322 			{

  1323 			TUint8 expected = (TUint8)total;

  1324 			TUint8 exor = (TUint8)txor;

  1325 			TUint8 got = (TUint8)iReg;

  1326 			test.Printf(_L("Expected %02x Got %02x XOR %02x\n"), expected, got, exor);

  1327 //			test(expected==got && exor==got);

  1328 			if (expected!=got || exor!=got)

  1329 				{

  1330 				test.Printf(_L("***FAIL***\n"));

  1331 				++iFailCount;

  1332 				}

  1333 			break;

  1334 			}

  1335 		case 2:

  1336 			{

  1337 			TUint16 expected = (TUint16)total;

  1338 			TUint16 exor = (TUint16)txor;

  1339 			TUint16 got = (TUint16)iReg;

  1340 			test.Printf(_L("Expected %04x Got %04x XOR %04x\n"), expected, got, exor);

  1341 //			test(expected==got && exor==got);

  1342 			if (expected!=got || exor!=got)

  1343 				{

  1344 				test.Printf(_L("***FAIL***\n"));

  1345 				++iFailCount;

  1346 				}

  1347 			break;

  1348 			}

  1349 		case 4:

  1350 			{

  1351 			TUint32 expected = (TUint32)total;

  1352 			TUint32 exor = (TUint32)txor;

  1353 			TUint32 got = (TUint32)iReg;

  1354 			test.Printf(_L("Expected %08x Got %08x XOR %08x\n"), expected, got, exor);

  1355 //			test(expected==got && exor==got);

  1356 			if (expected!=got || exor!=got)

  1357 				{

  1358 				test.Printf(_L("***FAIL***\n"));

  1359 				++iFailCount;

  1360 				}

  1361 			break;

  1362 			}

  1363 		case 8:

  1364 			{

  1365 			TUint64 expected = total;

  1366 			test.Printf(_L("Expected result %08x %08x\n"), I64HIGH(expected), I64LOW(expected));

  1367 			test.Printf(_L("Actual   result %08x %08x\n"), I64HIGH(iReg), I64LOW(iReg));

  1368 			test.Printf(_L("Tot. XOR result %08x %08x\n"), I64HIGH(txor), I64LOW(txor));

  1369 //			test(expected==iReg && expected==txor);

  1370 			if (expected!=iReg || expected!=txor)

  1371 				{

  1372 				test.Printf(_L("***FAIL***\n"));

  1373 				++iFailCount;

  1374 				}

  1375 			break;

  1376 			}

  1377 		}

  1378 	}

  1380 CThread::CThread()

  1381 	{

  1382 	}

  1384 CThread::~CThread()

  1385 	{

  1386 	TInt h = iThread.Handle();

  1387 	if (h && h!=KCurrentThreadHandle)

  1388 		{

  1389 		if (!iStarted)

  1390 			iThread.Kill(0);

  1391 		User::WaitForRequest(iStatus);

  1392 		}

  1393 	iThread.Close();

  1394 	}

  1396 TInt CThread::Create()

  1397 	{

  1398 	TInt r = iThread.Create(KNullDesC, &ThreadFunction, 0x2000, 0, this);

  1399 	if (r==KErrNone)

  1400 		{

  1401 		iThread.Logon(iStatus);

  1402 		if (iStatus.Int() != KRequestPending)

  1403 			r = iStatus.Int();

  1404 		}

  1405 	return r;

  1406 	}

  1408 void CThread::Start()

  1409 	{

  1410 	iThread.Resume();

  1411 	iThreads->iSem.Wait();

  1412 	}

  1414 void CThread::Kick()

  1415 	{

  1416 	TRequestStatus s;

  1417 	TRequestStatus* pS = &s;

  1418 	iThread.RequestComplete(pS,0);

  1419 	}

  1421 TInt CThread::ThreadFunction(TAny* aPtr)

  1422 	{

  1423 	return ((CThread*)aPtr)->Run();

  1424 	}

  1426 TInt CThread::Run()

  1427 	{

  1428 #ifdef __EPOC32__

  1429 	DD.SetCurrentThreadTimeslice(iThreads->iTimeslice);

  1430 #endif

  1431 	RThread().SetPriority(EPriorityLess);

  1432 	FOREVER

  1433 		{

  1434 		if (iThreads->iStop)

  1435 			{

  1436 			iThreads->iSem.Signal();

  1437 			if (iThreads->iNumCpus > 1)

  1438 				RThread().SetPriority(EPriorityAbsoluteHigh);	// encourage spreading out of threads between CPUs

  1439 			User::WaitForAnyRequest();

  1440 			if (iThreads->iIndex<0)

  1441 				break;

  1442 			if (iThreads->iNumCpus > 1)

  1443 				{

  1444 				TUint32 tick = User::NTickCount();

  1445 				while(User::NTickCount()-tick < 2) {}	// spin to discourage putting other threads on this CPU

  1446 				RThread().SetPriority(EPriorityLess);

  1447 				}

  1448 			}

  1449 		DoTest();

  1450 		}

  1451 	iThreads->iSem.Signal();

  1452 	return 0;

  1453 	}

  1455 TUint64 CThread::Random()

  1456 	{

  1457 	iSeed = Transform<TUint64>::F(iSeed);

  1458 	return iSeed;

  1459 	}

  1461 void CThread::DoTest()

  1462 	{

  1463 	iPerThread.iDiff = 0;

  1464 	iPerThread.iXor = 0;

  1465 	iPerThread.iFailCount = 0;

  1466 	iPerThread.iCount = 0;

  1467 	TInt index = iThreads->iIndex;

  1468 	TAny* p = (TAny*)&iThreads->iReg;

  1469 #ifdef __EPOC32__

  1470 	TBool kernel = iThreads->iKernel;

  1471 	if (kernel)

  1472 		{

  1473 		DD.SwitchExecTables(iId);

  1474 		RTestAtomic::SetThreadInfo(iPerThread);

  1475 		}

  1476 	TInt iter = 0;

  1477 #endif

  1478 	iSeed = iId;

  1479 	while (!iThreads->iStop)

  1480 		{

  1481 		TAtomicAction action;

  1482 		action.i0 = Random();

  1483 		action.i1 = Random();

  1484 		action.i2 = Random();

  1485 		action.iIndex = index;

  1486 		action.iThread = iId;

  1487 #ifdef __EPOC32__

  1488 		if (kernel)

  1489 			{

  1490 			RTestAtomic::AtomicAction(action);

  1491 			}

  1492 		else

  1493 #endif

  1494 			DoAtomicAction(p, &iPerThread, action);

  1495 #ifdef __EPOC32__

  1496 		if (kernel && ++iter==1024)

  1497 			{

  1498 			iter = 0;

  1499 			RTestAtomic::GetThreadInfo(iPerThread);

  1500 			}

  1501 #endif

  1502 		}

  1503 #ifdef __EPOC32__

  1504 	if (kernel)

  1505 		{

  1506 		RTestAtomic::GetThreadInfo(iPerThread);

  1507 		RTestAtomic::RestoreExecTable();

  1508 		}

  1509 #endif

  1510 	}

  1512 void TestMultipleThreads()

  1513 	{

  1514 	CThreads* p = CThreads::New();

  1515 	test(p!=0);

  1517 	TInt KRequiredRetries = 1000;

  1518 	if (p->NumCpus()==1)

  1519 		KRequiredRetries = 10;

  1521 	TUint32 time;

  1522 	TUint32 total_time = 0;

  1523 	TUint32 total_time_k = 0;

  1524 	TUint32 count = 0;

  1525 	TInt ix;

  1526 	for (ix=0; ix<TOTAL_INDEXES; ++ix)

  1527 		{

  1528 		TUint attr = FuncAttr[ix];

  1529 		TUint func = ATTR_TO_FUNC(attr);

  1530 		TUint type = ATTR_TO_TYPE(attr);

  1531 		if (p->NumCpus()==1)

  1532 			{

  1533 			TUint ord = ATTR_TO_ORD(attr);

  1534 			if (ord != EOrderOrdered)

  1535 				continue;

  1536 			}

  1537 		if (type==EFuncTypeInvalid)

  1538 			continue;

  1539 		if (func!=TUint(EAtomicFuncCAS))

  1540 			continue;

  1541 		time = p->DoCasTest(ix, EFalse, KRequiredRetries);

  1542 		total_time += time;

  1543 		++count;

  1544 		time = p->DoCasTest(ix, ETrue, KRequiredRetries);

  1545 		total_time_k += time;

  1546 		}

  1547 	TUint32 avg_time = total_time / count;

  1548 	TUint32 avg_time_k = total_time_k / count;

  1549 	TUint32 fcf=0;

  1550 	TInt r = HAL::Get(HAL::EFastCounterFrequency, (TInt&)fcf);

  1551 	test_KErrNone(r);

  1552 	test.Printf(_L("FastCounterFrequency = %u\n"), fcf);

  1553 	TUint64 avg_time_us64(avg_time);

  1554 	avg_time_us64*=UI64LIT(1000000);

  1555 	avg_time_us64/=TUint64(fcf);

  1556 	TInt avg_time_us = KMaxTInt;

  1557 	TInt avg_time_k_us = KMaxTInt;

  1558 	if (avg_time_us64<TUint64(KMaxTInt))

  1559 		avg_time_us = (TInt)avg_time_us64;

  1560 	TUint64 avg_time_k_us64(avg_time);

  1561 	avg_time_k_us64*=UI64LIT(1000000);

  1562 	avg_time_k_us64/=TUint64(fcf);

  1563 	if (avg_time_k_us64<TUint64(KMaxTInt))

  1564 		avg_time_k_us = (TInt)avg_time_k_us64;

  1566 	test.Printf(_L("Average time (user) %u (%dus)\n"), avg_time, avg_time_us);

  1567 	test.Printf(_L("Average time (kernel) %u (%dus)\n"), avg_time_k, avg_time_k_us);

  1569 	TInt limit_us = (p->NumCpus()==1) ? 15*1000*1000 : 4*1000*1000;

  1571 	for (ix=0; ix<TOTAL_INDEXES; ++ix)

  1572 		{

  1573 		TUint attr = FuncAttr[ix];

  1574 		TUint func = ATTR_TO_FUNC(attr);

  1575 		TUint type = ATTR_TO_TYPE(attr);

  1576 		if (p->NumCpus()==1)

  1577 			{

  1578 			TUint ord = ATTR_TO_ORD(attr);

  1579 			if (ord != EOrderOrdered)

  1580 				continue;

  1581 			}

  1582 		if (type==EFuncTypeInvalid)

  1583 			continue;

  1584 		if (func<TUint(EAtomicFuncSWP) || func>=TUint(EAtomicFuncCAS))

  1585 			continue;

  1586 		if (func==TUint(EAtomicFuncIOR))	// can only test AND and IOR together

  1587 			continue;

  1588 		p->DoRmwTest(ix, EFalse, Min(avg_time_us,limit_us));

  1589 		p->DoRmwTest(ix, ETrue, Min(avg_time_k_us,limit_us));

  1590 		}

  1592 	p->Finish();

  1593 	delete p;

  1594 	}

  1598 /******************************************************************************

  1599  * Main

  1600  ******************************************************************************/

  1601 TInt E32Main()

  1602 	{

  1603 	test.Title();

  1604 	test.Start(_L("Opening device driver"));

  1605 #ifdef __EPOC32__

  1606 	TInt r;

  1607 	r = User::LoadLogicalDevice(KAtomicTestLddName);

  1608 	test(r==KErrNone||r==KErrAlreadyExists);

  1609 	r = DD.Open();

  1610 	test_KErrNone(r);

  1611 #endif

  1612 	test.Next(_L("Testing atomic operations ..."));

  1613 	test.Next(_L("Single thread, normal operation"));

  1614 	TestSingleThread();

  1615 	test.Next(_L("Single thread, bad addresses"));

  1616 	TestInvalidAddresses();

  1617 	test.Next(_L("Multiple threads"));

  1618 	TestMultipleThreads();

  1619 	test.End();

  1620 	return 0;

  1621 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--