Fennel: BTreePrefetchSearchExecStream Class Reference (original) (raw)

• Main Page

• Namespaces

• Classes

• Files

• Directories

• Related Pages

• Alphabetical List

• Class List

• Class Hierarchy

• Class Members

BTreePrefetchSearchExecStream extends BTreeSearchExecStream by pre-fetching index leaf pages. More...

#include <[BTreePrefetchSearchExecStream.h](BTreePrefetchSearchExecStream%5F8h-source.html)>

Inheritance diagram for BTreePrefetchSearchExecStream:

List of all members.

Detailed Description

BTreePrefetchSearchExecStream extends BTreeSearchExecStream by pre-fetching index leaf pages.

It does this by utilizing two btree readers. The first searches and reads only non-leaf pages, and initiates the pre-fetching of leaf pages. The second reader searches and reads the pre-fetched leaf pages.

NOTE: Because this execution stream allocates a number of scratch pages that are freed when the stream is closed, a private scratch segment should be created for the stream, if it is used in a stream graph with other streams that also use scratch pages.

Also, this stream assumes that it's reading a snapshot of the btree pages. Specifically, it does not handle the case where the btree grows or shrinks from/to a 1-level btree while the tree is being searched/read.

Version:

Id

//open/dev/fennel/ftrs/BTreePrefetchSearchExecStream.h#6

Definition at line 96 of file BTreePrefetchSearchExecStream.h.

Constructor & Destructor Documentation

| BTreePrefetchSearchExecStream::BTreePrefetchSearchExecStream | ( | | ) | [explicit] | | ------------------------------------------------------------ | - | | - | ------------ |

Member Function Documentation

| void BTreePrefetchSearchExecStream::allocateScratchPages | ( | | ) | [protected] | | -------------------------------------------------------- | - | | - | ------------- |

| bool BTreePrefetchSearchExecStream::innerSearchLoop | ( | | ) | [protected] | | --------------------------------------------------- | - | | - | ------------- |

Searches individual leaf pages.

Returns:

true if the search was successful; false if the input stream has been exhausted

Reimplemented from BTreeSearchExecStream.

Definition at line 190 of file BTreePrefetchSearchExecStream.cpp.

References EXECBUF_EOS, getPrefetchSearchKey(), initialPrefetchDone, leafPageQueue, SegPageEntryIter< EntryT >::mapRange(), NULL_PAGE_ID, SingleInputExecStream::pInAccessor, pLeafReader, BTreeReadExecStream::pReader, prevLeafSearchRc, processingDone, BTreeReadExecStream::projAccessor, BTreeSearchExecStream::searchForKey(), BTreeDescriptor::segmentAccessor, setUpSearchKey(), BTreeSearchExecStream::testInterval(), BTreeExecStream::treeDescriptor, BTreeReadExecStream::tupleData, and TupleProjectionAccessor::unmarshal().

Referenced by execute().

| void BTreePrefetchSearchExecStream::getPrefetchSearchKey | ( | | ) | [protected] | | -------------------------------------------------------- | - | | - | ------------- |

Reads the search directives and keys from the input stream, and initializes the data for use in the btree searches used to pre-fetch leaf pages.

Definition at line 256 of file BTreePrefetchSearchExecStream.cpp.

References BTreeSearchExecStream::lowerBoundDirective, pfLowerBoundData, pfLowerBoundDirective, pfUpperBoundData, pfUpperBoundDirective, BTreeSearchExecStream::pSearchKey, BTreeSearchExecStream::readDirectives(), BTreeSearchExecStream::readSearchKey(), BTreeSearchExecStream::readUpperBoundKey(), setAdditionalKeys(), BTreeSearchExecStream::upperBoundData, and BTreeSearchExecStream::upperBoundDirective.

Referenced by getNextPageForPrefetch(), and innerSearchLoop().

Sets up the search key for the current leaf page search using data stored away by a pre-fetch.

Parameters:

Definition at line 268 of file BTreePrefetchSearchExecStream.cpp.

References BTreePrefetchSearchKey::lowerBoundDirective, BTreeSearchExecStream::lowerBoundDirective, BTreePrefetchSearchKey::lowerKeyBuffer, savedUpperBoundAccessor, TupleAccessor::setCurrentTupleBuf(), setLowerBoundKey(), TupleAccessor::unmarshal(), BTreeSearchExecStream::upperBoundData, BTreePrefetchSearchKey::upperBoundDirective, BTreeSearchExecStream::upperBoundDirective, and BTreePrefetchSearchKey::upperKeyBuffer.

Referenced by innerSearchLoop().

Saves away the search key data corresponding to a pre-fetched page.

Parameters:

Definition at line 387 of file BTreePrefetchSearchExecStream.cpp.

References bigMaxKey, TupleAccessor::getByteCount(), keyValuesSize, BTreePrefetchSearchKey::lowerBoundDirective, BTreePrefetchSearchKey::lowerKeyBuffer, TupleAccessor::marshal(), BTreePrefetchSearchKey::newSearch, pfLowerBoundData, pfLowerBoundDirective, pfUpperBoundData, pfUpperBoundDirective, savedLowerBoundAccessor, savedUpperBoundAccessor, BTreePrefetchSearchKey::upperBoundDirective, and BTreePrefetchSearchKey::upperKeyBuffer.

