ParallelExecStreamSchedulerTest Class Reference

ParallelExecStreamSchedulerTest repeats the tests from ExecStreamTestSuite, but using a parallel scheduler. More...

Inheritance diagram for ParallelExecStreamSchedulerTest:

List of all members.

Public Member Functions
	ParallelExecStreamSchedulerTest ()
void	testReshapeExecStream ()
void	testScratchBufferExecStream ()
void	testDoubleBufferExecStream ()
void	testCopyExecStream ()
void	testMergeExecStream ()
void	testSegBufferExecStream ()
void	testCountAggExecStream ()
void	testSumAggExecStream ()
void	testSingleValueAggExecStream ()
void	testMergeImplicitPullInputs ()
void	testSplitterPlusBarrier ()
void	testCartesianJoinExecStreamOuter ()
void	testCartesianJoinExecStreamInner ()
void	testGroupAggExecStream1 ()
void	testGroupAggExecStream2 ()
void	testGroupAggExecStream3 ()
void	testGroupAggExecStream4 ()
void	testReshapeExecStreamCastFilter ()
void	testReshapeExecStreamNoCastFilter ()
void	testReshapeExecStreamDynamicParams ()
void	testBTreeInsertExecStreamStaticBTree ()
void	testBTreeInsertExecStreamDynamicBTree ()
void	testNestedLoopJoinExecStream1 ()
void	testNestedLoopJoinExecStream2 ()
void	testSegBufferReaderWriterExecStream1 ()
void	testSegBufferReaderWriterExecStream2 ()
void	testSegBufferReaderWriterExecStream3 ()
void	testSegBufferReaderWriterExecStream4 ()
virtual void	testCaseSetUp ()
	Equivalent to JUnit TestCase.setUp; this is called before each test case method is invoked.
virtual void	testCaseTearDown ()
	Equivalent to JUnit TestCase.tearDown; this is called after each test case method is invoked.
virtual void	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	testCartesianJoinExecStream (uint nRowsLeft, uint nRowsRight)
void	testGroupAggExecStreamNrows (uint nrows)
void	testReshapeExecStream (bool cast, bool filter, uint expectedNRows, int expectedStart, bool compareParam, std::hash_set< int64_t > const &outputParams)
void	testBTreeInsertExecStream (bool useDynamicBTree, uint nRows)
void	testNestedLoopJoinExecStream (uint nRowsLeft, uint nRowsRight)
void	testSegBufferReaderWriterExecStream (bool restartable, bool earlyClose)
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 ExecStreamGovernor *	newResourceGovernor (ExecStreamResourceKnobs const &knobSettings, ExecStreamResourceQuantity const &resourcesAvailable)
	Creates the resource governor.
void	snooze (uint nSeconds)
Protected Attributes
SharedExecStreamGraph	pGraph
SharedExecStreamGraphEmbryo	pGraphEmbryo
SharedExecStreamScheduler	pScheduler
SharedExecStreamGovernor	pResourceGovernor
SharedCacheAccessor	pCacheAccessor
SharedSegmentFactory	pSegmentFactory
SharedSegment	pLinearSegment
	Segment supporting linear page allocation.
SharedSegment	pRandomSegment
	(Optional) segment supporting random page allocation.
SharedSegment	pVersionedRandomSegment
	(Optional) segment supporting versioned random page allocation.
SharedSegment	pSnapshotRandomSegment
	(Optional) segment supporting snapshot random page allocation.
VictimPolicy	victimPolicy
	VictimPolicy to instantiate.
CacheParams	cacheParams
	Parameters for cache initialization.
SharedCache	pCache
	Cache instance being tested.
SharedRandomAccessDevice	pRandomAccessDevice
	The default cached device.
uint	nMemPages
	Size of cache in memory pages.
uint	nDiskPages
	Size of device in disk pages.
uint	cbPageFull
	Disk page size.
DeviceId	dataDeviceId
	Fixed ID to assign to data device.
TestSuite *	pTestSuite
	Boost test suite.
boost::shared_ptr< TestBase >	pTestObj
std::ofstream	traceStream
	Output file stream for tracing.
StrictMutex	traceMutex
	Protects traceStream.
std::string	testName
	Name of test.
TraceLevel	traceLevel
	Level at which to trace test execution.
FileStatsTarget	statsTarget
	Output for stats.
StatsTimer	statsTimer
	Timer for stats collection.
bool	traceStdout
	Copy trace output to stdout.
bool	traceFile
	Copy trace output to file.
TestCaseGroup	defaultTests
TestCaseGroup	extraTests
Static Protected Attributes
static const uint	DefaultCacheReservePercent = 5
static const uint	DefaultConcurrentStatements = 4
static bool	runAll
	Run all test cases, including the extra tests.
static std::string	runSingle
	Run only the test case of this name.
Private Member Functions
virtual ExecStreamScheduler *	newScheduler ()
	Creates a scheduler.
uint	getDegreeOfParallelism ()
Private Attributes
ThreadTracker	threadTracker
uint	degreeOfParallelism

---

Detailed Description

ParallelExecStreamSchedulerTest repeats the tests from ExecStreamTestSuite, but using a parallel scheduler.

Definition at line 32 of file ParallelExecStreamSchedulerTest.cpp.

---

Member Enumeration Documentation

enum CacheTestBase::VictimPolicy [protected, inherited]

The available victim policy implementations.

Enumerator:

victimTwoQ
victimLRU
victimRandom

Definition at line 44 of file CacheTestBase.h.

                      {
        victimTwoQ,
        victimLRU,
        victimRandom
    };

---

Constructor & Destructor Documentation

ParallelExecStreamSchedulerTest::ParallelExecStreamSchedulerTest

(

)

[inline, explicit]

Definition at line 57 of file ParallelExecStreamSchedulerTest.cpp.

References TestBase::configMap, degreeOfParallelism, ConfigMap::getIntParam(), TestBase::paramDegreeOfParallelism, ExecStreamTestSuite::testBTreeInsertExecStreamDynamicBTree(), ExecStreamTestSuite::testBTreeInsertExecStreamStaticBTree(), ExecStreamTestSuite::testCartesianJoinExecStreamInner(), ExecStreamTestSuite::testCartesianJoinExecStreamOuter(), ExecStreamTestSuite::testCopyExecStream(), ExecStreamTestSuite::testCountAggExecStream(), ExecStreamTestSuite::testDoubleBufferExecStream(), ExecStreamTestSuite::testGroupAggExecStream1(), ExecStreamTestSuite::testGroupAggExecStream2(), ExecStreamTestSuite::testGroupAggExecStream3(), ExecStreamTestSuite::testGroupAggExecStream4(), ExecStreamTestSuite::testMergeExecStream(), ExecStreamTestSuite::testMergeImplicitPullInputs(), ExecStreamTestSuite::testNestedLoopJoinExecStream1(), ExecStreamTestSuite::testNestedLoopJoinExecStream2(), ExecStreamTestSuite::testReshapeExecStreamCastFilter(), ExecStreamTestSuite::testReshapeExecStreamDynamicParams(), ExecStreamTestSuite::testReshapeExecStreamNoCastFilter(), ExecStreamTestSuite::testScratchBufferExecStream(), ExecStreamTestSuite::testSegBufferExecStream(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream1(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream2(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream3(), ExecStreamTestSuite::testSegBufferReaderWriterExecStream4(), ExecStreamTestSuite::testSingleValueAggExecStream(), ExecStreamTestSuite::testSplitterPlusBarrier(), and ExecStreamTestSuite::testSumAggExecStream().

        : ExecStreamTestSuite(false)
    {
        degreeOfParallelism =
            configMap.getIntParam(paramDegreeOfParallelism, 4);

        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testScratchBufferExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testDoubleBufferExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testCopyExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testMergeExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testSegBufferExecStream);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,testCartesianJoinExecStreamOuter);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,testCartesianJoinExecStreamInner);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testCountAggExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testSumAggExecStream);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream1);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream2);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream3);
        FENNEL_UNIT_TEST_CASE(ExecStreamTestSuite,testGroupAggExecStream4);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,testReshapeExecStreamCastFilter);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,testReshapeExecStreamNoCastFilter);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,testReshapeExecStreamDynamicParams);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSingleValueAggExecStream);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testMergeImplicitPullInputs);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testBTreeInsertExecStreamStaticBTree);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testBTreeInsertExecStreamDynamicBTree);

        // TODO jvs 4-Aug-2008:  enable these once
        // NLJ is parallel-safe
        FENNEL_EXTRA_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testNestedLoopJoinExecStream1);
        FENNEL_EXTRA_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testNestedLoopJoinExecStream2);

        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSplitterPlusBarrier);

        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSegBufferReaderWriterExecStream1);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSegBufferReaderWriterExecStream2);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSegBufferReaderWriterExecStream3);
        FENNEL_UNIT_TEST_CASE(
            ExecStreamTestSuite,
            testSegBufferReaderWriterExecStream4);
    }

---

Member Function Documentation

virtual ExecStreamScheduler* ParallelExecStreamSchedulerTest::newScheduler

(

)

[inline, private, virtual]

Creates a scheduler.

Reimplemented from ExecStreamTestBase.

Definition at line 39 of file ParallelExecStreamSchedulerTest.cpp.

