DfsTreeExecStreamScheduler Class Reference

DfsTreeExecStreamScheduler is a reference implementation of the ExecStreamScheduler interface. More...

#include <DfsTreeExecStreamScheduler.h>

Inheritance diagram for DfsTreeExecStreamScheduler:

List of all members.

Public Member Functions
	DfsTreeExecStreamScheduler (SharedTraceTarget pTraceTarget, std::string name)
	Constructs a new scheduler.
virtual	~DfsTreeExecStreamScheduler ()
virtual void	addGraph (SharedExecStreamGraph pGraph)
	Adds a graph to be scheduled.
virtual void	removeGraph (SharedExecStreamGraph pGraph)
	Removes a graph currently being scheduled.
virtual void	start ()
	Starts this scheduler, preparing it to execute streams.
virtual void	setRunnable (ExecStream &stream, bool)
	Sets whether that a specific stream should be considered for execution.
virtual void	abort (ExecStreamGraph &graph)
	Asynchronously aborts execution of any scheduled streams contained by a particular graph and prevents further scheduling.
virtual void	checkAbort () const
	Checks whether there is an abort request for this scheduler, and if so, throws an AbortExcn.
virtual void	stop ()
	Shuts down this scheduler, preventing any further streams from being scheduled.
virtual ExecStreamBufAccessor &	readStream (ExecStream &stream)
	Reads data from a stream, first performing any scheduling necessary to make output available.
virtual void	traceStreamBufferContents (ExecStream &stream, ExecStreamBufAccessor &bufAccessor, TraceLevel traceLevel)
	Traces the contents of a stream buffer.
void	makeRunnable (ExecStream &stream)
	Requests that a specific stream be considered for execution.
virtual SharedExecStreamBufAccessor	newBufAccessor ()
	Creates a new ExecStreamBufAccessor suitable for use with this scheduler.
virtual void	createBufferProvisionAdapter (ExecStreamEmbryo &embryo)
	Creates a new adapter stream capable of buffering the output of a stream with BUFPROV_CONSUMER for use as input to a stream with BUFPROV_PRODUCER.
virtual void	createCopyProvisionAdapter (ExecStreamEmbryo &embryo)
	Creates a new adapter stream capable of copying the output of a stream with BUFPROV_PRODUCER into the input of a stream with BUFPROV_CONSUMER.
virtual uint	getDegreeOfParallelism ()
	Returns: the degree of parallelism implemented by this scheduler, or 1 for a non-parallel scheduler
virtual void	initTraceSource (SharedTraceTarget pTraceTarget, std::string name)
	For use when initialization has to be deferred until after construction.
void	trace (TraceLevel level, std::string message) const
	Records a trace message.
bool	isTracing () const
	Returns: true iff tracing is enabled for this source
bool	isTracingLevel (TraceLevel level) const
	Determines whether a particular level is being traced.
TraceTarget &	getTraceTarget () const
	Returns: the TraceTarget for this source
SharedTraceTarget	getSharedTraceTarget () const
	Returns: the SharedTraceTarget for this source
std::string	getTraceSourceName () const
	Gets the name of this source.
void	setTraceSourceName (std::string const &n)
	Sets the name of this source.
TraceLevel	getMinimumTraceLevel () const
void	disableTracing ()
Protected Member Functions
ExecStreamResult	executeStream (ExecStream &stream, ExecStreamQuantum const &quantum)
	Executes one stream, performing tracing if enabled.
virtual void	tracePreExecution (ExecStream &stream, ExecStreamQuantum const &quantum)
	Traces before execution of a stream.
virtual void	tracePostExecution (ExecStream &stream, ExecStreamResult rc)
	Traces after execution of a stream.
virtual void	traceStreamBuffers (ExecStream &stream, TraceLevel inputTupleTraceLevel, TraceLevel outputTupleTraceLevel)
	Traces the states of the input and output buffers adjacent to a stream.
