Compute execution time by edge using the parametric exegraph approach. More...

#include <otawa/etime/EdgeTimeBuilder.h>

Inheritance diagram for otawa::etime::EdgeTimeBuilder:

Classes
class	EventComparator

Public Types
enum	place_t { IN_PREFIX = 0, IN_EDGE = 1, IN_BLOCK = 2, IN_SIZE = 3 }

enum	log_level_t { LOG_NONE = 0, LOG_PROC = 1, LOG_FILE = 2, LOG_DEPS = LOG_FILE, LOG_FUN = 3, LOG_CFG = LOG_FUN, LOG_BLOCK = 4, LOG_BB = LOG_BLOCK, LOG_INST = 5 }

typedef enum otawa::Monitor::log_level_t	log_level_t

Public Member Functions
	EdgeTimeBuilder (p::declare &r=reg)

void	processWorkSpace (WorkSpace *ws)
	Process the given framework. More...

elm::genstruct::SLList < PathContext * > *	buildListOfPathContexts (BasicBlock *bb, int depth=1)

void	FillSequence (PathContext ctxt, elm::genstruct::SLList< PathContext > *context_list, int depth)

ParExeSequence *	buildSequence (PathContext *ctxt)

void	analyzePathContext (PathContext *ctxt, int context_index)

int	analyzeTimingContext (ParExeGraph graph, TimingContext NC_ctxt, TimingContext *FM_ctxt)

void	outputGraph (ParExeGraph *graph, int bb_number, int context_number, int case_number, const string &info="")
	Output the given graph in the directory configured by GRAPHS_OUTPUT_DIRECTORY. More...

elm::String	name (void) const

elm::Version	version (void) const

void	process (WorkSpace *ws, const PropList &props=PropList::EMPTY)
	Execute the code processor on the given framework. More...

WorkSpace *	workspace (void)
	Get the current workspace. More...

bool	isVerbose (void) const
	Test if the verbosity is activated. More...

bool	logFor (log_level_t tested) const
	Test if the given log level is activated or not. More...

log_level_t	logLevel (void) const

Public Attributes
elm::io::Output	out
	Provide a stream to perform output for the user. More...

elm::io::Output	log
	Provide a stream to perform log output. More...

Static Public Attributes
static p::declare	reg

static Identifier< PropList * >	STATS
	This property identifiers is used to pass a property list to the processor that will be used to store statistics about the performed work. More...

static Identifier< bool >	TIMED
	If the value of the associated property is true (default to false), time statistics will also be collected with other processor statistics. More...

static Identifier< bool >	RECURSIVE

static Identifier< Progress * >	PROGRESS
	Install. More...

static Identifier< bool >	COLLECT_STATS
	This property allows to activate collection of statistics for the work of the current processor. More...

static Identifier < elm::io::OutStream * > &	OUTPUT = otawa::OUTPUT
	This property identifier is used for setting the output stream used by the processor to write results. More...

static Identifier < elm::io::OutStream * > &	LOG = otawa::LOG
	This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error). More...

static Identifier< bool > &	VERBOSE = otawa::VERBOSE
	This property activates the verbose mode of the processor: information about the processor work will be displayed. More...

static Identifier< log_level_t > &	LOG_LEVEL = otawa::LOG_LEVEL
	Property passed in the configuration property list of a processor to select the log level between LOG_PROC, LOG_CFG or LOG_BB. More...

static Identifier < elm::system::time_t >	RUNTIME
	This property identifier is used to store in the statistics of a processor the overall run time of the processor work. More...

static Monitor &	null = __null_mon
	Monitor that output nothing. More...

Protected Types
typedef Pair< Event *, place_t >	event_t

typedef genstruct::Vector < event_t >	event_list_t

typedef genstruct::Vector < ConfigSet >	config_list_t

Protected Member Functions
virtual void	configure (const PropList &props)
	Configure the current processor. More...

virtual void	setup (WorkSpace *ws)
	This method is called before an anlysis to let the processor do some initialization. More...

virtual void	processBB (WorkSpace ws, CFG cfg, BasicBlock *bb)
	Perform the work of the given basic block. More...

virtual void	cleanup (WorkSpace *ws)
	This method is called after the end of the processor analysis to let it do some clean up. More...

virtual ParExeGraph *	make (ParExeSequence *seq)
	This method is called to build the parametric execution graph. More...

virtual void	processEdge (WorkSpace ws, CFG cfg)

virtual void	processSequence (void)
	Compute and process the time for the given sequence. More...

virtual void	clean (ParExeGraph *graph)
	Called to cleanup a graph allocated by a call to make(). More...

void	processTimes (const config_list_t &confs)
	Process the computed time and generate associated objective functions and constraints. More...

void	applyStrictSplit (const config_list_t &confs)
	Application of two time approach, LTS and HTS time. More...

void	applyFloppySplit (const config_list_t &confs)
	Application of two time approach, LTS and HTS time. More...

void	applyWeightedSplit (const config_list_t &confs)
	Performing split by computing an heuristic based on weights of BB and events. More...

void	contributeConst (void)
	Generate contribution for constant events. More...

void	contributeSplit (const config_list_t &confs, t::uint32 pos, t::uint32 neg, t::uint32 com, ot::time lts_time, ot::time hts_time)
	Contribute to WCET estimation in split way, x_HTS and x_LTS, with two sets of times. More...

void	makeSplit (const config_list_t &confs, int p, ConfigSet &hts, ot::time &lts_time, ot::time &hts_time)
	Build the set after split. More...

genstruct::Vector< Resource * > *	ressources (void)

virtual int	cacheMissPenalty (Address addr) const

virtual int	memoryLatency (Address addr) const

virtual void	buildNCTimingContextListForICache (elm::genstruct::SLList< TimingContext * > list, ParExeSequence seq)

virtual void	buildFMTimingContextListForICache (elm::genstruct::SLList< TimingContext * > list, ParExeSequence seq)

virtual void	computeDefaultTimingContextForICache (TimingContext dtctxt, ParExeSequence seq)

virtual void	BuildVectorOfHwResources ()

virtual void	configureMem (WorkSpace *ws)

virtual void	processCFG (WorkSpace ws, CFG cfg)
	See CFGProcessor::processCFG() More...

virtual void	cleanupCFG (WorkSpace ws, CFG cfg)
	This function may be overridden by a subclass to provide custom cleanup for a CFG. More...

virtual void	cleanupBB (WorkSpace ws, CFG cfg, BasicBlock *bb)
	When the function doCleanup() is called, this function is called for each basic block of the task. More...

template<class T >
void	trackBB (const AbstractFeature &feature, const Identifier< T * > &id)
	Track and delete the content of the given identifier on each basic block. More...

template<class T >
void	trackBB (const AbstractFeature &feature, const Identifier< T > &id)
	Track and remove properties put on basic blocks. More...

void	doCleanUp (void)
	Trigger associated with CFG. More...

string	str (const Address &address)
	Transform an address to a smart string, that is, if a source line is available, transform it to "source_file:source_line", if the CFG has a label, it gives "label + 0xoffset", else return the address. More...

