OperationSimulator Class Reference

#include <OperationSimulator.hh>

Collaboration diagram for OperationSimulator:

Public Member Functions
bool	simulateTrigger (Operation &op, std::vector< DataObject > inputs, std::vector< SimValue * > &outputs, OperationContext &context, std::string &result)
bool	lateResult (Operation &op, std::vector< DataObject > inputs, std::vector< SimValue * > &outputs, OperationContext &context, unsigned int bitWidth, std::string &result)
void	advanceClock (OperationContext &context)
bool	initializeSimValue (std::string value, SimValue *sim, std::string &result)

Static Public Member Functions
static OperationSimulator &	instance ()

Private Member Functions
	OperationSimulator ()
virtual	~OperationSimulator ()
bool	initializeOutputs (Operation &op, std::vector< DataObject > inputs, std::vector< SimValue * > &outputs, std::string &result)

Static Private Attributes
static OperationSimulator *	instance_ = NULL
	Unique instance. More...

Detailed Description

Contains functionality to simulate operation behavior.

Definition at line 48 of file OperationSimulator.hh.

Constructor & Destructor Documentation

OperationSimulator()

OperationSimulator::OperationSimulator ( )

private

Constructor.

Definition at line 50 of file OperationSimulator.cc.

                                       {
}

Referenced by instance().

~OperationSimulator()

OperationSimulator::~OperationSimulator ( )

privatevirtual

Destructor.

Definition at line 56 of file OperationSimulator.cc.

                                        {
}

Member Function Documentation

advanceClock()

void OperationSimulator::advanceClock

(

OperationContext &

context

)

initializeOutputs()

bool OperationSimulator::initializeOutputs ( Operation &  op, std::vector< DataObject >  inputs, std::vector< SimValue * > &  outputs, std::string &  result  )

private

Initializes the output values of the operation.

Parameters

op	Operation in which outputs are initialized.
inputs	Input values.
outputs	Output values to be initialized.
result	Possible error message string.

Returns

True if initialization is successful.

Definition at line 166 of file OperationSimulator.cc.

                       {
 
    for (size_t i = 0; i < inputs.size(); i++) {
        SimValue* sim = new SimValue(op.input(i).width());
 
        string value = inputs[i].stringValue();
 
        if (!initializeSimValue(value, sim, result)) {
            return false;
        }
 
        outputs.push_back(sim);
    }
 
    for (int i = 0; i < op.numberOfOutputs(); i++) {
        SimValue* result = new SimValue(op.output(i).width());
        outputs.push_back(result);
    }
    return true;
}

References initializeSimValue(), Operation::input(), Operation::numberOfOutputs(), Operation::output(), and Operand::width().

Referenced by simulateTrigger().

Here is the call graph for this function:

initializeSimValue()

bool OperationSimulator::initializeSimValue	(	std::string	value,
		SimValue *	sim,
		std::string &	result
	)

Initializes one SimValue.

Parameters

value	Value.
sim	SimValue to be initialized.
result	Possible error string.

Definition at line 122 of file OperationSimulator.cc.

                       {
 
    bool is_int = value.find(".") == string::npos &&
        value.find('e') == string::npos;
    bool is_float = !is_int &&
        (value.find("f") != string::npos ||
        value.find("F") != string::npos);
    bool is_half = value.find(".") != string::npos &&
        (value.find("h") != string::npos ||
        value.find("H") != string::npos);
 
    try {
        if (value.size() > 2 && value[0] == '0' && value[1] == 'x') {
            (*sim).setValue(TCEString(value));
        } else if (is_int && !is_float) {
            *sim = Conversion::toLong(value);
        } else if (is_float) {
            *sim = Conversion::toFloat(value.substr(0, value.length()-1));
        } else if (is_half) {
            *sim = HalfFloatWord(
                Conversion::toFloat(value.substr(0, value.length()-1)));
        } else {
            *sim = Conversion::toDouble(value);
        }
    } catch (const NumberFormatException& n) {
        result = "illegal operand value \"" + value + "\"";
        return false;
    }
    return true;
}

References Conversion::toDouble(), Conversion::toFloat(), and Conversion::toLong().

Referenced by initializeOutputs(), and SimulateDialog::onFormatChanged().

Here is the call graph for this function:

instance()

OperationSimulator & OperationSimulator::instance ( )

static

Returns the unique instance of OperationSimulator.

Returns

The instance of OperationSimulator.

Definition at line 65 of file OperationSimulator.cc.

                             {
    if (instance_ == NULL) {
        instance_ = new OperationSimulator();
    }
    return *instance_;
}

References instance_, and OperationSimulator().

Referenced by CmdTrigger::execute(), SimulateDialog::onFormatChanged(), and SimulateDialog::onTrigger().

Here is the call graph for this function:

lateResult()

bool OperationSimulator::lateResult	(	Operation &	op,
		std::vector< DataObject >	inputs,
		std::vector< SimValue * > &	outputs,
		OperationContext &	context,
		unsigned int	bitWidth,
		std::string &	result
	)

simulateTrigger()

bool OperationSimulator::simulateTrigger	(	Operation &	op,
		std::vector< DataObject >	inputs,
		std::vector< SimValue * > &	outputs,
		OperationContext &	context,
		std::string &	result
	)

Executes the operation trigger command.

Parameters

op	Operation to be simulated.
inputs	The inputs for the operation.
outputs	The outputs of the operation.
context	OperationContext used in simulation.
result	The possible error string.

Returns

True if simulation is successful.

Definition at line 83 of file OperationSimulator.cc.

                       {
 
    if (static_cast<unsigned>(op.numberOfInputs()) != inputs.size()) {
        result = "wrong number of arguments";
        return false;
    }
 
    if (!initializeOutputs(op, inputs, outputs, result)) {
        return false;
    }
 
    SimValue** io_ = new SimValue*[outputs.size()];
    for (std::size_t i = 0; i < outputs.size(); ++i) {
        io_[i] = outputs.at(i);
    }
    try {
        bool ready = op.simulateTrigger(io_, context);
        delete[] io_;
        io_ = NULL;
        return ready;
    } catch (const Exception& e) {
        result = e.errorMessage();
        return false;
    }
}

References Exception::errorMessage(), initializeOutputs(), Operation::numberOfInputs(), and Operation::simulateTrigger().

Referenced by CmdTrigger::execute(), and SimulateDialog::onTrigger().

Here is the call graph for this function:

Member Data Documentation

instance_

OperationSimulator * OperationSimulator::instance_ = NULL

staticprivate

Unique instance.

Definition at line 85 of file OperationSimulator.hh.

Referenced by instance().

---

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

• OperationSimulator.hh
• OperationSimulator.cc