PagingTestBase Class Reference

PagingTestBase is a common base for multi-threaded tests which exercise cache paging. More...

#include <PagingTestBase.h>

Inheritance diagram for PagingTestBase:

CacheTestBase ThreadedTestBase TestBase TestBase TraceTarget TraceTarget CacheTest SegmentTestBase LinearDeviceSegmentTest LinearViewSegmentTest RandomAllocationSegmentTest SnapshotSegmentTestBase VersionedSegmentTest BackupRestoreTest LcsClusterReplaceExecStreamTest SnapshotSegmentTest List of all members.

Public Types

enum  OpType {
  OP_READ_SEQ, OP_WRITE_SEQ, OP_READ_RAND, OP_WRITE_RAND,
  OP_READ_NOWAIT, OP_WRITE_NOWAIT, OP_WRITE_SKIP, OP_SCRATCH,
  OP_PREFETCH, OP_PREFETCH_BATCH, OP_ALLOCATE, OP_DEALLOCATE,
  OP_CHECKPOINT, OP_RESIZE_CACHE, OP_MAX
}
 The various operations that can be run in the multi-threaded test. More...

Public Member Functions

 PagingTestBase ()
virtual ~PagingTestBase ()
virtual void fillPage (CachePage &page, uint x)
 Scribbles on the contents of a page.
virtual void verifyPage (CachePage &page, uint x)
 Verifies that the page contents are correct (based on the parameter x).
virtual CachePage * lockPage (OpType opType, uint iPage)=0
virtual void unlockPage (CachePage &page, LockMode lockMode)=0
virtual void prefetchPage (uint iPage)=0
virtual void prefetchBatch (uint iPage, uint nPagesPerBatch)=0
bool testOp (OpType opType, uint iPage, bool bNice)
 Carries out one operation on a page.
char const * getOpName (OpType opType)
 Makes up an operation name based on an OpType.
LockMode getLockMode (OpType opType)
 Gets the LockMode corresponding to an OpType.
void testSequentialOp (OpType opType)
 Carries out an operation on each disk page in order from 0 to nDiskPages-1.
void testRandomOp (OpType opType)
 Carries out an operation on nRandomOps pages selected at random.
void testSkipOp (OpType opType, uint n)
 Carries out an operation on every "n" pages, starting at page 0.
void testScratch ()
 Performs nRandomOps scratch operations.
void testPrefetch ()
 Performs a limited number of prefetch operations.
void testPrefetchBatch ()
 Performs a limited number of batch prefetch operations.
virtual void testCheckpoint ()
 Performs a periodic checkpoint.
virtual void testAllocateAll ()
 Initializes all disk pages, filling them with information based on their block numbers.
void testSequentialRead ()
 Carries out one sequential read pass over the entire device.
void testSequentialWrite ()
 Carries out one sequential write pass over the entire device.
void testRandomRead ()
 Carries out nRandomOps read operations on pages selected at random.
void testRandomWrite ()
 Carries out nRandomOps write operations on pages selected at random.
void testSkipWrite (uint n)
 Carries out write operations every n pages.
virtual void testAllocate ()
virtual void testDeallocate ()
void testCheckpointGuarded ()
void testCacheResize ()
void testMultipleThreads ()
 Carries out specified tests in multi-threaded mode.
virtual void threadInit ()
virtual void threadTerminate ()
virtual bool testThreadedOp (int iOp)
 Test implementation must be supplied by derived test class.
Cache & getCache ()
virtual SharedCache newCache ()
SharedRandomAccessDevice openDevice (std::string devName, DeviceMode openMode, uint nDevicePages, DeviceId deviceId)
virtual void openStorage (DeviceMode openMode)
virtual void closeStorage ()
virtual void testCaseTearDown ()
 Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
void closeDevice (DeviceId deviceId, SharedRandomAccessDevice &pDevice)
TestSuite * releaseTestSuite ()
void beforeTestCase (std::string testCaseName)
void afterTestCase (std::string testCaseName)
virtual void testCaseSetUp ()
 Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
virtual void notifyTrace (std::string source, TraceLevel level, std::string message)
 Receives notification when a trace event occurs.
virtual TraceLevel getSourceTraceLevel (std::string source)
 Gets the level at which a particular source should be traced.

Static Public Member Functions

static void readParams (int argc, char **argv)
 Parses the command line.

Static Public Attributes

static ParamName paramTestSuiteName
static ParamName paramTraceFileName
static ParamName paramDictionaryFileName
static ParamName paramTraceLevel
static ParamName paramStatsFileName
static ParamName paramTraceStdout
static ParamName paramDegreeOfParallelism
static ConfigMap configMap
 Configuration parameters.

Protected Types

enum  VictimPolicy { victimTwoQ, victimLRU, victimRandom }
 The available victim policy implementations. More...

Protected Member Functions

uint generateRandomNumber (uint iMax)
void snooze (uint nSeconds)
void runThreadedTestCase ()
 Executes specified test threads.

Protected Attributes

uint cbPageUsable
 Portion of each page that should be scribbled on.
uint nRandomOps
 Number of random access operations to run per pass.
uint nSecondsBetweenCheckpoints
 Checkpoint interval during multi-threaded test.
StrictMutex logMutex
 Protects output stream.
SXMutex checkpointMutex
 SXMutex used to synchronize checkpoints with write actions.
bool bTestResize
 Flag indicating that the cache should be dynamically resized during the multi-threaded portion of the test.
VictimPolicy victimPolicy
 VictimPolicy to instantiate.
CacheParams cacheParams
 Parameters for cache initialization.
SharedCache pCache
 Cache instance being tested.
SharedRandomAccessDevice pRandomAccessDevice
 The default cached device.
uint nMemPages
 Size of cache in memory pages.
uint nDiskPages
 Size of device in disk pages.
uint cbPageFull
 Disk page size.
DeviceId dataDeviceId
 Fixed ID to assign to data device.
TestSuite * pTestSuite
 Boost test suite.
boost::shared_ptr< TestBase > pTestObj
std::ofstream traceStream
 Output file stream for tracing.
StrictMutex traceMutex
 Protects traceStream.
std::string testName
 Name of test.
TraceLevel traceLevel
 Level at which to trace test execution.
FileStatsTarget statsTarget
 Output for stats.
StatsTimer statsTimer
 Timer for stats collection.
bool traceStdout
 Copy trace output to stdout.
bool traceFile
 Copy trace output to file.
TestCaseGroup defaultTests
TestCaseGroup extraTests
uint nSeconds
 Duration of multi-threaded test.
std::vector< int > threadCounts
 Number of threads to run for each type of operation.

Static Protected Attributes

static bool runAll
 Run all test cases, including the extra tests.
static std::string runSingle
 Run only the test case of this name.

Detailed Description

PagingTestBase is a common base for multi-threaded tests which exercise cache paging.

Definition at line 41 of file PagingTestBase.h.

Member Enumeration Documentation

enum PagingTestBase::OpType

The various operations that can be run in the multi-threaded test.

Enumerator:
OP_READ_SEQ 
OP_WRITE_SEQ 
OP_READ_RAND 
OP_WRITE_RAND 
OP_READ_NOWAIT 
OP_WRITE_NOWAIT 
OP_WRITE_SKIP 
OP_SCRATCH 
OP_PREFETCH 
OP_PREFETCH_BATCH 
OP_ALLOCATE 
OP_DEALLOCATE 
OP_CHECKPOINT 
OP_RESIZE_CACHE 
OP_MAX 

Definition at line 83 of file PagingTestBase.h.

