AddFUFromHDBDialog Class Reference

#include <AddFUFromHDBDialog.hh>

Inheritance diagram for AddFUFromHDBDialog:

Collaboration diagram for AddFUFromHDBDialog:

Public Member Functions
	AddFUFromHDBDialog (wxWindow *parent, Model *model)
virtual	~AddFUFromHDBDialog ()

Private Types
enum	{   ID_LIST = 10000 , ID_FILTER_LABEL , ID_FILTER_TEXTCTRL , ID_ADD ,   ID_CLOSE , ID_LINE , ID_FILTER_TIMER }

Private Member Functions
virtual bool	TransferDataToWindow ()
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)
void	onListSelectionChange (wxListEvent &event)
void	onAdd (wxCommandEvent &event)
void	onClose (wxCommandEvent &event)
bool	loadHDB (const HDB::HDBManager &manager)
bool	acceptToList (const std::string hdbFilePath, const HDB::FUArchitecture &arch, const std::vector< std::string > &filterList)
void	onFilterChange (wxCommandEvent &event)
void	onFilterTimeOut (wxTimerEvent &event)
void	onColumnClick (wxListEvent &event)
void	setColumnImage (int col, int image)

Private Attributes
Model *	model_
	Model of the current adf file.
wxListCtrl *	list_
	Immediate slot list widget.
std::map< int, HDB::FUArchitecture * >	fuArchitectures_
	Map of iu architectures displayed in the dialog list.
wxSearchCtrl *	filterCtrl_ = nullptr
	The list filter text control.
std::vector< std::string >	filterPatterns_
	Keywords to filter HDB entries.
wxTimer	filterTimer_
	Timer to postpone filtering while typing filter patterns.
int	sortColumn_
bool	sortASC_

Static Private Attributes
static const wxString	HDB_FILE_FILTER = _T("*.hdb")
	File filter for HDB files.

Detailed Description

Dialog for adding register file architectures directly from HDB to the current machine.

Definition at line 64 of file AddFUFromHDBDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
ID_LIST
ID_FILTER_LABEL
ID_FILTER_TEXTCTRL
ID_ADD
ID_CLOSE
ID_LINE
ID_FILTER_TIMER

Definition at line 101 of file AddFUFromHDBDialog.hh.

         {
        ID_LIST = 10000,
        ID_FILTER_LABEL,
        ID_FILTER_TEXTCTRL,
        ID_ADD,
        ID_CLOSE,
        ID_LINE,
        ID_FILTER_TIMER
    };

Constructor & Destructor Documentation

AddFUFromHDBDialog()

AddFUFromHDBDialog::AddFUFromHDBDialog	(	wxWindow *	parent,
		Model *	model
	)

The Constructor.

Parameters

parent	Parent window of the dialog.
machine	Parent Machine of the immediate slots.

