OpsetDialog Class Reference

#include <OpsetDialog.hh>

Inheritance diagram for OpsetDialog:

Collaboration diagram for OpsetDialog:

Public Member Functions
	OpsetDialog (wxWindow *parent)
virtual	~OpsetDialog ()
TTAMachine::HWOperation *	createOperation (TTAMachine::FunctionUnit &fu)

Protected Member Functions
virtual bool	TransferDataToWindow ()
virtual bool	TransferDataFromWindow ()

Private Types
enum	{   ID_LIST = 20000, ID_OP_FILTER_LABEL, ID_OP_FILTER, ID_OP_DESCRIPTION,   ID_OP_INPUTS, ID_OP_OUTPUTS, ID_LATENCY, ID_TEXT,   ID_LINE }
	Widget IDs. More...
typedef std::set< const TTAMachine::FUPort *, TTAMachine::MachinePart::Comparator >	PortSet
typedef std::map< int, PortSet >	PortMap

Private Member Functions
bool	bindPorts (TTAMachine::HWOperation &operation, std::map< int, std::set< int > > &operands, PortMap &ports, bool needsTrigger)
const TTAMachine::FUPort *	findTriggerPort (PortMap &ports)
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)
void	onSelectOperation (wxCommandEvent &event)
void	onOK (wxCommandEvent &event)
void	onOperationFilterChange (wxCommandEvent &event)

Private Attributes
int	latency_
	Chosen latency. More...
TCEString	operation_
	Name of the selected operation. More...
wxListBox *	operationList_
	Operation list widget. More...
std::string	opNameFilter_ = ""
	A string to filter opset list. More...

Detailed Description

Dialog for selecting and creating HWOperation from the operation pool.

Definition at line 50 of file OpsetDialog.hh.

Member Typedef Documentation

PortMap

typedef std::map<int, PortSet> OpsetDialog::PortMap

private

Definition at line 61 of file OpsetDialog.hh.

PortSet

typedef std::set<const TTAMachine::FUPort*, TTAMachine::MachinePart::Comparator> OpsetDialog::PortSet

private

Definition at line 60 of file OpsetDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Widget IDs.

Enumerator
ID_LIST
ID_OP_FILTER_LABEL
ID_OP_FILTER
ID_OP_DESCRIPTION
ID_OP_INPUTS
ID_OP_OUTPUTS
ID_LATENCY
ID_TEXT
ID_LINE

Definition at line 84 of file OpsetDialog.hh.

         {
        ID_LIST = 20000,
        ID_OP_FILTER_LABEL,
        ID_OP_FILTER,
        ID_OP_DESCRIPTION,
        ID_OP_INPUTS,
        ID_OP_OUTPUTS,
        ID_LATENCY,
        ID_TEXT,
        ID_LINE
    };

Constructor & Destructor Documentation

OpsetDialog()

OpsetDialog::OpsetDialog

(

wxWindow *

parent

)

The constructor.

Parameters

parent

Parent window of the dialog.

Definition at line 69 of file OpsetDialog.cc.

                                        :
    wxDialog(parent, -1, _T("Choose operation & latency"),
        wxDefaultPosition),
    latency_(1), operation_("") {
 
    createContents(this, true, true);
    operationList_ = dynamic_cast<wxListBox*>(FindWindow(ID_LIST));
    FindWindow(wxID_OK)->Disable();
}

~OpsetDialog()

OpsetDialog::~OpsetDialog ( )

virtual

The Destructor.

Definition at line 82 of file OpsetDialog.cc.

                          {
}

Member Function Documentation

bindPorts()

bool OpsetDialog::bindPorts ( TTAMachine::HWOperation &  operation, std::map< int, std::set< int > > &  operands, PortMap &  ports, bool  needsTrigger  )

private

Binds ports to operands of an instruction.

Tries to use sensible port widths, ie smallest allowed.

Parameters

operation	HWOperation being constructed
operands	width-based map of all operands
ports	width-based map of all ports
needsTrigger	if trigger neeed to be bound.

Returns

true if did bind trigger, false if did not.

