// 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\demandpaging\t_datapaging.cpp

// Functional tests for data paging.

// 002 Test UserHeap::ChunkHeap data paging attributes

// 003 Test RThread::Create data paging attributes

// 

//

//! @SYMTestCaseID			KBASE-T_DATAPAGING

//! @SYMTestType			UT

//! @SYMPREQ				PREQ1954

//! @SYMTestCaseDesc		Data Paging functional tests.

//! @SYMTestActions			001 Test RChunk data paging attributes

//! @SYMTestExpectedResults All tests should pass.

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <dptest.h>

#include <e32hal.h>

#include <u32exec.h>

#include <e32svr.h>

#include <e32panic.h>

#include "u32std.h"

#include <e32msgqueue.h>

#include <e32atomics.h>

#include <e32math.h>

#include "t_dpcmn.h"

#include "../mmu/mmudetect.h"

#include "../mmu/d_memorytest.h"

#include "../mmu/paging_info.h"

RTest test(_L("T_DATAPAGING"));

_LIT(KChunkName, "t_datapaging chunk");

class TRandom

	{

public:

	TRandom();

	TUint32 Next();

private:

	enum

		{

		KA = 1664525,

		KB = 1013904223

		};

	TUint32 iV;

	};

TRandom::TRandom()

	{

	iV = RThread().Id() + User::NTickCount() + 23;

	}

TUint32 TRandom::Next()

	{

	iV = KA * iV + KB;

	return iV;

	}

void CreatePagedChunk(TInt aSizeInPages, TInt aWipeByte = -1)

	{

	test_Equal(0,gChunk.Handle());

	TChunkCreateInfo createInfo;

	TInt size = aSizeInPages * gPageSize;

	createInfo.SetNormal(size, size);

	createInfo.SetPaging(TChunkCreateInfo::EPaged);

	createInfo.SetOwner(EOwnerProcess);

	createInfo.SetGlobal(KChunkName);

	if (aWipeByte != -1)

		createInfo.SetClearByte(aWipeByte);

	test_KErrNone(gChunk.Create(createInfo));

	test(gChunk.IsPaged()); // this is only ever called if data paging is supported

	}

// The contents of a page is represented as type from enum below ORed with a byte value

enum TPageContent

	{

	ETypeUniform    = 0 << 8,

	ETypeIncreasing = 1 << 8,

	EContentValueMask = 255,

	EContentTypeMask  = 255 << 8

	};

// Write to a page to page it in and verify its previous contents

void WritePage(TInt aIndex, TUint aExpectedContents, TUint aNewContents)

	{

	test.Printf(_L("  %3d Write %x\n"), aIndex, aNewContents);

	TUint oldType = aExpectedContents & EContentTypeMask;

	TUint oldValue = aExpectedContents & EContentValueMask;

	TUint type = aNewContents & EContentTypeMask;

	TUint value = aNewContents & EContentValueMask;

	TUint8* page = gChunk.Base() + (gPageSize * aIndex);

	// write first byte first so page is paged in or rejuvenated with write permissions

	page[0] = 0;

	for (TInt i = 0 ; i < gPageSize ; ++i)

		{

		if (i != 0)

			test_Equal(oldValue, page[i]);

		if (oldType == ETypeIncreasing)

			oldValue = (oldValue + 1) & 255;

		page[i] = value;

		if (type == ETypeIncreasing)

			value = (value + 1) & 255;

		}

	}

// Read a page and verify its contents

void ReadPage(TInt aIndex, TUint aExpectedContents)

	{

	test.Printf(_L("  %3d Read  %x\n"), aIndex, aExpectedContents);

	TUint type = aExpectedContents & EContentTypeMask;

	TUint value = aExpectedContents & EContentValueMask;

	TUint8* page = gChunk.Base() + (gPageSize * aIndex);

	for (TInt i = 0 ; i < gPageSize ; ++i)

		{

		test_Equal(value, page[i]);

		if (type == ETypeIncreasing)

			value = (value + 1) & 255;

		}

	}

void PageOut()

	{

	test.Printf(_L("      PageOut\n"));

	DPTest::FlushCache();

	}