Protected Attributes
bool	tracingFine
Private Member Functions
bool	findNextConsumer (ExecStreamGraphImpl &graphImpl, const ExecStreamGraphImpl::GraphRep &graphRep, const ExecStream &stream, ExecStreamGraphImpl::Edge &edge, ExecStreamId &current, ExecStreamBufState skipState)
	Finds the next consumer to execute for a given producer.
Private Attributes
volatile bool	aborted
SharedExecStreamGraph	pGraph

---

Detailed Description

DfsTreeExecStreamScheduler is a reference implementation of the ExecStreamScheduler interface.

See SchedulerDesign for more details.

Author:

John V. Sichi

Version:

Id

//open/dev/fennel/exec/DfsTreeExecStreamScheduler.h#16

Definition at line 42 of file DfsTreeExecStreamScheduler.h.

---

Constructor & Destructor Documentation

DfsTreeExecStreamScheduler::DfsTreeExecStreamScheduler	(	SharedTraceTarget	pTraceTarget,
		std::string	name
	)			[explicit]

Constructs a new scheduler.

Parameters:

	pTraceTarget	the TraceTarget to which messages will be sent, or NULL to disable tracing entirely
	name	the name to use for tracing this scheduler

Definition at line 33 of file DfsTreeExecStreamScheduler.cpp.

    : TraceSource(pTraceTargetInit, nameInit),
      ExecStreamScheduler(pTraceTargetInit, nameInit)
{
}

DfsTreeExecStreamScheduler::~DfsTreeExecStreamScheduler

(

)

[virtual]

Definition at line 41 of file DfsTreeExecStreamScheduler.cpp.

{
}

---

Member Function Documentation

bool DfsTreeExecStreamScheduler::findNextConsumer	(	ExecStreamGraphImpl &	graphImpl,
		const ExecStreamGraphImpl::GraphRep &	graphRep,
		const ExecStream &	stream,
		ExecStreamGraphImpl::Edge &	edge,
		ExecStreamId &	current,
		ExecStreamBufState	skipState
	)			[private]

Finds the next consumer to execute for a given producer.

Parameters:

	graphImpl	current stream graph
	graphRep	graph representation of current stream graph
	stream	currrent execution stream
	edge	returns edge to consumer to execute next
	current	returns id of consumer to execute next
	skipState	state to skip when looking for next consumer

Returns:

false if reached sink vertex, else true

Definition at line 183 of file DfsTreeExecStreamScheduler.cpp.

References EXECBUF_EMPTY, EXECBUF_EOS, EXECBUF_UNDERFLOW, ExecStreamId, ExecStreamGraphImpl::getBufAccessorFromEdge(), ExecStream::getName(), ExecStreamBufAccessor::getState(), ExecStreamGraphImpl::getStreamFromVertex(), and TRACE_FINE.

Referenced by readStream().

{
    ExecStreamGraphImpl::OutEdgeIterPair outEdges =
        boost::out_edges(current,graphRep);

    bool emptyFound = false;
    // dummy initializations to avoid compiler error
    ExecStreamGraphImpl::Edge emptyEdge = edge;
    ExecStreamId emptyStreamId = current;

    for (; outEdges.first != outEdges.second; ++(outEdges.first)) {
        edge = *(outEdges.first);
        current = boost::target(edge,graphRep);
        if (boost::out_degree(current,graphRep) == 0) {
            // we've hit the output sentinel
            assert(!graphImpl.getStreamFromVertex(current));
            FENNEL_TRACE(
                TRACE_FINE,
                "leaving readStream " << stream.getName());
            return false;
        }

        ExecStreamBufAccessor &bufAccessor =
            graphImpl.getBufAccessorFromEdge(edge);

        // Save the first edge with an empty state that we find, but don't
        // return that as the next consumer.  We want to give priority to
        // streams that have explicity requested data.  So, only return the
        // empty edge consumer if there are no consumers that have explicitly
        // requested data.
        if (bufAccessor.getState() == EXECBUF_EMPTY) {
            if (!emptyFound) {
                emptyFound = true;
                emptyEdge = edge;
                emptyStreamId = current;
            }
            continue;
        }

        if (bufAccessor.getState() != skipState) {
            break;
        }
        assert(!(skipState == EXECBUF_UNDERFLOW &&
                    bufAccessor.getState() == EXECBUF_EOS));
    }

    if (outEdges.first == outEdges.second && emptyFound) {
        edge = emptyEdge;
        current = emptyStreamId;
    } else {
        assert(!(skipState == EXECBUF_UNDERFLOW &&
                    outEdges.first == outEdges.second));
    }

    return true;
}