References degreeOfParallelism, and threadTracker.

    {
        return new ParallelExecStreamScheduler(
            shared_from_this(),
            "ParallelExecStreamScheduler",
            threadTracker,
            degreeOfParallelism);
    }

uint ParallelExecStreamSchedulerTest::getDegreeOfParallelism

(

)

[inline, private, virtual]

Reimplemented from ExecStreamTestSuite.

Definition at line 48 of file ParallelExecStreamSchedulerTest.cpp.

References degreeOfParallelism.

    {
        return degreeOfParallelism;
    }

void ExecStreamTestSuite::testCartesianJoinExecStream	(	uint	nRowsLeft,
		uint	nRowsRight
	)			[protected, inherited]

Definition at line 246 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), CartesianJoinExecStreamParams::leftOuter, StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, ExecStreamUnitTestBase::prepareConfluenceGraph(), STANDARD_TYPE_INT_32, and ExecStreamUnitTestBase::verifyConstantOutput().

{
    // simulate SELECT * FROM t1, t2

    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_32));

    MockProducerExecStreamParams paramsMockOuter;
    paramsMockOuter.outputTupleDesc.push_back(attrDesc);
    paramsMockOuter.nRows = nRowsOuter;

    ExecStreamEmbryo outerStreamEmbryo;
    outerStreamEmbryo.init(new MockProducerExecStream(),paramsMockOuter);
    outerStreamEmbryo.getStream()->setName("OuterProducerExecStream");

    MockProducerExecStreamParams paramsMockInner(paramsMockOuter);
    paramsMockInner.nRows = nRowsInner;

    ExecStreamEmbryo innerStreamEmbryo;
    innerStreamEmbryo.init(new MockProducerExecStream(),paramsMockInner);
    innerStreamEmbryo.getStream()->setName("InnerProducerExecStream");

    CartesianJoinExecStreamParams paramsJoin;
    paramsJoin.leftOuter = false;

    ExecStreamEmbryo joinStreamEmbryo;
    joinStreamEmbryo.init(new CartesianJoinExecStream(),paramsJoin);
    joinStreamEmbryo.getStream()->setName("CartesianJoinExecStream");

    SharedExecStream pOutputStream = prepareConfluenceGraph(
        outerStreamEmbryo,
        innerStreamEmbryo,
        joinStreamEmbryo);

    int32_t zero = 0;
    TupleDescriptor expectedDesc;
    expectedDesc.push_back(attrDesc);
    expectedDesc.push_back(attrDesc);
    TupleData expectedTuple;
    expectedTuple.compute(expectedDesc);
    expectedTuple[0].pData = reinterpret_cast<PBuffer>(&zero);
    expectedTuple[1].pData = reinterpret_cast<PBuffer>(&zero);
    verifyConstantOutput(
        *pOutputStream,
        expectedTuple,
        nRowsOuter*nRowsInner);
}

void ExecStreamTestSuite::testGroupAggExecStreamNrows

(

uint

nrows

)

[protected, inherited]

Definition at line 373 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    // Create two columns, both with two duplicates per column.
    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = nrows;   // at least two buffers
    mockParams.pGenerator.reset(new RampDuplicateExecStreamGenerator());

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

    // simulate SELECT col, COUNT(*) FROM t10k GROUP BY col;
    SortedAggExecStreamParams aggParams;
    aggParams.groupByKeyCount = 1;
    aggParams.outputTupleDesc.push_back(attrDesc);
    aggParams.outputTupleDesc.push_back(attrDesc);
    AggInvocation countInvocation;
    countInvocation.aggFunction = AGG_FUNC_COUNT;
    countInvocation.iInputAttr = -1; // interpreted as COUNT(*)
    aggParams.aggInvocations.push_back(countInvocation);

    ExecStreamEmbryo aggStreamEmbryo;

    aggStreamEmbryo.init(new SortedAggExecStream(),aggParams);
    aggStreamEmbryo.getStream()->setName("SortedAggExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo,aggStreamEmbryo);

    // Result should be a sequence of values in the first column
    // and 2 for the second column
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;

    SharedInt64ColumnGenerator col =
        SharedInt64ColumnGenerator(new SeqColumnGenerator());
    columnGenerators.push_back(col);

    col = SharedInt64ColumnGenerator(new ConstColumnGenerator(2));
    columnGenerators.push_back(col);

    CompositeExecStreamGenerator expectedResultGenerator(columnGenerators);

    verifyOutput(*pOutputStream, mockParams.nRows/2, expectedResultGenerator);
}

void ExecStreamTestSuite::testReshapeExecStream	(	bool	cast,
		bool	filter,
		uint	expectedNRows,
		int	expectedStart,
		bool	compareParam,
		std::hash_set< int64_t > const &	outputParams
	)			[protected, inherited]

Definition at line 424 of file ExecStreamTestSuite.cpp.

References TupleDatum::cbData, COMP_EQ, COMP_NOOP, ReshapeExecStreamParams::compOp, TupleAccessor::compute(), TupleData::compute(), ReshapeExecStreamParams::dynamicParameters, FixedBuffer, TupleAccessor::getMaxByteCount(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), ReshapeExecStreamParams::inputCompareProj, TupleAccessor::marshal(), MAXU, StandardTypeDescriptorFactory::newDataType(), opaqueToInt(), ReshapeExecStreamParams::outputProj, ReshapeExecStreamParams::pCompTupleBuffer, TupleDatum::pData, ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

{
    assert(!compareParam || filter == compareParam);
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor nullAttrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64),
        true, sizeof(int64_t));
    TupleAttributeDescriptor notNullAttrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    // Input consists of 6 not nullable columns
    // - the first 4 columns will consist of sequential values, the 0th
    //   column starting at 0, the first at 1, 2nd at 2, 3rd at 3
    // - the 4th column will consist of sequential values starting at 0, each
    //   value repeating 25 times
    // - the 5th column will also consist of sequential values starting at 0,
    //   each value repeating 10 times
    MockProducerExecStreamParams mockParams;
    for (int i = 0; i < 6; i++) {
        mockParams.outputTupleDesc.push_back(notNullAttrDesc);
    }
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGen;
    for (int i = 0; i < 4; i++) {
        colGen = SharedInt64ColumnGenerator(new SeqColumnGenerator(i));
        columnGenerators.push_back(colGen);
    }
    colGen = SharedInt64ColumnGenerator(new DupColumnGenerator(25, 0));
    columnGenerators.push_back(colGen);
    colGen = SharedInt64ColumnGenerator(new DupColumnGenerator(10, 0));
    columnGenerators.push_back(colGen);
    mockParams.nRows = 1000;
    mockParams.pGenerator.reset(
        new CompositeExecStreamGenerator(columnGenerators));

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

    // Setup stream parameters as follows:
    // 1. If filtering is specified, filter columns 4 and 5 against values 20
    //    and 50.  If filtering on dynamic parameters, filter column 5 against
    //    the dynamic parameter value 50.
    // 2. Project columns 3, 0, and 2; if casting is specified, project them
    //    into nullable columns; else not nullable
    // 3. If outputting dynamic parameters, append them to the end of the
    //    output tuple
    ReshapeExecStreamParams rsParams;
    boost::shared_array<FixedBuffer> pBuffer;
    std::vector<int64_t> paramVals;
    paramVals.push_back(10);
    paramVals.push_back(20);
    paramVals.push_back(50);
    if (!filter) {
        rsParams.compOp = COMP_NOOP;
    } else {
        rsParams.compOp = COMP_EQ;
        TupleDescriptor compareDesc;
        // comparison type needs to be nullable to allow filtering of nulls
        compareDesc.push_back(nullAttrDesc);
        if (!compareParam) {
            compareDesc.push_back(nullAttrDesc);
        }
        TupleData compareData;
        compareData.compute(compareDesc);
        if (compareParam) {
            compareData[0].pData = (PConstBuffer) &paramVals[1];
        } else {
            compareData[0].pData = (PConstBuffer) &paramVals[1];
            compareData[1].pData = (PConstBuffer) &paramVals[2];
        }
        TupleAccessor tupleAccessor;
        tupleAccessor.compute(compareDesc);
        pBuffer.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]);
        tupleAccessor.marshal(compareData, pBuffer.get());
    }
    rsParams.pCompTupleBuffer = pBuffer;

    TupleProjection tupleProj;
    tupleProj.push_back(4);
    tupleProj.push_back(5);
    rsParams.inputCompareProj = tupleProj;

    tupleProj.clear();
    tupleProj.push_back(3);
    tupleProj.push_back(0);
    tupleProj.push_back(2);
    rsParams.outputProj = tupleProj;

    for (int i = 0; i < 3; i++) {
        if (cast) {
            rsParams.outputTupleDesc.push_back(nullAttrDesc);
        } else {
            rsParams.outputTupleDesc.push_back(notNullAttrDesc);
        }
    }

    // Setup the dynamic parameters, marking the ones that will be
    // included in the output stream.  If comparing against a dynamic
    // parameter, compare the third dynamic parameter against column 5.
    std::vector<ReshapeParameter> dynamicParams;
    if (compareParam || outputParams.size() > 0) {
        for (uint i = 1; i < paramVals.size() + 1; i++) {
            SharedDynamicParamManager pDynamicParamManager =
            pGraph->getDynamicParamManager();
            pDynamicParamManager->createParam(
                DynamicParamId(i),
                notNullAttrDesc);
            TupleDatum paramValDatum;
            paramValDatum.pData = (PConstBuffer) &(paramVals[i - 1]);
            paramValDatum.cbData = sizeof(int64_t);
            pDynamicParamManager->writeParam(
                DynamicParamId(i),
                paramValDatum);
            dynamicParams.push_back(
                ReshapeParameter(
                    DynamicParamId(i),
                    ((i == 3) && compareParam) ? uint(5) : MAXU,
                    (outputParams.find(i - 1) != outputParams.end())));
        }
    }
    rsParams.dynamicParameters = dynamicParams;

    // Setup the expected result
    columnGenerators.clear();
    colGen = SharedInt64ColumnGenerator(
        new SeqColumnGenerator(expectedStart + 3));
    columnGenerators.push_back(colGen);
    colGen = SharedInt64ColumnGenerator(
        new SeqColumnGenerator(expectedStart));
    columnGenerators.push_back(colGen);
    colGen = SharedInt64ColumnGenerator(
        new SeqColumnGenerator(expectedStart + 2));
    columnGenerators.push_back(colGen);
    for (uint i = 0; i < dynamicParams.size(); i++) {
        if (dynamicParams[i].outputParam) {
            colGen =
                SharedInt64ColumnGenerator(
                    new ConstColumnGenerator(
                        paramVals[opaqueToInt(
                            dynamicParams[i].dynamicParamId) - 1]));
            columnGenerators.push_back(colGen);
            rsParams.outputTupleDesc.push_back(notNullAttrDesc);
        }
    }

    ExecStreamEmbryo rsStreamEmbryo;
    rsStreamEmbryo.init(new ReshapeExecStream(),rsParams);
    rsStreamEmbryo.getStream()->setName("ReshapeExecStream");
    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, rsStreamEmbryo);

    CompositeExecStreamGenerator resultGenerator(columnGenerators);
    verifyOutput(*pOutputStream, expectedNRows, resultGenerator);
}