00083                 {
00084         OP_READ_SEQ,
00085         OP_WRITE_SEQ,
00086         OP_READ_RAND,
00087         OP_WRITE_RAND,
00088         OP_READ_NOWAIT,
00089         OP_WRITE_NOWAIT,
00090         OP_WRITE_SKIP,
00091         OP_SCRATCH,
00092         OP_PREFETCH,
00093         OP_PREFETCH_BATCH,
00094         OP_ALLOCATE,
00095         OP_DEALLOCATE,
00096         OP_CHECKPOINT,
00097         OP_RESIZE_CACHE,
00098         OP_MAX
00099     };

enum CacheTestBase::VictimPolicy [protected, inherited]

The available victim policy implementations.

Enumerator:
victimTwoQ 
victimLRU 
victimRandom 

Definition at line 44 of file CacheTestBase.h.

00044                       {
00045         victimTwoQ,
00046         victimLRU,
00047         victimRandom
00048     };

Constructor & Destructor Documentation

PagingTestBase::PagingTestBase (  )  [explicit]

Definition at line 322 of file PagingTestBase.cpp.

References bTestResize, cbPageUsable, checkpointMutex, TestBase::configMap, ConfigMap::getIntParam(), nRandomOps, ThreadedTestBase::nSeconds, nSecondsBetweenCheckpoints, OP_ALLOCATE, OP_CHECKPOINT, OP_DEALLOCATE, OP_MAX, OP_PREFETCH, OP_PREFETCH_BATCH, OP_READ_NOWAIT, OP_READ_RAND, OP_READ_SEQ, OP_RESIZE_CACHE, OP_SCRATCH, OP_WRITE_NOWAIT, OP_WRITE_RAND, OP_WRITE_SEQ, OP_WRITE_SKIP, SXMutex::SCHEDULE_FAVOR_EXCLUSIVE, SXMutex::setSchedulingPolicy(), ThreadedTestBase::threadCounts, and threadInit().

00323 {
00324     nRandomOps = configMap.getIntParam("randomOps",5000);
00325     nSecondsBetweenCheckpoints = configMap.getIntParam("checkpointInterval",20);
00326     bTestResize = configMap.getIntParam("resizeCache",1);
00327     checkpointMutex.setSchedulingPolicy(SXMutex::SCHEDULE_FAVOR_EXCLUSIVE);
00328 
00329     threadCounts.resize(OP_MAX,-1);
00330 
00331     threadCounts[OP_READ_SEQ] = configMap.getIntParam(
00332         "readSeqThreads",-1);
00333     threadCounts[OP_WRITE_SEQ] = configMap.getIntParam(
00334         "writeSeqThreads",-1);
00335     threadCounts[OP_READ_RAND] = configMap.getIntParam(
00336         "readRandThreads",-1);
00337     threadCounts[OP_WRITE_RAND] = configMap.getIntParam(
00338         "writeRandThreads",-1);
00339     threadCounts[OP_READ_NOWAIT] = configMap.getIntParam(
00340         "readNoWaitThreads",-1);
00341     threadCounts[OP_WRITE_NOWAIT] = configMap.getIntParam(
00342         "writeNoWaitThreads",-1);
00343     threadCounts[OP_WRITE_SKIP] = configMap.getIntParam(
00344         "writeSkipThreads",-1);
00345     threadCounts[OP_SCRATCH] = configMap.getIntParam(
00346         "scratchThreads",-1);
00347     threadCounts[OP_PREFETCH] = configMap.getIntParam(
00348         "prefetchThreads",-1);
00349     threadCounts[OP_PREFETCH_BATCH] = configMap.getIntParam(
00350         "prefetchBatchThreads",-1);
00351     threadCounts[OP_ALLOCATE] = configMap.getIntParam(
00352         "allocateThreads",-1);
00353     threadCounts[OP_DEALLOCATE] = configMap.getIntParam(
00354         "deallocateThreads",-1);
00355 
00356     if (nSecondsBetweenCheckpoints < nSeconds) {
00357         threadCounts[OP_CHECKPOINT] = 1;
00358     } else {
00359         threadCounts[OP_CHECKPOINT] = 0;
00360     }
00361 
00362     if (bTestResize) {
00363         threadCounts[OP_RESIZE_CACHE] = 1;
00364     } else {
00365         threadCounts[OP_RESIZE_CACHE] = 0;
00366     }
00367 
00368     cbPageUsable = 0;
00369 
00370     threadInit();
00371 }

PagingTestBase::~PagingTestBase (  )  [virtual]

Definition at line 373 of file PagingTestBase.cpp.

References threadTerminate().

00374 {
00375     threadTerminate();
00376 }

Member Function Documentation

uint PagingTestBase::generateRandomNumber ( uint  iMax  )  [protected]

Definition at line 53 of file PagingTestBase.cpp.

References g_pRNG.

Referenced by fillPage(), SegmentTestBase::testDeallocate(), testPrefetch(), testPrefetchBatch(), testRandomOp(), and testScratch().

00054 {
00055     return (*g_pRNG)(iMax);
00056 }

void PagingTestBase::fillPage ( CachePage &  page,
uint  x 
) [virtual]

Scribbles on the contents of a page.

The data written is derived from the parameter x.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 58 of file PagingTestBase.cpp.

References cbPageUsable, generateRandomNumber(), and CachePage::getWritableData().

Referenced by VersionedSegmentTest::fillPage(), SnapshotSegmentTestBase::fillPage(), SegmentTestBase::lockPage(), testOp(), and testScratch().

00059 {
00060     uint *p = reinterpret_cast<uint *>(page.getWritableData());
00061     assert(cbPageUsable);
00062     uint n = cbPageUsable / sizeof(uint);
00063     for (uint i = 0; i < n; i++) {
00064         p[i] = x + i;
00065     }
00066     uint r = generateRandomNumber(n);
00067     p[r] = 0;
00068 }

void PagingTestBase::verifyPage ( CachePage &  page,
uint  x 
) [virtual]

Verifies that the page contents are correct (based on the parameter x).

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 70 of file PagingTestBase.cpp.

References cbPageUsable, and CachePage::getReadableData().

Referenced by testOp(), VersionedSegmentTest::verifyPage(), and SnapshotSegmentTestBase::verifyPage().

00071 {
00072     uint const *p = reinterpret_cast<uint const *>(page.getReadableData());
00073     assert(cbPageUsable);
00074     uint n = cbPageUsable / sizeof(uint);
00075     uint nZeros = 0;
00076     for (uint i = 0; i < n; i++) {
00077         if (p[i] != x + i) {
00078             assert(!p[i]);
00079             nZeros++;
00080         }
00081     }
00082     assert(nZeros < 2);
00083 }

virtual CachePage* PagingTestBase::lockPage ( OpType  opType,
uint  iPage 
) [pure virtual]

Implemented in CacheTest, and SegmentTestBase.

Referenced by testOp().

virtual void PagingTestBase::unlockPage ( CachePage &  page,
LockMode  lockMode 
) [pure virtual]

Implemented in CacheTest, and SegmentTestBase.

Referenced by testOp().

virtual void PagingTestBase::prefetchPage ( uint  iPage  )  [pure virtual]

Implemented in CacheTest, and SegmentTestBase.

Referenced by testPrefetch().

virtual void PagingTestBase::prefetchBatch ( uint  iPage,
uint  nPagesPerBatch 
) [pure virtual]

Implemented in CacheTest, and SegmentTestBase.

Referenced by testPrefetchBatch().

