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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Contains MBufMgr Test Step 16 - Memory Full

// 

//

// EPOC includes

#include <e32base.h>

#include <ss_std.h>

// Test system includes

//#ifdef SYMBIAN_OLD_EXPORT_LOCATION

//#include "networking/log.h"

//#include "networking/teststep.h"

//#else

//#include <networking/log.h>

//#include <networking/teststep.h>

//#endif

#include "TestStepCTMbufmgr.h"

#include "test16memoryfull.h"

#include <comms-infras/mbufallocator.h>

#include <comms-infras/commsbufpond.h>

// constructor

CTest16MemoryFull::CTest16MemoryFull()

	{

	SetTestStepName( _L("MBufMgrTest16") );	// Store the name of this test case

	}

// destructor

CTest16MemoryFull::~CTest16MemoryFull()

	{

	}

//

void CTest16MemoryFull::FillDes(TDes8 &aBuf, TInt aStartPos, TInt anEndPos, TUint aStartChar, TUint anEndChar)

	{

	StripeDes(aBuf, aStartPos, anEndPos, aStartChar, anEndChar);

	}

RCommsBufPond& CTest16MemoryFull::BufPond()

	{

	return iBufPond;

	}

enum TVerdict CTest16MemoryFull::doTestStepL(void)

	{

	//-------------- substep 1 --------------------

	INFO_PRINTF1(_L("  01 Create CMBufManager and install active scheduler:"));

	CleanupStack::PushL( iActSch = new(ELeave) CActiveScheduler );

	CActiveScheduler::Install(iActSch);

	// Create some initial pools

	// AddL(KMBuf_MBufSize, KMBuf_InitialAllocation, KMBuf_MinGrowth, KMBuf_GrowthThreshold)

	// Background memory allocation (CMBufPoolManager::RunL) is used more frequently if

	// the KMBuf_MinGrowth and the KMBuf_GrowthThreshold are similar in size

	// Synchronous allocation (AllocPool(*poolChain, growth, ETrue)) occurs when the

	// requested size (iChain.CopyIn(size)) is larger than the KMBuf_MinGrowth

	// Multiple threads attempt to grow different poolchains at the same time when there

	// are a greater variety of pool sizes to grow.

	// 16384

	RArray<TCommsBufPoolCreateInfo> createInfoArray;

	TCommsBufPoolCreateInfo createInfo;

	createInfo.iBufSize = 128;

	createInfo.iInitialBufs = 128;

	createInfo.iGrowByBufs = 64;

	createInfo.iMinFreeBufs = 40;

	createInfo.iCeiling = 410; 

	TCommsBufPoolCreateInfo createInfo2;

	createInfo2.iBufSize = 256;

	createInfo2.iInitialBufs = 64;

	createInfo2.iGrowByBufs = 7;

	createInfo2.iMinFreeBufs = 6;

	createInfo2.iCeiling = 204;

	TCommsBufPoolCreateInfo createInfo3;

	createInfo3.iBufSize = 512;

	createInfo3.iInitialBufs = 32;

	createInfo3.iGrowByBufs = 6;

	createInfo3.iMinFreeBufs = 5;

	createInfo3.iCeiling = 125;

	TCommsBufPoolCreateInfo createInfo4;

	createInfo4.iBufSize = 1024;

	createInfo4.iInitialBufs = 16;

	createInfo4.iGrowByBufs = 5;

	createInfo4.iMinFreeBufs = 4;

	createInfo4.iCeiling = 51; 

	TCommsBufPoolCreateInfo createInfo5;

	createInfo5.iBufSize = 2048;

	createInfo5.iInitialBufs = 8;

	createInfo5.iGrowByBufs = 4;

	createInfo5.iMinFreeBufs = 3;

	createInfo5.iCeiling = 15; 

	createInfoArray.Append(createInfo);

	createInfoArray.Append(createInfo2);

	createInfoArray.Append(createInfo3);

	createInfoArray.Append(createInfo4);

	createInfoArray.Append(createInfo5);

	// Create 262144

	CreateInstanceMBufMgrL(createInfoArray);

	CleanupClosePushL(iBufPond);

	createInfoArray.Close ();

	TBuf8<KFactor*KFactor*KFactor*KFactor> *aDes1, *aDes2;

	CleanupStack::PushL( aDes1 = new(ELeave) TBuf8<KFactor*KFactor*KFactor*KFactor> );

	CleanupStack::PushL( aDes2 = new(ELeave) TBuf8<KFactor*KFactor*KFactor*KFactor> );

	//-------------------substep 02-----------------------------

	INFO_PRINTF1(_L("  02 Create and install active object that will do the test:"));

	RMBufAsyncRequest async;

	CMBufAsyncMemFull* memoryfull;

	CleanupStack::PushL(memoryfull = new(ELeave) CMBufAsyncMemFull(this, async, aDes1, aDes2));

	CActiveScheduler::Add(memoryfull);

	//-------------------substep 03-----------------------------

	INFO_PRINTF1(_L("  03 Start the test:"));

	TInt ret = memoryfull->DoStartTest();

	if (ret != KErrNone)

		{

		INFO_PRINTF1(_L("Error: Async Alloc's failing in test run:"));

		User::Leave(EFail);

		}

	// If allocation less than expected then there may be a problem.

	// So get the allocated memory for each pool chain

	RMBufAllocator allocator;

	TInt size = allocator.NextMBufSize(0);

	_LIT(aLogD,"     Info: Available MBufs in %d Pool Chain: %d"); 

	while (size != KErrNotFound)

		{

		INFO_PRINTF3(aLogD, size, allocator.BytesAvailable(size) / size);

		size = allocator.NextMBufSize(size);

		}

//	TInt heapSize = iMBMngr->__DbgGetHeapSize();

	//Clean up stack

	CleanupStack::PopAndDestroy(memoryfull);

	CleanupStack::PopAndDestroy(aDes2);

	CleanupStack::PopAndDestroy(aDes1);

	CleanupStack::PopAndDestroy();

	CActiveScheduler::Install(NULL);

	CleanupStack::PopAndDestroy(iActSch);

	//-------------------substep 04-----------------------------

	_LIT(aLog1,"     Info: Number of main thread checkings: %d with %d fails last failure on %d");

	INFO_PRINTF4(aLog1,iMainThreadTries,iMainThreadFails,iMainThreadLastFailure);

	_LIT(aLog2,"     Info: Number of main thread allocate size failures: %d");

	INFO_PRINTF2(aLog2,iMainThreadSizeFails);

	_LIT(aLog3,"     Info: Number of high priority thread checkings: %d with %d fails");

	INFO_PRINTF3(aLog3,iThread3Tries,iThread3Fails);

	_LIT(aLog4,"     Info: Number of high priority thread allocation failures: %d");

	INFO_PRINTF2(aLog4,iThread3AllocFails);

	_LIT(aLog5,"     Info: Number of memory gobbler allocate tries and failures: %d with %d memory full last memory full on %d");

	INFO_PRINTF4(aLog5,iThread1AllocTries,iThread1MemoryFull,iThread1LastMemoryFull);

	_LIT(aLog6,"     Info: Number of memory gobbler allocate size failures: %d");

	INFO_PRINTF2(aLog6,iThread1SizeFails);

	_LIT(aLog7,"     Info: Number of memory gobbler allocate tries and failures: %d with %d memory full last memory full on %d");

	INFO_PRINTF4(aLog7,iThread2AllocTries,iThread2MemoryFull,iThread2LastMemoryFull);

	_LIT(aLog8,"     Info: Number of memory gobbler allocate size failures: %d");

	INFO_PRINTF2(aLog8,iThread2SizeFails);

	_LIT(aLog9,"     Info: Max chain length for memory gobbler allocation: %d ; %d");

	INFO_PRINTF3(aLog9,iThread1MaxLen,iThread2MaxLen);

//	_LIT(aLogA,"     Info: Max allocated memory: %d"); Log(aLogA,heapSize);

	_LIT(aLogB,"     Info: Basic API (uses TLS) - Average time to allocate mbufs: %d ; Average time to free mbufs %d");

	INFO_PRINTF3(aLogB,iThread1AllocTime/iThread1AllocTries,iThread1FreeTime/(1000 - iThread1AllocTries));

	_LIT(aLogC,"     Info: Higher Speed API (no TLS) - Average time to allocate mbufs: %d ; Average time to free mbufs %d");

	INFO_PRINTF3(aLogC,iThread2AllocTime/iThread2AllocTries,iThread2FreeTime/(1000 - iThread2AllocTries));

	if (iThread3Tries <1000)

		{

		INFO_PRINTF1(_L("   Error: High priority thread ended before 1000 loops are finished"));

		return EFail;

		}

	// test to see if the byte by byte comparisons failed

	if ( iThread3Fails || iMainThreadFails || iThread1SizeFails || iThread2SizeFails)

		{

		INFO_PRINTF1(_L("   Error: MBuf allocation failure"));

        SetTestStepResult(EFail);

		return TestStepResult();

		}

	// Test the maximum allocated memory

	// Some of the possible problems include failing to background allocate new memory

/*	if ( KMBufDefaultHeapSize > (heapSize + KMBufDefaultHeapSize/100) )

		{

		Log(_L("   Error: Background allocation may have failed"));

		return EFail;

		}

*/   async.Close();

    SetTestStepResult(EPass);

	return TestStepResult();

  }

  // Async request

