LcsClusterReplaceExecStreamTest Class Reference

Test class for exercising LcsClusterReplaceExecStream. More...

Inheritance diagram for LcsClusterReplaceExecStreamTest:

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
	LcsClusterReplaceExecStreamTest ()
void	testSingleColOddNumRows ()
void	testSingleColEvenNumRows ()
void	testSingleColSeqStartAt1 ()
void	testReplaceAllRows ()
void	testReplaceNoRows ()
void	test3ColClusterReplace ()
virtual void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
virtual void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
virtual void	openRandomSegment ()
virtual void	openStorage (DeviceMode openMode)
virtual void	openSegmentStorage (DeviceMode openMode)
SharedSegment	createLinearDeviceSegment (DeviceId deviceId, uint nPages)
void	closeLinearSegment ()
void	closeRandomSegment ()
void	closeVersionedRandomSegment ()
void	closeSnapshotRandomSegment ()
virtual void	closeStorage ()
Cache &	getCache ()
virtual SharedCache	newCache ()
SharedRandomAccessDevice	openDevice (std::string devName, DeviceMode openMode, uint nDevicePages, DeviceId deviceId)
void	closeDevice (DeviceId deviceId, SharedRandomAccessDevice &pDevice)
TestSuite *	releaseTestSuite ()
void	beforeTestCase (std::string testCaseName)
void	afterTestCase (std::string testCaseName)
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.
virtual void	openSegmentStorage (DeviceMode openMode)
virtual void	closeStorage ()
virtual void	testAllocateAll ()
	Initializes all disk pages, filling them with information based on their block numbers.
virtual void	verifyPage (CachePage &page, uint x)
	Verifies that the page contents are correct (based on the parameter x).
virtual void	fillPage (CachePage &page, uint x)
	Scribbles on the contents of a page.
virtual void	openStorage (DeviceMode openMode)
virtual CachePage *	lockPage (OpType opType, uint iPage)
virtual void	unlockPage (CachePage &page, LockMode lockMode)
virtual void	prefetchPage (uint iPage)
virtual void	prefetchBatch (uint, uint)
virtual void	testAllocate ()
virtual void	testDeallocate ()
virtual void	testCheckpoint ()
	Performs a periodic checkpoint.
void	testSingleThread ()
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.
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.
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.
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
SharedExecStream	prepareSourceGraph (ExecStreamEmbryo &sourceStreamEmbryo)
	Defines and prepares a graph consisting of one source stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of one source stream and one transform stream.
SharedExecStream	prepareTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo, std::vector< ExecStreamEmbryo > &transforms)
	Defines and prepares a graph consisting of one source stream and one or multiple transform streams.
SharedExecStream	prepareConfluenceGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of two source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< ExecStreamEmbryo > &sourceStreamEmbryos, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of a list of source streams and one confluence stream.
SharedExecStream	prepareConfluenceGraph (std::vector< std::vector< ExecStreamEmbryo > > &sourceStreamEmbryosList, ExecStreamEmbryo &confluenceStreamEmbryo)
	Defines and prepares a graph consisting of one or more source streams and one confluence stream.
SharedExecStream	prepareConfluenceTransformGraph (ExecStreamEmbryo &sourceStreamEmbryo1, ExecStreamEmbryo &sourceStreamEmbryo2, ExecStreamEmbryo &confluenceStreamEmbryo, ExecStreamEmbryo &transformStreamEmbryo)
	Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< ExecStreamEmbryo > &interStreamEmbryos, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.
SharedExecStream	prepareDAG (ExecStreamEmbryo &srcStreamEmbryo, ExecStreamEmbryo &splitterStreamEmbryo, std::vector< std::vector< ExecStreamEmbryo > > &interStreamEmbryosList, ExecStreamEmbryo &destStreamEmbryo, bool createSink=true, bool saveSrc=true)
	Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.
void	verifyOutput (ExecStream &stream, uint nRowsExpected, MockProducerExecStreamGenerator &verifier, bool stopEarly=false)
	Executes the prepared stream graph and verifies that its output matches that produced by a value generator.
void	verifyConstantOutput (ExecStream &stream, const TupleData &expectedTuple, uint nRowsExpected)
	Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.
void	verifyBufferedOutput (ExecStream &stream, TupleDescriptor outputTupleDesc, uint nRowsExpected, PBuffer expectedBuffer)
	Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.
void	resetExecStreamTest ()
	Reset stream graph so multiple iterations of a method can be called within a single testcase.
virtual void	tearDownExecStreamTest ()
	ExecStream-specific handler called from testCaseTearDown.
virtual SharedExecStreamGraph	newStreamGraph ()
	Creates a stream graph.
virtual SharedExecStreamGraphEmbryo	newStreamGraphEmbryo (SharedExecStreamGraph)
	Creates an embryo for a stream graph.
virtual ExecStreamScheduler *	newScheduler ()
	Creates a scheduler.
virtual ExecStreamGovernor *	newResourceGovernor (ExecStreamResourceKnobs const &knobSettings, ExecStreamResourceQuantity const &resourcesAvailable)
	Creates the resource governor.
void	snooze (uint nSeconds)
void	setForceCacheUnmap (SharedSegment pSegment)
	Forces the underlying snapshot segment to always execute its checkpoints during a cache flush and unmap.
void	commitChanges (TxnId commitCsn)
	Commits transactions associated with a specified csn.
uint	generateRandomNumber (uint iMax)
void	runThreadedTestCase ()
	Executes specified test threads.
Protected Attributes
SharedExecStreamGraph	pGraph
SharedExecStreamGraphEmbryo	pGraphEmbryo
SharedExecStreamScheduler	pScheduler
SharedExecStreamGovernor	pResourceGovernor
SharedCacheAccessor	pCacheAccessor
SharedSegmentFactory	pSegmentFactory
SharedSegment	pLinearSegment
	Segment supporting linear page allocation.
SharedSegment	pRandomSegment
	(Optional) segment supporting random page allocation.
SharedSegment	pVersionedRandomSegment
	(Optional) segment supporting versioned random page allocation.
SharedSegment	pSnapshotRandomSegment
	(Optional) segment supporting snapshot random page allocation.
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	nDiskPagesTotal
PageId	firstPageId
DeviceId	tempDeviceId
SharedRandomAccessDevice	pTempDevice
SharedSegment	pTempSegment
TxnId	currCsn
std::vector< TxnId >	updatedCsns
bool	commit
SharedSegment	pSnapshotRandomSegment2
std::vector< PageId >	freeablePages
	Queue of allocated pages waiting to be freed.
StrictMutex	freeablePagesMutex
	Mutex protecting freeablePages.
PageOwnerId	objId
	PageOwnerId to use when allocating pages.
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.
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 const uint	DefaultCacheReservePercent = 5
static const uint	DefaultConcurrentStatements = 4
static bool	runAll
	Run all test cases, including the extra tests.
static std::string	runSingle
	Run only the test case of this name.
Private Member Functions
void	loadCluster (uint nCols, uint nRows, SharedMockProducerExecStreamGenerator pInputGenerator)
	Loads a cluster with the values specified by the mock producer stream generator input parameter, using a LcsClusterAppendExecStream.
void	verifyCluster (uint nCols, uint nRows, MockProducerExecStreamGenerator &resultGenerator)
	Verifies that a cluster contains the values specified by the mock producer stream generator passed in.
void	replaceCluster (uint nCols, uint nRows, SharedMockProducerExecStreamGenerator pInputGenerator)
	Replaces rows in an existing cluster column based on a mock producer exec stream passed in.
void	testClusterReplace (uint nCols, uint totalNumRows, uint numReplRows, SharedMockProducerExecStreamGenerator pOrigClusterInputGenerator, MockProducerExecStreamGenerator &origClusterResultGenerator, SharedMockProducerExecStreamGenerator pReplClusterInputGenerator, MockProducerExecStreamGenerator &replClusterResultGenerator)
	Loads a cluster and then replaces selected rows from the cluster with new input.
void	testSingleColRepeatingSequence (uint nRows, uint inputSeqStart, uint replSeqStart, uint expectedSeqStart)
void	testMultiColClusterReplace (uint nCols, uint nRows)
void	initClusterAppendParams (LcsClusterAppendExecStreamParams &lcsAppendParams, uint nCols, bool replace)
Private Attributes
StandardTypeDescriptorFactory	stdTypeFactory
TupleAttributeDescriptor	attrDesc_int64
TupleAttributeDescriptor	attrDesc_bitmap
PageId	savedRootPageId
BTreeDescriptor	btreeDescriptor

---

Detailed Description

Test class for exercising LcsClusterReplaceExecStream.

Note that the class is derived from SnapshotSegmentTestBase, which allows the underlying segment it uses for storage to be versioned.

Definition at line 47 of file LcsClusterReplaceExecStreamTest.cpp.

---

Member Enumeration Documentation

enum CacheTestBase::VictimPolicy [protected, inherited]

The available victim policy implementations.

Enumerator:

victimTwoQ
victimLRU
victimRandom

Definition at line 44 of file CacheTestBase.h.

                      {
        victimTwoQ,
        victimLRU,
        victimRandom
    };

enum PagingTestBase::OpType [inherited]

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.

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

---

Constructor & Destructor Documentation

LcsClusterReplaceExecStreamTest::LcsClusterReplaceExecStreamTest

(

)

[inline, explicit]

Definition at line 139 of file LcsClusterReplaceExecStreamTest.cpp.

References test3ColClusterReplace(), testReplaceAllRows(), testReplaceNoRows(), testSingleColEvenNumRows(), testSingleColOddNumRows(), and testSingleColSeqStartAt1().

    {
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, testSingleColOddNumRows);
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, testSingleColEvenNumRows);
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, testSingleColSeqStartAt1);
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, testReplaceAllRows);
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, testReplaceNoRows);
        FENNEL_UNIT_TEST_CASE(
            LcsClusterReplaceExecStreamTest, test3ColClusterReplace);
    }

---

Member Function Documentation

void LcsClusterReplaceExecStreamTest::loadCluster	(	uint	nCols,
		uint	nRows,
		SharedMockProducerExecStreamGenerator	pInputGenerator
	)			[private]

Loads a cluster with the values specified by the mock producer stream generator input parameter, using a LcsClusterAppendExecStream.

Parameters:

	nCols	number of columns in the cluster
	nRows	number of rows to load
	pInputGenerator	the generator that produces the data to be loaded into the cluster

Definition at line 424 of file LcsClusterReplaceExecStreamTest.cpp.

References attrDesc_int64, btreeDescriptor, BTreeBuilder::createEmptyRoot(), BTreeAccessBase::getRootPageId(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), initClusterAppendParams(), BTreeParams::keyProj, BTreeDescriptor::keyProjection, MockProducerExecStreamParams::nRows, NULL_PAGE_ID, SingleOutputExecStreamParams::outputTupleDesc, CacheTestBase::pCache, SegmentAccessor::pCacheAccessor, MockProducerExecStreamParams::pGenerator, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareTransformGraph(), BTreeParams::pSegment, SegmentAccessor::pSegment, BTreeParams::rootPageId, BTreeDescriptor::rootPageId, savedRootPageId, BTreeDescriptor::segmentAccessor, BTreeParams::tupleDesc, BTreeDescriptor::tupleDescriptor, and ExecStreamUnitTestBase::verifyOutput().

Referenced by testClusterReplace().