bool PagingTestBase::testOp ( OpType  opType,
uint  iPage,
bool  bNice 
)

Carries out one operation on a page.

This involves locking the page, calling verifyPage or fillPage, and then unlocking the page.

Parameters:
opType operation which will be attempted
iPage block number of page
bNice true if page should be marked as nice as part of access
Returns:
true if the operation was successfully carried out; false if NoWait locking was requested and the page lock could not be acquired

Definition at line 85 of file PagingTestBase.cpp.

References fillPage(), CacheTestBase::getCache(), getLockMode(), LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, LOCKMODE_X_NOWAIT, lockPage(), CacheAccessor::nicePage(), unlockPage(), and verifyPage().

Referenced by testRandomOp(), testSequentialOp(), and testSkipOp().

00086 {
00087     CachePage *pPage = lockPage(opType,iPage);
00088     LockMode lockMode = getLockMode(opType);
00089     if (!pPage) {
00090         // must be NoWait locking failed
00091         assert(lockMode >= LOCKMODE_S_NOWAIT);
00092         return false;
00093     }
00094     CachePage &page = *pPage;
00095     if (lockMode == LOCKMODE_S
00096         || lockMode == LOCKMODE_S_NOWAIT)
00097     {
00098         verifyPage(page,iPage);
00099     } else {
00100         fillPage(page,iPage);
00101     }
00102     switch (lockMode) {
00103     case LOCKMODE_X_NOWAIT:
00104         lockMode = LOCKMODE_X;
00105         break;
00106     case LOCKMODE_S_NOWAIT:
00107         lockMode = LOCKMODE_S;
00108         break;
00109     default:
00110         break;
00111     }
00112     if (bNice) {
00113         getCache().nicePage(page);
00114     }
00115     unlockPage(page,lockMode);
00116     return true;
00117 }

char const * PagingTestBase::getOpName ( OpType  opType  ) 

Makes up an operation name based on an OpType.

Definition at line 119 of file PagingTestBase.cpp.

References OP_ALLOCATE, OP_READ_NOWAIT, OP_READ_RAND, OP_READ_SEQ, OP_WRITE_NOWAIT, OP_WRITE_RAND, OP_WRITE_SEQ, and OP_WRITE_SKIP.

Referenced by testRandomOp(), testSequentialOp(), and testSkipOp().

00120 {
00121     switch (opType) {
00122     case OP_ALLOCATE:
00123         return "allocate";
00124     case OP_READ_SEQ:
00125         return "sequential read";
00126     case OP_WRITE_SEQ:
00127         return "sequential write";
00128     case OP_READ_RAND:
00129         return "random read";
00130     case OP_WRITE_RAND:
00131         return "random write";
00132     case OP_READ_NOWAIT:
00133         return "read no-wait";
00134     case OP_WRITE_NOWAIT:
00135         return "write no-wait";
00136     case OP_WRITE_SKIP:
00137         return "write every n pages";
00138     default:
00139         permAssert(false);
00140     }
00141 }

LockMode PagingTestBase::getLockMode ( OpType  opType  ) 

Gets the LockMode corresponding to an OpType.

Definition at line 143 of file PagingTestBase.cpp.

References LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, LOCKMODE_X_NOWAIT, OP_ALLOCATE, OP_READ_NOWAIT, OP_READ_RAND, OP_READ_SEQ, OP_WRITE_NOWAIT, OP_WRITE_RAND, OP_WRITE_SEQ, and OP_WRITE_SKIP.

Referenced by SegmentTestBase::lockPage(), CacheTest::lockPage(), and testOp().

00144 {
00145     switch (opType) {
00146     case OP_ALLOCATE:
00147         return LOCKMODE_X;
00148     case OP_READ_SEQ:
00149         return LOCKMODE_S;
00150     case OP_WRITE_SEQ:
00151         return LOCKMODE_X;
00152     case OP_READ_RAND:
00153         return LOCKMODE_S;
00154     case OP_WRITE_RAND:
00155         return LOCKMODE_X;
00156     case OP_READ_NOWAIT:
00157         return LOCKMODE_S_NOWAIT;
00158     case OP_WRITE_NOWAIT:
00159         return LOCKMODE_X_NOWAIT;
00160     case OP_WRITE_SKIP:
00161         return LOCKMODE_X;
00162     default:
00163         permAssert(false);
00164     }
00165 }

void PagingTestBase::testSequentialOp ( OpType  opType  ) 

Carries out an operation on each disk page in order from 0 to nDiskPages-1.

Parameters:
opType see testOp

Definition at line 167 of file PagingTestBase.cpp.

References getOpName(), logMutex, CacheTestBase::nDiskPages, and testOp().

Referenced by testAllocateAll(), testSequentialRead(), testSequentialWrite(), and testThreadedOp().

00168 {
00169     uint n = 0;
00170     for (uint i = 0; i < nDiskPages; i++) {
00171         if (testOp(opType,i,true)) {
00172             n++;
00173         }
00174     }
00175     StrictMutexGuard mutexGuard(logMutex);
00176     BOOST_MESSAGE(
00177         "completed " << n << " " << getOpName(opType) << " ops");
00178 }

void PagingTestBase::testRandomOp ( OpType  opType  ) 

Carries out an operation on nRandomOps pages selected at random.

Parameters:
opType see testOp

Definition at line 180 of file PagingTestBase.cpp.

References generateRandomNumber(), getOpName(), logMutex, CacheTestBase::nDiskPages, nRandomOps, and testOp().

Referenced by testRandomRead(), testRandomWrite(), and testThreadedOp().

00181 {
00182     uint n = 0;
00183     for (uint i = 0; i < nRandomOps; i++) {
00184         uint iPage = generateRandomNumber(nDiskPages);
00185         bool bNice = (generateRandomNumber(nRandomOps) == 0);
00186         if (testOp(opType,iPage,bNice)) {
00187             n++;
00188         }
00189     }
00190     StrictMutexGuard mutexGuard(logMutex);
00191     BOOST_MESSAGE(
00192         "completed " << n << " " << getOpName(opType) << " ops");
00193 
00194 }

void PagingTestBase::testSkipOp ( OpType  opType,
uint  n 
)

Carries out an operation on every "n" pages, starting at page 0.

Parameters:
opType see testOp
n the offset between each page

Definition at line 196 of file PagingTestBase.cpp.

References getOpName(), logMutex, CacheTestBase::nDiskPages, and testOp().

Referenced by testSkipWrite(), and testThreadedOp().

00197 {
00198     uint numOps = 0;
00199     for (uint i = 0; i < nDiskPages; i += n) {
00200         if (testOp(opType,i,true)) {
00201             numOps++;
00202         }
00203     }
00204     StrictMutexGuard mutexGuard(logMutex);
00205     BOOST_MESSAGE(
00206         "completed " << numOps << " " << getOpName(opType) << " ops");
00207 }

void PagingTestBase::testScratch (  ) 

Performs nRandomOps scratch operations.

A scratch operation consists of locking a scratch page, filling it with random data, and then unlocking it.

Definition at line 209 of file PagingTestBase.cpp.

References fillPage(), generateRandomNumber(), CacheTestBase::getCache(), LOCKMODE_X, logMutex, nRandomOps, and CacheAccessor::unlockPage().

Referenced by CacheTest::testSingleThread(), and testThreadedOp().