Referenced by getNextPageForPrefetch().

| bool BTreePrefetchSearchExecStream::testNonLeafInterval | ( | | ) | [protected] | | ------------------------------------------------------- | - | | - | ------------- |

Determines if the current key just read from a non-leaf page contains the last matching page in the search interval.

Returns:

true if the current key contains the last matching non-leaf page

Definition at line 408 of file BTreePrefetchSearchExecStream.cpp.

References TupleDescriptor::compareTuples(), TupleDescriptor::compareTuplesKey(), BTreeSearchExecStream::inputKeyDesc, pfLowerBoundData, pfUpperBoundData, pfUpperBoundDirective, pNonLeafReader, BTreeSearchExecStream::readerKeyData, SEARCH_OPEN_UPPER, SEARCH_UNBOUNDED_UPPER, and BTreeNodeAccessor::unmarshalKey().

Referenced by getNextPageForPrefetch().

| void BTreePrefetchSearchExecStream::setAdditionalKeys | ( | | ) | [protected, virtual] | | ----------------------------------------------------- | - | | - | ---------------------- |

Definition at line 40 of file BTreePrefetchSearchExecStream.cpp.

References SegPageLock::accessSegment(), TupleData::compute(), TupleAccessor::compute(), BTreeSearchExecStream::inputKeyDesc, pfLowerBoundData, pfUpperBoundData, BTreeSearchExecStream::prepare(), SegmentAccessor::pSegment, savedLowerBoundAccessor, savedUpperBoundAccessor, BTreeExecStream::scratchAccessor, scratchLock, scratchPageSize, and BTreeSearchExecStream::upperBoundDesc.

Referenced by LbmSearchExecStream::prepare().

Determines resource requirements for this stream.

Default implementation declares zero resource requirements.

Parameters:

Reimplemented from ExecStream.

Definition at line 59 of file BTreePrefetchSearchExecStream.cpp.

References bigMaxKey, EXEC_RESOURCE_ACCURATE, TupleAccessor::getMaxByteCount(), BTreeReadExecStream::getResourceRequirements(), keyValuesSize, ExecStreamResourceQuantity::nCachePages, nEntriesPerScratchPage, nMiscCachePages, savedLowerBoundAccessor, and scratchPageSize.

Opens this stream, acquiring any resources needed in order to be able to fetch data.

A precondition is that input streams must already be opened. A stream can be closed and reopened.

Parameters:

Reimplemented from BTreeSearchExecStream.

Definition at line 104 of file BTreePrefetchSearchExecStream.cpp.

References allocateScratchPages(), bigMaxKey, initialPrefetchDone, leafPageQueue, nEntriesPerScratchPage, nPrefetchScratchPages, BTreeSearchExecStream::open(), pNonLeafReader, prevLeafSearchRc, processingDone, SegPageEntryIter< EntryT >::resize(), returnedRoot, rootOnly, SegPageEntryIter< EntryT >::setPrefetchSource(), and BTreeExecStream::treeDescriptor.

Retrieves the next pageId to be pre-fetched, also filling in context- specific information associated with the page.

Parameters:

Returns:

the prefetch pageId

Implements SegPageEntryIterSource< BTreePrefetchSearchKey >.

Definition at line 290 of file BTreePrefetchSearchExecStream.cpp.

References DUP_SEEK_BEGIN, DUP_SEEK_END, endOnNextKey, EXECBUF_EOS, getPrefetchSearchKey(), BTreeSearchExecStream::leastUpper, BTreeSearchExecStream::lowerBoundDirective, NULL_PAGE_ID, pfLowerBoundData, pfLowerBoundDirective, SingleInputExecStream::pInAccessor, pNonLeafReader, returnedRoot, rootOnly, SEARCH_CLOSED_LOWER, SEARCH_OPEN_LOWER, SEARCH_UNBOUNDED_LOWER, setSearchKeyData(), and testNonLeafInterval().

| void BTreePrefetchSearchExecStream::closeImpl | ( | | ) | [virtual] | | --------------------------------------------- | - | | - | ----------- |

Definition at line 446 of file BTreeSearchExecStream.cpp.

References EXECRC_BUF_OVERFLOW, EXECRC_QUANTUM_EXPIRED, EXECRC_YIELD, BTreeSearchExecStream::nJoinAttributes, ExecStreamQuantum::nTuplesMax, SingleOutputExecStream::pOutAccessor, BTreeReadExecStream::pReader, BTreeReadExecStream::projAccessor, BTreeSearchExecStream::reachedTupleLimit(), BTreeSearchExecStream::testInterval(), BTreeReadExecStream::tupleData, and TupleProjectionAccessor::unmarshal().

Referenced by BTreeSearchExecStream::execute(), and execute().

| void BTreeSearchExecStream::readDirectives | ( | | ) | [protected, inherited] | | ------------------------------------------ | - | | - | ------------------------ |

Definition at line 265 of file BTreeSearchExecStream.cpp.