{
    MockProducerExecStreamParams mockParams;
    for (uint i = 0; i < nCols; i++) {
        mockParams.outputTupleDesc.push_back(attrDesc_int64);
    }
    mockParams.nRows = nRows;
    mockParams.pGenerator = pInputGenerator;

    ExecStreamEmbryo mockStreamEmbryo;
    mockStreamEmbryo.init(new MockProducerExecStream(), mockParams);
    mockStreamEmbryo.getStream()->setName("MockProducerExecStream");

    LcsClusterAppendExecStreamParams lcsAppendParams;
    initClusterAppendParams(lcsAppendParams, nCols, false);

    // setup temporary btree descriptor to get an empty page to start the btree
    btreeDescriptor.segmentAccessor.pSegment = lcsAppendParams.pSegment;
    btreeDescriptor.segmentAccessor.pCacheAccessor = pCache;
    btreeDescriptor.tupleDescriptor = lcsAppendParams.tupleDesc;
    btreeDescriptor.keyProjection = lcsAppendParams.keyProj;
    btreeDescriptor.rootPageId = NULL_PAGE_ID;

    BTreeBuilder builder(btreeDescriptor, pRandomSegment);
    builder.createEmptyRoot();
    savedRootPageId = builder.getRootPageId();

    lcsAppendParams.rootPageId = btreeDescriptor.rootPageId = savedRootPageId;

    ExecStreamEmbryo lcsAppendStreamEmbryo;
    lcsAppendStreamEmbryo.init(
        new LcsClusterAppendExecStream(),
        lcsAppendParams);
    lcsAppendStreamEmbryo.getStream()->setName("LcsClusterAppendExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, lcsAppendStreamEmbryo);

    // set up a generator which can produce the expected output
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGen =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(nRows));
    columnGenerators.push_back(colGen);
    colGen = SharedInt64ColumnGenerator(new SeqColumnGenerator(0));
    columnGenerators.push_back(colGen);

    CompositeExecStreamGenerator expectedResultGenerator(columnGenerators);

    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void LcsClusterReplaceExecStreamTest::verifyCluster	(	uint	nCols,
		uint	nRows,
		MockProducerExecStreamGenerator &	resultGenerator
	)			[private]

Verifies that a cluster contains the values specified by the mock producer stream generator passed in.

Parameters:

	nCols	number of columns in the cluster
	nRows	number of rows expected in the cluster
	resultGenerator	the generator that produces the expected data in the cluster

Definition at line 515 of file LcsClusterReplaceExecStreamTest.cpp.

References attrDesc_bitmap, attrDesc_int64, btreeDescriptor, ValuesExecStreamParams::bufSize, LcsClusterScanDef::clusterTupleDesc, FixedBuffer, ExecStreamEmbryo::getStream(), LcsRowScanExecStreamParams::hasExtraFilter, ExecStreamEmbryo::init(), LcsRowScanExecStreamParams::isFullScan, BTreeParams::keyProj, BTreeDescriptor::keyProjection, LcsRowScanBaseExecStreamParams::lcsClusterScanDefs, LcsRowScanBaseExecStreamParams::outputProj, SingleOutputExecStreamParams::outputTupleDesc, BTreeDescriptor::pageOwnerId, BTreeParams::pageOwnerId, SegmentAccessor::pCacheAccessor, ExecStreamParams::pCacheAccessor, ExecStreamUnitTestBase::prepareTransformGraph(), SegmentAccessor::pSegment, BTreeParams::pSegment, ValuesExecStreamParams::pTupleBuffer, BTreeDescriptor::rootPageId, BTreeParams::rootPageId, SAMPLING_OFF, LcsRowScanExecStreamParams::samplingMode, BTreeDescriptor::segmentAccessor, BTreeDescriptor::segmentId, BTreeParams::segmentId, BTreeParams::tupleDesc, BTreeDescriptor::tupleDescriptor, and ExecStreamUnitTestBase::verifyOutput().

Referenced by testClusterReplace().

{
    // setup parameters into scan
    //  single cluster with only one column, project that single column

    LcsRowScanExecStreamParams scanParams;
    scanParams.hasExtraFilter = false;
    scanParams.isFullScan = true;
    scanParams.samplingMode = SAMPLING_OFF;

    struct LcsClusterScanDef clusterScanDef;

    for (uint i = 0; i < nCols; i++) {
        clusterScanDef.clusterTupleDesc.push_back(attrDesc_int64);
    }
    clusterScanDef.pSegment = btreeDescriptor.segmentAccessor.pSegment;
    clusterScanDef.pCacheAccessor =
        btreeDescriptor.segmentAccessor.pCacheAccessor;
    clusterScanDef.tupleDesc = btreeDescriptor.tupleDescriptor;
    clusterScanDef.keyProj = btreeDescriptor.keyProjection;
    clusterScanDef.rootPageId = btreeDescriptor.rootPageId;
    clusterScanDef.segmentId = btreeDescriptor.segmentId;
    clusterScanDef.pageOwnerId = btreeDescriptor.pageOwnerId;

    scanParams.lcsClusterScanDefs.push_back(clusterScanDef);
    for (uint i = 0; i < nCols; i++) {
        scanParams.outputTupleDesc.push_back(attrDesc_int64);
        scanParams.outputProj.push_back(i);
    }

    ValuesExecStreamParams valuesParams;
    ExecStreamEmbryo valuesStreamEmbryo;
    boost::shared_array<FixedBuffer> pBuffer;

    valuesParams.outputTupleDesc.push_back(attrDesc_int64);
    valuesParams.outputTupleDesc.push_back(attrDesc_bitmap);
    valuesParams.outputTupleDesc.push_back(attrDesc_bitmap);

    uint bufferSize = 16;
    pBuffer.reset(new FixedBuffer[bufferSize]);
    valuesParams.pTupleBuffer = pBuffer;
    valuesParams.bufSize = 0;
    valuesStreamEmbryo.init(new ValuesExecStream(), valuesParams);
    valuesStreamEmbryo.getStream()->setName("ValuesExecStream");

    ExecStreamEmbryo scanStreamEmbryo;
    scanStreamEmbryo.init(new LcsRowScanExecStream(), scanParams);
    scanStreamEmbryo.getStream()->setName("RowScanExecStream");

    SharedExecStream pOutputStream =
        prepareTransformGraph(valuesStreamEmbryo, scanStreamEmbryo);

    verifyOutput(*pOutputStream, nRows, resultGenerator);
}

void LcsClusterReplaceExecStreamTest::replaceCluster	(	uint	nCols,
		uint	nRows,
		SharedMockProducerExecStreamGenerator	pInputGenerator
	)			[private]

Replaces rows in an existing cluster column based on a mock producer exec stream passed in.

Parameters:

	nCols	the number of columns in the cluster
	nRows	the number of rows to be replaced
	pInputGenerator	the generator that generates the input into the replace stream; each input row contains the rid value of the row to be replaced and the new column values

Definition at line 573 of file LcsClusterReplaceExecStreamTest.cpp.

References attrDesc_int64, btreeDescriptor, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), initClusterAppendParams(), BTreeDescriptor::keyProjection, MockProducerExecStreamParams::nRows, SingleOutputExecStreamParams::outputTupleDesc, CacheTestBase::pCache, SegmentAccessor::pCacheAccessor, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::prepareTransformGraph(), SegmentAccessor::pSegment, BTreeDescriptor::rootPageId, savedRootPageId, BTreeDescriptor::segmentAccessor, BTreeDescriptor::tupleDescriptor, and ExecStreamUnitTestBase::verifyOutput().

Referenced by testClusterReplace().

{
    MockProducerExecStreamParams mockParams;
    // +1 for the rid column
    for (uint i = 0; i < nCols + 1; i++) {
        mockParams.outputTupleDesc.push_back(attrDesc_int64);
    }
    mockParams.nRows = nRows;
    mockParams.pGenerator = pGenerator;

    ExecStreamEmbryo mockStreamEmbryo;
    mockStreamEmbryo.init(new MockProducerExecStream(), mockParams);
    mockStreamEmbryo.getStream()->setName("MockProducerExecStream");

    LcsClusterReplaceExecStreamParams lcsReplaceParams;
    initClusterAppendParams(lcsReplaceParams, nCols, true);

    btreeDescriptor.segmentAccessor.pSegment = lcsReplaceParams.pSegment;
    btreeDescriptor.segmentAccessor.pCacheAccessor = pCache;
    btreeDescriptor.tupleDescriptor = lcsReplaceParams.tupleDesc;
    btreeDescriptor.keyProjection = lcsReplaceParams.keyProj;

    lcsReplaceParams.rootPageId = btreeDescriptor.rootPageId = savedRootPageId;

    ExecStreamEmbryo lcsReplaceStreamEmbryo;
    lcsReplaceStreamEmbryo.init(
        new LcsClusterReplaceExecStream(),
        lcsReplaceParams);
    lcsReplaceStreamEmbryo.getStream()->setName("LcsClusterReplaceExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, lcsReplaceStreamEmbryo);

    // set up a generator which can produce the expected output
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(nRows));
    columnGenerators.push_back(colGenerator);
    colGenerator = SharedInt64ColumnGenerator(new SeqColumnGenerator(0));
    columnGenerators.push_back(colGenerator);

    CompositeExecStreamGenerator expectedResultGenerator(columnGenerators);

    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void LcsClusterReplaceExecStreamTest::testClusterReplace	(	uint	nCols,
		uint	totalNumRows,
		uint	numReplRows,
		SharedMockProducerExecStreamGenerator	pOrigClusterInputGenerator,
		MockProducerExecStreamGenerator &	origClusterResultGenerator,
		SharedMockProducerExecStreamGenerator	pReplClusterInputGenerator,
		MockProducerExecStreamGenerator &	replClusterResultGenerator
	)			[private]

Loads a cluster and then replaces selected rows from the cluster with new input.

Parameters:

	nCols	number of columns in the cluster
	totalNumRows	number of rows loaded into the original cluster
	numReplRows	number of rows to replace in the cluster
	pOrigClusterInputGenerator	generator that produces input to be loaded into the original cluster
	origClusterResultGenerator	generator that produces the expected result after loading the original cluster
	pReplClusterInputGenerator	generator that produces the rows to be replaced in the cluster
	replClusterResultGenerator	generator that produces the expected rows in the replaced cluster

Definition at line 378 of file LcsClusterReplaceExecStreamTest.cpp.

References Segment::checkpoint(), CHECKPOINT_FLUSH_ALL, SnapshotRandomAllocationSegment::commitChanges(), SnapshotSegmentTestBase::currCsn, loadCluster(), SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, SegStorageTestBase::pSnapshotRandomSegment, SnapshotSegmentTestBase::pSnapshotRandomSegment2, SegStorageTestBase::pVersionedRandomSegment, replaceCluster(), ExecStreamUnitTestBase::resetExecStreamTest(), SnapshotSegmentTestBase::setForceCacheUnmap(), and verifyCluster().

Referenced by testMultiColClusterReplace(), testReplaceAllRows(), testReplaceNoRows(), and testSingleColRepeatingSequence().

{
    // Load the cluster and verify the load by scanning the resulting cluster
    loadCluster(nCols, totalNumRows, pOrigClusterInputGenerator);
    resetExecStreamTest();
    verifyCluster(nCols, totalNumRows, origClusterResultGenerator);
    resetExecStreamTest();

    // Commit the changes associated with the current txn and create a new
    // snapshot segment for the next txn
    SnapshotRandomAllocationSegment *pSnapshotSegment =
        SegmentFactory::dynamicCast<SnapshotRandomAllocationSegment *>(
            pSnapshotRandomSegment);
    pSnapshotSegment->commitChanges(currCsn);
    pSnapshotSegment->checkpoint(CHECKPOINT_FLUSH_ALL);
    currCsn = TxnId(1);
    pSnapshotRandomSegment2 =
        pSegmentFactory->newSnapshotRandomAllocationSegment(
            pVersionedRandomSegment,
            pVersionedRandomSegment,
            currCsn);
    setForceCacheUnmap(pSnapshotRandomSegment2);
    pRandomSegment = pSnapshotRandomSegment2;

    // Replace some sequence of rows from the cluster
    replaceCluster(nCols, numReplRows, pReplClusterInputGenerator);

    // Commit the changes and then verify that the resulting cluster contains
    // a combination of the original and replaced values.  It should be
    // 0, 1, 2, 3, ...
    pSnapshotSegment =
        SegmentFactory::dynamicCast<SnapshotRandomAllocationSegment *>(
            pSnapshotRandomSegment2);
    pSnapshotSegment->commitChanges(currCsn);
    pSnapshotSegment->checkpoint(CHECKPOINT_FLUSH_ALL);
    resetExecStreamTest();
    verifyCluster(nCols, totalNumRows, replClusterResultGenerator);
}

void LcsClusterReplaceExecStreamTest::testSingleColRepeatingSequence	(	uint	nRows,
		uint	inputSeqStart,
		uint	replSeqStart,
		uint	expectedSeqStart
	)			[private]

Definition at line 192 of file LcsClusterReplaceExecStreamTest.cpp.

References testClusterReplace().

Referenced by testSingleColEvenNumRows(), testSingleColOddNumRows(), and testSingleColSeqStartAt1().

{
    // Original cluster contains the values inputSeqStart, inputSeqStart+2, ...
    // Replace every other rid starting at rid replSeqStart with values
    // replaceSeqStart, replaceSeqStart+2, ...,
    // The replace cluster should have the sequence expectedSeqStart,
    // expectedSeqStart+1, ...

    SharedMockProducerExecStreamGenerator pOrigClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new StairCaseExecStreamGenerator(2, 2, inputSeqStart));

    StairCaseExecStreamGenerator origClusterResultGenerator =
        StairCaseExecStreamGenerator(2, 2, inputSeqStart);

    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(replSeqStart, 2));
    columnGenerators.push_back(colGenerator);
    colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(replSeqStart, 2));
    columnGenerators.push_back(colGenerator);
    SharedMockProducerExecStreamGenerator pReplClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new CompositeExecStreamGenerator(columnGenerators));

    RampExecStreamGenerator replClusterResultGenerator(expectedSeqStart);

    testClusterReplace(
        1,
        nRows,
        nRows / 2,
        pOrigClusterInputGenerator,
        origClusterResultGenerator,
        pReplClusterInputGenerator,
        replClusterResultGenerator);
}

void LcsClusterReplaceExecStreamTest::testMultiColClusterReplace	(	uint	nCols,
		uint	nRows
	)			[private]

Definition at line 315 of file LcsClusterReplaceExecStreamTest.cpp.

References testClusterReplace().

Referenced by test3ColClusterReplace().

{
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGenerator;

    // For the original cluster, each column is a repeating sequence of
    // values n,n,n+2,n+2,n+4,n+4, ..., where n corresponds to the column
    // number, starting at 0
    for (uint i = 0; i < nCols; i++) {
        colGenerator =
            SharedInt64ColumnGenerator(new StairCaseColumnGenerator(2, 2, i));
        columnGenerators.push_back(colGenerator);
    }
    SharedMockProducerExecStreamGenerator pOrigClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new CompositeExecStreamGenerator(columnGenerators));

    columnGenerators.clear();
    for (uint i = 0; i < nCols; i++) {
        colGenerator =
            SharedInt64ColumnGenerator(new StairCaseColumnGenerator(2, 2, i));
        columnGenerators.push_back(colGenerator);
    }
    CompositeExecStreamGenerator origClusterResultGenerator =
        CompositeExecStreamGenerator(columnGenerators);

    // Replace every other row, starting at rid 1, with the values n+1, n+3, ...
    // where n is the column number.  The first column generator below is
    // for the rid sequence.
    columnGenerators.clear();
    colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(1, 2));
    columnGenerators.push_back(colGenerator);
    for (uint i = 1; i < nCols + 1; i++) {
        colGenerator = SharedInt64ColumnGenerator(new SeqColumnGenerator(i, 2));
        columnGenerators.push_back(colGenerator);
    }
    SharedMockProducerExecStreamGenerator pReplClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new CompositeExecStreamGenerator(columnGenerators));

    // Expected resulting cluster should have values n,n+1, ... where n is
    // the column number
    columnGenerators.clear();
    for (uint i = 0; i < nCols; i++) {
        colGenerator = SharedInt64ColumnGenerator(new SeqColumnGenerator(i));
        columnGenerators.push_back(colGenerator);
    }
    CompositeExecStreamGenerator replClusterResultGenerator =
        CompositeExecStreamGenerator(columnGenerators);

    testClusterReplace(
        nCols,
        nRows,
        nRows / 2,
        pOrigClusterInputGenerator,
        origClusterResultGenerator,
        pReplClusterInputGenerator,
        replClusterResultGenerator);
}

