SimpleExecStreamGovernor Class Reference

SimpleExecStreamGovernor is a reference implementation of ExecStreamGovernor. More...

#include <SimpleExecStreamGovernor.h>

Inheritance diagram for SimpleExecStreamGovernor:

List of all members.

Public Member Functions
	SimpleExecStreamGovernor (ExecStreamResourceKnobs const &knobSettings, ExecStreamResourceQuantity const &resourcesAvailable, SharedTraceTarget pTraceTarget, std::string name)
virtual	~SimpleExecStreamGovernor ()
virtual bool	setResourceKnob (ExecStreamResourceKnobs const &knob, ExecStreamResourceKnobType knobType)
	Informs the resource governor of a new knob setting.
virtual bool	setResourceAvailability (ExecStreamResourceQuantity const &available, ExecStreamResourceType resourceType)
	Informs the resource governor of a new resource availablity.
virtual void	requestResources (ExecStreamGraph &graph)
	Requests resources for an exec stream graph and assigns resources to each exec stream in the graph.
virtual void	returnResources (ExecStreamGraph &graph)
	Returns to the available resource pool resources that have been assigned to an exec stream graph.
void	writeStats (StatsTarget &target)
	Writes a current stats snapshot to a StatsTarget.
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 Types
typedef std::map< ExecStreamGraph *, SharedExecStreamResourceQuantity >	ExecStreamGraphResourceMap
Protected Member Functions
void	traceCachePageRequest (uint assigned, ExecStreamResourceRequirements const &reqt, std::string const &name)
	Traces the number of pages assigned to a stream, as well as its minimum and optimum requirements.
Protected Attributes
ExecStreamResourceKnobs	knobSettings
	Current resource knob settings.
ExecStreamResourceQuantity	resourcesAvailable
	Keeps track of the total resources that are currently available for assignment.
ExecStreamResourceQuantity	resourcesAssigned
	Keeps track of resources that have been assigned.
ExecStreamGraphResourceMap	resourceMap
	Used to keep track of how much resources have been assigned to each of the currently active exec stream graphs.
StrictMutex	mutex
	Used to synchronize access.
Private Member Functions
uint	computePerGraphAllocation ()
	Computes the per graph allocation.
void	assignCachePages (std::vector< SharedExecStream > &streams, boost::scoped_array< ExecStreamResourceRequirements > const &reqts, bool assignMin)
	Assigns each stream either its minimum or optimum resource requirements.
uint	distributeCachePages (std::vector< SharedExecStream > &streams, boost::scoped_array< ExecStreamResourceRequirements > const &reqts, boost::scoped_array< double > const &sqrtDiffOptMin, double totalSqrtDiffs, uint excessAvailable, bool assignOpt)
	Distributes cache pages across streams according to the following formula:.
Private Attributes
uint	perGraphAllocation
	Portion of resources that can be allocated to an exec stream graph.

---

Detailed Description

SimpleExecStreamGovernor is a reference implementation of ExecStreamGovernor.

Author:

Zelaine Fong

Version:

Id

//open/dev/fennel/exec/SimpleExecStreamGovernor.h#8

Definition at line 40 of file SimpleExecStreamGovernor.h.

---

Member Typedef Documentation

typedef std::map<ExecStreamGraph *, SharedExecStreamResourceQuantity> ExecStreamGovernor::ExecStreamGraphResourceMap [protected, inherited]

Definition at line 95 of file ExecStreamGovernor.h.

---

Constructor & Destructor Documentation

SimpleExecStreamGovernor::SimpleExecStreamGovernor	(	ExecStreamResourceKnobs const &	knobSettings,
		ExecStreamResourceQuantity const &	resourcesAvailable,
		SharedTraceTarget	pTraceTarget,
		std::string	name
	)			[explicit]

Definition at line 34 of file SimpleExecStreamGovernor.cpp.

References computePerGraphAllocation(), and perGraphAllocation.

    : TraceSource(pTraceTargetInit, nameInit),
      ExecStreamGovernor(
            knobSettings, resourcesAvailable, pTraceTargetInit, nameInit)
{
    perGraphAllocation = computePerGraphAllocation();
}

