LbmLoadBitmapTest Class Reference

Testcase for loading multiple clusters. More...

Inheritance diagram for LbmLoadBitmapTest:


Public Member Functions
	LbmLoadBitmapTest ()
void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
void	testLoadSmall (bool dynamicRootPageId)
void	testLoad50 ()
void	testLoad5000 ()
void	testLoad10000 ()
void	testAppend ()
void	testLoadDynamicRoot50 ()
virtual void	openStorage (DeviceMode openMode)
virtual void	openSegmentStorage (DeviceMode openMode)
virtual void	openRandomSegment ()
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.
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
void	initBTreeExecStreamParam (BTreeExecStreamParams &param, shared_ptr< BTreeDescriptor > pBTreeDesc)
	Initializes a BTreeExecStreamParam structure.
void	initBTreeParam (BTreeParams &param, shared_ptr< BTreeDescriptor > pBTreeDesc)
	Initializes BTreeParams structure.
void	initClusterScanDef (LbmGeneratorExecStreamParams &generatorParams, struct LcsClusterScanDef &clusterScanDef, uint bTreeIndex, DynamicParamId paramId)
	Initializes a cluster scan def structure for a generator exec stream.
void	initBTreeBitmapDesc (TupleDescriptor &param, TupleProjection &keyProj, uint nKeys)
	Initializes BTreeExecStreamParam corresponding to a bitmap index.
void	initBTreeTupleDesc (TupleDescriptor &tupleDesc, uint nKeys)
	Initializes a tuple descriptor corresponding to a bitmap index.
void	testLoad (uint nRows, uint nClusters, std::vector< int > &repeatSeqValues, bool newRoot, bool dumpEntries, string testName, bool dynamicRootPageId)
	Loads a table with nClusters clusters, 1 column per cluster, and nRows rows.
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)
Protected Attributes
StandardTypeDescriptorFactory	stdTypeFactory
TupleAttributeDescriptor	attrDesc_int64
vector< boost::shared_ptr< BTreeDescriptor > >	bTreeClusters
	BTrees corresponding to the clusters.
vector< PageId >	savedBTreeClusterRootIds
	Saved root pageids of btrees corresponding to clusters; used to append to existing table.
vector< boost::shared_ptr< BTreeDescriptor > >	bTreeBitmaps
	BTrees corresponding to the bitmaps.
vector< PageId >	savedBTreeBitmapRootIds
	Saved root pageids of btrees corresponding to bitmaps; used to append to existing table.
vector< boost::shared_ptr< LbmEntryDump > >	entryDumps
	Entry dumps corresponding to the bitmaps.
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
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.

Detailed Description

Testcase for loading multiple clusters.

Definition at line 52 of file LbmLoadBitmapTest.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.

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

Constructor & Destructor Documentation

LbmLoadBitmapTest::LbmLoadBitmapTest ( ) [inline, explicit]

Definition at line 123 of file LbmLoadBitmapTest.cpp.

References testAppend(), testLoad10000(), testLoad50(), testLoad5000(), and testLoadDynamicRoot50().

00124     {
00125         FENNEL_UNIT_TEST_CASE(LbmLoadBitmapTest, testLoad50);
00126         FENNEL_UNIT_TEST_CASE(LbmLoadBitmapTest, testLoad5000);
00127         FENNEL_UNIT_TEST_CASE(LbmLoadBitmapTest, testLoad10000);
00128         FENNEL_UNIT_TEST_CASE(LbmLoadBitmapTest, testAppend);
00129         FENNEL_UNIT_TEST_CASE(LbmLoadBitmapTest, testLoadDynamicRoot50);
00130     }

Member Function Documentation

void LbmLoadBitmapTest::initBTreeExecStreamParam	(	BTreeExecStreamParams &	param,
		shared_ptr< BTreeDescriptor >	pBTreeDesc
	)			`[protected]`

Initializes a BTreeExecStreamParam structure.

Definition at line 554 of file LbmLoadBitmapTest.cpp.

References initBTreeParam(), CacheTestBase::pCache, ExecStreamParams::pCacheAccessor, SegStorageTestBase::pSegmentFactory, and ExecStreamParams::scratchAccessor.

Referenced by testLoad().

00556 {
00557     param.scratchAccessor = pSegmentFactory->newScratchSegment(pCache, 15);
00558     param.pCacheAccessor = pCache;
00559     initBTreeParam(param, pBTreeDesc);
00560 }

void LbmLoadBitmapTest::initBTreeParam	(	BTreeParams &	param,
		shared_ptr< BTreeDescriptor >	pBTreeDesc
	)			`[protected]`

Initializes BTreeParams structure.

Definition at line 562 of file LbmLoadBitmapTest.cpp.

References BTreeParams::keyProj, BTreeParams::pageOwnerId, CacheTestBase::pCache, SegStorageTestBase::pRandomSegment, BTreeParams::pRootMap, BTreeParams::pSegment, BTreeParams::rootPageIdParamId, BTreeParams::segmentId, and BTreeParams::tupleDesc.

Referenced by initBTreeExecStreamParam(), and testLoad().

00564 {
00565     param.pSegment = pRandomSegment;
00566     param.pRootMap = 0;
00567     param.rootPageIdParamId = DynamicParamId(0);
00568 
00569     pBTreeDesc->segmentAccessor.pSegment = param.pSegment;
00570     pBTreeDesc->segmentAccessor.pCacheAccessor = pCache;
00571     pBTreeDesc->tupleDescriptor = param.tupleDesc;
00572     pBTreeDesc->keyProjection = param.keyProj;
00573     param.pageOwnerId = pBTreeDesc->pageOwnerId;
00574     param.segmentId = pBTreeDesc->segmentId;
00575 }

void LbmLoadBitmapTest::initClusterScanDef	(	LbmGeneratorExecStreamParams &	generatorParams,
		struct LcsClusterScanDef &	clusterScanDef,
		uint	bTreeIndex,
		DynamicParamId	paramId
	)			`[protected]`

Initializes a cluster scan def structure for a generator exec stream.

Definition at line 577 of file LbmLoadBitmapTest.cpp.

References bTreeClusters, BTreeParams::keyProj, LcsRowScanBaseExecStreamParams::lcsClusterScanDefs, NULL_PAGE_ID, opaqueToInt(), BTreeParams::pageOwnerId, ExecStreamParams::pCacheAccessor, BTreeParams::pRootMap, BTreeParams::pSegment, BTreeParams::rootPageId, BTreeParams::rootPageIdParamId, BTreeParams::segmentId, and BTreeParams::tupleDesc.

Referenced by testLoad().