void ExecStreamTestSuite::testReshapeExecStream

(

)

[inherited]

void ExecStreamTestSuite::testBTreeInsertExecStream	(	bool	useDynamicBTree,
		uint	nRows
	)			[protected, inherited]

Definition at line 764 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), BTreeBuilder::createEmptyRoot(), BTreeInsertExecStreamParams::distinctness, DUP_FAIL, BTreeAccessBase::getRootPageId(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), BTreeParams::keyProj, BTreeDescriptor::keyProjection, BTreeInsertExecStreamParams::monotonic, StandardTypeDescriptorFactory::newDataType(), NULL_PAGE_ID, SingleOutputExecStreamParams::outputTupleDesc, BTreeDescriptor::pageOwnerId, BTreeParams::pageOwnerId, CacheTestBase::pCache, ExecStreamParams::pCacheAccessor, ExecStreamTestBase::pCacheAccessor, SegmentAccessor::pCacheAccessor, ExecStreamUnitTestBase::pGraph, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareTransformGraph(), BTreeParams::pRootMap, BTreeParams::pSegment, SegmentAccessor::pSegment, SegStorageTestBase::pSegmentFactory, BTreeParams::rootPageId, BTreeDescriptor::rootPageId, BTreeParams::rootPageIdParamId, ExecStreamParams::scratchAccessor, BTreeDescriptor::segmentAccessor, BTreeDescriptor::segmentId, BTreeParams::segmentId, STANDARD_TYPE_INT_64, BTreeParams::tupleDesc, BTreeDescriptor::tupleDescriptor, and ExecStreamUnitTestBase::verifyOutput().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    // Use a MockProducer to generate the btree records with a single key
    // and single value for each record.  The key sequences from
    // 0 ... nRows-1 while the value sequences from nRows to nRows*2-1
    MockProducerExecStreamParams mockParams;
    mockParams.nRows = nRows;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.outputTupleDesc.push_back(attrDesc);
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    columnGenerators.push_back(
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0)));
    columnGenerators.push_back(
        SharedInt64ColumnGenerator(new SeqColumnGenerator(nRows)));
    mockParams.pGenerator.reset(
        new CompositeExecStreamGenerator(columnGenerators));

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

    // Setup the BTreeInsert stream
    BTreeDescriptor descriptor;
    BTreeInsertExecStreamParams bTreeInsertParams;
    descriptor.tupleDescriptor.push_back(attrDesc);
    descriptor.tupleDescriptor.push_back(attrDesc);
    descriptor.keyProjection.push_back(0);
    descriptor.segmentAccessor.pSegment = pRandomSegment;
    descriptor.segmentAccessor.pCacheAccessor = pCacheAccessor;
    BTreeBuilder builder(descriptor, pRandomSegment);
    if (!useDynamicBTree) {
        builder.createEmptyRoot();
        descriptor.rootPageId = builder.getRootPageId();
        bTreeInsertParams.rootPageIdParamId = DynamicParamId(0);
    } else {
        descriptor.rootPageId = NULL_PAGE_ID;
        bTreeInsertParams.rootPageIdParamId = DynamicParamId(1);
    }

    bTreeInsertParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache, 10);
    bTreeInsertParams.pCacheAccessor = pCacheAccessor;
    bTreeInsertParams.distinctness = DUP_FAIL;
    bTreeInsertParams.monotonic = true;
    bTreeInsertParams.pSegment = pRandomSegment;
    bTreeInsertParams.pCacheAccessor = pCacheAccessor;
    bTreeInsertParams.rootPageId = descriptor.rootPageId;
    bTreeInsertParams.segmentId = descriptor.segmentId;
    bTreeInsertParams.pageOwnerId = descriptor.pageOwnerId;
    bTreeInsertParams.tupleDesc = descriptor.tupleDescriptor;
    bTreeInsertParams.keyProj = descriptor.keyProjection;
    bTreeInsertParams.pRootMap = 0;
    bTreeInsertParams.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo bTreeInsertEmbryo;
    bTreeInsertEmbryo.init(new BTreeInsertExecStream(), bTreeInsertParams);
    bTreeInsertEmbryo.getStream()->setName("BTreeInsertExecStream");

    SharedExecStream pOutputStream =
        prepareTransformGraph(mockStreamEmbryo, bTreeInsertEmbryo);

    ConstExecStreamGenerator expectedResultGenerator(0);
    verifyOutput(*pOutputStream, 0, expectedResultGenerator);

    // Get the rootPageId created by the stream so we can read from the tree
    if (useDynamicBTree) {
        descriptor.rootPageId =
            *reinterpret_cast<PageId const *>(
                pGraph->getDynamicParamManager()->getParam(
                    DynamicParamId(1)).getDatum().pData);
    }

    // Now that we've loaded the btree, verify the contents by directly
    // reading from the btree using a BTreeReader
    BTreeReader reader(descriptor);
    bool found = reader.searchFirst();
    if (!found) {
        BOOST_FAIL("searchFirst found nothing");
    }
    TupleData tupleData;
    tupleData.compute(descriptor.tupleDescriptor);
    for (uint i = 0; i < nRows; i++) {
        if (!found) {
            BOOST_FAIL("Could not searchNext for key #" << i);
        }
        reader.getTupleAccessorForRead().unmarshal(tupleData);
        uint64_t key = *reinterpret_cast<uint64_t const *>(tupleData[0].pData);
        uint64_t val = *reinterpret_cast<uint64_t const *>(tupleData[1].pData);
        BOOST_CHECK_EQUAL(key, i);
        BOOST_CHECK_EQUAL(val, i + nRows);
        found = reader.searchNext();
    }
    if (!reader.isSingular()) {
        BOOST_FAIL("Should have reached end of tree");
    }
    reader.endSearch();
}

void ExecStreamTestSuite::testNestedLoopJoinExecStream	(	uint	nRowsLeft,
		uint	nRowsRight
	)			[protected, inherited]

Definition at line 868 of file ExecStreamTestSuite.cpp.

References ValuesExecStreamParams::bufSize, COMP_EQ, ReshapeExecStreamParams::compOp, ReshapeExecStreamParams::dynamicParameters, ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), ReshapeExecStreamParams::inputCompareProj, NestedLoopJoinExecStreamParams::leftJoinKeys, CartesianJoinExecStreamParams::leftOuter, min(), StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, ReshapeExecStreamParams::outputProj, SingleOutputExecStreamParams::outputTupleDesc, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::prepareConfluenceGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