CMBufAsyncMemFull::CMBufAsyncMemFull(CTest16MemoryFull* aTestObject,

		RMBufAsyncRequest& aMBufAsyncReq,

		TDes8 *aDes1,

		TDes8 *aDes2)

		:CActive(EPriorityStandard)

		,iTestObject(aTestObject)

		,iDes1(aDes1)

		,iDes2(aDes2)

		,iMBufAsyncReq(aMBufAsyncReq)

	{

	}

TInt CMBufAsyncMemFull::DoStartTest()

	{

	// Create some random sizes for allocation later

	for (TInt i=1; i<(KFactor+1); i++)

		{

		iRequested_size[i-1] = i * i * i * KFactor;

		}

	// Allocate two 5000-bytes long descriptors (Des1 & Des2):"));

	iDes1->SetLength(iRequested_size[KFactor-1]);

	iDes2->SetLength(iRequested_size[KFactor-1]);

	//Fill in the Des1 with a pattern:"));

	iTestObject->FillDes(*iDes1, 0, iRequested_size[KFactor-1], '@', 'Z');

	//-------------------substep 01-----------------------------

	TInt err=iThread1.Create(_L("testThread1Rec"),

		                       fThread1,

 							   KDefaultStackSize,

							   KDefaultHeapSize,

							   KMaxHeapSize,

							   (TAny*)iTestObject,

							   EOwnerProcess);

	if (err!=KErrNone)

		{

		User::Leave(EFail);

		}

	iThread1.SetPriority(EPriorityAbsoluteHigh);

	iThread1.Resume();

	//-------------------substep 02-----------------------------

	RThread aThread2;

	err=iThread2.Create(_L("testThread2Rec"),

		                       fThread2,

 							   KDefaultStackSize,

							   KDefaultHeapSize,

 							   KMaxHeapSize,

							   (TAny*)iTestObject,

							   EOwnerProcess);

	if (err!=KErrNone)

		{

		User::Leave(EFail);

		}

	iThread2.SetPriority(EPriorityAbsoluteHigh);

	iThread2.Resume();

	//-------------------substep 03-----------------------------

	RThread aThread3;

	err=iThread3.Create(_L("testThread3Rec"),

		                       fThread3,

 							   KDefaultStackSize,

							   KDefaultHeapSize,

							   KMaxHeapSize,

							   (TAny*)iTestObject,

							   EOwnerProcess);

	if (err!=KErrNone)

		{

		User::Leave(EFail);

		}

	iThread3.SetPriority(EPriorityAbsoluteHigh);

	iThread3.Resume();

	//-------------------substep 04-----------------------------

	iMBufAsyncReq.Alloc(iChain, iRequested_size[iRequestloop], iStatus);

	SetActive();

	CActiveScheduler::Start();

	iThread1.Close();

	iThread2.Close();

	iThread3.Close();

	return iStatus.Int();

	}