References BTreeSearchExecStream::directiveAccessor, BTreeSearchExecStream::directiveData, BTreeSearchExecStream::LOWER_BOUND_DIRECTIVE, BTreeSearchExecStream::lowerBoundDirective, SEARCH_CLOSED_LOWER, SEARCH_CLOSED_UPPER, TupleProjectionAccessor::size(), TupleProjectionAccessor::unmarshal(), BTreeSearchExecStream::UPPER_BOUND_DIRECTIVE, and BTreeSearchExecStream::upperBoundDirective.

Referenced by getPrefetchSearchKey(), and BTreeSearchExecStream::innerSearchLoop().

| bool BTreeSearchExecStream::testInterval | ( | | ) | [protected, inherited] | | ---------------------------------------- | - | | - | ------------------------ |

Definition at line 390 of file BTreeSearchExecStream.cpp.

References BTreeSearchExecStream::checkNextKey(), TupleDescriptor::compareTuples(), TupleDescriptor::compareTuplesKey(), BTreeSearchExecStream::inputKeyDesc, BTreeSearchExecStream::leastUpper, BTreeSearchExecStream::lowerBoundDirective, BTreeSearchExecStream::pSearchKey, BTreeSearchExecStream::readerKeyAccessor, BTreeSearchExecStream::readerKeyData, SEARCH_CLOSED_LOWER, SEARCH_CLOSED_UPPER, SEARCH_UNBOUNDED_UPPER, TupleProjectionAccessor::unmarshal(), BTreeSearchExecStream::upperBoundData, and BTreeSearchExecStream::upperBoundDirective.

Referenced by BTreeSearchExecStream::innerFetchLoop(), innerSearchLoop(), and BTreeSearchExecStream::searchForKey().

| void BTreeSearchExecStream::readSearchKey | ( | | ) | [protected, inherited] | | ----------------------------------------- | - | | - | ------------------------ |

Reads the search key either from the input stream or dynamic parameters.

Definition at line 216 of file BTreeSearchExecStream.cpp.

References BTreeSearchExecStream::dynamicKeysRead, BTreeSearchExecStream::inputKeyAccessor, BTreeSearchExecStream::inputKeyData, ExecStream::pDynamicParamManager, SingleInputExecStream::pInAccessor, BTreeSearchExecStream::searchKeyParams, BTreeSearchExecStream::searchKeyProj, TupleProjectionAccessor::size(), TupleAccessor::unmarshal(), and TupleProjectionAccessor::unmarshal().

Referenced by getPrefetchSearchKey(), and BTreeSearchExecStream::innerSearchLoop().

| void BTreeSearchExecStream::readUpperBoundKey | ( | | ) | [protected, inherited] | | --------------------------------------------- | - | | - | ------------------------ |

| bool BTreeSearchExecStream::checkNextKey | ( | | ) | [protected, inherited] | | ---------------------------------------- | - | | - | ------------------------ |

| bool BTreeSearchExecStream::searchForKey | ( | | ) | [protected, inherited] | | ---------------------------------------- | - | | - | ------------------------ |

Searches the btree for a specific key.

Returns:

true if the search yielded matching keys

Definition at line 286 of file BTreeSearchExecStream.cpp.

References TupleData::containsNull(), DUP_SEEK_BEGIN, DUP_SEEK_END, BTreeSearchExecStream::inputJoinAccessor, BTreeSearchExecStream::leastUpper, BTreeSearchExecStream::lowerBoundDirective, BTreeSearchExecStream::nJoinAttributes, BTreeSearchExecStream::outerJoin, BTreeReadExecStream::pReader, BTreeSearchExecStream::preFilterNulls, BTreeReadExecStream::projAccessor, BTreeSearchExecStream::pSearchKey, SEARCH_CLOSED_LOWER, SEARCH_OPEN_LOWER, SEARCH_UNBOUNDED_LOWER, BTreeSearchExecStream::searchKeyProj, TupleProjectionAccessor::size(), BTreeSearchExecStream::testInterval(), BTreeReadExecStream::tupleData, TupleProjectionAccessor::unmarshal(), BTreeSearchExecStream::upperBoundData, and BTreeSearchExecStream::upperBoundKeyProj.

Referenced by BTreeSearchExecStream::innerSearchLoop(), and innerSearchLoop().

Reimplemented in BTreeSearchUniqueExecStream.

Definition at line 32 of file BTreeSearchExecStream.cpp.