void DfsTreeExecStreamScheduler::addGraph

(

SharedExecStreamGraph

pGraph

)

[virtual]

Adds a graph to be scheduled.

Some implementations may require all graphs to be added before scheduler is started; others may allow graphs to be added at any time.

Parameters:

pGraph

the graph to be scheduled

Reimplemented from ExecStreamScheduler.

Definition at line 45 of file DfsTreeExecStreamScheduler.cpp.

References ExecStreamScheduler::addGraph(), and pGraph.

{
    assert(!pGraph);

    ExecStreamScheduler::addGraph(pGraphInit);
    pGraph = pGraphInit;
}

void DfsTreeExecStreamScheduler::removeGraph

(

SharedExecStreamGraph

pGraph

)

[virtual]

Removes a graph currently being scheduled.

Some implementations may disallow graph removal except when scheduler is stopped; others may disallow graph removal altogether.

Parameters:

pGraph

the graph currently being scheduled

Reimplemented from ExecStreamScheduler.

Definition at line 53 of file DfsTreeExecStreamScheduler.cpp.

References pGraph, and ExecStreamScheduler::removeGraph().

{
    assert(pGraph == pGraphInit);

    pGraph.reset();
    ExecStreamScheduler::removeGraph(pGraphInit);
}

void DfsTreeExecStreamScheduler::start

(

)

[virtual]

Starts this scheduler, preparing it to execute streams.

Implements ExecStreamScheduler.

Definition at line 61 of file DfsTreeExecStreamScheduler.cpp.

References aborted, pGraph, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE,"start");

    // TODO jvs 2-Jan-2006:  rename this class now that it's no longer
    // restricted to trees; come up with something more generic in case
    // DFS becomes irrelevant also.

    // note: we no longer check that graph is a tree (or forest of trees)
    // since it is now possible to have multiple consumers from a single
    // producer
    assert(pGraph->isAcyclic());
    aborted = false;
}

void DfsTreeExecStreamScheduler::setRunnable	(	ExecStream &	stream,
		bool
	)			[virtual]

Sets whether that a specific stream should be considered for execution.

Parameters:

stream

the stream to make runnable

Implements ExecStreamScheduler.

Definition at line 76 of file DfsTreeExecStreamScheduler.cpp.

{
    permAssert(false);
}

void DfsTreeExecStreamScheduler::abort

(

ExecStreamGraph &

graph

)

[virtual]

Asynchronously aborts execution of any scheduled streams contained by a particular graph and prevents further scheduling.

Returns immediately, not waiting for abort request to be fully processed.

Parameters:

graph

graph to abort; must be one of the graphs associated with this scheduler

Implements ExecStreamScheduler.

Definition at line 81 of file DfsTreeExecStreamScheduler.cpp.

References aborted, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE,"abort requested");

    aborted = true;
}

void DfsTreeExecStreamScheduler::checkAbort

(

)

const [virtual]

Checks whether there is an abort request for this scheduler, and if so, throws an AbortExcn.

Reimplemented from ExecStreamScheduler.

Definition at line 88 of file DfsTreeExecStreamScheduler.cpp.

References aborted, and TRACE_FINE.

Referenced by readStream().

{
    if (aborted) {
        FENNEL_TRACE(TRACE_FINE,"abort detected");
        throw AbortExcn();
    }
}

void DfsTreeExecStreamScheduler::stop

(

)

[virtual]

