1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/store/TSTRM/t_storstreamperf.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,637 @@
1.4 +// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include <e32test.h>
1.20 +#include <s32file.h>
1.21 +#include <s32fileiter.h>
1.22 +#include <s32mem.h>
1.23 +#include <hal.h>
1.24 +
1.25 +RTest TheTest(_L("t_storstreamperf"));
1.26 +RFs TheFs;
1.27 +
1.28 +TFileName TheTestFile;
1.29 +TFileName TheTestDir;
1.30 +TFileName TheTestDictFile;
1.31 +
1.32 +const TUid KDictFileUid = {19445};
1.33 +const TUid KDictStrmUid1 = {19446};
1.34 +const TUid KDictStrmUid2 = {19447};
1.35 +
1.36 +const TInt KBufSize = 30000;
1.37 +const TInt KIterCnt = 1000;
1.38 +const TInt KTestDataLen = KBufSize / KIterCnt;
1.39 +const TUint8 KTestData[KTestDataLen] =
1.40 + {
1.41 + 'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O',
1.42 + 'P','Q','R','S','T','U','V','W','X','Y','Z','0','1','2','3'
1.43 + };
1.44 +const TPtrC8 KTestDes(KTestData, KTestDataLen);
1.45 +
1.46 +///////////////////////////////////////////////////////////////////////////////////////
1.47 +
1.48 +void DestroyTestEnv()
1.49 + {
1.50 + (void)TheFs.Delete(TheTestDictFile);
1.51 + (void)TheFs.Delete(TheTestFile);
1.52 + TheFs.Close();
1.53 + }
1.54 +
1.55 +///////////////////////////////////////////////////////////////////////////////////////
1.56 +//Test macros and functions
1.57 +void Check(TInt aValue, TInt aLine)
1.58 + {
1.59 + if(!aValue)
1.60 + {
1.61 + TheTest.Printf(_L("*** Boolean expression evaluated to false\r\n"));
1.62 + DestroyTestEnv();
1.63 + TheTest(EFalse, aLine);
1.64 + }
1.65 + }
1.66 +void Check(TInt aValue, TInt aExpected, TInt aLine)
1.67 + {
1.68 + if(aValue != aExpected)
1.69 + {
1.70 + DestroyTestEnv();
1.71 + TheTest.Printf(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
1.72 + TheTest(EFalse, aLine);
1.73 + }
1.74 + }
1.75 +#define TEST(arg) ::Check((arg), __LINE__)
1.76 +#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)
1.77 +
1.78 +///////////////////////////////////////////////////////////////////////////////////////
1.79 +
1.80 +void CreateTestEnv()
1.81 + {
1.82 + TInt err = TheFs.Connect();
1.83 + TheTest(err == KErrNone);
1.84 +
1.85 + err = TheFs.MkDirAll(TheTestFile);
1.86 + TEST(err == KErrNone || err == KErrAlreadyExists);
1.87 + }
1.88 +
1.89 +///////////////////////////////////////////////////////////////////////////////////////
1.90 +
1.91 +static TInt TheCounterFreq = -10000000;
1.92 +const TInt KMicroSecIn1Sec = 1000000;
1.93 +
1.94 +TUint32 CalcTickDiff(TUint32 aStartTicks, TUint32 aEndTicks)
1.95 + {
1.96 + TInt64 diffTicks = (TInt64)aEndTicks - (TInt64)aStartTicks;
1.97 + if(diffTicks < 0)
1.98 + {
1.99 + diffTicks = KMaxTUint32 + diffTicks + 1;
1.100 + }
1.101 + return (TUint32)diffTicks;
1.102 + }
1.103 +
1.104 +//Prints aFastCount parameter (converted to us)
1.105 +void PrintFcDiffAsUs(const TDesC& aFormatStr, TUint32 aFastCount)
1.106 + {
1.107 + double v = ((double)aFastCount * KMicroSecIn1Sec) / (double)TheCounterFreq;
1.108 + TInt v2 = (TInt)v;
1.109 + TheTest.Printf(aFormatStr, v2);
1.110 + }
1.111 +
1.112 +///////////////////////////////////////////////////////////////////////////////////////
1.113 +
1.114 +//Testing RWriteStream performance.
1.115 +void StreamWriteTestL(RWriteStream& aStream, TUint32& aWriteFc, TUint32& aCommitFc)
1.116 + {
1.117 + TUint32 fc = User::FastCounter();
1.118 + for(TInt i=0;i<KIterCnt;++i)
1.119 + {
1.120 + aStream.WriteL(KTestDes);
1.121 + }
1.122 + TUint32 fc2 = User::FastCounter();
1.123 + aStream.CommitL();
1.124 + TUint32 fc3 = User::FastCounter();
1.125 +
1.126 + aWriteFc = CalcTickDiff(fc, fc2);
1.127 + aCommitFc = CalcTickDiff(fc2, fc3);
1.128 + }
1.129 +
1.130 +void DoStreamWriteTestL(RWriteStream& aStream)
1.131 + {
1.132 + TUint32 writeFc = 0, commitFc = 0;
1.133 + StreamWriteTestL(aStream, writeFc, commitFc);
1.134 + PrintFcDiffAsUs(_L("### RWriteStream::WriteL(), Time=%d us\r\n"), writeFc);
1.135 + PrintFcDiffAsUs(_L("### RWriteStream::CommitL(), Time=%d us\r\n"), commitFc);
1.136 + }
1.137 +
1.138 +//Testing RReadStream performance.
1.139 +void StreamReadTestL(RReadStream& aStream, TUint32& aReadFc)
1.140 + {
1.141 + TBuf8<KTestDataLen> buf;
1.142 + TUint32 fc = User::FastCounter();
1.143 + for(TInt i=0;i<KIterCnt;++i)
1.144 + {
1.145 + aStream.ReadL(buf);
1.146 + }
1.147 + TUint32 fc2 = User::FastCounter();
1.148 + TEST(buf == KTestDes);
1.149 +
1.150 + aReadFc = CalcTickDiff(fc, fc2);
1.151 + }
1.152 +
1.153 +void DoStreamReadTestL(RReadStream& aStream)
1.154 + {
1.155 + TUint32 readFc = 0;
1.156 + StreamReadTestL(aStream, readFc);
1.157 + PrintFcDiffAsUs(_L("### RReadStream::ReadL(), Time=%d us\r\n"), readFc);
1.158 + }
1.159 +
1.160 +///////////////////////////////////////////////////////////////////////////////////////
1.161 +
1.162 +void GetFastCounterFrequency()
1.163 + {
1.164 + TEST2(HAL::Get(HAL::EFastCounterFrequency, TheCounterFreq), KErrNone);
1.165 + TheTest.Printf(_L("Counter frequency=%d Hz\r\n"), TheCounterFreq);
1.166 + }
1.167 +
1.168 +/**
1.169 +@SYMTestCaseID PDS-STORE-UT-4053
1.170 +@SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests.
1.171 + PREQ2505 Insturmentation of PDS.
1.172 + RDictionaryWriteStream & RDictionaryReadStream performance tests.
1.173 +@SYMTestPriority High
1.174 +@SYMTestActions Test for DEF141471 - STORE, new stream performance tests.
1.175 +@SYMTestExpectedResults Test must not fail
1.176 +@SYMDEF DEF141471
1.177 +*/
1.178 +void DictionaryStreamTestL()
1.179 + {
1.180 + (void)TheFs.Delete(TheTestDictFile);
1.181 + CDictionaryFileStore* store = CDictionaryFileStore::OpenLC(TheFs, TheTestDictFile, KDictFileUid);
1.182 +
1.183 + //RDictionaryWriteStream::AssignL()
1.184 + RDictionaryWriteStream strm1;
1.185 + CleanupClosePushL(strm1);
1.186 + TUint32 fc = User::FastCounter();
1.187 + strm1.AssignL(*store, KDictStrmUid1);
1.188 + TUint32 assignFc = CalcTickDiff(fc, User::FastCounter());
1.189 + PrintFcDiffAsUs(_L("### RDictionaryWriteStream::AssignL(), Time=%d us\r\n"), assignFc);
1.190 + DoStreamWriteTestL(strm1);
1.191 + CleanupStack::PopAndDestroy(&strm1);
1.192 +
1.193 + //RDictionaryWriteStream::AssignLC()
1.194 + RDictionaryWriteStream strm2;
1.195 + fc = User::FastCounter();
1.196 + strm2.AssignLC(*store, KDictStrmUid2);
1.197 + assignFc = CalcTickDiff(fc, User::FastCounter());
1.198 + PrintFcDiffAsUs(_L("### RDictionaryWriteStream::AssignLC(), Time=%d us\r\n"), assignFc);
1.199 + DoStreamWriteTestL(strm2);
1.200 + CleanupStack::PopAndDestroy(&strm2);
1.201 +
1.202 + //RDictionaryReadStream::OpenL()
1.203 + RDictionaryReadStream strm3;
1.204 + CleanupClosePushL(strm3);
1.205 + fc = User::FastCounter();
1.206 + strm3.OpenL(*store, KDictStrmUid1);
1.207 + TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
1.208 + PrintFcDiffAsUs(_L("### RDictionaryReadStream::OpenL(), Time=%d us\r\n"), openFc);
1.209 + DoStreamReadTestL(strm3);
1.210 + CleanupStack::PopAndDestroy(&strm3);
1.211 +
1.212 + //RDictionaryReadStream::OpenLC()
1.213 + RDictionaryReadStream strm4;
1.214 + fc = User::FastCounter();
1.215 + strm4.OpenLC(*store, KDictStrmUid2);
1.216 + openFc = CalcTickDiff(fc, User::FastCounter());
1.217 + PrintFcDiffAsUs(_L("### RDictionaryReadStream::OpenLC(), Time=%d us\r\n"), openFc);
1.218 + DoStreamReadTestL(strm4);
1.219 + CleanupStack::PopAndDestroy(&strm4);
1.220 +
1.221 + CleanupStack::PopAndDestroy(store);
1.222 + }
1.223 +
1.224 +/**
1.225 +@SYMTestCaseID PDS-STORE-UT-4054
1.226 +@SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests.
1.227 + PREQ2505 Insturmentation of PDS.
1.228 + RFileWriteStream & RFileReadStream performance tests.
1.229 +@SYMTestPriority High
1.230 +@SYMTestActions Test for DEF141471 - STORE, new stream performance tests.
1.231 +@SYMTestExpectedResults Test must not fail
1.232 +@SYMDEF DEF141471
1.233 +*/
1.234 +void FileStreamTestL()
1.235 + {
1.236 + (void)TheFs.Delete(TheTestFile);
1.237 +
1.238 + //RFileWriteStream::Create()
1.239 + RFileWriteStream strm1;
1.240 + TUint32 fc = User::FastCounter();
1.241 + TInt err = strm1.Create(TheFs, TheTestFile, EFileWrite | EFileRead);
1.242 + TUint32 createFc = CalcTickDiff(fc, User::FastCounter());
1.243 + TEST2(err, KErrNone);
1.244 + PrintFcDiffAsUs(_L("### RFileWriteStream::Create(), Time=%d us\r\n"), createFc);
1.245 + strm1.Close();
1.246 +
1.247 + //RFileWriteStream::Replace()
1.248 + RFileWriteStream strm2;
1.249 + fc = User::FastCounter();
1.250 + err = strm2.Replace(TheFs, TheTestFile, EFileWrite | EFileRead);
1.251 + TUint32 replaceFc = CalcTickDiff(fc, User::FastCounter());
1.252 + TEST2(err, KErrNone);
1.253 + PrintFcDiffAsUs(_L("### RFileWriteStream::Replace(), Time=%d us\r\n"), replaceFc);
1.254 + strm2.Close();
1.255 +
1.256 + //RFileWriteStream::Open()
1.257 + RFileWriteStream strm3;
1.258 + fc = User::FastCounter();
1.259 + err = strm3.Open(TheFs, TheTestFile, EFileWrite | EFileRead);
1.260 + TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
1.261 + TEST2(err, KErrNone);
1.262 + PrintFcDiffAsUs(_L("### RFileWriteStream::Open(), Time=%d us\r\n"), openFc);
1.263 + strm3.Close();
1.264 +
1.265 + //RFileWriteStream::Attach()
1.266 + RFile file;
1.267 + err = file.Open(TheFs, TheTestFile, EFileWrite | EFileRead);
1.268 + TEST2(err, KErrNone);
1.269 + RFileWriteStream strm4;
1.270 + CleanupClosePushL(strm4);
1.271 + fc = User::FastCounter();
1.272 + strm4.Attach(file);
1.273 + TUint32 attachFc = CalcTickDiff(fc, User::FastCounter());
1.274 + PrintFcDiffAsUs(_L("### RFileWriteStream::Attach(), Time=%d us\r\n"), attachFc);
1.275 + DoStreamWriteTestL(strm4);
1.276 + CleanupStack::PopAndDestroy(&strm4);
1.277 +
1.278 + //RFileWriteStream::Temp()
1.279 + RFileWriteStream strm5;
1.280 + CleanupClosePushL(strm5);
1.281 + TFileName fname;
1.282 + fc = User::FastCounter();
1.283 + err = strm5.Temp(TheFs, TheTestDir, fname, EFileWrite | EFileRead);
1.284 + TUint32 tempFc = CalcTickDiff(fc, User::FastCounter());
1.285 + TEST2(err, KErrNone);
1.286 + PrintFcDiffAsUs(_L("### RFileWriteStream::Temp(), Time=%d us\r\n"), tempFc);
1.287 + DoStreamWriteTestL(strm5);
1.288 + CleanupStack::PopAndDestroy(&strm5);
1.289 + err = TheFs.Delete(fname);
1.290 + TEST2(err, KErrNone);
1.291 +
1.292 + //RFileReadStream::Open()
1.293 + RFileReadStream strm6;
1.294 + fc = User::FastCounter();
1.295 + err = strm6.Open(TheFs, TheTestFile, EFileRead);
1.296 + openFc = CalcTickDiff(fc, User::FastCounter());
1.297 + PrintFcDiffAsUs(_L("### RFileReadStream::Open(), Time=%d us\r\n"), openFc);
1.298 + strm6.Close();
1.299 +
1.300 + //RFileReadStream::Attach()
1.301 + err = file.Open(TheFs, TheTestFile, EFileRead);
1.302 + TEST2(err, KErrNone);
1.303 + RFileReadStream strm7;
1.304 + fc = User::FastCounter();
1.305 + strm7.Attach(file);
1.306 + attachFc = CalcTickDiff(fc, User::FastCounter());
1.307 + PrintFcDiffAsUs(_L("### RFileReadStream::Attach(), Time=%d us\r\n"), attachFc);
1.308 + strm7.Close();
1.309 +
1.310 + //RFileReadStream::RFileReadStream(RFile&)
1.311 + err = file.Open(TheFs, TheTestFile, EFileRead);
1.312 + TEST2(err, KErrNone);
1.313 + fc = User::FastCounter();
1.314 + RFileReadStream strm8(file);
1.315 + TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());
1.316 + CleanupClosePushL(strm8);
1.317 + PrintFcDiffAsUs(_L("### RFileReadStream::RFileReadStream(RFile&), Time=%d us\r\n"), constrFc);
1.318 + DoStreamReadTestL(strm8);
1.319 + CleanupStack::PopAndDestroy(&strm8);
1.320 + }
1.321 +
1.322 +/**
1.323 +@SYMTestCaseID PDS-STORE-UT-4055
1.324 +@SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests.
1.325 + PREQ2505 Insturmentation of PDS.
1.326 + RMemWriteStream & RMemReadStream performance tests.
1.327 +@SYMTestPriority High
1.328 +@SYMTestActions Test for DEF141471 - STORE, new stream performance tests.
1.329 +@SYMTestExpectedResults Test must not fail
1.330 +@SYMDEF DEF141471
1.331 +*/
1.332 +void MemStreamTestL()
1.333 + {
1.334 + HBufC8* buf = HBufC8::NewLC(KBufSize);
1.335 + TPtr8 bufPtr = buf->Des();
1.336 +
1.337 + //RMemWriteStream::Open()
1.338 + RMemWriteStream strm1;
1.339 + TUint32 fc = User::FastCounter();
1.340 + strm1.Open(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);
1.341 + TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
1.342 + PrintFcDiffAsUs(_L("### RMemWriteStream::Open(), Time=%d us\r\n"), openFc);
1.343 + strm1.Close();
1.344 +
1.345 + //RMemWriteStream::RMemWriteStream(TAny*,...)
1.346 + fc = User::FastCounter();
1.347 + RMemWriteStream strm2(const_cast <TUint8*> (bufPtr.Ptr()), KBufSize);
1.348 + TUint32 constrFc = CalcTickDiff(fc, User::FastCounter());
1.349 + PrintFcDiffAsUs(_L("### RMemWriteStream::RMemWriteStream(TAny*,...), Time=%d us\r\n"), constrFc);
1.350 + CleanupClosePushL(strm2);
1.351 + DoStreamWriteTestL(strm2);
1.352 + CleanupStack::PopAndDestroy(&strm2);
1.353 +
1.354 + //RMemReadStream::Open()
1.355 + RMemReadStream strm3;
1.356 + fc = User::FastCounter();
1.357 + strm3.Open(bufPtr.Ptr(), KBufSize);
1.358 + openFc = CalcTickDiff(fc, User::FastCounter());
1.359 + PrintFcDiffAsUs(_L("### RMemReadStream::Open(), Time=%d us\r\n"), openFc);
1.360 + strm3.Close();
1.361 +
1.362 + //RMemReadStream::RMemReadStream(TAny*,...)
1.363 + fc = User::FastCounter();
1.364 + RMemReadStream strm4(bufPtr.Ptr(), KBufSize);
1.365 + constrFc = CalcTickDiff(fc, User::FastCounter());
1.366 + PrintFcDiffAsUs(_L("### RMemReadStream::RMemReadStream(TAny*,...), Time=%d us\r\n"), openFc);
1.367 + CleanupClosePushL(strm4);
1.368 + DoStreamReadTestL(strm4);
1.369 + CleanupStack::PopAndDestroy(&strm4);
1.370 +
1.371 + CleanupStack::PopAndDestroy(buf);
1.372 + }
1.373 +
1.374 +/**
1.375 +@SYMTestCaseID PDS-STORE-UT-4056
1.376 +@SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests.
1.377 + PREQ2505 Insturmentation of PDS.
1.378 + RBufWriteStream & RBufReadStream performance tests.
1.379 +@SYMTestPriority High
1.380 +@SYMTestActions Test for DEF141471 - STORE, new stream performance tests.
1.381 +@SYMTestExpectedResults Test must not fail
1.382 +@SYMDEF DEF141471
1.383 +*/
1.384 +void BufStreamTestL()
1.385 + {
1.386 + CBufFlat* bufFlat = CBufFlat::NewL(KTestDataLen);
1.387 + CleanupStack::PushL(bufFlat);
1.388 +
1.389 + //RBufWriteStream::Open()
1.390 + RBufWriteStream strm1;
1.391 + CleanupClosePushL(strm1);
1.392 + TUint32 fc = User::FastCounter();
1.393 + strm1.Open(*bufFlat);
1.394 + TUint32 openFc = CalcTickDiff(fc, User::FastCounter());
1.395 + PrintFcDiffAsUs(_L("### RBufWriteStream::Open(), Time=%d us\r\n"), openFc);
1.396 + DoStreamWriteTestL(strm1);
1.397 + CleanupStack::PopAndDestroy(&strm1);
1.398 + TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size());
1.399 +
1.400 + //RBufWriteStream::Append()
1.401 + RBufWriteStream strm2;
1.402 + CleanupClosePushL(strm2);
1.403 + fc = User::FastCounter();
1.404 + strm2.Append(*bufFlat);
1.405 + TUint32 appendFc = CalcTickDiff(fc, User::FastCounter());
1.406 + PrintFcDiffAsUs(_L("### RBufWriteStream::Append(), Time=%d us\r\n"), appendFc);
1.407 + DoStreamWriteTestL(strm2);
1.408 + CleanupStack::PopAndDestroy(&strm2);
1.409 + TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size());
1.410 +
1.411 + //RBufWriteStream::Insert()
1.412 + RBufWriteStream strm3;
1.413 + CleanupClosePushL(strm3);
1.414 + fc = User::FastCounter();
1.415 + strm3.Insert(*bufFlat, KBufSize);
1.416 + TUint32 insertFc = CalcTickDiff(fc, User::FastCounter());
1.417 + PrintFcDiffAsUs(_L("### RBufWriteStream::Insert(), Time=%d us\r\n"), insertFc);
1.418 + DoStreamWriteTestL(strm3);
1.419 + CleanupStack::PopAndDestroy(&strm3);
1.420 + TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size());
1.421 +
1.422 + //RBufWriteStream::Truncate()
1.423 + RBufWriteStream strm4;
1.424 + CleanupClosePushL(strm4);
1.425 + fc = User::FastCounter();
1.426 + strm4.Truncate(*bufFlat);
1.427 + TUint32 truncateFc = CalcTickDiff(fc, User::FastCounter());
1.428 + PrintFcDiffAsUs(_L("### RBufWriteStream::Truncate(), Time=%d us\r\n"), truncateFc);
1.429 + DoStreamWriteTestL(strm4);
1.430 + CleanupStack::PopAndDestroy(&strm4);
1.431 + TheTest.Printf(_L(" Buffer size=%d\r\n"), bufFlat->Size());
1.432 +
1.433 + RBufReadStream strm5;
1.434 + CleanupClosePushL(strm5);
1.435 + fc = User::FastCounter();
1.436 + strm5.Open(*bufFlat);
1.437 + openFc = CalcTickDiff(fc, User::FastCounter());
1.438 + PrintFcDiffAsUs(_L("### RBufReadStream::Open(), Time=%d us\r\n"), openFc);
1.439 + DoStreamReadTestL(strm5);
1.440 + CleanupStack::PopAndDestroy(&strm5);
1.441 +
1.442 + CleanupStack::PopAndDestroy(bufFlat);
1.443 + }
1.444 +
1.445 +/**
1.446 +@SYMTestCaseID PDS-STORE-UT-4057
1.447 +@SYMTestCaseDesc Test for DEF141471 - STORE, new stream performance tests.
1.448 + PREQ2505 Insturmentation of PDS.
1.449 + RPermanentFileStoreIter performance tests.
1.450 +@SYMTestPriority High
1.451 +@SYMTestActions Test for DEF141471 - STORE, new stream performance tests.
1.452 +@SYMTestExpectedResults Test must not fail
1.453 +@SYMDEF DEF141471
1.454 +*/
1.455 +void PermanentFileStoreIterTestL()
1.456 + {
1.457 + (void)TheFs.Delete(TheTestFile);
1.458 +
1.459 + CPermanentFileStore* store = CPermanentFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.460 + store->SetTypeL(KPermanentFileStoreLayoutUid);
1.461 +
1.462 + //Create streams
1.463 + const TInt KStreamCnt = 10;
1.464 + TStreamId streamId[KStreamCnt] = {0};
1.465 + TheTest.Printf(_L("### CPermanentFileStore, create %d streams\r\n"), KStreamCnt);
1.466 + for(TInt i=0;i<KStreamCnt;i++)
1.467 + {
1.468 + RStoreWriteStream out;
1.469 + streamId[i] = out.CreateLC(*store);
1.470 + TheTest.Printf(_L("### Stream##%02d, streamId=%08X\r\n"), i + 1, streamId[i].Value());
1.471 + DoStreamWriteTestL(out);
1.472 + CleanupStack::PopAndDestroy(&out);
1.473 + }
1.474 + TUint32 fc = User::FastCounter();
1.475 + store->CommitL();
1.476 + TUint32 commitFc = CalcTickDiff(fc, User::FastCounter());
1.477 + CleanupStack::PopAndDestroy(store);
1.478 + PrintFcDiffAsUs(_L("### RPermanentFileStoreIter::CommitL(), Time=%d us\r\n"), commitFc);
1.479 +
1.480 + //RPermanentFileStoreIter::ResetL()
1.481 + store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.482 + RPermanentFileStoreIter it1;
1.483 + CleanupClosePushL(it1);
1.484 + fc = User::FastCounter();
1.485 + it1.ResetL(*store);
1.486 + TUint32 resetFc = CalcTickDiff(fc, User::FastCounter());
1.487 + CleanupStack::PopAndDestroy(&it1);
1.488 + CleanupStack::PopAndDestroy(store);
1.489 + PrintFcDiffAsUs(_L("### RPermanentFileStoreIter::ResetL(), Time=%d us\r\n"), resetFc);
1.490 +
1.491 + //RPermanentFileStoreIter::ResetLC()
1.492 + store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.493 + RPermanentFileStoreIter it2;
1.494 + fc = User::FastCounter();
1.495 + it2.ResetLC(*store);
1.496 + resetFc = CalcTickDiff(fc, User::FastCounter());
1.497 + CleanupStack::PopAndDestroy(&it2);
1.498 + CleanupStack::PopAndDestroy(store);
1.499 + PrintFcDiffAsUs(_L("### RPermanentFileStoreIter::ResetLC(), Time=%d us\r\n"), resetFc);
1.500 +
1.501 + //RPermanentFileStoreIter - construction & destruction
1.502 + store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.503 + fc = User::FastCounter();
1.504 + RPermanentFileStoreIter it3;
1.505 + CleanupClosePushL(it3);
1.506 + it3.ResetL(*store);
1.507 + CleanupStack::PopAndDestroy(&it3);
1.508 + TUint32 fc2 = CalcTickDiff(fc, User::FastCounter());
1.509 + CleanupStack::PopAndDestroy(store);
1.510 + PrintFcDiffAsUs(_L("### RPermanentFileStoreIter - construction & destruction, Time=%d us\r\n"), fc2);
1.511 +
1.512 + //RPermanentFileStoreIter::NextL()
1.513 + store = CPermanentFileStore::OpenLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.514 + RPermanentFileStoreIter it4;
1.515 + it4.ResetLC(*store);
1.516 + TStreamId id(KNullStreamIdValue);
1.517 + TInt cnt = 0;
1.518 + fc = User::FastCounter();
1.519 + while((id = it4.NextL()) != KNullStreamIdValue)
1.520 + {
1.521 + ++cnt;
1.522 + }
1.523 + TUint32 nextFc = CalcTickDiff(fc, User::FastCounter());
1.524 + CleanupStack::PopAndDestroy(&it4);
1.525 + CleanupStack::PopAndDestroy(store);
1.526 + TEST2(cnt, KStreamCnt);
1.527 + PrintFcDiffAsUs(_L("### RPermanentFileStoreIter::NextL(), Time=%d us\r\n"), nextFc);
1.528 + }
1.529 +
1.530 +/**
1.531 +@SYMTestCaseID SYSLIB-STORE-CT-4007
1.532 +@SYMTestCaseDesc CDirectFileStore::ReplaceLC() and SetTypeL() performance test
1.533 +@SYMTestPriority High
1.534 +@SYMTestActions Creates new CDirectFileStore object and measures the time of the operation.
1.535 +@SYMTestExpectedResults Tests set type time
1.536 +@SYMCR ATHE-7CQP8H
1.537 +*/
1.538 +void CreateDirectFileStoreTestL()
1.539 + {
1.540 + (void)TheFs.Delete(TheTestFile);
1.541 +
1.542 + TUint32 fc = User::FastCounter();
1.543 + CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.544 + // Must say what kind of file store
1.545 + // SetTypeL() calls RFileBuf::EndL() which used to call RFile::Size()
1.546 + store->SetTypeL(KDirectFileStoreLayoutUid);
1.547 + TUint32 time = CalcTickDiff(fc, User::FastCounter());
1.548 + CleanupStack::PopAndDestroy(store);
1.549 + PrintFcDiffAsUs(_L("### CDirectFileStore::ReplaceLC() & SetTypeL(), Time=%d us\r\n"), time);
1.550 + }
1.551 +
1.552 +/**
1.553 +@SYMTestCaseID SYSLIB-STORE-CT-4008
1.554 +@SYMTestCaseDesc Tests performance when calling CFileStore::Destruct()
1.555 +@SYMTestPriority High
1.556 +@SYMTestActions Creates and deletes a File Store
1.557 +@SYMTestExpectedResults Tests deletion time
1.558 +@SYMCR ATHE-7CQP8H
1.559 +*/
1.560 +void DirectFileStoreTestL()
1.561 + {
1.562 + (void)TheFs.Delete(TheTestFile);
1.563 +
1.564 + TUint32 fc = User::FastCounter();
1.565 + CFileStore* store = CDirectFileStore::ReplaceLC(TheFs, TheTestFile, EFileWrite | EFileRead);
1.566 + //then delete it. this calls CFileStore::Destruct(), which used to call Revert()
1.567 + CleanupStack::PopAndDestroy(store);
1.568 + TUint32 time = CalcTickDiff(fc, User::FastCounter());
1.569 + PrintFcDiffAsUs(_L("### CDirectFileStore construction & destruction, Time=%d us\r\n"), time);
1.570 + }
1.571 +
1.572 +void DoTestsL()
1.573 + {
1.574 + TheTest.Start(_L("Get fast counter frequency"));
1.575 + GetFastCounterFrequency();
1.576 +
1.577 + TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4053 RDictionaryWriteStream & RDictionaryReadStream - performance test"));
1.578 + DictionaryStreamTestL();
1.579 +
1.580 + TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4054 RFileWriteStream & RFileReadStream - performance test"));
1.581 + FileStreamTestL();
1.582 +
1.583 + TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4055 RMemWriteStream & RMemReadStream - performance test"));
1.584 + MemStreamTestL();
1.585 +
1.586 + TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4056 RBufWriteStream & RBufReadStream - performance test"));
1.587 + BufStreamTestL();
1.588 +
1.589 + TheTest.Next(_L(" @SYMTestCaseID:PDS-STORE-UT-4057 RPermanentFileStoreIter - performance test"));
1.590 + PermanentFileStoreIterTestL();
1.591 +
1.592 + TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4007 CDirectFileStore::ReplaceLC() & SetTypeL() performance test"));
1.593 + CreateDirectFileStoreTestL();
1.594 +
1.595 + TheTest.Next(_L(" @SYMTestCaseID SYSLIB-STORE-CT-4008 CDirectFileStore construction & destruction performance test"));
1.596 + DirectFileStoreTestL();
1.597 + }
1.598 +
1.599 +//Usage: "t_streamperf [<drive letter>:]]"
1.600 +TInt E32Main()
1.601 + {
1.602 + TheTest.Title();
1.603 +
1.604 + CTrapCleanup* tc = CTrapCleanup::New();
1.605 + TheTest(tc != NULL);
1.606 +
1.607 + TBuf<256> cmdline;
1.608 + User::CommandLine(cmdline);
1.609 +
1.610 + TParse parse;
1.611 +
1.612 + _LIT(KTestFile, "c:\\stor-tst\\t_streamperf.dat");
1.613 + parse.Set(cmdline, &KTestFile, 0);
1.614 + TheTestFile.Copy(parse.FullName());
1.615 +
1.616 + _LIT(KTestPath, "c:\\stor-tst\\");
1.617 + parse.Set(cmdline, &KTestPath, 0);
1.618 + TheTestDir.Copy(parse.FullName());
1.619 +
1.620 + _LIT(KDictFile, "c:\\stor-tst\\dicfile.ini");
1.621 + parse.Set(cmdline, &KDictFile, 0);
1.622 + TheTestDictFile.Copy(parse.FullName());
1.623 +
1.624 + __UHEAP_MARK;
1.625 +
1.626 + CreateTestEnv();
1.627 + TRAPD(err, DoTestsL());
1.628 + TEST2(err, KErrNone);
1.629 + DestroyTestEnv();
1.630 +
1.631 + __UHEAP_MARKEND;
1.632 +
1.633 + TheTest.End();
1.634 + TheTest.Close();
1.635 +
1.636 + delete tc;
1.637 +
1.638 + User::Heap().Check();
1.639 + return KErrNone;
1.640 + }