00582 {
00583     clusterScanDef.pSegment =
00584         bTreeClusters[bTreeIndex]->segmentAccessor.pSegment;
00585     clusterScanDef.pCacheAccessor =
00586         bTreeClusters[bTreeIndex]->segmentAccessor.pCacheAccessor;
00587     clusterScanDef.tupleDesc = bTreeClusters[bTreeIndex]->tupleDescriptor;
00588     clusterScanDef.keyProj = bTreeClusters[bTreeIndex]->keyProjection;
00589     clusterScanDef.rootPageIdParamId = paramId;
00590     clusterScanDef.rootPageId =
00591         (opaqueToInt(paramId) > 0) ?
00592             NULL_PAGE_ID : bTreeClusters[bTreeIndex]->rootPageId;
00593     clusterScanDef.pageOwnerId = bTreeClusters[bTreeIndex]->pageOwnerId;
00594     clusterScanDef.segmentId = bTreeClusters[bTreeIndex]->segmentId;
00595     clusterScanDef.pRootMap = 0;
00596     generatorParams.lcsClusterScanDefs.push_back(clusterScanDef);
00597 }

void LbmLoadBitmapTest::initBTreeBitmapDesc	(	TupleDescriptor &	param,
		TupleProjection &	keyProj,
		uint	nKeys
	)			`[protected]`

Initializes BTreeExecStreamParam corresponding to a bitmap index.

Definition at line 599 of file LbmLoadBitmapTest.cpp.

References initBTreeTupleDesc(), BTreeParams::keyProj, and BTreeParams::tupleDesc.

Referenced by testLoad().

00601 {
00602     initBTreeTupleDesc(tupleDesc, nKeys);
00603 
00604     // btree key consists of the key columns + starting rid
00605     for (uint j = 0; j < nKeys; j++) {
00606         keyProj.push_back(j);
00607     }
00608 }

void LbmLoadBitmapTest::initBTreeTupleDesc	(	TupleDescriptor &	tupleDesc,
		uint	nKeys
	)			`[protected]`

Initializes a tuple descriptor corresponding to a bitmap index.

Definition at line 610 of file LbmLoadBitmapTest.cpp.

References attrDesc_int64, StandardTypeDescriptorFactory::newDataType(), SegStorageTestBase::pRandomSegment, STANDARD_TYPE_VARBINARY, stdTypeFactory, and BTreeParams::tupleDesc.

Referenced by initBTreeBitmapDesc(), and testLoad().

00612 {
00613     for (uint i = 0; i < nKeys; i++) {
00614         tupleDesc.push_back(attrDesc_int64);
00615     }
00616     uint varColSize;
00617 
00618     // The default page size is 4K.
00619     varColSize = pRandomSegment->getUsablePageSize() / 8;
00620     // varColSize = 256;
00621 
00622     tupleDesc.push_back(
00623         TupleAttributeDescriptor(
00624             stdTypeFactory.newDataType(STANDARD_TYPE_VARBINARY), true,
00625             varColSize));
00626     tupleDesc.push_back(
00627         TupleAttributeDescriptor(
00628             stdTypeFactory.newDataType(STANDARD_TYPE_VARBINARY), true,
00629             varColSize));
00630 }

void LbmLoadBitmapTest::testLoad	(	uint	nRows,
		uint	nClusters,
		std::vector< int > &	repeatSeqValues,
		bool	newRoot,
		bool	dumpEntries,
		string	testName,
		bool	dynamicRootPageId
	)			`[protected]`

Loads a table with nClusters clusters, 1 column per cluster, and nRows rows.

Each column has a repeating sequence of values based on the value in the repeatSeqValues vector. E.g., a repeating sequence of n will have values: (0, 1, 2, ..., n-1, 0, 1, 2, ..., n-1, 0, 1, 2, ...).

Bitmap indexes are then created on each column as well as a multi-key index that is created on all columns.

If newRoot is false, this is testing an append to an existing table.

Definition at line 249 of file LbmLoadBitmapTest.cpp.

References attrDesc_int64, BARRIER_RET_ANY_INPUT, bTreeBitmaps, bTreeClusters, LbmSplicerExecStreamParams::bTreeParams, TupleDatum::cbData, LcsClusterScanDef::clusterTupleDesc, BTreeBuilder::createEmptyRoot(), LbmGeneratorExecStreamParams::createIndex, LbmSplicerExecStreamParams::createNewIndex, ExternalSortExecStreamParams::distinctness, DUP_ALLOW, ExternalSortExecStreamParams::earlyClose, entryDumps, ExternalSortExecStreamParams::estimatedNumRows, BTreeAccessBase::getRootPageId(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), initBTreeBitmapDesc(), initBTreeExecStreamParam(), initBTreeParam(), initBTreeTupleDesc(), initClusterScanDef(), LbmSplicerExecStreamParams::insertRowCountParamId, LbmGeneratorExecStreamParams::insertRowCountParamId, ExternalSortExecStreamParams::keyProj, BTreeParams::keyProj, MAXU, ExternalSortExecStream::newExternalSortExecStream(), MockProducerExecStreamParams::nRows, LcsRowScanBaseExecStreamParams::outputProj, DiffluenceExecStreamParams::outputTupleDesc, SingleOutputExecStreamParams::outputTupleDesc, CacheTestBase::pCache, TupleDatum::pData, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::pGraph, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), SegStorageTestBase::pSegmentFactory, ExternalSortExecStreamParams::pTempSegment, BarrierExecStreamParams::returnMode, BTreeParams::rootPageId, savedBTreeBitmapRootIds, savedBTreeClusterRootIds, ExternalSortExecStreamParams::storeFinalRun, TRACE_INFO, traceName, BTreeParams::tupleDesc, ExecStreamUnitTestBase::verifyOutput(), and LbmSplicerExecStreamParams::writeRowCountParamId.

Referenced by testAppend(), testLoad10000(), testLoad5000(), and testLoadSmall().

