// Copyright (c) 1996-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:

 // Very simple test of CPU overhead

 // 

 //

 /**

  @file bf_cpu.cpp

 */

 #include <e32std.h>

 #include <e32std_private.h>

 #include <e32base.h>

 #include <e32base_private.h>

 #include <e32test.h>

 #include <e32svr.h>

 #include "user_config.h"

 #define TEST_WRITE_OVERHEAD

 #define NON_WRITING_LOOPS

 const TInt KAverageOverInSeconds=10;	///< Number of seconds to run tests for

 TInt64 Count;				///< Global variable used to count number of operations completed

 RSemaphore CountSem;		///< control access to Count;

 RTest test(_L("BF_CPU"));

 TBusLocalDrive	drive;

 TLocalDriveCapsV2Buf driveInfo;

 LOCAL_D TBool StopTest;		///< set to ETrue to stop the test

 #ifdef TEST_WRITE_OVERHEAD

 LOCAL_D TBool StopZeroTest;

 LOCAL_C TInt WriteZeroThread(TAny*)

 	/**

 	 * Performs writes of zero length continuously

 	 */

 	{

 #if 0

 	_LIT( KPanicCat, "ZERWRTH" );

 #endif

 	TBuf8<513> buf;

 	buf.SetLength(513);

 	while( !StopZeroTest )

 		{

 		// Return values are bogus when doing overhead testing

 		drive.Write( 513, buf );

 		}

 	return KErrNone;

 	}

 #endif

 LOCAL_C TInt WriteThread(TAny*)

 	/**

 	 * Performs writes continuously

 	 */

 	{

 	_LIT( KPanicCat, "WRTHRD" );

 	TBuf8<512> buf;

 	buf.SetLength(512);

 	buf.Fill(0xFF);		// all 0xFF so we can repeatedly overwrite

 	while( !StopTest )

 		{

 		TInt r = drive.Write( 0, buf );

 		if( KErrNone != r )

 			{

 			User::Panic( KPanicCat, r );

 			}

 		}

 	return KErrNone;

 	}

 LOCAL_C TInt CpuThread(TAny*)

 	/**

 	 * Just increments the counter

 	 */

 	{

 	while( !StopTest )

 		{

 		CountSem.Wait();

 #ifdef NON_WRITING_LOOPS

 		for( volatile TInt i = 5000; i > 0; i-- );

 #endif

 		++Count;

 		CountSem.Signal();

 		}

 	return KErrNone;

 	}

 void runTest()

 	{

     RThread writeThread;

 	TInt r=writeThread.Create(_L("WRITER"),WriteThread,KDefaultStackSize,&User::Heap(),NULL);

 	test(r==KErrNone);

 	RThread cpuThread;

 	r=cpuThread.Create(_L("CPU-ER"),CpuThread,KDefaultStackSize,&User::Heap(),NULL);

 	test(r==KErrNone);

 #ifdef TEST_WRITE_OVERHEAD

     RThread writeZeroThread;

 	r=writeZeroThread.Create(_L("WRITERZERO"),WriteZeroThread,KDefaultStackSize,&User::Heap(),NULL);

 	test(r==KErrNone);

 #endif

 	r = CountSem.CreateLocal(1);

 	test(r==KErrNone);

 	StopTest = EFalse;	// allow the test to run

     TRequestStatus deadStatWrite;

     TRequestStatus deadStatCpu;

 	writeThread.Logon( deadStatWrite );

 	cpuThread.Logon( deadStatCpu );

 	// make writer thread have priority over CPU usage thread

 	writeThread.SetPriority( EPriorityMore );

 	// make this thread highest priority

 	RThread().SetPriority( EPriorityMuchMore );

     cpuThread.Resume();

 #ifdef TEST_WRITE_OVERHEAD

     TRequestStatus deadStatWriteZero;

 	writeZeroThread.Logon( deadStatWriteZero );

 	// make writer thread have priority over CPU usage thread

 	writeZeroThread.SetPriority( EPriorityMore );

 	StopZeroTest = EFalse;

 	writeZeroThread.Resume();

 #endif

 	// wait for thread to initialise

 	User::After(1000000);

 	CountSem.Wait();

 	Count=0;

 	CountSem.Signal();

     User::After(KAverageOverInSeconds*1000000);

 	CountSem.Wait();

 	TInt64 noWriteCount( Count );	// number of counts when not writing

 	CountSem.Signal();

 #ifdef TEST_WRITE_OVERHEAD

 	// kill the zero writer

 	StopZeroTest = ETrue;

 	User::WaitForRequest( deadStatWriteZero );

 	CLOSE_AND_WAIT(writeZeroThread);

 #endif

 	test.Printf( _L("Loops without writing = %ld"), noWriteCount );

 	// start write thread

 	writeThread.Resume();

 	User::After(1000000);

 	CountSem.Wait();

 	Count=0;

 	CountSem.Signal();

     User::After(KAverageOverInSeconds*1000000);

 	CountSem.Wait();

 	TInt64 withWriteCount( Count );	// number of counts when writing

 	CountSem.Signal();

 	test.Printf( _L("Loops while writing = %ld"), withWriteCount );

 	// tell test to stop and wait for thread to exit.

 	cpuThread.Kill(KErrNone);

 	StopTest = ETrue;

 	User::WaitForRequest( deadStatWrite );

 	CLOSE_AND_WAIT(writeThread);

 	CLOSE_AND_WAIT(cpuThread);

 	TInt64 calc( withWriteCount );

 	calc = calc * 100;

 	calc = calc / noWriteCount;

 	test.Printf( _L("%% CPU used = %d"), 100 - I64LOW(calc) );

     }

 LOCAL_C TInt EraseSegment( TInt aSegmentNumber )

 	/**

 	 * Erases a segment on Flash

 	 *

 	 * @param aSegmentNumber index of segment to erase

 	 * @return KErrNone or error code

 	 */

 	{

 	TInt offset = aSegmentNumber * driveInfo().iEraseBlockSize;

 	TInt r = drive.Format( offset, driveInfo().iEraseBlockSize );

 	test.Printf( _L("erase returns %d"), r );

 	return  r;

 	}

 void Initialize()

 	/**

 	 * Open channel to media driver

 	 */

 	{

 	//

 	// Load the media driver

 	//

 #ifndef SKIP_PDD_LOAD

 	test.Printf( _L("Loading %S\n"), &KLfsDriverName );

 	TInt r = User::LoadPhysicalDevice( KLfsDriverName );

 	test( KErrNone == r || KErrAlreadyExists == r );

 #endif

 #ifdef UNMOUNT_DRIVE

 	RFs fs;

 	test( KErrNone == fs.Connect() );

 #if 0

 	// XXX not EKA2

 	test( KErrNone == fs.SetDefaultPath( _L("Z:\\") ) );

 #endif

 	TFullName name;

 	fs.FileSystemName( name, KLffsLogicalDriveNumber );

 	if( name.Length() > 0 )

 		{

 		test.Printf( _L("Unmounting drive") );

 		test( KErrNone == fs.DismountFileSystem( _L("Lffs"), KLffsLogicalDriveNumber) );

 		User::After( 2000000 );

 		test.Printf( _L("Drive unmounted") );

 		}

 	fs.Close();

 #endif

 	//

 	// Open a TBusLogicalDevice to it

 	//

 	test.Printf( _L("Opening media channel\n") );

 	TBool changedFlag = EFalse;

 	test( KErrNone == drive.Connect( KDriveNumber, changedFlag ) );

 	//

 	// Get size of Flash drive, block size, block count

 	//

     drive.Caps(driveInfo);

 	}

 TInt E32Main()

     {

     test.Title();

     test.Start(_L("Testing CPU overhead"));

 	Initialize();

 	test.Printf( _L("Erasing first segment") );

 	TInt r = EraseSegment( 0 );

 	test( KErrNone == r );

 	test.Printf( _L("Segment erased") );

 	runTest();

 	drive.Disconnect();

     test.End();

 	return(KErrNone);

     }