References TupleProjectionAccessor::bind(), TupleData::compute(), TupleDescriptor::containsNullable(), BTreeSearchExecStream::directiveAccessor, BTreeSearchExecStream::directiveData, BTreeSearchExecStreamParams::inputDirectiveProj, BTreeSearchExecStream::inputJoinAccessor, BTreeSearchExecStreamParams::inputJoinProj, BTreeSearchExecStream::inputKeyAccessor, BTreeSearchExecStream::inputKeyData, BTreeSearchExecStream::inputKeyDesc, BTreeSearchExecStreamParams::inputKeyProj, BTreeDescriptor::keyProjection, BTreeSearchExecStream::leastUpper, BTreeSearchExecStream::LOWER_BOUND_DIRECTIVE, StandardTypeDescriptorFactory::newDataType(), BTreeSearchExecStream::nJoinAttributes, BTreeSearchExecStreamParams::outerJoin, BTreeSearchExecStream::outerJoin, BTreeReadExecStreamParams::outputProj, SingleOutputExecStreamParams::outputTupleDesc, SingleInputExecStream::pInAccessor, BTreeSearchExecStream::preFilterNulls, ConduitExecStream::prepare(), BTreeReadExecStream::prepare(), TupleDescriptor::projectFrom(), BTreeSearchExecStream::readerKeyData, BTreeSearchExecStreamParams::searchKeyParams, BTreeSearchExecStream::searchKeyParams, BTreeSearchExecStream::searchKeyProj, STANDARD_TYPE_CHAR, BTreeExecStream::treeDescriptor, BTreeSearchExecStream::UPPER_BOUND_DIRECTIVE, BTreeSearchExecStream::upperBoundAccessor, BTreeSearchExecStream::upperBoundData, BTreeSearchExecStream::upperBoundDesc, and BTreeSearchExecStream::upperBoundKeyProj.

Referenced by BTreeSearchUniqueExecStream::prepare(), and prepare().

00033 { 00034 BTreeReadExecStream::prepare(params); 00035 ConduitExecStream::prepare(params); 00036 00037 leastUpper = true; 00038 outerJoin = params.outerJoin; 00039 searchKeyParams = params.searchKeyParams; 00040 00041
00042 00043 TupleDescriptor const &inputDesc = pInAccessor->getTupleDesc(); 00044 00045 TupleAccessor &inputAccessor = pInAccessor->getConsumptionTupleAccessor(); 00046 00047 if (params.inputDirectiveProj.size()) { 00048 assert(params.inputDirectiveProj.size() == 2); 00049
00050
00051
00052
00053 assert(params.inputKeyProj.size() > 0); 00054 assert((params.inputKeyProj.size() % 2) == 0); 00055 directiveAccessor.bind(inputAccessor, params.inputDirectiveProj); 00056 TupleDescriptor inputDirectiveDesc; 00057 inputDirectiveDesc.projectFrom(inputDesc, params.inputDirectiveProj); 00058 00059
00060 StandardTypeDescriptorFactory stdTypeFactory; 00061 TupleAttributeDescriptor expectedDirectiveDesc( 00062 stdTypeFactory.newDataType(STANDARD_TYPE_CHAR)); 00063 expectedDirectiveDesc.cbStorage = 1; 00064 assert( 00065 inputDirectiveDesc[LOWER_BOUND_DIRECTIVE] == expectedDirectiveDesc); 00066 assert( 00067 inputDirectiveDesc[UPPER_BOUND_DIRECTIVE] == expectedDirectiveDesc); 00068 00069 directiveData.compute(inputDirectiveDesc); 00070 } 00071 00072 if (params.inputKeyProj.size()) { 00073 TupleProjection inputKeyProj = params.inputKeyProj; 00074 if (params.inputDirectiveProj.size()) { 00075
00076
00077 TupleProjection upperBoundProj; 00078 int n = inputKeyProj.size() / 2; 00079
00080 upperBoundProj.resize(n); 00081
00082 std::copy( 00083 inputKeyProj.begin() + n, 00084 inputKeyProj.end(), 00085 upperBoundProj.begin()); 00086
00087 inputKeyProj.resize(n); 00088 00089 upperBoundAccessor.bind(inputAccessor, upperBoundProj); 00090 upperBoundDesc.projectFrom(inputDesc, upperBoundProj); 00091 upperBoundData.compute(upperBoundDesc); 00092 00093 assert( 00094 searchKeyParams.size() == 0 || 00095 (searchKeyParams.size() >= (n-1)*2+1 && 00096 searchKeyParams.size() <= n*2)); 00097 } else { 00098 assert(searchKeyParams.size() == 0); 00099 } 00100 inputKeyAccessor.bind(inputAccessor,inputKeyProj); 00101 inputKeyDesc.projectFrom(inputDesc,inputKeyProj); 00102 } else { 00103 inputKeyDesc = inputDesc; 00104 assert(searchKeyParams.size() == 0); 00105 } 00106 inputKeyData.compute(inputKeyDesc); 00107 00108 if (upperBoundDesc.size()) { 00109
00110
00111 assert(upperBoundDesc == inputKeyDesc); 00112 } 00113 00114 preFilterNulls = false; 00115 if ((outerJoin && inputKeyDesc.containsNullable()) || 00116 searchKeyParams.size() > 0) 00117 { 00118
00119
00120
00121 preFilterNulls = true; 00122 00123
00124
00125
00126 if (searchKeyParams.size() == 0) { 00127 for (uint i = 0; i < inputKeyData.size(); i++) { 00128 searchKeyProj.push_back(i); 00129 upperBoundKeyProj.push_back(i); 00130 } 00131 } 00132 } 00133 00134 inputJoinAccessor.bind(inputAccessor,params.inputJoinProj); 00135 00136 TupleDescriptor joinDescriptor; 00137 joinDescriptor.projectFrom(inputDesc,params.inputJoinProj); 00138 00139 TupleProjection readerKeyProj = treeDescriptor.keyProjection; 00140 readerKeyProj.resize(inputKeyDesc.size()); 00141 readerKeyData.compute(inputKeyDesc); 00142 00143 nJoinAttributes = params.outputTupleDesc.size() - params.outputProj.size(); 00144 }