Definition at line 131 of file AddFUFromHDBDialog.cc.

                  :
    wxDialog(
        parent, -1, _T("HDB Function Units"),
        wxDefaultPosition, wxDefaultSize,
        wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER),
    model_(model),
    filterTimer_(this, ID_FILTER_TIMER),
    sortColumn_(1), sortASC_(true) {
 
    createContents(this, true, true);
    SetSize(500, 400);
 
    list_ = dynamic_cast<wxListCtrl*>(FindWindow(ID_LIST));
 
    list_->InsertColumn(0, _T("Latency"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(
                    1, _T("Operations"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(2, _T("Impls"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(3, _T("HDB ID"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
    list_->InsertColumn(4, _T("HDB"), wxLIST_FORMAT_LEFT, wxLIST_AUTOSIZE);
 
    string iconPath =
        Environment::iconDirPath() + FileSystem::DIRECTORY_SEPARATOR;
 
    wxImageList* imageList = new wxImageList(13, 17);
    imageList->Add(wxIcon(
        WxConversion::toWxString(iconPath + ProDeConstants::ICON_SORT_DESC)));
    imageList->Add(wxIcon(
        WxConversion::toWxString(iconPath + ProDeConstants::ICON_SORT_ASC)));
    list_->SetImageList(imageList, wxIMAGE_LIST_SMALL);
 
    // Disable conditional buttons.
    FindWindow(ID_ADD)->Disable();
}

References createContents(), FileSystem::DIRECTORY_SEPARATOR, ProDeConstants::ICON_SORT_ASC, ProDeConstants::ICON_SORT_DESC, Environment::iconDirPath(), ID_ADD, ID_LIST, list_, and WxConversion::toWxString().

Here is the call graph for this function:

~AddFUFromHDBDialog()

AddFUFromHDBDialog::~AddFUFromHDBDialog ( )

virtual

The Destructor.

Definition at line 172 of file AddFUFromHDBDialog.cc.

                                        {
    MapTools::deleteAllValues(fuArchitectures_);
}

References MapTools::deleteAllValues(), and fuArchitectures_.

Here is the call graph for this function:

Member Function Documentation

acceptToList()

bool AddFUFromHDBDialog::acceptToList ( const std::string  hdbFilePath, const HDB::FUArchitecture &  arch, const std::vector< std::string > &  filterList  )

private

Returns true if the FU architecture should not be viewed.

Parameters

filterList

The list of all keywords (uppercase), that the FU architecture should contain.

Definition at line 308 of file AddFUFromHDBDialog.cc.

                                            {
 
    if (filterList.empty()) {
        return true;
    }
 
    // Construct string from where the keywords are searched.
    std::string archStr;
    const FunctionUnit& fu = arch.architecture();
    for (int i = 0; i < fu.operationCount(); i++) {
        const HWOperation& oper = *fu.operation(i);
 
        // Operation with latency as viewed in the list.
        archStr += oper.name()
            + "(" + Conversion::toString(oper.latency()) + ") ";
 
    }
 
    for (auto& c : archStr) c = tolower(c);
 
    for (const string& keyword : filterList) {
        if (keyword.size() > 0 && keyword.front() == '!') {
            if (keyword.size() < 2) {
                continue;
            } else if (archStr.find(keyword.substr(1)) != std::string::npos ||
                hdbFilePath.find(keyword.substr(1)) != std::string::npos) {
                return false;
            }
        } else if (archStr.find(keyword) == std::string::npos &&
            hdbFilePath.find(keyword) == std::string::npos) {
            return false;
        }
    }
 
    return true;
}

References HDB::FUArchitecture::architecture(), TTAMachine::HWOperation::latency(), TTAMachine::HWOperation::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), and Conversion::toString().

Referenced by loadHDB().

Here is the call graph for this function:

createContents()

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

private

Creates the dialog contents.

Parameters

parent	Parent dialog of the contents.
call_fit	If true, fits the contents inside the dialog.
set_sizer	If true, sets the main sizer as dialog contents.

Returns

Top level sizer of the dialog contents.

Definition at line 496 of file AddFUFromHDBDialog.cc.

                                                     {
 
    wxFlexGridSizer *item0 = new wxFlexGridSizer( 1, 0, 0 );
    item0->AddGrowableCol( 0 );
    item0->AddGrowableRow( 0 );
 
    wxListCtrl *item1 = new wxListCtrl( parent, ID_LIST, wxDefaultPosition, wxSize(160,120), wxLC_REPORT|wxSUNKEN_BORDER );
    item0->Add( item1, 0, wxGROW|wxALL, 5 );
 
    filterCtrl_ = new wxSearchCtrl(parent,
        ID_FILTER_TEXTCTRL, wxT(""), wxDefaultPosition, wxDefaultSize, 0);
    filterCtrl_->SetDescriptiveText(
        wxT("Filter operations or HDBs. '!PATTERN' to exclude."));
    item0->Add(filterCtrl_, 0, wxGROW|wxALL, 5);
 
    wxButton *item2 = new wxButton( parent, ID_ADD, wxT("&Add"), wxDefaultPosition, wxDefaultSize, 0 );
    item0->Add( item2, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxStaticLine *item3 = new wxStaticLine( parent, ID_LINE, wxDefaultPosition, wxSize(20,-1), wxLI_HORIZONTAL );
    item0->Add( item3, 0, wxGROW|wxALL, 5 );
 
    wxButton *item4 = new wxButton( parent, ID_CLOSE, wxT("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
    item0->Add( item4, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    if (set_sizer) {
        parent->SetSizer( item0 );
        if (call_fit) {
            item0->SetSizeHints( parent );
        }
    }
    
    return item0;
}

References filterCtrl_, ID_ADD, ID_CLOSE, ID_FILTER_TEXTCTRL, ID_LINE, and ID_LIST.

Referenced by AddFUFromHDBDialog().

loadHDB()

bool AddFUFromHDBDialog::loadHDB ( const HDB::HDBManager &  manager )

private

Loads register files from a HDB to the dialog list.

Parameters

manager

HDB manager to load.

Returns

True, if the HDB was succesfully loaded.

Definition at line 229 of file AddFUFromHDBDialog.cc.

                                                     {
 
    const std::set<RowID> fuArchIDs = manager.fuArchitectureIDs();
    std::set<RowID>::iterator iter = fuArchIDs.begin();
 
    std::string path = manager.fileName();
 
    // Read properties of all function units found in the HDB and append
    // data to the dialog FU list widget.
    for (; iter != fuArchIDs.end(); iter++) {
 
        FUArchitecture* arch = manager.fuArchitectureByID(*iter);
        FunctionUnit& fu = arch->architecture();
 
        if (!acceptToList(path, *arch, filterPatterns_)) {
            continue;
        }
 
        fuArchitectures_.insert(
            std::pair<int, FUArchitecture*>(list_->GetItemCount(), arch));
 
        ListItemData* lid = new ListItemData;
 
        list_->InsertItem(0, _T(""));
        if (fu.operationCount() > 0) {
            wxString operations;
            int minLatency = fu.operation(0)->latency();
            int maxLatency = fu.operation(0)->latency();
            for (int i = 0; i < fu.operationCount(); i++) {
                if (i > 0) {
                    operations.Append(_T(", "));
                }
                operations.Append(
                    WxConversion::toWxString(fu.operation(i)->name()));
                operations.Append(_T("("));
                operations.Append(
                    WxConversion::toWxString(fu.operation(i)->latency()));
                operations.Append(_T(")"));
 
                if (fu.operation(i)->latency() > maxLatency) {
                    maxLatency = fu.operation(i)->latency();
                }
                if (fu.operation(i)->latency() < minLatency) {
                    minLatency = fu.operation(i)->latency();
                }
            }
            wxString latency = WxConversion::toWxString(minLatency);
            if (maxLatency != minLatency) {
                latency.Append(_T(".."));
                latency.Append(WxConversion::toWxString(maxLatency));
            }
                
            list_->SetItem(0, 0, latency);
            lid->latency = minLatency;
            list_->SetItem(0, 1, operations);
            lid->operations = operations;
        }
        list_->SetItem(0, 3, WxConversion::toWxString(*iter));
        lid->hdbId = *iter;
        list_->SetItem(0, 4, WxConversion::toWxString(path));
        lid->path = WxConversion::toWxString(path);
        lid->id = list_->GetItemCount() - 1;
        list_->SetItemData(0, (long)lid);
    }
    // default sorting column is "Operations"
    list_->SortItems(FUListCompareASC, 1);
    setColumnImage(1, sortASC_);
 
    return true;
}

References acceptToList(), HDB::FUArchitecture::architecture(), HDB::HDBManager::fileName(), filterPatterns_, HDB::HDBManager::fuArchitectureByID(), HDB::HDBManager::fuArchitectureIDs(), fuArchitectures_, FUListCompareASC(), ListItemData::hdbId, ListItemData::id, TTAMachine::HWOperation::latency(), ListItemData::latency, list_, TTAMachine::HWOperation::name(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), ListItemData::operations, ListItemData::path, setColumnImage(), sortASC_, and WxConversion::toWxString().

Referenced by TransferDataToWindow().

Here is the call graph for this function:

onAdd()

void AddFUFromHDBDialog::onAdd ( wxCommandEvent &  event )

private

Adds a new register file to the machine when "Add" button is pressed.

Definition at line 387 of file AddFUFromHDBDialog.cc.

                                         {
 
    long item = -1;
    item = list_->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
    if ( item == -1 ) return;
    
    ListItemData* lid = (ListItemData*)list_->GetItemData(item);
    int id = lid->id;
    const FUArchitecture* arch =
        MapTools::valueForKey<FUArchitecture*>(fuArchitectures_, id);
 
    // Copy the architecture of the selected function unit from HDB.
    // Copying is done by saving and loading the FU state to an ObjectState
    // object, because FunctionUnit class doesn't have a copy constructor.
    ObjectState* fuState = arch->architecture().saveState();
    FunctionUnit* fu = NULL;
    try {
        fu = new FunctionUnit(fuState);
        delete fuState;
    } catch (Exception& e) {
        wxString message = _T("Error while adding function unit:\n");
        message.Append(WxConversion::toWxString(e.errorMessage()));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    int inIndex = 1;
    int outIndex = 1;
    int ioIndex = 1;
    int unusedIndex = 1;
 
    // Rename ports.
    for (int p = 0; p < fu->portCount(); p++) {
        FUPort* port = dynamic_cast<FUPort*>(fu->port(p));
        bool read = false;
        bool write = false;
 
        // Check from the operation pipelines if the port is read or written.
        for (int o = 0; o < fu->operationCount(); o++) {
            const HWOperation* operation = fu->operation(o);
            const ExecutionPipeline* pipeline = operation->pipeline();
            for (int cycle = 0; cycle < operation->latency(); cycle++) {
                if (pipeline->isPortRead(*port, cycle)) read = true;
                if (pipeline->isPortWritten(*port, cycle)) write = true;
            }
        }
 
        // Generate new name for the port according to if it's read/written.
        std::string portName = "";
        if (read && write) {
            portName = "io" + Conversion::toString(ioIndex);
            ioIndex++;
        } else if (read) {
            portName = "in" + Conversion::toString(inIndex);
            inIndex++;
        } else if (write) {
            portName = "out" + Conversion::toString(outIndex);
            outIndex++;
        } else {
            portName = "unused" + Conversion::toString(unusedIndex);
            unusedIndex++;
        }
        if (port->isTriggering()) {
            portName = portName + "t";
        }
        port->setName(portName);
    }
 
    // Rename the function unit. All operation names are appended to the
    // function unit name.
    std::string name;
    for (int i = 0; i < fu->operationCount(); i++) {
        if (i > 0) name += "_";
        name += fu->operation(i)->name();
    }
 
    Machine* machine = model_->getMachine();
    std::string fuName = name;
    int i = 1;
    while (machine->functionUnitNavigator().hasItem(fuName)) {        
        fuName = name + "_" + Conversion::toString(i);
        i++;
    }
 
    fu->setName(fuName);
    model_->pushToStack();
    machine->addFunctionUnit(*fu);
    model_->notifyObservers();
 
}

References TTAMachine::Machine::addFunctionUnit(), HDB::FUArchitecture::architecture(), Exception::errorMessage(), fuArchitectures_, TTAMachine::Machine::functionUnitNavigator(), Model::getMachine(), TTAMachine::Machine::Navigator< ComponentType >::hasItem(), ListItemData::id, TTAMachine::ExecutionPipeline::isPortRead(), TTAMachine::ExecutionPipeline::isPortWritten(), TTAMachine::FUPort::isTriggering(), MapTools::keyForValue(), TTAMachine::HWOperation::latency(), list_, machine, model_, TTAMachine::HWOperation::name(), Model::notifyObservers(), TTAMachine::FunctionUnit::operation(), TTAMachine::FunctionUnit::operationCount(), TTAMachine::HWOperation::pipeline(), TTAMachine::FunctionUnit::port(), TTAMachine::Unit::portCount(), Model::pushToStack(), TTAMachine::FunctionUnit::saveState(), TTAMachine::FunctionUnit::setName(), TTAMachine::Port::setName(), Conversion::toString(), and WxConversion::toWxString().

Here is the call graph for this function:

onClose()

void AddFUFromHDBDialog::onClose ( wxCommandEvent &  event )

private

Closes the dialog when the close button is pressed.

Definition at line 482 of file AddFUFromHDBDialog.cc.

                                           {
    Close();
}

onColumnClick()

void AddFUFromHDBDialog::onColumnClick ( wxListEvent &  event )

private

Sorts HDB FU list according to clicked column.

Definition at line 536 of file AddFUFromHDBDialog.cc.

                                                    {
 
    int clickedColumn = event.GetColumn();
 
    if (clickedColumn == sortColumn_) {
        sortASC_ = !sortASC_;
    } else {
        sortASC_ = true;
        setColumnImage(sortColumn_, -1);    // removes arrow from old column
        sortColumn_ = clickedColumn;
    }
 
    setColumnImage(clickedColumn, sortASC_);
 
    if (sortASC_) {
        list_->SortItems(FUListCompareASC, clickedColumn);
    } else {
        list_->SortItems(FUListCompareDESC, clickedColumn);
    }
}

References FUListCompareASC(), FUListCompareDESC(), list_, setColumnImage(), sortASC_, and sortColumn_.

Here is the call graph for this function:

onFilterChange()

void AddFUFromHDBDialog::onFilterChange ( wxCommandEvent &  event )

private

Updates FU architecture list view accordingly to new filter rule.

Definition at line 353 of file AddFUFromHDBDialog.cc.

                                                  {
    if (filterTimer_.Start(250, /*oneShot = */ true)) {
        return;
    }
 
    // Timer could not be started for some reason.
    // Do filtering immediately instead.
    AddFUFromHDBDialog::TransferDataToWindow();
}

References filterTimer_, and TransferDataToWindow().

Here is the call graph for this function:

onFilterTimeOut()

void AddFUFromHDBDialog::onFilterTimeOut ( wxTimerEvent &  event )

private

Definition at line 365 of file AddFUFromHDBDialog.cc.

                                                 {
    AddFUFromHDBDialog::TransferDataToWindow();
}

References TransferDataToWindow().

Here is the call graph for this function:

onListSelectionChange()

void AddFUFromHDBDialog::onListSelectionChange ( wxListEvent &  event )

private

Enables and disables the delete button according to slot list selection.

Definition at line 374 of file AddFUFromHDBDialog.cc.

                                                      {
    if (list_->GetSelectedItemCount() == 1) {
        FindWindow(ID_ADD)->Enable();
    } else {
        FindWindow(ID_ADD)->Disable();
    }
}

References ID_ADD, and list_.

setColumnImage()

void AddFUFromHDBDialog::setColumnImage ( int  col, int  image  )

private

Sets sorting arrow image on selected column

Parameters

col	Column index to set the image
image	Image index in wxImageList

Definition at line 565 of file AddFUFromHDBDialog.cc.

                                                     {
    wxListItem item;
    item.SetMask(wxLIST_MASK_IMAGE);
    item.SetImage(image);
    list_->SetColumn(col, item);
}

References list_.

Referenced by loadHDB(), and onColumnClick().

TransferDataToWindow()

bool AddFUFromHDBDialog::TransferDataToWindow ( )

privatevirtual

Transfers data from the HDBs to the dialog list widget.

Definition at line 181 of file AddFUFromHDBDialog.cc.

                                         {
 
    MapTools::deleteAllValues(fuArchitectures_);
    list_->DeleteAllItems();
 
    if (filterCtrl_) {
        std::string tmp = WxConversion::toString(filterCtrl_->GetValue());
        std::istringstream rawFilterRules(tmp.c_str());
        filterPatterns_.clear();
        std::string keyword;
        while (rawFilterRules >> keyword) {
            filterPatterns_.push_back(keyword);
        }
    }
 
    HDBRegistry& registry = HDBRegistry::instance();
    registry.loadFromSearchPaths();
 
    for (int i = 0; i < registry.hdbCount(); i++) {
        loadHDB(registry.hdb(i));
    }
 
    wxString message;
    for (int i = 0; i < registry.hdbErrorCount(); i++) {
        message.Append(WxConversion::toWxString(registry.hdbErrorMessage(i)));
        message.Append(_T("\n"));
        WarningDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    if (registry.hdbCount() < 1) {
        wxString message = _T("No HDBs found in HDB search paths.");
        WarningDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    list_->SetColumnWidth(1, 200);
    list_->SetColumnWidth(4, wxLIST_AUTOSIZE);
    return wxDialog::TransferDataToWindow();
}

References MapTools::deleteAllValues(), filterCtrl_, filterPatterns_, fuArchitectures_, HDB::HDBRegistry::hdb(), HDB::HDBRegistry::hdbCount(), HDB::HDBRegistry::hdbErrorCount(), HDB::HDBRegistry::hdbErrorMessage(), HDB::HDBRegistry::instance(), list_, HDB::HDBRegistry::loadFromSearchPaths(), loadHDB(), WxConversion::toString(), and WxConversion::toWxString().

Referenced by onFilterChange(), and onFilterTimeOut().

Here is the call graph for this function:

Member Data Documentation

filterCtrl_

wxSearchCtrl* AddFUFromHDBDialog::filterCtrl_ = nullptr

private

The list filter text control.

Definition at line 92 of file AddFUFromHDBDialog.hh.

Referenced by createContents(), and TransferDataToWindow().

filterPatterns_

std::vector<std::string> AddFUFromHDBDialog::filterPatterns_

private

Keywords to filter HDB entries.

Definition at line 94 of file AddFUFromHDBDialog.hh.

Referenced by loadHDB(), and TransferDataToWindow().

filterTimer_

wxTimer AddFUFromHDBDialog::filterTimer_

private

Timer to postpone filtering while typing filter patterns.

Definition at line 96 of file AddFUFromHDBDialog.hh.

Referenced by onFilterChange().

fuArchitectures_

std::map<int, HDB::FUArchitecture*> AddFUFromHDBDialog::fuArchitectures_

private

Map of iu architectures displayed in the dialog list.

Definition at line 90 of file AddFUFromHDBDialog.hh.

Referenced by loadHDB(), onAdd(), TransferDataToWindow(), and ~AddFUFromHDBDialog().

HDB_FILE_FILTER

const wxString AddFUFromHDBDialog::HDB_FILE_FILTER = _T("*.hdb")

staticprivate

File filter for HDB files.

Definition at line 112 of file AddFUFromHDBDialog.hh.

list_

wxListCtrl* AddFUFromHDBDialog::list_

private

Immediate slot list widget.

Definition at line 88 of file AddFUFromHDBDialog.hh.

Referenced by AddFUFromHDBDialog(), loadHDB(), onAdd(), onColumnClick(), onListSelectionChange(), setColumnImage(), and TransferDataToWindow().

model_

Model* AddFUFromHDBDialog::model_

private

Model of the current adf file.

Definition at line 86 of file AddFUFromHDBDialog.hh.

Referenced by onAdd().

sortASC_

bool AddFUFromHDBDialog::sortASC_

private

Definition at line 99 of file AddFUFromHDBDialog.hh.

Referenced by loadHDB(), and onColumnClick().

sortColumn_

int AddFUFromHDBDialog::sortColumn_

private

Definition at line 98 of file AddFUFromHDBDialog.hh.

Referenced by onColumnClick().

---

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

• AddFUFromHDBDialog.hh
• AddFUFromHDBDialog.cc