Definition at line 333 of file OpsetDialog.cc.

                                               {
    bool triggerBound = false;
    int triggerWidth = 0;
    const FUPort* triggerPort = NULL;
 
    if (needsTrigger) {
        triggerPort = findTriggerPort(ports);
        if (triggerPort) {
            triggerWidth = triggerPort->width();
        }
    }
 
    while (!operands.empty() && !ports.empty()) {
        std::map<int, std::set<int> >::iterator j = operands.begin(); 
        int width = j->first;
        for (PortMap::iterator k = ports.begin();
             k != ports.end();) {
            if (k->first >= width) {
                std::set<int>& operandsOfSize = j->second;
                std::set<int>::iterator operandIter = operandsOfSize.begin();
                if (needsTrigger
                    && triggerPort != nullptr
                    && width <= triggerWidth
                    && operandsOfSize.size() == 1) {
                    std::map<int, std::set<int> >::iterator next = j;
                    next++;
                    if (next==operands.end() || next->first > triggerWidth) {
                        operation.bindPort(*operandIter, *triggerPort);
                        operands.erase(j->first);
                        ports.erase(triggerWidth);
                        needsTrigger = false;
                        triggerBound = true;
                        break;
                    }
                }
                PortSet& portsOfSize = k->second;
                // Take the last element of the set
                PortSet::iterator portIter = portsOfSize.end();
                portIter--;
                const TTAMachine::FUPort* fuPort = *portIter;
                operation.bindPort(*operandIter, *fuPort);
                if (fuPort->isTriggering()) {
                    needsTrigger = false;
                    triggerBound = true;
                }
                operandsOfSize.erase(operandIter);
                if (operandsOfSize.empty()) {
                    operands.erase(j->first);
                }
                portsOfSize.erase(portIter);
                if (portsOfSize.empty()) {
                    ports.erase(k->first);
                }
                break;
            } else {
                // port sizes of this size are too small for all in the future
                ports.erase(k++);
            }
        }
    }
    return triggerBound;
}

References TTAMachine::HWOperation::bindPort(), TTAMachine::FUPort::isTriggering(), and TTAMachine::BaseFUPort::width().

Here is the call graph for this function:

createContents()

wxSizer * OpsetDialog::createContents ( wxWindow *  parent, bool  call_fit, bool  set_sizer  )

private

Creates the dialog widgets.

Parameters

parent

Parent window of the widgets.

Definition at line 423 of file OpsetDialog.cc.

                                                                           {
 
    wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
    // Sizer for leftSizer and rightSizer
    wxBoxSizer *upperSizer = new wxBoxSizer(wxHORIZONTAL);
 
    // Sizer for oplistbox, filterlabel and filterinput
    wxBoxSizer *leftSizer = new wxBoxSizer(wxVERTICAL);
    // List of operations
    wxListBox *opListBox = new wxListBox(parent, ID_LIST, wxDefaultPosition,
        wxSize(210, 150), 0, NULL, wxLB_SINGLE|wxLB_SORT);
    leftSizer->Add(opListBox, 0, wxEXPAND|wxALL, 5);
 
    // Sizer for opNameFilterLabel and opNameFilter
    wxBoxSizer *filterSizer = new wxBoxSizer(wxHORIZONTAL);
    // TextLabel "Filter:"
    wxStaticText *opNameFilterLabel = new wxStaticText(parent,
        ID_OP_FILTER_LABEL, wxT("Filter:"), wxDefaultPosition, wxDefaultSize,
        0);
    // Operation filter input
    wxTextCtrl *opNameFilter = new wxTextCtrl(parent, ID_OP_FILTER, wxT(""),
        wxDefaultPosition, wxDefaultSize, 0);
    filterSizer->Add(opNameFilterLabel, 0, 0);
    filterSizer->Add(opNameFilter, 1, wxEXPAND);
    leftSizer->Add(filterSizer, 0, wxEXPAND|wxALL, 5);
 
    // Sizer for latencyLabel and latencySpinner
    wxBoxSizer *latencySizer = new wxBoxSizer(wxHORIZONTAL);
    // TextLabel "Latency"
    wxStaticText *latencyLabel = new wxStaticText(parent, ID_TEXT,
        wxT("Latency:"), wxDefaultPosition, wxDefaultSize, 0);
    // Latency spinner
    wxSpinCtrl *latencySpinner = new wxSpinCtrl(parent, ID_LATENCY, wxT("1"),
        wxDefaultPosition, wxSize(-1,-1), 0, 1, 100, 1);
    latencySizer->Add(latencyLabel, 1, 0);
    latencySizer->Add(latencySpinner, 1);
    leftSizer->Add(latencySizer, 0, wxEXPAND|wxALL, 5);
 
    // Sizer for operation information
    wxStaticBoxSizer *rightSizer = new wxStaticBoxSizer(wxVERTICAL, parent,
        wxT("Operation description"));
    // Selected operation description
    wxTextCtrl *opDescription = new wxTextCtrl(parent, ID_OP_DESCRIPTION,
        wxT(""), wxDefaultPosition, wxSize(210, -1),
        wxTE_MULTILINE|wxTE_READONLY);
 
    // Sizer for Inputs/Outputs
    wxBoxSizer *insOutsSizer = new wxBoxSizer(wxHORIZONTAL);
    // Output count label
    wxStaticText *inputsLabel = new wxStaticText(parent, ID_OP_INPUTS,
        wxT("Inputs:"), wxDefaultPosition, wxDefaultSize, 0);
    // Outputs count label
    wxStaticText *outputsLabel = new wxStaticText(parent, ID_OP_OUTPUTS,
        wxT("Outputs: "), wxDefaultPosition, wxDefaultSize, 0);
    insOutsSizer->Add(inputsLabel, 1);
    insOutsSizer->Add(outputsLabel, 1);
    rightSizer->Add(opDescription, 1, wxEXPAND|wxALL, 5);
    rightSizer->Add(insOutsSizer, 0, wxEXPAND|wxALL, 5);
 
    upperSizer->Add(leftSizer, 0, wxALL, 5);
    upperSizer->Add(rightSizer, 1, wxEXPAND|wxALL, 5);
 
    mainSizer->Add(upperSizer, 1, wxEXPAND);
 
    // Static line
    wxStaticLine *horisontalLine = new wxStaticLine(parent, ID_LINE,
        wxDefaultPosition, wxSize(20,-1), wxLI_HORIZONTAL);
    mainSizer->Add(horisontalLine, 0, wxEXPAND|wxALL, 5);
 
    // Sizer for Cancel and OK buttons
    wxBoxSizer *buttonsSizer = new wxBoxSizer(wxHORIZONTAL);
    // Cancel button
    wxButton *cancelButton = new wxButton(parent, wxID_CANCEL, wxT("&Cancel"),
        wxDefaultPosition, wxDefaultSize, 0);
    buttonsSizer->Add(cancelButton, 0, wxALIGN_CENTER|wxALL, 5);
    // OK button
    wxButton *okButton = new wxButton(parent, wxID_OK, wxT("&OK"),
        wxDefaultPosition, wxDefaultSize, 0);
    buttonsSizer->Add(okButton, 0, wxALIGN_CENTER|wxALL, 5);
 
    mainSizer->Add(buttonsSizer, 0, 0, 5);
 
    if (set_sizer) {
        parent->SetSizer(mainSizer);
        if (call_fit) {
            mainSizer->SetSizeHints( parent );
        }
    }
    
    return mainSizer;
}