void TestOnePage()

	{

	CreatePagedChunk(1, 0xed);

	// Test initial contents (read)

	ReadPage(0, ETypeUniform | 0xed);

	// Test read initial contents after flush (may or may not actually been paged out)

	PageOut();

	ReadPage(0, ETypeUniform | 0xed);

	// Test page out / page in (read) of dirty contents

	WritePage(0, ETypeUniform | 0xed, ETypeIncreasing | 0x1a);

	PageOut();

	ReadPage(0, ETypeIncreasing | 0x1a);

	// Test page out / page in (read) of clean contents

	PageOut();

	ReadPage(0, ETypeIncreasing | 0x1a);

	// Test page out / page in (write) of dirty contents

	WritePage(0, ETypeIncreasing | 0x1a, ETypeIncreasing | 0x23);

	PageOut();

	WritePage(0, ETypeIncreasing | 0x23, ETypeIncreasing | 0x45);

	CLOSE_AND_WAIT(gChunk);

	CreatePagedChunk(1, 0x0d);

	// Test initial contents (write)

	WritePage(0, ETypeUniform | 0x0d, ETypeIncreasing | 0x1a);

	// Test page out / page in (read) of dirty contents

	PageOut();

	ReadPage(0, ETypeIncreasing | 0x1a);

	CLOSE_AND_WAIT(gChunk);

	}

TInt PageInThreadFunc(TAny* aArg)

	{

	TUint8* page = (TUint8*)aArg;

	for (;;)

		{

		DPTest::FlushCache();

		RDebug::Printf("Start page in...");

		volatile TInt i = page[0];

		(void)i;

		RDebug::Printf("  done.");

		}

	}

TInt PageOutThreadFunc(TAny* aArg)

	{

	TUint8* page = (TUint8*)aArg;

	for (;;)

		{

		page[0] = 1;  // make page dirty

		RDebug::Printf("Start page out...");

		DPTest::FlushCache();

		RDebug::Printf("  done.");

		}

	}

void TestKillThread(TThreadFunction aFunc, TInt aIterations)

	{

	__KHEAP_MARK;

	TRandom random;

	CreatePagedChunk(1);

	TUint8* page = gChunk.Base();

	page[0] = 0;  // make page dirty

	DPTest::FlushCache();

	for (TInt i = 0 ; i < aIterations ; ++i)

		{

		RThread thread;

		test_KErrNone(thread.Create(KNullDesC, aFunc, gPageSize, NULL, page));

		TRequestStatus status;

		thread.Logon(status);

		thread.Resume();

		User::AfterHighRes((random.Next() % 50 + 1) * 1000);

		thread.Kill(123);

		User::WaitForRequest(status);

		test_Equal(123, status.Int());

		CLOSE_AND_WAIT(thread);

		}

	CLOSE_AND_WAIT(gChunk);

	User::After(1000000);

	__KHEAP_MARKEND;

	}

struct SSoakTestArgs

	{

	TInt iThreadIndex;

	TInt iPages;

	};

TUint32* PageBasePtr(TInt aPage)

	{

	return (TUint32*)(gChunk.Base() + (gPageSize * aPage));

	}

TUint32* PageDataPtr(TInt aPage, TInt aThreadIndex)

	{

	return (TUint32*)((TUint8*)PageBasePtr(aPage) + ((aThreadIndex * 2 + 1) * sizeof(TUint32)));

	}

TUint32 PageTag(TInt aPage)

	{

	return 0x80000000 | aPage;

	}	

void StopSoakTest(RMsgQueue<TInt> aMsgQueue)

	{

	while(aMsgQueue.Send(0) != KErrOverflow)

		;

	}

TBool ContinueSoakTest(RMsgQueue<TInt> aMsgQueue)

	{

	TInt msg;

	return aMsgQueue.Receive(msg) == KErrUnderflow;

	}

_LIT(KMsgQueueName, "t_datapaging_queue");