Definition at line 30 of file BTreeExecStream.cpp.

References BTreeExecStream::copyParamsToDescriptor(), ExecStreamParams::pCacheAccessor, SingleOutputExecStream::prepare(), BTreeParams::pRootMap, BTreeExecStream::pRootMap, BTreeParams::rootPageIdParamId, BTreeExecStream::rootPageIdParamId, ExecStreamParams::scratchAccessor, BTreeExecStream::scratchAccessor, and BTreeExecStream::treeDescriptor.

Referenced by LcsClusterAppendExecStream::prepare(), LbmGeneratorExecStream::prepare(), BTreeReadExecStream::prepare(), and BTreeInsertExecStream::prepare().

Definition at line 48 of file SingleOutputExecStream.cpp.

References SingleOutputExecStream::getOutputBufProvision(), SingleOutputExecStreamParams::outputTupleDesc, SingleOutputExecStreamParams::outputTupleFormat, SingleOutputExecStream::pOutAccessor, and ExecStream::prepare().

Referenced by BTreeExecStream::prepare(), FlatFileExecStreamImpl::prepare(), ValuesExecStream::prepare(), MockResourceExecStream::prepare(), MockProducerExecStream::prepare(), ConfluenceExecStream::prepare(), and ConduitExecStream::prepare().

Prepares this stream for execution.

A precondition is that input streams must already be defined and prepared. As an effect of this call, the tuple shape should be defined for all output buffers and remain unchanged for the lifetime of the stream. This method is only ever called once, before the first open. Although this method is virtual, derived classes may choose to define an overloaded version instead with a specialized covariant parameter class.

Parameters:

Definition at line 84 of file ExecStream.cpp.

References ExecStreamGraph::getDynamicParamManager(), SegmentAccessor::pCacheAccessor, ExecStreamParams::pCacheAccessor, ExecStream::pDynamicParamManager, ExecStream::pGraph, ExecStream::pQuotaAccessor, ExecStream::pScratchQuotaAccessor, and ExecStreamParams::scratchAccessor.

Referenced by JavaTransformExecStream::prepare(), SingleOutputExecStream::prepare(), and SingleInputExecStream::prepare().

Definition at line 42 of file ConduitExecStream.cpp.

References SingleInputExecStream::pInAccessor, SingleOutputExecStream::pOutAccessor, SingleOutputExecStream::prepare(), and SingleInputExecStream::prepare().

Referenced by ExternalSortExecStreamImpl::prepare(), LcsClusterAppendExecStream::prepare(), LbmNormalizerExecStream::prepare(), LhxAggExecStream::prepare(), FtrsTableWriterExecStream::prepare(), BTreeSearchExecStream::prepare(), BTreeInsertExecStream::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SegBufferReaderExecStream::prepare(), SegBufferExecStream::prepare(), ScratchBufferExecStream::prepare(), ReshapeExecStream::prepare(), DoubleBufferExecStream::prepare(), CopyExecStream::prepare(), CollectExecStream::prepare(), BernoulliSamplingExecStream::prepare(), and CalcExecStream::prepare().

| void BTreeExecStream::endSearch | ( | | ) | [protected, virtual, inherited] | | ------------------------------- | - | | - | --------------------------------- |

Definition at line 93 of file BTreeExecStream.cpp.

References BTreeParams::keyProj, BTreeDescriptor::keyProjection, BTreeParams::pageOwnerId, BTreeDescriptor::pageOwnerId, SegmentAccessor::pCacheAccessor, BTreeParams::pSegment, SegmentAccessor::pSegment, BTreeParams::rootPageId, BTreeDescriptor::rootPageId, BTreeDescriptor::segmentAccessor, BTreeParams::segmentId, BTreeDescriptor::segmentId, BTreeExecStream::treeDescriptor, BTreeParams::tupleDesc, and BTreeDescriptor::tupleDescriptor.

Referenced by BTreeExecStream::newWriter(), LbmSplicerExecStream::prepare(), and BTreeExecStream::prepare().

Initializes the buffer accessors for inputs to this stream.

This method is only ever called once, before prepare.

Parameters:

Implements ExecStream.

Reimplemented in ConduitExecStream, and ConfluenceExecStream.

Definition at line 35 of file SingleOutputExecStream.cpp.

00037 { 00038 assert(inAccessors.size() == 0); 00039 }

| bool ExecStream::canEarlyClose | ( | | ) | [virtual, inherited] | | ------------------------------ | - | | - | ---------------------- |

| ExecStreamId ExecStream::getStreamId | ( | | ) | const [inline, inherited] | | -------------------------------------------------------------------------------------------------- | - | | - | --------------------------- |

Returns:

the identifier for this stream within containing graph

Definition at line 288 of file ExecStream.h.

References ExecStream::id.