00252 {
00253     // 0. reset member fields.
00254     for (uint i = 0; i < bTreeClusters.size(); i++) {
00255         bTreeClusters[i]->segmentAccessor.reset();
00256     }
00257     for (uint i = 0; i < bTreeBitmaps.size(); i++) {
00258         bTreeBitmaps[i]->segmentAccessor.reset();
00259     }
00260     bTreeClusters.clear();
00261     bTreeBitmaps.clear();
00262     entryDumps.clear();
00263 
00264     // 1. setup mock input stream
00265 
00266     MockProducerExecStreamParams mockParams;
00267     for (uint i = 0; i < nClusters; i++) {
00268         mockParams.outputTupleDesc.push_back(attrDesc_int64);
00269     }
00270     mockParams.nRows = nRows;
00271 
00272     vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
00273     SharedInt64ColumnGenerator col;
00274     assert(repeatSeqValues.size() == nClusters);
00275     for (uint i = 0; i < repeatSeqValues.size(); i++) {
00276         col =
00277             SharedInt64ColumnGenerator(
00278                 new RepeatingSeqColumnGenerator(repeatSeqValues[i]));
00279         columnGenerators.push_back(col);
00280     }
00281     mockParams.pGenerator.reset(
00282         new CompositeExecStreamGenerator(columnGenerators));
00283 
00284     ExecStreamEmbryo mockStreamEmbryo;
00285     mockStreamEmbryo.init(new MockProducerExecStream(), mockParams);
00286     mockStreamEmbryo.getStream()->setName("MockProducerExecStream");
00287 
00288     // 2. setup splitter stream for cluster loads
00289 
00290     SplitterExecStreamParams splitterParams;
00291     ExecStreamEmbryo splitterStreamEmbryo;
00292     splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams);
00293     splitterStreamEmbryo.getStream()->setName("ClusterSplitterExecStream");
00294 
00295     // 3. setup loader streams
00296 
00297     vector<ExecStreamEmbryo> lcsAppendEmbryos;
00298     for (uint i = 0; i < nClusters; i++) {
00299         LcsClusterAppendExecStreamParams lcsAppendParams;
00300         boost::shared_ptr<BTreeDescriptor> pBTreeDesc =
00301             boost::shared_ptr<BTreeDescriptor> (new BTreeDescriptor());
00302         bTreeClusters.push_back(pBTreeDesc);
00303 
00304         // initialize the btree parameter portion of lcsAppendParams
00305         // BTree tuple desc has two columns (rid, clusterPageid)
00306         (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);
00307         (lcsAppendParams.tupleDesc).push_back(attrDesc_int64);
00308 
00309         // BTree key only has one column which is the first column.
00310         (lcsAppendParams.keyProj).push_back(0);
00311 
00312         initBTreeExecStreamParam(lcsAppendParams, pBTreeDesc);
00313 
00314         // output two values (rows inserted, starting rid value)
00315         lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);
00316         lcsAppendParams.outputTupleDesc.push_back(attrDesc_int64);
00317 
00318         lcsAppendParams.inputProj.push_back(i);
00319 
00320         // create an empty page to start the btree
00321 
00322         if (newRoot) {
00323             BTreeBuilder builder(*pBTreeDesc, pRandomSegment);
00324             builder.createEmptyRoot();
00325             savedBTreeClusterRootIds.push_back(builder.getRootPageId());
00326         }
00327         lcsAppendParams.rootPageId = pBTreeDesc->rootPageId =
00328             savedBTreeClusterRootIds[i];
00329 
00330         // Now use the above initialized parameter
00331 
00332         ExecStreamEmbryo lcsAppendStreamEmbryo;
00333         lcsAppendStreamEmbryo.init(
00334             new LcsClusterAppendExecStream(), lcsAppendParams);
00335         std::ostringstream oss;
00336         oss << "LcsClusterAppendExecStream" << "#" << i;
00337         lcsAppendStreamEmbryo.getStream()->setName(oss.str());
00338         lcsAppendEmbryos.push_back(lcsAppendStreamEmbryo);
00339     }
00340 
00341     // 4. setup barrier stream for cluster loads
00342 
00343     BarrierExecStreamParams barrierParams;
00344     barrierParams.outputTupleDesc.push_back(attrDesc_int64);
00345     barrierParams.outputTupleDesc.push_back(attrDesc_int64);
00346     barrierParams.returnMode = BARRIER_RET_ANY_INPUT;
00347 
00348     ExecStreamEmbryo clusterBarrierStreamEmbryo;
00349     clusterBarrierStreamEmbryo.init(new BarrierExecStream(), barrierParams);
00350     clusterBarrierStreamEmbryo.getStream()->setName("ClusterBarrierExecStream");
00351 
00352     // create a DAG with the above, but without the final output sink
00353     prepareDAG(
00354         mockStreamEmbryo, splitterStreamEmbryo, lcsAppendEmbryos,
00355         clusterBarrierStreamEmbryo, false);
00356 
00357     // 5. setup splitter stream for create bitmaps
00358 
00359     splitterStreamEmbryo.init(
00360         new SplitterExecStream(), splitterParams);
00361     splitterStreamEmbryo.getStream()->setName("BitmapSplitterExecStream");
00362 
00363     // create streams for bitmap generator, sort, and bitmap splicer,
00364     // 1 index on each column and then an index on all columns
00365 
00366     std::vector<std::vector<ExecStreamEmbryo> > createBitmapStreamList;
00367     for (uint i = 0; i < nClusters + 1; i++) {
00368         if (i == 1 && nClusters == 1) {
00369             /*
00370              * There's only one column.
00371              * Do not bother to build the composite index.
00372              */
00373             break;
00374         }
00375 
00376         std::vector<ExecStreamEmbryo> createBitmapStream;
00377 
00378         // 6. setup generator
00379 
00380         LbmGeneratorExecStreamParams generatorParams;
00381         struct LcsClusterScanDef clusterScanDef;
00382         clusterScanDef.clusterTupleDesc.push_back(attrDesc_int64);
00383 
00384         // first nCluster generators only scan a single column; the
00385         // last one scans all columns
00386         if (i < nClusters) {
00387             DynamicParamId paramId =
00388                 (dynamicRootPageId) ?
00389                     DynamicParamId(nClusters + i + 2) : DynamicParamId(0);
00390             initClusterScanDef(generatorParams, clusterScanDef, i, paramId);
00391         } else {
00392             for (uint j = 0; j < nClusters; j++) {
00393                 DynamicParamId paramId =
00394                     (dynamicRootPageId) ? DynamicParamId(nClusters + 2 + j) :
00395                         DynamicParamId(0);
00396                 initClusterScanDef(generatorParams, clusterScanDef, j, paramId);
00397             }
00398         }
00399 
00400         TupleProjection proj;
00401         if (i < nClusters) {
00402             proj.push_back(0);
00403         } else {
00404             for (uint j = 0; j < nClusters; j++) {
00405                 proj.push_back(j);
00406             }
00407         }
00408         generatorParams.outputProj = proj;
00409         generatorParams.insertRowCountParamId = DynamicParamId(i + 1);
00410         generatorParams.createIndex = false;
00411 
00412         boost::shared_ptr<BTreeDescriptor> pBTreeDesc =
00413             boost::shared_ptr<BTreeDescriptor> (new BTreeDescriptor());
00414         bTreeBitmaps.push_back(pBTreeDesc);
00415 
00416         /*
00417          * Setup the dump objects.
00418          */
00419         if (dumpEntries) {
00420             ostringstream traceName;
00421             traceName << testName << " Index " << i;
00422             boost::shared_ptr<LbmEntryDump> pEntryDump =
00423                 boost::shared_ptr<LbmEntryDump>(
00424                     new LbmEntryDump(
00425                         TRACE_INFO,
00426                         shared_from_this(),
00427                         traceName.str()));
00428             entryDumps.push_back(pEntryDump);
00429         }
00430 
00431         // BTree tuple desc has the key columns + starting Rid + varbinary
00432         // field for bit segments/bit descriptors
00433         uint nKeys;
00434         if (i < nClusters) {
00435             nKeys = 2;
00436         } else {
00437             nKeys = nClusters + 1;
00438         }
00439         initBTreeTupleDesc(generatorParams.outputTupleDesc, nKeys);
00440 
00441         initBTreeBitmapDesc(
00442             generatorParams.tupleDesc, generatorParams.keyProj, nKeys);
00443         initBTreeExecStreamParam(generatorParams, pBTreeDesc);
00444 
00445         // create an empty page to start the btree
00446 
00447         if (newRoot) {
00448             BTreeBuilder builder(*pBTreeDesc, pRandomSegment);
00449             builder.createEmptyRoot();
00450             savedBTreeBitmapRootIds.push_back(builder.getRootPageId());
00451         }
00452         generatorParams.rootPageId = pBTreeDesc->rootPageId =
00453             savedBTreeBitmapRootIds[i];
00454         if (dynamicRootPageId && i < nClusters) {
00455             SharedDynamicParamManager pDynamicParamManager =
00456                 pGraph->getDynamicParamManager();
00457             DynamicParamId paramId = DynamicParamId(nClusters + i + 2);
00458             pDynamicParamManager->createParam(paramId, attrDesc_int64);
00459             TupleDatum pageIdDatum;
00460             PageId rootPageId = savedBTreeBitmapRootIds[i];
00461             pageIdDatum.pData = (PConstBuffer) &rootPageId;
00462             pageIdDatum.cbData = sizeof(PageId);
00463             pDynamicParamManager->writeParam(paramId, pageIdDatum);
00464         }
00465 
00466         ExecStreamEmbryo generatorStreamEmbryo;
00467         generatorStreamEmbryo.init(
00468             new LbmGeneratorExecStream(), generatorParams);
00469         std::ostringstream oss;
00470         oss << "LbmGeneratorExecStream" << "#" << i;
00471         generatorStreamEmbryo.getStream()->setName(oss.str());
00472         createBitmapStream.push_back(generatorStreamEmbryo);
00473 
00474         // 7. setup sorter
00475 
00476         ExternalSortExecStreamParams sortParams;
00477         initBTreeBitmapDesc(
00478             sortParams.outputTupleDesc, sortParams.keyProj, nKeys);
00479         sortParams.distinctness = DUP_ALLOW;
00480         sortParams.pTempSegment = pRandomSegment;
00481         sortParams.pCacheAccessor = pCache;
00482         sortParams.scratchAccessor =
00483             pSegmentFactory->newScratchSegment(pCache, 10);
00484         sortParams.storeFinalRun = false;
00485         sortParams.estimatedNumRows = MAXU;
00486         sortParams.earlyClose = false;
00487 
00488         ExecStreamEmbryo sortStreamEmbryo;
00489         sortStreamEmbryo.init(
00490             ExternalSortExecStream::newExternalSortExecStream(), sortParams);
00491         sortStreamEmbryo.getStream()->setName("ExternalSortExecStream");
00492         std::ostringstream oss2;
00493         oss2 << "ExternalSortExecStream" << "#" << i;
00494         sortStreamEmbryo.getStream()->setName(oss2.str());
00495         createBitmapStream.push_back(sortStreamEmbryo);
00496 
00497         // 8. setup splicer
00498 
00499         LbmSplicerExecStreamParams splicerParams;
00500         splicerParams.createNewIndex = false;
00501         splicerParams.scratchAccessor =
00502             pSegmentFactory->newScratchSegment(pCache, 15);
00503         splicerParams.pCacheAccessor = pCache;
00504         BTreeParams bTreeParams;
00505         initBTreeBitmapDesc(
00506             bTreeParams.tupleDesc, bTreeParams.keyProj, nKeys);
00507         initBTreeParam(bTreeParams, pBTreeDesc);
00508         bTreeParams.rootPageId = pBTreeDesc->rootPageId;
00509         splicerParams.bTreeParams.push_back(bTreeParams);
00510         splicerParams.insertRowCountParamId = DynamicParamId(i + 1);
00511         splicerParams.writeRowCountParamId = DynamicParamId(0);
00512         splicerParams.outputTupleDesc.push_back(attrDesc_int64);
00513 
00514         ExecStreamEmbryo splicerStreamEmbryo;
00515         splicerStreamEmbryo.init(new LbmSplicerExecStream(), splicerParams);
00516         std::ostringstream oss3;
00517         oss3 << "LbmSplicerExecStream" << "#" << i;
00518         splicerStreamEmbryo.getStream()->setName(oss3.str());
00519         createBitmapStream.push_back(splicerStreamEmbryo);
00520 
00521         // connect the sorter and splicer to generator and then add this
00522         // newly connected stream to the list of create bitmap stream embryos
00523         createBitmapStreamList.push_back(createBitmapStream);
00524     }
00525 
00526     // 9. setup barrier stream for create bitmaps
00527 
00528     barrierParams.outputTupleDesc.clear();
00529     barrierParams.outputTupleDesc.push_back(attrDesc_int64);
00530 
00531     ExecStreamEmbryo barrierStreamEmbryo;
00532     barrierStreamEmbryo.init(
00533         new BarrierExecStream(), barrierParams);
00534     barrierStreamEmbryo.getStream()->setName("BitmapBarrierExecStream");
00535 
00536     // create the bitmap stream graph, with the load stream graph from
00537     // above as the source
00538     SharedExecStream pOutputStream = prepareDAG(
00539         clusterBarrierStreamEmbryo, splitterStreamEmbryo,
00540         createBitmapStreamList, barrierStreamEmbryo, true, false);
00541 
00542     // set up a generator which can produce the expected output
00543     RampExecStreamGenerator expectedResultGenerator(mockParams.nRows);
00544 
00545     verifyOutput(*pOutputStream, 1, expectedResultGenerator);
00546 
00547     if (dumpEntries) {
00548         for (uint i = 0; i < entryDumps.size(); i++) {
00549             entryDumps[i]->dump(*(bTreeBitmaps[i].get()), true);
00550         }
00551     }
00552 }