Shuts down this scheduler, preventing any further streams from being scheduled.

Implements ExecStreamScheduler.

Definition at line 96 of file DfsTreeExecStreamScheduler.cpp.

References aborted, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE,"stop");

    // nothing to do
    aborted = false;
}

ExecStreamBufAccessor & DfsTreeExecStreamScheduler::readStream

(

ExecStream &

stream

)

[virtual]

Reads data from a stream, first performing any scheduling necessary to make output available.

Parameters:

stream

the stream from which to read

Returns:

accessor for output data buffer

Implements ExecStreamScheduler.

Definition at line 104 of file DfsTreeExecStreamScheduler.cpp.

References checkAbort(), EXECBUF_EOS, EXECBUF_UNDERFLOW, EXECRC_BUF_OVERFLOW, EXECRC_BUF_UNDERFLOW, EXECRC_EOS, EXECRC_QUANTUM_EXPIRED, ExecStreamId, ExecStreamScheduler::executeStream(), findNextConsumer(), ExecStreamGraphImpl::getBufAccessorFromEdge(), ExecStreamGraphImpl::getGraphRep(), ExecStream::getName(), ExecStreamGraphImpl::getStreamFromVertex(), ExecStream::getStreamId(), and TRACE_FINE.

{
    FENNEL_TRACE(
        TRACE_FINE,
        "entering readStream " << stream.getName());

    ExecStreamId current = stream.getStreamId();
    ExecStreamQuantum quantum;

    ExecStreamGraphImpl &graphImpl =
        dynamic_cast<ExecStreamGraphImpl&>(*pGraph);
    ExecStreamGraphImpl::GraphRep const &graphRep = graphImpl.getGraphRep();

    // assert that we're reading from a designated output stream
    assert(boost::out_degree(current,graphRep) == 1);
    assert(!graphImpl.getStreamFromVertex(
               boost::target(
                   *(boost::out_edges(current,graphRep).first),
                   graphRep)));

    // TODO:  assertions about accessor state/provision

    for (;;) {
        ExecStreamGraphImpl::InEdgeIterPair inEdges =
            boost::in_edges(current,graphRep);
        for (; inEdges.first != inEdges.second; ++(inEdges.first)) {
            ExecStreamGraphImpl::Edge edge = *(inEdges.first);
            ExecStreamBufAccessor &bufAccessor =
                graphImpl.getBufAccessorFromEdge(edge);
            if (bufAccessor.getState() == EXECBUF_UNDERFLOW) {
                // move current upstream
                current = boost::source(edge,graphRep);
                break;
            }
        }
        if (inEdges.first != inEdges.second) {
            // hit EXECBUF_UNDERFLOW
            continue;
        }

        SharedExecStream pStream = graphImpl.getStreamFromVertex(current);
        ExecStreamResult rc = executeStream(*pStream, quantum);

        checkAbort();

        ExecStreamGraphImpl::Edge edge;

        switch (rc) {
        case EXECRC_EOS:
            // find a consumer that is not in EOS state
            if (!findNextConsumer(
                graphImpl, graphRep, stream, edge, current, EXECBUF_EOS))
            {
                return graphImpl.getBufAccessorFromEdge(edge);
            }
            // if all were in eos, just use the last consumer
            break;
        case EXECRC_BUF_OVERFLOW:
            // find a consumer that is not in underflow state; i.e., not
            // waiting on this producer to continue execution
            if (!findNextConsumer(
                graphImpl, graphRep, stream, edge, current, EXECBUF_UNDERFLOW))
            {
                return graphImpl.getBufAccessorFromEdge(edge);
            }
            break;
        case EXECRC_BUF_UNDERFLOW:
            // TODO:  assert that at least one input is in state
            // EXECBUF_UNDERFLOW
            break;
        case EXECRC_QUANTUM_EXPIRED:
            break;
        default:
            permAssert(false);
        }
    }
}

ExecStreamResult ExecStreamScheduler::executeStream	(	ExecStream &	stream,
		ExecStreamQuantum const &	quantum
	)			[inline, protected, inherited]