Referenced by ExternalSortExecStreamImpl::execute(), SegBufferWriterExecStream::execute(), SegBufferExecStream::execute(), CorrelationJoinExecStream::execute(), BarrierExecStream::execute(), Java_net_sf_farrago_fennel_FennelStorage_tupleStreamTransformFetch(), JavaTransformExecStream::open(), SingleInputExecStream::open(), ConfluenceExecStream::open(), CartesianJoinExecStream::prepare(), ParallelExecStreamScheduler::readStream(), DfsTreeExecStreamScheduler::readStream(), LbmMinusExecStream::restartSubtrahends(), ExecStreamScheduler::tracePostExecution(), ExecStreamScheduler::tracePreExecution(), ExecStreamScheduler::traceStreamBuffers(), and ParallelExecStreamScheduler::tryExecuteTask().

00289 { 00290 return id; 00291 }

| void ExecStream::setName | ( | std::string const & | | ) | [virtual, inherited] | | ------------------------ | - | ------------------- | | - | ---------------------- |

| std::string const & ExecStream::getName | ( | | ) | const [virtual, inherited] | | --------------------------------------- | - | | - | ---------------------------- |

| bool ExecStream::mayBlock | ( | | ) | const [virtual, inherited] | | ------------------------- | - | | - | ---------------------------- |

Queries whether this stream's implementation may block when execute() is called.

For accurate scheduling, non-blocking implementations are preferred; the scheduler must be aware of the potential for blocking so that it can allocate extra threads accordingly.

Returns:

whether stream may block; default is false

Definition at line 167 of file ExecStream.cpp.

00168 { 00169 return false; 00170 }

| void ExecStream::checkAbort | ( | | ) | const [virtual, inherited] | | --------------------------- | - | | - | ---------------------------- |

| bool ClosableObject::isClosed | ( | | ) | const [inline, inherited] | | ----------------------------- | - | | - | --------------------------- |

Returns:

whether the object has been closed

Definition at line 58 of file ClosableObject.h.

| void ClosableObject::close | ( | | ) | [inherited] | | -------------------------- | - | | - | ------------- |

Closes this object, releasing any unallocated resources.

Reimplemented in CollectExecStream, CorrelationJoinExecStream, LcsClusterAppendExecStream, and LcsClusterReplaceExecStream.

Definition at line 39 of file ClosableObject.cpp.

References ClosableObject::closeImpl(), and ClosableObject::needsClose.

Referenced by CacheImpl< PageT, VictimPolicyT >::allocatePages(), LcsRowScanBaseExecStream::closeImpl(), ExecStreamGraphImpl::closeImpl(), FlatFileBuffer::open(), ClosableObjectDestructor::operator()(), and Segment::~Segment().

| bool TraceSource::isTracing | ( | | ) | const [inline, inherited] | | --------------------------- | - | | - | --------------------------- |

| TraceTarget& TraceSource::getTraceTarget | ( | | ) | const [inline, inherited] | | ----------------------------------------------------------------- | - | | - | --------------------------- |

| std::string TraceSource::getTraceSourceName | ( | | ) | const [inline, inherited] | | ------------------------------------------- | - | | - | --------------------------- |

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 136 of file TraceSource.h.

00137 { 00138 name = n; 00139 }

| TraceLevel TraceSource::getMinimumTraceLevel | ( | | ) | const [inline, inherited] | | ------------------------------------------------------------------------------------------------------ | - | | - | --------------------------- |

| void TraceSource::disableTracing | ( | | ) | [inherited] | | -------------------------------- | - | | - | ------------- |

| bool ErrorSource::hasTarget | ( | | ) | const [inline, inherited] | | --------------------------- | - | | - | --------------------------- |

| ErrorTarget& ErrorSource::getErrorTarget | ( | | ) | const [inline, inherited] | | ----------------------------------------------------------------- | - | | - | --------------------------- |

Returns:

the SharedErrorTarget for this source

Definition at line 129 of file ErrorSource.h.

| std::string ErrorSource::getErrorSourceName | ( | | ) | const [inline, inherited] | | ------------------------------------------- | - | | - | --------------------------- |

Gets the name of this source.

Useful to construct nested names for subcomponents that are also ErrorSources.

Returns:

the name

Definition at line 139 of file ErrorSource.h.

00140 { 00141 return name; 00142 }

Sets the name of this source.

Useful to construct dynamic names for fine-grained filtering.

Definition at line 148 of file ErrorSource.h.

00149 { 00150 name = n; 00151 }

| void ErrorSource::disableTarget | ( | | ) | [inherited] | | ------------------------------- | - | | - | ------------- |

| ExecStreamResult ConduitExecStream::precheckConduitBuffers | ( | | ) | [protected, inherited] | | ----------------------------------------------------------------------------------------------------------------------- | - | | - | ------------------------ |

Checks the state of the input and output buffers.

If input empty, requests production. If input EOS, propagates that to output buffer. If output full, returns EXECRC_OVERFLOW.

Returns:

result of precheck; anything but EXECRC_YIELD indicates that execution should terminate immediately with returned code

Definition at line 61 of file ConduitExecStream.cpp.