SimpleExecStreamGovernor::~SimpleExecStreamGovernor

(

)

[virtual]

Definition at line 46 of file SimpleExecStreamGovernor.cpp.

{
}

---

Member Function Documentation

uint SimpleExecStreamGovernor::computePerGraphAllocation

(

)

[inline, private]

Computes the per graph allocation.

Definition at line 121 of file SimpleExecStreamGovernor.h.

References ExecStreamResourceKnobs::expectedConcurrentStatements, ExecStreamGovernor::knobSettings, ExecStreamResourceQuantity::nCachePages, ExecStreamGovernor::resourcesAssigned, and ExecStreamGovernor::resourcesAvailable.

Referenced by setResourceAvailability(), setResourceKnob(), and SimpleExecStreamGovernor().

{
    return (resourcesAvailable.nCachePages + resourcesAssigned.nCachePages) /
        knobSettings.expectedConcurrentStatements;
}

void SimpleExecStreamGovernor::assignCachePages	(	std::vector< SharedExecStream > &	streams,
		boost::scoped_array< ExecStreamResourceRequirements > const &	reqts,
		bool	assignMin
	)			[private]

Assigns each stream either its minimum or optimum resource requirements.

Parameters:

	streams	streams to be assigned resources
	reqts	resource requirements for each stream
	assignMin	if true, assign each stream its minimum; otherwise, assign each stream its optimum

Definition at line 280 of file SimpleExecStreamGovernor.cpp.

References TraceSource::isTracingLevel(), TRACE_FINER, and ExecStreamGovernor::traceCachePageRequest().

Referenced by requestResources().

{
    for (uint i = 0; i < streams.size(); i++) {
        ExecStreamResourceQuantity quantity;
        quantity.nCachePages =
            (assignMin) ? reqts[i].minReqt : reqts[i].optReqt;
        streams[i]->setResourceAllocation(quantity);
        if (isTracingLevel(TRACE_FINER)) {
            traceCachePageRequest(
                quantity.nCachePages, reqts[i], streams[i]->getName());
        }
    }
}

uint SimpleExecStreamGovernor::distributeCachePages	(	std::vector< SharedExecStream > &	streams,
		boost::scoped_array< ExecStreamResourceRequirements > const &	reqts,
		boost::scoped_array< double > const &	sqrtDiffOptMin,
		double	totalSqrtDiffs,
		uint	excessAvailable,
		bool	assignOpt
	)			[private]