Executes one stream, performing tracing if enabled.

Parameters:

	stream	stream to execute
	quantum	quantum controlling stream execution

Returns:

result of executing stream

Definition at line 243 of file ExecStreamScheduler.h.

References ExecStream::execute(), ExecStreamScheduler::tracePostExecution(), ExecStreamScheduler::tracePreExecution(), and ExecStreamScheduler::tracingFine.

Referenced by readStream(), and ParallelExecStreamScheduler::tryExecuteTask().

{
    if (tracingFine) {
        tracePreExecution(stream, quantum);
        ExecStreamResult rc = stream.execute(quantum);
        tracePostExecution(stream, rc);
        return rc;
    } else {
        return stream.execute(quantum);
    }
}

void ExecStreamScheduler::tracePreExecution	(	ExecStream &	stream,
		ExecStreamQuantum const &	quantum
	)			[protected, virtual, inherited]

Traces before execution of a stream.

Parameters:

	stream	stream about to be executed
	quantum	quantum controlling stream execution

Definition at line 112 of file ExecStreamScheduler.cpp.

References ExecStream::getName(), ExecStream::getStreamId(), isMAXU(), ExecStreamQuantum::nTuplesMax, TRACE_FINE, TRACE_FINEST, and ExecStreamScheduler::traceStreamBuffers().

Referenced by ExecStreamScheduler::executeStream().

{
    FENNEL_TRACE(
        TRACE_FINE,
        "executing " << stream.getStreamId() << ' ' << stream.getName());
    if (!isMAXU(quantum.nTuplesMax)) {
        FENNEL_TRACE(
            TRACE_FINE,
            "nTuplesMax = " << quantum.nTuplesMax);
    }

    traceStreamBuffers(stream, TRACE_FINEST, TRACE_FINEST);
}

void ExecStreamScheduler::tracePostExecution	(	ExecStream &	stream,
		ExecStreamResult	rc
	)			[protected, virtual, inherited]

Traces after execution of a stream.

Parameters:

	stream	stream which was just executed
	rc	result code returned by stream

Definition at line 128 of file ExecStreamScheduler.cpp.

References ExecStreamResult_names, ExecStream::getName(), ExecStream::getStreamId(), TRACE_FINE, TRACE_FINER, TRACE_FINEST, and ExecStreamScheduler::traceStreamBuffers().

Referenced by ExecStreamScheduler::executeStream().

{
    FENNEL_TRACE(
        TRACE_FINE,
        "executed " << stream.getStreamId() << ' ' << stream.getName()
        << " with result " << ExecStreamResult_names[rc]);

    traceStreamBuffers(stream, TRACE_FINEST, TRACE_FINER);
}

void ExecStreamScheduler::traceStreamBuffers	(	ExecStream &	stream,
		TraceLevel	inputTupleTraceLevel,
		TraceLevel	outputTupleTraceLevel
	)			[protected, virtual, inherited]

Traces the states of the input and output buffers adjacent to a stream.

Parameters:

	stream	stream whose buffers are to be traced
	inputTupleTraceLevel	trace level at which tuple contents of input buffers are to be traced
	outputTupleTraceLevel	trace level at which tuple contents of output buffers are to be traced

Definition at line 140 of file ExecStreamScheduler.cpp.

References ExecStreamBufState_names, ExecStreamGraphImpl::getBufAccessorFromEdge(), ExecStreamBufAccessor::getConsumptionAvailable(), ExecStream::getGraph(), ExecStreamGraphImpl::getGraphRep(), ExecStreamBufAccessor::getProductionAvailable(), ExecStreamBufAccessor::getState(), ExecStream::getStreamId(), ExecStreamBufAccessor::hasPendingEOS(), TraceSource::isTracingLevel(), TRACE_FINER, and ExecStreamScheduler::traceStreamBufferContents().

Referenced by ExecStreamScheduler::tracePostExecution(), and ExecStreamScheduler::tracePreExecution().

