Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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:
// File Name: f32test/bench/t_fat_perf.cpp
// This file contains implementation for the functions called
// by test cases from the command line to test FAT Performance on
// large number of files (PREQ 1885).
//
//
//Include files
#include <e32test.h>
#include <f32file.h>
#include <f32dbg.h>
#include "t_server.h"
#include "t_fat_perf.h"
LOCAL_C void ClearCache(TInt);
RTest test(_L("T_FAT_PERF"));
TFileName gPath;
TFileName gFileNameBase;
TInt gFileNo = 0;
TInt gTestCase = -1;
TInt gCacheClear = 0;
TInt gZeroPadFileNumberForFixedLengthFileNames = 0;
//-----------------------------------------------------------------------------
TNamingSchemeParam::TNamingSchemeParam()
: iConOrRan(EConsecutive), iUniOrAsc(EAscii), iZeroPadFileNumber(EFalse), iMaxFileNameLength(0), iMinStringLength(0)
{
iFileNameBase = _L("");
}
//-----------------------------------------------------------------------------
/**
This function creates the files in the following directories
INITIAL CONDITION: FILL FOLLOWING SUB-DIRS WITH 1600 FILES
"\\DIR1\\"...2000 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 2000.TXT")
"\\DIR1\\DIR11\\"...1600 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT")
"\\DIR1\\DIR11\\DIR111\\"...1610 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT") + "ANOTHERLONGFILENAME_1~10.TXT"
"\\DIR1\\DIR12RAN\\"...1600 files ("...random string (31~34)....TXT")
"\\DIR2\\"...1600 files ("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_1 ~ 1600.TXT")
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseSetup()
{
test.Next(_L(" 'Test Setup' - 00"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
TInt curDriveNum;
TInt err = TheFs.CharToDrive(gDriveToTest, curDriveNum);
test(KErrNone == err);
FormatFatDrive(TheFs,curDriveNum, EQuickFormat, NULL, EFalse);
/*-----------------------------------------------------------------------------
* Setup for "\\DIR1\\"
*-----------------------------------------------------------------------------*/
TNamingSchemeParam namingScheme;
namingScheme.iConOrRan = EConsecutive;
namingScheme.iUniOrAsc = EAscii;
namingScheme.iZeroPadFileNumber = EFalse;
namingScheme.iFileNameBase = _L("ABCD1ABCD2ABCD3ABCD4ABCD5ABCD_");
namingScheme.iMaxFileNameLength = 0;
namingScheme.iMinStringLength = 0;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("?:\\DIR1\\");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 2000;
dirParam1.iSampleInterval = 0;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileCreate;
execUnit->AddDirUnitL(dirParam1);
/*-----------------------------------------------------------------------------
* Setup for "\\DIR1\\DIR11\\"
*-----------------------------------------------------------------------------*/
TDirUnitParam dirParam11 = dirParam1;
dirParam11.iDirName = _L("?:\\DIR1\\DIR11\\");
dirParam11.iFilesPerRun = 1600;
dirParam11.iSampleInterval = 0;
execUnit->AddDirUnitL(dirParam11);
/*-----------------------------------------------------------------------------
* Setup for "\\DIR1\\DIR11\\DIR111\\"
*-----------------------------------------------------------------------------*/
TDirUnitParam dirParam111 = dirParam1;
dirParam111.iDirName = _L("?:\\DIR1\\DIR11\\DIR111\\");
dirParam111.iFilesPerRun = 1600;
dirParam111.iSampleInterval = 0;
execUnit->AddDirUnitL(dirParam111);
/*-----------------------------------------------------------------------------
* Test setup for "\\DIR1\\DIR11\\DIR111\\" with "ANOTHERLONGFILENAME_" file
*-----------------------------------------------------------------------------*/
TNamingSchemeParam namingScheme111A = namingScheme;
namingScheme111A.iFileNameBase = _L("ANOTHERLONGFILENAME_");
TDirUnitParam dirParam111A = dirParam1;
dirParam111A.iDirName = _L("?:\\DIR1\\DIR11\\DIR111\\");
dirParam111A.iFilesPerRun = 10;
dirParam111A.iSampleInterval = 0;
dirParam111A.iNamingScheme = namingScheme111A;
execUnit->AddDirUnitL(dirParam111A);
/*-----------------------------------------------------------------------------
* Setup for "\\DIR1\\DIR12RAN\\"
*-----------------------------------------------------------------------------*/
TNamingSchemeParam namingScheme12 = namingScheme;
namingScheme12.iConOrRan = ERandom;
namingScheme12.iZeroPadFileNumber = EFalse;
namingScheme12.iFileNameBase = _L("");
namingScheme12.iMaxFileNameLength = 34;
namingScheme12.iMinStringLength = 31;
TDirUnitParam dirParam12 = dirParam1;
dirParam12.iDirName = _L("?:\\DIR1\\DIR12RAN\\");
dirParam12.iFilesPerRun = 1600;
dirParam12.iSampleInterval = 0;
dirParam12.iNamingScheme = namingScheme12;
execUnit->AddDirUnitL(dirParam12);
/*-----------------------------------------------------------------------------
* Setup for "\\DIR2\\"
*-----------------------------------------------------------------------------*/
TDirUnitParam dirParam2 = dirParam1;
dirParam2.iDirName = _L("?:\\DIR2\\");
dirParam2.iFilesPerRun = 1600;
dirParam2.iSampleInterval = 0;
dirParam2.iNamingScheme = namingScheme;
execUnit->AddDirUnitL(dirParam2);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
This function creates a files in the valid directory path
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseCreateFile()
{
test.Next(_L(" 'Create File' - 01"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
ClearCache(gCacheClear);
TNamingSchemeParam namingScheme;
namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 0;
dirParam1.iSampleInterval = 1;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileCreate;
TFileName path = _L("?:\\");
path.Append(gPath);
if (path[path.Length() - 1] != '\\')
{
path.Append('\\');
}
dirParam1.iDirName = path;
dirParam1.iFilesPerRun = gFileNo;
dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;
execUnit->AddDirUnitL(dirParam1);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
This function opens file in the valid directoy path
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseOpenFile()
{
test.Next(_L(" 'Open File' - 02"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
ClearCache(gCacheClear);
TNamingSchemeParam namingScheme;
namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 0;
dirParam1.iSampleInterval = 1;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileOpen;
TFileName path = _L("?:\\");
path.Append(gPath);
if (path[path.Length() - 1] != '\\')
{
path.Append('\\');
}
dirParam1.iDirName = path;
dirParam1.iFilesPerRun = gFileNo;
dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;
execUnit->AddDirUnitL(dirParam1);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
This function deletes the files in the valid directory path
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseDeleteFile()
{
test.Next(_L(" 'Delete File' - 03"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
ClearCache(gCacheClear);
TNamingSchemeParam namingScheme;
namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 0;
dirParam1.iSampleInterval = 1;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileDelete;
TFileName path = _L("?:\\");
path.Append(gPath);
if (path[path.Length() - 1] != '\\')
{
path.Append('\\');
}
dirParam1.iDirName = path;
dirParam1.iFilesPerRun = gFileNo;
dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;
execUnit->AddDirUnitL(dirParam1);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
PREQ1885 - optional test case
This function writes data into the files in the valid directory path
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseWriteFile()
{
test.Next(_L(" 'Write File' - 04 - Write 4KB of Data"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
ClearCache(gCacheClear);
TNamingSchemeParam namingScheme;
namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 0;
dirParam1.iSampleInterval = 1;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileWrite;
TFileName path = _L("?:\\");
path.Append(gPath);
if (path[path.Length() - 1] != '\\')
{
path.Append('\\');
}
dirParam1.iDirName = path;
dirParam1.iFilesPerRun = gFileNo;
dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;
execUnit->AddDirUnitL(dirParam1);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
PREQ1885 - optional test case
This function Reads data from the files in the valid directory path
*/
//-----------------------------------------------------------------------------
LOCAL_C void DoTestCaseReadFile()
{
test.Next(_L(" 'Read File' - 05 Read 4KB of data"));
TMLUnitParam mlParam =
{
12345 // iID
};
CMeasureAndLogUnit* measureAndLogUnit = CMeasureAndLogUnit::NewLC(mlParam);
CExecutionUnit* execUnit = CExecutionUnit::NewLC(measureAndLogUnit, gDriveToTest);
ClearCache(gCacheClear);
TNamingSchemeParam namingScheme;
namingScheme.iZeroPadFileNumber = gZeroPadFileNumberForFixedLengthFileNames;
TDirUnitParam dirParam1;
dirParam1.iPriority = 1;
dirParam1.iDirName = _L("");
dirParam1.iRuns = 1;
dirParam1.iFilesPerRun = 0;
dirParam1.iSampleInterval = 1;
dirParam1.iNamingScheme = namingScheme;
dirParam1.iFileOpMode = EFATPerfFileRead;
TFileName path = _L("?:\\");
path.Append(gPath);
if (path[path.Length() - 1] != '\\')
{
path.Append('\\');
}
dirParam1.iDirName = path;
dirParam1.iFilesPerRun = gFileNo;
dirParam1.iNamingScheme.iFileNameBase = gFileNameBase;
execUnit->AddDirUnitL(dirParam1);
execUnit->Run();
CleanupStack::PopAndDestroy(2);
}
//-----------------------------------------------------------------------------
/**
This function Dumps the information about Directory Cache
*/
//
LOCAL_C void DoTestCaseDirCacheInfo()
{
ClearCache(gCacheClear);
RDebug::Print(_L("Dumping DirCache Info - Only for DEBUG Mode \n"));
#if defined(_DEBUG) || defined(_DEBUG_RELEASE)
TInt ret = TheFs.ControlIo(CurrentDrive(), ETestFATDirCacheInfo); // For DirCache info
if (ret != KErrNone)
{
RDebug::Print(_L("RFs::ControlIo() returned %d when attempting to dump cache info"), ret);
}
ret = TheFs.ControlIo(CurrentDrive(), ETestDumpFATDirCache); // For Dumping DirCache contents
if (ret != KErrNone)
{
RDebug::Print(_L("RFs::ControlIo() returned %d when attempting to dump cache contents"), ret);
}
#endif
}
/* To clear the cache - remount drive */
LOCAL_C void ClearCache(TInt gCacheClear)
{
TInt rel = KErrNone;
if (gCacheClear == 1)
{
// Remount the drive to clear the cache
rel = RemountFS (TheFs, CurrentDrive(), NULL);
if (rel != KErrNone)
{
RDebug::Print(_L("<<Error>>: Remounting: %d\n"), rel);
User::Leave(rel);
}
}
}
/* Function for command line arguments for the tests */
LOCAL_C void ParseMyCommandArguments()
{
TBuf<0x100> cmd;
User::CommandLine(cmd);
TLex lex(cmd);
TPtrC token=lex.NextToken();
TFileName thisfile=RProcess().FileName();
if (token.MatchF(thisfile)==0)
{
token.Set(lex.NextToken());
}
test.Printf(_L("CLP=%S"),&token);
if(token.Length()!=0)
{
gDriveToTest=token[0];
gDriveToTest.UpperCase();
}
else
{
gDriveToTest='C';
return;
}
while (!lex.Eos())
{
token.Set(lex.NextToken());
if (token.Compare(_L("-c")) == 0 || token.Compare(_L("-C")) == 0)
{
token.Set(lex.NextToken());
if (token.MatchF(_L("Setup"))==0)
{
gTestCase = EFATPerfSetup;
}
else if (token.MatchF(_L("Create"))==0)
{
gTestCase = EFATPerfCreate;
}
else if (token.MatchF(_L("Open"))==0)
{
gTestCase = EFATPerfOpen;
}
else if (token.MatchF(_L("Delete"))==0)
{
gTestCase = EFATPerfDelete;
}
else if (token.MatchF(_L("Write"))==0)
{
gTestCase = EFATPerfWrite;
}
else if (token.MatchF(_L("Read"))==0)
{
gTestCase = EFATPerfRead;
}
else if (token.MatchF(_L("Dumpinfo"))==0)
{
gTestCase = EFATPerfDirCacheInfo;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
if (token.Compare(_L("-p")) == 0 || token.Compare(_L("-P")) == 0)
{
token.Set(lex.NextToken());
if (token.Length() != 0)
{
gPath = token;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
if (token.Compare(_L("-b")) == 0 || token.Compare(_L("-B")) == 0)
{
token.Set(lex.NextToken());
if (token.Length() != 0)
{
gFileNameBase = token;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
if (token.Compare(_L("-n")) == 0 || token.Compare(_L("-N")) == 0)
{
token.Set(lex.NextToken());
if (token.Length() != 0)
{
TLex tokenLex;
tokenLex.Assign(token);
TInt value;
tokenLex.Val(value);
gFileNo = value;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
if (token.Compare(_L("-m")) == 0 || token.Compare(_L("-M")) == 0)
{
token.Set(lex.NextToken());
if (token.Length() != 0)
{
TLex tokenLex;
tokenLex.Assign(token);
TInt value;
tokenLex.Val(value);
gCacheClear = value;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
if (token.Compare(_L("-f")) == 0 || token.Compare(_L("-F")) == 0)
{
token.Set(lex.NextToken());
if (token.Length() != 0)
{
TLex tokenLex;
tokenLex.Assign(token);
TInt value;
tokenLex.Val(value);
gZeroPadFileNumberForFixedLengthFileNames = value;
}
else
{
test.Printf(_L("Bad command syntax"));
test(EFalse);
}
}
}
}
/* System Info */
LOCAL_C void GetSystemInfo()
{
test.Next(_L("Get System Info"));
TFSName fsName;
TInt drvNo = -1;
TInt err = TheFs.CharToDrive(gDriveToTest, drvNo);
test(err == KErrNone);
err = TheFs.FileSystemSubType(drvNo, fsName);
test(err == KErrNone);
test.Printf(_L("File System: [%S]\n"), &fsName);
TVolumeIOParamInfo ioParam;
err = TheFs.VolumeIOParam(drvNo, ioParam);
test(err == KErrNone);
test.Printf(_L("Sector Size: [%d Bytes]\n"), ioParam.iBlockSize);
test.Printf(_L("Cluster Size: [%d Bytes]\n"), ioParam.iClusterSize);
}
//-----------------------------------------------------------------------------
/**
Main Function to call specific test features
*/
//-----------------------------------------------------------------------------
void CallTestsL()
{
//Interpreting Command Line Arguments
ParseMyCommandArguments();
// Get Drive Information
GetSystemInfo();
// Switch Case for Test Functions
switch(gTestCase)
{
//Test Setup
case EFATPerfSetup:
{
DoTestCaseSetup();
break;
}
//File Create
case EFATPerfCreate:
{
DoTestCaseCreateFile();
break;
}
// File Open
case EFATPerfOpen:
{
DoTestCaseOpenFile();
break;
}
// File Delete
case EFATPerfDelete:
{
DoTestCaseDeleteFile();
break;
}
// File Write
case EFATPerfWrite:
{
DoTestCaseWriteFile();
break;
}
// File Read
case EFATPerfRead:
{
DoTestCaseReadFile();
break;
}
// Print / Dump DirCache Info
case EFATPerfDirCacheInfo:
{
DoTestCaseDirCacheInfo();
break;
}
default:
break;
}
}
/*-- EOF--*/