createOperation()

HWOperation * OpsetDialog::createOperation

(

TTAMachine::FunctionUnit &

fu

)

Creates a new HWOperation based on user choices.

Parameters

fu	Parent function unit of the new operation.

Returns

Pointer to the created operation.

Definition at line 212 of file OpsetDialog.cc.

                                             {
 
    // Check that the function unit doesn't already have an operation with
    // the selected name.
    if (fu.hasOperation(operation_)) {
        wxString message = _T("Function unit already contains operation '");
        message.Append(WxConversion::toWxString(operation_));
        message.Append(_T("'."));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return NULL;
    }
 
    OperationPool pool;
    const Operation& op = pool.operation(operation_.c_str());
 
    HWOperation* operation = new HWOperation(operation_, fu);
 
    // Read operation operand information from the operation pool.
    std::map<int, std::set<int> > inputs;
    std::map<int, std::set<int> > outputs;
    wxString opWidths;
 
    PortMap inputPorts;
    PortMap outputPorts;
    PortMap unconnectedPorts;
 
    for (int i = 1; i <= op.numberOfInputs() + op.numberOfOutputs(); i++) {
        const Operand& oper = op.operand(i);
        opWidths.Append(WxConversion::toWxString(oper.width()));
 
        if (oper.isInput()) {
            int opWidth;
            if (oper.isAddress()) {
                assert(fu.hasAddressSpace());
                opWidth = MathTools::requiredBits(fu.addressSpace()->end());
            } else {
                opWidth = oper.width();
            }
            inputs[opWidth].insert(oper.index());
            opWidths.Append(WxConversion::toWxString("b input, "));
            operation->pipeline()->addPortRead(oper.index(), 0, 1);
        } else if (oper.isOutput()) {
            outputs[oper.width()].insert(oper.index());
            opWidths.Append(WxConversion::toWxString("b output, "));
            if (!inputs.empty()) {
                // 0 and 1 latency means that the output operand is written
                // on cycle 0.
                int latency = (latency_ > 0) ? latency_ - 1 : latency_;
                operation->pipeline()->addPortWrite(oper.index(), latency, 1);
            }
        }
    }
 
    opWidths.RemoveLast(2);
    opWidths.Append(_T("."));
 
    // Try to bind operation operands to function unit ports.
    for (int i = 0; i < fu.operationPortCount(); i++) {
        const FUPort* port = fu.operationPort(i);
 
        if (port->inputSocket() != NULL || port->isTriggering()) {
            inputPorts[port->width()].insert(port);
        } else if (port->outputSocket() != NULL) {
            outputPorts[port->width()].insert(port);
        } else {
            unconnectedPorts[port->width()].insert(port);
        }
    }
 
    bool triggerBound = false;
    triggerBound |= bindPorts(*operation, inputs, inputPorts, !inputs.empty());
    bindPorts(*operation, outputs, outputPorts, false);
 
    bindPorts(*operation, inputs, unconnectedPorts, false);
    bindPorts(*operation, outputs, unconnectedPorts, false);
    
    // Display an error dialog and abort if the operands couldn't be bound
    // to ports.
    if (!inputs.empty() || !outputs.empty()
        || (!inputs.empty() && !triggerBound)) {
        wxString message;
        if (!inputs.empty() && !triggerBound) {
            message.Append(
                _T("Could not bind operand to the trigger port. "));
            message.Append(
                _T("It may be too narrow or missing?\n"));
        }
 
        if (!inputs.empty()) {
            message.Append(
                _T("Not enough (wide enough?) input ports for the operation "
                   "input operands.\n"));
        }
        if (!outputs.empty()) {
            message.Append(
                _T("Not enough (wide enough?) output ports for the operation "
                   "output operands.\n"));
        }
        message.Append(WxConversion::toWxString("\n" + operation_));
        message.Append(_T(" needs a "));
        message.Append(opWidths);
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        delete operation;
        return NULL;
    }
 
    return operation;
}