void CMBufAsyncMemFull::RunL()

	{

	if (iStatus.Int() == KErrNone)

		{

		//Copy in Des1 into Chain

		iChain.CopyIn(iDes1->LeftTPtr(iRequested_size[iRequestloop]));

		//Fill left most part of Des2 with zeros:"));

		iDes2->SetLength(iRequested_size[KFactor-1]);

		iTestObject->FillDes(*iDes2, 0, iRequested_size[iRequestloop], 0, 0);

		//Copy out Chain into Des2:"));

		iChain.CopyOut(*iDes2);

		//Compare the contents of Des1 & Des2:

		if((iDes1->LeftTPtr(iRequested_size[iRequestloop])).

				Compare(iDes2->Left(iRequested_size[iRequestloop])))

			{

			iTestObject->iMainThreadFails++;

			iTestObject->iMainThreadLastFailure = iTestObject->iMainThreadTries;

			if (iChain.Length() != iRequested_size[iRequestloop])

				{

				iTestObject->iMainThreadSizeFails++;

				}

			}

		iTestObject->iMainThreadTries++;

		//Free chain

		iChain.Free();

		//Check whether the other task has finished

		TBool isRunning1 = ETrue;

		TBool isRunning2 = ETrue;

		TBool isRunning3 = ETrue;

		volatile TExitType aExit;

		aExit = iThread1.ExitType();

		if (aExit != EExitPending)

			{

			isRunning1 = EFalse;

			}

		aExit = iThread2.ExitType();

		if (aExit != EExitPending)

			{

			isRunning2 = EFalse;

			}

		aExit = iThread3.ExitType();

		if (aExit != EExitPending)

			{

			isRunning3 = EFalse;

			}

		iRequestloop++;

		if (iRequestloop>9)

			{

			iRequestloop = 0;

			}

		if (isRunning1 || isRunning2 || isRunning3)

			{

			iMBufAsyncReq.Alloc(iChain, iRequested_size[iRequestloop], iStatus);

			SetActive();

			return;

			}

		}

	CActiveScheduler::Stop();

	}

