| /* Copyright (c) 2012 Massachusetts Institute of Technology |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to deal |
| * in the Software without restriction, including without limitation the rights |
| * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| * copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| * THE SOFTWARE. |
| */ |
| |
| #include "model/electrical/MatrixArbiter.h" |
| |
| #include <cmath> |
| #include <vector> |
| |
| #include "model/PortInfo.h" |
| #include "model/EventInfo.h" |
| #include "model/TransitionInfo.h" |
| #include "model/ModelGen.h" |
| #include "model/std_cells/StdCell.h" |
| #include "model/std_cells/StdCellLib.h" |
| |
| namespace DSENT |
| { |
| using std::abs; |
| using std::vector; |
| |
| MatrixArbiter::MatrixArbiter(const String& instance_name_, const TechModel* tech_model_) |
| : ElectricalModel(instance_name_, tech_model_) |
| { |
| initParameters(); |
| initProperties(); |
| } |
| |
| MatrixArbiter::~MatrixArbiter() |
| {} |
| |
| void MatrixArbiter::initParameters() |
| { |
| addParameterName("NumberRequests"); |
| return; |
| } |
| |
| void MatrixArbiter::initProperties() |
| { |
| return; |
| } |
| |
| MatrixArbiter* MatrixArbiter::clone() const |
| { |
| // TODO |
| return NULL; |
| } |
| |
| void MatrixArbiter::constructModel() |
| { |
| // Get parameters |
| unsigned int number_requests = getParameter("NumberRequests").toUInt(); |
| |
| ASSERT(number_requests > 0, "[Error] " + getInstanceName() + |
| " -> Number of requests must be > 0!"); |
| |
| // Connect ports |
| createInputPort("CK"); |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| createInputPort("Request" + (String)i); |
| createOutputPort("Grant" + (String)i); |
| } |
| |
| // Create area, power, event results |
| createElectricalResults(); |
| getEventInfo("Idle")->setStaticTransitionInfos(); |
| getEventInfo("Idle")->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0)); |
| // for(unsigned int i = 0; i <= number_requests; ++i) |
| // { |
| // // Create arbitrate event with i requests |
| // createElectricalEventResult("Arbitrate" + (String)i); |
| // EventInfo* event_info = getEventInfo("Arbitrate" + (String)i); |
| // event_info->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0)); |
| // |
| // for(unsigned int j = 0; j < i; ++j) |
| // { |
| // event_info->setTransitionInfo("Request" + (String)j, TransitionInfo(0.0, 0.0, 1.0)); |
| // } |
| // for(unsigned int j = i; j < number_requests; ++j) |
| // { |
| // event_info->setTransitionInfo("Request" + (String)j, TransitionInfo(1.0, 0.0, 0.0)); |
| // |
| // } |
| // //double P_0 = (double)(number_requests - i) / (double)(number_requests); |
| // //double P_1 = (double)(i) / (double)(number_requests); |
| // //TransitionInfo trans(P_0 * P_0, P_0 * P_1, P_1 * P_1); |
| // |
| // //for(unsigned int j = 0; j < number_requests; ++j) |
| // //{ |
| // // event_info->setTransitionInfo("Request" + (String)j, trans); |
| // //} |
| // } |
| createElectricalEventResult("Arbitrate"); |
| getEventInfo("Arbitrate")->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0)); |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| getEventInfo("Arbitrate")->setTransitionInfo("Request" + (String)i, TransitionInfo(0.25, 0.25, 0.25)); |
| } |
| |
| if(number_requests == 1) |
| { |
| assign("Grant0", "Request0"); |
| } |
| else |
| { |
| // Init components |
| vector<String> g_inv_names(number_requests, ""); |
| vector<StdCell*> g_invs(number_requests, NULL); |
| vector<String> g_and2_names(number_requests, ""); |
| vector<StdCell*> g_and2s(number_requests, NULL); |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| g_inv_names[i] = "G_INV" + (String)i; |
| g_and2_names[i] = "G_AND2" + (String)i; |
| g_invs[i] = getTechModel()->getStdCellLib()->createStdCell("INV", g_inv_names[i]); |
| g_invs[i]->construct(); |
| g_and2s[i] = getTechModel()->getStdCellLib()->createStdCell("AND2", g_and2_names[i]); |
| g_and2s[i]->construct(); |
| } |
| |
| unsigned int number_states = (number_requests - 1) * number_requests / 2; |
| |
| vector<String> w_or2_names(number_states, ""); |
| vector<StdCell*> w_or2s(number_states, NULL); |
| vector<String> w_and2_names(number_states, ""); |
| vector<StdCell*> w_and2s(number_states, NULL); |
| vector<String> w_inv_names(number_states, ""); |
| vector<StdCell*> w_invs(number_states, NULL); |
| vector<String> w_dff_names(number_states, ""); |
| vector<StdCell*> w_dffs(number_states, NULL); |
| vector<String> dis_and2_names(number_states * 2, ""); |
| vector<StdCell*> dis_and2s(number_states * 2, NULL); |
| vector<String> dis_inv_names(number_states, ""); |
| vector<StdCell*> dis_invs(number_states, NULL); |
| unsigned int state_count = 0; |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| for(unsigned int j = i + 1; j < number_requests; ++j) |
| { |
| w_or2_names[state_count] = String::format("W_OR2_%d_%d", i, j); |
| w_and2_names[state_count] = String::format("W_AND2_%d_%d", i, j); |
| w_inv_names[state_count] = String::format("W_INV_%d_%d", i, j); |
| w_dff_names[state_count] = String::format("W_DFF_%d_%d", i, j); |
| w_or2s[state_count] = getTechModel()->getStdCellLib()->createStdCell("OR2", w_or2_names[state_count]); |
| w_or2s[state_count]->construct(); |
| w_and2s[state_count] = getTechModel()->getStdCellLib()->createStdCell("AND2", w_and2_names[state_count]); |
| w_and2s[state_count]->construct(); |
| w_invs[state_count] = getTechModel()->getStdCellLib()->createStdCell("INV", w_inv_names[state_count]); |
| w_invs[state_count]->construct(); |
| w_dffs[state_count] = getTechModel()->getStdCellLib()->createStdCell("DFFQ", w_dff_names[state_count]); |
| w_dffs[state_count]->construct(); |
| |
| dis_inv_names[state_count] = String::format("Dis_INV_%d_%d", i, j); |
| dis_and2_names[state_count] = String::format("Dis_AND2_%d_%d", i, j); |
| dis_and2_names[state_count + number_states] = String::format("Dis_AND2_%d_%d", j, i); |
| dis_invs[state_count] = getTechModel()->getStdCellLib()->createStdCell("INV", dis_inv_names[state_count]); |
| dis_invs[state_count]->construct(); |
| dis_and2s[state_count] = getTechModel()->getStdCellLib()->createStdCell("AND2", dis_and2_names[state_count]); |
| dis_and2s[state_count]->construct(); |
| dis_and2s[state_count + number_states] = getTechModel()->getStdCellLib()->createStdCell("AND2", dis_and2_names[state_count + number_states]); |
| dis_and2s[state_count + number_states]->construct(); |
| state_count++; |
| } |
| } |
| |
| vector<String> dis_or_names(number_requests, ""); |
| vector<ElectricalModel*> dis_ors(number_requests, NULL); |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| dis_or_names[i] = "Dis_OR" + (String)i; |
| dis_ors[i] = (ElectricalModel*)ModelGen::createModel("OR", dis_or_names[i], getTechModel()); |
| dis_ors[i]->setParameter("NumberInputs", number_requests-1); |
| dis_ors[i]->setParameter("NumberBits", 1); |
| dis_ors[i]->construct(); |
| } |
| |
| state_count = 0; |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| createNet("Dis_OR_Out" + (String)i); |
| createNet("G_INV_Out" + (String)i); |
| portConnect(g_invs[i], "A", "Dis_OR_Out" + (String)i); |
| portConnect(g_invs[i], "Y", "G_INV_Out" + (String)i); |
| portConnect(g_and2s[i], "A", "Request" + (String)i); |
| portConnect(g_and2s[i], "B", "G_INV_Out" + (String)i); |
| portConnect(g_and2s[i], "Y", "Grant" + (String)i); |
| |
| for(unsigned int j = i + 1; j < number_requests; ++j) |
| { |
| createNet(String::format("W_INV_Out_%d_%d", i, j)); |
| createNet(String::format("W_OR2_Out_%d_%d", i, j)); |
| createNet(String::format("W_AND2_Out_%d_%d", i, j)); |
| createNet(String::format("W_DFF_Out_%d_%d", i, j)); |
| portConnect(w_invs[state_count], "A", "Grant" + (String)i); |
| portConnect(w_invs[state_count], "Y", String::format("W_INV_Out_%d_%d", i, j)); |
| portConnect(w_or2s[state_count], "A", String::format("W_DFF_Out_%d_%d", i, j)); |
| portConnect(w_or2s[state_count], "B", "Grant" + (String)j); |
| portConnect(w_or2s[state_count], "Y", String::format("W_OR2_Out_%d_%d", i, j)); |
| portConnect(w_and2s[state_count], "A", String::format("W_OR2_Out_%d_%d", i, j)); |
| portConnect(w_and2s[state_count], "B", String::format("W_INV_Out_%d_%d", i, j)); |
| portConnect(w_and2s[state_count], "Y", String::format("W_AND2_Out_%d_%d", i, j)); |
| portConnect(w_dffs[state_count], "D", String::format("W_AND2_Out_%d_%d", i, j)); |
| portConnect(w_dffs[state_count], "CK", "CK"); |
| portConnect(w_dffs[state_count], "Q", String::format("W_DFF_Out_%d_%d", i, j)); |
| |
| createNet(String::format("Dis_AND2_Out_%d_%d", i, j)); |
| createNet(String::format("Dis_AND2_Out_%d_%d", j, i)); |
| createNet(String::format("Dis_INV_Out_%d_%d", j, i)); |
| portConnect(dis_and2s[state_count], "A", "Request" + (String)i); |
| portConnect(dis_and2s[state_count], "B", String::format("W_DFF_Out_%d_%d", i, j)); |
| portConnect(dis_and2s[state_count], "Y", String::format("Dis_AND2_Out_%d_%d", i, j)); |
| |
| portConnect(dis_invs[state_count], "A", String::format("W_DFF_Out_%d_%d", i, j)); |
| portConnect(dis_invs[state_count], "Y", String::format("Dis_INV_Out_%d_%d", j, i)); |
| portConnect(dis_and2s[state_count + number_states], "A", "Request" + (String)j); |
| portConnect(dis_and2s[state_count + number_states], "B", String::format("Dis_INV_Out_%d_%d", j, i)); |
| portConnect(dis_and2s[state_count + number_states], "Y", String::format("Dis_AND2_Out_%d_%d", j, i)); |
| |
| state_count++; |
| } |
| } |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| unsigned int k = 0; |
| for(unsigned int j = 0; j < number_requests; ++j) |
| { |
| if(i != j) |
| { |
| portConnect(dis_ors[i], "In" + (String)k, String::format("Dis_AND2_Out_%d_%d", j, i)); |
| k++; |
| } |
| } |
| portConnect(dis_ors[i], "Out", "Dis_OR_Out" + (String)i); |
| } |
| |
| // Add instances |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| addSubInstances(g_invs[i], 1.0); |
| addElectricalSubResults(g_invs[i], 1.0); |
| addSubInstances(g_and2s[i], 1.0); |
| addElectricalSubResults(g_and2s[i], 1.0); |
| addSubInstances(dis_ors[i], 1.0); |
| addElectricalSubResults(dis_ors[i], 1.0); |
| } |
| for(unsigned int i = 0; i < number_states; ++i) |
| { |
| addSubInstances(w_or2s[i], 1.0); |
| addElectricalSubResults(w_or2s[i], 1.0); |
| addSubInstances(w_and2s[i], 1.0); |
| addElectricalSubResults(w_and2s[i], 1.0); |
| addSubInstances(w_invs[i], 1.0); |
| addElectricalSubResults(w_invs[i], 1.0); |
| addSubInstances(w_dffs[i], 1.0); |
| addElectricalSubResults(w_dffs[i], 1.0); |
| addSubInstances(dis_and2s[i], 1.0); |
| addElectricalSubResults(dis_and2s[i], 1.0); |
| addSubInstances(dis_and2s[i + number_states], 1.0); |
| addElectricalSubResults(dis_and2s[i + number_states], 1.0); |
| addSubInstances(dis_invs[i], 1.0); |
| addElectricalSubResults(dis_invs[i], 1.0); |
| } |
| |
| // Update event |
| //for(unsigned int i = 0; i <= number_requests; ++i) |
| //{ |
| //Result* arb_event = getEventResult("Arbitrate" + (String)i); |
| Result* arb_event = getEventResult("Arbitrate"); |
| for(unsigned int j = 0; j < number_requests; ++j) |
| { |
| arb_event->addSubResult(g_invs[j]->getEventResult("INV"), g_inv_names[j], 1.0); |
| arb_event->addSubResult(g_and2s[j]->getEventResult("AND2"), g_and2_names[j], 1.0); |
| arb_event->addSubResult(dis_ors[j]->getEventResult("OR"), dis_or_names[j], 1.0); |
| } |
| for(unsigned int j = 0; j < number_states; ++j) |
| { |
| arb_event->addSubResult(w_or2s[j]->getEventResult("OR2"), w_or2_names[j], 1.0); |
| arb_event->addSubResult(w_and2s[j]->getEventResult("AND2"), w_and2_names[j], 1.0); |
| arb_event->addSubResult(w_invs[j]->getEventResult("INV"), w_inv_names[j], 1.0); |
| arb_event->addSubResult(w_dffs[j]->getEventResult("DFFD"), w_dff_names[j], 1.0); |
| arb_event->addSubResult(w_dffs[j]->getEventResult("DFFQ"), w_dff_names[j], 1.0); |
| arb_event->addSubResult(w_dffs[j]->getEventResult("CK"), w_dff_names[j], 1.0); |
| arb_event->addSubResult(dis_and2s[j]->getEventResult("AND2"), dis_and2_names[j], 1.0); |
| arb_event->addSubResult(dis_and2s[j + number_states]->getEventResult("AND2"), dis_and2_names[j + number_states], 1.0); |
| arb_event->addSubResult(dis_invs[j]->getEventResult("INV"), dis_inv_names[j], 1.0); |
| } |
| //} |
| } |
| return; |
| } |
| |
| void MatrixArbiter::propagateTransitionInfo() |
| { |
| // Get parameters |
| unsigned int number_requests = getParameter("NumberRequests").toUInt(); |
| |
| if(number_requests == 1) |
| { |
| propagatePortTransitionInfo("Grant0", "Request0"); |
| } |
| else |
| { |
| unsigned int number_states = (number_requests - 1) * number_requests / 2; |
| |
| vector<ElectricalModel*> g_and2s(number_requests, NULL); |
| vector<ElectricalModel*> g_invs(number_requests, NULL); |
| vector<ElectricalModel*> w_invs(number_states, NULL); |
| vector<ElectricalModel*> w_or2s(number_states, NULL); |
| vector<ElectricalModel*> w_and2s(number_states, NULL); |
| vector<ElectricalModel*> w_dffs(number_states, NULL); |
| vector<ElectricalModel*> dis_invs(number_states, NULL); |
| vector<ElectricalModel*> dis_and2s(number_requests * number_requests, NULL); |
| vector<ElectricalModel*> dis_ors(number_requests, NULL); |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| g_and2s[i] = (ElectricalModel*)getSubInstance("G_AND2" + (String)i); |
| g_invs[i] = (ElectricalModel*)getSubInstance("G_INV" + (String)i); |
| dis_ors[i] = (ElectricalModel*)getSubInstance("Dis_OR" + (String)i); |
| } |
| unsigned int state_count = 0; |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| for(unsigned int j = i + 1; j < number_requests; ++j) |
| { |
| w_invs[state_count] = (ElectricalModel*)getSubInstance(String::format("W_INV_%d_%d", i, j)); |
| w_or2s[state_count] = (ElectricalModel*)getSubInstance(String::format("W_OR2_%d_%d", i, j)); |
| w_and2s[state_count] = (ElectricalModel*)getSubInstance(String::format("W_AND2_%d_%d", i, j)); |
| w_dffs[state_count] = (ElectricalModel*)getSubInstance(String::format("W_DFF_%d_%d", i, j)); |
| dis_invs[state_count] = (ElectricalModel*)getSubInstance(String::format("Dis_INV_%d_%d", i, j)); |
| dis_and2s[i * number_requests + j] = (ElectricalModel*)getSubInstance(String::format("Dis_AND2_%d_%d", i, j)); |
| dis_and2s[j * number_requests + i] = (ElectricalModel*)getSubInstance(String::format("Dis_AND2_%d_%d", j, i)); |
| |
| w_dffs[state_count]->getInputPort("D")->setTransitionInfo(TransitionInfo(0.5, 0.0, 0.5)); |
| propagatePortTransitionInfo(w_dffs[state_count], "CK", "CK"); |
| w_dffs[state_count]->use(); |
| |
| state_count++; |
| } |
| } |
| |
| unsigned int iteration = 1; |
| unsigned int max_number_iterations = 10; |
| //vector<TransitionInfo> trans_vector(number_states, TransitionInfo(0.0, 0.0, 1.0)); |
| //vector<double> total_P_vector(number_states, 0.0); |
| while(iteration < max_number_iterations) |
| { |
| // for(unsigned int i = 0; i < number_states; ++i) |
| // { |
| // w_dffs[i]->getInputPort("D")->setTransitionInfo(trans_vector[i]); |
| // propagatePortTransitionInfo(w_dffs[i], "CK", "CK"); |
| // w_dffs[i]->use(); |
| // } |
| state_count = 0; |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| for(unsigned int j = i + 1; j < number_requests; ++j) |
| { |
| propagatePortTransitionInfo(dis_and2s[i * number_requests + j], "A", "Request" + (String)i); |
| propagatePortTransitionInfo(dis_and2s[i * number_requests + j], "B", w_dffs[state_count], "Q"); |
| dis_and2s[i * number_requests + j]->use(); |
| propagatePortTransitionInfo(dis_invs[state_count], "A", w_dffs[state_count], "Q"); |
| dis_invs[state_count]->use(); |
| propagatePortTransitionInfo(dis_and2s[j * number_requests + i], "A", "Request" + (String)j); |
| propagatePortTransitionInfo(dis_and2s[j * number_requests + i], "B", dis_invs[state_count], "Y"); |
| dis_and2s[j * number_requests + i]->use(); |
| |
| state_count++; |
| } |
| } |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| unsigned int k = 0; |
| for(unsigned int j = 0; j < number_requests; ++j) |
| { |
| if(i != j) |
| { |
| propagatePortTransitionInfo(dis_ors[i], "In" + (String)k, dis_and2s[j * number_requests + i], "Y"); |
| k++; |
| } |
| } |
| dis_ors[i]->use(); |
| } |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| propagatePortTransitionInfo(g_invs[i], "A", dis_ors[i], "Out"); |
| g_invs[i]->use(); |
| propagatePortTransitionInfo(g_and2s[i], "A", "Request" + (String)i); |
| propagatePortTransitionInfo(g_and2s[i], "B", g_invs[i], "Y"); |
| g_and2s[i]->use(); |
| } |
| state_count = 0; |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| for(unsigned int j = i + 1; j < number_requests; ++j) |
| { |
| propagatePortTransitionInfo(w_invs[state_count], "A", g_and2s[i], "Y"); |
| w_invs[state_count]->use(); |
| propagatePortTransitionInfo(w_or2s[state_count], "A", w_dffs[state_count], "Q"); |
| propagatePortTransitionInfo(w_or2s[state_count], "B", g_and2s[j], "Y"); |
| w_or2s[state_count]->use(); |
| propagatePortTransitionInfo(w_and2s[state_count], "A", w_or2s[state_count], "Y"); |
| propagatePortTransitionInfo(w_and2s[state_count], "B", w_invs[state_count], "Y"); |
| w_and2s[state_count]->use(); |
| propagatePortTransitionInfo(w_dffs[state_count], "D", w_and2s[state_count], "Y"); |
| propagatePortTransitionInfo(w_dffs[state_count], "CK", "CK"); |
| w_dffs[state_count]->use(); |
| state_count++; |
| } |
| } |
| |
| // for(unsigned int i = 0; i < number_states; ++i) |
| // { |
| // const TransitionInfo& new_trans = w_dffs[i]->getOutputPort("Q")->getTransitionInfo(); |
| // total_P_vector[i] += new_trans.getProbability1(); |
| // trans_vector[i] = TransitionInfo((1.0 - total_P_vector[i] / iteration) * (1.0 - total_P_vector[i] / iteration), |
| // (1.0 - total_P_vector[i] / iteration) * (total_P_vector[i] / iteration), |
| // (total_P_vector[i] / iteration) * (total_P_vector[i] / iteration)); |
| // } |
| // |
| // for(unsigned int i = 0; i < number_requests; ++i) |
| // { |
| // g_and2s[i]->getOutputPort("Y")->getTransitionInfo().print(cout); |
| // } |
| // cout << endl; |
| iteration++; |
| } |
| |
| for(unsigned int i = 0; i < number_requests; ++i) |
| { |
| propagatePortTransitionInfo("Grant" + (String)i, g_and2s[i], "Y"); |
| } |
| } |
| |
| return; |
| } |
| } // namespace DSENT |
| |