string	str (const Address &base, const Address &address)
	Transform an address to a smart string, that is, if a source line is available, transform it to "source_file:source_line", if the CFG has a label, it gives "label + 0xoffset", else return the address. More...

CFG *	cfg (void) const
	Get the current CFG. More...

bool	isTimed (void) const
	Test if the timed mode is activated (recording of timings in the statistics). More...

bool	recordsStats (void) const
	Test if the statictics mode is activated. More...

bool	isAllocated (void) const

bool	isPrepared (void) const

bool	isCollectingStats (void) const

void	require (const AbstractFeature &feature)
	Usually called from a processor constructor, this method records a required feature for the work of the current processor. More...

void	provide (const AbstractFeature &feature)
	Usually called from a processor constructor, this method records a feature provided by the work of the current processor. More...

void	invalidate (const AbstractFeature &feature)
	Usually called from a processor constructor, this method records a feature invalidated by the work of the current processor. More...

void	use (const AbstractFeature &feature)
	Usually called from a processor constructor, this method records a feature as used by the work of the current processor. More...

void	warn (const String &message)
	Display a warning. More...

WorkSpace *	workspace (void) const
	Get the current workspace. More...

Progress &	progress (void)
	Get the current progress handler. More...

void	recordStat (const AbstractFeature &feature, StatCollector *collector)
	Add a statistics collector to the current workspace collection. More...

void	addCleaner (const AbstractFeature &feature, Cleaner *cleaner)
	Add a cleaner for the given feature. More...

template<class T >
void	addRemover (const AbstractFeature &feature, const Ref< T, Identifier< T > > &ref)

template<class T >
void	addDeletor (const AbstractFeature &feature, const Ref< T , Identifier< T > > &ref)

virtual void	prepare (WorkSpace *ws)
	This method called to let the processor customize its requirements according to some generic feature. More...

virtual void	collectStats (WorkSpace *ws)
	This method is invoked if the user has required to collect statistics about the processor. More...

virtual void	processFrameWork (WorkSpace *fw)
	Process the given workspace. More...

template<class T >
T *	track (const AbstractFeature &feature, T *object)

template<class T >
void	track (const AbstractFeature &feature, const Ref< T , Identifier< T > > &ref)
	Track the release of an allocated object assigned to an identifier relatively to the given feature. More...

template<class T >
void	track (const AbstractFeature &feature, const Ref< T , const Identifier< T > > &ref)
	Track the release of an allocated object assigned to an identifier relatively to the given feature. More...

virtual void	requireDyn (WorkSpace *ws, const PropList &props)
	Method called after registration requirements to support dynamic requirements. More...

void	setWorkspace (WorkSpace *workspace)
	Set the current workspace. More...

Static Protected Member Functions
static EventCollector::case_t	make (const Event *e, EdgeTimeBuilder::place_t place, bool on)
	Build an event selector case. More...

Protected Attributes
bool	_do_output_graphs

bool	_do_consider_icache

const hard::Memory *	mem

const hard::Cache *	icache

ParExeProc *	_microprocessor

elm::genstruct::Vector < Resource * >	_hw_resources

PropList *	stats

t::uint32	flags
	Contains various bit flags. More...

Static Protected Attributes
static const t::uint32	IS_TIMED = 0x01 << CUSTOM_SHIFT

static const t::uint32	IS_ALLOCATED = 0x04 << CUSTOM_SHIFT

static const t::uint32	IS_PREPARED = 0x08 << CUSTOM_SHIFT

static const t::uint32	IS_COLLECTING = 0x10 << CUSTOM_SHIFT

static const t::uint32	IS_VERBOSE = 0x01

static const t::uint32	CUSTOM_SHIFT = 16

Private Member Functions
void	apply (Event event, ParExeInst inst)
	Apply the given event to the given instruction. More...

void	rollback (Event event, ParExeInst inst)
	Rollback the given event to the given instruction. More...

EventCollector *	get (Event *event)
	Get the collector for the given event. More...

void	genForOneCost (ot::time cost, Edge *edge, event_list_t &events)
	Generate the constraints when only one cost is considered for the edge. More...

ParExeNode *	getBranchNode (void)
	Get the branch node resolving a branch prediction. More...