void LbmLoadBitmapTest::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 632 of file LbmLoadBitmapTest.cpp.

References attrDesc_int64, StandardTypeDescriptorFactory::newDataType(), STANDARD_TYPE_INT_64, stdTypeFactory, and ExecStreamUnitTestBase::testCaseSetUp().

00633 {
00634     ExecStreamUnitTestBase::testCaseSetUp();
00635 
00636     attrDesc_int64 = TupleAttributeDescriptor(
00637         stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));
00638 }

void LbmLoadBitmapTest::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 640 of file LbmLoadBitmapTest.cpp.

References bTreeBitmaps, bTreeClusters, entryDumps, savedBTreeBitmapRootIds, savedBTreeClusterRootIds, and ExecStreamTestBase::testCaseTearDown().

00641 {
00642     for (uint i = 0; i < bTreeClusters.size(); i++) {
00643         bTreeClusters[i]->segmentAccessor.reset();
00644     }
00645     for (uint i = 0; i < bTreeBitmaps.size(); i++) {
00646         bTreeBitmaps[i]->segmentAccessor.reset();
00647     }
00648     bTreeClusters.clear();
00649     bTreeBitmaps.clear();
00650     savedBTreeClusterRootIds.clear();
00651     savedBTreeBitmapRootIds.clear();
00652     entryDumps.clear();
00653 
00654     ExecStreamUnitTestBase::testCaseTearDown();
00655 }

void LbmLoadBitmapTest::testLoadSmall ( bool dynamicRootPageId )

Definition at line 154 of file LbmLoadBitmapTest.cpp.

References testLoad().

Referenced by testLoad50(), and testLoadDynamicRoot50().

