AutoSelectImplementationsDialog Class Reference

#include <AutoSelectImplementationsDialog.hh>

Inheritance diagram for AutoSelectImplementationsDialog:

Collaboration diagram for AutoSelectImplementationsDialog:

Classes
struct	HdbIdPair

Public Member Functions
	AutoSelectImplementationsDialog (wxWindow *parent, TTAMachine::Machine &machine, IDF::MachineImplementation &impl)
virtual	~AutoSelectImplementationsDialog ()

Private Types
enum	{   ID_HDB_CHOICE, ID_BROWSE, ID_LINE, ID_TEXT,   ID_FIND, ID_RF, ID_IU, ID_FU,   ID_CLOSE }

Private Member Functions
wxSizer *	createContents (wxWindow *parent, bool call_fit, bool set_sizer)
void	onBrowse (wxCommandEvent &event)
void	onClose (wxCommandEvent &event)
void	onFind (wxCommandEvent &event)
void	findRFImplementations (HDB::HDBManager &hdb)
void	findIUImplementations (HDB::HDBManager &hdb)
void	findFUImplementations (HDB::HDBManager &hdb)

Private Attributes
TTAMachine::Machine &	machine_
	Machine containing navigators fo RFs, IUs and FUs. More...
IDF::MachineImplementation &	impl_
wxChoice *	hdbChoice_
	Choice selection for list of HDB files. More...
wxCheckBox *	cboxRF_
	Checkbox widget for register file flag. More...
wxCheckBox *	cboxIU_
	Checkbox widget for immediate unit flag. More...
wxCheckBox *	cboxFU_
	Checkbox widget for function unit flag. More...
std::set< TCEString >	hdbs_
	Set for hdb paths. More...
std::map< const IDF::UnitImplementationLocation *, HdbIdPair >	foundRF_
std::map< const IDF::UnitImplementationLocation *, HdbIdPair >	foundIU_
std::map< const IDF::UnitImplementationLocation *, HdbIdPair >	foundFU_

Static Private Attributes
static const std::string	defaultHDB_

Detailed Description

Dialog for searching and selecting implementations for empty RF/IU/FU units automatically from user chosen HDB file.

Definition at line 59 of file AutoSelectImplementationsDialog.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
ID_HDB_CHOICE
ID_BROWSE
ID_LINE
ID_TEXT
ID_FIND
ID_RF
ID_IU
ID_FU
ID_CLOSE

Definition at line 111 of file AutoSelectImplementationsDialog.hh.

         {
        ID_HDB_CHOICE,
        ID_BROWSE,
        ID_LINE,
        ID_TEXT,
        ID_FIND,
        ID_RF,
        ID_IU,
        ID_FU,
        ID_CLOSE
    };

Constructor & Destructor Documentation

AutoSelectImplementationsDialog()

AutoSelectImplementationsDialog::AutoSelectImplementationsDialog	(	wxWindow *	parent,
		TTAMachine::Machine &	machine,
		IDF::MachineImplementation &	impl
	)

The Constructor.

Parameters

parent	Parent window of the dialog.
machine	Current machine.
impl	Implementation of the machine.

Definition at line 69 of file AutoSelectImplementationsDialog.cc.

                                 :
    wxDialog(parent, -1, _T("Auto Select Implementations"), wxDefaultPosition),
    machine_(machine),
    impl_(impl) {
    
    createContents(this, true, true);
    
    hdbChoice_ = dynamic_cast<wxChoice*>(FindWindow(ID_HDB_CHOICE));
    cboxRF_ = dynamic_cast<wxCheckBox*>(FindWindow(ID_RF));
    cboxIU_ = dynamic_cast<wxCheckBox*>(FindWindow(ID_IU));
    cboxFU_ = dynamic_cast<wxCheckBox*>(FindWindow(ID_FU));
    
    // set all checkboxes as selected
    cboxRF_->SetValue(true);
    cboxIU_->SetValue(true);
    cboxFU_->SetValue(true);
 
    // add available HDBs to the choice list
    HDBRegistry& registry = HDBRegistry::instance();
    registry.loadFromSearchPaths();
    for (int i = 0; i < registry.hdbCount(); i++) {
        hdbs_.insert(registry.hdbPath(i));
    }
    if (!hdbs_.empty()) {
        std::set<TCEString>::iterator iter = hdbs_.begin();
        bool defaultHDBFound = false;
        int selection = 0;
        for (; iter != hdbs_.end(); iter++) {
            std::string shortPath = Environment::shortHDBPath(*iter);
            hdbChoice_->Append(WxConversion::toWxString(shortPath));
            if (!defaultHDBFound && StringTools::endsWith(*iter, defaultHDB_)) {
                selection = hdbChoice_->GetCount() - 1;
                defaultHDBFound = true;
            }
        }
        hdbChoice_->SetSelection(selection);
    }
}