00210 {
00211     for (uint i = 0; i < nRandomOps; i++) {
00212         CachePage &page = getCache().lockScratchPage();
00213         fillPage(page,generateRandomNumber(10000));
00214         getCache().unlockPage(page,LOCKMODE_X);
00215     }
00216     StrictMutexGuard mutexGuard(logMutex);
00217     BOOST_MESSAGE("completed " << nRandomOps << " random scratch ops");
00218 }

void PagingTestBase::testPrefetch (  ) 

Performs a limited number of prefetch operations.

Prefetches are not verified.

Definition at line 220 of file PagingTestBase.cpp.

References generateRandomNumber(), logMutex, CacheTestBase::nDiskPages, prefetchPage(), and TestBase::snooze().

Referenced by testThreadedOp().

00221 {
00222     // TODO: parameterize this
00223     uint n = 3;
00224     for (uint i = 0; i < n; i++) {
00225         uint iPage = generateRandomNumber(nDiskPages);
00226         prefetchPage(iPage);
00227     }
00228     // give the prefetches a chance to complete
00229     snooze(1);
00230     StrictMutexGuard mutexGuard(logMutex);
00231     BOOST_MESSAGE("completed " << n << " random prefetch ops");
00232 }

void PagingTestBase::testPrefetchBatch (  ) 

Performs a limited number of batch prefetch operations.

Prefetches are not verified.

Definition at line 234 of file PagingTestBase.cpp.

References generateRandomNumber(), logMutex, CacheTestBase::nDiskPages, prefetchBatch(), and TestBase::snooze().

Referenced by testThreadedOp().

00235 {
00236     // TODO: parameterize this
00237     uint n = 2;
00238     uint nPagesPerBatch = 4;
00239     for (uint i = 0; i < n; i++) {
00240         uint iPage = generateRandomNumber(nDiskPages - nPagesPerBatch);
00241         prefetchBatch(iPage,nPagesPerBatch);
00242     }
00243     // give the prefetches a chance to complete
00244     snooze(1);
00245     StrictMutexGuard mutexGuard(logMutex);
00246     BOOST_MESSAGE("completed " << n << " random prefetch batch ops");
00247 }

void PagingTestBase::testCheckpoint (  )  [virtual]

Performs a periodic checkpoint.

Reimplemented in SegmentTestBase, and VersionedSegmentTest.

Definition at line 289 of file PagingTestBase.cpp.

References CHECKPOINT_FLUSH_ALL, Cache::checkpointPages(), CacheTestBase::dataDeviceId, and CacheTestBase::getCache().

Referenced by testCheckpointGuarded().

00290 {
00291     DeviceIdPagePredicate pagePredicate(dataDeviceId);
00292     getCache().checkpointPages(pagePredicate,CHECKPOINT_FLUSH_ALL);
00293 }

void PagingTestBase::testAllocateAll (  )  [virtual]

Initializes all disk pages, filling them with information based on their block numbers.

Reimplemented in LinearViewSegmentTest, and SnapshotSegmentTestBase.

Definition at line 249 of file PagingTestBase.cpp.

References OP_ALLOCATE, and testSequentialOp().

Referenced by SnapshotSegmentTestBase::testAllocateAll(), LinearViewSegmentTest::testAllocateAll(), testMultipleThreads(), SegmentTestBase::testSingleThread(), and CacheTest::testSingleThread().

00250 {
00251     testSequentialOp(OP_ALLOCATE);
00252 }

void PagingTestBase::testSequentialRead (  ) 

Carries out one sequential read pass over the entire device.

Definition at line 254 of file PagingTestBase.cpp.

References OP_READ_SEQ, and testSequentialOp().