void LcsClusterReplaceExecStreamTest::initClusterAppendParams	(	LcsClusterAppendExecStreamParams &	lcsAppendParams,
		uint	nCols,
		bool	replace
	)			[private]

Definition at line 478 of file LcsClusterReplaceExecStreamTest.cpp.

References attrDesc_int64, btreeDescriptor, LcsClusterAppendExecStreamParams::inputProj, BTreeParams::keyProj, SingleOutputExecStreamParams::outputTupleDesc, BTreeDescriptor::pageOwnerId, BTreeParams::pageOwnerId, CacheTestBase::pCache, ExecStreamParams::pCacheAccessor, SegStorageTestBase::pRandomSegment, BTreeParams::pRootMap, BTreeParams::pSegment, SegStorageTestBase::pSegmentFactory, BTreeParams::rootPageIdParamId, ExecStreamParams::scratchAccessor, BTreeDescriptor::segmentId, BTreeParams::segmentId, and BTreeParams::tupleDesc.

Referenced by loadCluster(), and replaceCluster().

{
    lcsAppendParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache, 10);
    lcsAppendParams.pCacheAccessor = pCache;
    lcsAppendParams.pSegment = pRandomSegment;
    lcsAppendParams.rootPageIdParamId = DynamicParamId(0);

    for (uint i = 0; i < nCols; i++) {
        lcsAppendParams.inputProj.push_back(i);
    }
    if (replace) {
        lcsAppendParams.inputProj.push_back(nCols);
    }

    // initialize the btree parameter portion of lcsAppendParams
    // BTree tuple desc only has one column
    (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);
    (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);

    // BTree key only has one column which is the first column.
    (lcsAppendParams.keyProj).push_back(0);

    // output only single row with 2 columns (# rows loaded, starting rid value)
    lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);
    lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);

    lcsAppendParams.pRootMap = 0;

    // Set up BTreeExecStreamParams using default values from BTreeDescriptor.
    lcsAppendParams.segmentId = btreeDescriptor.segmentId;
    lcsAppendParams.pageOwnerId = btreeDescriptor.pageOwnerId;
}

void LcsClusterReplaceExecStreamTest::testSingleColOddNumRows

(

)

Definition at line 168 of file LcsClusterReplaceExecStreamTest.cpp.

References testSingleColRepeatingSequence().

Referenced by LcsClusterReplaceExecStreamTest().

{
    // Original cluster contains 5001 rows with values 0, 0, 2, 2, 4, 4, ...
    // Replace every other rid starting at rid 1 with the values 1, 3, 5, ...
    // Resulting cluster contains the values 0, 1, 2, 3, ...
    testSingleColRepeatingSequence(5001, 0, 1, 0);
}

void LcsClusterReplaceExecStreamTest::testSingleColEvenNumRows

(

)

Definition at line 176 of file LcsClusterReplaceExecStreamTest.cpp.

References testSingleColRepeatingSequence().

Referenced by LcsClusterReplaceExecStreamTest().

{
    // Original cluster contains 4000 rows with values 0, 0, 2, 2, 4, 4, ...
    // Replace every other rid starting at rid 1 with the values 1, 3, 5, ...
    // Resulting cluster contains the values 0, 1, 2, 3, ...
    testSingleColRepeatingSequence(4000, 0, 1, 0);
}

void LcsClusterReplaceExecStreamTest::testSingleColSeqStartAt1

(

)

Definition at line 184 of file LcsClusterReplaceExecStreamTest.cpp.

References testSingleColRepeatingSequence().

Referenced by LcsClusterReplaceExecStreamTest().

{
    // Original cluster contains 3000 rows with values 1, 1, 3, 3, 5, 5, ...
    // Replace every other rid starting at rid 0 with the values 0, 2, 4, ...
    // Resulting cluster contains the values 0, 1, 2, 3, ...
    testSingleColRepeatingSequence(3000, 1, 0, 0);
}

void LcsClusterReplaceExecStreamTest::testReplaceAllRows

(

)

Definition at line 234 of file LcsClusterReplaceExecStreamTest.cpp.

References testClusterReplace().

Referenced by LcsClusterReplaceExecStreamTest().

{
    // Original cluster 2003 rows, all with the value 99.
    // Replace every row with the sequence 0, 1, 2, ...

    uint nRows = 2003;

    SharedMockProducerExecStreamGenerator pOrigClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new ConstExecStreamGenerator(99));

    ConstExecStreamGenerator origClusterResultGenerator =
        ConstExecStreamGenerator(99);

    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0, 1));
    columnGenerators.push_back(colGenerator);
    colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0, 1));
    columnGenerators.push_back(colGenerator);
    SharedMockProducerExecStreamGenerator pReplClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new CompositeExecStreamGenerator(columnGenerators));

    RampExecStreamGenerator replClusterResultGenerator;

    testClusterReplace(
        1,
        nRows,
        nRows,
        pOrigClusterInputGenerator,
        origClusterResultGenerator,
        pReplClusterInputGenerator,
        replClusterResultGenerator);
}

void LcsClusterReplaceExecStreamTest::testReplaceNoRows

(

)

Definition at line 271 of file LcsClusterReplaceExecStreamTest.cpp.

References testClusterReplace().

Referenced by LcsClusterReplaceExecStreamTest().

{
    // Original cluster contains 1007 rows with the sequence 0, 1, 2, ...
    // Replace no rows.

    uint nRows = 1007;

    SharedMockProducerExecStreamGenerator pOrigClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new RampExecStreamGenerator());

    RampExecStreamGenerator origClusterResultGenerator =
        RampExecStreamGenerator();

    // It doesn't matter what we use for these ColumnGenerators, since no
    // rows will be generated.
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0, 1));
    columnGenerators.push_back(colGenerator);
    colGenerator =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0, 1));
    columnGenerators.push_back(colGenerator);
    SharedMockProducerExecStreamGenerator pReplClusterInputGenerator =
        SharedMockProducerExecStreamGenerator(
            new CompositeExecStreamGenerator(columnGenerators));

    RampExecStreamGenerator replClusterResultGenerator;

    testClusterReplace(
        1,
        nRows,
        0,
        pOrigClusterInputGenerator,
        origClusterResultGenerator,
        pReplClusterInputGenerator,
        replClusterResultGenerator);
}

void LcsClusterReplaceExecStreamTest::test3ColClusterReplace

(

)

Definition at line 310 of file LcsClusterReplaceExecStreamTest.cpp.

References testMultiColClusterReplace().

Referenced by LcsClusterReplaceExecStreamTest().

{
    testMultiColClusterReplace(3, 800);
}

void LcsClusterReplaceExecStreamTest::testCaseSetUp

(

)

[virtual]

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

Default is no-op.

Reimplemented from ExecStreamUnitTestBase.

Definition at line 622 of file LcsClusterReplaceExecStreamTest.cpp.

References attrDesc_bitmap, attrDesc_int64, StandardTypeDescriptorFactory::newDataType(), NULL_PAGE_ID, SegStorageTestBase::pRandomSegment, savedRootPageId, STANDARD_TYPE_CHAR, STANDARD_TYPE_INT_64, stdTypeFactory, SnapshotSegmentTestBase::testCaseSetUp(), and ExecStreamUnitTestBase::testCaseSetUp().

{
    ExecStreamUnitTestBase::testCaseSetUp();
    SnapshotSegmentTestBase::testCaseSetUp();

    attrDesc_int64 = TupleAttributeDescriptor(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));
    attrDesc_bitmap = TupleAttributeDescriptor(
        stdTypeFactory.newDataType(STANDARD_TYPE_CHAR),
        true, pRandomSegment->getUsablePageSize() / 8);

    savedRootPageId = NULL_PAGE_ID;
}

void LcsClusterReplaceExecStreamTest::testCaseTearDown

(

)

[virtual]

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

Default is no-op.

Reimplemented from ExecStreamTestBase.

Definition at line 642 of file LcsClusterReplaceExecStreamTest.cpp.

References btreeDescriptor, SegmentAccessor::reset(), BTreeDescriptor::segmentAccessor, and ExecStreamTestBase::testCaseTearDown().

{
    btreeDescriptor.segmentAccessor.reset();
    ExecStreamUnitTestBase::testCaseTearDown();
}

void LcsClusterReplaceExecStreamTest::openRandomSegment

(

)

[virtual]

Reimplemented from SegStorageTestBase.

Definition at line 636 of file LcsClusterReplaceExecStreamTest.cpp.

{
    // nothing to do since SnapshotSegmentTestBase::openSegmentStorage
    // has already set pRandomSegment to the snapshot segment.
}

SharedExecStream ExecStreamUnitTestBase::prepareSourceGraph

(

ExecStreamEmbryo &

sourceStreamEmbryo

)

[protected, inherited]

Defines and prepares a graph consisting of one source stream.

Parameters:

sourceStreamEmbryo

embryonic source stream which produces tuples

Returns:

output buffer stream

Definition at line 41 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareTransformGraph().

Referenced by FlatFileExecStreamTest::testStream().

{
    std::vector<ExecStreamEmbryo> transforms;
    return prepareTransformGraph(sourceStreamEmbryo, transforms);
}

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of one source stream and one transform stream.

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transformStreamEmbryo	embryonic transform stream which processes tuples produced by sourceStreamEmbryo

Returns:

output buffer stream

Definition at line 48 of file ExecStreamUnitTestBase.cpp.

Referenced by loadCluster(), LcsRowScanExecStreamTest::loadOneCluster(), ExecStreamUnitTestBase::prepareSourceGraph(), replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectInts(), CollectExecStreamTestSuite::testCollectUncollect(), CalcExecStreamTestSuite::testConstant(), ExecStreamTestSuite::testCopyExecStream(), ExecStreamTestSuite::testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamTestSuite::testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), ExternalSortExecStreamTest::testImpl(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmNormalizerExecStreamTest::testNormalizer(), ExecStreamTestSuite::testReshapeExecStream(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), LbmSearchTest::testScanIdx(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), ExecStreamTestSuite::testScratchBufferExecStream(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), ExecStreamTestSuite::testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), LbmUnionExecStreamTest::testUnion(), and verifyCluster().

{
    std::vector<ExecStreamEmbryo> transforms;
    transforms.push_back(transformStreamEmbryo);
    return prepareTransformGraph(sourceStreamEmbryo, transforms);
}

SharedExecStream ExecStreamUnitTestBase::prepareTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	transforms
	)			[protected, inherited]

Defines and prepares a graph consisting of one source stream and one or multiple transform streams.

Parameters:

	sourceStreamEmbryo	embryonic source stream which produces tuples
	transforms	embryonic transform streams which process tuples produced by sourceStreamEmbryo or a child stream

Returns:

output buffer stream

Definition at line 57 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryo);
    std::vector<ExecStreamEmbryo>::iterator it;

    // save all transforms
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }

    // connect streams in a cascade
    ExecStreamEmbryo& previousStream = sourceStreamEmbryo;
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->addDataflow(
            previousStream.getStream()->getName(),
            (*it).getStream()->getName());
        previousStream = *it;
    }

    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            previousStream.getStream()->getName(),
            0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");
    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of two source streams and one confluence stream.

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:

output buffer stream

Definition at line 89 of file ExecStreamUnitTestBase.cpp.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamTestSuite::testCartesianJoinExecStream(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LcsRowScanExecStreamTest::testFilterCols(), ExecStreamGovernorTest::testGovernor(), LhxJoinExecStreamTest::testImpl(), LbmIntersectExecStreamTest::testIntersect(), ExecStreamTestSuite::testMergeExecStream(), LbmMinusExecStreamTest::testMinus(), and ExecStreamTestSuite::testNestedLoopJoinExecStream().

{
    std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
    sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
    sourceStreamEmbryos.push_back(sourceStreamEmbryo2);
    return prepareConfluenceGraph(sourceStreamEmbryos, confluenceStreamEmbryo);
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< ExecStreamEmbryo > &	sourceStreamEmbryos,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of a list of source streams and one confluence stream.

Parameters:

	sourceStreamEmbryos	list of embryonic source streams that produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos

Returns:

output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

{
    std::vector<std::vector<ExecStreamEmbryo> > sourceStreamEmbryosList;
    std::vector<ExecStreamEmbryo>::iterator it;
    std::vector<ExecStreamEmbryo> sourceStreamList;
    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        it++)
    {
        sourceStreamList.clear();
        sourceStreamList.push_back(*it);
        sourceStreamEmbryosList.push_back(sourceStreamList);
    }

    return
        prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo);
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceGraph	(	std::vector< std::vector< ExecStreamEmbryo > > &	sourceStreamEmbryosList,
		ExecStreamEmbryo &	confluenceStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of one or more source streams and one confluence stream.

Each source stream can be a list of streams.

Parameters:

	sourceStreamEmbryosList	list of embryonic source streams which produce tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the source streams

Returns:

output buffer stream

Definition at line 174 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);

    for (int i = 0; i < sourceStreamEmbryosList.size(); i++) {
        for (int j = 0; j < sourceStreamEmbryosList[i].size(); j++) {
            pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryosList[i][j]);
        }

        // connect streams in each sourceStreamEmbryos list in a cascade
        for (int j = 1; j < sourceStreamEmbryosList[i].size(); j++) {
            pGraphEmbryo->addDataflow(
                sourceStreamEmbryosList[i][j - 1].getStream()->getName(),
                sourceStreamEmbryosList[i][j].getStream()->getName());
        }
        pGraphEmbryo->addDataflow(
            sourceStreamEmbryosList[i].back().getStream()->getName(),
            confluenceStreamEmbryo.getStream()->getName());
    }

    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            confluenceStreamEmbryo.getStream()->getName(), 0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(
        pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");

    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareConfluenceTransformGraph	(	ExecStreamEmbryo &	sourceStreamEmbryo1,
		ExecStreamEmbryo &	sourceStreamEmbryo2,
		ExecStreamEmbryo &	confluenceStreamEmbryo,
		ExecStreamEmbryo &	transformStreamEmbryo
	)			[protected, inherited]

Defines and prepares a graph consisting of two source streams, one confluence stream, and one transform stream.

Parameters:

	sourceStreamEmbryo1	embryonic source stream which produces tuples
	sourceStreamEmbryo2	embryonic source stream which produces tuples
	confluenceStreamEmbryo	embryonic confluence stream which processes tuples produced by the sourceStreamEmbryos
	transformStreamEmbryo	embryonic transform streams which process tuples produced by a child stream

Returns:

output buffer stream

Definition at line 100 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by LhxJoinExecStreamTest::testImpl(), and LbmMinusExecStreamTest::testRestartingMinus().

{
    std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
    sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
    sourceStreamEmbryos.push_back(sourceStreamEmbryo2);

    std::vector<ExecStreamEmbryo>::iterator it;

    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        ++it)
    {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }
    pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);

    for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
        ++it)
    {
        pGraphEmbryo->addDataflow(
            (*it).getStream()->getName(),
            confluenceStreamEmbryo.getStream()->getName());
    }

    std::vector<ExecStreamEmbryo> transforms;
    transforms.push_back(transformStreamEmbryo);
    ExecStreamEmbryo& previousStream = confluenceStreamEmbryo;

    // save all transforms
    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->saveStreamEmbryo(*it);
    }

    for (it = transforms.begin(); it != transforms.end(); ++it) {
        pGraphEmbryo->addDataflow(
            previousStream.getStream()->getName(),
            (*it).getStream()->getName());
        previousStream = *it;
    }


    SharedExecStream pAdaptedStream =
        pGraphEmbryo->addAdapterFor(
            previousStream.getStream()->getName(),
            0,
            BUFPROV_PRODUCER);
    pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

    pGraphEmbryo->prepareGraph(shared_from_this(), "");
    return pAdaptedStream;
}

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< ExecStreamEmbryo > &	interStreamEmbryos,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = true,
		bool	saveSrc = true
	)			[protected, inherited]

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryos	embryonic intermediate streams which transform tuples; each stream consists of a single embryo
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