TInt PinPagesFunc(TAny* aArg)

	{

	SSoakTestArgs* args = (SSoakTestArgs*)aArg;

	RMemoryTestLdd ldd;

	TInt r = ldd.Open();

	if (r != KErrNone)

		return r;

	r = ldd.CreateVirtualPinObject();

	if (r != KErrNone)

		return r;

	RMsgQueue<TInt> msgQueue;

	r = msgQueue.OpenGlobal(KMsgQueueName, EOwnerThread);

	if (r != KErrNone)

		return r;

	TInt i = 0;

	TRandom random;

	while (ContinueSoakTest(msgQueue))

		{

		TInt count = 1 + random.Next() % (args->iPages / 4);

		TInt start = random.Next() % (args->iPages - count);

		TInt sleepInMs = 1 + random.Next() % 20;

		TUint32* ptr = PageBasePtr(start);

		r = ldd.PinVirtualMemory((TLinAddr)ptr, count * gPageSize);

		if (r != KErrNone)

			return r;

		User::AfterHighRes(sleepInMs * 1000);

		r = ldd.UnpinVirtualMemory();

		if (r != KErrNone)

			return r;

		++i;

		}

	msgQueue.Close();

	r = ldd.DestroyVirtualPinObject();

	if (r != KErrNone)

		return r;

	ldd.Close();

	RDebug::Printf("  thread %d performed %d iterations (pinning)", args->iThreadIndex, i);

	return KErrNone;

	}

TBool TestReadWord(TUint32* aPtr, TUint32 aExpected, TInt aThread, TInt aPage, TInt aIteration, TInt aLine, RMsgQueue<TInt> aMsgQueue)

	{

	TUint32 aActual = *aPtr;

	if (aActual != aExpected)

		{

		StopSoakTest(aMsgQueue);

		RDebug::Printf("  thread %d failure reading page %d at iteration %d address %08x: expected %08x but got %08x",

					   aThread, aPage, aIteration, aPtr, aExpected, aActual);

		return EFalse;

		}

	return ETrue;

	}

TInt SoakTestFunc(TAny* aArg)

	{

	SSoakTestArgs* args = (SSoakTestArgs*)aArg;

	RMsgQueue<TInt> msgQueue;

	TInt r = msgQueue.OpenGlobal(KMsgQueueName, EOwnerThread);

	if (r != KErrNone)

		return r;

	TUint32* contents = new TUint32[args->iPages];

	if (contents == NULL)

		return KErrNoMemory;

	Mem::Fill(contents, args->iPages * sizeof(TUint32), 0);

	TInt i = 0;

	TRandom random;

	while (ContinueSoakTest(msgQueue))

		{

		TUint32 rand = random.Next();

		TInt page = rand % args->iPages;

		TUint32* ptr = PageDataPtr(page, args->iThreadIndex);

		TInt action = rand >> 31;

		if (action == 0)

			{

			if (!TestReadWord(PageBasePtr(page), PageTag(page), args->iThreadIndex, page, i, __LINE__, msgQueue))

				return KErrGeneral;

			if (!TestReadWord(&ptr[0], contents[page], args->iThreadIndex, page, i, __LINE__, msgQueue))

				return KErrGeneral;

			if (!TestReadWord(&ptr[1], contents[page], args->iThreadIndex, page, i, __LINE__, msgQueue))

				return KErrGeneral;

			}

		else

			{

			TUint newContents = args->iThreadIndex+0x100+(contents[page]&~0xff);

			ptr[0] = newContents;

			if (!TestReadWord(PageBasePtr(page), PageTag(page), args->iThreadIndex, page, i, __LINE__, msgQueue))

				return KErrGeneral;

			if (!TestReadWord(&ptr[1], contents[page], args->iThreadIndex, page, i, __LINE__, msgQueue))

				return KErrGeneral;

			ptr[1] = newContents;

			contents[page] = newContents;

			}

		++i;

		}

	for (TInt j = 0 ; j < args->iPages ; ++j)

		{

		TUint32* ptr = PageDataPtr(j, args->iThreadIndex);

		if (!TestReadWord(PageBasePtr(j), PageTag(j), args->iThreadIndex, j, i, __LINE__, msgQueue))

			return KErrGeneral;

		if (!TestReadWord(&ptr[0], contents[j], args->iThreadIndex, j, i, __LINE__, msgQueue))

			return KErrGeneral;

		if (!TestReadWord(&ptr[1], contents[j], args->iThreadIndex, j, i, __LINE__, msgQueue))

			return KErrGeneral;

		}

	delete [] contents;

	msgQueue.Close();

	RDebug::Printf("  thread %d performed %d iterations", args->iThreadIndex, i);

	return KErrNone;

	}

TInt SoakProcess(TInt aProcessIndex, TInt aThreads, TInt aPages, TBool aPinPages)

	{

	TInt pinThreadIndex = aPinPages ? aThreads++ : -1;

	test_KErrNone(gChunk.OpenGlobal(KChunkName, EFalse));

	SSoakTestArgs* testArgs = new SSoakTestArgs[aThreads];

	test_NotNull(testArgs);

	RThread* threads = new RThread[aThreads];

	test_NotNull(threads);

	TRequestStatus* statuses = new TRequestStatus[aThreads];

	test_NotNull(statuses);

	TInt i;

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

		{

		testArgs[i].iThreadIndex = aProcessIndex * aThreads + i;

		testArgs[i].iPages = aPages;

		TThreadFunction func = i == pinThreadIndex ? PinPagesFunc : SoakTestFunc;

		test_KErrNone(threads[i].Create(KNullDesC, func, gPageSize, NULL, &testArgs[i]));

		threads[i].Logon(statuses[i]);

		}

	// todo: rendezvous here?

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

		threads[i].Resume();

	TBool ok = ETrue;		

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

		{

		User::WaitForRequest(statuses[i]);

		if (threads[i].ExitType() != EExitKill || statuses[i].Int() != KErrNone)

			ok = EFalse;

		threads[i].Close();

		}

	delete [] testArgs;

	delete [] threads;

	delete [] statuses;

	gChunk.Close();

	return ok ? KErrNone : KErrGeneral;

	}

TInt RunSoakProcess()

	{

	TBuf<80> buf;

	if (User::CommandLineLength() > buf.MaxLength())

		return KErrArgument;

	User::CommandLine(buf);

	TLex lex(buf);

	TInt index;

	TInt r = lex.Val(index);

	if (r != KErrNone)

		return r;

	lex.SkipSpace();

	TInt threads;

	r = lex.Val(threads);

	if (r != KErrNone)

		return r;

	lex.SkipSpace();

	TInt pages;

	r = lex.Val(pages);

	if (r != KErrNone)

		return r;

	lex.SkipSpace();

	TBool pinPages;

	r = lex.Val(pinPages);

	if (r != KErrNone)

		return r;

	return SoakProcess(index, threads, pages, pinPages);

	}

void SoakTest(TInt aProcesses, TInt aThreads, TInt aPages, TBool aPinPages, TInt aDurationInSeconds)

	{

	RDebug::Printf("Soak test: %d processes, %d threads, %d pages, %s pinning for %d seconds",

				   aProcesses, aThreads, aPages, (aPinPages ? "with" : "without"), aDurationInSeconds);

	DPTest::FlushCache();

	TInt totalThreads = (aThreads + (aPinPages ? 1 : 0)) * aProcesses;

	test(totalThreads < 512); // each thread uses two words in a page

	TMediaPagingStats dummy=EMediaPagingStatsRomAndCode;

	PagingInfo::ResetBenchmarks(-1, dummy);	// Don't worry about locmedia stats.

	RMsgQueue<TInt> msgQueue;

	test_KErrNone(msgQueue.CreateGlobal(KMsgQueueName, totalThreads, EOwnerThread));

	CreatePagedChunk(aPages, 0);

	TInt i;

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

		*PageBasePtr(i) = PageTag(i);

	RProcess* processes = new RProcess[aProcesses];

	TRequestStatus* statuses = new TRequestStatus[aProcesses];

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

		{

		TBuf<80> args;

		args.AppendFormat(_L("%d %d %d %d"), i, aThreads, aPages, aPinPages);

		test_KErrNone(processes[i].Create(_L("t_datapaging"), args));

		processes[i].Logon(statuses[i]);

		}

	RThread().SetPriority(EPriorityMore); // so we don't get starved of CPU by worker threads

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

		processes[i].Resume();

	User::After(aDurationInSeconds * 1000000);

	StopSoakTest(msgQueue);

	TBool ok = ETrue;		

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

		{

		User::WaitForRequest(statuses[i]);

		if (processes[i].ExitType() != EExitKill || statuses[i].Int() != KErrNone)

			{