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.
TCEString	operation_
	Name of the selected operation.
wxListBox *	operationList_
	Operation list widget.
std::string	opNameFilter_ = ""
	A string to filter opset list.

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(), findTriggerPort(), TTAMachine::FUPort::isTriggering(), and TTAMachine::BaseFUPort::width().

Referenced by createOperation().

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;
}

References ID_LATENCY, ID_LINE, ID_LIST, ID_OP_DESCRIPTION, ID_OP_FILTER, ID_OP_FILTER_LABEL, ID_OP_INPUTS, ID_OP_OUTPUTS, and ID_TEXT.

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, bindPorts(), TTAMachine::AddressSpace::end(), TTAMachine::FunctionUnit::hasAddressSpace(), TTAMachine::FunctionUnit::hasOperation(), Operand::index(), TTAMachine::Port::inputSocket(), Operand::isAddress(), Operand::isInput(), Operand::isOutput(), TTAMachine::FUPort::isTriggering(), latency_, Operation::numberOfInputs(), Operation::numberOfOutputs(), Operation::operand(), 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().

Referenced by bindPorts().

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);
}

References operationList_, and TransferDataFromWindow().

Here is the call graph for this function:

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 opNameFilter_, and 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(), ID_OP_DESCRIPTION, ID_OP_INPUTS, ID_OP_OUTPUTS, Operation::numberOfInputs(), Operation::numberOfOutputs(), operation_, operationList_, 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 ID_LATENCY, latency_, operation_, operationList_, and WxConversion::toString().

Referenced by onOK().

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(), OperationIndex::moduleCount(), OperationIndex::operationCount(), operationList_, OperationIndex::operationName(), opNameFilter_, 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.

Referenced by createOperation(), and TransferDataFromWindow().

operation_

TCEString OpsetDialog::operation_

private

Name of the selected operation.

Definition at line 77 of file OpsetDialog.hh.

Referenced by createOperation(), onSelectOperation(), and TransferDataFromWindow().

operationList_

wxListBox* OpsetDialog::operationList_

private

Operation list widget.

Definition at line 79 of file OpsetDialog.hh.

Referenced by onOK(), onSelectOperation(), TransferDataFromWindow(), and TransferDataToWindow().

opNameFilter_

std::string OpsetDialog::opNameFilter_ = ""

private

A string to filter opset list.

Definition at line 81 of file OpsetDialog.hh.

Referenced by onOperationFilterChange(), and TransferDataToWindow().

---

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

• OpsetDialog.hh
• OpsetDialog.cc