OperationDAGBehavior Class Reference

#include <OperationDAGBehavior.hh>

Inheritance diagram for OperationDAGBehavior:

Collaboration diagram for OperationDAGBehavior:

Classes
struct	SimulationStep

Public Member Functions
	OperationDAGBehavior (OperationDAG &dag, int operandCount, const Operation &parent=NullOperation::instance())
virtual	~OperationDAGBehavior ()
virtual bool	simulateTrigger (SimValue **io, OperationContext &context) const override
virtual bool	areValid (const InputOperandVector &inputs, const OperationContext &context) const override
virtual bool	lateResult (SimValue **io, OperationContext &context) const
virtual void	createState (OperationContext &context) const override
virtual void	deleteState (OperationContext &context) const override
virtual const char *	stateName () const override
virtual bool	canBeSimulated () const override
Public Member Functions inherited from OperationBehavior
virtual void	writeOutput (const char *text) const
	OperationBehavior ()
	OperationBehavior (const Operation &parent)
virtual	~OperationBehavior ()

Private Attributes
OperationDAG &	dag_
int	operandCount_
	Number of operands of this operation.
SimValue *	ios_
	Table of parameters for simulate trigger.
std::vector< SimulationStep >	simulationSteps_
std::vector< SimValue * >	cleanUpTable_
	Contain list of pointers to delete in destructor.
bool	cycleFound_
	For checking if there is cyclic dependency in DAG.

Additional Inherited Members
Public Types inherited from OperationBehavior
typedef std::vector< SimValue >	InputOperandVector
	Input operand type for areValid()
Protected Attributes inherited from OperationBehavior
const Operation &	parent_

Detailed Description

Implementation of OperationBehavior which uses OperationDAG for execution of operation.

Definition at line 54 of file OperationDAGBehavior.hh.

Constructor & Destructor Documentation

OperationDAGBehavior()

OperationDAGBehavior::OperationDAGBehavior	(	OperationDAG &	dag,
		int	operandCount,
		const Operation &	parent = NullOperation::instance()
	)

Initilized class to be easier to simulate.

Basically goes through DAG and schedules operation nodes to calculation levels.

