// 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 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\smpsoak\t_smpsoakprocess.cpp

//  User Includes

#include "t_smpsoak.h"

#define PRINT(args)\

    if (!TestSilent)\

        test.Printf args

void ParseCmdLine();

//class for soak process and same executable(t_smpsoakprocess.exe) will be lauched with different process operation

//Example: IPC Read, IPC Write, File Process, Timer Process

class CSMPSoakProcess

    {

public:

	CSMPSoakProcess();

	~CSMPSoakProcess();

	void CreateThread(TPtrC aThreadType);

private:

    //Thread Functions

 	static TInt FileThread(TAny*);

	static TInt TimerThread(TAny*);

	static TInt MemoryThread(TAny*);

private:

   // Thread member functions

    TInt DoFileThread();

    TInt DoTimerThread();

    TInt DoMemoryThread();

    void DoCreateThread(TAny*);

    void ResumeThread();

    //IPC's

    void WriteProcess();

    void ReadProcess();

    //Thread Priority

    void SetThreadPriority();

    //Utils for soak process

	void SetSoakProcessPriority();

	void CommitChunk(RChunk& aChunk, TInt aSize);

	void ReadChunk(RChunk& aChunk, TInt aSize);

	void WriteToChunk(RChunk& aChunk, TInt aSize);

	void DeleteChunk(RChunk& aChunk);

private:

    //Thread tables

    static TThread KOOMemoryTable[];

    static TThread KFileTable[];

    static TThread KTimerTable[];

private:

    TThreadData iThreadData;

    RThread     iThread;

    TInt        iPriority;

    };

//Memory thread data