{
    ExecStreamGraphImpl &graphImpl =
        dynamic_cast<ExecStreamGraphImpl&>(stream.getGraph());
    ExecStreamGraphImpl::GraphRep const &graphRep = graphImpl.getGraphRep();

    ExecStreamGraphImpl::InEdgeIterPair inEdges =
        boost::in_edges(stream.getStreamId(),graphRep);
    for (uint i = 0; inEdges.first != inEdges.second;
         ++(inEdges.first),  ++i)
    {
        ExecStreamGraphImpl::Edge edge = *(inEdges.first);
        ExecStreamBufAccessor &bufAccessor =
            graphImpl.getBufAccessorFromEdge(edge);
        FENNEL_TRACE(
            TRACE_FINER,
            "input buffer " << i << ":  "
            << ExecStreamBufState_names[bufAccessor.getState()]
            << (bufAccessor.hasPendingEOS() ? ", EOS pending" : "")
            << ",  consumption available = "
            << bufAccessor.getConsumptionAvailable());
        if (stream.isTracingLevel(inputTupleTraceLevel)) {
            traceStreamBufferContents(
                stream, bufAccessor, inputTupleTraceLevel);
        }
    }

    ExecStreamGraphImpl::OutEdgeIterPair outEdges =
        boost::out_edges(stream.getStreamId(),graphRep);
    for (uint i = 0; outEdges.first != outEdges.second;
         ++(outEdges.first),  ++i) {
        ExecStreamGraphImpl::Edge edge = *(outEdges.first);
        ExecStreamBufAccessor &bufAccessor =
            graphImpl.getBufAccessorFromEdge(edge);
        FENNEL_TRACE(
            TRACE_FINER,
            "output buffer " << i << ":  "
            << ExecStreamBufState_names[bufAccessor.getState()]
            << (bufAccessor.hasPendingEOS() ? ", EOS pending" : "")
            << ",  consumption available = "
            << bufAccessor.getConsumptionAvailable()
            << ",  production available = "
            << bufAccessor.getProductionAvailable());
        if (stream.isTracingLevel(outputTupleTraceLevel)) {
            traceStreamBufferContents(
                stream, bufAccessor, outputTupleTraceLevel);
        }
    }
}

void ExecStreamScheduler::traceStreamBufferContents	(	ExecStream &	stream,
		ExecStreamBufAccessor &	bufAccessor,
		TraceLevel	traceLevel
	)			[virtual, inherited]

Traces the contents of a stream buffer.

Parameters:

	stream	stream whose buffer is being traced
	bufAccessor	accessor for stream buffer
	traceLevel	level at which contents should be traced

Definition at line 193 of file ExecStreamScheduler.cpp.

References ExecStreamBufAccessor::getConsumptionEnd(), ExecStreamBufAccessor::getConsumptionStart(), TupleAccessor::getCurrentByteCount(), ExecStreamBufAccessor::getScratchTupleAccessor(), ExecStreamBufAccessor::getTupleDesc(), TuplePrinter::print(), TupleAccessor::setCurrentTupleBuf(), TraceSource::trace(), and TupleAccessor::unmarshal().

Referenced by ExecStreamScheduler::traceStreamBuffers().

{
    TupleDescriptor const &tupleDesc = bufAccessor.getTupleDesc();
    TupleData tupleData(tupleDesc);
    TupleAccessor &tupleAccessor = bufAccessor.getScratchTupleAccessor();

    for (PConstBuffer pTuple = bufAccessor.getConsumptionStart();
         pTuple != bufAccessor.getConsumptionEnd();
         pTuple += tupleAccessor.getCurrentByteCount())
    {
        tupleAccessor.setCurrentTupleBuf(pTuple);
        // while we're here, we might as well sanity-check the content
        assert(pTuple + tupleAccessor.getCurrentByteCount()
            <= bufAccessor.getConsumptionEnd());
        tupleAccessor.unmarshal(tupleData);
        // TODO:  sanity-check individual data values?
        std::ostringstream oss;
        TuplePrinter tuplePrinter;
        tuplePrinter.print(oss,tupleDesc,tupleData);
        stream.trace(traceLevel,oss.str());
    }
}