Definition at line 53 of file OperationDAGBehavior.cc.

                                                                  :
    OperationBehavior(parent), dag_(dag), operandCount_(operandCount),
    cycleFound_(false) {
  
    ios_ = new SimValue[operandCount_];
    
    std::vector<std::set<OperationDAGNode*, OperationDAGNode::Comparator> > 
        nodeLevels;
    std::set<OperationDAGNode*, OperationDAGNode::Comparator> addedNodes;
    
    // organize all the nodes calculation levels, in first level we calculate
    // nodes whose inputs are read straight from TerminalNodes or 
    // ConstantNodes, in the second are added nodes whose inputs are read 
    // from TerminalNodes or first level nodes etc.
    while (static_cast<int>(addedNodes.size()) < dag_.nodeCount()) {
        std::set<OperationDAGNode*, OperationDAGNode::Comparator> currSet;
                       
        for (int i = 0; i < dag_.nodeCount(); i++) {
            OperationDAGNode& currNode = dag_.node(i);
            
            // check if the node is already handled
            if (addedNodes.find(&currNode) != addedNodes.end()) {
                continue;
            }            
            
            // if node doesn't have in edges it can always be added
            bool canBeAddedToCurrentLevel = true;
 
            for (int j = 0; j < dag_.inDegree(currNode); j++) {
                OperationDAGNode& parentNode = 
                    dag_.tailNode(dag_.inEdge(currNode, j));
                                                              
                // find node from previous levels
                bool wasFound = false;
                for (unsigned int k = 0; k < nodeLevels.size(); k++) {
                    if (nodeLevels[k].find(&parentNode) != 
                        nodeLevels[k].end()) {
                        wasFound = true;
                        break;
                    }
                }
             
                // it was not found... too bad.
                if (!wasFound) {
                    canBeAddedToCurrentLevel = false;
                }
            }
            
            // current level is ok for currently checked node
            if (canBeAddedToCurrentLevel) {
                currSet.insert(&currNode);
                addedNodes.insert(&currNode);
            }
        }
                
        nodeLevels.push_back(currSet);
        currSet.clear();
    }
    
    // create execution steps for all operation nodes and add them to
    // executionStep table
    std::map<OperationNode*, int> stepOfNode;
 
    for (unsigned int i = 0; i < nodeLevels.size(); i++) {
        for (std::set<OperationDAGNode*,OperationDAGNode::Comparator>::
                 iterator nodeIter = 
                 nodeLevels[i].begin(); nodeIter != nodeLevels[i].end();
             nodeIter++) {
            
            OperationNode* opNode = dynamic_cast<OperationNode*>(*nodeIter);
            
            if (opNode != NULL) {
                SimulationStep step;
                step.op = &opNode->referencedOperation();
                
                step.params = 
                    new SimValue*[step.op->numberOfInputs() + 
                                  step.op->numberOfOutputs()];
                
                // set input variables
                for (int j = 0; j < dag_.inDegree(*opNode); j++) {
                    OperationDAGEdge* currEdge = &dag_.inEdge(*opNode, j);
                    OperationDAGNode* paramNode = &(dag_.tailNode(*currEdge));
                    
                    TerminalNode* termNode = 
                        dynamic_cast<TerminalNode*>(paramNode);
                    
                    OperationNode* operNode = 
                        dynamic_cast<OperationNode*>(paramNode);
                    
                    ConstantNode* constNode = 
                        dynamic_cast<ConstantNode*>(paramNode);
                    
                    if (termNode != NULL) {
                        // if terminal node, read stuff from ios_ table
                        step.params[currEdge->dstOperand() - 1] = 
                            &ios_[termNode->operandIndex() - 1];
                        
                    } else if (constNode != NULL) {
                        // if constant node, read constant to SimValue
                        // and give it to operation
                        SimValue* newVal = new SimValue();
                        *newVal = constNode->value();
                        cleanUpTable_.push_back(newVal);
                        step.params[currEdge->dstOperand() - 1] = newVal;
                        
                    } else if (operNode != NULL) {
                        // if normal operation, read stuff from parent operand
                        SimulationStep &refStep = 
                            simulationSteps_[stepOfNode[operNode]];
                        
                        step.params[currEdge->dstOperand() - 1] = 
                            refStep.params[currEdge->srcOperand() - 1];
                    } else {
                        assert(false && "Invalid node type");
                    }
                }                    
                
                // set output variables and also create them if needed.
                for (int j = 0; j < dag_.outDegree(*opNode); j++) {
                    OperationDAGEdge* currEdge = &dag_.outEdge(*opNode, j);
                    OperationDAGNode* paramNode = &(dag_.headNode(*currEdge));
                    
                    TerminalNode* termNode = 
                        dynamic_cast<TerminalNode*>(paramNode);
                    
                    OperationNode* operNode = 
                        dynamic_cast<OperationNode*>(paramNode);
                    
                    if (termNode != NULL) {
                        // if terminal node, write stuff to ios_ table
                        step.params[currEdge->srcOperand() - 1] = 
                            &ios_[termNode->operandIndex() - 1];
 
                    } else if (operNode != NULL) {
                        // if normal operation, write stuff to temp
                        SimValue* newVal = new SimValue();
                        cleanUpTable_.push_back(newVal);
                        step.params[currEdge->srcOperand() - 1] = newVal;
                    
                    } else {
                        assert(false && "Invalid node type");
                    }
                }
                stepOfNode[opNode] = simulationSteps_.size();
                simulationSteps_.push_back(step);
            }
        }
    }
}

References assert, cleanUpTable_, dag_, OperationDAGEdge::dstOperand(), BoostGraph< GraphNode, GraphEdge >::headNode(), BoostGraph< GraphNode, GraphEdge >::inDegree(), BoostGraph< GraphNode, GraphEdge >::inEdge(), ios_, BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), Operation::numberOfInputs(), Operation::numberOfOutputs(), OperationDAGBehavior::SimulationStep::op, operandCount_, TerminalNode::operandIndex(), BoostGraph< GraphNode, GraphEdge >::outDegree(), BoostGraph< GraphNode, GraphEdge >::outEdge(), OperationDAGBehavior::SimulationStep::params, OperationNode::referencedOperation(), simulationSteps_, OperationDAGEdge::srcOperand(), BoostGraph< GraphNode, GraphEdge >::tailNode(), and ConstantNode::value().