00155 {
00156     // small load
00157     uint nRows = 50;
00158     uint nClusters = 4;
00159     std::vector<int> repeatSeqValues;
00160 
00161     // first column will contain all unique values; the remaining columns
00162     // have a repeating sequence based on the value set in the vector
00163     repeatSeqValues.push_back(nRows);
00164     repeatSeqValues.push_back(5);
00165     repeatSeqValues.push_back(9);
00166     repeatSeqValues.push_back(19);
00167     testLoad(
00168         nRows, nClusters, repeatSeqValues, true, true, "testLoad50",
00169         dynamicRootPageId);
00170 }

void LbmLoadBitmapTest::testLoad50 ( )

Definition at line 144 of file LbmLoadBitmapTest.cpp.

References testLoadSmall().

Referenced by LbmLoadBitmapTest().

00145 {
00146     testLoadSmall(false);
00147 }

void LbmLoadBitmapTest::testLoad5000 ( )

Definition at line 172 of file LbmLoadBitmapTest.cpp.

References testLoad().

Referenced by LbmLoadBitmapTest().

00173 {
00174     uint nRows = 5000;
00175     uint nClusters = 2;
00176     std::vector<int> repeatSeqValues;
00177 
00178     // test with a larger number of distinct values to force buffer flushing
00179     repeatSeqValues.push_back(nRows);
00180     repeatSeqValues.push_back(200);
00181     testLoad(
00182         nRows, nClusters, repeatSeqValues, true, true, "testLoad5000", false);
00183 }

void LbmLoadBitmapTest::testLoad10000 ( )

Definition at line 185 of file LbmLoadBitmapTest.cpp.

References testLoad().

Referenced by LbmLoadBitmapTest().

00186 {
00187     // larger rowset to force bitmaps exceeding their buffer sizes
00188     uint nRows = 10000;
00189     uint nClusters = 4;
00190     std::vector<int> repeatSeqValues;
00191 
00192     repeatSeqValues.push_back(nRows);
00193     repeatSeqValues.push_back(5);
00194     repeatSeqValues.push_back(9);
00195     repeatSeqValues.push_back(19);
00196     testLoad(
00197         nRows, nClusters, repeatSeqValues, true, true, "testLoad10000", false);
00198 }

void LbmLoadBitmapTest::testAppend ( )

Definition at line 200 of file LbmLoadBitmapTest.cpp.

References ExecStreamUnitTestBase::resetExecStreamTest(), and testLoad().

Referenced by LbmLoadBitmapTest().

00201 {
00202     // parameters for test
00203     uint nRows = 60;
00204     uint nClusters = 4;
00205     std::vector<int> repeatSeqValues1;
00206     std::vector<int> repeatSeqValues2;
00207 
00208     // Set up the column generators for empty load and append.
00209 
00210     // column 1
00211     repeatSeqValues1.push_back(nRows);
00212     repeatSeqValues2.push_back(nRows);
00213 
00214     // column 2
00215     repeatSeqValues1.push_back(23);
00216     repeatSeqValues2.push_back(31);
00217 
00218     // column 3
00219     repeatSeqValues1.push_back(1);
00220     repeatSeqValues2.push_back(2);
00221 
00222     // column 4
00223     repeatSeqValues1.push_back(7);
00224     repeatSeqValues2.push_back(29);
00225 
00226     // load into empty btree
00227     testLoad(
00228         nRows, nClusters, repeatSeqValues1, true,  true, "testAppendNewRoot",
00229         false);
00230 
00231     // append some new values
00232     resetExecStreamTest();
00233     testLoad(
00234         nRows, nClusters, repeatSeqValues2, false, true, "testAppendOldRoot",
00235         false);
00236 }

void LbmLoadBitmapTest::testLoadDynamicRoot50 ( )

Definition at line 149 of file LbmLoadBitmapTest.cpp.

References testLoadSmall().

Referenced by LbmLoadBitmapTest().

00150 {
00151     testLoadSmall(true);
00152 }

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

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

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.

00051 {
00052     std::vector<ExecStreamEmbryo> transforms;
00053     transforms.push_back(transformStreamEmbryo);
00054     return prepareTransformGraph(sourceStreamEmbryo, transforms);
00055 }

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.

00060 {
00061     pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryo);
00062     std::vector<ExecStreamEmbryo>::iterator it;
00063 
00064     // save all transforms
00065     for (it = transforms.begin(); it != transforms.end(); ++it) {
00066         pGraphEmbryo->saveStreamEmbryo(*it);
00067     }
00068 
00069     // connect streams in a cascade
00070     ExecStreamEmbryo& previousStream = sourceStreamEmbryo;
00071     for (it = transforms.begin(); it != transforms.end(); ++it) {
00072         pGraphEmbryo->addDataflow(
00073             previousStream.getStream()->getName(),
00074             (*it).getStream()->getName());
00075         previousStream = *it;
00076     }
00077 
00078     SharedExecStream pAdaptedStream =
00079         pGraphEmbryo->addAdapterFor(
00080             previousStream.getStream()->getName(),
00081             0,
00082             BUFPROV_PRODUCER);
00083     pGraph->addOutputDataflow(pAdaptedStream->getStreamId());
00084 
00085     pGraphEmbryo->prepareGraph(shared_from_this(), "");
00086     return pAdaptedStream;
00087 }

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

00093 {
00094     std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
00095     sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
00096     sourceStreamEmbryos.push_back(sourceStreamEmbryo2);
00097     return prepareConfluenceGraph(sourceStreamEmbryos, confluenceStreamEmbryo);
00098 }

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

00158 {
00159     std::vector<std::vector<ExecStreamEmbryo> > sourceStreamEmbryosList;
00160     std::vector<ExecStreamEmbryo>::iterator it;
00161     std::vector<ExecStreamEmbryo> sourceStreamList;
00162     for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
00163         it++)
00164     {
00165         sourceStreamList.clear();
00166         sourceStreamList.push_back(*it);
00167         sourceStreamEmbryosList.push_back(sourceStreamList);
00168     }
00169 
00170     return
00171         prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo);
00172 }

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.

00177 {
00178     pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);
00179 
00180     for (int i = 0; i < sourceStreamEmbryosList.size(); i++) {
00181         for (int j = 0; j < sourceStreamEmbryosList[i].size(); j++) {
00182             pGraphEmbryo->saveStreamEmbryo(sourceStreamEmbryosList[i][j]);
00183         }
00184 
00185         // connect streams in each sourceStreamEmbryos list in a cascade
00186         for (int j = 1; j < sourceStreamEmbryosList[i].size(); j++) {
00187             pGraphEmbryo->addDataflow(
00188                 sourceStreamEmbryosList[i][j - 1].getStream()->getName(),
00189                 sourceStreamEmbryosList[i][j].getStream()->getName());
00190         }
00191         pGraphEmbryo->addDataflow(
00192             sourceStreamEmbryosList[i].back().getStream()->getName(),
00193             confluenceStreamEmbryo.getStream()->getName());
00194     }
00195 
00196     SharedExecStream pAdaptedStream =
00197         pGraphEmbryo->addAdapterFor(
00198             confluenceStreamEmbryo.getStream()->getName(), 0,
00199             BUFPROV_PRODUCER);
00200     pGraph->addOutputDataflow(
00201         pAdaptedStream->getStreamId());
00202 
00203     pGraphEmbryo->prepareGraph(shared_from_this(), "");
00204 
00205     return pAdaptedStream;
00206 }

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