void ExecStreamScheduler::makeRunnable

(

ExecStream &

stream

)

[inline, inherited]

Requests that a specific stream be considered for execution.

Parameters:

stream

the stream to make runnable

Deprecated:

use setRunnable

Reimplemented in ParallelExecStreamScheduler.

Definition at line 257 of file ExecStreamScheduler.h.

References ExecStreamScheduler::setRunnable().

{
    setRunnable(stream, true);
}

SharedExecStreamBufAccessor ExecStreamScheduler::newBufAccessor

(

)

[virtual, inherited]

Creates a new ExecStreamBufAccessor suitable for use with this scheduler.

Returns:

new buffer accessor

Definition at line 78 of file ExecStreamScheduler.cpp.

Referenced by ExecStreamGraphImpl::prepare().

{
    return SharedExecStreamBufAccessor(new ExecStreamBufAccessor());
}

void ExecStreamScheduler::createBufferProvisionAdapter

(

ExecStreamEmbryo &

embryo

)

[virtual, inherited]

Creates a new adapter stream capable of buffering the output of a stream with BUFPROV_CONSUMER for use as input to a stream with BUFPROV_PRODUCER.

Default implementation is ScratchBufferExecStream. Caller is responsible for filling in generic ExecStreamParams after return.

Parameters:

embryo

receives new adapter stream

Reimplemented in ParallelExecStreamScheduler.

Definition at line 83 of file ExecStreamScheduler.cpp.

References ExecStreamEmbryo::init().

{
    ScratchBufferExecStreamParams adapterParams;
    embryo.init(
        new ScratchBufferExecStream(),
        adapterParams);
}

void ExecStreamScheduler::createCopyProvisionAdapter

(

ExecStreamEmbryo &

embryo

)

[virtual, inherited]

Creates a new adapter stream capable of copying the output of a stream with BUFPROV_PRODUCER into the input of a stream with BUFPROV_CONSUMER.

Default implementation is CopyExecStream. Caller is responsible for filling in generic ExecStreamParams after return.

Parameters:

embryo

receives new adapter stream

Definition at line 92 of file ExecStreamScheduler.cpp.

References ExecStreamEmbryo::init().

{
    CopyExecStreamParams adapterParams;
    embryo.init(
        new CopyExecStream(),
        adapterParams);
}

uint ExecStreamScheduler::getDegreeOfParallelism

(

)

[virtual, inherited]

Returns:

the degree of parallelism implemented by this scheduler, or 1 for a non-parallel scheduler

Reimplemented in ParallelExecStreamScheduler.

Definition at line 223 of file ExecStreamScheduler.cpp.

Referenced by MergeExecStream::open().

{
    return 1;
}

void TraceSource::initTraceSource	(	SharedTraceTarget	pTraceTarget,
		std::string	name
	)			[virtual, inherited]

For use when initialization has to be deferred until after construction.

Parameters:

	pTraceTarget	the TraceTarget to which messages will be sent
	name	the name of this source

Definition at line 46 of file TraceSource.cpp.

References TraceSource::isTracing(), TraceSource::minimumLevel, TraceSource::name, TraceSource::pTraceTarget, and TRACE_OFF.

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

{
    assert(!pTraceTarget.get());

    pTraceTarget = pTraceTargetInit;
    name = nameInit;
    if (isTracing()) {
        minimumLevel = pTraceTarget->getSourceTraceLevel(name);
    } else {
        minimumLevel = TRACE_OFF;
    }
}

void TraceSource::trace	(	TraceLevel	level,
		std::string	message
	)			const [inherited]

Records a trace message.

Normally only called via FENNEL_TRACE.

Parameters:

	level	severity level of event being trace
	message	the text of the message

Definition at line 61 of file TraceSource.cpp.

