// 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;
	}