00105 {
00106     std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
00107     sourceStreamEmbryos.push_back(sourceStreamEmbryo1);
00108     sourceStreamEmbryos.push_back(sourceStreamEmbryo2);
00109 
00110     std::vector<ExecStreamEmbryo>::iterator it;
00111 
00112     for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
00113         ++it)
00114     {
00115         pGraphEmbryo->saveStreamEmbryo(*it);
00116     }
00117     pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);
00118 
00119     for (it = sourceStreamEmbryos.begin(); it != sourceStreamEmbryos.end();
00120         ++it)
00121     {
00122         pGraphEmbryo->addDataflow(
00123             (*it).getStream()->getName(),
00124             confluenceStreamEmbryo.getStream()->getName());
00125     }
00126 
00127     std::vector<ExecStreamEmbryo> transforms;
00128     transforms.push_back(transformStreamEmbryo);
00129     ExecStreamEmbryo& previousStream = confluenceStreamEmbryo;
00130 
00131     // save all transforms
00132     for (it = transforms.begin(); it != transforms.end(); ++it) {
00133         pGraphEmbryo->saveStreamEmbryo(*it);
00134     }
00135 
00136     for (it = transforms.begin(); it != transforms.end(); ++it) {
00137         pGraphEmbryo->addDataflow(
00138             previousStream.getStream()->getName(),
00139             (*it).getStream()->getName());
00140         previousStream = *it;
00141     }
00142 
00143 
00144     SharedExecStream pAdaptedStream =
00145         pGraphEmbryo->addAdapterFor(
00146             previousStream.getStream()->getName(),
00147             0,
00148             BUFPROV_PRODUCER);
00149     pGraph->addOutputDataflow(pAdaptedStream->getStreamId());
00150 
00151     pGraphEmbryo->prepareGraph(shared_from_this(), "");
00152     return pAdaptedStream;
00153 }

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(), testLoad(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream(), and ExecStreamTestSuite::testSplitterPlusBarrier().

00215 {
00216     std::vector<std::vector<ExecStreamEmbryo> > listOfList;
00217 
00218     // Convert interStreamEmbryos to a vector of vectors.  E.g., if
00219     // interStreamEmbryos contains (1, 2, 3), it will get converted to:
00220     // ((1)) ((2)) ((3))
00221     for (uint i = 0; i < interStreamEmbryos.size(); i++) {
00222         std::vector<ExecStreamEmbryo> interStreamEmbryoList;
00223 
00224         interStreamEmbryoList.push_back(interStreamEmbryos[i]);
00225         listOfList.push_back(interStreamEmbryoList);
00226     }
00227     return prepareDAG(
00228         srcStreamEmbryo, splitterStreamEmbryo, listOfList, destStreamEmbryo,
00229         createSink, saveSrc);
00230 }

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.

00239 {
00240     if (saveSrc) {
00241         pGraphEmbryo->saveStreamEmbryo(srcStreamEmbryo);
00242     }
00243     pGraphEmbryo->saveStreamEmbryo(splitterStreamEmbryo);
00244 
00245     // save all intermediate stream embryos
00246     for (int i = 0; i < interStreamEmbryos.size(); i++) {
00247         for (int j = 0; j < interStreamEmbryos[i].size(); j++) {
00248             pGraphEmbryo->saveStreamEmbryo(interStreamEmbryos[i][j]);
00249         }
00250 
00251         // connect streams in each interStreamEmbryos list in a cascade
00252         for (int j = 1; j < interStreamEmbryos[i].size(); j++) {
00253             pGraphEmbryo->addDataflow(
00254                 interStreamEmbryos[i][j - 1].getStream()->getName(),
00255                 interStreamEmbryos[i][j].getStream()->getName());
00256         }
00257     }
00258 
00259     pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo);
00260 
00261     pGraphEmbryo->addDataflow(
00262         srcStreamEmbryo.getStream()->getName(),
00263         splitterStreamEmbryo.getStream()->getName());
00264 
00265     // connect all inter streams to src and dest
00266     for (int i = 0; i < interStreamEmbryos.size(); i++) {
00267         pGraphEmbryo->addDataflow(
00268             splitterStreamEmbryo.getStream()->getName(),
00269             interStreamEmbryos[i][0].getStream()->getName());
00270         pGraphEmbryo->addDataflow(
00271             interStreamEmbryos[i].back().getStream()->getName(),
00272             destStreamEmbryo.getStream()->getName());
00273     }
00274 
00275     SharedExecStream pAdaptedStream;
00276 
00277     if (createSink) {
00278         pAdaptedStream = pGraphEmbryo->addAdapterFor(
00279             destStreamEmbryo.getStream()->getName(), 0,
00280             BUFPROV_PRODUCER);
00281         pGraph->addOutputDataflow(pAdaptedStream->getStreamId());
00282 
00283         pGraphEmbryo->prepareGraph(shared_from_this(), "");
00284     }
00285 
00286     return pAdaptedStream;
00287 }

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.

00330 {
00331     // TODO:  assertions about output tuple
00332 
00333     pResourceGovernor->requestResources(*pGraph);
00334     pGraph->open();
00335     pScheduler->start();
00336     uint nRows = 0;
00337     for (;;) {
00338         ExecStreamBufAccessor &bufAccessor =
00339             pScheduler->readStream(stream);
00340         if (bufAccessor.getState() == EXECBUF_EOS) {
00341             break;
00342         }
00343         BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
00344         const uint nCol =
00345             bufAccessor.getConsumptionTupleAccessor().size();
00346         BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
00347         BOOST_REQUIRE(nCol >= 1);
00348         TupleData inputTuple;
00349         inputTuple.compute(bufAccessor.getTupleDesc());
00350         for (;;) {
00351             if (!bufAccessor.demandData()) {
00352                 break;
00353             }
00354             BOOST_REQUIRE(nRows < nRowsExpected);
00355             bufAccessor.unmarshalTuple(inputTuple);
00356             for (int col = 0; col < nCol; ++col) {
00357                 int64_t actualValue =
00358                     *reinterpret_cast<int64_t const *>(inputTuple[col].pData);
00359                 int64_t expectedValue = generator.generateValue(nRows, col);
00360                 if (actualValue != expectedValue) {
00361                     std::cout << "(Row, Col) = (" << nRows << ", " << col <<")"
00362                               << std::endl;
00363                     BOOST_CHECK_EQUAL(expectedValue,actualValue);
00364                     return;
00365                 }
00366             }
00367             bufAccessor.consumeTuple();
00368             ++nRows;
00369             if (stopEarly && nRows == nRowsExpected) {
00370                 return;
00371             }
00372         }
00373     }
00374     BOOST_CHECK_EQUAL(nRowsExpected,nRows);
00375 }

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