Distributes cache pages across streams according to the following formula:.

 base amount for stream +
  (# of extra pages above total min available to the stream graph) *
  sqrt((opt for stream) - (min for stream)) /
  sum of the sqrt of the differences between the opt and min for streams
      that will receive excess allocations

  where the base amount is either the min or opt requirements of the
  stream
 

Parameters:

	streams	streams to be assigned resources
	reqts	resource requirements for each stream
	sqrtDiffOptMin	sqrt of the difference between the opt and min for each stream
	totalSqrtDiffs	sum of the sqrt of the differences between the opt and min for each stream
	excessAvailable	excess cache pages to be distributed across certain streams
	assignOpt	if true, assign at least the optimum amount to each stream; otherwise, assign at least the minimum amount

Returns:

total number of cache pages assigned to streams

Definition at line 297 of file SimpleExecStreamGovernor.cpp.

References EXEC_RESOURCE_ACCURATE, EXEC_RESOURCE_UNBOUNDED, TraceSource::isTracingLevel(), ExecStreamResourceRequirements::minReqt, ExecStreamResourceQuantity::nCachePages, ExecStreamResourceRequirements::optReqt, ExecStreamResourceRequirements::optType, TRACE_FINER, and ExecStreamGovernor::traceCachePageRequest().

Referenced by requestResources().

{
    // if there's enough to assign the optimum amount to each stream, then
    // adjust totalSqrtDiffs so we don't allocate any extra to the
    // streams with accurate settings
    if (assignOpt) {
        totalSqrtDiffs = 0;
        for (uint i = 0; i < streams.size(); i++) {
            if (reqts[i].optType != EXEC_RESOURCE_ACCURATE) {
                totalSqrtDiffs += sqrtDiffOptMin[i];
            }
        }
    }

    uint excessAssigned = 0;
    uint totalAssigned = 0;
    for (uint i = 0; i < streams.size(); i++) {
        uint amount;
        ExecStreamResourceRequirements &reqt = reqts[i];
        if (assignOpt && reqt.optType == EXEC_RESOURCE_ACCURATE) {
            amount = 0;
        } else {
            amount = (uint) floor(excessAvailable * sqrtDiffOptMin[i] /
                totalSqrtDiffs);
        }
        assert(amount <= (excessAvailable - excessAssigned));
        excessAssigned += amount;

        ExecStreamResourceQuantity quantity;
        if (assignOpt) {
            assert(reqt.optType != EXEC_RESOURCE_UNBOUNDED);
            quantity.nCachePages = reqt.optReqt;
        } else {
            quantity.nCachePages = reqt.minReqt;
        }
        quantity.nCachePages += amount;
        totalAssigned += quantity.nCachePages;
        streams[i]->setResourceAllocation(quantity);
        if (isTracingLevel(TRACE_FINER)) {
            traceCachePageRequest(
                quantity.nCachePages, reqt, streams[i]->getName());
        }
    }

    return totalAssigned;
}

bool SimpleExecStreamGovernor::setResourceKnob	(	ExecStreamResourceKnobs const &	knob,
		ExecStreamResourceKnobType	knobType
	)			[virtual]

Informs the resource governor of a new knob setting.

Called by ALTER SYSTEM SET commands that dynamically modify parameters controlling resource allocation.

Parameters:

	knob	new resource knob setting
	knobType	indicates which knob setting to change

Returns:

true if possible to apply new setting; false if the setting is below current in-use threshholds. E.g., if modifying cacheReservePercentage, the new number of reserved pages must allow for pages already assigned.

Implements ExecStreamGovernor.

Definition at line 50 of file SimpleExecStreamGovernor.cpp.

References ExecStreamResourceKnobs::cacheReservePercentage, computePerGraphAllocation(), EXEC_KNOB_CACHE_RESERVE_PERCENTAGE, EXEC_KNOB_EXPECTED_CONCURRENT_STATEMENTS, ExecStreamResourceKnobs::expectedConcurrentStatements, ExecStreamGovernor::knobSettings, ExecStreamGovernor::mutex, ExecStreamResourceQuantity::nCachePages, perGraphAllocation, ExecStreamGovernor::resourcesAssigned, ExecStreamGovernor::resourcesAvailable, and TRACE_FINE.

{
    StrictMutexGuard mutexGuard(mutex);

    switch (knobType) {
    case EXEC_KNOB_EXPECTED_CONCURRENT_STATEMENTS:
        knobSettings.expectedConcurrentStatements =
            knob.expectedConcurrentStatements;
        perGraphAllocation = computePerGraphAllocation();
        FENNEL_TRACE(
            TRACE_FINE,
            "Expected concurrent statements set to " <<
            knobSettings.expectedConcurrentStatements <<
            ". Per graph allocation is now " << perGraphAllocation <<
            " cache pages.");
        break;

    case EXEC_KNOB_CACHE_RESERVE_PERCENTAGE:
        // make sure we have enough unassigned pages to set aside the new
        // reserve amount
        double percent = (100 - knobSettings.cacheReservePercentage) / 100.0;
        uint totalPagesAvailable = (uint)
            ((resourcesAvailable.nCachePages + resourcesAssigned.nCachePages) /
            percent);
        uint numReserve =
            totalPagesAvailable * knob.cacheReservePercentage / 100;
        if (totalPagesAvailable - numReserve < resourcesAssigned.nCachePages) {
            return false;
        }
        knobSettings.cacheReservePercentage = knob.cacheReservePercentage;
        resourcesAvailable.nCachePages =
            totalPagesAvailable - numReserve - resourcesAssigned.nCachePages;
        perGraphAllocation = computePerGraphAllocation();
        FENNEL_TRACE(
            TRACE_FINE,
            "Cache reserve percentage set to " <<
            knobSettings.cacheReservePercentage <<
            ". Per graph allocation is now " << perGraphAllocation <<
            " cache pages.");
        break;
    }

    return true;
}

bool SimpleExecStreamGovernor::setResourceAvailability	(	ExecStreamResourceQuantity const &	available,
		ExecStreamResourceType	resourceType
	)			[virtual]

Informs the resource governor of a new resource availablity.

Called by ALTER SYSTEM SET commands that dynamically modify resources available.

Parameters:

	available	amount of resources now available
	resourceType	type of resource to be set

Returns:

true if possible to apply new settings; false if the setting is below current in-use threshholds. E.g., if modifying cachePagesInit, the value needs to be >= current number of cache pages that have been assigned.

Implements ExecStreamGovernor.

Definition at line 96 of file SimpleExecStreamGovernor.cpp.

References ExecStreamResourceKnobs::cacheReservePercentage, computePerGraphAllocation(), EXEC_RESOURCE_CACHE_PAGES, EXEC_RESOURCE_THREADS, ExecStreamGovernor::knobSettings, ExecStreamGovernor::mutex, ExecStreamResourceQuantity::nCachePages, ExecStreamResourceQuantity::nThreads, perGraphAllocation, ExecStreamGovernor::resourcesAssigned, ExecStreamGovernor::resourcesAvailable, and TRACE_FINE.

{
    StrictMutexGuard mutexGuard(mutex);

    switch (resourceType) {
    case EXEC_RESOURCE_CACHE_PAGES:
        {
        uint pagesAvailable =
            available.nCachePages *
            (100 - knobSettings.cacheReservePercentage) / 100;
        if (pagesAvailable < resourcesAssigned.nCachePages) {
            return false;
        }
        resourcesAvailable.nCachePages =
            (pagesAvailable - resourcesAssigned.nCachePages);
        perGraphAllocation = computePerGraphAllocation();
        FENNEL_TRACE(
            TRACE_FINE,
            resourcesAvailable.nCachePages <<
            " cache pages now available for assignment.  " <<
            "Per graph allocation is now " << perGraphAllocation <<
            " cache pages.");
        break;
        }

    case EXEC_RESOURCE_THREADS:
        resourcesAvailable.nThreads = available.nThreads;
        break;
    }

    return true;
}

void SimpleExecStreamGovernor::requestResources

(

ExecStreamGraph &

graph

)

[virtual]

Requests resources for an exec stream graph and assigns resources to each exec stream in the graph.

Parameters:

graph

the exec stream graph for which resources are being requested

Implements ExecStreamGovernor.

Definition at line 130 of file SimpleExecStreamGovernor.cpp.

References assignCachePages(), distributeCachePages(), EXEC_RESOURCE_ACCURATE, EXEC_RESOURCE_ESTIMATE, EXEC_RESOURCE_UNBOUNDED, ExecStreamGraph::getSortedStreams(), min(), ExecStreamResourceRequirements::minReqt, ExecStreamGovernor::mutex, ExecStreamResourceQuantity::nCachePages, ExecStreamResourceQuantity::nThreads, ExecStreamResourceRequirements::optReqt, ExecStreamResourceRequirements::optType, perGraphAllocation, ExecStreamGovernor::resourceMap, ExecStreamGovernor::resourcesAssigned, ExecStreamGovernor::resourcesAvailable, and TRACE_FINE.

{
    FENNEL_TRACE(TRACE_FINE, "requestResources");

    StrictMutexGuard mutexGuard(mutex);

    std::vector<SharedExecStream> sortedStreams = graph.getSortedStreams();
    boost::scoped_array<ExecStreamResourceRequirements> resourceReqts;
    boost::scoped_array<double> sqrtDiffOptMin;
    uint nStreams = sortedStreams.size();

    resourceReqts.reset(new ExecStreamResourceRequirements[nStreams]);
    sqrtDiffOptMin.reset(new double[nStreams]);

    // scale down the number of pages that can be allocated based on how
    // much still remains
    uint allocationAmount =
        std::min(resourcesAvailable.nCachePages, perGraphAllocation);
    FENNEL_TRACE(
        TRACE_FINE,
        allocationAmount << " cache pages available for stream graph");

    // Total the minimum and optimum resource requirements and determine
    // if we have any estimate/unbounded optimum settings
    uint totalMin = 0;
    uint totalOpt = 0;
    double totalSqrtDiffs = 0;
    bool allAccurate = true;
    for (uint i = 0; i < nStreams; i++) {
        ExecStreamResourceQuantity minQuantity, optQuantity;
        ExecStreamResourceSettingType optType;
        sortedStreams[i]->getResourceRequirements(
            minQuantity, optQuantity, optType);
        assert(
            optType == EXEC_RESOURCE_UNBOUNDED ||
            minQuantity.nCachePages <= optQuantity.nCachePages);
        assert(minQuantity.nThreads <= optQuantity.nThreads);

        ExecStreamResourceRequirements &reqt = resourceReqts[i];
        reqt.minReqt = minQuantity.nCachePages;
        totalMin += reqt.minReqt;
        reqt.optType = optType;

        switch (optType) {
        case EXEC_RESOURCE_ACCURATE:
            reqt.optReqt = optQuantity.nCachePages;
            sqrtDiffOptMin[i] = sqrt(double(reqt.optReqt - reqt.minReqt));
            break;
        case EXEC_RESOURCE_ESTIMATE:
            reqt.optReqt = optQuantity.nCachePages;
            sqrtDiffOptMin[i] = sqrt(double(reqt.optReqt - reqt.minReqt));
            allAccurate = false;
            break;
        case EXEC_RESOURCE_UNBOUNDED:
            // in the unbounded case, since we're trying to use as much
            // memory as available, set the difference to how much is
            // available; this way, we set it to something large relative
            // to availability, but still set it to a finite value to
            // allow some allocation to go towards those streams that
            // have estimated optimums
            sqrtDiffOptMin[i] = sqrt(double(allocationAmount));
            allAccurate = false;
            // in the unbounded case, we don't have an optimum setting, so
            // set it to assume the full allocation amount plus the min
            reqt.optReqt = reqt.minReqt + allocationAmount;
            break;
        }
        totalOpt += reqt.optReqt;
        totalSqrtDiffs += sqrtDiffOptMin[i];
    }

    // not enough pages even to assign the minimum requirements
    if (totalMin > allocationAmount &&
        totalMin > resourcesAvailable.nCachePages)
    {
        FENNEL_TRACE(
            TRACE_FINE,
            "Minimum request of " << totalMin << " cache pages not met");
        throw ScratchMemExcn();
    }

    uint totalAssigned;

    // only enough to assign the minimum
    if (totalMin >= allocationAmount) {
        assignCachePages(sortedStreams, resourceReqts, true);
        totalAssigned = totalMin;
        FENNEL_TRACE(
            TRACE_FINE,
            "Mininum request of " << totalMin << " cache pages assigned");

    } else if (totalOpt <= allocationAmount) {
        // if all streams have accurate optimum settings, and we have enough
        // to assign the optimum amount, then do so
        if (allAccurate) {
            assignCachePages(sortedStreams, resourceReqts, false);
            totalAssigned = totalOpt;
            FENNEL_TRACE(
                TRACE_FINE,
                "Optimum request of " << totalOpt << " cache pages assigned");

        } else {
            // even though total optimum is less than the allocation amount,
            // since some streams have estimate settings, we want to try and
            // give a little extra to those streams; the streams that have
            // accurate settings will receive their full optimum amount;
            // note that in this case, there should not be any streams with
            // optimum settings
            uint assigned =
                distributeCachePages(
                    sortedStreams, resourceReqts, sqrtDiffOptMin,
                    totalSqrtDiffs, allocationAmount - totalOpt, true);
            totalAssigned = assigned;
            FENNEL_TRACE(
                TRACE_FINE,
                assigned <<
                " cache pages assigned, based on an optimum request for " <<
                totalOpt << " cache pages");
        }

    } else {
        // allocate the minimum to each stream and then distribute what
        // remains
        uint assigned =
            distributeCachePages(
                sortedStreams, resourceReqts, sqrtDiffOptMin, totalSqrtDiffs,
                allocationAmount - totalMin, false);
        totalAssigned = assigned;
        FENNEL_TRACE(
            TRACE_FINE,
            assigned <<
            " cache pages assigned based on an optimum request for " <<
            totalOpt << " cache pages");
    }

    // update structures to reflect what's been assigned
    resourcesAssigned.nCachePages += totalAssigned;
    resourcesAvailable.nCachePages -= totalAssigned;
    SharedExecStreamResourceQuantity
        pQuantity(new ExecStreamResourceQuantity());
    pQuantity->nCachePages = totalAssigned;
    resourceMap.insert(
        ExecStreamGraphResourceMap::value_type(&graph, pQuantity));

    FENNEL_TRACE(
        TRACE_FINE,
        resourcesAvailable.nCachePages <<
        " cache pages remaining for assignment");
}

void SimpleExecStreamGovernor::returnResources

(

ExecStreamGraph &

graph

)

[virtual]

Returns to the available resource pool resources that have been assigned to an exec stream graph.

Parameters:

graph

the exec stream graph that is returning its resources

Implements ExecStreamGovernor.

Definition at line 349 of file SimpleExecStreamGovernor.cpp.

References ExecStreamGovernor::mutex, ExecStreamResourceQuantity::nCachePages, ExecStreamGovernor::resourceMap, ExecStreamGovernor::resourcesAssigned, ExecStreamGovernor::resourcesAvailable, and TRACE_FINE.

{
    StrictMutexGuard mutexGuard(mutex);

    ExecStreamGraphResourceMap::const_iterator iter = resourceMap.find(&graph);
    if (iter == resourceMap.end()) {
        // no allocation may have been done
        return;
    }
    SharedExecStreamResourceQuantity pQuantity = iter->second;
    resourcesAssigned.nCachePages -= pQuantity->nCachePages;
    resourcesAvailable.nCachePages += pQuantity->nCachePages;
    FENNEL_TRACE(
        TRACE_FINE,
        "Returned " << pQuantity->nCachePages << " cache pages. " <<
        resourcesAvailable.nCachePages <<
        " cache pages now available for assignment");

    resourceMap.erase(&graph);
}

void ExecStreamGovernor::traceCachePageRequest	(	uint	assigned,
		ExecStreamResourceRequirements const &	reqt,
		std::string const &	name
	)			[protected, inherited]

Traces the number of pages assigned to a stream, as well as its minimum and optimum requirements.

Parameters:

	assigned	number of cache pages assigned to the stream
	reqt	resource requirements for the stream
	name	name of the stream

Definition at line 53 of file ExecStreamGovernor.cpp.

References EXEC_RESOURCE_ACCURATE, EXEC_RESOURCE_ESTIMATE, EXEC_RESOURCE_UNBOUNDED, ExecStreamResourceRequirements::minReqt, ExecStreamResourceRequirements::optReqt, ExecStreamResourceRequirements::optType, and TRACE_FINER.

Referenced by assignCachePages(), and distributeCachePages().

{
    switch (reqt.optType) {
    case EXEC_RESOURCE_ACCURATE:
        FENNEL_TRACE(
            TRACE_FINER,
            "Stream " << name << " assigned " << assigned <<
            " pages based on accurate (min,opt) request of " << "(" <<
            reqt.minReqt << "," << reqt.optReqt << ") pages");
        break;
    case EXEC_RESOURCE_ESTIMATE:
        FENNEL_TRACE(
            TRACE_FINER,
            "Stream " << name << " assigned " << assigned <<
            " pages based on estimated (min,opt) request of " << "(" <<
            reqt.minReqt << "," << reqt.optReqt << ") pages");
        break;
    case EXEC_RESOURCE_UNBOUNDED:
        FENNEL_TRACE(
            TRACE_FINER,
            "Stream " << name << " assigned " << assigned <<
            " pages based on an unbounded opt request with " <<
            reqt.minReqt << " min pages");
    }
}

void ExecStreamGovernor::writeStats

(

StatsTarget &

target

)

[virtual, inherited]

Writes a current stats snapshot to a StatsTarget.

Parameters:

target

receives the stats

Implements StatsSource.

Definition at line 82 of file ExecStreamGovernor.cpp.

References ExecStreamResourceKnobs::cacheReservePercentage, ExecStreamResourceKnobs::expectedConcurrentStatements, ExecStreamGovernor::knobSettings, ExecStreamGovernor::mutex, ExecStreamResourceQuantity::nCachePages, ExecStreamGovernor::resourcesAssigned, ExecStreamGovernor::resourcesAvailable, and StatsTarget::writeCounter().

{
    StrictMutexGuard mutexGuard(mutex);
    target.writeCounter(
        "ExpectedConcurrentStatements",
        knobSettings.expectedConcurrentStatements);
    target.writeCounter(
        "CacheReservePercentage",
        knobSettings.cacheReservePercentage);
    target.writeCounter(
        "CachePagesGoverned",
        resourcesAvailable.nCachePages);
    target.writeCounter(
        "CachePagesReserved",
        resourcesAssigned.nCachePages);
}

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(), assignCachePages(), 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

uint SimpleExecStreamGovernor::perGraphAllocation [private]

Portion of resources that can be allocated to an exec stream graph.

Definition at line 46 of file SimpleExecStreamGovernor.h.

Referenced by requestResources(), setResourceAvailability(), setResourceKnob(), and SimpleExecStreamGovernor().

ExecStreamResourceKnobs ExecStreamGovernor::knobSettings [protected, inherited]

Current resource knob settings.

Definition at line 100 of file ExecStreamGovernor.h.

Referenced by computePerGraphAllocation(), ExecStreamGovernor::ExecStreamGovernor(), setResourceAvailability(), setResourceKnob(), and ExecStreamGovernor::writeStats().

ExecStreamResourceQuantity ExecStreamGovernor::resourcesAvailable [protected, inherited]

Keeps track of the total resources that are currently available for assignment.

Definition at line 106 of file ExecStreamGovernor.h.

Referenced by computePerGraphAllocation(), ExecStreamGovernor::ExecStreamGovernor(), requestResources(), returnResources(), setResourceAvailability(), setResourceKnob(), and ExecStreamGovernor::writeStats().

ExecStreamResourceQuantity ExecStreamGovernor::resourcesAssigned [protected, inherited]

Keeps track of resources that have been assigned.

Definition at line 111 of file ExecStreamGovernor.h.

Referenced by computePerGraphAllocation(), ExecStreamGovernor::ExecStreamGovernor(), requestResources(), returnResources(), setResourceAvailability(), setResourceKnob(), and ExecStreamGovernor::writeStats().

ExecStreamGraphResourceMap ExecStreamGovernor::resourceMap [protected, inherited]

Used to keep track of how much resources have been assigned to each of the currently active exec stream graphs.

Definition at line 117 of file ExecStreamGovernor.h.

Referenced by requestResources(), returnResources(), and ExecStreamGovernor::~ExecStreamGovernor().

StrictMutex ExecStreamGovernor::mutex [protected, inherited]

Used to synchronize access.

Definition at line 122 of file ExecStreamGovernor.h.

Referenced by requestResources(), returnResources(), setResourceAvailability(), setResourceKnob(), and ExecStreamGovernor::writeStats().

---

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

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

---