{
    // simulate SELECT t1.a, t2.a FROM t1, t2 WHERE t1.a = t2.a

    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    // 1st input is a mock producer that generates values 0 ... nRowsLeft - 1
    MockProducerExecStreamParams paramsMockOuter;
    paramsMockOuter.outputTupleDesc.push_back(attrDesc);
    paramsMockOuter.nRows = nRowsLeft;
    paramsMockOuter.pGenerator.reset(new RampExecStreamGenerator(0, 1));

    ExecStreamEmbryo outerStreamEmbryo;
    outerStreamEmbryo.init(new MockProducerExecStream(), paramsMockOuter);
    outerStreamEmbryo.getStream()->setName("OuterProducerExecStream");

    // 2nd input consists of a mock producer that generates values
    // 0 ... nRowsRight - 1, but those values are then filtered by a
    // ReshapeExecStream that only outputs rows matching the current left hand
    // side row.  The current left hand side row is passed to the right via
    // a dynamic parameter
    MockProducerExecStreamParams paramsMockInner;
    paramsMockInner.outputTupleDesc.push_back(attrDesc);
    paramsMockInner.nRows = nRowsRight;
    paramsMockInner.pGenerator.reset(new RampExecStreamGenerator(0, 1));

    ExecStreamEmbryo innerStreamEmbryo;
    innerStreamEmbryo.init(new MockProducerExecStream(), paramsMockInner);
    innerStreamEmbryo.getStream()->setName("InnerProducerExecStream");

    ReshapeExecStreamParams paramsReshape;
    paramsReshape.compOp = COMP_EQ;
    paramsReshape.outputProj.push_back(0);
    paramsReshape.inputCompareProj.push_back(0);
    paramsReshape.dynamicParameters.push_back(
        ReshapeParameter(DynamicParamId(1), 0, false));
    paramsReshape.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo reshapeStreamEmbryo;
    reshapeStreamEmbryo.init(new ReshapeExecStream(), paramsReshape);
    reshapeStreamEmbryo.getStream()->setName("ReshapeExecStream");

    // For the 3rd input, just create a an empty values stream.  This doesn't
    // do anything, but is just there to make sure the stream handles reading
    // from it.
    ValuesExecStreamParams paramsValues;
    paramsValues.bufSize = 0;
    paramsValues.outputTupleDesc.push_back(attrDesc);
    ExecStreamEmbryo valuesStreamEmbryo;
    valuesStreamEmbryo.init(new ValuesExecStream(), paramsValues);
    valuesStreamEmbryo.getStream()->setName("ValuesExecStream");

    // String together the inputs
    std::vector<std::vector<ExecStreamEmbryo> > sourceStreamEmbryosList;
    std::vector<ExecStreamEmbryo> sourceStreamEmbryos;
    sourceStreamEmbryos.push_back(outerStreamEmbryo);
    sourceStreamEmbryosList.push_back(sourceStreamEmbryos);

    sourceStreamEmbryos.clear();
    sourceStreamEmbryos.push_back(innerStreamEmbryo);
    sourceStreamEmbryos.push_back(reshapeStreamEmbryo);
    sourceStreamEmbryosList.push_back(sourceStreamEmbryos);

    sourceStreamEmbryos.clear();
    sourceStreamEmbryos.push_back(valuesStreamEmbryo);
    sourceStreamEmbryosList.push_back(sourceStreamEmbryos);

    NestedLoopJoinExecStreamParams paramsJoin;
    paramsJoin.leftOuter = false;
    paramsJoin.leftJoinKeys.push_back(
        NestedLoopJoinKey(DynamicParamId(1), 0));

    ExecStreamEmbryo joinStreamEmbryo;
    joinStreamEmbryo.init(new NestedLoopJoinExecStream(), paramsJoin);
    joinStreamEmbryo.getStream()->setName("NestedLoopJoinExecStream");

    SharedExecStream pOutputStream =
        prepareConfluenceGraph(sourceStreamEmbryosList, joinStreamEmbryo);

    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerators;
    SharedInt64ColumnGenerator colGen =
        SharedInt64ColumnGenerator(new SeqColumnGenerator(0));
    columnGenerators.push_back(colGen);
    colGen = SharedInt64ColumnGenerator(new SeqColumnGenerator(0));
    columnGenerators.push_back(colGen);

    CompositeExecStreamGenerator resultGenerator(columnGenerators);
    verifyOutput(
        *pOutputStream, std::min(nRowsLeft, nRowsRight), resultGenerator);
}

void ExecStreamTestSuite::testSegBufferReaderWriterExecStream	(	bool	restartable,
		bool	earlyClose
	)			[protected, inherited]

Definition at line 1019 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), ExecStreamTestSuite::getDegreeOfParallelism(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), MergeExecStreamParams::isParallel, CartesianJoinExecStreamParams::leftOuter, SegBufferExecStreamParams::multipass, StandardTypeDescriptorFactory::newDataType(), DiffluenceExecStreamParams::outputTupleDesc, ExecStreamTestBase::pCacheAccessor, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), SegBufferReaderExecStreamParams::readerRefCountParamId, SegBufferWriterExecStreamParams::readerRefCountParamId, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyConstantOutput().

{
    // This testcase exercises the SegBufferReaderExecStream and
    // SegBufferWriterExecStream classes using either a MergeExecStream
    // (inputs read serially) or a CartesianJoinExecStream (restartable
    // input), depending on the "restartable" parameter.
    //
    // The stream graph consists of a MergeExecStream or a
    // CartesianJoinExecStream with two inputs that are
    // SegBufferReaderExecStreams.  A SegBufferWriterExecStream buffers a
    // mock producer so it can be read by SegBufferReaderExecStreams.
    //
    // If the earlyClose parameter is set, then the
    // SegBufferReaderExecStreams output their data to a SegBufferExecStream
    // which will execute an early close once it has read all of its input.

    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    uint nRows;
    if (!restartable) {
        nRows = 10000;
    } else {
        nRows = 200;
    }
    mockParams.nRows = nRows;

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

    SegBufferWriterExecStreamParams writerParams;
    writerParams.scratchAccessor.pSegment = pRandomSegment;
    writerParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
    writerParams.readerRefCountParamId = DynamicParamId(1);
    writerParams.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo writerStreamEmbryo;
    writerStreamEmbryo.init(
        new SegBufferWriterExecStream(),
        writerParams);
    writerStreamEmbryo.getStream()->setName("SegBufferWriterExecStream");

    SegBufferReaderExecStreamParams readerParams;
    readerParams.scratchAccessor.pSegment = pRandomSegment;
    readerParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
    readerParams.readerRefCountParamId = DynamicParamId(1);
    readerParams.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo readerStreamEmbryo1;
    readerStreamEmbryo1.init(
        new SegBufferReaderExecStream(),
        readerParams);
    readerStreamEmbryo1.getStream()->setName("SegBufferReaderExecStream1");

    ExecStreamEmbryo readerStreamEmbryo2;
    readerStreamEmbryo2.init(
        new SegBufferReaderExecStream(),
        readerParams);
    readerStreamEmbryo2.getStream()->setName("SegBufferReaderExecStream2");

    std::vector<std::vector<ExecStreamEmbryo> > interStreamEmbryosList;
    std::vector<ExecStreamEmbryo> readerInput;
    readerInput.push_back(readerStreamEmbryo1);
    if (earlyClose) {
        SegBufferExecStreamParams bufParams;
        bufParams.scratchAccessor.pSegment = pRandomSegment;
        bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
        bufParams.multipass = false;

        ExecStreamEmbryo bufStreamEmbryo;
        bufStreamEmbryo.init(new SegBufferExecStream(),bufParams);
        bufStreamEmbryo.getStream()->setName("SegBufferExecStream1");
        readerInput.push_back(bufStreamEmbryo);
    }
    interStreamEmbryosList.push_back(readerInput);

    readerInput.clear();
    readerInput.push_back(readerStreamEmbryo2);
    if (earlyClose) {
        SegBufferExecStreamParams bufParams;
        bufParams.scratchAccessor.pSegment = pRandomSegment;
        bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
        if (restartable) {
            bufParams.multipass = true;
        }

        ExecStreamEmbryo bufStreamEmbryo;
        bufStreamEmbryo.init(new SegBufferExecStream(),bufParams);
        bufStreamEmbryo.getStream()->setName("SegBufferExecStream2");
        readerInput.push_back(bufStreamEmbryo);
    }
    interStreamEmbryosList.push_back(readerInput);

    MergeExecStreamParams mergeParams;
    CartesianJoinExecStreamParams joinParams;
    if (restartable) {
        joinParams.leftOuter = false;
    } else {
        mergeParams.outputTupleDesc.push_back(attrDesc);
        if (getDegreeOfParallelism() != 1) {
            mergeParams.isParallel = true;
        }
    }

    ExecStreamEmbryo execStreamEmbryo;
    if (restartable) {
        execStreamEmbryo.init(new CartesianJoinExecStream(), joinParams);
        execStreamEmbryo.getStream()->setName("CartesianJoinExecStream");
    } else {
        execStreamEmbryo.init(new MergeExecStream(), mergeParams);
        execStreamEmbryo.getStream()->setName("MergeExecStream");
    }

    SharedExecStream pOutputStream =
        prepareDAG(
            mockStreamEmbryo,
            writerStreamEmbryo,
            interStreamEmbryosList,
            execStreamEmbryo);

    int64_t zero = 0;
    TupleDescriptor expectedDesc;
    expectedDesc.push_back(attrDesc);
    if (restartable) {
        expectedDesc.push_back(attrDesc);
    }
    TupleData expectedTuple;
    expectedTuple.compute(expectedDesc);
    expectedTuple[0].pData = reinterpret_cast<PBuffer>(&zero);
    if (restartable) {
        expectedTuple[1].pData = reinterpret_cast<PBuffer>(&zero);
    }

    verifyConstantOutput(
        *pOutputStream,
        expectedTuple,
        restartable ? nRows * nRows : 2 * nRows);
}

void ExecStreamTestSuite::testScratchBufferExecStream

(

)

[inherited]

Definition at line 60 of file ExecStreamTestSuite.cpp.

References ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), CacheTestBase::pCache, ExecStreamUnitTestBase::prepareTransformGraph(), SegStorageTestBase::pSegmentFactory, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 5000;     // at least two buffers
    mockParams.pGenerator.reset(new RampExecStreamGenerator());

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

    ScratchBufferExecStreamParams bufParams;
    bufParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache,1);

    ExecStreamEmbryo bufStreamEmbryo;
    bufStreamEmbryo.init(new ScratchBufferExecStream(),bufParams);
    bufStreamEmbryo.getStream()->setName("ScratchBufferExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, bufStreamEmbryo);

    verifyOutput(
        *pOutputStream,
        mockParams.nRows,
        *(mockParams.pGenerator));
}

void ExecStreamTestSuite::testDoubleBufferExecStream

(

)

[inherited]

Definition at line 93 of file ExecStreamTestSuite.cpp.

References ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), CacheTestBase::pCache, ExecStreamUnitTestBase::prepareTransformGraph(), SegStorageTestBase::pSegmentFactory, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 25000;     // cycle through a few buffers
    mockParams.pGenerator.reset(new RampExecStreamGenerator());

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

    DoubleBufferExecStreamParams bufParams;
    bufParams.scratchAccessor =
        pSegmentFactory->newScratchSegment(pCache,1);

    ExecStreamEmbryo bufStreamEmbryo;
    bufStreamEmbryo.init(new DoubleBufferExecStream(),bufParams);
    bufStreamEmbryo.getStream()->setName("DoubleBufferExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, bufStreamEmbryo);

    verifyOutput(
        *pOutputStream,
        mockParams.nRows,
        *(mockParams.pGenerator));
}

void ExecStreamTestSuite::testCopyExecStream

(

)

[inherited]

Definition at line 125 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_32, and ExecStreamUnitTestBase::verifyConstantOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_32));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 10000;   // at least two buffers

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

    CopyExecStreamParams copyParams;
    copyParams.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo copyStreamEmbryo;
    copyStreamEmbryo.init(new CopyExecStream(),copyParams);
    copyStreamEmbryo.getStream()->setName("CopyExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo,copyStreamEmbryo);

    int32_t zero = 0;
    TupleDescriptor expectedDesc;
    expectedDesc.push_back(attrDesc);
    TupleData expectedTuple;
    expectedTuple.compute(expectedDesc);
    expectedTuple[0].pData = reinterpret_cast<PBuffer>(&zero);
    verifyConstantOutput(
        *pOutputStream,
        expectedTuple,
        mockParams.nRows);
}

void ExecStreamTestSuite::testMergeExecStream

(

)

[inherited]

Definition at line 161 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), ExecStreamTestSuite::getDegreeOfParallelism(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), MergeExecStreamParams::isParallel, StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareConfluenceGraph(), STANDARD_TYPE_INT_32, and ExecStreamUnitTestBase::verifyConstantOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    // simulate SELECT * FROM t10k UNION ALL SELECT * FROM 10k;

    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_32));

    MockProducerExecStreamParams paramsMock;
    paramsMock.outputTupleDesc.push_back(attrDesc);
    paramsMock.nRows = 10000; // at least two buffers

    ExecStreamEmbryo mockStreamEmbryo1;
    mockStreamEmbryo1.init(new MockProducerExecStream(),paramsMock);
    mockStreamEmbryo1.getStream()->setName("MockProducerExecStream1");

    ExecStreamEmbryo mockStreamEmbryo2;
    mockStreamEmbryo2.init(new MockProducerExecStream(),paramsMock);
    mockStreamEmbryo2.getStream()->setName("MockProducerExecStream2");

    MergeExecStreamParams paramsMerge;
    paramsMerge.outputTupleDesc.push_back(attrDesc);
    if (getDegreeOfParallelism() != 1) {
        paramsMerge.isParallel = true;
    }

    ExecStreamEmbryo mergeStreamEmbryo;
    mergeStreamEmbryo.init(new MergeExecStream(),paramsMerge);
    mergeStreamEmbryo.getStream()->setName("MergeExecStream");

    SharedExecStream pOutputStream = prepareConfluenceGraph(
        mockStreamEmbryo1,
        mockStreamEmbryo2,
        mergeStreamEmbryo);

    int32_t zero = 0;
    TupleDescriptor expectedDesc;
    expectedDesc.push_back(attrDesc);
    TupleData expectedTuple;
    expectedTuple.compute(expectedDesc);
    expectedTuple[0].pData = reinterpret_cast<PBuffer>(&zero);
    verifyConstantOutput(
        *pOutputStream,
        expectedTuple,
        2*paramsMock.nRows);
}

void ExecStreamTestSuite::testSegBufferExecStream

(

)

[inherited]

Definition at line 208 of file ExecStreamTestSuite.cpp.

References TupleData::compute(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), SegBufferExecStreamParams::multipass, StandardTypeDescriptorFactory::newDataType(), ExecStreamTestBase::pCacheAccessor, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_32, and ExecStreamUnitTestBase::verifyConstantOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_32));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 10000;     // at least two buffers

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

    SegBufferExecStreamParams bufParams;
    bufParams.scratchAccessor.pSegment = pRandomSegment;
    bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
    bufParams.multipass = false;

    ExecStreamEmbryo bufStreamEmbryo;
    bufStreamEmbryo.init(new SegBufferExecStream(),bufParams);
    bufStreamEmbryo.getStream()->setName("SegBufferExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo, bufStreamEmbryo);

    int32_t zero = 0;
    TupleDescriptor expectedDesc;
    expectedDesc.push_back(attrDesc);
    TupleData expectedTuple;
    expectedTuple.compute(expectedDesc);
    expectedTuple[0].pData = reinterpret_cast<PBuffer>(&zero);
    verifyConstantOutput(
        *pOutputStream,
        expectedTuple,
        mockParams.nRows);
}

void ExecStreamTestSuite::testCountAggExecStream

(

)

[inherited]

Definition at line 296 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 10000;   // at least two buffers

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

    // simulate SELECT COUNT(*) FROM t10k
    SortedAggExecStreamParams aggParams;
    aggParams.groupByKeyCount = 0;
    aggParams.outputTupleDesc.push_back(attrDesc);
    AggInvocation countInvocation;
    countInvocation.aggFunction = AGG_FUNC_COUNT;
    countInvocation.iInputAttr = -1; // interpreted as COUNT(*)
    aggParams.aggInvocations.push_back(countInvocation);

    ExecStreamEmbryo aggStreamEmbryo;
    aggStreamEmbryo.init(new SortedAggExecStream(),aggParams);
    aggStreamEmbryo.getStream()->setName("SortedAggExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo,aggStreamEmbryo);

    // set up a generator which can produce the expected output
    // (a count of 10000)
    RampExecStreamGenerator expectedResultGenerator(mockParams.nRows);

    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void ExecStreamTestSuite::testSumAggExecStream

(

)

[inherited]

Definition at line 333 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_SUM, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 10000;   // at least two buffers
    mockParams.pGenerator.reset(new RampExecStreamGenerator());

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

    // simulate SELECT SUM(x) FROM t10k with x iterating from 0 to 9999
    SortedAggExecStreamParams aggParams;
    aggParams.groupByKeyCount = 0;
    attrDesc.isNullable = true;
    aggParams.outputTupleDesc.push_back(attrDesc);
    AggInvocation sumInvocation;
    sumInvocation.aggFunction = AGG_FUNC_SUM;
    sumInvocation.iInputAttr = 0;
    aggParams.aggInvocations.push_back(sumInvocation);

    ExecStreamEmbryo aggStreamEmbryo;
    aggStreamEmbryo.init(new SortedAggExecStream(),aggParams);
    aggStreamEmbryo.getStream()->setName("SortedAggExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo,aggStreamEmbryo);

    // set up a generator which can produce the expected output
    // (a count of 5000*9999)
    RampExecStreamGenerator expectedResultGenerator(
        (mockParams.nRows-1)*mockParams.nRows/2);

    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void ExecStreamTestSuite::testSingleValueAggExecStream

(

)

[inherited]

Definition at line 583 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_SINGLE_VALUE, AggInvocation::aggFunction, SortedAggExecStreamParams::aggInvocations, ExecStreamEmbryo::getStream(), SortedAggExecStreamParams::groupByKeyCount, AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, SingleOutputExecStreamParams::outputTupleDesc, MockProducerExecStreamParams::pGenerator, ExecStreamUnitTestBase::prepareTransformGraph(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));
    TupleAttributeDescriptor attrDescNullable(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64), true,
        sizeof(int64_t));

    // Result should be a sequence of values in the first column
    // and 2 for the second column
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGeneratorsIn;

    SharedInt64ColumnGenerator col =
        SharedInt64ColumnGenerator(new DupColumnGenerator(1));
    columnGeneratorsIn.push_back(col);

    // Create two columns, both with two duplicates per column.
    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    mockParams.nRows = 10;
    mockParams.pGenerator.reset(
        new CompositeExecStreamGenerator(columnGeneratorsIn));

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

    // simulate SELECT col, SINGLE_VALUE(col) FROM t10k GROUP BY col;
    SortedAggExecStreamParams aggParams;
    aggParams.groupByKeyCount = 1;
    aggParams.outputTupleDesc.push_back(attrDesc);
    aggParams.outputTupleDesc.push_back(attrDescNullable);
    AggInvocation singleValueInvocation;
    singleValueInvocation.aggFunction = AGG_FUNC_SINGLE_VALUE;
    singleValueInvocation.iInputAttr = 0;
    aggParams.aggInvocations.push_back(singleValueInvocation);

    ExecStreamEmbryo aggStreamEmbryo;

    aggStreamEmbryo.init(new SortedAggExecStream(),aggParams);
    aggStreamEmbryo.getStream()->setName("SortedAggExecStream");

    SharedExecStream pOutputStream = prepareTransformGraph(
        mockStreamEmbryo,aggStreamEmbryo);

    // Result should be a sequence of values in both columns
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGeneratorsOut;

    col =
        SharedInt64ColumnGenerator(new DupColumnGenerator(1));
    columnGeneratorsOut.push_back(col);

    col =
        SharedInt64ColumnGenerator(new DupColumnGenerator(1));
    columnGeneratorsOut.push_back(col);

    CompositeExecStreamGenerator expectedResultGenerator(columnGeneratorsOut);

    verifyOutput(*pOutputStream, mockParams.nRows, expectedResultGenerator);
}