Returns:

output buffer stream or null stream if createSink is false

Definition at line 208 of file ExecStreamUnitTestBase.cpp.

Referenced by LcsMultiClusterAppendTest::loadClusters(), LbmSearchTest::loadTableAndIndex(), LbmLoadBitmapTest::testLoad(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), and ExecStreamTestSuite::testSplitterPlusBarrier().

{
    std::vector<std::vector<ExecStreamEmbryo> > listOfList;

    // Convert interStreamEmbryos to a vector of vectors.  E.g., if
    // interStreamEmbryos contains (1, 2, 3), it will get converted to:
    // ((1)) ((2)) ((3))
    for (uint i = 0; i < interStreamEmbryos.size(); i++) {
        std::vector<ExecStreamEmbryo> interStreamEmbryoList;

        interStreamEmbryoList.push_back(interStreamEmbryos[i]);
        listOfList.push_back(interStreamEmbryoList);
    }
    return prepareDAG(
        srcStreamEmbryo, splitterStreamEmbryo, listOfList, destStreamEmbryo,
        createSink, saveSrc);
}

SharedExecStream ExecStreamUnitTestBase::prepareDAG	(	ExecStreamEmbryo &	srcStreamEmbryo,
		ExecStreamEmbryo &	splitterStreamEmbryo,
		std::vector< std::vector< ExecStreamEmbryo > > &	interStreamEmbryosList,
		ExecStreamEmbryo &	destStreamEmbryo,
		bool	createSink = true,
		bool	saveSrc = true
	)			[protected, inherited]

Defines and prepares a graph consisting of a source, a splitter, and one or more parallel transform streams which flow together into a confluence stream.

Parameters:

	srcStreamEmbryo	embryonic source stream which produces tuples
	splitterStreamEmbryo	embryonic SplitterExecStream which produces tuples for multiple consumers
	interStreamEmbryosList	one or more embryonic intermediate streams which transform tuples; each stream can have one more embryos
	destStreamEmbryo	embryonic confluence stream which processes tuples produced by the interStreamEmbryos
	createSink	if true (the default), creates a final output sink in the stream graph
	saveSrc	if true (the default), save the source in the stream graph; if false, the save has already been done

Returns:

output buffer stream or null stream if createSink is false

Definition at line 232 of file ExecStreamUnitTestBase.cpp.

References BUFPROV_PRODUCER, ExecStreamEmbryo::getStream(), ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

{
    if (saveSrc) {
        pGraphEmbryo->saveStreamEmbryo(srcStreamEmbryo);
    }
    pGraphEmbryo->saveStreamEmbryo(splitterStreamEmbryo);

    // save all intermediate stream embryos
    for (int i = 0; i < interStreamEmbryos.size(); i++) {
        for (int j = 0; j < interStreamEmbryos[i].size(); j++) {
            pGraphEmbryo->saveStreamEmbryo(interStreamEmbryos[i][j]);
        }

        // connect streams in each interStreamEmbryos list in a cascade
        for (int j = 1; j < interStreamEmbryos[i].size(); j++) {
            pGraphEmbryo->addDataflow(
                interStreamEmbryos[i][j - 1].getStream()->getName(),
                interStreamEmbryos[i][j].getStream()->getName());
        }
    }

    pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo);

    pGraphEmbryo->addDataflow(
        srcStreamEmbryo.getStream()->getName(),
        splitterStreamEmbryo.getStream()->getName());

    // connect all inter streams to src and dest
    for (int i = 0; i < interStreamEmbryos.size(); i++) {
        pGraphEmbryo->addDataflow(
            splitterStreamEmbryo.getStream()->getName(),
            interStreamEmbryos[i][0].getStream()->getName());
        pGraphEmbryo->addDataflow(
            interStreamEmbryos[i].back().getStream()->getName(),
            destStreamEmbryo.getStream()->getName());
    }

    SharedExecStream pAdaptedStream;

    if (createSink) {
        pAdaptedStream = pGraphEmbryo->addAdapterFor(
            destStreamEmbryo.getStream()->getName(), 0,
            BUFPROV_PRODUCER);
        pGraph->addOutputDataflow(pAdaptedStream->getStreamId());

        pGraphEmbryo->prepareGraph(shared_from_this(), "");
    }

    return pAdaptedStream;
}

void ExecStreamUnitTestBase::verifyOutput	(	ExecStream &	stream,
		uint	nRowsExpected,
		MockProducerExecStreamGenerator &	verifier,
		bool	stopEarly = false
	)			[protected, inherited]

Executes the prepared stream graph and verifies that its output matches that produced by a value generator.

Parameters:

	stream	output stream from which to read
	nRowsExpected	number of rows expected
	verifier	generator for expected values
	stopEarly	if true, stop once nRowsExpected have been fetched, even if more rows are available; this can be used for simulating the cleanup effect of an error in the middle of execution

Definition at line 325 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, MockProducerExecStreamGenerator::generateValue(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, and ExecStreamTestBase::pScheduler.

Referenced by loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), replaceCluster(), LcsMultiClusterAppendTest::scanCols(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), CollectExecStreamTestSuite::testCollectCollectUncollectUncollect(), CollectExecStreamTestSuite::testCollectUncollect(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), ExecStreamTestSuite::testCountAggExecStream(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), LcsRowScanExecStreamTest::testFilterCols(), ExecStreamTestSuite::testGroupAggExecStreamNrows(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testNestedLoopJoinExecStream(), LbmNormalizerExecStreamTest::testNormalizer(), ExecStreamTestSuite::testReshapeExecStream(), LbmMinusExecStreamTest::testRestartingMinus(), LcsRowScanExecStreamTest::testSampleScanCols(), LcsRowScanExecStreamTest::testScanCols(), LcsClusterAppendExecStreamTest::testScanMultiCol(), LcsClusterAppendExecStreamTest::testScanSingleCol(), ExecStreamTestSuite::testScratchBufferExecStream(), ExecStreamTestSuite::testSingleValueAggExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LbmSortedAggExecStreamTest::testSortedAgg(), ExecStreamTestSuite::testSplitterPlusBarrier(), ExecStreamTestSuite::testSumAggExecStream(), LhxAggExecStreamTest::testSumImpl(), and verifyCluster().

{
    // TODO:  assertions about output tuple

    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
        const uint nCol =
            bufAccessor.getConsumptionTupleAccessor().size();
        BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
        BOOST_REQUIRE(nCol >= 1);
        TupleData inputTuple;
        inputTuple.compute(bufAccessor.getTupleDesc());
        for (;;) {
            if (!bufAccessor.demandData()) {
                break;
            }
            BOOST_REQUIRE(nRows < nRowsExpected);
            bufAccessor.unmarshalTuple(inputTuple);
            for (int col = 0; col < nCol; ++col) {
                int64_t actualValue =
                    *reinterpret_cast<int64_t const *>(inputTuple[col].pData);
                int64_t expectedValue = generator.generateValue(nRows, col);
                if (actualValue != expectedValue) {
                    std::cout << "(Row, Col) = (" << nRows << ", " << col <<")"
                              << std::endl;
                    BOOST_CHECK_EQUAL(expectedValue,actualValue);
                    return;
                }
            }
            bufAccessor.consumeTuple();
            ++nRows;
            if (stopEarly && nRows == nRowsExpected) {
                return;
            }
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected,nRows);
}

void ExecStreamUnitTestBase::verifyConstantOutput	(	ExecStream &	stream,
		const TupleData &	expectedTuple,
		uint	nRowsExpected
	)			[protected, inherited]

Executes the prepared stream graph and verifies that all output tuples matche an expected and given one.

Parameters:

	stream	output stream from which to read
	expectedTuple
	nRowsExpected

Definition at line 377 of file ExecStreamUnitTestBase.cpp.

References TupleData::compute(), EXECBUF_EOS, ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, TuplePrinter::print(), and ExecStreamTestBase::pScheduler.

Referenced by ExecStreamTestSuite::testCartesianJoinExecStream(), CollectExecStreamTestSuite::testCollectInts(), CalcExecStreamTestSuite::testConstant(), ExecStreamTestSuite::testCopyExecStream(), ExecStreamGovernorTest::testGovernor(), ExecStreamTestSuite::testMergeExecStream(), ExecStreamTestSuite::testSegBufferExecStream(), and ExecStreamTestSuite::testSegBufferReaderWriterExecStream().

{
    // TODO:  assertions about output tuple

    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());

        if (!bufAccessor.demandData()) {
            break;
        }
        BOOST_REQUIRE(nRows < nRowsExpected);

        TupleData actualTuple;
        actualTuple.compute(bufAccessor.getTupleDesc());
        bufAccessor.unmarshalTuple(actualTuple);

        int c = bufAccessor.getTupleDesc().compareTuples(
                               expectedTuple, actualTuple);
        bufAccessor.consumeTuple();
        ++nRows;
        if (c) {
#if 1
            TupleDescriptor statusDesc = bufAccessor.getTupleDesc();
            TuplePrinter tuplePrinter;
            tuplePrinter.print(std::cout, statusDesc, actualTuple);
            tuplePrinter.print(std::cout, statusDesc, expectedTuple);
            std::cout << std::endl;
#endif
            BOOST_CHECK_EQUAL(0,c);
            break;
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected, nRows);
}

void ExecStreamUnitTestBase::verifyBufferedOutput	(	ExecStream &	stream,
		TupleDescriptor	outputTupleDesc,
		uint	nRowsExpected,
		PBuffer	expectedBuffer
	)			[protected, inherited]

Executes the prepared stream graph and verifies the resultant tuples against a set of tuples supplied in an input buffer.

Parameters:

	stream	output stream from which to read
	outputTupleDesc	descriptor of expected output tuple
	nRowsExpected	number of rows expected
	expectedBuffer	buffer containing expected tuples

Definition at line 424 of file ExecStreamUnitTestBase.cpp.

References TupleDescriptor::compareTuples(), TupleData::compute(), TupleAccessor::compute(), EXECBUF_EOS, TupleAccessor::getCurrentByteCount(), ExecStreamUnitTestBase::pGraph, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, TupleAccessor::setCurrentTupleBuf(), and TupleAccessor::unmarshal().

Referenced by LbmIntersectExecStreamTest::testIntersect(), LbmMinusExecStreamTest::testMinus(), LbmSearchTest::testScanIdx(), and LbmUnionExecStreamTest::testUnion().

{
    // TODO:  assertions about output tuple

    TupleAccessor expectedOutputAccessor;
    expectedOutputAccessor.compute(outputTupleDesc);
    TupleData expectedTuple(outputTupleDesc);
    uint bufOffset = 0;
    pResourceGovernor->requestResources(*pGraph);
    pGraph->open();
    pScheduler->start();
    uint nRows = 0;
    for (;;) {
        ExecStreamBufAccessor &bufAccessor =
            pScheduler->readStream(stream);
        if (bufAccessor.getState() == EXECBUF_EOS) {
            break;
        }
        BOOST_REQUIRE(bufAccessor.getTupleDesc() == outputTupleDesc);
        BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
        const uint nCol =
            bufAccessor.getConsumptionTupleAccessor().size();
        BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
        BOOST_REQUIRE(nCol >= 1);
        TupleData inputTuple;
        inputTuple.compute(bufAccessor.getTupleDesc());
        for (;;) {
            if (!bufAccessor.demandData()) {
                break;
            }
            BOOST_REQUIRE(nRows < nRowsExpected);
            bufAccessor.unmarshalTuple(inputTuple);
            expectedOutputAccessor.setCurrentTupleBuf(
                expectedBuffer + bufOffset);
            expectedOutputAccessor.unmarshal(expectedTuple);
            int c = outputTupleDesc.compareTuples(inputTuple, expectedTuple);
            if (c) {
                std::cout << "(Row) = (" << nRows << ")"
                    << " -- Tuples don't match"<< std::endl;
                BOOST_CHECK_EQUAL(0,c);
                return;
            }
            bufAccessor.consumeTuple();
            bufOffset += expectedOutputAccessor.getCurrentByteCount();
            ++nRows;
        }
    }
    BOOST_CHECK_EQUAL(nRowsExpected,nRows);
}