Referenced by SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTest::testDeallocateOld(), VersionedSegmentTest::testRecovery(), SnapshotSegmentTest::testRollback(), SegmentTestBase::testSingleThread(), CacheTest::testSingleThread(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and BackupRestoreTest::verifyData().

00255 {
00256     testSequentialOp(OP_READ_SEQ);
00257 }

void PagingTestBase::testSequentialWrite (  ) 

Carries out one sequential write pass over the entire device.

Definition at line 259 of file PagingTestBase.cpp.

References OP_WRITE_SEQ, and testSequentialOp().

Referenced by SegmentTestBase::testSingleThread(), and CacheTest::testSingleThread().

00260 {
00261     testSequentialOp(OP_WRITE_SEQ);
00262 }

void PagingTestBase::testRandomRead (  ) 

Carries out nRandomOps read operations on pages selected at random.

Definition at line 264 of file PagingTestBase.cpp.

References OP_READ_RAND, and testRandomOp().

Referenced by SegmentTestBase::testSingleThread(), and CacheTest::testSingleThread().

00265 {
00266     testRandomOp(OP_READ_RAND);
00267 }

void PagingTestBase::testRandomWrite (  ) 

Carries out nRandomOps write operations on pages selected at random.

Definition at line 269 of file PagingTestBase.cpp.

References OP_WRITE_RAND, and testRandomOp().

Referenced by SegmentTestBase::testSingleThread(), and CacheTest::testSingleThread().

00270 {
00271     testRandomOp(OP_WRITE_RAND);
00272 }

void PagingTestBase::testSkipWrite ( uint  n  ) 

Carries out write operations every n pages.

Parameters:
n offset between pages

Definition at line 274 of file PagingTestBase.cpp.

References OP_WRITE_SKIP, and testSkipOp().

Referenced by BackupRestoreTest::testBackupRestore(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testRollback(), SnapshotSegmentTest::testSnapshotReads(), and SnapshotSegmentTest::testUncommittedReads().

00275 {
00276     testSkipOp(OP_WRITE_SKIP, n);
00277 }

void PagingTestBase::testAllocate (  )  [virtual]

Reimplemented in SegmentTestBase.

Definition at line 279 of file PagingTestBase.cpp.

Referenced by testThreadedOp().

00280 {
00281     permAssert(false);
00282 }

void PagingTestBase::testDeallocate (  )  [virtual]

Reimplemented in SegmentTestBase.

Definition at line 284 of file PagingTestBase.cpp.

Referenced by testThreadedOp().

00285 {
00286     permAssert(false);
00287 }

void PagingTestBase::testCheckpointGuarded (  ) 

Definition at line 295 of file PagingTestBase.cpp.

References checkpointMutex, logMutex, nSecondsBetweenCheckpoints, TestBase::snooze(), testCheckpoint(), and SXMutexGuard< lockMode >::unlock().

Referenced by testThreadedOp().

00296 {
00297     snooze(nSecondsBetweenCheckpoints);
00298     StrictMutexGuard logGuard(logMutex);
00299     BOOST_MESSAGE("checkpoint started");
00300     logGuard.unlock();
00301     SXMutexExclusiveGuard checkpointExclusiveGuard(checkpointMutex);
00302     testCheckpoint();
00303     checkpointExclusiveGuard.unlock();
00304     logGuard.lock();
00305     BOOST_MESSAGE("checkpoint completed");
00306 }

void PagingTestBase::testCacheResize (  ) 

Definition at line 308 of file PagingTestBase.cpp.

References CacheTestBase::getCache(), logMutex, CacheTestBase::nMemPages, ThreadedTestBase::nSeconds, Cache::setAllocatedPageCount(), and TestBase::snooze().

Referenced by testThreadedOp().

00309 {
00310     snooze(nSeconds / 3);
00311     getCache().setAllocatedPageCount(nMemPages / 2);
00312     StrictMutexGuard mutexGuard(logMutex);
00313     BOOST_MESSAGE("shrank cache");
00314     mutexGuard.unlock();
00315     snooze(nSeconds / 3);
00316     getCache().setAllocatedPageCount(nMemPages - 1);
00317     mutexGuard.lock();
00318     BOOST_MESSAGE("expanded cache");
00319     mutexGuard.unlock();
00320 }

void PagingTestBase::testMultipleThreads (  ) 

Carries out specified tests in multi-threaded mode.

Definition at line 431 of file PagingTestBase.cpp.

References DeviceMode::createNew, CacheTestBase::openStorage(), ThreadedTestBase::runThreadedTestCase(), and testAllocateAll().

Referenced by CacheTest::CacheTest(), LinearDeviceSegmentTest::LinearDeviceSegmentTest(), LinearViewSegmentTest::LinearViewSegmentTest(), SnapshotSegmentTest::SnapshotSegmentTest(), and VersionedSegmentTest::VersionedSegmentTest().

00432 {
00433     openStorage(DeviceMode::createNew);
00434     testAllocateAll();
00435     runThreadedTestCase();
00436 }

void PagingTestBase::threadInit (  )  [virtual]

Reimplemented from ThreadedTestBase.

Definition at line 41 of file PagingTestBase.cpp.

References g_pRNG, and ThreadedTestBase::threadInit().

Referenced by PagingTestBase().

00042 {
00043     ThreadedTestBase::threadInit();
00044     g_pRNG.reset(new std::subtractive_rng());
00045 }

void PagingTestBase::threadTerminate (  )  [virtual]

Reimplemented from ThreadedTestBase.

Definition at line 47 of file PagingTestBase.cpp.

References g_pRNG, and ThreadedTestBase::threadTerminate().

Referenced by ~PagingTestBase().

00048 {
00049     g_pRNG.reset();
00050     ThreadedTestBase::threadTerminate();
00051 }

bool PagingTestBase::testThreadedOp ( int  iOp  )  [virtual]

Test implementation must be supplied by derived test class.

Parameters:
iOp operation type to test
Returns:
true if test should run again

Implements ThreadedTestBase.

Definition at line 378 of file PagingTestBase.cpp.

References checkpointMutex, SXMutexGuard< lockMode >::lock(), OP_ALLOCATE, OP_CHECKPOINT, OP_DEALLOCATE, OP_MAX, OP_PREFETCH, OP_PREFETCH_BATCH, OP_READ_NOWAIT, OP_READ_RAND, OP_READ_SEQ, OP_RESIZE_CACHE, OP_SCRATCH, OP_WRITE_NOWAIT, OP_WRITE_RAND, OP_WRITE_SEQ, OP_WRITE_SKIP, testAllocate(), testCacheResize(), testCheckpointGuarded(), testDeallocate(), testPrefetch(), testPrefetchBatch(), testRandomOp(), testScratch(), testSequentialOp(), and testSkipOp().

00379 {
00380     SXMutexSharedGuard checkpointSharedGuard(checkpointMutex,false);
00381     assert(iOp < OP_MAX);
00382     OpType op = static_cast<OpType>(iOp);
00383     switch (op) {
00384     case PagingTestBase::OP_WRITE_SEQ:
00385         checkpointSharedGuard.lock();
00386         // fall through
00387     case PagingTestBase::OP_READ_SEQ:
00388         testSequentialOp(op);
00389         break;
00390     case PagingTestBase::OP_WRITE_RAND:
00391     case PagingTestBase::OP_WRITE_NOWAIT:
00392         checkpointSharedGuard.lock();
00393         // fall through
00394     case PagingTestBase::OP_READ_RAND:
00395     case PagingTestBase::OP_READ_NOWAIT:
00396         testRandomOp(op);
00397         break;
00398     case PagingTestBase::OP_WRITE_SKIP:
00399         checkpointSharedGuard.lock();
00400         testSkipOp(op, 5);
00401         break;
00402     case PagingTestBase::OP_SCRATCH:
00403         testScratch();
00404         break;
00405     case PagingTestBase::OP_PREFETCH:
00406         testPrefetch();
00407         break;
00408     case PagingTestBase::OP_PREFETCH_BATCH:
00409         testPrefetchBatch();
00410         break;
00411     case PagingTestBase::OP_ALLOCATE:
00412         checkpointSharedGuard.lock();
00413         testAllocate();
00414         break;
00415     case PagingTestBase::OP_DEALLOCATE:
00416         checkpointSharedGuard.lock();
00417         testDeallocate();
00418         break;
00419     case PagingTestBase::OP_CHECKPOINT:
00420         testCheckpointGuarded();
00421         break;
00422     case PagingTestBase::OP_RESIZE_CACHE:
00423         testCacheResize();
00424         return false;
00425     default:
00426         permAssert(false);
00427     }
00428     return true;
00429 }

Cache & CacheTestBase::getCache (  )  [inherited]

Definition at line 42 of file CacheTestBase.cpp.

References CacheTestBase::pCache.

Referenced by CacheTest::lockPage(), CacheTest::prefetchBatch(), SegmentTestBase::prefetchPage(), CacheTest::prefetchPage(), testCacheResize(), testCheckpoint(), testOp(), testScratch(), SegmentTestBase::unlockPage(), and CacheTest::unlockPage().

00043 {
00044     return *pCache;
00045 }

SharedCache CacheTestBase::newCache (  )  [virtual, inherited]

Definition at line 66 of file CacheTestBase.cpp.

References CacheTestBase::cacheParams, Cache::newCache(), CacheTestBase::victimLRU, CacheTestBase::victimPolicy, CacheTestBase::victimRandom, and CacheTestBase::victimTwoQ.

Referenced by CacheTestBase::openStorage().

00067 {
00068     switch (victimPolicy) {
00069     case victimRandom:
00070         return SharedCache(
00071             new RandomCache(cacheParams),
00072             ClosableObjectDestructor());
00073     case victimLRU:
00074         return SharedCache(
00075             new LRUCache(cacheParams),
00076             ClosableObjectDestructor());
00077     case victimTwoQ:
00078         return Cache::newCache(cacheParams);
00079     default:
00080         permAssert(false);
00081     }
00082 }

SharedRandomAccessDevice CacheTestBase::openDevice ( std::string  devName,
DeviceMode  openMode,
uint  nDevicePages,
DeviceId  deviceId 
) [inherited]

Definition at line 84 of file CacheTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, CacheTestBase::pCache, and FileSystem::remove().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

00087 {
00088     if (openMode.create) {
00089         FileSystem::remove(devName.c_str());
00090     }
00091     SharedRandomAccessDevice pDevice(
00092         new RandomAccessFileDevice(devName,openMode));
00093     if (openMode.create) {
00094         pDevice->setSizeInBytes(nDevicePages*cbPageFull);
00095     }
00096     pCache->registerDevice(deviceId,pDevice);
00097     return pDevice;
00098 }

void CacheTestBase::openStorage ( DeviceMode  openMode  )  [virtual, inherited]

Reimplemented in SegmentTestBase, and SegStorageTestBase.

Definition at line 100 of file CacheTestBase.cpp.

References StatsTimer::addSource(), CacheTestBase::dataDeviceId, CacheTestBase::nDiskPages, CacheTestBase::newCache(), CacheTestBase::openDevice(), CacheTestBase::pCache, CacheTestBase::pRandomAccessDevice, StatsTimer::start(), and TestBase::statsTimer.

Referenced by SegStorageTestBase::openStorage(), testMultipleThreads(), CacheTest::testQuotaCacheAccessor(), and CacheTest::testSingleThread().

00101 {
00102     // make a test.dat filename unique to each process
00103     std::ostrstream testDataFile;
00104     testDataFile << "test-" << getpid() << ".dat" << ends;
00105 
00106     pCache = newCache();
00107 
00108     statsTimer.addSource(pCache);
00109     statsTimer.start();
00110 
00111     pRandomAccessDevice = openDevice(
00112         testDataFile.str(),openMode,nDiskPages,dataDeviceId);
00113 }

void CacheTestBase::closeStorage (  )  [virtual, inherited]

Reimplemented in SegStorageTestBase, SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 115 of file CacheTestBase.cpp.

References CacheTestBase::closeDevice(), CacheTestBase::dataDeviceId, CacheTestBase::pCache, CacheTestBase::pRandomAccessDevice, TestBase::statsTimer, and StatsTimer::stop().

Referenced by SegStorageTestBase::closeStorage(), CacheTestBase::testCaseTearDown(), CacheTest::testQuotaCacheAccessor(), and CacheTest::testSingleThread().

00116 {
00117     closeDevice(dataDeviceId,pRandomAccessDevice);
00118     statsTimer.stop();
00119     if (pCache) {
00120         assert(pCache.unique());
00121         pCache.reset();
00122     }
00123 }

void CacheTestBase::testCaseTearDown (  )  [virtual, inherited]

Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.

Default is no-op.

Reimplemented from TestBase.

Reimplemented in LbmEntryTest, LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, ExecStreamTestBase, and LhxHashTableTest.

Definition at line 125 of file CacheTestBase.cpp.

References CacheTestBase::closeStorage().

Referenced by LhxHashTableTest::testCaseTearDown(), ExecStreamTestBase::testCaseTearDown(), BTreeTest::testCaseTearDown(), BTreeReadersTest::testCaseTearDown(), and LbmEntryTest::testCaseTearDown().

00126 {
00127     closeStorage();
00128 }

void CacheTestBase::closeDevice ( DeviceId  deviceId,
SharedRandomAccessDevice &  pDevice 
) [inherited]

Definition at line 130 of file CacheTestBase.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, and CacheTestBase::pCache.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), and CacheTestBase::closeStorage().

00132 {
00133     if (!pDevice) {
00134         return;
00135     }
00136     DeviceIdPagePredicate pagePredicate(deviceId);
00137     pCache->checkpointPages(pagePredicate,CHECKPOINT_FLUSH_AND_UNMAP);
00138     pCache->unregisterDevice(deviceId);
00139     assert(pDevice.unique());
00140     pDevice.reset();
00141 }

void TestBase::snooze ( uint  nSeconds  )  [protected, inherited]

Definition at line 263 of file TestBase.cpp.

Referenced by DatabaseTest::executeForceTxn(), ThreadedTestBase::runThreadedTestCase(), testCacheResize(), BTreeTxnTest::testCheckpoint(), testCheckpointGuarded(), testPrefetch(), and testPrefetchBatch().

00264 {
00265 #ifdef __MSVC__
00266     ::_sleep(nSeconds*1000);
00267 #else
00268     ::sleep(nSeconds);
00269 #endif
00270 }

void TestBase::readParams ( int  argc,
char **  argv 
) [static, inherited]

Parses the command line.

format: [-v] [-t TEST | -all] {param=val}* [CONFIGFILE | -] Normally, the test program runs the default test cases. With the option "-all", runs the extra test cases as well. With the option "-t TEST", runs only the single test case named TEST. CONFIGFILE is read to load configuration parameters. Configuration parameters can also be set ad hoc, from the command line, as pairs name=val. These take precedence.

Definition at line 108 of file TestBase.cpp.

References TestBase::configMap, ConfigMap::dumpParams(), ConfigMap::isParamSet(), ConfigMap::mergeFrom(), TestBase::paramDictionaryFileName, ConfigMap::readParams(), TestBase::runAll, TestBase::runSingle, ConfigMap::setStringParam(), and verbose.

00109 {
00110     bool verbose = false;
00111     ConfigMap adhocMap;
00112 
00113     for (int i = 1; i < argc; ++i) {
00114         std::string arg = argv[i];
00115         if (argv[i][0] == '-') {
00116             if (arg == "-v") {
00117                 verbose = true;
00118             } else if (arg == "-") {
00119                 configMap.readParams(std::cin);
00120             } else if (arg == "-all") {
00121                 runAll = true;
00122             } else if (arg == "-t") {   // -t TEST
00123                 permAssert(i + 1 < argc);
00124                 runSingle = argv[++i];
00125             } else if (arg[1] == 't') { // allow -tTEST
00126                 runSingle = arg.substr(2);
00127             }
00128         } else {
00129             int i = arg.find("=");
00130             if ((0 < i) && (i < arg.size())) {
00131                 // an ad hoc parameter
00132                 std::string key = arg.substr(0,i);
00133                 std::string val = arg.substr(i + 1);
00134                 adhocMap.setStringParam(key,val);
00135             } else {
00136                 // a config file name
00137                 std::ifstream configFile(arg.c_str());
00138                 assert(configFile.good());
00139                 configMap.readParams(configFile);
00140             }
00141         }
00142     }
00143     configMap.mergeFrom(adhocMap);
00144 
00145     // set a default dictionary file location for use by tests that need a
00146     // small non-random sorted data set
00147     if (!configMap.isParamSet(paramDictionaryFileName)) {
00148         std::string dictFileName = "dictWords";
00149         configMap.setStringParam(paramDictionaryFileName,dictFileName);
00150     }
00151 
00152     if (verbose) {
00153         configMap.dumpParams(std::cout);
00154     }
00155 }

TestSuite * TestBase::releaseTestSuite (  )  [inherited]

Definition at line 157 of file TestBase.cpp.

References TestBase::TestCaseGroup::addAllToTestSuite(), TestBase::defaultTests, TestBase::extraTests, TestBase::TestCaseGroup::findTest(), TestBase::pTestObj, TestBase::pTestSuite, TestBase::runAll, TestBase::runSingle, and TestBase::testName.

00158 {
00159     assert(pTestObj);
00160     assert(pTestObj.use_count() > 1);
00161 
00162     // release self-reference now that all test cases have been registered
00163     pTestObj.reset();
00164 
00165     TestSuite* pTestSuite = BOOST_TEST_SUITE(testName.c_str());
00166 
00167     if (runSingle.size()) {
00168         test_unit *p =  defaultTests.findTest(runSingle);
00169         if (!p) {
00170             p = extraTests.findTest(runSingle);
00171         }
00172         if (!p) {
00173             std::cerr << "test " << runSingle << " not found\n";
00174             exit(2);
00175         }
00176         pTestSuite->add(p);
00177     } else {
00178         defaultTests.addAllToTestSuite(pTestSuite);
00179         if (runAll) {
00180             extraTests.addAllToTestSuite(pTestSuite);
00181         }
00182     }
00183     return pTestSuite;
00184 }

void TestBase::beforeTestCase ( std::string  testCaseName  )  [inherited]

Definition at line 214 of file TestBase.cpp.

References TestBase::configMap, TraceSource::initTraceSource(), AutoBacktrace::install(), TestBase::notifyTrace(), AutoBacktrace::setOutputStream(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

00215 {
00216     notifyTrace(testName,TRACE_INFO,"ENTER:  " + testCaseName);
00217 
00218     // Install the AutoBacktrace signal handler now, after
00219     // boost::execution_monitor::catch_signals() has installed its own, so that
00220     // on SIGABRT AutoBacktrace goes first, prints the backtrace, then chains
00221     // to boost, which handles the error.
00222     AutoBacktrace::setOutputStream();
00223     AutoBacktrace::setTraceTarget(shared_from_this());
00224     AutoBacktrace::install();
00225     configMap.initTraceSource(shared_from_this(), "testConfig");
00226 }

void TestBase::afterTestCase ( std::string  testCaseName  )  [inherited]

Definition at line 228 of file TestBase.cpp.

References TestBase::configMap, TraceSource::disableTracing(), TestBase::notifyTrace(), AutoBacktrace::setTraceTarget(), TestBase::testName, and TRACE_INFO.

00229 {
00230     AutoBacktrace::setTraceTarget();
00231     configMap.disableTracing();
00232     notifyTrace(testName,TRACE_INFO,"LEAVE:  " + testCaseName);
00233 }

void TestBase::testCaseSetUp (  )  [virtual, inherited]

Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.

Default is no-op.

Reimplemented in LbmEntryTest, LbmExecStreamTestBase, LbmLoadBitmapTest, LbmSearchTest, LbmSplicerExecStreamTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, BTreeReadersTest, BTreeTest, BTreeTxnTest, ExecStreamGovernorTest, ExecStreamTestBase, ExecStreamUnitTestBase, ExternalSortExecStreamTest, LhxHashTableTest, LogicalTxnTest, and SnapshotSegmentTestBase.

Definition at line 235 of file TestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

00236 {
00237 }

void TestBase::notifyTrace ( std::string  source,
TraceLevel  level,
std::string  message 
) [virtual, inherited]

Receives notification when a trace event occurs.

Parameters:
source the facility from which the message originated
level the trace event severity level
message the text of the message

Implements TraceTarget.

Definition at line 243 of file TestBase.cpp.

References TestBase::traceFile, TestBase::traceMutex, TestBase::traceStdout, and TestBase::traceStream.

Referenced by TestBase::afterTestCase(), and TestBase::beforeTestCase().

00244 {
00245     if (traceFile || traceStdout) {
00246         StrictMutexGuard traceMutexGuard(traceMutex);
00247         if (traceFile) {
00248             traceStream << "[" << source << "] " << message << std::endl;
00249             traceStream.flush();
00250         }
00251         if (traceStdout) {
00252             std::cout << "[" << source << "] " << message << std::endl;
00253             std::cout.flush();
00254         }
00255     }
00256 }

TraceLevel TestBase::getSourceTraceLevel ( std::string  source  )  [virtual, inherited]

Gets the level at which a particular source should be traced.

Parameters:
source name of source to be traced
Returns:
minimum severity level which should be traced

Implements TraceTarget.

Definition at line 258 of file TestBase.cpp.

References TestBase::traceLevel.

Referenced by LbmExecStreamTestBase::generateBitmaps().

00259 {
00260     return traceLevel;
00261 }

void ThreadedTestBase::runThreadedTestCase (  )  [protected, inherited]

Executes specified test threads.

Definition at line 43 of file ThreadedTestBase.cpp.

References ThreadedTestBase::bDone, ThreadedTestBase::defaultThreadCount, ThreadedTestBase::nSeconds, ThreadedTestBase::pStartBarrier, TestBase::snooze(), ThreadPoolBase::start(), ThreadPoolBase::stop(), ThreadPool< Task >::submitTask(), and ThreadedTestBase::threadCounts.

Referenced by testMultipleThreads(), and BTreeTxnTest::testTxns().

00044 {
00045     bDone = false;
00046 
00047     // materialize default thread counts
00048     std::replace_if(
00049         threadCounts.begin(),
00050         threadCounts.end(),
00051         std::bind2nd(std::equal_to<int>(),-1),
00052         defaultThreadCount);
00053 
00054     // calculate how many threads are needed
00055     int nThreads = std::accumulate(
00056         threadCounts.begin(),
00057         threadCounts.end(),
00058         0);
00059 
00060     // initialize a barrier to make sure they all start at once
00061     pStartBarrier.reset(new boost::barrier(nThreads));
00062 
00063     // fire 'em up
00064     ThreadPool<ThreadedTestBaseTask> threadPool;
00065     threadPool.start(nThreads);
00066 
00067     // and distribute the tasks
00068     for (uint i = 0; i < threadCounts.size(); ++i) {
00069         for (int j = 0; j < threadCounts[i]; ++j) {
00070             ThreadedTestBaseTask task(*this,i);
00071             threadPool.submitTask(task);
00072         }
00073     }
00074 
00075     // run the tests for the requested duration
00076     snooze(nSeconds);
00077 
00078     // tell threads to quit and then wait for them to finish up
00079     bDone = true;
00080     threadPool.stop();
00081 }

Member Data Documentation

uint PagingTestBase::cbPageUsable [protected]

Portion of each page that should be scribbled on.

Definition at line 49 of file PagingTestBase.h.

Referenced by CacheTest::CacheTest(), fillPage(), SegmentTestBase::openStorage(), PagingTestBase(), and verifyPage().

uint PagingTestBase::nRandomOps [protected]

Number of random access operations to run per pass.

Definition at line 54 of file PagingTestBase.h.

Referenced by PagingTestBase(), SegmentTestBase::testAllocate(), SegmentTestBase::testDeallocate(), testRandomOp(), and testScratch().

uint PagingTestBase::nSecondsBetweenCheckpoints [protected]

Checkpoint interval during multi-threaded test.

Definition at line 59 of file PagingTestBase.h.

Referenced by PagingTestBase(), and testCheckpointGuarded().

StrictMutex PagingTestBase::logMutex [protected]

Protects output stream.

Definition at line 64 of file PagingTestBase.h.

Referenced by SegmentTestBase::testAllocate(), testCacheResize(), testCheckpointGuarded(), SegmentTestBase::testDeallocate(), testPrefetch(), testPrefetchBatch(), testRandomOp(), testScratch(), testSequentialOp(), and testSkipOp().

SXMutex PagingTestBase::checkpointMutex [protected]

SXMutex used to synchronize checkpoints with write actions.

Definition at line 69 of file PagingTestBase.h.

Referenced by PagingTestBase(), testCheckpointGuarded(), and testThreadedOp().

bool PagingTestBase::bTestResize [protected]

Flag indicating that the cache should be dynamically resized during the multi-threaded portion of the test.

Definition at line 75 of file PagingTestBase.h.

Referenced by PagingTestBase().

VictimPolicy CacheTestBase::victimPolicy [protected, inherited]

VictimPolicy to instantiate.

Definition at line 53 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), and CacheTestBase::newCache().

CacheParams CacheTestBase::cacheParams [protected, inherited]

Parameters for cache initialization.

Definition at line 58 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::newCache(), BackupRestoreTest::testBackupCleanup(), BackupRestoreTest::testHeaderBackupRestore(), and SegPageEntryIterTest::testIter().

SharedCache CacheTestBase::pCache [protected, inherited]

Cache instance being tested.

Definition at line 63 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeDevice(), CacheTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), BackupRestoreTest::createSnapshotData(), BackupRestoreTest::executeSnapshotTxn(), CacheTestBase::getCache(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), LcsClusterReplaceExecStreamTest::replaceCluster(), BackupRestoreTest::restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupCleanup(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), BackupRestoreTest::testHeaderBackupRestore(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), CacheTest::testLargeCacheInit(), CacheTest::testLargeCacheRequest(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), SegStreamTest::testMarkReset(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), CacheTest::testQuotaCacheAccessor(), BTreeReadersTest::testReaders(), SegStreamTest::testReadSeg(), BTreeTest::testScan(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), LogicalTxnTest::testTxnIdSequence(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSeg(), SegStreamTest::testWriteSpillAndRead(), LbmEntryTest::testZeroBytes(), and BackupRestoreTest::verifySnapshotData().

SharedRandomAccessDevice CacheTestBase::pRandomAccessDevice [protected, inherited]

The default cached device.

Definition at line 68 of file CacheTestBase.h.

Referenced by BackupRestoreTest::backup(), CacheTestBase::closeStorage(), SegStorageTestBase::openSegmentStorage(), CacheTestBase::openStorage(), and BackupRestoreTest::restore().

uint CacheTestBase::nMemPages [protected, inherited]

Size of cache in memory pages.

Definition at line 73 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), testCacheResize(), and ExecStreamTestBase::testCaseSetUp().