void ExecStreamTestSuite::testMergeImplicitPullInputs

(

)

[inherited]

Definition at line 645 of file ExecStreamTestSuite.cpp.

References COMP_EQ, TupleAccessor::compute(), TupleData::compute(), FixedBuffer, TupleAccessor::getMaxByteCount(), ExecStreamEmbryo::getStream(), ExecStreamEmbryo::init(), TupleAccessor::marshal(), SegBufferExecStreamParams::multipass, StandardTypeDescriptorFactory::newDataType(), MockProducerExecStreamParams::nRows, SingleOutputExecStreamParams::outputTupleDesc, ExecStreamTestBase::pCacheAccessor, MockProducerExecStreamParams::pGenerator, SegStorageTestBase::pRandomSegment, ExecStreamUnitTestBase::prepareDAG(), STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    // This testcase exercises the case where production of rows from inputs
    // into the MergeExecStream needs to occur independent of explicit requests
    // made by the MergeExecStream.  The initial input is a single stream
    // that is split by a SplitterExecStream and then brought back together by
    // the MergeExecSteam in a different order from the original input.

    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));
    TupleAttributeDescriptor nullAttrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64),
        true, sizeof(int64_t));

    // Initial input stream is a repeating sequence of
    // 0, 1, 2, ... nInputs - 1, 0, 1, 2, ..., nInputs - 1, 0, 1, 2, ...
    // Note that we're using a column generator here because there's already a
    // column generator class that produces the kind of input stream we need.

    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    // needs to fill up at least 2 buffers per input into the merge
    uint nInputs = 5;
    uint nRows = nInputs * 4000;
    mockParams.nRows = nRows;
    vector<boost::shared_ptr<ColumnGenerator<int64_t> > > columnGenerator;
    columnGenerator.push_back(
        SharedInt64ColumnGenerator(
            new DupRepeatingSeqColumnGenerator(nInputs, 1)));
    mockParams.pGenerator.reset(
        new CompositeExecStreamGenerator(columnGenerator));

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

    // split the mock data stream with each value being redirected to
    // one of the merge inputs, based on its value, by using reshape streams
    // to filter the input values

    SplitterExecStreamParams splitterParams;
    ExecStreamEmbryo splitterStreamEmbryo;
    splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams);
    splitterStreamEmbryo.getStream()->setName("SplitterExecStream");

    vector<vector<ExecStreamEmbryo> > reshapeEmbryoStreamList;
    for (int i = 0; i < nInputs; i++) {
        ReshapeExecStreamParams rsParams;
        boost::shared_array<FixedBuffer> pBuffer;
        rsParams.compOp = COMP_EQ;
        int64_t key = i;
        TupleDescriptor compareDesc;
        // comparison type needs to be nullable to allow filtering of nulls
        compareDesc.push_back(nullAttrDesc);
        TupleData compareData;
        compareData.compute(compareDesc);
        compareData[0].pData = (PConstBuffer) &key;
        TupleAccessor tupleAccessor;
        tupleAccessor.compute(compareDesc);
        pBuffer.reset(new FixedBuffer[tupleAccessor.getMaxByteCount()]);
        tupleAccessor.marshal(compareData, pBuffer.get());
        rsParams.pCompTupleBuffer = pBuffer;
        TupleProjection tupleProj;
        tupleProj.push_back(0);
        rsParams.inputCompareProj = tupleProj;
        rsParams.outputProj = tupleProj;

        ExecStreamEmbryo rsStreamEmbryo;
        rsStreamEmbryo.init(new ReshapeExecStream(), rsParams);
        std::ostringstream oss;
        oss << "ReshapeExecStream" << "#" << i;
        rsStreamEmbryo.getStream()->setName(oss.str());

        vector<ExecStreamEmbryo> reshapeStreamEmbryo;
        reshapeStreamEmbryo.push_back(rsStreamEmbryo);

        // since the splitter needs to pass through all rows but the merge
        // needs to return each input in the order of the inputs, we need to
        // buffer all but the first input to prevent the splitter from blocking
        if (i != 0) {
            SegBufferExecStreamParams bufParams;
            bufParams.scratchAccessor.pSegment = pRandomSegment;
            bufParams.scratchAccessor.pCacheAccessor = pCacheAccessor;
            bufParams.multipass = false;

            ExecStreamEmbryo bufStreamEmbryo;
            bufStreamEmbryo.init(new SegBufferExecStream(), bufParams);
            std::ostringstream oss;
            oss << "SegBufferExecStream" << "#" << i;
            bufStreamEmbryo.getStream()->setName(oss.str());

            reshapeStreamEmbryo.push_back(bufStreamEmbryo);
        }
        reshapeEmbryoStreamList.push_back(reshapeStreamEmbryo);
    }

    // merge the inputs with each input being read in sequence
    MergeExecStreamParams mergeParams;
    mergeParams.outputTupleDesc.push_back(attrDesc);

    ExecStreamEmbryo mergeStreamEmbryo;
    mergeStreamEmbryo.init(new MergeExecStream(), mergeParams);
    mergeStreamEmbryo.getStream()->setName("MergeExecStream");

    SharedExecStream pOutputStream =
        prepareDAG(
            mockStreamEmbryo,
            splitterStreamEmbryo,
            reshapeEmbryoStreamList,
            mergeStreamEmbryo);

    // setup the generator for the expected result -- 0's, followed by 1's,
    // followed by 2's, etc.
    StairCaseExecStreamGenerator expectedResultGenerator(1, nRows / nInputs);

    verifyOutput(*pOutputStream, nRows, expectedResultGenerator);
}

void ExecStreamTestSuite::testSplitterPlusBarrier

(

)

[inherited]

Definition at line 963 of file ExecStreamTestSuite.cpp.

References AGG_FUNC_COUNT, AggInvocation::aggFunction, BARRIER_RET_ANY_INPUT, ExecStreamEmbryo::getStream(), AggInvocation::iInputAttr, ExecStreamEmbryo::init(), StandardTypeDescriptorFactory::newDataType(), ExecStreamUnitTestBase::prepareDAG(), BarrierExecStreamParams::returnMode, STANDARD_TYPE_INT_64, and ExecStreamUnitTestBase::verifyOutput().

Referenced by ParallelExecStreamSchedulerTest().

{
    StandardTypeDescriptorFactory stdTypeFactory;
    TupleAttributeDescriptor attrDesc(
        stdTypeFactory.newDataType(STANDARD_TYPE_INT_64));
    MockProducerExecStreamParams mockParams;
    mockParams.outputTupleDesc.push_back(attrDesc);
    uint nRows = 10000;
    mockParams.nRows = nRows;
    ExecStreamEmbryo mockStreamEmbryo;
    mockStreamEmbryo.init(new MockProducerExecStream(), mockParams);
    mockStreamEmbryo.getStream()->setName("MockProducerExecStream");

    SplitterExecStreamParams splitterParams;
    ExecStreamEmbryo splitterStreamEmbryo;
    splitterStreamEmbryo.init(new SplitterExecStream(), splitterParams);
    splitterStreamEmbryo.getStream()->setName("SplitterExecStream");

    vector<vector<ExecStreamEmbryo> > aggEmbryoStreamList;
    for (int i = 0; i < 10; i++) {
        SortedAggExecStreamParams aggParams;
        aggParams.groupByKeyCount = 0;
        aggParams.outputTupleDesc.push_back(attrDesc);
        AggInvocation countInvocation;
        countInvocation.aggFunction = AGG_FUNC_COUNT;
        countInvocation.iInputAttr = -1;
        aggParams.aggInvocations.push_back(countInvocation);

        ExecStreamEmbryo aggStreamEmbryo;
        aggStreamEmbryo.init(new SortedAggExecStream(),aggParams);
        std::ostringstream oss;
        oss << "AggExecStream" << "#" << i;
        aggStreamEmbryo.getStream()->setName(oss.str());
        vector<ExecStreamEmbryo> v;
        v.push_back(aggStreamEmbryo);
        aggEmbryoStreamList.push_back(v);
    }

    BarrierExecStreamParams barrierParams;
    barrierParams.outputTupleDesc.push_back(attrDesc);
    barrierParams.returnMode = BARRIER_RET_ANY_INPUT;
    ExecStreamEmbryo barrierStreamEmbryo;
    barrierStreamEmbryo.init(new BarrierExecStream(), barrierParams);
    barrierStreamEmbryo.getStream()->setName("BarrierExecStream");

    SharedExecStream pOutputStream =
        prepareDAG(
            mockStreamEmbryo,
            splitterStreamEmbryo,
            aggEmbryoStreamList,
            barrierStreamEmbryo);

    ConstExecStreamGenerator expectedResultGenerator(nRows);
    verifyOutput(*pOutputStream, 1, expectedResultGenerator);
}