References EXECBUF_EMPTY, EXECBUF_EOS, EXECBUF_NONEMPTY, EXECBUF_OVERFLOW, EXECBUF_UNDERFLOW, EXECRC_BUF_OVERFLOW, EXECRC_BUF_UNDERFLOW, EXECRC_EOS, EXECRC_YIELD, SingleInputExecStream::pInAccessor, and SingleOutputExecStream::pOutAccessor.

Referenced by ExternalSortExecStreamImpl::execute(), FtrsTableWriterExecStream::execute(), BTreeSearchUniqueExecStream::execute(), BTreeSearchExecStream::execute(), BTreeInsertExecStream::execute(), UncollectExecStream::execute(), SortedAggExecStream::execute(), ReshapeExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), BernoulliSamplingExecStream::execute(), and CalcExecStream::execute().

Member Data Documentation

Definition at line 113 of file BTreeExecStream.h.

Referenced by BTreeInsertExecStream::buildTree(), BTreeExecStream::closeImpl(), BTreeExecStream::copyParamsToDescriptor(), LcsClusterReplaceExecStream::getTupleForLoad(), LcsClusterAppendExecStream::initLoad(), LcsClusterReplaceExecStream::initTupleLoadParams(), innerSearchLoop(), newReader(), BTreeExecStream::newReader(), BTreeExecStream::newWriter(), LcsClusterReplaceExecStream::open(), BTreeSearchExecStream::open(), open(), BTreeInsertExecStream::open(), BTreeExecStream::open(), LcsClusterReplaceExecStream::prepare(), LcsClusterAppendExecStream::prepare(), LbmSearchExecStream::prepare(), LbmGeneratorExecStream::prepare(), BTreeSearchExecStream::prepare(), BTreeInsertExecStream::prepare(), BTreeExecStream::prepare(), and BTreeInsertExecStream::truncateTree().

Definition at line 56 of file SingleOutputExecStream.h.

Referenced by LcsClusterAppendExecStream::compress(), ExternalSortExecStreamImpl::execute(), LcsRowScanExecStream::execute(), LbmUnionExecStream::execute(), LbmNormalizerExecStream::execute(), LbmGeneratorExecStream::execute(), LbmChopperExecStream::execute(), LhxJoinExecStream::execute(), LhxAggExecStream::execute(), FtrsTableWriterExecStream::execute(), BTreeSortExecStream::execute(), BTreeSearchUniqueExecStream::execute(), BTreeScanExecStream::execute(), execute(), BTreeInsertExecStream::execute(), FlatFileExecStreamImpl::execute(), ValuesExecStream::execute(), UncollectExecStream::execute(), SortedAggExecStream::execute(), SegBufferReaderExecStream::execute(), ScratchBufferExecStream::execute(), ReshapeExecStream::execute(), MockResourceExecStream::execute(), MockProducerExecStream::execute(), MergeExecStream::execute(), DoubleBufferExecStream::execute(), CorrelationJoinExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), CartesianJoinExecStream::execute(), BernoulliSamplingExecStream::execute(), BarrierExecStream::execute(), CalcExecStream::execute(), LbmGeneratorExecStream::flushEntry(), MockProducerExecStream::getProducedRowCount(), ExternalSortExecStreamImpl::getResourceRequirements(), BTreeSearchExecStream::innerFetchLoop(), LbmUnionExecStream::open(), LbmChopperExecStream::open(), LbmBitOpExecStream::open(), SingleOutputExecStream::open(), SegBufferReaderExecStream::open(), SegBufferExecStream::open(), ScratchBufferExecStream::open(), DoubleBufferExecStream::open(), CollectExecStream::open(), SegBufferExecStream::openBufferForRead(), ConduitExecStream::precheckConduitBuffers(), LcsRowScanExecStream::prepare(), LcsRowScanBaseExecStream::prepare(), LcsClusterAppendExecStream::prepare(), LbmUnionExecStream::prepare(), LbmGeneratorExecStream::prepare(), LhxJoinExecStream::prepare(), LhxAggExecStream::prepare(), FtrsTableWriterExecStream::prepare(), FlatFileExecStreamImpl::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SingleOutputExecStream::prepare(), ReshapeExecStream::prepare(), MockResourceExecStream::prepare(), MockProducerExecStream::prepare(), MergeExecStream::prepare(), CorrelationJoinExecStream::prepare(), ConduitExecStream::prepare(), CollectExecStream::prepare(), CartesianJoinExecStream::prepare(), BernoulliSamplingExecStream::prepare(), BarrierExecStream::prepare(), CalcExecStream::prepare(), SortedAggExecStream::produce(), LbmBitOpExecStream::producePendingOutput(), LbmUnionExecStream::produceTuple(), LbmNormalizerExecStream::produceTuple(), LbmMinusExecStream::produceTuple(), LbmChopperExecStream::produceTuple(), LbmBitOpExecStream::produceTuple(), LbmBitOpExecStream::readInput(), LbmMinusExecStream::readMinuendInput(), and SingleOutputExecStream::setOutputBufAccessors().

Dataflow graph containing this stream.