uint CacheTestBase::nDiskPages [protected, inherited]

Size of device in disk pages.

Definition at line 78 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), LinearViewSegmentTest::LinearViewSegmentTest(), CacheTest::makeBlockId(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), SegStreamTest::SegStreamTest(), SnapshotSegmentTestBase::SnapshotSegmentTestBase(), SnapshotSegmentTest::testDeallocateOld(), testPrefetch(), testPrefetchBatch(), testRandomOp(), SnapshotSegmentTest::testRollback(), testSequentialOp(), and testSkipOp().

uint CacheTestBase::cbPageFull [protected, inherited]

Disk page size.

Definition at line 83 of file CacheTestBase.h.

Referenced by CacheTest::CacheTest(), CacheTestBase::CacheTestBase(), CacheTestBase::openDevice(), and SegStorageTestBase::openSegmentStorage().

DeviceId CacheTestBase::dataDeviceId [protected, inherited]

Fixed ID to assign to data device.

Definition at line 88 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), CacheTestBase::closeStorage(), CacheTest::makeBlockId(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), CacheTestBase::openStorage(), and testCheckpoint().

TestSuite* TestBase::pTestSuite [protected, inherited]

Boost test suite.

Definition at line 59 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

boost::shared_ptr<TestBase> TestBase::pTestObj [protected, inherited]

