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