TThread CSMPSoakProcess::KOOMemoryTable[] =

    {   

         { _L("SMPOOMemoryThread1"), CSMPSoakProcess::MemoryThread, {{EPriorityAbsoluteLowNormal, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, NULL,NULL}},

         { _L("SMPOOMemoryThread2"), CSMPSoakProcess::MemoryThread, {{EPriorityAbsoluteLow, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, NULL,NULL}},

         { _L("SMPOOMemoryThread3"), CSMPSoakProcess::MemoryThread, {{EPriorityMore, EPriorityAbsoluteVeryLow, EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, NULL,NULL}},

         { _L("SMPOOMemoryThread4"), CSMPSoakProcess::MemoryThread, {{EPriorityAbsoluteLow, EPriorityAbsoluteVeryLow, EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, NULL,NULL}},

    };

//File thread data

TThread CSMPSoakProcess::KFileTable[] =

    {   

        { _L("SMPFileThread1"), CSMPSoakProcess::FileThread, {{EPriorityAbsoluteLow, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, 11, 5}},

        { _L("SMPFileThread2"), CSMPSoakProcess::FileThread, {{EPriorityNormal, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, 22, 10}},

        { _L("SMPFileThread3"), CSMPSoakProcess::FileThread, {{EPriorityMore, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, 33, 15}},

        { _L("SMPFileThread4"), CSMPSoakProcess::FileThread, {{EPriorityAbsoluteVeryLow, EPriorityMore,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 0, 4, NULL, 44, 20}},

    };

//Timer thread data

TThread CSMPSoakProcess::KTimerTable[] =

    {   

        { _L("SMPTimerThread1"), CSMPSoakProcess::TimerThread, {{EPriorityAbsoluteLowNormal, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 1000, 2, NULL, NULL,NULL}},

        { _L("SMPTimerThread2"), CSMPSoakProcess::TimerThread, {{EPriorityAbsoluteLow, EPriorityAbsoluteVeryLow,   EPriorityNormal, 0}, EPriorityList, KCpuAffinityAny, 1500, 2, NULL, NULL,NULL}},

    };

//Constructor

CSMPSoakProcess::CSMPSoakProcess()

    { 

    }

//Destructor

CSMPSoakProcess::~CSMPSoakProcess()

    {    

    }

//Set the process priority each time for each process

void CSMPSoakProcess::SetSoakProcessPriority()

	{

	RProcess proc;

	TInt priority;

	static TInt priorityindex = 0;

	static const TProcessPriority priorityTable[]=

		{

		EPriorityLow,

		EPriorityBackground,

		EPriorityForeground,

		EPriorityHigh

		};

	if(++priorityindex >= 4)

		priorityindex=0;

	priority = priorityTable[priorityindex];

	proc.SetPriority((TProcessPriority)priority);

	PRINT((_L("Process Priority:%d \n"),proc.Priority()));

	}

//Changes the thread priority each time time, for each thread by Random, Increment, from List, Fixed.

//pick up the priority option from thread table

void CSMPSoakProcess::SetThreadPriority()

    {

    static TInt64 randSeed = KRandSeed;

    static const TThreadPriority priorityTable[]=

        {

        EPriorityMuchLess, EPriorityLess, EPriorityNormal, EPriorityMore, EPriorityMuchMore,

        EPriorityRealTime, EPriorityRealTime, EPriorityAbsoluteVeryLow, EPriorityAbsoluteLowNormal,

        EPriorityAbsoluteLow, EPriorityAbsoluteBackgroundNormal, EPriorityAbsoluteBackground,

        EPriorityAbsoluteForegroundNormal, EPriorityAbsoluteForeground, EPriorityAbsoluteHighNormal, EPriorityAbsoluteHigh

        };

    TInt priorityIndex = 0;

    switch (iThreadData.threadPriorityChange)

        {

        case EpriorityFixed:

            break;

        case EPriorityList:

            if (++iPriority >= KPriorityOrder)

                iPriority = 0;

            if (iThreadData.threadPriorities[iPriority] == 0)

                iPriority = 0;

         //   PRINT(_L("SetPriority List CPU %d index %d priority %d\n"),gSMPStressDrv.GetThreadCPU(&iThread),iPriority, iThreadData.threadPriorities[iPriority]);

            iThread.SetPriority((TThreadPriority)iThreadData.threadPriorities[iPriority]);

            break;

        case EPriorityIncrement:

            while (priorityTable[priorityIndex] <= iPriority)

                {

                priorityIndex++;

                }

            iPriority = priorityTable[priorityIndex];

            if (iPriority > iThreadData.threadPriorities[2])

                iPriority = iThreadData.threadPriorities[1];

          //  PRINT(_L("SetPriority Increment CPU %d priority %d\n"),gSMPStressDrv.GetThreadCPU(&iThread), iPriority);

            iThread.SetPriority((TThreadPriority)iPriority);

            break;

        case EPriorityRandom:

            iPriority = Math::Rand(randSeed) % (iThreadData.threadPriorities[2] - iThreadData.threadPriorities[1] + 1);

            iPriority += iThreadData.threadPriorities[1];

            while (priorityTable[priorityIndex] < iPriority)

                {

                priorityIndex++;

                }

            iPriority = priorityTable[priorityIndex];

           // PRINT(_L("SetPriority Random CPU %d iPriority %d\n"),gSMPStressDrv.GetThreadCPU(&iThread), iPriority);

            iThread.SetPriority((TThreadPriority)iPriority);

            break;

        }

    }

//Resume each thread

void CSMPSoakProcess::ResumeThread()

    {

    iThread.Resume();

    }

// CSMPSoakProcess Thread Creation.

// @param aThread thread table data          

void CSMPSoakProcess::DoCreateThread(TAny* aThread)

    {

    //Initialize each thread data

    iThreadData = ((TThread*)aThread)->threadData;

    test.Next(_L("Create Thread"));

    PRINT ((_L("%s   CPU affinity %d  Priority %d\n"),((TThread*)aThread)->threadName.Ptr(),iThreadData.cpuAffinity,iThreadData.threadPriorities[0]));

    TInt r = iThread.Create(((TThread*)aThread)->threadName, ((TThread*)aThread)->threadFunction, KDefaultStackSize, KHeapMinSize, KHeapMaxSize,(TAny*)this);

    test_KErrNone(r);

    if (iThreadData.threadPriorityChange == EPriorityList)

        {

        iPriority = 0;

        }

    else

        {

        iPriority = iThreadData.threadPriorities[0];

        }

    iThread.SetPriority((TThreadPriority)iThreadData.threadPriorities[0]);

    //Set the thread CPU Affinity

    gSMPStressDrv.ChangeThreadAffinity(&iThread, iThreadData.cpuAffinity);

    }

//Commit the chunk with aSize

void CSMPSoakProcess::CommitChunk(RChunk& aChunk, TInt aSize)

	{

	//PRINT ((_L("Commit Chunk \n")));

	test_KErrNone(aChunk.Adjust(aSize));

	}

//Write some data into the chunk 

void CSMPSoakProcess::WriteToChunk(RChunk& aChunk, TInt aSize)

	{

	TUint8 *writeaddr = aChunk.Base();

	TPtr8 write(writeaddr,aSize);

	write.Fill('S',aSize);

	write.Copy(memData);

	}

//Read the data from chunk and verify

void CSMPSoakProcess::ReadChunk(RChunk& aChunk, TInt aSize)

	{

	TUint8 *readaddr = aChunk.Base();

	TPtr8 read(readaddr,aSize);

	test_KErrNone(read.Compare(memData));

	}

//Cleaunup chunk

void CSMPSoakProcess::DeleteChunk(RChunk& aChunk)

	{

	test_KErrNone(aChunk.Adjust(0));

	}

//IPC Read operation

void CSMPSoakProcess::ReadProcess()

    {

	RTest test(_L("SMPSoakReadProcess"));

	FOREVER

		{

		// SetSoakProcessPriority();

		 gWriteSem.Wait(); //Wait for write completion

		 PRINT((_L("Read Chunk\n")));

		 ReadChunk( gChunk,KChunkSize);

		 PRINT((_L("Delete Chunk\n")));

		 DeleteChunk(gChunk);

		 gReadSem.Signal(); //Read completion

		}

    }

//IPC Write operation

void CSMPSoakProcess::WriteProcess()

	{

	RTest test(_L("SMPSoakWriteProcess"));

	FOREVER

		{

		// SetSoakProcessPriority();

		 CommitChunk( gChunk, KChunkSize);

		 PRINT((_L("Write To Chunk\n")));

		 WriteToChunk( gChunk,KChunkSize);

		 gWriteSem.Signal(); //Write completion

		 gReadSem.Wait(); //Wait for read completion

		}

	}

//File Thread - creates Dir's, Files, Fileread, Filewrite and verify

//param aSoakThread - CSMPSoakUtil pointer

TInt CSMPSoakProcess::FileThread(TAny* aSoakThread)

     {

    CSMPSoakProcess* self = (CSMPSoakProcess*)aSoakThread;

    __ASSERT_ALWAYS(self !=NULL, User::Panic(_L("CSMPSoakProcess::TimerThread Panic"),0));

    return self->DoFileThread();

     }

//Member Filethread

 TInt CSMPSoakProcess::DoFileThread()

	 {

 	 RTest test(_L("SMPFileThread"));

 	 TInt r = KErrNone;

 	 TFileName sessionPath;

 	 TBuf8<KFileNameLength> fileData;

 	 fileData.Copy(KFileData);

 	 RFs fs;

 	 RFile file;

 	 TBuf<KFileNameLength> filename;

 	 TBuf<KFileNameLength> directory;

 	 TBuf<KFileNameLength> tempdir;

 	//Setup Dir structure

 	 tempdir.Format(KDir,iThreadData.dirID);

  	 test_KErrNone(fs.Connect());

  	 sessionPath=KSessionPath;

 	 TChar driveLetter;

 	 //Setup Drive and Session

 	 test_KErrNone(fs.DriveToChar(EDriveD,driveLetter));

 	 sessionPath[0]=(TText)driveLetter;

 	 test_KErrNone(fs.SetSessionPath(sessionPath));

 	 test.Printf(_L("SessionPath=%S\n"),&sessionPath);

 	 directory=sessionPath;

 	 directory.Append(tempdir);

 	PRINT((_L("Dir Level =%S Creation\n"),&directory));

 	 FOREVER

 			{

 			r= fs.MkDirAll(directory);

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

                //Create Number of files then write data into it.

                for (TInt i = 0; i < iThreadData.numFile; i++)

                    {	

                    filename.Format(KFile,iThreadData.dirID,i);

                    PRINT((_L("File = %S Write\n"),&filename));

                    test_KErrNone(file.Create(fs,filename,EFileWrite));

                    test_KErrNone(file.Write(fileData));

                    file.Close();

                    }

                //Read those files and verify it

                for (TInt i = 0; i < iThreadData.numFile; i++)

                    {	

                    TBuf8<KFileNameLength> readData;

                    filename.Format(KFile,iThreadData.dirID,i);

                    PRINT((_L("File = %S Read/Verify\n"),&filename));

                    test_KErrNone(file.Open(fs,filename,EFileRead));

                    test_KErrNone(file.Read(readData));

                    test_KErrNone(readData.Compare(fileData));

                    file.Close();

                    }

                //Delete files

                for (TInt i = 0; i < iThreadData.numFile; i++)

                    {	

                    filename.Format(KFile,iThreadData.dirID,i);

                    PRINT((_L("File = %S Delete\n"),&filename));

                    test_KErrNone(fs.Delete(filename));

                    }

                //Remove Dir's

                PRINT((_L("Dir Level =%S Removed\n"),&directory));

 				test_KErrNone(fs.RmDir(directory));

 				SetThreadPriority();

 				if (gAbort)

 				    break;

 				User::After(gPeriod);

 			}

 	 fs.Close();

 	 return 0x00;

 	 }

//Timer Thread - produces DFC's in the kernel side

//param aSoakThread - CSMPSoakUtil pointer

 TInt CSMPSoakProcess::TimerThread(TAny* aSoakThread)

     {

     CSMPSoakProcess* self = (CSMPSoakProcess*)aSoakThread;

     __ASSERT_ALWAYS(self !=NULL, User::Panic(_L("CSMPSoakProcess::TimerThread Panic"),0));

     return self->DoTimerThread();

     }

//Member TimerThread

TInt CSMPSoakProcess::DoTimerThread()

	 {

 	 RTest test(_L("SMPSoakTimerThread"));

 	 RTimer timer;

 	 test_KErrNone(timer.CreateLocal());

 	 TRequestStatus status;

 	 FOREVER

 		{

 		timer.After(status, iThreadData.delayTime*1000);

 		User::WaitForRequest(status);

 		test(status == KErrNone);

 		PRINT((_L("$")));

 		SetThreadPriority();

 		if (gAbort)

 		    break;

 		User::After(gPeriod);

 		}

 	 timer.Close();

 	 return 0x00;

	 }

 //OOM Thread - produces out of memory condition on SMP threads run on different cpu cores

 //param aSoakThread - this pointer

 TInt CSMPSoakProcess::MemoryThread(TAny* aSoakThread)

     {

     CSMPSoakProcess* self = (CSMPSoakProcess*)aSoakThread;

     __ASSERT_ALWAYS(self !=NULL, User::Panic(_L("CSMPSoakProcess::MemoryThread Panic"),0));

     return self->DoMemoryThread();

     }

//Memory thread member

 TInt CSMPSoakProcess::DoMemoryThread()

     {

     RTest test(_L("SMPOOMemoryThread"));

     static TInt memOKCount =0;

     TAny* oomheap = NULL;

     TAny* prev = NULL;

     //Reserve the memory in heap

     RHeap* heap;

     heap = UserHeap::ChunkHeap(NULL, KHeapMinSize, KHeapMaxiSize);

     //Keep produce OOM condition and inform to other threads (run on different CPU cores)

     FOREVER

         {

          TInt allocsize = KHeapMaxiSize - KHeapReserveSize;

          if(memOKCount == iThreadData.numThreads-1)

              allocsize = KHeapMaxiSize;

          prev = oomheap;

          oomheap = heap->Alloc(allocsize);

          if(oomheap == NULL)

              {

              PRINT(_L("Out Of Memory\n"));

              heap->Free(prev);

              PRINT(_L("Recover Back Memory\n")); 

              memOKCount = 0;

              ooMemSem.Signal(iThreadData.numThreads - 1);

              }

          else

             {

             ++memOKCount;

             PRINT((_L("%d:Here MemOK\n"),memOKCount));

             ooMemSem.Wait();

             }

          //Change Thread Priority

          SetThreadPriority();

          if (gAbort)

             break;

          User::After(gPeriod);

         }

     if(heap != NULL)

     heap->Close();

     return 0x00;

     }

//Create thread

 void CSMPSoakProcess::CreateThread(TPtrC aThreadType)

     {

     if (aThreadType == _L("-W"))

         {

         CSMPSoakProcess smpipcwrite;

         smpipcwrite.WriteProcess();

         }

     else if (aThreadType == _L("-R"))

         {

         CSMPSoakProcess smpipcread;

         smpipcread.ReadProcess();

         }

     else if (aThreadType == _L("-F"))

         {

         CSMPSoakProcess smpfilethread[KNumFileThreads];

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

             smpfilethread[i].DoCreateThread(&KFileTable[i]);

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

             smpfilethread[i].ResumeThread();

         }

     else if (aThreadType == _L("-T"))

         {

         CSMPSoakProcess smptimerthread[KNumTimerThreads];

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

             smptimerthread[i].DoCreateThread(&KTimerTable[i]);

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

             smptimerthread[i].ResumeThread();

         }

     else if (aThreadType == _L("-O"))

         {

         CSMPSoakProcess smpoomthread[KNumOOMThreads];

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

             smpoomthread[i].DoCreateThread(&KOOMemoryTable[i]);

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

             smpoomthread[i].ResumeThread();

         }               

     /* else

          {

          test.Printf(_L("Invalid Argument for Soak Process \n"));

          test(EFalse);

          }*/

     }

//Command line arg to launch operation specific process

void ParseCmdLine()

	{

 	TBuf<256> cmd;

 	User::CommandLine(cmd);

 	TLex	lex(cmd);

 	PRINT ((_L("Command for Process = %s\n"), cmd.PtrZ()));

 	CSMPSoakProcess smpp;

 	FOREVER

 		{

 		TPtrC  token=lex.NextToken();

 		if(token.Length()!=0)

 			{   

               if (token.Length()==0)

 		            break;  // ignore trailing whitespace

 			   else if (token.Mid(0) == _L("-b"))

 			                {

 			                test.Printf(_L("SMPSOAKPROCESS: Silent Mode\n")); 

 			                TestSilent = ETrue;

 			                lex.SkipSpaceAndMark();

 			                token.Set(lex.NextToken());

 			                test.Printf(_L("-b Thread Type = %s\n"), token.Ptr());

 			                smpp.CreateThread(token);

 			                break;

 			                }

                else if (token.Left(2) == _L("-p"))

                            {

                            test.Printf(_L("SMPSOAKPROCESS: period\n"));

                            lex.SkipSpaceAndMark();

                            token.Set(lex.NextToken());

                            TLex lexNum(token);

                            lexNum.Val(gPeriod,EDecimal);    

                            test.Printf(_L("SMPSOAKPROCESS:period in mSeconds=%d \n"),gPeriod);  

                            token.Set(lex.NextToken());

                            test.Printf(_L("-p Thread Type = %s\n"), token.Ptr());

                            smpp.CreateThread(token);

                            break;

                            }

                else

                            {

                            test.Printf(_L("-d Thread Type = %s\n"), token.Ptr());

                            smpp.CreateThread(token);

                            break;

                            }

            }

 		 break;

 		}

	}

// Child process called by (T_SMPSOAK) Main Process

TInt E32Main() 

	{

    test.Title();

    __UHEAP_MARK;

    test.Start(_L("t_SMPSoakProcess.exe"));

    test.Next(_L("Load device driver"));

    TInt r = User::LoadLogicalDevice(_L("d_smpsoak.ldd"));

    if (r == KErrNotFound)

  		{

  		PRINT (_L("Test not supported on this platform because the D_SMPSOAK.LDD Driver is Not Present\n"));

   		test(EFalse);

   		}

    PRINT (_L("Calling SMPStressDrv.Open\n"));

  	r = gSMPStressDrv.Open();

  	test_KErrNone(r);

  	PRINT (_L("Create/Open Global Write Semaphores\n"));

    r = gWriteSem.CreateGlobal(KGlobalWriteSem,0);

   	if (r==KErrAlreadyExists)

   		{

   		r = gWriteSem.OpenGlobal(KGlobalWriteSem);

   		}

   	if (r!=KErrNone)

   		{

   		PRINT ((_L("Error- OpenGlobal Write Semaphore:%d\n"),r));

   		test(EFalse);

   		}

   PRINT (_L("Create/Open Global Read Semaphores\n"));

   r = gReadSem.CreateGlobal(KGlobalReadSem,0);

   if (r==KErrAlreadyExists)

	   {

   	   r = gReadSem.OpenGlobal(KGlobalReadSem);

	   }

   if (r!=KErrNone)

	   {

	   PRINT( (_L("Error- OpenGlobal Read Semaphore:%d\n"),r));

	   test(EFalse);

	   }

   PRINT (_L("Creating Global Chunk\n"));

   r = gChunk.CreateGlobal(KGlobalWRChunk,KChunkSize,KChunkMaxSize);

   if(r==KErrAlreadyExists)

       {

       test_KErrNone( gChunk.OpenGlobal(KGlobalWRChunk,EFalse));

       }

   PRINT (_L("Creating local OOM Memory semaphore\n"));

   r=ooMemSem.CreateLocal(0);

   if (r!=KErrNone)

       {

       PRINT ((_L("Error- Creating local OOM Memory semaphore:%d\n"),r));

       test(EFalse);

       }

   ParseCmdLine();

   CActiveScheduler* myScheduler = new (ELeave) CActiveScheduler();

   test(myScheduler != NULL);

   CActiveScheduler::Install(myScheduler);

   CActiveScheduler::Start();

   ooMemSem.Close();

   gWriteSem.Close();

   gReadSem.Close();

   gChunk.Close();

   gSMPStressDrv.Close();

   CActiveScheduler::Stop();

   __UHEAP_MARKEND;

   test.End();

   return 0x00; 

	}