References StringTools::endsWith(), HDB::HDBRegistry::hdbCount(), HDB::HDBRegistry::hdbPath(), HDB::HDBRegistry::loadFromSearchPaths(), Environment::shortHDBPath(), and WxConversion::toWxString().

Here is the call graph for this function:

~AutoSelectImplementationsDialog()

AutoSelectImplementationsDialog::~AutoSelectImplementationsDialog ( )

virtual

The Destructor.

Definition at line 114 of file AutoSelectImplementationsDialog.cc.

                                                                  {
}

Member Function Documentation

createContents()

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

private

Creates the dialog widgets.

Definition at line 438 of file AutoSelectImplementationsDialog.cc.

                    {
 
    wxFlexGridSizer *item0 = new wxFlexGridSizer( 1, 0, 0 );
    item0->AddGrowableCol( 0 );
    item0->AddGrowableRow( 1 );
 
    wxBoxSizer *item1 = new wxBoxSizer( wxHORIZONTAL );
 
    wxStaticText *itemText = new wxStaticText( parent, ID_TEXT, wxT("HDB file:"), wxDefaultPosition, wxDefaultSize, 0 );
    item1->Add( itemText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxString *strs2 = (wxString*) NULL;
    wxChoice *item2 = new wxChoice( parent, ID_HDB_CHOICE, wxDefaultPosition, wxSize(250,-1), 0, strs2, 0 );
    item1->Add( item2, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *item3 = new wxButton( parent, ID_BROWSE, wxT("Browse..."), wxDefaultPosition, wxDefaultSize, 0 );
    item1->Add( item3, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxButton *buttonFind = new wxButton( parent, ID_FIND, wxT("Find"), wxDefaultPosition, wxDefaultSize, 0 );
    item1->Add( buttonFind, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item0->Add( item1, 0, wxALIGN_CENTER|wxALL, 5 );
 
    wxBoxSizer *cboxSizer = new wxBoxSizer( wxHORIZONTAL );
 
    wxStaticText *cboxText = new wxStaticText( parent, ID_TEXT, wxT("Do selections for:"), wxDefaultPosition, wxDefaultSize, 0 );
    cboxSizer->Add( cboxText, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxCheckBox *cboxRF = new wxCheckBox( parent, ID_RF, wxT("Register Files"), wxDefaultPosition, wxDefaultSize, 0 );
    cboxSizer->Add( cboxRF, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxCheckBox *cboxIU = new wxCheckBox( parent, ID_IU, wxT("Immediate Units"), wxDefaultPosition, wxDefaultSize, 0 );
    cboxSizer->Add( cboxIU, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxCheckBox *cboxFU = new wxCheckBox( parent, ID_FU, wxT("Function Units"), wxDefaultPosition, wxDefaultSize, 0 );
    cboxSizer->Add( cboxFU, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
    
    item0->Add( cboxSizer, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
    wxStaticLine *item5 = new wxStaticLine( parent, ID_LINE, wxDefaultPosition, wxSize(20,-1), wxLI_HORIZONTAL );
    item0->Add( item5, 0, wxGROW|wxALL, 5 );
    
    wxBoxSizer *item6 = new wxBoxSizer( wxHORIZONTAL );
 
    wxButton *closeButton = new wxButton( parent, ID_CLOSE, wxT("Close"), wxDefaultPosition, wxDefaultSize, 0 );
    item6->Add( closeButton, 0, wxALIGN_CENTER|wxALL, 5 );
 
    item0->Add( item6, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );
 
 
    if (set_sizer)
    {
        parent->SetSizer( item0 );
        if (call_fit)
            item0->SetSizeHints( parent );
    }
 
    return item0;
}

findFUImplementations()

void AutoSelectImplementationsDialog::findFUImplementations ( HDB::HDBManager &  hdb )

private

Function that searches FU implementations from given HDB file.

Parameters

hdb	HDB file from which implementations are searched.

Definition at line 394 of file AutoSelectImplementationsDialog.cc.

                                                                      {
 
    // this component searches proper implementations for function units
    ComponentImplementationSelector* selector = 
        new ComponentImplementationSelector();
    // add the HDB file to selector for searching
    selector->addHDB(hdb);
 
    std::map<const FUImplementationLocation*, CostEstimates*> fuImpls;
    std::map<const FUImplementationLocation*, CostEstimates*>::iterator it;
 
    // loop through machine's function units
    int fuCount = machine_.functionUnitNavigator().count();
    for (int i = 0; i < fuCount; ++i) {
        Component* comp = machine_.functionUnitNavigator().item(i);
        FunctionUnit* fu = dynamic_cast<FunctionUnit*>(comp);
 
        // if function unit doesn't have an implementation...
        if (fu != NULL && !impl_.hasFUImplementation(fu->name())) {
            // ...try to find one using the selector component
            fuImpls = selector->fuImplementations(*fu);
            it = fuImpls.begin();
 
            // if an implementation was found, save it into the std::map
            if (fuImpls.size() > 0 && it->first != NULL) {
                const FUImplementationLocation* location = it->first;
                HdbIdPair locationInfo;
                locationInfo.hdbFile = hdb.fileName();
                locationInfo.id = location->id();
 
                foundFU_.insert(
                    std::pair<const FUImplementationLocation*, HdbIdPair>(
                        location, locationInfo));
            }
        }
    }
 
    delete selector;
}

References ComponentImplementationSelector::addHDB(), HDB::HDBManager::fileName(), ComponentImplementationSelector::fuImplementations(), AutoSelectImplementationsDialog::HdbIdPair::hdbFile, IDF::UnitImplementationLocation::id(), AutoSelectImplementationsDialog::HdbIdPair::id, and TTAMachine::Component::name().

Here is the call graph for this function:

findIUImplementations()

void AutoSelectImplementationsDialog::findIUImplementations ( HDB::HDBManager &  hdb )

private

Function that searches IU implementations from given HDB file.

Parameters

hdb	HDB file from which implementations are searched.

Definition at line 348 of file AutoSelectImplementationsDialog.cc.

                                                                      {
 
    // this component searches proper implementations for immediate units
    ComponentImplementationSelector* selector = 
        new ComponentImplementationSelector();
    // add the HDB file to selector for searching
    selector->addHDB(hdb);
 
    std::map<const RFImplementationLocation*, CostEstimates*> iuImpls;
    std::map<const RFImplementationLocation*, CostEstimates*>::iterator it;
 
    // loop through machine's immediate units
    int iuCount = machine_.immediateUnitNavigator().count();
    for (int i = 0; i < iuCount; ++i) {
        Component* comp = machine_.immediateUnitNavigator().item(i);
        ImmediateUnit* iu = dynamic_cast<ImmediateUnit*>(comp);
 
        // if immediate unit doesn't have an implementation...
        if (iu != NULL  && !impl_.hasIUImplementation(iu->name())) {
            // ...try to find one using the selector component
            iuImpls = selector->iuImplementations(*iu);
            it = iuImpls.begin();
 
            // if an implementation was found, save it into the std::map
            if (iuImpls.size() > 0 && it->first != NULL) {
                const RFImplementationLocation* location = it->first;
                HdbIdPair locationInfo;
                locationInfo.hdbFile = hdb.fileName();
                locationInfo.id = location->id();
 
                foundIU_.insert(
                    std::pair<const RFImplementationLocation*, HdbIdPair>(
                        location, locationInfo));
            }
        }
    }
 
    delete selector;
}

References ComponentImplementationSelector::addHDB(), HDB::HDBManager::fileName(), AutoSelectImplementationsDialog::HdbIdPair::hdbFile, IDF::UnitImplementationLocation::id(), AutoSelectImplementationsDialog::HdbIdPair::id, ComponentImplementationSelector::iuImplementations(), and TTAMachine::Component::name().

Here is the call graph for this function:

findRFImplementations()

void AutoSelectImplementationsDialog::findRFImplementations ( HDB::HDBManager &  hdb )

private

Function that searches RF implementations from given HDB file.

Parameters

hdb	HDB file from which implementations are searched.

Definition at line 302 of file AutoSelectImplementationsDialog.cc.

                                                                      {
 
    // this component searches proper implementations for register files
    ComponentImplementationSelector* selector = 
        new ComponentImplementationSelector();
    // add the HDB file to selector for searching
    selector->addHDB(hdb);
 
    std::map<const RFImplementationLocation*, CostEstimates*> rfImpls;
    std::map<const RFImplementationLocation*, CostEstimates*>::iterator it;
 
    // loop through machine's register files
    int rfCount = machine_.registerFileNavigator().count();
    for (int i = 0; i < rfCount; ++i) {
        Component* comp = machine_.registerFileNavigator().item(i);
        RegisterFile* rf = dynamic_cast<RegisterFile*>(comp);
        
        // if register file doesn't have an implementation...
        if (rf != NULL && !impl_.hasRFImplementation(rf->name())) {
            // ...try to find one using the selector component
            rfImpls = selector->rfImplementations(*rf, rf->isUsedAsGuard());
            it = rfImpls.begin();
 
            // if an implementation was found, save it into the std::map
            if (rfImpls.size() > 0 && it->first != NULL) {
                const RFImplementationLocation* location = it->first;
                HdbIdPair locationInfo;
                locationInfo.hdbFile = hdb.fileName();
                locationInfo.id = location->id();
 
                foundRF_.insert(
                    std::pair<const RFImplementationLocation*, HdbIdPair>(
                        location, locationInfo));
            }
        }
    }
 
    delete selector;
}

References ComponentImplementationSelector::addHDB(), HDB::HDBManager::fileName(), AutoSelectImplementationsDialog::HdbIdPair::hdbFile, IDF::UnitImplementationLocation::id(), AutoSelectImplementationsDialog::HdbIdPair::id, TTAMachine::RegisterFile::isUsedAsGuard(), TTAMachine::Component::name(), and ComponentImplementationSelector::rfImplementations().

Here is the call graph for this function:

onBrowse()

void AutoSelectImplementationsDialog::onBrowse ( wxCommandEvent &  event )

private

File dialog for choosing a custom HDB file.

Definition at line 121 of file AutoSelectImplementationsDialog.cc.

                                                         {
 
    wxFileDialog dialog(
        this, _T("Choose a HDB file containing the implementation"),
        _T(""), _T(""), _T("HDBs|*.hdb|All files|*.*"),
        (wxOPEN | wxFILE_MUST_EXIST));
 
    if (dialog.ShowModal() == wxID_OK) {
        std::string hdb = std::string(dialog.GetPath().mb_str());
        hdb = Environment::shortHDBPath(hdb);
        auto wxHDB = WxConversion::toWxString(hdb);
        int item = hdbChoice_->FindString(wxHDB);
        if (item == wxNOT_FOUND) {
            item = hdbChoice_->Append(wxHDB);
        }
        hdbChoice_->Select(item);
    }
}

References Environment::shortHDBPath(), and WxConversion::toWxString().

Here is the call graph for this function:

onClose()

void AutoSelectImplementationsDialog::onClose ( wxCommandEvent &  event )

private

Exit the dialog.

Definition at line 144 of file AutoSelectImplementationsDialog.cc.

                                                        {
    Close();
}

onFind()

void AutoSelectImplementationsDialog::onFind ( wxCommandEvent &  event )

private

Searches implementations for empty RF/IU/FU units.

After search is over and if implementations were found, user is asked if he/she wants to integrate the found implementations to the current machine implementation.

Definition at line 156 of file AutoSelectImplementationsDialog.cc.

                                                       {
 
    foundRF_.clear();
    foundIU_.clear();
    foundFU_.clear();
 
    // if none of the check boxes are selected, no point in searching
    if (!cboxRF_->GetValue() && !cboxIU_->GetValue() && !cboxFU_->GetValue()) {
        return;
    }
 
    // extract path of the HDB file that user has chosen
    TCEString path = WxConversion::toString(hdbChoice_->GetStringSelection());
    path = Environment::longHDBPath(path);
    // make sure the file exists
    if (!FileSystem::fileExists(path)) {
        wxString message = _T("Error: path ");
        message.append(WxConversion::toWxString(path));
        message.append(_T(" could not be found!\n"));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
 
    // pass the hdb file to search functions for implementation searching
    try {
        HDBManager& hdb = HDBRegistry::instance().hdb(path);
        
        if (cboxRF_->GetValue()) {
            findRFImplementations(hdb);
        }
        if (cboxIU_->GetValue()) {
            findIUImplementations(hdb);
        }
        if (cboxFU_->GetValue()) {
            findFUImplementations(hdb);
        }
    } catch (Exception& e) {
        wxString message = _T("");
        message.append(WxConversion::toWxString(e.errorMessage()));
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
    
    unsigned int rfCount = static_cast<unsigned int>(foundRF_.size());
    unsigned int iuCount = static_cast<unsigned int>(foundIU_.size());
    unsigned int fuCount = static_cast<unsigned int>(foundFU_.size());
 
    // form a message describing how many implementations were found
    wxString message = _T("");
    message.append(WxConversion::toWxString(rfCount+iuCount+fuCount));
    message.append(_T(" implementations were found for ")); 
    if (cboxRF_->GetValue()) {
        message.append(_T("RF ("));
        message.append(WxConversion::toWxString(rfCount));
        message.append(_T(")"));
    }
    if (cboxIU_->GetValue()) {
        if (cboxRF_->GetValue()) {
            message.append(_T(" / "));
        }
        message.append(_T("IU ("));
        message.append(WxConversion::toWxString(iuCount));
        message.append(_T(")"));
    }
    if (cboxFU_->GetValue()) {
        if (cboxIU_->GetValue() || cboxRF_->GetValue()) {
            message.append(_T(" / "));
        }
        message.append(_T("FU ("));
        message.append(WxConversion::toWxString(fuCount));
        message.append(_T(")"));
    }
    message.append(_T(" units that have no implementations yet.\n\n"));
    
    // if no implementations were found, prompt user and exit
    if ((rfCount+iuCount+fuCount) == 0) {
        WarningDialog dialog(this, message);
        dialog.ShowModal();
        return;
    }
    
    message.append(_T("Press Yes to integrate found implementations into"));
    message.append(_T(" the empty units.\n"));
 
    // ask if user wants to save the found implementations
    ConfirmDialog dialog(this, message);
    if (dialog.ShowModal() != wxID_YES) {
        return;
    }
    
    // add all the newly found implementations to the machine implementation
    
    // steps: set the new HDB file and ID pair for the unit implementation,
    // and then add the unit implementation to the machine implementation 
    std::map<const RFImplementationLocation*, HdbIdPair>::iterator itRF;
    for (itRF = foundRF_.begin(); itRF != foundRF_.end(); ++itRF) {
        const RFImplementationLocation* unit = itRF->first;
        HdbIdPair hdbID = itRF->second;
        RFImplementationLocation* rf = new RFImplementationLocation(
            hdbID.hdbFile, hdbID.id, unit->unitName());
        try {
            impl_.addRFImplementation(rf);
        } catch (...) {
            // do nothing if the implementation could not be added
        }
    }
 
    std::map<const RFImplementationLocation*, HdbIdPair>::iterator itIU;
    for (itIU = foundIU_.begin(); itIU != foundIU_.end(); ++itIU) {
        const RFImplementationLocation* unit = itIU->first;
        HdbIdPair hdbID = itIU->second;
        RFImplementationLocation* iu = new RFImplementationLocation(
            hdbID.hdbFile, hdbID.id, unit->unitName());
        try {
            impl_.addIUImplementation(iu);
        } catch (...) {
            // do nothing if the implementation could not be added
        }
    }
 
    std::map<const FUImplementationLocation*, HdbIdPair>::iterator itFU;
    for (itFU = foundFU_.begin(); itFU != foundFU_.end(); ++itFU) {
        const FUImplementationLocation* unit = itFU->first;
        HdbIdPair hdbID = itFU->second;
        FUImplementationLocation* fu = new FUImplementationLocation(
            hdbID.hdbFile, hdbID.id, unit->unitName());
        try {
            impl_.addFUImplementation(fu);
        } catch (...) {
            // do nothing if the implementation could not be added
        }
    }
 
    // exit to update the RF/IU/FU implementation list view for user
    wxCommandEvent dummy;
    onClose(dummy);
}

References dummy, Exception::errorMessage(), FileSystem::fileExists(), AutoSelectImplementationsDialog::HdbIdPair::hdbFile, AutoSelectImplementationsDialog::HdbIdPair::id, Environment::longHDBPath(), WxConversion::toString(), WxConversion::toWxString(), and IDF::UnitImplementationLocation::unitName().

Here is the call graph for this function:

Member Data Documentation

cboxFU_

wxCheckBox* AutoSelectImplementationsDialog::cboxFU_

private

Checkbox widget for function unit flag.

Definition at line 91 of file AutoSelectImplementationsDialog.hh.

cboxIU_

wxCheckBox* AutoSelectImplementationsDialog::cboxIU_

private

Checkbox widget for immediate unit flag.

Definition at line 89 of file AutoSelectImplementationsDialog.hh.

cboxRF_

wxCheckBox* AutoSelectImplementationsDialog::cboxRF_

private

Checkbox widget for register file flag.

Definition at line 87 of file AutoSelectImplementationsDialog.hh.

defaultHDB_

const std::string AutoSelectImplementationsDialog::defaultHDB_

staticprivate

Definition at line 97 of file AutoSelectImplementationsDialog.hh.

foundFU_

std::map<const IDF::UnitImplementationLocation*, HdbIdPair> AutoSelectImplementationsDialog::foundFU_

private

Definition at line 109 of file AutoSelectImplementationsDialog.hh.

foundIU_

std::map<const IDF::UnitImplementationLocation*, HdbIdPair> AutoSelectImplementationsDialog::foundIU_

private

Definition at line 108 of file AutoSelectImplementationsDialog.hh.

foundRF_

std::map<const IDF::UnitImplementationLocation*, HdbIdPair> AutoSelectImplementationsDialog::foundRF_

private

Definition at line 107 of file AutoSelectImplementationsDialog.hh.

hdbChoice_

wxChoice* AutoSelectImplementationsDialog::hdbChoice_

private

Choice selection for list of HDB files.

Definition at line 84 of file AutoSelectImplementationsDialog.hh.

hdbs_

std::set<TCEString> AutoSelectImplementationsDialog::hdbs_

private

Set for hdb paths.

Definition at line 94 of file AutoSelectImplementationsDialog.hh.

impl_

IDF::MachineImplementation& AutoSelectImplementationsDialog::impl_

private

Definition at line 81 of file AutoSelectImplementationsDialog.hh.

machine_

TTAMachine::Machine& AutoSelectImplementationsDialog::machine_

private

Machine containing navigators fo RFs, IUs and FUs.

Definition at line 79 of file AutoSelectImplementationsDialog.hh.

---

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

• AutoSelectImplementationsDialog.hh
• AutoSelectImplementationsDialog.cc