// The memory gobbler thread

TInt CMBufAsyncMemFull::fThread1(TAny* aInput)

	{

	CTest16MemoryFull* pTestObject = (CTest16MemoryFull*)aInput;

	// We need to introduce this new client thread to the MBufMgr

	TCommsBufPondTLSOp tls(pTestObject->BufPond());

	tls.Set();

	CTrapCleanup* aCleanup = CTrapCleanup::New();

	//Install active scheduler

    CActiveScheduler* aActSch = new CActiveScheduler;

	if(aActSch==NULL)

		{

		return KErrNoMemory;

		}

	CActiveScheduler::Install(aActSch);

	RTimer aTimer;

	TRequestStatus aTimerStatus;	// Request status associated with timer

	aTimer.CreateLocal();			// Create timer for this thread

	//-------------- substep 1 --------------------

	// Create some random sizes for allocation later

	TInt requested_size[KFactor1];

	for (TInt i=1; i<(KFactor1+1); i++)

		{

		requested_size[i-1] = i * i * KFactor1;

		}

	// Allocate two 5000-bytes long descriptors (Des1 & Des2):"));

	TBuf8<KFactor1*KFactor1*KFactor1> *aDes1=NULL;

	TRAPD(ret, aDes1 = new(ELeave) TBuf8<KFactor1*KFactor1*KFactor1> );

	if(ret!=KErrNone)

		{

		return ret;

		}

	aDes1->SetLength(requested_size[KFactor1-1]);

	//Fill in the Des1 with a pattern:"));

	pTestObject->FillDes(*aDes1, 0, requested_size[KFactor1-1], 1, 1);

	TUint time;

	RMBufChain aChain;

	RMBufChain bChain;

	TInt requestloop = 0;

	TBool isFillMe = ETrue;

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

		{

		if (isFillMe)

			{

			pTestObject->iThread1AllocTries++;

			//Use up mbuf memory by appending to a chain

			time = User::FastCounter();

			TRAP(ret,aChain.AllocL(requested_size[requestloop]));

			time = User::FastCounter() - time;

			if (ret != KErrNone)

				{

				isFillMe = EFalse;

				pTestObject->iThread1MemoryFull++;

				pTestObject->iThread1LastMemoryFull = pTestObject->iThread1AllocTries - 1;

				}

			else

				{

				pTestObject->iThread1AllocTime += time;

				//Copy in Des1 into Chain

				aChain.CopyIn(aDes1->LeftTPtr(requested_size[requestloop]));

				if (aChain.Length() != requested_size[requestloop])

					{

					pTestObject->iThread1SizeFails++;

					}

				// Now grow the chain

				bChain.Append(aChain);

				}

			}

		else

			{

			//Free some memory

			TInt length = bChain.Length();

			if (length > pTestObject->iThread1MaxLen)

				{

				pTestObject->iThread1MaxLen = length;

				}

			TInt trimOffset = length - requested_size[requestloop];

			if (trimOffset > 0)

				{

				time = User::FastCounter();

				bChain.TrimEnd(trimOffset);

				time = User::FastCounter() - time;

				pTestObject->iThread1FreeTime += time;

				}

			else

				{

				isFillMe = ETrue;

				}

			}

		//Sleep for 5ms

		aTimer.After(aTimerStatus,5000);

		User::WaitForRequest(aTimerStatus);

		requestloop++;

		if (requestloop>(KFactor1-1))

			{

			requestloop = 0;

			}

		}

	// Free the memory

	bChain.Free();

	delete aDes1;

	CActiveScheduler::Install(NULL);

	delete aActSch;

	delete aCleanup;

	return ret;

}

// The memory gobbler thread

TInt CMBufAsyncMemFull::fThread2(TAny* aInput)

	{

	CTest16MemoryFull* pTestObject = (CTest16MemoryFull*)aInput;

	// We need to introduce this new client thread to the MBufMgr

	TCommsBufPondTLSOp tls(pTestObject->BufPond());

	tls.Set();

	CTrapCleanup* aCleanup = CTrapCleanup::New();

	//Install active scheduler

	CActiveScheduler* aActSch = new CActiveScheduler;

	if(aActSch==NULL)

		{

		return KErrNoMemory;

		}

	CActiveScheduler::Install(aActSch);

	RTimer aTimer;

	TRequestStatus aTimerStatus;	// Request status associated with timer

	aTimer.CreateLocal();			// Create timer for this thread

	//-------------- substep 1 --------------------

	// Create some random sizes for allocation later

	TInt requested_size[KFactor2];

	for (TInt i=1; i<(KFactor2+1); i++)

		{

		requested_size[i-1] = i * i * KFactor2;

		}

	// Allocate two 5000-bytes long descriptors (Des1 & Des2):"));