Note that we don't use a weak_ptr for this because it needs to be accessed frequently during execution, and the extra locking overhead would be frivolous.

Definition at line 68 of file ExecStream.h.

Referenced by ExecStream::checkAbort(), ExecStream::ExecStream(), CorrelationJoinExecStream::execute(), ExecStream::getGraph(), JavaTransformExecStream::open(), SingleInputExecStream::open(), MergeExecStream::open(), ExecStream::open(), CorrelationJoinExecStream::open(), ConfluenceExecStream::open(), ExecStream::prepare(), CartesianJoinExecStream::prepare(), and LbmMinusExecStream::restartSubtrahends().

The dynamic parameter manager available to this stream.

(Obtained at prepare() time. Keep a shared pointer in case the stream is reassigned to another graph for execution; cf ExecStreamGraph::mergeFrom())

Definition at line 85 of file ExecStream.h.

Referenced by CorrelationJoinExecStream::close(), SegBufferReaderExecStream::closeImpl(), LbmUnionExecStream::execute(), LbmSplicerExecStream::execute(), LbmGeneratorExecStream::execute(), LbmChopperExecStream::execute(), CorrelationJoinExecStream::execute(), BarrierExecStream::execute(), LcsClusterReplaceExecStream::open(), LbmUnionExecStream::open(), LbmSplicerExecStream::open(), LbmGeneratorExecStream::open(), LbmBitOpExecStream::open(), BTreeSearchExecStream::open(), BTreeInsertExecStream::open(), SegBufferWriterExecStream::open(), SegBufferReaderExecStream::open(), NestedLoopJoinExecStream::open(), CorrelationJoinExecStream::open(), ExecStream::prepare(), CalcExecStream::prepare(), NestedLoopJoinExecStream::processLeftInput(), LbmSearchExecStream::reachedTupleLimit(), ReshapeExecStream::readDynamicParams(), SegBufferWriterExecStream::readReaderRefCount(), BTreeSearchExecStream::readSearchKey(), BTreeSearchExecStream::readUpperBoundKey(), LbmSearchExecStream::setAdditionalKeys(), and LbmBitOpExecStream::writeStartRidParamValue().

Definition at line 51 of file SingleInputExecStream.h.

Referenced by SortedAggExecStream::compareGroupByKeys(), ExternalSortExecStreamImpl::computeFirstResult(), ExternalSortExecStreamImpl::execute(), LbmSplicerExecStream::execute(), FtrsTableWriterExecStream::execute(), BTreeSortExecStream::execute(), BTreeSearchUniqueExecStream::execute(), BTreeSearchExecStream::execute(), execute(), BTreeInsertExecStream::execute(), JavaSinkExecStream::execute(), UncollectExecStream::execute(), SplitterExecStream::execute(), SortedAggExecStream::execute(), SegBufferWriterExecStream::execute(), SegBufferReaderExecStream::execute(), SegBufferExecStream::execute(), ScratchBufferExecStream::execute(), ReshapeExecStream::execute(), MockConsumerExecStream::execute(), DoubleBufferExecStream::execute(), CopyExecStream::execute(), CollectExecStream::execute(), BernoulliSamplingExecStream::execute(), CalcExecStream::execute(), getNextPageForPrefetch(), LcsClusterReplaceExecStream::getTupleForLoad(), LcsClusterAppendExecStream::getTupleForLoad(), LbmSplicerExecStream::getValidatedTuple(), LcsClusterReplaceExecStream::initTupleLoadParams(), BTreeSearchExecStream::innerSearchLoop(), innerSearchLoop(), LcsClusterReplaceExecStream::open(), LbmNormalizerExecStream::open(), SingleInputExecStream::open(), SegBufferWriterExecStream::open(), SegBufferExecStream::open(), ScratchBufferExecStream::open(), MockConsumerExecStream::open(), DoubleBufferExecStream::open(), CollectExecStream::open(), LcsClusterAppendExecStream::postProcessTuple(), ConduitExecStream::precheckConduitBuffers(), ExternalSortExecStreamImpl::prepare(), LcsClusterAppendExecStream::prepare(), LbmSplicerExecStream::prepare(), LbmNormalizerExecStream::prepare(), BTreeSearchExecStream::prepare(), BTreeInsertExecStream::prepare(), UncollectExecStream::prepare(), SortedAggExecStream::prepare(), SingleInputExecStream::prepare(), SegBufferReaderExecStream::prepare(), ReshapeExecStream::prepare(), DiffluenceExecStream::prepare(), ConduitExecStream::prepare(), CollectExecStream::prepare(), BernoulliSamplingExecStream::prepare(), CalcExecStream::prepare(), SortedAggExecStream::produce(), BTreeSearchExecStream::readSearchKey(), LhxAggExecStream::setAggComputers(), LhxAggExecStream::setHashInfo(), SingleInputExecStream::setInputBufAccessors(), and JavaSinkExecStream::stuffByteBuffer().

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

• /home/pub/open/dev/fennel/ftrs/BTreePrefetchSearchExecStream.h
• /home/pub/open/dev/fennel/ftrs/BTreePrefetchSearchExecStream.cpp

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