void ExecStreamTestSuite::testCartesianJoinExecStreamOuter

(

)

[inline, inherited]

Definition at line 137 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        // iterate multiple outer buffers
        testCartesianJoinExecStream(10000,5);
    }

void ExecStreamTestSuite::testCartesianJoinExecStreamInner

(

)

[inline, inherited]

Definition at line 143 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        // iterate multiple inner buffers
        testCartesianJoinExecStream(5,10000);
    }

void ExecStreamTestSuite::testGroupAggExecStream1

(

)

[inline, inherited]

Definition at line 149 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testGroupAggExecStreamNrows(10000);
    }

void ExecStreamTestSuite::testGroupAggExecStream2

(

)

[inline, inherited]

Definition at line 157 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testGroupAggExecStreamNrows(257*2);
    }

void ExecStreamTestSuite::testGroupAggExecStream3

(

)

[inline, inherited]

Definition at line 162 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testGroupAggExecStreamNrows(258*2);
    }

void ExecStreamTestSuite::testGroupAggExecStream4

(

)

[inline, inherited]

Definition at line 167 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testGroupAggExecStreamNrows(259*2);
    }

void ExecStreamTestSuite::testReshapeExecStreamCastFilter

(

)

[inline, inherited]

Definition at line 172 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        std::hash_set<int64_t> outputParams;
        testReshapeExecStream(true, true, 10, 500, false, outputParams);
    }

void ExecStreamTestSuite::testReshapeExecStreamNoCastFilter

(

)

[inline, inherited]

Definition at line 178 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        std::hash_set<int64_t> outputParams;
        testReshapeExecStream(false, false, 1000, 0, false, outputParams);
    }

void ExecStreamTestSuite::testReshapeExecStreamDynamicParams

(

)

[inline, inherited]

Definition at line 184 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        std::hash_set<int64_t> outputParams;
        outputParams.insert(0);
        outputParams.insert(2);
        testReshapeExecStream(true, false, 10, 500, true, outputParams);
    }

void ExecStreamTestSuite::testBTreeInsertExecStreamStaticBTree

(

)

[inline, inherited]

Definition at line 192 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testBTreeInsertExecStream(false, 1000);
    }

void ExecStreamTestSuite::testBTreeInsertExecStreamDynamicBTree

(

)

[inline, inherited]

Definition at line 197 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testBTreeInsertExecStream(true, 1000);
    }

void ExecStreamTestSuite::testNestedLoopJoinExecStream1

(

)

[inline, inherited]

Definition at line 202 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testNestedLoopJoinExecStream(10000, 5);
    }

void ExecStreamTestSuite::testNestedLoopJoinExecStream2

(

)

[inline, inherited]

Definition at line 207 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testNestedLoopJoinExecStream(5, 10000);
    }

void ExecStreamTestSuite::testSegBufferReaderWriterExecStream1

(

)

[inline, inherited]

Definition at line 212 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testSegBufferReaderWriterExecStream(false, false);
    }

void ExecStreamTestSuite::testSegBufferReaderWriterExecStream2

(

)

[inline, inherited]

Definition at line 217 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testSegBufferReaderWriterExecStream(true, false);
    }

void ExecStreamTestSuite::testSegBufferReaderWriterExecStream3

(

)

[inline, inherited]

Definition at line 222 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testSegBufferReaderWriterExecStream(false, true);
    }

void ExecStreamTestSuite::testSegBufferReaderWriterExecStream4

(

)

[inline, inherited]

Definition at line 227 of file ExecStreamTestSuite.h.

Referenced by ParallelExecStreamSchedulerTest().

    {
        testSegBufferReaderWriterExecStream(true, true);
    }

SharedExecStream ExecStreamUnitTestBase::prepareSourceGraph

(

ExecStreamEmbryo &

sourceStreamEmbryo

)

[protected, inherited]

Defines and prepares a graph consisting of one source stream.

Parameters:

sourceStreamEmbryo

embryonic source stream which produces tuples

Returns:

output buffer stream

Definition at line 41 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareTransformGraph().

Referenced by FlatFileExecStreamTest::testStream().

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

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

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

Parameters:

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

Returns:

output buffer stream

Definition at line 48 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

Parameters:

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

Returns:

output buffer stream

Definition at line 57 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

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

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

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

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

Parameters:

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

Returns:

output buffer stream

Definition at line 89 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

Parameters:

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

Returns:

output buffer stream

Definition at line 155 of file ExecStreamUnitTestBase.cpp.

References ExecStreamUnitTestBase::prepareConfluenceGraph().

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

    return
        prepareConfluenceGraph(sourceStreamEmbryosList, confluenceStreamEmbryo);
}

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

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

Each source stream can be a list of streams.

Parameters:

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

Returns:

output buffer stream

Definition at line 174 of file ExecStreamUnitTestBase.cpp.

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

{
    pGraphEmbryo->saveStreamEmbryo(confluenceStreamEmbryo);

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

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

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

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

    return pAdaptedStream;
}

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

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

Parameters:

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

Returns:

output buffer stream

Definition at line 100 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

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

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

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

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

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


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

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

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

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

Parameters:

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

Returns:

output buffer stream or null stream if createSink is false

Definition at line 208 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

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

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

Parameters:

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

Returns:

output buffer stream or null stream if createSink is false

Definition at line 232 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

    pGraphEmbryo->saveStreamEmbryo(destStreamEmbryo);

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

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

    SharedExecStream pAdaptedStream;

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

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

    return pAdaptedStream;
}

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

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

Parameters:

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

Definition at line 325 of file ExecStreamUnitTestBase.cpp.

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

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