Definition at line 61 of file TestBase.h.

Referenced by TestBase::releaseTestSuite(), and TestBase::TestBase().

std::ofstream TestBase::traceStream [protected, inherited]

Output file stream for tracing.

Definition at line 66 of file TestBase.h.

Referenced by TestBase::notifyTrace(), TestBase::TestBase(), and TestBase::~TestBase().

StrictMutex TestBase::traceMutex [protected, inherited]

Protects traceStream.

Definition at line 71 of file TestBase.h.

Referenced by TestBase::notifyTrace().

std::string TestBase::testName [protected, inherited]

Name of test.

Definition at line 76 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), TestBase::releaseTestSuite(), TestBase::TestBase(), LhxHashTableTest::testInsert1Ka(), and LhxHashTableTest::testInsert1Kb().

TraceLevel TestBase::traceLevel [protected, inherited]

Level at which to trace test execution.

Definition at line 81 of file TestBase.h.

Referenced by TestBase::getSourceTraceLevel(), and TestBase::TestBase().

FileStatsTarget TestBase::statsTarget [protected, inherited]

Output for stats.

Definition at line 86 of file TestBase.h.

StatsTimer TestBase::statsTimer [protected, inherited]

Timer for stats collection.

Definition at line 91 of file TestBase.h.

Referenced by CacheTestBase::closeStorage(), CacheTestBase::openStorage(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCaseTearDown(), and BTreeTxnTest::testTxns().

bool TestBase::traceStdout [protected, inherited]

Copy trace output to stdout.

Definition at line 99 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::traceFile [protected, inherited]

Copy trace output to file.

Definition at line 104 of file TestBase.h.

Referenced by TestBase::notifyTrace(), and TestBase::TestBase().

bool TestBase::runAll [static, protected, inherited]

Run all test cases, including the extra tests.

(static, since set by readParams())

Definition at line 110 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

std::string TestBase::runSingle [static, protected, inherited]

Run only the test case of this name.

(static, since set by readParams())

Definition at line 116 of file TestBase.h.

Referenced by TestBase::readParams(), and TestBase::releaseTestSuite().

TestCaseGroup TestBase::defaultTests [protected, inherited]

Definition at line 139 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

TestCaseGroup TestBase::extraTests [protected, inherited]

Definition at line 140 of file TestBase.h.

Referenced by TestBase::releaseTestSuite().

ParamName TestBase::paramTestSuiteName [static, inherited]

Definition at line 143 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramTraceFileName [static, inherited]

Definition at line 144 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDictionaryFileName [static, inherited]

Definition at line 145 of file TestBase.h.

Referenced by TestBase::readParams(), SegStreamTest::testRead(), and SegStreamTest::testWrite().

ParamName TestBase::paramTraceLevel [static, inherited]

Definition at line 146 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramStatsFileName [static, inherited]

Definition at line 147 of file TestBase.h.

ParamName TestBase::paramTraceStdout [static, inherited]

Definition at line 148 of file TestBase.h.

Referenced by TestBase::TestBase().

ParamName TestBase::paramDegreeOfParallelism [static, inherited]

Definition at line 149 of file TestBase.h.

Referenced by ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest().

ConfigMap TestBase::configMap [static, inherited]

Configuration parameters.

The reason this is static is so that no constructor parameters (which burden virtual bases) are needed.

Definition at line 155 of file TestBase.h.

Referenced by TestBase::afterTestCase(), TestBase::beforeTestCase(), BTreeTxnTest::BTreeTxnTest(), CacheTestBase::CacheTestBase(), BackupRestoreTest::createSnapshotData(), DatabaseTest::DatabaseTest(), TestOptionsTest::extra(), DatabaseTest::loadDatabase(), SparseBitmapTest::openStorage(), PagingTestBase(), ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest(), RandomAccessFileDeviceTest::RandomAccessFileDeviceTest(), TestBase::readParams(), SegStorageTestBase::SegStorageTestBase(), TestOptionsTest::test1(), TestOptionsTest::test2(), BackupRestoreTest::testBackupCleanup(), TestBase::TestBase(), BTreeTxnTest::testCaseSetUp(), BTreeTxnTest::testCheckpoint(), DatabaseTest::testCreateEmpty(), DatabaseTest::testForceTxns(), BackupRestoreTest::testHeaderBackupRestore(), SegPageEntryIterTest::testIter(), SegStreamTest::testRead(), BTreeTxnTest::testTxns(), SegStreamTest::testWrite(), ThreadedTestBase::ThreadedTestBase(), and TestBase::~TestBase().

uint ThreadedTestBase::nSeconds [protected, inherited]

Duration of multi-threaded test.

Definition at line 65 of file ThreadedTestBase.h.

Referenced by BTreeTxnTest::BTreeTxnTest(), PagingTestBase(), ThreadedTestBase::runThreadedTestCase(), testCacheResize(), and ThreadedTestBase::ThreadedTestBase().

std::vector<int> ThreadedTestBase::threadCounts [protected, inherited]

Number of threads to run for each type of operation.

Definition at line 70 of file ThreadedTestBase.h.

Referenced by BTreeTxnTest::BTreeTxnTest(), CacheTest::CacheTest(), SegmentTestBase::openStorage(), PagingTestBase(), ThreadedTestBase::runThreadedTestCase(), and SegmentTestBase::SegmentTestBase().

The documentation for this class was generated from the following files:
Generated on Mon Jun 22 04:00:40 2009 for Fennel by  doxygen 1.5.1