Here is the call graph for this function:

~OperationDAGBehavior()

OperationDAGBehavior::~OperationDAGBehavior ( )

virtual

Destructor.

Definition at line 208 of file OperationDAGBehavior.cc.

                                            {
    delete[] ios_;
    
    for (unsigned int i = 0; i < cleanUpTable_.size(); i++) {
        delete cleanUpTable_[i];
    }
    
    for (unsigned int i = 0; i < simulationSteps_.size(); i++) {
        delete[] simulationSteps_[i].params;
    }
}

References cleanUpTable_, ios_, and simulationSteps_.

Member Function Documentation

areValid()

bool OperationDAGBehavior::areValid ( const InputOperandVector &  inputs, const OperationContext &  context  ) const

overridevirtual

Checks that the input operands for the OperationDag are valid.

Reimplemented from OperationBehavior.

Definition at line 257 of file OperationDAGBehavior.cc.

                                           {
 
    assert(simulationSteps_.size() != 0);
 
    InstructionAddress sandboxedProgramCounter = context.programCounter();
    SimValue sandboxedReturnAddress = context.returnAddress();
    OperationContext sandBoxContext(
        NULL, // Todo Add sandboxed memory proxy
        sandboxedProgramCounter,
        sandboxedReturnAddress,
        context.branchDelayCycles());
 
    for (size_t i = 0; i < inputs.size(); i++) {
        ios_[i].deepCopy(inputs.at(i));
    }
    bool valid = true;
 
    // Check validity of inputs for each step.
    for (unsigned int stepi = 0; stepi < simulationSteps_.size(); stepi++) {
        // Ugly copying values back and forth just to accommodate arguments for
        // areValid().
        OperationBehavior::InputOperandVector tmp;
        tmp.resize(simulationSteps_.at(stepi).op->numberOfInputs());
        for (int inputi = 0;
            inputi < simulationSteps_.at(stepi).op->numberOfInputs();
            inputi++) {
            tmp.at(inputi).deepCopy(*simulationSteps_[stepi].params[inputi]);
        }
 
        // Note: OperationState may not be preserved sanely even if the
        // context is sandboxed (concern is that copying OperationContext does
        // not deep copy the OperationState mannerly).
        assert(!simulationSteps_[stepi].op->hasSideEffects());
 
        if (simulationSteps_[stepi].op->areValid(tmp, context)) {
            // Simulate the step to get new inputs for the next step.
            simulationSteps_[stepi].op->simulateTrigger(
                simulationSteps_[stepi].params, sandBoxContext);
        } else {
            valid = false;
            break;
        }
    }
 
    return valid;
}

References assert, OperationContext::branchDelayCycles(), SimValue::deepCopy(), ios_, OperationContext::programCounter(), OperationContext::returnAddress(), and simulationSteps_.

Here is the call graph for this function:

canBeSimulated()

bool OperationDAGBehavior::canBeSimulated ( ) const

overridevirtual

If behavior can be simulated.

Check that every node can be simulated and recognize cyclic depency.

Returns

true If simulation of behavior is possible.

Reimplemented from OperationBehavior.

Definition at line 372 of file OperationDAGBehavior.cc.

                                           {
 
    if (cycleFound_ || dag_.isNull()) {
        cycleFound_ = false;
        return false;
    }
 
    cycleFound_ = true;
    for (int i = 0; i < dag_.nodeCount(); i++) {
        OperationNode* node = dynamic_cast<OperationNode*>(&dag_.node(i));
        
        if (node != NULL) {
            if (!node->referencedOperation().canBeSimulated()) {
                return false;
            } 
        }
    }
 
    cycleFound_ = false;
    return true;
}

References Operation::canBeSimulated(), cycleFound_, dag_, OperationDAG::isNull(), BoostGraph< GraphNode, GraphEdge >::node(), BoostGraph< GraphNode, GraphEdge >::nodeCount(), and OperationNode::referencedOperation().

Here is the call graph for this function:

createState()

void OperationDAGBehavior::createState ( OperationContext &  context ) const

overridevirtual

Creates the instance of operation state for this operation and adds it to its operation context.

By default this function does nothing (assumes that the operation has no state). If the operation context already contains the required operation state instance, nothing is done.

Parameters