References TTAMachine::ExecutionPipeline::addPortRead(), TTAMachine::ExecutionPipeline::addPortWrite(), TTAMachine::FunctionUnit::addressSpace(), assert, TTAMachine::AddressSpace::end(), TTAMachine::FunctionUnit::hasAddressSpace(), TTAMachine::FunctionUnit::hasOperation(), Operand::index(), TTAMachine::Port::inputSocket(), Operand::isAddress(), Operand::isInput(), Operand::isOutput(), TTAMachine::FUPort::isTriggering(), Operation::numberOfInputs(), Operation::numberOfOutputs(), Operation::operand(), OperationPool::operation(), TTAMachine::FunctionUnit::operationPort(), TTAMachine::FunctionUnit::operationPortCount(), TTAMachine::Port::outputSocket(), TTAMachine::HWOperation::pipeline(), MathTools::requiredBits(), WxConversion::toWxString(), TTAMachine::BaseFUPort::width(), and Operand::width().

Referenced by FUDialog::onAddOperationFromOpset().

Here is the call graph for this function:

findTriggerPort()

const TTAMachine::FUPort * OpsetDialog::findTriggerPort ( PortMap &  ports )

private

Finds the trigger port from map of function unit ports.

Definition at line 403 of file OpsetDialog.cc.

                                           {
    for (PortMap::iterator i = ports.begin(); i != ports.end(); i++) {
        PortSet& portsOfSize = i->second;
        for (PortSet::iterator j = portsOfSize.begin(); 
             j != portsOfSize.end(); j++) {
            const TTAMachine::FUPort* port = *j;
            if (port->isTriggering()) {
                return port;
            }
        }
    }
    return NULL;
}

References TTAMachine::FUPort::isTriggering().

Here is the call graph for this function:

onOK()

void OpsetDialog::onOK ( wxCommandEvent &  event )

private

Event handler for the OK button.