int	splitConfs (const config_list_t &confs, const event_list_t &events, bool &lower)
	Partition the configuration times in two sets: configuration times in [0, p[ are the low time set (LTS) and the configuration times in [p, ...] are the high time set (HTS). More...

void	sortEvents (event_list_t &events, BasicBlock bb, place_t place, Edge edge=0)
	Sort events according the instructions they apply to. More...

void	displayConfs (const genstruct::Vector< ConfigSet > &confs, const event_list_t &events)
	Display the list of configuration sorted by cost. More...

int	countVarEvents (const event_list_t &events)
	Count the number of variable events in the event list. More...

Private Attributes
bool	_explicit

ilp::System *	sys

bool	predump

int	event_th

Edge *	edge

genstruct::Vector< event_t >	all_events

event_list_t	events

ParExeSequence *	seq

ParExeGraph *	graph

ParExeNode *	bnode

ParExeEdge *	bedge

BasicBlock *	source

BasicBlock *	target

genstruct::HashTable< Event , EventCollector >	colls

Detailed Description

Compute execution time by edge using the parametric exegraph approach.

Notice that only two times are considered by edge: worst time and best time. Possible execution are classified in two sets, worst and best, and max of these sets represent the worst and the best time. The repartition is made to maximize the gap between max of best set and min of worst set.

Provided Features

Required Features

Member Typedef Documentation

typedef genstruct::Vector<ConfigSet> otawa::etime::EdgeTimeBuilder::config_list_t

protected

typedef genstruct::Vector<event_t> otawa::etime::EdgeTimeBuilder::event_list_t

protected

typedef Pair<Event *, place_t> otawa::etime::EdgeTimeBuilder::event_t

protected

typedef enum otawa::Monitor::log_level_t otawa::Monitor::log_level_t

inherited

Member Enumeration Documentation

enum otawa::Monitor::log_level_t

inherited

Enumerator
LOG_NONE
LOG_PROC
LOG_FILE
LOG_DEPS
LOG_FUN
LOG_CFG
LOG_BLOCK
LOG_BB
LOG_INST

enum otawa::etime::EdgeTimeBuilder::place_t

Enumerator
IN_PREFIX
IN_EDGE
IN_BLOCK
IN_SIZE

Constructor & Destructor Documentation

otawa::etime::EdgeTimeBuilder::EdgeTimeBuilder ( p::declare & r = reg )

Member Function Documentation

void otawa::Processor::addCleaner	(	const AbstractFeature &	feature,
		Cleaner *	cleaner
	)

inlineprotectedinherited

Add a cleaner for the given feature.

A cleaner is an object with a virtual destructor that is called when the associated feature is removed: this let the processor to release and clean up the resources it allocated to implement the provided features.

Parameters

feature	Feature the cleaner apply to.
cleaner	Cleaner to add.

Referenced by otawa::DelayedBuilder::cleanup(), otawa::StackAnalysis::cleanup(), otawa::Dominance::processCFG(), otawa::CFGCollector::processWorkSpace(), otawa::clp::Analysis::processWorkSpace(), and otawa::Processor::recordStat().

template<class T >

void otawa::Processor::addDeletor	(	const AbstractFeature &	feature,
		const Ref< T , Identifier< T > > &	ref
	)

inlineprotectedinherited

Referenced by otawa::Virtualizer::cleanup().

template<class T >

void otawa::Processor::addRemover	(	const AbstractFeature &	feature,
		const Ref< T, Identifier< T > > &	ref
	)

inlineprotectedinherited

Referenced by otawa::Virtualizer::cleanup().

void otawa::GraphBBTime< ParExeGraph >::analyzePathContext	(	PathContext *	ctxt,
		int	context_index
	)

inherited

int otawa::GraphBBTime< ParExeGraph >::analyzeTimingContext	(	ParExeGraph *	graph,
		TimingContext *	NC_ctxt,
		TimingContext *	FM_ctxt
	)

inherited

void otawa::etime::EdgeTimeBuilder::apply	(	Event *	event,
		ParExeInst *	inst
	)

private

Apply the given event to the given instruction.

Parameters

event	Event to apply.
inst	Instruction to apply to.

References _, bedge, otawa::etime::BRANCH, otawa::etime::Event::cost(), otawa::etime::FETCH, otawa::ParExeInst::fetchNode(), getBranchNode(), otawa::etime::Event::kind(), otawa::ParExeNode::latency(), otawa::etime::MEM, otawa::ParExeNode::setLatency(), otawa::ParExeEdge::setLatency(), and otawa::ParExeEdge::SOLID.

Referenced by processSequence().

void otawa::etime::EdgeTimeBuilder::applyFloppySplit ( const config_list_t & confs )

protected

Application of two time approach, LTS and HTS time.

To perform the split, an evaluation function is maximized according the two sets so that:

difference of time in LTS is the lowest,
difference of time between HTS and LTS is the biggest.
a feasible HTS is also a good point,

References all_events, contributeSplit(), edge, events, genForOneCost(), otawa::etime::ConfigSet::isFeasible(), otawa::Monitor::isVerbose(), elm::genstruct::Vector< T >::length(), otawa::Monitor::log, makeSplit(), otawa::etime::maskToString(), otawa::sem::neg(), otawa::etime::ConfigSet::pop(), otawa::etime::ConfigSet::push(), otawa::etime::ConfigSet::scan(), and elm::genstruct::Vector< T >::top().

void otawa::etime::EdgeTimeBuilder::applyStrictSplit ( const config_list_t & confs )

protected

Application of two time approach, LTS and HTS time.

To perform the split, an evaluation function is maximized according the two sets so that:

the HTS is feasible,
difference of time in LTS is the lowest,
difference of time between HTS and LTS is the biggest.

References all_events, contributeSplit(), edge, events, genForOneCost(), hex(), otawa::etime::ConfigSet::isFeasible(), otawa::Monitor::isVerbose(), elm::genstruct::Vector< T >::length(), otawa::Monitor::log, makeSplit(), otawa::etime::maskToString(), otawa::sem::neg(), otawa::etime::ConfigSet::pop(), otawa::etime::ConfigSet::push(), otawa::etime::ConfigSet::scan(), and elm::genstruct::Vector< T >::top().

void otawa::etime::EdgeTimeBuilder::applyWeightedSplit ( const config_list_t & confs )

protected

Performing split by computing an heuristic based on weights of BB and events.

Parameters

confs List of configurations.

References cerr, contributeSplit(), edge, events, otawa::Monitor::isVerbose(), elm::genstruct::Vector< T >::length(), otawa::Monitor::log, otawa::Monitor::LOG_BB, otawa::Monitor::logFor(), makeSplit(), otawa::etime::maskToString(), otawa::clp::max(), otawa::sem::neg(), otawa::etime::ConfigSet::pop(), otawa::etime::ConfigSet::push(), otawa::etime::ConfigSet::scan(), otawa::Edge::target(), elm::genstruct::Vector< T >::top(), and otawa::WEIGHT.

Referenced by processTimes().

virtual void otawa::GraphBBTime< ParExeGraph >::buildFMTimingContextListForICache	(	elm::genstruct::SLList< TimingContext * > *	list,
		ParExeSequence *	seq
	)

protectedvirtualinherited

elm::genstruct::SLList<PathContext > otawa::GraphBBTime< ParExeGraph >::buildListOfPathContexts	(	BasicBlock *	bb,
		int	depth = `1`
	)

inherited

virtual void otawa::GraphBBTime< ParExeGraph >::buildNCTimingContextListForICache	(	elm::genstruct::SLList< TimingContext * > *	list,
		ParExeSequence *	seq
	)

protectedvirtualinherited

ParExeSequence* otawa::GraphBBTime< ParExeGraph >::buildSequence ( PathContext * ctxt )

inherited

virtual void otawa::GraphBBTime< ParExeGraph >::BuildVectorOfHwResources ( )

protectedvirtualinherited

virtual int otawa::GraphBBTime< ParExeGraph >::cacheMissPenalty ( Address addr ) const

protectedvirtualinherited

CFG * otawa::CFGProcessor::cfg ( void ) const

inlineprotectedinherited

Get the current CFG.

Returns: Current CFG.

References otawa::CFGProcessor::_cfg.

Referenced by otawa::DelayedBuilder::fix(), otawa::PSTBuilder::getVCFG(), otawa::ContextualProcessor::processCFG(), otawa::DelayedBuilder::processWorkSpace(), and otawa::CFGProcessor::processWorkSpace().

void otawa::etime::EdgeTimeBuilder::clean ( ParExeGraph * graph )

protectedvirtual

Called to cleanup a graph allocated by a call to make().

Parameters

grap	Graph to clean.

References graph.

void otawa::etime::EdgeTimeBuilder::cleanup ( WorkSpace * ws )

protectedvirtual

This method is called after the end of the processor analysis to let it do some clean up.

Parameters

ws	Workspace to work on.

Reimplemented from otawa::Processor.

References elm::genstruct::Vector< T >::clear(), colls, events, and sys.

void otawa::BBProcessor::cleanupBB	(	WorkSpace *	ws,
		CFG *	cfg,
		BasicBlock *	bb
	)

protectedvirtualinherited

When the function doCleanup() is called, this function is called for each basic block of the task.

As a default do nothing.

Warning: If you override the cleanupCFG() function, do not forget to perform a call to the CFGProcessor original version.

Parameters

ws	Current workspace.
cfg	Current CFG.
bb	Current BB.

Referenced by otawa::BBProcessor::cleanupCFG().

void otawa::BBProcessor::cleanupCFG	(	WorkSpace *	ws,
		CFG *	cfg
	)

protectedvirtualinherited

This function may be overridden by a subclass to provide custom cleanup for a CFG.

It is called for each CFG of the task when doCleanUp() is called. As a default, do nothing.

Parameters

ws	Current workspace.
cfg	Current CFG.

Reimplemented from otawa::CFGProcessor.

References otawa::cfgio::bb(), and otawa::BBProcessor::cleanupBB().

void otawa::Processor::collectStats ( WorkSpace * ws )

protectedvirtualinherited

This method is invoked if the user has required to collect statistics about the processor.

In its default implementation, this method does nothing but it may be customized if the current implementation provides statistics. It is called after the main computation of the processor.

Statistics must be objects inheriting from the class StatCollector and recorded with method recordStat().

Parameters

ws	Current workspace.

Reimplemented in otawa::dcache::CatConstraintBuilder, otawa::ipet::WCETComputation, and otawa::CAT2OnlyConstraintBuilder.

Referenced by otawa::Processor::process().

virtual void otawa::GraphBBTime< ParExeGraph >::computeDefaultTimingContextForICache	(	TimingContext *	dtctxt,
		ParExeSequence *	seq
	)

protectedvirtualinherited

void otawa::etime::EdgeTimeBuilder::configure ( const PropList & props )

protectedvirtual

Configure the current processor.

Parameters

props Configuration properties.

Reimplemented from otawa::GraphBBTime< ParExeGraph >.

References _explicit, otawa::GraphBBTime< G >::configure(), event_th, otawa::etime::EVENT_THRESHOLD, otawa::ipet::EXPLICIT, predump, and otawa::etime::PREDUMP.

virtual void otawa::GraphBBTime< ParExeGraph >::configureMem ( WorkSpace * ws )

inlineprotectedvirtualinherited

References otawa::hard::CACHE_CONFIGURATION, and otawa::hard::MEMORY.

void otawa::etime::EdgeTimeBuilder::contributeConst ( void )

protected

Generate contribution for constant events.

References all_events, otawa::etime::ALWAYS, edge, make(), otawa::etime::NEVER, and otawa::ipet::VAR.

Referenced by contributeSplit(), and genForOneCost().

void otawa::etime::EdgeTimeBuilder::contributeSplit	(	const config_list_t &	confs,
		t::uint32	pos,
		t::uint32	neg,
		t::uint32	com,
		ot::time	lts_time,
		ot::time	hts_time
	)

protected

Contribute to WCET estimation in split way, x_HTS and x_LTS, with two sets of times.

Parameters

confs	Time configuration.
p	Position of split.

References _explicit, otawa::ilp::Constraint::addLeft(), otawa::ilp::System::addObjectFunction(), otawa::ilp::Constraint::addRight(), buf, otawa::BasicBlock::cfg(), contributeConst(), elm::genstruct::Vector< T >::count(), edge, events, otawa::ilp::Constraint::GE, otawa::CFG::label(), otawa::ilp::Constraint::LE, elm::genstruct::Vector< T >::length(), make(), otawa::ilp::System::newConstraint(), otawa::ilp::System::newVar(), otawa::BasicBlock::number(), source, sys, target, elm::StringBuffer::toString(), and otawa::ipet::VAR.

Referenced by applyFloppySplit(), applyStrictSplit(), and applyWeightedSplit().

int otawa::etime::EdgeTimeBuilder::countVarEvents ( const event_list_t & events )

private

Count the number of variable events in the event list.

Parameters

events Event list to process.

Returns: Number of variable events.

References elm::genstruct::Vector< T >::length(), and otawa::etime::SOMETIMES.

Referenced by processEdge().

void otawa::etime::EdgeTimeBuilder::displayConfs	(	const genstruct::Vector< ConfigSet > &	confs,
		const event_list_t &	events
	)

private

Display the list of configuration sorted by cost.

Parameters

confs List of configuration to display.

References elm::genstruct::Vector< T >::length(), and otawa::Monitor::log.

Referenced by processSequence().

void otawa::CFGProcessor::doCleanUp ( void )

protectedinherited

Trigger associated with CFG.

For each CFG, perform a call to cleanupCFG() that may be customized by a subclass.

References otawa::CFGProcessor::cleanupCFG(), otawa::CFGCollection::count(), otawa::CFGCollection::get(), otawa::INVOLVED_CFGS, and otawa::Processor::workspace().

void otawa::GraphBBTime< ParExeGraph >::FillSequence	(	PathContext *	ctxt,
		elm::genstruct::SLList< PathContext * > *	context_list,
		int	depth
	)

inherited

void otawa::etime::EdgeTimeBuilder::genForOneCost	(	ot::time	cost,
		Edge *	edge,
		event_list_t &	events
	)

private

Generate the constraints when only one cost is considered for the edge.

Parameters

cost	Edge cost.
edge	Current edge.
events	List of edge events.

References otawa::ilp::System::addObjectFunction(), contributeConst(), otawa::Monitor::log, otawa::Monitor::LOG_BB, otawa::Monitor::logFor(), make(), otawa::etime::SOMETIMES, sys, and otawa::ipet::VAR.

Referenced by applyFloppySplit(), applyStrictSplit(), and processSequence().

EventCollector * otawa::etime::EdgeTimeBuilder::get ( Event * event )

private

Get the collector for the given event.

If it doesn't exist, create it.

Parameters

event Concerned event.

Returns: Matching collector (never null).

References colls.

ParExeNode * otawa::etime::EdgeTimeBuilder::getBranchNode ( void )

private

Get the branch node resolving a branch prediction.

Returns: Node of resolution.

References bnode, otawa::BasicBlock::controlInst(), seq, and source.

Referenced by apply().

void otawa::Processor::invalidate ( const AbstractFeature & feature )

protectedinherited

Usually called from a processor constructor, this method records a feature invalidated by the work of the current processor.

Parameters

feature Invalidated feature.

References otawa::Processor::_reg, otawa::AbstractRegistration::features, otawa::Monitor::flags, otawa::FeatureUsage::invalidate, otawa::Processor::IS_ALLOCATED, otawa::Processor::isAllocated(), and otawa::Processor::isPrepared().

Referenced by otawa::LoopReductor::LoopReductor().

bool otawa::Processor::isAllocated ( void ) const

inlineprotectedinherited

References flags.

Referenced by otawa::Processor::invalidate(), otawa::Processor::provide(), otawa::Processor::require(), and otawa::Processor::use().

bool otawa::Processor::isCollectingStats ( void ) const

inlineprotectedinherited

References flags.

Referenced by otawa::Processor::process(), and otawa::Processor::recordStat().

bool otawa::Processor::isPrepared ( void ) const

inlineprotectedinherited

References flags.

Referenced by otawa::Processor::invalidate(), otawa::Processor::process(), otawa::Processor::provide(), otawa::Processor::require(), and otawa::Processor::use().

bool otawa::Processor::isTimed ( void ) const

inlineprotectedinherited

Test if the timed mode is activated (recording of timings in the statistics).

Returns: True if timed mode is activated, false else.

Note: If statistics are not activated, this method returns ever false.

References flags.

Referenced by otawa::Processor::process().

bool otawa::Monitor::isVerbose ( void ) const

inlineinherited

Test if the verbosity is activated.

Returns: True if verbosity is activated, false else.

References flags.

Referenced by otawa::ccg::LBlockBuilder::addLBlock(), otawa::LBlockBuilder::addLBlock(), applyFloppySplit(), applyStrictSplit(), applyWeightedSplit(), makeSplit(), processSequence(), and otawa::dcache::BlockBuilder::setup().

bool otawa::Monitor::logFor ( log_level_t tested ) const

inlineinherited

Test if the given log level is activated or not.

Parameters

tested Tested log level.

Returns: True if the log level is activated, false else.

log_level_t otawa::Monitor::logLevel ( void ) const

inlineinherited

Referenced by otawa::script::Script::declareGlobals().

ParExeGraph * otawa::etime::EdgeTimeBuilder::make ( ParExeSequence * seq )

protectedvirtual

This method is called to build the parametric execution graph.

As a default, build a usual ParExeGraph but it may be overridden to build a custom graph.

Parameters

seq	Sequence to build graph for.

Returns: Built graph.

References otawa::GraphBBTime< ParExeGraph >::_hw_resources, otawa::GraphBBTime< ParExeGraph >::_microprocessor, otawa::ParExeGraph::build(), graph, and otawa::Processor::workspace().

Referenced by contributeConst(), contributeSplit(), genForOneCost(), and processSequence().

EventCollector::case_t otawa::etime::EdgeTimeBuilder::make	(	const Event *	e,
		EdgeTimeBuilder::place_t	place,
		bool	on
	)

staticprotected

Build an event selector case.

References otawa::etime::EventCollector::BLOCK_OFF, otawa::etime::EventCollector::BLOCK_ON, otawa::etime::EDGE, IN_BLOCK, IN_EDGE, IN_PREFIX, otawa::etime::EventCollector::PREFIX_OFF, otawa::etime::EventCollector::PREFIX_ON, and otawa::etime::Event::type().

void otawa::etime::EdgeTimeBuilder::makeSplit	(	const config_list_t &	confs,
		int	p,
		ConfigSet &	hts,
		ot::time &	lts_time,
		ot::time &	hts_time
	)

protected

Build the set after split.

Parameters

confs	Current configuration.
p	Split position.
hts	HTS result set.
lts_time	LTS time.
hts_time	HTS time.

References otawa::etime::ConfigSet::add(), events, otawa::Monitor::isVerbose(), elm::genstruct::Vector< T >::length(), otawa::Monitor::log, and elm::genstruct::Vector< T >::top().

Referenced by applyFloppySplit(), applyStrictSplit(), and applyWeightedSplit().

virtual int otawa::GraphBBTime< ParExeGraph >::memoryLatency ( Address addr ) const

protectedvirtualinherited

elm::String otawa::Processor::name ( void ) const

inlineinherited

Referenced by otawa::CFGCollector::configure(), otawa::display::ILPSystemDisplayer::displayVar(), otawa::etime::StandardEventBuilder::handleVariableBranchPred(), otawa::script::Script::makeConfig(), otawa::DynProcessor::name(), otawa::display::ILPSystemDisplayer::nameOf(), otawa::FlowFactLoader::onCheckSum(), otawa::Processor::process(), otawa::ccg::ConstraintBuilder::processLBlockSet(), otawa::Processor::Processor(), otawa::ipet::WCETComputation::processWorkSpace(), otawa::dcache::CatConstraintBuilder::processWorkSpace(), otawa::CFGCollector::processWorkSpace(), otawa::FlowFactLoader::scanIgnoreEntry(), otawa::FlowFactLoader::scanMemSet(), otawa::FlowFactLoader::scanRegSet(), otawa::Processor::warn(), and otawa::script::Script::work().

void otawa::GraphBBTime< ParExeGraph >::outputGraph	(	ParExeGraph *	graph,
		int	bb_number,
		int	context_number,
		int	case_number,
		const string &	info = `""`
	)

inherited

Output the given graph in the directory configured by GRAPHS_OUTPUT_DIRECTORY.

The name of the file is formed by the concatenation of:

"b" bb_number "-ctxt" context_index "-case" case_index ".dot";

Parameters

graph	Graph to output.
bb_number	Basic number.
context_index	Index of the context.
case_index	Index of case.
info	Information to display in the graph.

Referenced by processSequence().

void otawa::Processor::prepare ( WorkSpace * ws )

protectedvirtualinherited

This method called to let the processor customize its requirements according to some generic feature.

When overload, the original method MUST be called at the end of the custom overriding implementation.

Parameters

ws	Current workspace.

References otawa::Monitor::flags, and otawa::Processor::IS_PREPARED.

Referenced by otawa::Processor::process().

void otawa::Processor::process	(	WorkSpace *	fw,
		const PropList &	props = `PropList::EMPTY`
	)

inherited

Execute the code processor on the given framework.

Parameters

fw	Workspace to work on.
props	Configuration properties.

Referenced by otawa::PFGBuilder::finalizeBB(), otawa::WorkSpace::getCFGInfo(), otawa::FlowFactLoader::onIgnoreEntry(), otawa::SilentFeature::process(), otawa::ActualFeature::process(), otawa::DynProcessor::process(), otawa::Feature< T, C >::process(), otawa::p::feature::process(), otawa::TextDecoder::processWorkSpace(), otawa::cat::CATBuilder::processWorkSpace(), and otawa::DelayedBuilder::setup().

void otawa::etime::EdgeTimeBuilder::processBB	(	WorkSpace *	ws,
		CFG *	cfd,
		BasicBlock *	bb
	)

protectedvirtual

Perform the work of the given basic block.

Parameters

fw	Container framework.
cfg	Parent CFG.
bb	Basic block to process.

Implements otawa::BBProcessor.

References edge, in, otawa::BasicBlock::isEnd(), and processEdge().

void otawa::BBProcessor::processCFG	(	WorkSpace *	ws,
		CFG *	cfg
	)

protectedvirtualinherited

See CFGProcessor::processCFG()

Implements otawa::CFGProcessor.

Reimplemented in otawa::BBRatioDisplayer, otawa::CFGSaver, otawa::CFGChecker, and otawa::cfgio::Output.

References otawa::ot::address(), otawa::cfgio::bb(), otawa::Monitor::log, otawa::Monitor::LOG_BB, otawa::Monitor::logFor(), and otawa::BBProcessor::processBB().

Referenced by otawa::cfgio::Output::processCFG(), otawa::CFGChecker::processCFG(), otawa::CFGSaver::processCFG(), and otawa::BBRatioDisplayer::processCFG().

void otawa::etime::EdgeTimeBuilder::processEdge	(	WorkSpace *	ws,
		CFG *	cfg
	)

protectedvirtual

void otawa::Processor::processFrameWork ( WorkSpace * fw )

protectedvirtualinherited

Process the given workspace.

Parameters

fw	Workspace to process.

Deprecated:: Use processWorkSpace() instead.

Referenced by otawa::Processor::processWorkSpace().

void otawa::etime::EdgeTimeBuilder::processSequence ( void )

protectedvirtual

Compute and process the time for the given sequence.

References _, otawa::GraphBBTime< ParExeGraph >::_do_output_graphs, elm::genstruct::Vector< T >::add(), all_events, otawa::etime::ALWAYS, otawa::ParExeGraph::analyze(), apply(), otawa::BLOCK, elm::genstruct::Vector< T >::clear(), elm::genstruct::Vector< T >::count(), displayConfs(), edge, events, otawa::ParExeGraph::firstNode(), genForOneCost(), graph, IN_PREFIX, otawa::etime::Event::inst(), elm::genstruct::Vector< T >::isEmpty(), otawa::Monitor::isVerbose(), elm::genstruct::Vector< T >::length(), otawa::Monitor::log, otawa::Monitor::LOG_BB, otawa::Monitor::logFor(), make(), otawa::etime::NEVER, otawa::BasicBlock::number(), otawa::etime::Event::occurrence(), otawa::GraphBBTime< ParExeGraph >::outputGraph(), predump, processTimes(), rollback(), seq, otawa::etime::SOMETIMES, source, and target.

Referenced by processEdge().

void otawa::etime::EdgeTimeBuilder::processTimes ( const config_list_t & confs )

protected

Process the computed time and generate associated objective functions and constraints.

References applyWeightedSplit().

Referenced by processSequence().

void otawa::GraphBBTime< ParExeGraph >::processWorkSpace ( WorkSpace * ws )

virtualinherited

Process the given framework.

Parameters

fw	Framework to process.

Deprecated:: Use processWorkSpace() instead.

Reimplemented from otawa::CFGProcessor.

Progress & otawa::Processor::progress ( void )

inlineprotectedinherited

Get the current progress handler.

Returns: Progress handler.

void otawa::Processor::provide ( const AbstractFeature & feature )

protectedinherited

Usually called from a processor constructor, this method records a feature provided by the work of the current processor.

Parameters

feature Provided feature.

References otawa::Processor::_reg, otawa::AbstractRegistration::features, otawa::Monitor::flags, otawa::Processor::IS_ALLOCATED, otawa::Processor::isAllocated(), otawa::Processor::isPrepared(), and otawa::FeatureUsage::provide.

Referenced by otawa::ipet::BasicConstraintsBuilder::BasicConstraintsBuilder(), otawa::CFGBuilder::CFGBuilder(), otawa::CFGCheckSummer::CFGCheckSummer(), otawa::CFGCollector::CFGCollector(), otawa::CFGNormalizer::CFGNormalizer(), otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::DeadCodeAnalysis::DeadCodeAnalysis(), otawa::Dominance::Dominance(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), otawa::EdgeCAT2ConstraintBuilder::EdgeCAT2ConstraintBuilder(), otawa::ExeGraphBBTime< G >::ExeGraphBBTime(), otawa::FirstLastBuilder::FirstLastBuilder(), otawa::ipet::FlowFactConstraintBuilder::FlowFactConstraintBuilder(), otawa::ipet::ILPSystemGetter::ILPSystemGetter(), otawa::LoopReductor::LoopReductor(), otawa::PCGBuilder::PCGBuilder(), otawa::PFGBuilder::PFGBuilder(), otawa::PostDominance::PostDominance(), otawa::PSTBuilder::PSTBuilder(), otawa::TextDecoder::TextDecoder(), otawa::ipet::TrivialDataCacheManager::TrivialDataCacheManager(), and otawa::VarTextDecoder::VarTextDecoder().

bool otawa::Processor::recordsStats ( void ) const

inlineprotectedinherited

Test if the statictics mode is activated.

Returns: True if the statistics mode is activated, false else.

Referenced by otawa::Processor::init(), otawa::Processor::process(), and otawa::CFGProcessor::processWorkSpace().

void otawa::Processor::recordStat	(	const AbstractFeature &	feature,
		StatCollector *	collector
	)

protectedinherited

Add a statistics collector to the current workspace collection.

The statistics object is tracked and linked to the feature. In case of the feature invalidation, the statistics information instance is purged of the statistics collector.

Parameters

feature	Feature to link the collector to.
collector	Statistics collector to add.

References otawa::StatInfo::add(), otawa::Processor::addCleaner(), otawa::Processor::isCollectingStats(), and otawa::Processor::workspace().

Referenced by otawa::CAT2OnlyConstraintBuilder::collectStats(), otawa::ipet::WCETComputation::collectStats(), and otawa::dcache::CatConstraintBuilder::collectStats().

void otawa::Processor::require ( const AbstractFeature & feature )

protectedinherited

Usually called from a processor constructor, this method records a required feature for the work of the current processor.

Parameters

feature Required feature.

References otawa::Processor::_reg, otawa::AbstractRegistration::features, otawa::Monitor::flags, otawa::Processor::IS_ALLOCATED, otawa::Processor::isAllocated(), otawa::Processor::isPrepared(), and otawa::FeatureUsage::require.

Referenced by otawa::ipet::BasicConstraintsBuilder::BasicConstraintsBuilder(), otawa::CFGBuilder::CFGBuilder(), otawa::CFGCollector::CFGCollector(), otawa::CFGNormalizer::CFGNormalizer(), otawa::ContextTreeBuilder::ContextTreeBuilder(), otawa::ContextTreeByCFGBuilder::ContextTreeByCFGBuilder(), otawa::ContextualProcessor::ContextualProcessor(), otawa::DeadCodeAnalysis::DeadCodeAnalysis(), otawa::EdgeACSBuilder::EdgeACSBuilder(), otawa::EdgeCAT2Builder::EdgeCAT2Builder(), otawa::EdgeCAT2ConstraintBuilder::EdgeCAT2ConstraintBuilder(), otawa::FirstLastBuilder::FirstLastBuilder(), otawa::ipet::FlowFactConstraintBuilder::FlowFactConstraintBuilder(), otawa::LinkedBlocksDetector::LinkedBlocksDetector(), otawa::LoopReductor::LoopReductor(), otawa::PCGBuilder::PCGBuilder(), otawa::PFGBuilder::PFGBuilder(), otawa::PSTBuilder::PSTBuilder(), otawa::FeatureRequirer::require(), otawa::TextDecoder::TextDecoder(), otawa::ipet::TrivialDataCacheManager::TrivialDataCacheManager(), and otawa::script::Script::work().

void otawa::Processor::requireDyn	(	WorkSpace *	ws,
		const PropList &	props
	)

protectedvirtualinherited

Method called after registration requirements to support dynamic requirements.

As a default, do nothing.

Parameters

ws	Current workspace.
props	Current properties.

genstruct::Vector<Resource *>* otawa::etime::EdgeTimeBuilder::ressources ( void )

inlineprotected

References otawa::GraphBBTime< ParExeGraph >::_hw_resources.

void otawa::etime::EdgeTimeBuilder::rollback	(	Event *	event,
		ParExeInst *	inst
	)

private

Rollback the given event to the given instruction.

Parameters

event	Event to apply.
inst	Instruction to apply to.

References _, bedge, otawa::etime::BRANCH, cerr, otawa::etime::FETCH, otawa::ParExeInst::fetchNode(), graph, otawa::etime::Event::kind(), otawa::ParExeNode::latency(), otawa::etime::MEM, otawa::GenGraph< N, E >::remove(), and otawa::ParExeNode::setLatency().

Referenced by processSequence().

void otawa::etime::EdgeTimeBuilder::setup ( WorkSpace * ws )

protectedvirtual

This method is called before an anlysis to let the processor do some initialization.

Parameters

ws	Processed workspace.

Reimplemented from otawa::Processor.

References sys, and otawa::ipet::SYSTEM.

void otawa::Monitor::setWorkspace ( WorkSpace * workspace )

inlineprotectedinherited

Set the current workspace.

Parameters

workspace New current workspace.

void otawa::etime::EdgeTimeBuilder::sortEvents	(	event_list_t &	events,
		BasicBlock *	bb,
		place_t	place,
		Edge *	edge = `0`
	)

private

Sort events according the instructions they apply to.

Parameters

events	Data structure to store events to.
bb	BasicBlock to look events in.
place	Place in the sequence.
edge	Edge events to include.

References otawa::etime::EVENT, IN_EDGE, elm::pair(), and elm::genstruct::Vector< T >::push().

Referenced by processEdge().

int otawa::etime::EdgeTimeBuilder::splitConfs	(	const config_list_t &	confs,
		const event_list_t &	events,
		bool &	lower
	)

private

Partition the configuration times in two sets: configuration times in [0, p[ are the low time set (LTS) and the configuration times in [p, ...] are the high time set (HTS).

Parameters

confs	Configuration set to find partition for.
events	List of events.

Returns: Position of partition in confs.

References otawa::etime::ConfigSet::isFeasible(), elm::genstruct::Vector< T >::length(), otawa::etime::ConfigSet::pop(), and otawa::etime::ConfigSet::push().

string otawa::CFGProcessor::str ( const Address & address )

protectedinherited

Transform an address to a smart string, that is, if a source line is available, transform it to "source_file:source_line", if the CFG has a label, it gives "label + 0xoffset", else return the address.

Parameters

address Address to display.

Returns: Address transformed in string.

References otawa::Address::null.

Referenced by otawa::ipet::FlowFactLoader::processBB().

string otawa::CFGProcessor::str	(	const Address &	base,
		const Address &	address
	)

protectedinherited

Transform an address to a smart string, that is, if a source line is available, transform it to "source_file:source_line", if the CFG has a label, it gives "label + 0xoffset", else return the address.

Parameters

base	Base address of the function containing the give address.
address	Address to display.

Returns: Address transformed in string.

References _, otawa::CFGProcessor::_cfg, otawa::ProgItem::address(), otawa::ot::address(), otawa::WorkSpace::findInstAt(), otawa::CFG::firstInst(), otawa::FUNCTION_LABEL, hex(), otawa::Address::isNull(), otawa::Address::offset(), and otawa::Processor::workspace().

template<class T >

T* otawa::Processor::track	(	const AbstractFeature &	feature,
		T *	object
	)

inlineprotectedinherited

Referenced by otawa::SubCFGBuilder::cleanup(), otawa::DelayedBuilder::cleanup(), and otawa::CFGBuilder::processWorkSpace().

template<class T >

void otawa::Processor::track	(	const AbstractFeature &	feature,
		const Ref< T , Identifier< T > > &	ref
	)

inlineprotectedinherited

Track the release of an allocated object assigned to an identifier relatively to the given feature.

When the feature is deleted, the object is fried and the identifier is removed. It is used as below:

track(MY_FEATURE, MY_ID(props) = value);

Parameters

feature	Linked feature.
ref	Reference to the identifier to remove.

template<class T >

void otawa::Processor::track	(	const AbstractFeature &	feature,
		const Ref< T , const Identifier< T > > &	ref
	)

inlineprotectedinherited

Track the release of an allocated object assigned to an identifier relatively to the given feature.

When the feature is deleted, the object is fried and the identifier is removed. It is used as below:

track(MY_FEATURE, MY_ID(props) = value);

Parameters

feature	Linked feature.
ref	Reference to the identifier to remove.

template<class T >

void otawa::BBProcessor::trackBB	(	const AbstractFeature &	feature,
		const Identifier< T * > &	id
	)

inlineprotectedinherited

Track and delete the content of the given identifier on each basic block.

Parameters

feature	Feature this identifier is linked to.
id	Identifier of the properties to remove.

template<class T >

void otawa::BBProcessor::trackBB	(	const AbstractFeature &	feature,
		const Identifier< T > &	id
	)

inlineprotectedinherited

Track and remove properties put on basic blocks.

Parameters

feature	Feature this identifier is linked to.
id	Identifier of the properties to remove.

void otawa::Processor::use ( const AbstractFeature & feature )

protectedinherited

Usually called from a processor constructor, this method records a feature as used by the work of the current processor.

Parameters

feature Used feature.

References otawa::Processor::_reg, otawa::AbstractRegistration::features, otawa::Monitor::flags, otawa::Processor::IS_ALLOCATED, otawa::Processor::isAllocated(), otawa::Processor::isPrepared(), and otawa::FeatureUsage::use.

elm::Version otawa::Processor::version ( void ) const

inlineinherited

Referenced by otawa::Processor::process(), otawa::Processor::Processor(), otawa::DynProcessor::version(), and otawa::Processor::warn().

void otawa::Processor::warn ( const String & message )

protectedinherited

Display a warning.

Parameters

message Message to display.

References otawa::Monitor::log, otawa::Processor::name(), and otawa::Processor::version().

Referenced by otawa::CFGBuilder::addFile(), otawa::CFGBuilder::buildCFG(), otawa::VarTextDecoder::getInst(), otawa::FlowFactLoader::load(), otawa::FlowFactLoader::onWarning(), otawa::ets::FlowFactLoader::processAST(), otawa::ipet::FlowFactLoader::processBB(), otawa::CFGChecker::processBB(), otawa::ipet::FlowFactConstraintBuilder::processBB(), otawa::etime::StandardEventBuilder::processBB(), otawa::CFGNormalizer::processCFG(), otawa::CFGChecker::processCFG(), otawa::VarTextDecoder::processEntry(), otawa::VarTextDecoder::processWorkSpace(), otawa::FixedTextDecoder::processWorkSpace(), otawa::CFGCollector::processWorkSpace(), otawa::FlowFactLoader::processWorkSpace(), otawa::Processor::processWorkSpace(), otawa::ipet::TrivialInstCacheManager::setup(), and otawa::script::Script::work().

WorkSpace * otawa::Monitor::workspace ( void )

inlineinherited

Get the current workspace.

Returns: Current workspace.

WorkSpace * otawa::Processor::workspace ( void ) const

inlineprotectedinherited

Get the current workspace.

Returns: Current workspace.

Referenced by otawa::CFGProcessor::doCleanUp(), otawa::PFGBuilder::finalizeBB(), otawa::VarTextDecoder::getBytes(), otawa::etime::StandardEventBuilder::handleVariableBranchPred(), otawa::ipet::FlowFactLoader::lookLineAt(), make(), otawa::DelayedBuilder::makeNOp(), otawa::DelayedBuilder::next(), otawa::FlowFactLoader::onIgnoreEntry(), otawa::VarTextDecoder::processEntry(), otawa::Processor::recordStat(), otawa::DelayedBuilder::setup(), otawa::DelayedBuilder::size(), and otawa::CFGProcessor::str().

Member Data Documentation

bool otawa::GraphBBTime< ParExeGraph >::_do_consider_icache

protectedinherited

bool otawa::GraphBBTime< ParExeGraph >::_do_output_graphs

protectedinherited

Referenced by processSequence().

bool otawa::etime::EdgeTimeBuilder::_explicit

private

Referenced by configure(), and contributeSplit().

elm::genstruct::Vector<Resource *> otawa::GraphBBTime< ParExeGraph >::_hw_resources

protectedinherited

Referenced by make(), and ressources().

ParExeProc* otawa::GraphBBTime< ParExeGraph >::_microprocessor

protectedinherited

Referenced by make().

genstruct::Vector<event_t> otawa::etime::EdgeTimeBuilder::all_events

private

Referenced by applyFloppySplit(), applyStrictSplit(), contributeConst(), processEdge(), and processSequence().

ParExeEdge* otawa::etime::EdgeTimeBuilder::bedge

private

Referenced by apply(), and rollback().

ParExeNode* otawa::etime::EdgeTimeBuilder::bnode

private

Referenced by getBranchNode(), and processEdge().

Identifier< bool > otawa::Processor::COLLECT_STATS

staticinherited

This property allows to activate collection of statistics for the work of the current processor.

See also: StatInfo class.

Referenced by otawa::Processor::init().

genstruct::HashTable<Event *, EventCollector *> otawa::etime::EdgeTimeBuilder::colls

private

Referenced by cleanup(), and get().

const t::uint32 otawa::Monitor::CUSTOM_SHIFT = 16

staticprotectedinherited

Edge* otawa::etime::EdgeTimeBuilder::edge

private

Referenced by applyFloppySplit(), applyStrictSplit(), applyWeightedSplit(), contributeConst(), contributeSplit(), processBB(), processEdge(), and processSequence().

int otawa::etime::EdgeTimeBuilder::event_th

private

Referenced by configure(), and processEdge().

event_list_t otawa::etime::EdgeTimeBuilder::events

private

Referenced by applyFloppySplit(), applyStrictSplit(), applyWeightedSplit(), cleanup(), contributeSplit(), makeSplit(), processEdge(), and processSequence().

t::uint32 otawa::Monitor::flags

protectedinherited

Contains various bit flags.

Bits from 0 to CUSTOM_SHIFT - 1 are private while bits from CUSTOM_SHIFT to 31 may be customized. To build a bit mask for custom bit i, the CUSTOM_SHIFT may be used as below:

static const t::uint32 MY_MASK = 1 << (i + CUSTOM_SHIFT);

Referenced by otawa::Processor::init(), otawa::Processor::invalidate(), otawa::Processor::prepare(), otawa::Processor::Processor(), otawa::Processor::provide(), otawa::Processor::require(), otawa::Processor::use(), and otawa::Processor::~Processor().

ParExeGraph* otawa::etime::EdgeTimeBuilder::graph

private

Referenced by clean(), make(), processSequence(), and rollback().

const hard::Cache* otawa::GraphBBTime< ParExeGraph >::icache

protectedinherited

const t::uint32 otawa::Processor::IS_ALLOCATED = 0x04 << CUSTOM_SHIFT

staticprotectedinherited

Referenced by otawa::Processor::invalidate(), otawa::Processor::Processor(), otawa::Processor::provide(), otawa::Processor::require(), otawa::Processor::use(), and otawa::Processor::~Processor().

const t::uint32 otawa::Processor::IS_COLLECTING = 0x10 << CUSTOM_SHIFT

staticprotectedinherited

Referenced by otawa::Processor::init().

const t::uint32 otawa::Processor::IS_PREPARED = 0x08 << CUSTOM_SHIFT

staticprotectedinherited

Referenced by otawa::Processor::prepare().

const t::uint32 otawa::Processor::IS_TIMED = 0x01 << CUSTOM_SHIFT

staticprotectedinherited

Referenced by otawa::Processor::init().

const t::uint32 otawa::Monitor::IS_VERBOSE = 0x01

staticprotectedinherited

elm::io::Output otawa::Monitor::log

inherited

Provide a stream to perform log output.

Should be used only when verbosity is activated.

Identifier< elm::io::OutStream * > & otawa::Processor::LOG = otawa::LOG

staticinherited

This property identifier is used for setting the log stream used by the processor to write messages (information, warning, error).

Deprecated:

Referenced by otawa::Processor::init(), otawa::Manager::loadBin(), and otawa::LiExeGraphBBTime::processBB().

Identifier< Processor::log_level_t > & otawa::Processor::LOG_LEVEL = otawa::LOG_LEVEL

staticinherited

Property passed in the configuration property list of a processor to select the log level between LOG_PROC, LOG_CFG or LOG_BB.

Deprecated:

Referenced by otawa::Application::run().

const hard::Memory* otawa::GraphBBTime< ParExeGraph >::mem

protectedinherited

Monitor & otawa::Monitor::null = __null_mon

staticinherited

Monitor that output nothing.

elm::io::Output otawa::Monitor::out

inherited

Provide a stream to perform output for the user.

Referenced by otawa::DelayedBuilder::buildEdges(), otawa::etime::StandardEventBuilder::handleVariableBranchPred(), otawa::Processor::init(), otawa::ast::ASTLoader::onError(), otawa::CFGChecker::processBB(), otawa::etime::StandardEventBuilder::processBB(), otawa::hard::Dumper::processWorkSpace(), otawa::ccg::Builder::processWorkSpace(), and otawa::Virtualizer::virtualize().

Identifier< elm::io::OutStream * > & otawa::Processor::OUTPUT = otawa::OUTPUT

staticinherited

This property identifier is used for setting the output stream used by the processor to write results.

Deprecated:

Referenced by otawa::Processor::init().

bool otawa::etime::EdgeTimeBuilder::predump

private

Referenced by configure(), and processSequence().

Identifier< Progress * > otawa::Processor::PROGRESS

staticinherited

Install.

Referenced by otawa::Processor::init().

Identifier<bool> otawa::Processor::RECURSIVE

staticinherited

p::declare otawa::etime::EdgeTimeBuilder::reg

static

Initial value:

= p::init("otawa::etime::EdgeTimeBuilder", Version(1, 0, 0))
        .base(GraphBBTime<ParExeGraph>::reg)
        .maker<EdgeTimeBuilder>()
        .require(ipet::ASSIGNED_VARS_FEATURE)
        .require(ipet::ILP_SYSTEM_FEATURE)
        .require(WEIGHT_FEATURE)
        .require(EVENTS_FEATURE)
        .provide(ipet::OBJECT_FUNCTION_FEATURE)
        .provide(EDGE_TIME_FEATURE)