{
    // TODO:  assertions about output tuple

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

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

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

Parameters:

	stream	output stream from which to read
	expectedTuple
	nRowsExpected

Definition at line 377 of file ExecStreamUnitTestBase.cpp.

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

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

{
    // TODO:  assertions about output tuple

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

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

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

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

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

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

Parameters:

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

Definition at line 424 of file ExecStreamUnitTestBase.cpp.

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

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

{
    // TODO:  assertions about output tuple

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

void ExecStreamUnitTestBase::resetExecStreamTest

(

)

[protected, inherited]

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

Definition at line 305 of file ExecStreamUnitTestBase.cpp.

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

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

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

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

void ExecStreamUnitTestBase::tearDownExecStreamTest

(

)

[protected, virtual, inherited]

ExecStream-specific handler called from testCaseTearDown.

Reimplemented from ExecStreamTestBase.

Definition at line 319 of file ExecStreamUnitTestBase.cpp.

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

Referenced by ExecStreamUnitTestBase::resetExecStreamTest().

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

void ExecStreamUnitTestBase::testCaseSetUp

(

)

[virtual, inherited]

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

Default is no-op.

Reimplemented from ExecStreamTestBase.

Reimplemented in LbmExecStreamTestBase, LbmLoadBitmapTest, LbmSearchTest, LbmSplicerExecStreamTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, LcsRowScanExecStreamTest, ExecStreamGovernorTest, and ExternalSortExecStreamTest.

Definition at line 289 of file ExecStreamUnitTestBase.cpp.

References ExecStreamTestBase::newStreamGraph(), ExecStreamTestBase::newStreamGraphEmbryo(), SegStorageTestBase::openRandomSegment(), CacheTestBase::pCache, ExecStreamTestBase::pCacheAccessor, ExecStreamUnitTestBase::pGraph, ExecStreamUnitTestBase::pGraphEmbryo, ExecStreamTestBase::pResourceGovernor, and ExecStreamTestBase::testCaseSetUp().

Referenced by ExternalSortExecStreamTest::testCaseSetUp(), ExecStreamGovernorTest::testCaseSetUp(), LcsRowScanExecStreamTest::testCaseSetUp(), LcsMultiClusterAppendTest::testCaseSetUp(), LcsClusterReplaceExecStreamTest::testCaseSetUp(), LcsClusterAppendExecStreamTest::testCaseSetUp(), LbmSplicerExecStreamTest::testCaseSetUp(), LbmLoadBitmapTest::testCaseSetUp(), and LbmExecStreamTestBase::testCaseSetUp().

{
    ExecStreamTestBase::testCaseSetUp();
    openRandomSegment();
    pGraph = newStreamGraph();
    pGraphEmbryo = newStreamGraphEmbryo(pGraph);
    pGraph->setResourceGovernor(pResourceGovernor);

    // we don't bother with quotas for unit tests, but we do need
    // to be able to associate TxnId's in order for parallel
    // execution to work (since a cache page may be pinned
    // by one thread and then released by another)
    pCacheAccessor.reset(
        new TransactionalCacheAccessor(pCache));
}

SharedExecStreamGraph ExecStreamTestBase::newStreamGraph

(

)

[protected, virtual, inherited]

Creates a stream graph.

Definition at line 37 of file ExecStreamTestBase.cpp.

References ExecStreamGraph::newExecStreamGraph().

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

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

SharedExecStreamGraphEmbryo ExecStreamTestBase::newStreamGraphEmbryo

(

SharedExecStreamGraph

)

[protected, virtual, inherited]

Creates an embryo for a stream graph.

Definition at line 45 of file ExecStreamTestBase.cpp.

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

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

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

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

Creates the resource governor.

Definition at line 59 of file ExecStreamTestBase.cpp.

Referenced by ExecStreamTestBase::testCaseSetUp().

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

void ExecStreamTestBase::testCaseTearDown

(

)

[virtual, inherited]

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

Default is no-op.

Reimplemented from CacheTestBase.

Reimplemented in LbmLoadBitmapTest, LbmSearchTest, LcsClusterAppendExecStreamTest, LcsClusterReplaceExecStreamTest, LcsMultiClusterAppendTest, and LcsRowScanExecStreamTest.

Definition at line 82 of file ExecStreamTestBase.cpp.

References ExecStreamTestBase::pCacheAccessor, ExecStreamTestBase::pResourceGovernor, ExecStreamTestBase::pScheduler, ExecStreamTestBase::tearDownExecStreamTest(), and CacheTestBase::testCaseTearDown().

Referenced by LcsRowScanExecStreamTest::testCaseTearDown(), LcsMultiClusterAppendTest::testCaseTearDown(), LcsClusterReplaceExecStreamTest::testCaseTearDown(), LcsClusterAppendExecStreamTest::testCaseTearDown(), LbmSearchTest::testCaseTearDown(), and LbmLoadBitmapTest::testCaseTearDown().

{
    // first stop the scheduler
    if (pScheduler) {
        pScheduler->stop();
    }
    pCacheAccessor.reset();
    // destroy the graph
    tearDownExecStreamTest();
    // free the scheduler last, since an ExecStreamGraph holds a raw Scheduler
    // ptr
    pScheduler.reset();
    assert(pResourceGovernor.unique());
    pResourceGovernor.reset();
    SegStorageTestBase::testCaseTearDown();
}

void SegStorageTestBase::openStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SegmentTestBase.

Definition at line 31 of file SegStorageTestBase.cpp.

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

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

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

void SegStorageTestBase::openSegmentStorage

(

DeviceMode

openMode

)

[virtual, inherited]

Reimplemented in LinearViewSegmentTest, SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 37 of file SegStorageTestBase.cpp.

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

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

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

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

{
    // reopen will interpret pages as already allocated, which
    // is what RandomAllocationSegment expects
    closeStorage();
    openStorage(DeviceMode::load);
    pRandomSegment = pSegmentFactory->newRandomAllocationSegment(
        pLinearSegment, true);
    pLinearSegment.reset();
}

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

Definition at line 56 of file SegStorageTestBase.cpp.

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

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

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

void SegStorageTestBase::closeLinearSegment

(

)

[inherited]

Definition at line 70 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pLinearSegment.

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

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

void SegStorageTestBase::closeRandomSegment

(

)

[inherited]

Definition at line 78 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pRandomSegment.

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

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

void SegStorageTestBase::closeVersionedRandomSegment

(

)

[inherited]

Definition at line 86 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pVersionedRandomSegment.

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

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

void SegStorageTestBase::closeSnapshotRandomSegment

(

)

[inherited]

Definition at line 94 of file SegStorageTestBase.cpp.

References SegStorageTestBase::pSnapshotRandomSegment.

Referenced by SnapshotSegmentTestBase::closeStorage().

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

void SegStorageTestBase::closeStorage

(

)

[virtual, inherited]

Reimplemented from CacheTestBase.

Reimplemented in SnapshotSegmentTestBase, and VersionedSegmentTest.

Definition at line 102 of file SegStorageTestBase.cpp.

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

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

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

Cache & CacheTestBase::getCache

(

)

[inherited]

Definition at line 42 of file CacheTestBase.cpp.

References CacheTestBase::pCache.

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

{
    return *pCache;
}

SharedCache CacheTestBase::newCache

(

)

[virtual, inherited]

Definition at line 66 of file CacheTestBase.cpp.

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

Referenced by CacheTestBase::openStorage().

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

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

Definition at line 84 of file CacheTestBase.cpp.

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

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

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

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

Definition at line 130 of file CacheTestBase.cpp.

References CHECKPOINT_FLUSH_AND_UNMAP, and CacheTestBase::pCache.

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

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

void TestBase::snooze

(

uint

nSeconds

)

[protected, inherited]

Definition at line 263 of file TestBase.cpp.

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

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

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

Parses the command line.

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

Definition at line 108 of file TestBase.cpp.

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

{
    bool verbose = false;
    ConfigMap adhocMap;

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

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

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

TestSuite * TestBase::releaseTestSuite

(

)

[inherited]

Definition at line 157 of file TestBase.cpp.

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

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

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

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

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

void TestBase::beforeTestCase

(

std::string

testCaseName

)

[inherited]

Definition at line 214 of file TestBase.cpp.

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

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

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

void TestBase::afterTestCase

(

std::string

testCaseName

)

[inherited]

Definition at line 228 of file TestBase.cpp.

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

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

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

Receives notification when a trace event occurs.

Parameters:

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

Implements TraceTarget.

Definition at line 243 of file TestBase.cpp.

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

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

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

TraceLevel TestBase::getSourceTraceLevel

(

std::string

source

)

[virtual, inherited]

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

Parameters:

source

name of source to be traced

Returns:

minimum severity level which should be traced

Implements TraceTarget.

Definition at line 258 of file TestBase.cpp.

References TestBase::traceLevel.

Referenced by LbmExecStreamTestBase::generateBitmaps().

{
    return traceLevel;
}

---

Member Data Documentation

ThreadTracker ParallelExecStreamSchedulerTest::threadTracker [private]

Definition at line 34 of file ParallelExecStreamSchedulerTest.cpp.

Referenced by newScheduler().

uint ParallelExecStreamSchedulerTest::degreeOfParallelism [private]

Definition at line 36 of file ParallelExecStreamSchedulerTest.cpp.

Referenced by getDegreeOfParallelism(), newScheduler(), and ParallelExecStreamSchedulerTest().

SharedExecStreamGraph ExecStreamUnitTestBase::pGraph [protected, inherited]

Definition at line 46 of file ExecStreamUnitTestBase.h.

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

SharedExecStreamGraphEmbryo ExecStreamUnitTestBase::pGraphEmbryo [protected, inherited]

Definition at line 47 of file ExecStreamUnitTestBase.h.

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

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

Definition at line 45 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

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

Definition at line 47 of file ExecStreamTestBase.h.

Referenced by ExecStreamTestBase::testCaseSetUp().

SharedExecStreamScheduler ExecStreamTestBase::pScheduler [protected, inherited]

Definition at line 49 of file ExecStreamTestBase.h.

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

SharedExecStreamGovernor ExecStreamTestBase::pResourceGovernor [protected, inherited]

Definition at line 51 of file ExecStreamTestBase.h.

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

SharedCacheAccessor ExecStreamTestBase::pCacheAccessor [protected, inherited]

Definition at line 53 of file ExecStreamTestBase.h.

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

SharedSegmentFactory SegStorageTestBase::pSegmentFactory [protected, inherited]

Definition at line 40 of file SegStorageTestBase.h.

Referenced by BackupRestoreTest::backup(), SegStorageTestBase::createLinearDeviceSegment(), LogicalTxnTest::createRecoveryLog(), LbmSearchTest::initBTreeExecStreamParam(), LbmLoadBitmapTest::initBTreeExecStreamParam(), 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(), LbmLoadBitmapTest::testLoad(), LcsClusterAppendExecStreamTest::testLoadMultiCol(), LcsClusterAppendExecStreamTest::testLoadSingleCol(), LbmEntryTest::testMergeEntry(), BTreeTest::testMultiKeySearches(), BTreeTest::testScan(), ExecStreamTestSuite::testScratchBufferExecStream(), LhxAggExecStreamTest::testSingleValueImpl(), FlatFileExecStreamTest::testStream(), LhxAggExecStreamTest::testSumImpl(), LogicalTxnTest::testTxn(), SnapshotSegmentTest::testUncommittedReads(), LbmUnionExecStreamTest::testUnion(), SegStreamTest::testWriteSpillAndRead(), and LbmEntryTest::testZeroBytes().

SharedSegment SegStorageTestBase::pLinearSegment [protected, inherited]

Segment supporting linear page allocation.

Definition at line 45 of file SegStorageTestBase.h.

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

SharedSegment SegStorageTestBase::pRandomSegment [protected, inherited]

(Optional) segment supporting random page allocation.

Definition at line 50 of file SegStorageTestBase.h.

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

SharedSegment SegStorageTestBase::pVersionedRandomSegment [protected, inherited]

(Optional) segment supporting versioned random page allocation.

Definition at line 55 of file SegStorageTestBase.h.

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

SharedRandomAccessDevice CacheTestBase::pRandomAccessDevice [protected, inherited]

The default cached device.

Definition at line 68 of file CacheTestBase.h.

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

uint CacheTestBase::nMemPages [protected, inherited]

Size of cache in memory pages.

Definition at line 73 of file CacheTestBase.h.

Referenced by CacheTestBase::CacheTestBase(), 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().

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(), 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/test/ParallelExecStreamSchedulerTest.cpp

---