context

The operation context to add the state to.

Reimplemented from OperationBehavior.

Definition at line 334 of file OperationDAGBehavior.cc.

                                                         {
}

deleteState()

void OperationDAGBehavior::deleteState ( OperationContext &  context ) const

overridevirtual

Deletes the instance of operation state for this operation from its operation context.

By default this function does nothing (assumes that the operation has no state). If the operation context does not contain the required operation state instance, nothing is done.

Parameters

context

The operation context to delete the state from.

Reimplemented from OperationBehavior.

Definition at line 348 of file OperationDAGBehavior.cc.

                                                         {
}

lateResult()

bool OperationDAGBehavior::lateResult ( SimValue **  io, OperationContext &  context  ) const

virtual

Checks whether any of the pending results of an operation initiated in earlier cycle is ready.

Parameters

io	The results of the operation.
context	The operation context affecting the operation results.

Returns

bool True if at least one new result of the operation could be computed, false otherwise. Returns false when all results are already computed.

Definition at line 317 of file OperationDAGBehavior.cc.

                                         {
    
    return false;
}

simulateTrigger()

bool OperationDAGBehavior::simulateTrigger ( SimValue **  operands, OperationContext &  context  ) const

overridevirtual

Simulates the process of starting the execution of an operation.

Clients should invoke isTriggerLocking() before any attempt to call simulateTrigger() in current clock cycle. By default, an operation invocations are successful.

Parameters

io	The input operands and the results of the operation.
context	The operation context affecting the operation results.

Returns

bool True if all values could be computed, false otherwise.

Exceptions

Exception

Depends on the implementation.

Implements OperationBehavior.

Definition at line 234 of file OperationDAGBehavior.cc.

                                                          {    
  
    for (int i = 0; i < operandCount_; i++) {
        ios_[i].deepCopy(*(operands[i]));
    }
 
    for (unsigned int i = 0; i < simulationSteps_.size(); i++) {
        simulationSteps_[i].op->simulateTrigger(
            simulationSteps_[i].params, context);
    }
    
    for (int i = 0; i < operandCount_; i++) {
        operands[i]->deepCopy(ios_[i]);
    }
 
    return true;
}

References SimValue::deepCopy(), ios_, operandCount_, and simulationSteps_.

Here is the call graph for this function:

stateName()

const char * OperationDAGBehavior::stateName ( ) const

overridevirtual

Returns the name of the state of this operation behavior.

By default returns an empty string which denotes that there is no state.

Returns

The state name for this operation behavior.

Reimplemented from OperationBehavior.

Definition at line 359 of file OperationDAGBehavior.cc.

                                      {
    return "";
}

Member Data Documentation

cleanUpTable_

std::vector<SimValue*> OperationDAGBehavior::cleanUpTable_

private

Contain list of pointers to delete in destructor.

Definition at line 96 of file OperationDAGBehavior.hh.

Referenced by OperationDAGBehavior(), and ~OperationDAGBehavior().

cycleFound_

bool OperationDAGBehavior::cycleFound_

mutableprivate

For checking if there is cyclic dependency in DAG.

Definition at line 99 of file OperationDAGBehavior.hh.

Referenced by canBeSimulated().

dag_

OperationDAG& OperationDAGBehavior::dag_

private

Definition at line 84 of file OperationDAGBehavior.hh.

Referenced by canBeSimulated(), and OperationDAGBehavior().

ios_

SimValue* OperationDAGBehavior::ios_

private

Table of parameters for simulate trigger.

Definition at line 90 of file OperationDAGBehavior.hh.

Referenced by areValid(), OperationDAGBehavior(), simulateTrigger(), and ~OperationDAGBehavior().

operandCount_

int OperationDAGBehavior::operandCount_

private

Number of operands of this operation.

Definition at line 87 of file OperationDAGBehavior.hh.

Referenced by OperationDAGBehavior(), and simulateTrigger().

simulationSteps_

std::vector<SimulationStep> OperationDAGBehavior::simulationSteps_

private

Definition at line 93 of file OperationDAGBehavior.hh.

Referenced by areValid(), OperationDAGBehavior(), simulateTrigger(), and ~OperationDAGBehavior().

---

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

• OperationDAGBehavior.hh
• OperationDAGBehavior.cc