Definition at line 176 of file OpsetDialog.cc.

                                 {
    if (operationList_->GetSelection() == wxNOT_FOUND) {
        wxString message = _T("No operation selected.");
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
    TransferDataFromWindow();
    EndModal(wxID_OK);
}

onOperationFilterChange()

void OpsetDialog::onOperationFilterChange ( wxCommandEvent &  event )

private

Event handler for opset filtering.

Definition at line 192 of file OpsetDialog.cc.

                                                          {
    std::string pattern(event.GetString().mb_str());
    std::string::iterator it;
    it = std::remove_if(pattern.begin(), pattern.end(), [](const char& c) {
        return c == ' ';
    });
    pattern.erase(it, pattern.end());
    for (auto& c : pattern) c = toupper(c);
    opNameFilter_ = pattern;
    OpsetDialog::TransferDataToWindow();
}

References TransferDataToWindow().

Here is the call graph for this function:

onSelectOperation()

void OpsetDialog::onSelectOperation ( wxCommandEvent &  event )

private

Event handler for the operation list selections.

Enables and disables the OK button. Displays operation description and ports count.

Definition at line 134 of file OpsetDialog.cc.

                                              {
    FindWindow(wxID_OK)->Enable(operationList_->GetSelection() != wxNOT_FOUND);
 
    operation_ = WxConversion::toString(operationList_->GetStringSelection());
 
    if (operation_ == "")
        return;
 
    wxString opDesc;
    wxString inputCount;
    wxString outputCount;
    try {
        OperationPool pool;
        const Operation& op = pool.operation(operation_.c_str());
        opDesc = WxConversion::toWxString(op.description());
        inputCount = WxConversion::toWxString(op.numberOfInputs());
        outputCount = WxConversion::toWxString(op.numberOfOutputs());
    } catch (Exception&) {
        opDesc = WxConversion::toWxString(
            "Error in loading the operation description.");
        inputCount = WxConversion::toWxString("N/A");
        outputCount = WxConversion::toWxString("N/A");
    }
    // Set operation description
    wxTextCtrl *opDescription = dynamic_cast<wxTextCtrl*>(
        FindWindow(ID_OP_DESCRIPTION));
    opDescription->Clear();
    opDescription->AppendText(opDesc);
    // Set inputs and outputs count
    wxStaticText *inputsLabel = dynamic_cast<wxStaticText*>(
        FindWindow(ID_OP_INPUTS));
    inputsLabel->SetLabel(wxT("Inputs: ") + inputCount);
    wxStaticText *outputsLabel = dynamic_cast<wxStaticText*>(
        FindWindow(ID_OP_OUTPUTS));
    outputsLabel->SetLabel(wxT("Outputs: ") + outputCount);
}

References Operation::description(), Operation::numberOfInputs(), Operation::numberOfOutputs(), OperationPool::operation(), WxConversion::toString(), and WxConversion::toWxString().

Here is the call graph for this function:

TransferDataFromWindow()

bool OpsetDialog::TransferDataFromWindow ( )

protectedvirtual

Reads user choices from the dialog widgets.

Definition at line 121 of file OpsetDialog.cc.

                                    {
    latency_ = dynamic_cast<wxSpinCtrl*>(FindWindow(ID_LATENCY))->GetValue();
    operation_ = WxConversion::toString(operationList_->GetStringSelection());
    return true;
}

References WxConversion::toString().

Here is the call graph for this function:

TransferDataToWindow()

bool OpsetDialog::TransferDataToWindow ( )

protectedvirtual

Transfers data to the opset list.

Definition at line 89 of file OpsetDialog.cc.

                                  {
 
    operationList_->Clear();
 
    // Cleanup operation pool cache so new operations
    // appear w/o restarting prode.
    OperationPool::cleanupCache();
    OperationPool pool;
    OperationIndex& index = pool.index();
    std::set<TCEString> opset;
    for (int m = 0; m < index.moduleCount(); m++) {
        OperationModule& module = index.module(m);
        for (int i = 0; i < index.operationCount(module); i++) {
            std::string opName = index.operationName(i, module);
            if (opNameFilter_.empty()
                || opName.find(opNameFilter_) != std::string::npos) {
                opset.insert(opName);
            }
        }
    }
 
    for (const auto& opName : opset) {
        operationList_->Append(WxConversion::toWxString(opName));
    }
 
    return true;
}

References OperationPool::cleanupCache(), OperationPool::index(), OperationIndex::module(), OperationIndex::moduleCount(), OperationIndex::operationCount(), OperationIndex::operationName(), and WxConversion::toWxString().

Referenced by onOperationFilterChange().

Here is the call graph for this function:

Member Data Documentation

latency_

int OpsetDialog::latency_

private

Chosen latency.

Definition at line 75 of file OpsetDialog.hh.

operation_

TCEString OpsetDialog::operation_

private

Name of the selected operation.

Definition at line 77 of file OpsetDialog.hh.

operationList_

wxListBox* OpsetDialog::operationList_

private

Operation list widget.

Definition at line 79 of file OpsetDialog.hh.

opNameFilter_

std::string OpsetDialog::opNameFilter_ = ""

private

A string to filter opset list.

Definition at line 81 of file OpsetDialog.hh.

---

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

• OpsetDialog.hh
• OpsetDialog.cc