00381 {
00382     // TODO:  assertions about output tuple
00383 
00384     pResourceGovernor->requestResources(*pGraph);
00385     pGraph->open();
00386     pScheduler->start();
00387     uint nRows = 0;
00388     for (;;) {
00389         ExecStreamBufAccessor &bufAccessor =
00390             pScheduler->readStream(stream);
00391         if (bufAccessor.getState() == EXECBUF_EOS) {
00392             break;
00393         }
00394         BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
00395 
00396         if (!bufAccessor.demandData()) {
00397             break;
00398         }
00399         BOOST_REQUIRE(nRows < nRowsExpected);
00400 
00401         TupleData actualTuple;
00402         actualTuple.compute(bufAccessor.getTupleDesc());
00403         bufAccessor.unmarshalTuple(actualTuple);
00404 
00405         int c = bufAccessor.getTupleDesc().compareTuples(
00406                                expectedTuple, actualTuple);
00407         bufAccessor.consumeTuple();
00408         ++nRows;
00409         if (c) {
00410 #if 1
00411             TupleDescriptor statusDesc = bufAccessor.getTupleDesc();
00412             TuplePrinter tuplePrinter;
00413             tuplePrinter.print(std::cout, statusDesc, actualTuple);
00414             tuplePrinter.print(std::cout, statusDesc, expectedTuple);
00415             std::cout << std::endl;
00416 #endif
00417             BOOST_CHECK_EQUAL(0,c);
00418             break;
00419         }
00420     }
00421     BOOST_CHECK_EQUAL(nRowsExpected, nRows);
00422 }

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

00429 {
00430     // TODO:  assertions about output tuple
00431 
00432     TupleAccessor expectedOutputAccessor;
00433     expectedOutputAccessor.compute(outputTupleDesc);
00434     TupleData expectedTuple(outputTupleDesc);
00435     uint bufOffset = 0;
00436     pResourceGovernor->requestResources(*pGraph);
00437     pGraph->open();
00438     pScheduler->start();
00439     uint nRows = 0;
00440     for (;;) {
00441         ExecStreamBufAccessor &bufAccessor =
00442             pScheduler->readStream(stream);
00443         if (bufAccessor.getState() == EXECBUF_EOS) {
00444             break;
00445         }
00446         BOOST_REQUIRE(bufAccessor.getTupleDesc() == outputTupleDesc);
00447         BOOST_REQUIRE(bufAccessor.isConsumptionPossible());
00448         const uint nCol =
00449             bufAccessor.getConsumptionTupleAccessor().size();
00450         BOOST_REQUIRE(nCol == bufAccessor.getTupleDesc().size());
00451         BOOST_REQUIRE(nCol >= 1);
00452         TupleData inputTuple;
00453         inputTuple.compute(bufAccessor.getTupleDesc());
00454         for (;;) {
00455             if (!bufAccessor.demandData()) {
00456                 break;
00457             }
00458             BOOST_REQUIRE(nRows < nRowsExpected);
00459             bufAccessor.unmarshalTuple(inputTuple);
00460             expectedOutputAccessor.setCurrentTupleBuf(
00461                 expectedBuffer + bufOffset);
00462             expectedOutputAccessor.unmarshal(expectedTuple);
00463             int c = outputTupleDesc.compareTuples(inputTuple, expectedTuple);
00464             if (c) {
00465                 std::cout << "(Row) = (" << nRows << ")"
00466                     << " -- Tuples don't match"<< std::endl;
00467                 BOOST_CHECK_EQUAL(0,c);
00468                 return;
00469             }
00470             bufAccessor.consumeTuple();
00471             bufOffset += expectedOutputAccessor.getCurrentByteCount();
00472             ++nRows;
00473         }
00474     }
00475     BOOST_CHECK_EQUAL(nRowsExpected,nRows);
00476 }

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

00306 {
00307     if (pScheduler) {
00308         pScheduler->stop();
00309     }
00310     tearDownExecStreamTest();
00311 
00312     pScheduler.reset(newScheduler());
00313     pGraph = newStreamGraph();
00314     pGraphEmbryo = newStreamGraphEmbryo(pGraph);
00315     pGraph->setResourceGovernor(pResourceGovernor);
00316 }

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

00320 {
00321     pGraph.reset();
00322     pGraphEmbryo.reset();
00323 }

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

00038 {
00039     SharedExecStreamGraph pGraph = ExecStreamGraph::newExecStreamGraph();
00040     pGraph->enableDummyTxnId(true);
00041     return pGraph;
00042 }

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

00046 {
00047     return SharedExecStreamGraphEmbryo(
00048         new ExecStreamGraphEmbryo(
00049             g, pScheduler, pCache, pSegmentFactory));
00050 }

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

00053 {
00054     return new DfsTreeExecStreamScheduler(
00055         shared_from_this(),
00056         "DfsTreeExecStreamScheduler");
00057 }

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

00062 {
00063     return new SimpleExecStreamGovernor(
00064         knobSettings, resourcesAvailable, shared_from_this(),
00065         "SimpleExecStreamGovernor");
00066 }

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

00032 {
00033     CacheTestBase::openStorage(openMode);
00034     openSegmentStorage(openMode);
00035 }

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

00038 {
00039     pLinearSegment = createLinearDeviceSegment(
00040         dataDeviceId,
00041         openMode.create ? 0
00042         : pRandomAccessDevice->getSizeInBytes() / cbPageFull);
00043 }

void SegStorageTestBase::openRandomSegment ( ) [virtual, inherited]

Reimplemented in LcsClusterReplaceExecStreamTest.

Definition at line 45 of file SegStorageTestBase.cpp.

References SegStorageTestBase::closeStorage(), DeviceMode::load, SegStorageTestBase::openStorage(), SegStorageTestBase::pLinearSegment, SegStorageTestBase::pRandomSegment, and SegStorageTestBase::pSegmentFactory.

Referenced by RandomAllocationSegmentTest::testAllocateAndDeallocate(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), and BTreeReadersTest::testCaseSetUp().

00046 {
00047     // reopen will interpret pages as already allocated, which
00048     // is what RandomAllocationSegment expects
00049     closeStorage();
00050     openStorage(DeviceMode::load);
00051     pRandomSegment = pSegmentFactory->newRandomAllocationSegment(
00052         pLinearSegment, true);
00053     pLinearSegment.reset();
00054 }

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

00058 {
00059     BlockId blockId(0);
00060     CompoundId::setDeviceId(blockId,deviceId);
00061     CompoundId::setBlockNum(blockId,0);
00062     LinearDeviceSegmentParams deviceParams;
00063     deviceParams.firstBlockId = blockId;
00064     deviceParams.nPagesMin = nPages;
00065     deviceParams.nPagesAllocated = nPages;
00066     return pSegmentFactory->newLinearDeviceSegment(
00067         pCache,deviceParams);
00068 }

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

00071 {
00072     if (pLinearSegment) {
00073         assert(pLinearSegment.unique());
00074         pLinearSegment.reset();
00075     }
00076 }