References TraceSource::getTraceTarget(), TraceSource::isTracing(), TraceSource::name, and TraceTarget::notifyTrace().

Referenced by Calculator::exec(), and ExecStreamScheduler::traceStreamBufferContents().

{
    if (isTracing()) {
        getTraceTarget().notifyTrace(name,level,message);
    }
}

bool TraceSource::isTracing

(

)

const [inline, inherited]

Returns:

true iff tracing is enabled for this source

Definition at line 88 of file TraceSource.h.

Referenced by TraceSource::initTraceSource(), CalcExecStream::prepare(), and TraceSource::trace().

    {
        return pTraceTarget.get() ? true : false;
    }

bool TraceSource::isTracingLevel

(

TraceLevel

level

)

const [inline, inherited]

Determines whether a particular level is being traced.

Parameters:

level

trace level to test

Returns:

true iff tracing is enabled for the given level

Definition at line 100 of file TraceSource.h.

Referenced by ExecStreamScheduler::addGraph(), SimpleExecStreamGovernor::assignCachePages(), SimpleExecStreamGovernor::distributeCachePages(), Calculator::exec(), ExecStreamScheduler::ExecStreamScheduler(), LcsClusterNodeWriter::getLastClusterPageForWrite(), LcsClusterNodeWriter::moveFromTempToIndex(), JavaSinkExecStream::stuffByteBuffer(), and ExecStreamScheduler::traceStreamBuffers().

    {
        return level >= minimumLevel;
    }

TraceTarget& TraceSource::getTraceTarget

(

)

const [inline, inherited]

Returns:

the TraceTarget for this source

Definition at line 108 of file TraceSource.h.

Referenced by TraceSource::trace().

    {
        assert(isTracing());
        return *(pTraceTarget.get());
    }

SharedTraceTarget TraceSource::getSharedTraceTarget

(

)

const [inline, inherited]

Returns:

the SharedTraceTarget for this source

Definition at line 117 of file TraceSource.h.

Referenced by Database::init(), LcsClusterAppendExecStream::initLoad(), and CalcExecStream::prepare().

    {
        return pTraceTarget;
    }

std::string TraceSource::getTraceSourceName

(

)

const [inline, inherited]

Gets the name of this source.

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

Returns:

the name

Definition at line 127 of file TraceSource.h.

Referenced by LcsClusterAppendExecStream::initLoad().

    {
        return name;
    }

void TraceSource::setTraceSourceName

(

std::string const &

n

)

[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.

    {
        name = n;
    }

TraceLevel TraceSource::getMinimumTraceLevel

(

)

const [inline, inherited]

Definition at line 141 of file TraceSource.h.

    {
        return minimumLevel;
    }

void TraceSource::disableTracing

(

)

[inherited]

Definition at line 68 of file TraceSource.cpp.

References TraceSource::minimumLevel, TraceSource::pTraceTarget, and TRACE_OFF.

Referenced by TestBase::afterTestCase().

{
    pTraceTarget.reset();
    minimumLevel = TRACE_OFF;
}

---

Member Data Documentation

volatile bool DfsTreeExecStreamScheduler::aborted [private]

Definition at line 45 of file DfsTreeExecStreamScheduler.h.

Referenced by abort(), checkAbort(), start(), and stop().

SharedExecStreamGraph DfsTreeExecStreamScheduler::pGraph [private]

Definition at line 47 of file DfsTreeExecStreamScheduler.h.

Referenced by addGraph(), removeGraph(), and start().

bool ExecStreamScheduler::tracingFine [protected, inherited]

Definition at line 47 of file ExecStreamScheduler.h.

Referenced by ExecStreamScheduler::addGraph(), ExecStreamScheduler::ExecStreamScheduler(), and ExecStreamScheduler::executeStream().

---

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

• /home/pub/open/dev/fennel/exec/DfsTreeExecStreamScheduler.h
• /home/pub/open/dev/fennel/exec/DfsTreeExecStreamScheduler.cpp

---