diff -r 000000000000 -r a41df078684a kerneltest/e32test/mmu/t_shbuf_perfclient.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/mmu/t_shbuf_perfclient.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,321 @@ +// Copyright (c) 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/mmu/t_shbuf_perfclient.cpp +// +// + +#include +#include +#include +#include +#include + +#include "t_shbuf_perfserver.h" +#include "t_shbuf_perfclient.h" + + +/** + * @file + * + * Client side APIs for a test server used for Performance Testing of shared buffers. + */ + + +/** + * Test API version. + */ +const TInt KRShBufTestServerMajorVersion = 1; +const TInt KRShBufTestServerMinorVersion = 0; +const TInt KRShBufTestServerBuildVersion = 1; + + +/** + * Start the server process which lives in its own executable and rendezvous with it. + * + * @return KErrNone if successful, or an error code if not. + */ +static TInt StartTestServer() + { +#ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS + // + // Create a new server process. Simultaneous launching of two such + // processes should be detected when the second one attempts to + // create the server object, failing with KErrAlreadyExists. + // + _LIT(KTestServerExeImg, "T_SHBUF_PERFSERVER.EXE"); + RProcess server; + + TInt ret = server.Create(KTestServerExeImg, KNullDesC); + if (ret != KErrNone) + { + return ret; + } +#else + // + // Start a thread with the server in it. + // + RThread server; + + TInt ret = server.Create(_L("RShBufTestServerThread"), RShBufTestServerThread, + KDefaultStackSize, 0x10000, 0x10000, NULL); + if (ret != KErrNone) + { + return ret; + } +#endif + + // + // Rendezvous with the server or abort startup... + // + TRequestStatus status; + + server.Rendezvous(status); + if (status != KRequestPending) + { + server.Kill(0); + } + else + { + server.Resume(); + } + User::WaitForRequest(status); + + // + // We can't use the 'exit reason' if the server panicked as this + // is the panic 'reason' and may be '0' which cannot be distinguished + // from KErrNone. + // + if (server.ExitType() == EExitPanic) + { + ret = KErrGeneral; + } + else if (status.Int() != KErrAlreadyExists) + { + ret = status.Int(); + } + + server.Close(); + + return ret; + } // StartTestServer + + +/** + * Standard constructor. + */ +EXPORT_C RShBufTestServerSession::RShBufTestServerSession() + { + // NOP + } // RShBufTestServerSession::RShBufTestServerSession + + +/** + * Connects the client to the test server. + * + * @return KErrNone if successful, a system-wide error code if not. + * + * @capability None + */ +EXPORT_C TInt RShBufTestServerSession::Connect() + { + // + // Create a session with the server, but if it doesn't exist then start it and + // then create a session. + // + TInt result = CreateSession(KRShBufTestServerName, + TVersion(KRShBufTestServerMajorVersion, + KRShBufTestServerMinorVersion, + KRShBufTestServerBuildVersion)); + if (result == KErrNotFound || result == KErrServerTerminated) + { + result = StartTestServer(); + + if(result == KErrNone) + { + result = CreateSession(KRShBufTestServerName, + TVersion(KRShBufTestServerMajorVersion, + KRShBufTestServerMinorVersion, + KRShBufTestServerBuildVersion)); + } + } + + // + // If the creation of the session fails clean up session data... + // + if (result != KErrNone) + { + Close(); + } + + return result; + } // RShBufTestServerSession::Connect + + +/** + * Closes the client's session with the RShBuf Test Server. + * + * @capability None + */ +EXPORT_C void RShBufTestServerSession::Close() + { + RSessionBase::Close(); + } // RShBufTestServerSession::Close + + +/** + * Returns the current version of the RShBuf Test Server. + * + * @return The version of the RShBuf Test Server. + * + * @capability None + */ +EXPORT_C TVersion RShBufTestServerSession::Version() const + { + return(TVersion(KRShBufTestServerMajorVersion, + KRShBufTestServerMinorVersion, + KRShBufTestServerBuildVersion)); + } // RShBufTestServerSession::Version + + +/** + * Requests the shutdown of the server when the last client disconnects. + * There is no support for immediate shutdown functionality. This API call + * can only be executed if the server is compiled as a debug release. + * + * @return KErrNone if successful, a system-wide error code if not. + */ +EXPORT_C TInt RShBufTestServerSession::ShutdownServer() + { + return SendReceive(EShBufServerShutdownServer, TIpcArgs()); + } // RShBufTestServerSession::ShutdownServer + + +EXPORT_C TInt RShBufTestServerSession::FromTPtr8ProcessAndReturn(TDes8& aBuf, TUint aBufSize) + { + TIpcArgs args(&aBuf, aBufSize); + + return SendReceive(EShBufServerFromTPtr8ProcessAndReturn, args); + } // RShBufTestServerSession::FromTPtr8ProcessAndReturn + + +EXPORT_C TInt RShBufTestServerSession::FromTPtr8ProcessAndRelease(const TDesC8& aBuf) + { + TIpcArgs args(&aBuf); + + return SendReceive(EShBufServerFromTPtr8ProcessAndRelease, args); + } // RShBufTestServerSession::FromTPtr8ProcessAndRelease + + +EXPORT_C TInt RShBufTestServerSession::FromRShBufProcessAndReturn(RShBuf& aShBuf, TUint aBufSize) + { + TInt r; + TInt handle; + TPckg handlePckg(handle); + + TIpcArgs args(&handlePckg, aBufSize); + + r = SendReceive(EShBufServerFromRShBufProcessAndReturn, args); + + if (r == KErrNone) + aShBuf.SetReturnedHandle(handle); + + return r; + } // RShBufTestServerSession::FromRShBufProcessAndReturn + + +EXPORT_C TInt RShBufTestServerSession::OpenRShBufPool(TInt aHandle, const TShPoolInfo& aShPoolInfo) + { + TPckg shPoolInfoPckg(aShPoolInfo); + TIpcArgs args(aHandle, &shPoolInfoPckg); + + return SendReceive(EShBufServerOpenRShBufPool, args); + } // RShBufTestServerSession::OpenRShBufPool + + +EXPORT_C TInt RShBufTestServerSession::CloseRShBufPool(TInt aHandle) + { + TIpcArgs args(aHandle); + + return SendReceive(EShBufServerCloseRShBufPool, args); + } // RShBufTestServerSession::CloseRShBufPool + + +EXPORT_C TInt RShBufTestServerSession::FromRShBufProcessAndRelease(RShBuf& aShBuf) + { + TIpcArgs args(aShBuf.Handle()); + + return SendReceive(EShBufServerFromRShBufProcessAndRelease, args); + } // RShBufTestServerSession::FromRShBufProcessAndRelease + + +/** + * Set a heap mark in the RShBuf Test Server thread. + * + * @capability None + */ +EXPORT_C TInt RShBufTestServerSession::__DbgMarkHeap() + { + TIpcArgs args(TIpcArgs::ENothing); + + return SendReceive(EShBufServerDbgMarkHeap, args); + } // RShBufTestServerSession::__DbgMarkHeap + + +/** + * Performs a heap mark check in the RShBuf Test Server thread. + * + * @param aCount The number of heap cells expected to be allocated at + * the current nest level. + * + * @capability None + */ +EXPORT_C TInt RShBufTestServerSession::__DbgCheckHeap(TInt aCount) + { + TIpcArgs args(aCount); + + return SendReceive(EShBufServerDbgCheckHeap, args); + } // RShBufTestServerSession::__DbgCheckHeap + + +/** + * Perfom a heap mark end check in the RShBuf Test Server thread. + * + * @param aCount The number of heap cells expected to remain allocated + * at the current nest level. + * + * @capability None + */ +EXPORT_C TInt RShBufTestServerSession::__DbgMarkEnd(TInt aCount) + { + TIpcArgs args(aCount); + + return SendReceive(EShBufServerDbgMarkEnd, args); + } // RShBufTestServerSession::__DbgMarkEnd + + +/** + * Set a heap fail next condition in the RShBuf Test Server thread. + * + * @param aCount Determines when the allocation will fail. + * + * @capability None + */ +EXPORT_C TInt RShBufTestServerSession::__DbgFailNext(TInt aCount) + { + TIpcArgs args(aCount); + + return SendReceive(EShBufServerDbgFailNext, args); + } // RShBufTestServerSession::__DbgFailNext + +