void SegStorageTestBase::closeRandomSegment ( ) [inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

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

00079 {
00080     if (pRandomSegment) {
00081         assert(pRandomSegment.unique());
00082         pRandomSegment.reset();
00083     }
00084 }

void SegStorageTestBase::closeVersionedRandomSegment ( ) [inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

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

00087 {
00088     if (pVersionedRandomSegment) {
00089         assert(pVersionedRandomSegment.unique());
00090         pVersionedRandomSegment.reset();
00091     }
00092 }

void SegStorageTestBase::closeSnapshotRandomSegment ( ) [inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

00095 {
00096     if (pSnapshotRandomSegment) {
00097         assert(pSnapshotRandomSegment.unique());
00098         pSnapshotRandomSegment.reset();
00099     }
00100 }

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

00103 {
00104     closeLinearSegment();
00105     closeRandomSegment();
00106     closeVersionedRandomSegment();
00107     // TODO:  assert pSegmentFactory.unique(), but not here
00108     CacheTestBase::closeStorage();
00109 }

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

00043 {
00044     return *pCache;
00045 }

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

Definition at line 66 of file CacheTestBase.cpp.

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

Referenced by CacheTestBase::openStorage().

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

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

Definition at line 84 of file CacheTestBase.cpp.

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

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

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

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

Definition at line 130 of file CacheTestBase.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, and CacheTestBase::pCache.

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

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

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

Definition at line 263 of file TestBase.cpp.

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

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

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

Parses the command line.

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

Definition at line 108 of file TestBase.cpp.

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

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

TestSuite * TestBase::releaseTestSuite ( ) [inherited]

Definition at line 157 of file TestBase.cpp.

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

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

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

Definition at line 214 of file TestBase.cpp.

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

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

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

Definition at line 228 of file TestBase.cpp.

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

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

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

Receives notification when a trace event occurs.

Parameters:

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

Implements TraceTarget.

Definition at line 243 of file TestBase.cpp.

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

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

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

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

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

Parameters:

source

name of source to be traced

Returns:: minimum severity level which should be traced

Implements TraceTarget.

Definition at line 258 of file TestBase.cpp.

References TestBase::traceLevel.

Referenced by LbmExecStreamTestBase::generateBitmaps().

00259 {
00260     return traceLevel;
00261 }

Member Data Documentation

StandardTypeDescriptorFactory LbmLoadBitmapTest::stdTypeFactory [protected]

Definition at line 55 of file LbmLoadBitmapTest.cpp.

Referenced by initBTreeTupleDesc(), and testCaseSetUp().

TupleAttributeDescriptor LbmLoadBitmapTest::attrDesc_int64 [protected]

Definition at line 56 of file LbmLoadBitmapTest.cpp.

Referenced by initBTreeTupleDesc(), testCaseSetUp(), and testLoad().

vector<boost::shared_ptr<BTreeDescriptor> > LbmLoadBitmapTest::bTreeClusters [protected]

BTrees corresponding to the clusters.

Definition at line 61 of file LbmLoadBitmapTest.cpp.

Referenced by initClusterScanDef(), testCaseTearDown(), and testLoad().

vector<PageId> LbmLoadBitmapTest::savedBTreeClusterRootIds [protected]

Saved root pageids of btrees corresponding to clusters; used to append to existing table.

Definition at line 67 of file LbmLoadBitmapTest.cpp.

Referenced by testCaseTearDown(), and testLoad().

vector<boost::shared_ptr<BTreeDescriptor> > LbmLoadBitmapTest::bTreeBitmaps [protected]

BTrees corresponding to the bitmaps.

Definition at line 72 of file LbmLoadBitmapTest.cpp.

Referenced by testCaseTearDown(), and testLoad().

vector<PageId> LbmLoadBitmapTest::savedBTreeBitmapRootIds [protected]

Saved root pageids of btrees corresponding to bitmaps; used to append to existing table.

Definition at line 78 of file LbmLoadBitmapTest.cpp.

Referenced by testCaseTearDown(), and testLoad().

vector<boost::shared_ptr<LbmEntryDump> > LbmLoadBitmapTest::entryDumps [protected]

Entry dumps corresponding to the bitmaps.

Definition at line 83 of file LbmLoadBitmapTest.cpp.

Referenced by testCaseTearDown(), and testLoad().

SharedExecStreamGraph ExecStreamUnitTestBase::pGraph [protected, inherited]

Definition at line 46 of file ExecStreamUnitTestBase.h.

SharedExecStreamGraphEmbryo ExecStreamUnitTestBase::pGraphEmbryo [protected, inherited]

Definition at line 47 of file ExecStreamUnitTestBase.h.

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(), initBTreeExecStreamParam(), LcsClusterReplaceExecStreamTest::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(), LcsClusterReplaceExecStreamTest::testClusterReplace(), LhxAggExecStreamTest::testCountImpl(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), 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.

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(), LcsClusterReplaceExecStreamTest::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(), LcsClusterReplaceExecStreamTest::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(), initBTreeExecStreamParam(), LbmSearchTest::initBTreeParam(), initBTreeParam(), LcsClusterReplaceExecStreamTest::initClusterAppendParams(), LbmExecStreamTestBase::initSorterExecStream(), LcsClusterReplaceExecStreamTest::loadCluster(), LcsMultiClusterAppendTest::loadClusters(), LcsRowScanExecStreamTest::loadOneCluster(), LbmSearchTest::loadTableAndIndex(), SegmentTestBase::lockPage(), LbmMinusExecStreamTest::newMinusStream(), ExecStreamTestBase::newStreamGraphEmbryo(), CacheTestBase::openDevice(), CacheTestBase::openStorage(), LcsClusterReplaceExecStreamTest::replaceCluster(), BackupRestoreTest::restore(), LbmSplicerExecStreamTest::spliceInput(), SegmentTestBase::testAllocate(), RandomAllocationSegmentTest::testAllocateAndDeallocate(), BackupRestoreTest::testBackupCleanup(), ExecStreamTestSuite::testBTreeInsertExecStream(), BTreeTest::testBulkLoad(), LhxHashTableTest::testCaseSetUp(), ExecStreamUnitTestBase::testCaseSetUp(), BTreeTest::testCaseSetUp(), BTreeReadersTest::testCaseSetUp(), LhxAggExecStreamTest::testCountImpl(), SegmentTestBase::testDeallocate(), SnapshotSegmentTest::testDeallocateOld(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamGovernorTest::testGovernor(), LhxAggExecStreamTest::testGroupCountImpl(), BackupRestoreTest::testHeaderBackupRestore(), LhxJoinExecStreamTest::testImpl(), ExternalSortExecStreamTest::testImpl(), BTreeTest::testInserts(), LbmIntersectExecStreamTest::testIntersect(), SegPageIterTest::testIter(), SegPageEntryIterTest::testIter(), CacheTest::testLargeCacheInit(), CacheTest::testLargeCacheRequest(), LbmEntryTest::testldb35(), LbmEntryTest::testler5920(), 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().

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

/home/pub/open/dev/fennel/lucidera/test/LbmLoadBitmapTest.cpp

Generated on Mon Jun 22 04:00:34 2009 for Fennel by

1.5.1

LbmLoadBitmapTest Class Reference

Public Member Functions

Static Public Member Functions

Static Public Attributes

Protected Types

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation