// Copyright (c) 1998-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\bench\t_ipcbm.cpp

// Overview:

// Test and benchmark the data copy in inter-process communication. 

// API Information:

// RServer2, RSessionBase

// Details:

// - Create a server thread and write data blocks of varying sizes from the 

// server to client, increment a count after each write.

// - Create a client session, connect to server and send data block size 

// to the server.

// - Print the block size, total number of bytes written along with usec 

// per block.

// - Verify that the heap was not corrupted by any of the tests.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32def.h>

#include <e32def_private.h>

LOCAL_D RTest test(_L("T_IPCBM"));

const TInt KBufferSize = 65536;

LOCAL_D TUint32* Src;

LOCAL_D TUint32* Dest;

LOCAL_D TInt Count=0;

LOCAL_D RServer2 Server;

LOCAL_D RSemaphore ServerSem;

class RMySession : public RSessionBase

	{

public:

	TInt Connect(RServer2 aSrv,TRequestStatus& aStat)

		{return CreateSession(aSrv,TVersion(),1,EIpcSession_Unsharable,0,&aStat);}

	void Test(TDes8& aDes)

		{Send(0,TIpcArgs(&aDes));}

	};

LOCAL_C TInt TestThread(TAny* aSize)

	{

	TInt r = Server.CreateGlobal(KNullDesC);

	ServerSem.Signal();

	if (r != KErrNone)

		return r;

	RMessage2 m;

	Server.Receive(m);

	m.Complete(KErrNone);	// connect message

	Server.Receive(m);

	TInt size=(TInt)aSize;

	TPtrC8 src((const TUint8*)Src,size);

	FOREVER

		{

		m.Write(0,src);

		Count++;

		}

	}

const TInt KTestRunSeconds = 10;

LOCAL_C void RunTest(TInt aSize)

	{

	const TInt KTestRunUs = KTestRunSeconds * 1000000;

	RThread t;

	TInt r=t.Create(KNullDesC,TestThread,0x1000,NULL,(TAny*)aSize);

	test(r==KErrNone);

	t.SetPriority(EPriorityLess);

	TRequestStatus s;

	t.Logon(s);

	t.Resume();

	ServerSem.Wait();

	test(Server.Handle() != KNullHandle);

	RMySession sess;

	TRequestStatus stat;

	test(sess.Connect(Server,stat) == KErrNone);

	User::WaitForRequest(stat);	// connected

	Count=0;

	TPtr8 des((TUint8*)Dest, 0, aSize);

	sess.Test(des);

	User::After(KTestRunUs);

	t.Kill(0);

	User::WaitForRequest(s);

	sess.Close();

	Server.Close();

	CLOSE_AND_WAIT(t);

	TInt us=10*KTestRunUs/Count;

	test.Printf(_L("%5d byte writes: %8d/%ds %4d.%01dus\n"),aSize,Count,KTestRunSeconds,us/10,us%10);

	}

GLDEF_C TInt E32Main()

	{

	test.Title();

	test.Start(_L("Benchmark IPC copy"));

	__KHEAP_MARK;

	TAny* buffer = User::Alloc(2 * KBufferSize + 32);

	test(buffer != 0);

	Src = (TUint32*)((((TInt)buffer) & ~0x1f) + 0x20);	

	Dest = (TUint32*)(((TInt)Src) + KBufferSize);

	test(ServerSem.CreateLocal(0) == KErrNone);

	static TInt KMaxCounts[] = { 16, 256, 512, 2048, 2052, 4096, 32768, 65536 };

	for (TUint i=0; i<sizeof KMaxCounts/sizeof KMaxCounts[0]; ++i)

		{

		RunTest(KMaxCounts[i]);

		}

	ServerSem.Close();

	User::Free(buffer);

	__KHEAP_MARKEND;

	test.End();

	return KErrNone;

	}