void ExecStreamUnitTestBase::resetExecStreamTest

(

)

[protected, inherited]

Reset stream graph so multiple iterations of a method can be called within a single testcase.

Definition at line 305 of file ExecStreamUnitTestBase.cpp.

References ExecStreamTestBase::newScheduler(), ExecStreamTestBase::newStreamGraph(), ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::pGraphEmbryo, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, and ExecStreamUnitTestBase::tearDownExecStreamTest().

Referenced by LcsRowScanExecStreamTest::loadClusters(), LbmLoadBitmapTest::testAppend(), LcsRowScanExecStreamTest::testBernoulliSampling(), testClusterReplace(), LcsRowScanExecStreamTest::testCompressedFiltering(), LbmSplicerExecStreamTest::testLER5968(), LbmSplicerExecStreamTest::testLER6473(), LcsMultiClusterAppendTest::testLoad(), LcsClusterAppendExecStreamTest::testMultiColConstNewRoot(), LcsClusterAppendExecStreamTest::testMultiColConstOldRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testMultiColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testMultiColStairNewRoot(), LcsClusterAppendExecStreamTest::testMultiColStairOldRoot(), LbmSearchTest::testMultipleRanges(), ExecStreamGovernorTest::testReturnResources(), LbmSearchTest::testScanIdx(), LcsRowScanExecStreamTest::testScanPastEndOfCluster(), LcsRowScanExecStreamTest::testScans(), LcsClusterAppendExecStreamTest::testSingleColConstNewRoot(), LcsClusterAppendExecStreamTest::testSingleColConstOldRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupNewRoot(), LcsClusterAppendExecStreamTest::testSingleColNoDupOldRoot(), LcsClusterAppendExecStreamTest::testSingleColStairNewRoot(), LcsClusterAppendExecStreamTest::testSingleColStairOldRoot(), LbmSplicerExecStreamTest::testSpliceRids(), LbmSplicerExecStreamTest::testSpliceWithKeys(), and LcsRowScanExecStreamTest::testSystemSampling().

{
    if (pScheduler) {
        pScheduler->stop();
    }
    tearDownExecStreamTest();

    pScheduler.reset(newScheduler());
    pGraph = newStreamGraph();
    pGraphEmbryo = newStreamGraphEmbryo(pGraph);
    pGraph->setResourceGovernor(pResourceGovernor);
}

void ExecStreamUnitTestBase::tearDownExecStreamTest

(

)

[protected, virtual, inherited]

ExecStream-specific handler called from testCaseTearDown.

Reimplemented from ExecStreamTestBase.

Definition at line 319 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::pGraph, and ExecStreamUnitTestBase::pGraphEmbryo.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest().

{
    pGraph.reset();
    pGraphEmbryo.reset();
}

SharedExecStreamGraph ExecStreamTestBase::newStreamGraph

(

)

[protected, virtual, inherited]

Creates a stream graph.

Definition at line 37 of file ExecStreamTestBase.cpp.

References ExecStreamGraph::newExecStreamGraph().

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

{
    SharedExecStreamGraph pGraph = ExecStreamGraph::newExecStreamGraph();
    pGraph->enableDummyTxnId(true);
    return pGraph;
}

SharedExecStreamGraphEmbryo ExecStreamTestBase::newStreamGraphEmbryo

(

SharedExecStreamGraph

)

[protected, virtual, inherited]

Creates an embryo for a stream graph.

Definition at line 45 of file ExecStreamTestBase.cpp.

References CacheTestBase::pCache, ExecStreamTestBase::pScheduler, and SegStorageTestBase::pSegmentFactory.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

{
    return SharedExecStreamGraphEmbryo(
        new ExecStreamGraphEmbryo(
            g, pScheduler, pCache, pSegmentFactory));
}

ExecStreamScheduler * ExecStreamTestBase::newScheduler

(

)

[protected, virtual, inherited]

Creates a scheduler.

Reimplemented in ParallelExecStreamSchedulerTest.

Definition at line 52 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), and ExecStreamTestBase::testCaseSetUp().

{
    return new DfsTreeExecStreamScheduler(
        shared_from_this(),
        "DfsTreeExecStreamScheduler");
}

ExecStreamGovernor * ExecStreamTestBase::newResourceGovernor	(	ExecStreamResourceKnobs const &	knobSettings,
		ExecStreamResourceQuantity const &	resourcesAvailable
	)			[protected, virtual, inherited]

Creates the resource governor.

Definition at line 59 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

{
    return new SimpleExecStreamGovernor(
        knobSettings, resourcesAvailable, shared_from_this(),
        "SimpleExecStreamGovernor");
}

void SegStorageTestBase::openStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SegmentTestBase.

Definition at line 31 of file SegStorageTestBase.cpp.

References SegStorageTestBase::openSegmentStorage(), and CacheTestBase::openStorage().

Referenced by SegStorageTestBase::openRandomSegment(), SegmentTestBase::openStorage(), LhxHashTableTest::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LbmEntryTest::testCaseSetUp(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), LogicalTxnTest::testTxn(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

{
    CacheTestBase::openStorage(openMode);
    openSegmentStorage(openMode);
}

void SegStorageTestBase::openSegmentStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented in LinearViewSegmentTest, SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 37 of file SegStorageTestBase.cpp.

References CacheTestBase::cbPageFull, DeviceMode::create, SegStorageTestBase::createLinearDeviceSegment(), CacheTestBase::dataDeviceId, SegStorageTestBase::pLinearSegment, and CacheTestBase::pRandomAccessDevice.

Referenced by VersionedSegmentTest::openSegmentStorage(), and SegStorageTestBase::openStorage().

{
    pLinearSegment = createLinearDeviceSegment(
        dataDeviceId,
        openMode.create ? 0
        : pRandomAccessDevice->getSizeInBytes() / cbPageFull);
}

SharedSegment SegStorageTestBase::createLinearDeviceSegment	(	DeviceId	deviceId,
		uint	nPages
	)			[inherited]

Definition at line 56 of file SegStorageTestBase.cpp.

References LinearDeviceSegmentParams::firstBlockId, LinearDeviceSegmentParams::nPagesAllocated, LinearDeviceSegmentParams::nPagesMin, CacheTestBase::pCache, SegStorageTestBase::pSegmentFactory, CompoundId::setBlockNum(), and CompoundId::setDeviceId().

Referenced by VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), and LinearViewSegmentTest::openSegmentStorage().

{
    BlockId blockId(0);
    CompoundId::setDeviceId(blockId,deviceId);
    CompoundId::setBlockNum(blockId,0);
    LinearDeviceSegmentParams deviceParams;
    deviceParams.firstBlockId = blockId;
    deviceParams.nPagesMin = nPages;
    deviceParams.nPagesAllocated = nPages;
    return pSegmentFactory->newLinearDeviceSegment(
        pCache,deviceParams);
}

void SegStorageTestBase::closeLinearSegment

(

)

[inherited]

Definition at line 70 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pLinearSegment.

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeStorage(), and SnapshotSegmentTest::testUncommittedReads().

{
    if (pLinearSegment) {
        assert(pLinearSegment.unique());
        pLinearSegment.reset();
    }
}

void SegStorageTestBase::closeRandomSegment

(

)

[inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

Referenced by VersionedSegmentTest::closeStorage(), and SegStorageTestBase::closeStorage().

{
    if (pRandomSegment) {
        assert(pRandomSegment.unique());
        pRandomSegment.reset();
    }
}

void SegStorageTestBase::closeVersionedRandomSegment

(

)

[inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage(), and SegStorageTestBase::closeStorage().

{
    if (pVersionedRandomSegment) {
        assert(pVersionedRandomSegment.unique());
        pVersionedRandomSegment.reset();
    }
}

void SegStorageTestBase::closeSnapshotRandomSegment

(

)

[inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

{
    if (pSnapshotRandomSegment) {
        assert(pSnapshotRandomSegment.unique());
        pSnapshotRandomSegment.reset();
    }
}

void SegStorageTestBase::closeStorage

(

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeRandomSegment(), CacheTestBase::closeStorage(), and SegStorageTestBase::closeVersionedRandomSegment().

Referenced by VersionedSegmentTest::closeStorage(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::openRandomSegment(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), SegmentTestBase::testSingleThread(), SegStreamTest::testWriteSeg(), and SegStreamTest::testWriteSpillAndRead().

{
    closeLinearSegment();
    closeRandomSegment();
    closeVersionedRandomSegment();
    // TODO:  assert pSegmentFactory.unique(), but not here
    CacheTestBase::closeStorage();
}

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(), PagingTestBase::testCacheResize(), PagingTestBase::testCheckpoint(), PagingTestBase::testOp(), PagingTestBase::testScratch(), SegmentTestBase::unlockPage(), and CacheTest::unlockPage().

{
    return *pCache;
}

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().

{
    switch (victimPolicy) {
    case victimRandom:
        return SharedCache(
            new RandomCache(cacheParams),
            ClosableObjectDestructor());
    case victimLRU:
        return SharedCache(
            new LRUCache(cacheParams),
            ClosableObjectDestructor());
    case victimTwoQ:
        return Cache::newCache(cacheParams);
    default:
        permAssert(false);
    }
}

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().

{
    if (openMode.create) {
        FileSystem::remove(devName.c_str());
    }
    SharedRandomAccessDevice pDevice(
        new RandomAccessFileDevice(devName,openMode));
    if (openMode.create) {
        pDevice->setSizeInBytes(nDevicePages*cbPageFull);
    }
    pCache->registerDevice(deviceId,pDevice);
    return pDevice;
}

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().

{
    if (!pDevice) {
        return;
    }
    DeviceIdPagePredicate pagePredicate(deviceId);
    pCache->checkpointPages(pagePredicate,CHECKPOINT_FLUSH_AND_UNMAP);
    pCache->unregisterDevice(deviceId);
    assert(pDevice.unique());
    pDevice.reset();
}

void TestBase::snooze

(

uint

nSeconds

)

[protected, inherited]

Definition at line 263 of file TestBase.cpp.

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

{
#ifdef __MSVC__
    ::_sleep(nSeconds*1000);
#else
    ::sleep(nSeconds);
#endif
}

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.

{
    bool verbose = false;
    ConfigMap adhocMap;

    for (int i = 1; i < argc; ++i) {
        std::string arg = argv[i];
        if (argv[i][0] == '-') {
            if (arg == "-v") {
                verbose = true;
            } else if (arg == "-") {
                configMap.readParams(std::cin);
            } else if (arg == "-all") {
                runAll = true;
            } else if (arg == "-t") {   // -t TEST
                permAssert(i + 1 < argc);
                runSingle = argv[++i];
            } else if (arg[1] == 't') { // allow -tTEST
                runSingle = arg.substr(2);
            }
        } else {
            int i = arg.find("=");
            if ((0 < i) && (i < arg.size())) {
                // an ad hoc parameter
                std::string key = arg.substr(0,i);
                std::string val = arg.substr(i + 1);
                adhocMap.setStringParam(key,val);
            } else {
                // a config file name
                std::ifstream configFile(arg.c_str());
                assert(configFile.good());
                configMap.readParams(configFile);
            }
        }
    }
    configMap.mergeFrom(adhocMap);

    // set a default dictionary file location for use by tests that need a
    // small non-random sorted data set
    if (!configMap.isParamSet(paramDictionaryFileName)) {
        std::string dictFileName = "dictWords";
        configMap.setStringParam(paramDictionaryFileName,dictFileName);
    }

    if (verbose) {
        configMap.dumpParams(std::cout);
    }
}

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.

{
    assert(pTestObj);
    assert(pTestObj.use_count() > 1);

    // release self-reference now that all test cases have been registered
    pTestObj.reset();

    TestSuite* pTestSuite = BOOST_TEST_SUITE(testName.c_str());

    if (runSingle.size()) {
        test_unit *p =  defaultTests.findTest(runSingle);
        if (!p) {
            p = extraTests.findTest(runSingle);
        }
        if (!p) {
            std::cerr << "test " << runSingle << " not found\n";
            exit(2);
        }
        pTestSuite->add(p);
    } else {
        defaultTests.addAllToTestSuite(pTestSuite);
        if (runAll) {
            extraTests.addAllToTestSuite(pTestSuite);
        }
    }
    return pTestSuite;
}

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.

{
    notifyTrace(testName,TRACE_INFO,"ENTER:  " + testCaseName);

    // Install the AutoBacktrace signal handler now, after
    // boost::execution_monitor::catch_signals() has installed its own, so that
    // on SIGABRT AutoBacktrace goes first, prints the backtrace, then chains
    // to boost, which handles the error.
    AutoBacktrace::setOutputStream();
    AutoBacktrace::setTraceTarget(shared_from_this());
    AutoBacktrace::install();
    configMap.initTraceSource(shared_from_this(), "testConfig");
}

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.

{
    AutoBacktrace::setTraceTarget();
    configMap.disableTracing();
    notifyTrace(testName,TRACE_INFO,"LEAVE:  " + testCaseName);
}

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().

{
    if (traceFile || traceStdout) {
        StrictMutexGuard traceMutexGuard(traceMutex);
        if (traceFile) {
            traceStream << "[" << source << "] " << message << std::endl;
            traceStream.flush();
        }
        if (traceStdout) {
            std::cout << "[" << source << "] " << message << std::endl;
            std::cout.flush();
        }
    }
}

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().

{
    return traceLevel;
}

void SnapshotSegmentTestBase::setForceCacheUnmap

(

SharedSegment

pSegment

)

[protected, inherited]

Forces the underlying snapshot segment to always execute its checkpoints during a cache flush and unmap.

Definition at line 87 of file SnapshotSegmentTestBase.cpp.

References SnapshotRandomAllocationSegment::setForceCacheUnmap().

Referenced by SnapshotSegmentTestBase::openSegmentStorage(), testClusterReplace(), and SnapshotSegmentTest::testUncommittedReads().

{
    // Force the snapshot segment to always execute its checkpoints during
    // a cache flush and unmap, in order to unmap these page from the cache
    if (pSegment) {
        SnapshotRandomAllocationSegment *pSnapshotSegment =
            SegmentFactory::dynamicCast<SnapshotRandomAllocationSegment *>(
                pSegment);
        pSnapshotSegment->setForceCacheUnmap();
    }
}

void SnapshotSegmentTestBase::commitChanges

(

TxnId

commitCsn

)

[protected, inherited]

Commits transactions associated with a specified csn.

Parameters:

commitCsn

the specified csn

Definition at line 161 of file SnapshotSegmentTestBase.cpp.

References SnapshotSegmentTestBase::commit, SnapshotRandomAllocationSegment::commitChanges(), SegStorageTestBase::pSnapshotRandomSegment, and SnapshotRandomAllocationSegment::rollbackChanges().

Referenced by SnapshotSegmentTestBase::closeStorage().

{
    if (pSnapshotRandomSegment) {
        SnapshotRandomAllocationSegment *pSnapshotSegment =
            SegmentFactory::dynamicCast<SnapshotRandomAllocationSegment *>(
                pSnapshotRandomSegment);
        if (commit) {
            pSnapshotSegment->commitChanges(commitCsn);
        } else {
            pSnapshotSegment->rollbackChanges();
        }
    }
}

void SnapshotSegmentTestBase::openSegmentStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented from SegStorageTestBase.

Definition at line 47 of file SnapshotSegmentTestBase.cpp.

References DeviceMode::create, SegStorageTestBase::createLinearDeviceSegment(), SnapshotSegmentTestBase::currCsn, CacheTestBase::dataDeviceId, SnapshotSegmentTestBase::firstPageId, CacheTestBase::nDiskPages, SnapshotSegmentTestBase::nDiskPagesTotal, NULL_PAGE_ID, CacheTestBase::openDevice(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, SegStorageTestBase::pSegmentFactory, SegStorageTestBase::pSnapshotRandomSegment, SnapshotSegmentTestBase::pTempDevice, SnapshotSegmentTestBase::pTempSegment, SegStorageTestBase::pVersionedRandomSegment, SnapshotSegmentTestBase::setForceCacheUnmap(), and SnapshotSegmentTestBase::tempDeviceId.

{
    nDiskPages = nDiskPagesTotal;
    if (openMode.create) {
        firstPageId = NULL_PAGE_ID;
    }

    pTempDevice =
        openDevice("temp.dat", openMode, nDiskPages / 50, tempDeviceId);
    SharedSegment pTempDeviceSegment =
        createLinearDeviceSegment(tempDeviceId, nDiskPages / 50);
    pTempSegment =
        pSegmentFactory->newRandomAllocationSegment(
            pTempDeviceSegment,
            openMode.create);

    SharedSegment pDeviceSegment =
        createLinearDeviceSegment(dataDeviceId, nDiskPages);
    pVersionedRandomSegment =
        pSegmentFactory->newVersionedRandomAllocationSegment(
            pDeviceSegment,
            pTempSegment,
            openMode.create);
    pSnapshotRandomSegment =
        pSegmentFactory->newSnapshotRandomAllocationSegment(
            pVersionedRandomSegment,
            pVersionedRandomSegment,
            currCsn);
    setForceCacheUnmap(pSnapshotRandomSegment);

    pRandomSegment = pSnapshotRandomSegment;

    nDiskPages /= 2;
    SharedSegment pLinearViewSegment =
        pSegmentFactory->newLinearViewSegment(
            pSnapshotRandomSegment,
            firstPageId);
    pLinearSegment = pLinearViewSegment;
}

void SnapshotSegmentTestBase::closeStorage

(

)

[virtual, inherited]

Reimplemented from SegStorageTestBase.

Definition at line 99 of file SnapshotSegmentTestBase.cpp.

References CacheTestBase::closeDevice(), SegStorageTestBase::closeLinearSegment(), SegStorageTestBase::closeSnapshotRandomSegment(), SegStorageTestBase::closeStorage(), SegStorageTestBase::closeVersionedRandomSegment(), SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::currCsn, VersionedRandomAllocationSegment::freeTempPages(), SegStorageTestBase::pRandomSegment, SnapshotSegmentTestBase::pSnapshotRandomSegment2, SnapshotSegmentTestBase::pTempDevice, SnapshotSegmentTestBase::pTempSegment, SegStorageTestBase::pVersionedRandomSegment, and SnapshotSegmentTestBase::tempDeviceId.

Referenced by BackupRestoreTest::backup(), SnapshotSegmentTest::deallocateOldPages(), BackupRestoreTest::restore(), BackupRestoreTest::testBackupRestore(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testRollback(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and BackupRestoreTest::verifyData().

{
    commitChanges(currCsn);
    closeLinearSegment();
    pRandomSegment.reset();
    closeSnapshotRandomSegment();
    if (pSnapshotRandomSegment2) {
        assert(pSnapshotRandomSegment2.unique());
        pSnapshotRandomSegment2.reset();
    }
    // Free leftover temp pages used during page versioning
    if (pVersionedRandomSegment) {
        VersionedRandomAllocationSegment *pVRSegment =
            SegmentFactory::dynamicCast<VersionedRandomAllocationSegment *>(
                pVersionedRandomSegment);
        pVRSegment->freeTempPages();
    }
    closeVersionedRandomSegment();
    if (pTempSegment) {
        // Confirm that all temp pages have been freed.
        BOOST_REQUIRE(pTempSegment->getAllocatedSizeInPages() == 0);
        assert(pTempSegment.unique());
        pTempSegment.reset();
    }
    if (pTempDevice) {
        closeDevice(tempDeviceId, pTempDevice);
    }
    SegmentTestBase::closeStorage();
}

void SnapshotSegmentTestBase::testAllocateAll

(

)

[virtual, inherited]

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

Reimplemented from PagingTestBase.

Definition at line 129 of file SnapshotSegmentTestBase.cpp.

References SnapshotSegmentTestBase::firstPageId, LinearViewSegment::getFirstPageId(), NULL_PAGE_ID, SegStorageTestBase::pLinearSegment, and PagingTestBase::testAllocateAll().

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

{
    SegmentTestBase::testAllocateAll();
    assert(firstPageId == NULL_PAGE_ID);
    LinearViewSegment *pLinearViewSegment =
        SegmentFactory::dynamicCast<LinearViewSegment *>(pLinearSegment);
    assert(pLinearViewSegment);
    firstPageId = pLinearViewSegment->getFirstPageId();
}

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

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

Reimplemented from PagingTestBase.

Definition at line 139 of file SnapshotSegmentTestBase.cpp.

References SnapshotSegmentTestBase::currCsn, opaqueToInt(), SnapshotSegmentTestBase::updatedCsns, and PagingTestBase::verifyPage().

{
    // If the pageId is a multiple of one of the csn's smaller than the
    // current csn, then the page should reflect the update made by
    // that smaller csn
    uint update = 0;
    for (int i = updatedCsns.size() - 1; i >= 0; i--) {
        if (updatedCsns[i] <= currCsn &&
            x % opaqueToInt(updatedCsns[i]) == 0)
        {
            update = opaqueToInt(updatedCsns[i]);
            break;
        }
    }
    SegmentTestBase::verifyPage(page, x + update);
}

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

Scribbles on the contents of a page.

The data written is derived from the parameter x.

Reimplemented from PagingTestBase.

Definition at line 156 of file SnapshotSegmentTestBase.cpp.

References SnapshotSegmentTestBase::currCsn, PagingTestBase::fillPage(), and opaqueToInt().

{
    SegmentTestBase::fillPage(page, x + opaqueToInt(currCsn));
}

void SegmentTestBase::openStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented from SegStorageTestBase.

Definition at line 37 of file SegmentTestBase.cpp.

References PagingTestBase::cbPageUsable, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_DEALLOCATE, SegStorageTestBase::openStorage(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, and ThreadedTestBase::threadCounts.

Referenced by BackupRestoreTest::backup(), SnapshotSegmentTest::deallocateOldPages(), BackupRestoreTest::restore(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupRestore(), SnapshotSegmentTest::testDeallocateOld(), VersionedSegmentTest::testRecovery(), SnapshotSegmentTest::testRollback(), SegmentTestBase::testSingleThread(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and BackupRestoreTest::verifyData().

{
    SegStorageTestBase::openStorage(openMode);
    cbPageUsable = pLinearSegment->getUsablePageSize();
    if (!pRandomSegment) {
        threadCounts[OP_ALLOCATE] = 0;
        threadCounts[OP_DEALLOCATE] = 0;
    }
}

CachePage * SegmentTestBase::lockPage	(	OpType	opType,
		uint	iPage
	)			[virtual, inherited]

Implements PagingTestBase.

Definition at line 47 of file SegmentTestBase.cpp.

References SegPageLock::allocatePage(), SegPageLock::dontUnlock(), PagingTestBase::fillPage(), Segment::getLinearBlockNum(), Segment::getLinearPageId(), PagingTestBase::getLockMode(), SegPageLock::getPage(), SegPageLock::isLocked(), SegPageLock::lockPage(), SegmentTestBase::objId, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_WRITE_RAND, PagingTestBase::OP_WRITE_SEQ, PagingTestBase::OP_WRITE_SKIP, CacheTestBase::pCache, and SegStorageTestBase::pLinearSegment.

{
    SegmentAccessor segmentAccessor(pLinearSegment,pCache);
    SegPageLock pageLock(segmentAccessor);
    if (opType == OP_ALLOCATE) {
        PageId pageId = pageLock.allocatePage(objId);
        assert(Segment::getLinearBlockNum(pageId) == iPage);
        CachePage &page = pageLock.getPage();
        fillPage(page,iPage);
        pageLock.dontUnlock();
        return &page;
    } else {
        PageId pageId = Segment::getLinearPageId(iPage);
        // Prepare the page for update before locking it
        if (opType == OP_WRITE_SEQ || opType == OP_WRITE_RAND ||
            opType == OP_WRITE_SKIP)
        {
            pLinearSegment->updatePage(pageId, true);
        }
        pageLock.lockPage(pageId,getLockMode(opType));
        CachePage *pPage = pageLock.isLocked() ? &(pageLock.getPage()) : NULL;
        pageLock.dontUnlock();
        return pPage;
    }
}

void SegmentTestBase::unlockPage	(	CachePage &	page,
		LockMode	lockMode
	)			[virtual, inherited]

Implements PagingTestBase.

Definition at line 73 of file SegmentTestBase.cpp.

References CacheTestBase::getCache(), and CacheAccessor::unlockPage().

{
    getCache().unlockPage(page,lockMode);
}

void SegmentTestBase::prefetchPage

(

uint

iPage

)

[virtual, inherited]

Implements PagingTestBase.

Definition at line 78 of file SegmentTestBase.cpp.

References CacheTestBase::getCache(), Segment::getLinearPageId(), SegStorageTestBase::pLinearSegment, and CacheAccessor::prefetchPage().

{
    PageId pageId = Segment::getLinearPageId(iPage);
    BlockId blockId = pLinearSegment->translatePageId(pageId);
    getCache().prefetchPage(blockId,pLinearSegment.get());
}

void SegmentTestBase::prefetchBatch	(	uint	,
		uint
	)			[virtual, inherited]

Implements PagingTestBase.

Definition at line 85 of file SegmentTestBase.cpp.

{
    permAssert(false);
}

void SegmentTestBase::testAllocate

(

)

[virtual, inherited]

Reimplemented from PagingTestBase.

Definition at line 90 of file SegmentTestBase.cpp.

References SegmentTestBase::freeablePages, SegmentTestBase::freeablePagesMutex, PagingTestBase::logMutex, PagingTestBase::nRandomOps, NULL_PAGE_ID, SegmentTestBase::objId, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, SegPageLock::tryAllocatePage(), and SegPageLock::unlock().

{
    assert(pRandomSegment);

    uint i;
    SegmentAccessor segmentAccessor(pRandomSegment,pCache);
    for (i = 0; i < nRandomOps; ++i) {
#ifdef HAVE_SCHED_H
        sched_yield();
#else
        // TODO:  call Mingw equivalent
#endif
        SegPageLock pageLock(segmentAccessor);
        PageId pageId = pageLock.tryAllocatePage(objId);
        if (pageId == NULL_PAGE_ID) {
            break;
        }
        pageLock.unlock();
        StrictMutexGuard freeablePagesGuard(freeablePagesMutex);
        freeablePages.push_back(pageId);
    }
    if (i) {
        StrictMutexGuard logGuard(logMutex);
        BOOST_MESSAGE("completed " << i << " allocate ops");
    }
}

void SegmentTestBase::testDeallocate

(

)

[virtual, inherited]

Reimplemented from PagingTestBase.

Definition at line 117 of file SegmentTestBase.cpp.

References SegPageLock::deallocateLockedPage(), SegmentTestBase::freeablePages, SegmentTestBase::freeablePagesMutex, PagingTestBase::generateRandomNumber(), SegPageLock::lockShared(), PagingTestBase::logMutex, PagingTestBase::nRandomOps, CacheTestBase::pCache, and SegStorageTestBase::pRandomSegment.

{
    assert(pRandomSegment);

    uint i;
    SegmentAccessor segmentAccessor(pRandomSegment,pCache);
    for (i = 0; i < nRandomOps; ++i) {
#ifdef HAVE_SCHED_H
        sched_yield();
#else
        // TODO:  call Mingw equivalent
#endif
        StrictMutexGuard freeablePagesGuard(freeablePagesMutex);
        if (freeablePages.empty()) {
            break;
        }
        uint i = generateRandomNumber(freeablePages.size());
        PageId pageId = freeablePages[i];
        freeablePages.erase(freeablePages.begin() + i);
        freeablePagesGuard.unlock();
        SegPageLock pageLock(segmentAccessor);
        pageLock.lockShared(pageId);
        pageLock.deallocateLockedPage();
    }
    if (i) {
        StrictMutexGuard logGuard(logMutex);
        BOOST_MESSAGE("completed " << i << " deallocate ops");
    }
}

void SegmentTestBase::testCheckpoint

(

)

[virtual, inherited]

Performs a periodic checkpoint.

Reimplemented from PagingTestBase.

Reimplemented in VersionedSegmentTest.

Definition at line 147 of file SegmentTestBase.cpp.

References CHECKPOINT_FLUSH_ALL, and SegStorageTestBase::pLinearSegment.

{
    pLinearSegment->checkpoint(CHECKPOINT_FLUSH_ALL);
}

void SegmentTestBase::testSingleThread

(

)

[inherited]

Definition at line 161 of file SegmentTestBase.cpp.

References SegStorageTestBase::closeStorage(), DeviceMode::createNew, SegmentTestBase::freeablePages, DeviceMode::load, SegmentTestBase::openStorage(), PagingTestBase::testAllocateAll(), PagingTestBase::testRandomRead(), PagingTestBase::testRandomWrite(), PagingTestBase::testSequentialRead(), and PagingTestBase::testSequentialWrite().

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

{
    openStorage(DeviceMode::createNew);
    testAllocateAll();
    testSequentialRead();
    testSequentialWrite();
    testRandomRead();
    closeStorage();
    openStorage(DeviceMode::load);
    testRandomRead();
    testRandomWrite();
    testSequentialRead();
    closeStorage();
    freeablePages.clear();
}

uint PagingTestBase::generateRandomNumber

(

uint

iMax

)

[protected, inherited]

Definition at line 53 of file PagingTestBase.cpp.

References g_pRNG.

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

{
    return (*g_pRNG)(iMax);
}

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

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 PagingTestBase::fillPage(), CacheTestBase::getCache(), PagingTestBase::getLockMode(), LOCKMODE_S, LOCKMODE_S_NOWAIT, LOCKMODE_X, LOCKMODE_X_NOWAIT, PagingTestBase::lockPage(), CacheAccessor::nicePage(), PagingTestBase::unlockPage(), and PagingTestBase::verifyPage().

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

{
    CachePage *pPage = lockPage(opType,iPage);
    LockMode lockMode = getLockMode(opType);
    if (!pPage) {
        // must be NoWait locking failed
        assert(lockMode >= LOCKMODE_S_NOWAIT);
        return false;
    }
    CachePage &page = *pPage;
    if (lockMode == LOCKMODE_S
        || lockMode == LOCKMODE_S_NOWAIT)
    {
        verifyPage(page,iPage);
    } else {
        fillPage(page,iPage);
    }
    switch (lockMode) {
    case LOCKMODE_X_NOWAIT:
        lockMode = LOCKMODE_X;
        break;
    case LOCKMODE_S_NOWAIT:
        lockMode = LOCKMODE_S;
        break;
    default:
        break;
    }
    if (bNice) {
        getCache().nicePage(page);
    }
    unlockPage(page,lockMode);
    return true;
}

char const * PagingTestBase::getOpName

(

OpType

opType

)

[inherited]

Makes up an operation name based on an OpType.

Definition at line 119 of file PagingTestBase.cpp.

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

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

{
    switch (opType) {
    case OP_ALLOCATE:
        return "allocate";
    case OP_READ_SEQ:
        return "sequential read";
    case OP_WRITE_SEQ:
        return "sequential write";
    case OP_READ_RAND:
        return "random read";
    case OP_WRITE_RAND:
        return "random write";
    case OP_READ_NOWAIT:
        return "read no-wait";
    case OP_WRITE_NOWAIT:
        return "write no-wait";
    case OP_WRITE_SKIP:
        return "write every n pages";
    default:
        permAssert(false);
    }
}

LockMode PagingTestBase::getLockMode

(

OpType

opType

)

[inherited]

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, PagingTestBase::OP_ALLOCATE, PagingTestBase::OP_READ_NOWAIT, PagingTestBase::OP_READ_RAND, PagingTestBase::OP_READ_SEQ, PagingTestBase::OP_WRITE_NOWAIT, PagingTestBase::OP_WRITE_RAND, PagingTestBase::OP_WRITE_SEQ, and PagingTestBase::OP_WRITE_SKIP.

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

{
    switch (opType) {
    case OP_ALLOCATE:
        return LOCKMODE_X;
    case OP_READ_SEQ:
        return LOCKMODE_S;
    case OP_WRITE_SEQ:
        return LOCKMODE_X;
    case OP_READ_RAND:
        return LOCKMODE_S;
    case OP_WRITE_RAND:
        return LOCKMODE_X;
    case OP_READ_NOWAIT:
        return LOCKMODE_S_NOWAIT;
    case OP_WRITE_NOWAIT:
        return LOCKMODE_X_NOWAIT;
    case OP_WRITE_SKIP:
        return LOCKMODE_X;
    default:
        permAssert(false);
    }
}

void PagingTestBase::testSequentialOp

(

OpType

opType

)

[inherited]

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 PagingTestBase::getOpName(), PagingTestBase::logMutex, CacheTestBase::nDiskPages, and PagingTestBase::testOp().

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

{
    uint n = 0;
    for (uint i = 0; i < nDiskPages; i++) {
        if (testOp(opType,i,true)) {
            n++;
        }
    }
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE(
        "completed " << n << " " << getOpName(opType) << " ops");
}

void PagingTestBase::testRandomOp

(

OpType

opType

)

[inherited]

Carries out an operation on nRandomOps pages selected at random.

Parameters:

opType

see testOp

Definition at line 180 of file PagingTestBase.cpp.

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

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

{
    uint n = 0;
    for (uint i = 0; i < nRandomOps; i++) {
        uint iPage = generateRandomNumber(nDiskPages);
        bool bNice = (generateRandomNumber(nRandomOps) == 0);
        if (testOp(opType,iPage,bNice)) {
            n++;
        }
    }
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE(
        "completed " << n << " " << getOpName(opType) << " ops");

}

void PagingTestBase::testSkipOp	(	OpType	opType,
		uint	n
	)			[inherited]

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 PagingTestBase::getOpName(), PagingTestBase::logMutex, CacheTestBase::nDiskPages, and PagingTestBase::testOp().

Referenced by PagingTestBase::testSkipWrite(), and PagingTestBase::testThreadedOp().

{
    uint numOps = 0;
    for (uint i = 0; i < nDiskPages; i += n) {
        if (testOp(opType,i,true)) {
            numOps++;
        }
    }
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE(
        "completed " << numOps << " " << getOpName(opType) << " ops");
}

void PagingTestBase::testScratch

(

)

[inherited]

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 PagingTestBase::fillPage(), PagingTestBase::generateRandomNumber(), CacheTestBase::getCache(), LOCKMODE_X, PagingTestBase::logMutex, PagingTestBase::nRandomOps, and CacheAccessor::unlockPage().

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

{
    for (uint i = 0; i < nRandomOps; i++) {
        CachePage &page = getCache().lockScratchPage();
        fillPage(page,generateRandomNumber(10000));
        getCache().unlockPage(page,LOCKMODE_X);
    }
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE("completed " << nRandomOps << " random scratch ops");
}

void PagingTestBase::testPrefetch

(

)

[inherited]

Performs a limited number of prefetch operations.

Prefetches are not verified.

Definition at line 220 of file PagingTestBase.cpp.

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

Referenced by PagingTestBase::testThreadedOp().

{
    // TODO: parameterize this
    uint n = 3;
    for (uint i = 0; i < n; i++) {
        uint iPage = generateRandomNumber(nDiskPages);
        prefetchPage(iPage);
    }
    // give the prefetches a chance to complete
    snooze(1);
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE("completed " << n << " random prefetch ops");
}

void PagingTestBase::testPrefetchBatch

(

)

[inherited]

Performs a limited number of batch prefetch operations.

Prefetches are not verified.

Definition at line 234 of file PagingTestBase.cpp.

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

Referenced by PagingTestBase::testThreadedOp().

{
    // TODO: parameterize this
    uint n = 2;
    uint nPagesPerBatch = 4;
    for (uint i = 0; i < n; i++) {
        uint iPage = generateRandomNumber(nDiskPages - nPagesPerBatch);
        prefetchBatch(iPage,nPagesPerBatch);
    }
    // give the prefetches a chance to complete
    snooze(1);
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE("completed " << n << " random prefetch batch ops");
}

void PagingTestBase::testSequentialRead

(

)

[inherited]

Carries out one sequential read pass over the entire device.

Definition at line 254 of file PagingTestBase.cpp.

References PagingTestBase::OP_READ_SEQ, and PagingTestBase::testSequentialOp().

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

{
    testSequentialOp(OP_READ_SEQ);
}

void PagingTestBase::testSequentialWrite

(

)

[inherited]

Carries out one sequential write pass over the entire device.

Definition at line 259 of file PagingTestBase.cpp.

References PagingTestBase::OP_WRITE_SEQ, and PagingTestBase::testSequentialOp().

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

{
    testSequentialOp(OP_WRITE_SEQ);
}

void PagingTestBase::testRandomRead

(

)

[inherited]

Carries out nRandomOps read operations on pages selected at random.

Definition at line 264 of file PagingTestBase.cpp.

References PagingTestBase::OP_READ_RAND, and PagingTestBase::testRandomOp().

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

{
    testRandomOp(OP_READ_RAND);
}

void PagingTestBase::testRandomWrite

(

)

[inherited]

Carries out nRandomOps write operations on pages selected at random.

Definition at line 269 of file PagingTestBase.cpp.

References PagingTestBase::OP_WRITE_RAND, and PagingTestBase::testRandomOp().

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

{
    testRandomOp(OP_WRITE_RAND);
}

void PagingTestBase::testSkipWrite

(

uint

n

)

[inherited]

Carries out write operations every n pages.

Parameters:

n

offset between pages

Definition at line 274 of file PagingTestBase.cpp.

References PagingTestBase::OP_WRITE_SKIP, and PagingTestBase::testSkipOp().

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

{
    testSkipOp(OP_WRITE_SKIP, n);
}

void PagingTestBase::testCheckpointGuarded

(

)

[inherited]

Definition at line 295 of file PagingTestBase.cpp.

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

Referenced by PagingTestBase::testThreadedOp().

{
    snooze(nSecondsBetweenCheckpoints);
    StrictMutexGuard logGuard(logMutex);
    BOOST_MESSAGE("checkpoint started");
    logGuard.unlock();
    SXMutexExclusiveGuard checkpointExclusiveGuard(checkpointMutex);
    testCheckpoint();
    checkpointExclusiveGuard.unlock();
    logGuard.lock();
    BOOST_MESSAGE("checkpoint completed");
}

void PagingTestBase::testCacheResize

(

)

[inherited]

Definition at line 308 of file PagingTestBase.cpp.

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

Referenced by PagingTestBase::testThreadedOp().

{
    snooze(nSeconds / 3);
    getCache().setAllocatedPageCount(nMemPages / 2);
    StrictMutexGuard mutexGuard(logMutex);
    BOOST_MESSAGE("shrank cache");
    mutexGuard.unlock();
    snooze(nSeconds / 3);
    getCache().setAllocatedPageCount(nMemPages - 1);
    mutexGuard.lock();
    BOOST_MESSAGE("expanded cache");
    mutexGuard.unlock();
}

void PagingTestBase::testMultipleThreads

(

)

[inherited]

Carries out specified tests in multi-threaded mode.

Definition at line 431 of file PagingTestBase.cpp.

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

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

{
    openStorage(DeviceMode::createNew);
    testAllocateAll();
    runThreadedTestCase();
}

void PagingTestBase::threadInit

(

)

[virtual, inherited]

Reimplemented from ThreadedTestBase.

Definition at line 41 of file PagingTestBase.cpp.

References g_pRNG, and ThreadedTestBase::threadInit().

Referenced by PagingTestBase::PagingTestBase().

{
    ThreadedTestBase::threadInit();
    g_pRNG.reset(new std::subtractive_rng());
}

void PagingTestBase::threadTerminate

(

)

[virtual, inherited]

Reimplemented from ThreadedTestBase.

Definition at line 47 of file PagingTestBase.cpp.

References g_pRNG, and ThreadedTestBase::threadTerminate().

Referenced by PagingTestBase::~PagingTestBase().

{
    g_pRNG.reset();
    ThreadedTestBase::threadTerminate();
}

bool PagingTestBase::testThreadedOp

(

int

iOp

)

[virtual, inherited]

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

{
    SXMutexSharedGuard checkpointSharedGuard(checkpointMutex,false);
    assert(iOp < OP_MAX);
    OpType op = static_cast<OpType>(iOp);
    switch (op) {
    case PagingTestBase::OP_WRITE_SEQ:
        checkpointSharedGuard.lock();
        // fall through
    case PagingTestBase::OP_READ_SEQ:
        testSequentialOp(op);
        break;
    case PagingTestBase::OP_WRITE_RAND:
    case PagingTestBase::OP_WRITE_NOWAIT:
        checkpointSharedGuard.lock();
        // fall through
    case PagingTestBase::OP_READ_RAND:
    case PagingTestBase::OP_READ_NOWAIT:
        testRandomOp(op);
        break;
    case PagingTestBase::OP_WRITE_SKIP:
        checkpointSharedGuard.lock();
        testSkipOp(op, 5);
        break;
    case PagingTestBase::OP_SCRATCH:
        testScratch();
        break;
    case PagingTestBase::OP_PREFETCH:
        testPrefetch();
        break;
    case PagingTestBase::OP_PREFETCH_BATCH:
        testPrefetchBatch();
        break;
    case PagingTestBase::OP_ALLOCATE:
        checkpointSharedGuard.lock();
        testAllocate();
        break;
    case PagingTestBase::OP_DEALLOCATE:
        checkpointSharedGuard.lock();
        testDeallocate();
        break;
    case PagingTestBase::OP_CHECKPOINT:
        testCheckpointGuarded();
        break;
    case PagingTestBase::OP_RESIZE_CACHE:
        testCacheResize();
        return false;
    default:
        permAssert(false);
    }
    return true;
}

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 PagingTestBase::testMultipleThreads(), and BTreeTxnTest::testTxns().

{
    bDone = false;

    // materialize default thread counts
    std::replace_if(
        threadCounts.begin(),
        threadCounts.end(),
        std::bind2nd(std::equal_to<int>(),-1),
        defaultThreadCount);

    // calculate how many threads are needed
    int nThreads = std::accumulate(
        threadCounts.begin(),
        threadCounts.end(),
        0);

    // initialize a barrier to make sure they all start at once
    pStartBarrier.reset(new boost::barrier(nThreads));

    // fire 'em up
    ThreadPool<ThreadedTestBaseTask> threadPool;
    threadPool.start(nThreads);

    // and distribute the tasks
    for (uint i = 0; i < threadCounts.size(); ++i) {
        for (int j = 0; j < threadCounts[i]; ++j) {
            ThreadedTestBaseTask task(*this,i);
            threadPool.submitTask(task);
        }
    }

    // run the tests for the requested duration
    snooze(nSeconds);

    // tell threads to quit and then wait for them to finish up
    bDone = true;
    threadPool.stop();
}

---

Member Data Documentation

StandardTypeDescriptorFactory LcsClusterReplaceExecStreamTest::stdTypeFactory [private]

Definition at line 50 of file LcsClusterReplaceExecStreamTest.cpp.

Referenced by testCaseSetUp().

TupleAttributeDescriptor LcsClusterReplaceExecStreamTest::attrDesc_int64 [private]

Definition at line 51 of file LcsClusterReplaceExecStreamTest.cpp.

Referenced by initClusterAppendParams(), loadCluster(), replaceCluster(), testCaseSetUp(), and verifyCluster().

TupleAttributeDescriptor LcsClusterReplaceExecStreamTest::attrDesc_bitmap [private]

Definition at line 52 of file LcsClusterReplaceExecStreamTest.cpp.

Referenced by testCaseSetUp(), and verifyCluster().

PageId LcsClusterReplaceExecStreamTest::savedRootPageId [private]

Definition at line 54 of file LcsClusterReplaceExecStreamTest.cpp.

Referenced by loadCluster(), replaceCluster(), and testCaseSetUp().

BTreeDescriptor LcsClusterReplaceExecStreamTest::btreeDescriptor [private]

Definition at line 55 of file LcsClusterReplaceExecStreamTest.cpp.

Referenced by initClusterAppendParams(), loadCluster(), replaceCluster(), testCaseTearDown(), and verifyCluster().

SharedExecStreamGraph ExecStreamUnitTestBase::pGraph [protected, inherited]

Definition at line 46 of file ExecStreamUnitTestBase.h.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamUnitTestBase::prepareConfluenceTransformGraph(), ExecStreamUnitTestBase::prepareDAG(), ExecStreamUnitTestBase::prepareTransformGraph(), ExecStreamUnitTestBase::resetExecStreamTest(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamUnitTestBase::tearDownExecStreamTest(), ExecStreamTestSuite::testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), CorrelationJoinExecStreamTestSuite::testCorrelationJoin(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), LbmLoadBitmapTest::testLoad(), ExecStreamTestSuite::testReshapeExecStream(), LbmSearchTest::testScanIdx(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedExecStreamGraphEmbryo ExecStreamUnitTestBase::pGraphEmbryo [protected, inherited]

Definition at line 47 of file ExecStreamUnitTestBase.h.

Referenced by ExecStreamUnitTestBase::prepareConfluenceGraph(), ExecStreamUnitTestBase::prepareConfluenceTransformGraph(), ExecStreamUnitTestBase::prepareDAG(), ExecStreamUnitTestBase::prepareTransformGraph(), ExecStreamUnitTestBase::resetExecStreamTest(), ExecStreamUnitTestBase::tearDownExecStreamTest(), and ExecStreamUnitTestBase::testCaseSetUp().

const uint ExecStreamTestBase::DefaultCacheReservePercent = 5 [static, protected, inherited]

Definition at line 45 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

const uint ExecStreamTestBase::DefaultConcurrentStatements = 4 [static, protected, inherited]

Definition at line 47 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

SharedExecStreamScheduler ExecStreamTestBase::pScheduler [protected, inherited]

Definition at line 49 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::newStreamGraphEmbryo(), ExecStreamUnitTestBase::resetExecStreamTest(), ExecStreamTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedExecStreamGovernor ExecStreamTestBase::pResourceGovernor [protected, inherited]

Definition at line 51 of file ExecStreamTestBase.h.

Referenced by ExecStreamUnitTestBase::resetExecStreamTest(), ExternalSortExecStreamTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseSetUp(), ExecStreamGovernorTest::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamGovernorTest::testMinGreaterAllocation(), ExecStreamUnitTestBase::verifyBufferedOutput(), ExecStreamUnitTestBase::verifyConstantOutput(), FlatFileExecStreamTest::verifyOutput(), and ExecStreamUnitTestBase::verifyOutput().

SharedCacheAccessor ExecStreamTestBase::pCacheAccessor [protected, inherited]

Definition at line 53 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestSuite::testBTreeInsertExecStream(), ExecStreamUnitTestBase::testCaseSetUp(), ExecStreamTestBase::testCaseTearDown(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferExecStream(), and ExecStreamTestSuite::testSegBufferReaderWriterExecStream().

SharedSegmentFactory SegStorageTestBase::pSegmentFactory [protected, inherited]

Definition at line 40 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), BackupRestoreTest::restore(), SegStorageTestBase::SegStorageTestBase(), LbmSplicerExecStreamTest::spliceInput(), ExecStreamTestSuite::testBTreeInsertExecStream(), LhxHashTableTest::testCaseSetUp(), testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), BTreeTest::testScan(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

SharedSegment SegStorageTestBase::pLinearSegment [protected, inherited]

Segment supporting linear page allocation.

Definition at line 45 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeLinearSegment(), LogicalTxnTest::createRecoveryLog(), SegmentTestBase::lockPage(), SegStorageTestBase::openRandomSegment(), VersionedSegmentTest::openSegmentStorage(), SnapshotSegmentTestBase::openSegmentStorage(), SegStorageTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::prefetchPage(), SnapshotSegmentTestBase::testAllocateAll(), LinearViewSegmentTest::testAllocateAll(), VersionedSegmentTest::testCheckpoint(), SegmentTestBase::testCheckpoint(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), SegStreamTest::testMarkReset(), SegStreamTest::testReadSeg(), VersionedSegmentTest::testRecovery(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), SegStreamTest::testWriteSeg(), and VersionedSegmentTest::verifyPage().

SharedSegment SegStorageTestBase::pRandomSegment [protected, inherited]

(Optional) segment supporting random page allocation.

Definition at line 50 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeRandomSegment(), SnapshotSegmentTestBase::closeStorage(), LbmSplicerExecStreamTest::createBTree(), LbmSplicerExecStreamTest::initBTreeParam(), LbmSearchTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeParam(), LbmLoadBitmapTest::initBTreeTupleDesc(), initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegStorageTestBase::openRandomSegment(), SnapshotSegmentTestBase::openSegmentStorage(), LinearViewSegmentTest::openSegmentStorage(), SegmentTestBase::openStorage(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LcsRowScanExecStreamTest::testCaseSetUp(), LcsMultiClusterAppendTest::testCaseSetUp(), testCaseSetUp(), LcsClusterAppendExecStreamTest::testCaseSetUp(), LbmExecStreamTestBase::testCaseSetUp(), testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), ExecStreamTestSuite::testMergeImplicitPullInputs(), BTreeTest::testMultiKeySearches(), BTreeReadersTest::testReaders(), LcsRowScanExecStreamTest::testScanOnEmptyCluster(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), LhxAggExecStreamTest::testSumImpl(), and LbmUnionExecStreamTest::testUnion().

SharedSegment SegStorageTestBase::pVersionedRandomSegment [protected, inherited]

(Optional) segment supporting versioned random page allocation.

Definition at line 55 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SnapshotSegmentTestBase::closeStorage(), SegStorageTestBase::closeVersionedRandomSegment(), SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTestBase::openSegmentStorage(), BackupRestoreTest::restore(), testClusterReplace(), SnapshotSegmentTest::testRollback(), and SnapshotSegmentTest::testUncommittedReads().

SharedSegment SegStorageTestBase::pSnapshotRandomSegment [protected, inherited]

(Optional) segment supporting snapshot random page allocation.

Definition at line 60 of file SegStorageTestBase.h.

Referenced by SegStorageTestBase::closeSnapshotRandomSegment(), SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::openSegmentStorage(), testClusterReplace(), and SnapshotSegmentTest::testDeallocateOld().

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(), initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), 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(), PagingTestBase::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(), PagingTestBase::testPrefetch(), PagingTestBase::testPrefetchBatch(), PagingTestBase::testRandomOp(), SnapshotSegmentTest::testRollback(), PagingTestBase::testSequentialOp(), and PagingTestBase::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 PagingTestBase::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::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 SnapshotSegmentTestBase::nDiskPagesTotal [protected, inherited]

Definition at line 39 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::openSegmentStorage(), and SnapshotSegmentTestBase::SnapshotSegmentTestBase().

PageId SnapshotSegmentTestBase::firstPageId [protected, inherited]

Definition at line 40 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::openSegmentStorage(), SnapshotSegmentTestBase::testAllocateAll(), SnapshotSegmentTest::testDeallocateOld(), and SnapshotSegmentTest::testUncommittedReads().

DeviceId SnapshotSegmentTestBase::tempDeviceId [protected, inherited]

Definition at line 41 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), SnapshotSegmentTestBase::openSegmentStorage(), and SnapshotSegmentTestBase::SnapshotSegmentTestBase().

SharedRandomAccessDevice SnapshotSegmentTestBase::pTempDevice [protected, inherited]

Definition at line 42 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), and SnapshotSegmentTestBase::openSegmentStorage().

SharedSegment SnapshotSegmentTestBase::pTempSegment [protected, inherited]

Definition at line 43 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), and SnapshotSegmentTestBase::openSegmentStorage().

TxnId SnapshotSegmentTestBase::currCsn [protected, inherited]

Definition at line 44 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), SnapshotSegmentTest::deallocateOldPages(), SnapshotSegmentTestBase::fillPage(), SnapshotSegmentTestBase::openSegmentStorage(), BackupRestoreTest::testBackupRestore(), SnapshotSegmentTestBase::testCaseSetUp(), testClusterReplace(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testRollback(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and SnapshotSegmentTestBase::verifyPage().

std::vector<TxnId> SnapshotSegmentTestBase::updatedCsns [protected, inherited]

Definition at line 45 of file SnapshotSegmentTestBase.h.

Referenced by BackupRestoreTest::testBackupRestore(), SnapshotSegmentTestBase::testCaseSetUp(), SnapshotSegmentTest::testDeallocateOld(), SnapshotSegmentTest::testSnapshotReads(), SnapshotSegmentTest::testUncommittedReads(), and SnapshotSegmentTestBase::verifyPage().

bool SnapshotSegmentTestBase::commit [protected, inherited]

Definition at line 46 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::commitChanges(), SnapshotSegmentTestBase::testCaseSetUp(), and SnapshotSegmentTest::testRollback().

SharedSegment SnapshotSegmentTestBase::pSnapshotRandomSegment2 [protected, inherited]

Definition at line 47 of file SnapshotSegmentTestBase.h.

Referenced by SnapshotSegmentTestBase::closeStorage(), testClusterReplace(), and SnapshotSegmentTest::testUncommittedReads().

std::vector<PageId> SegmentTestBase::freeablePages [protected, inherited]

Queue of allocated pages waiting to be freed.

Definition at line 44 of file SegmentTestBase.h.

Referenced by SegmentTestBase::testAllocate(), SegmentTestBase::testDeallocate(), and SegmentTestBase::testSingleThread().

StrictMutex SegmentTestBase::freeablePagesMutex [protected, inherited]

Mutex protecting freeablePages.

Definition at line 49 of file SegmentTestBase.h.

Referenced by SegmentTestBase::testAllocate(), and SegmentTestBase::testDeallocate().

PageOwnerId SegmentTestBase::objId [protected, inherited]

PageOwnerId to use when allocating pages.

Definition at line 54 of file SegmentTestBase.h.

Referenced by SegmentTestBase::lockPage(), SegmentTestBase::SegmentTestBase(), and SegmentTestBase::testAllocate().

uint PagingTestBase::cbPageUsable [protected, inherited]

Portion of each page that should be scribbled on.

Definition at line 49 of file PagingTestBase.h.

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

uint PagingTestBase::nRandomOps [protected, inherited]

Number of random access operations to run per pass.

Definition at line 54 of file PagingTestBase.h.

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

uint PagingTestBase::nSecondsBetweenCheckpoints [protected, inherited]

Checkpoint interval during multi-threaded test.

Definition at line 59 of file PagingTestBase.h.

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

StrictMutex PagingTestBase::logMutex [protected, inherited]

Protects output stream.

Definition at line 64 of file PagingTestBase.h.

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

SXMutex PagingTestBase::checkpointMutex [protected, inherited]

SXMutex used to synchronize checkpoints with write actions.

Definition at line 69 of file PagingTestBase.h.

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

bool PagingTestBase::bTestResize [protected, inherited]

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::PagingTestBase().

uint ThreadedTestBase::nSeconds [protected, inherited]

Duration of multi-threaded test.

Definition at line 65 of file ThreadedTestBase.h.

Referenced by BTreeTxnTest::BTreeTxnTest(), PagingTestBase::PagingTestBase(), ThreadedTestBase::runThreadedTestCase(), PagingTestBase::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::PagingTestBase(), ThreadedTestBase::runThreadedTestCase(), and SegmentTestBase::SegmentTestBase().

---

The documentation for this class was generated from the following file:

• /home/pub/open/dev/fennel/lucidera/test/LcsClusterReplaceExecStreamTest.cpp

---