gem5/ext/dsent/model/electrical/DFFRAM.cc

343 lines
13 KiB
C++
Raw Normal View History

/* 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/DFFRAM.h"
#include <cmath>
#include "model/PortInfo.h"
#include "model/EventInfo.h"
#include "model/TransitionInfo.h"
#include "model/timing_graph/ElectricalDriverMultiplier.h"
#include "model/timing_graph/ElectricalNet.h"
#include "model/std_cells/StdCell.h"
#include "model/std_cells/StdCellLib.h"
#include "model/electrical/Decoder.h"
#include "model/electrical/Multiplexer.h"
namespace DSENT
{
using std::ceil;
DFFRAM::DFFRAM(const String& instance_name_, const TechModel* tech_model_)
: ElectricalModel(instance_name_, tech_model_)
{
initParameters();
initProperties();
}
DFFRAM::~DFFRAM()
{}
void DFFRAM::initParameters()
{
addParameterName("NumberEntries");
addParameterName("NumberBits");
return;
}
void DFFRAM::initProperties()
{
return;
}
DFFRAM* DFFRAM::clone() const
{
// TODO
return NULL;
}
void DFFRAM::constructModel()
{
// Get parameters
unsigned int number_bits = getParameter("NumberBits").toUInt();
unsigned int number_entries = getParameter("NumberEntries").toUInt();
ASSERT(number_bits > 0, "[Error] " + getInstanceName() +
" -> Number of bits must be > 0!");
ASSERT(number_entries > 0, "[Error] " + getInstanceName() +
" -> Number of entries must be > 0!");
unsigned int number_addr_bits = (unsigned int)ceil(log2(number_entries));
// Create ports
createInputPort("In", makeNetIndex(0, number_bits-1));
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
createInputPort("WRAddr" + (String)i);
createInputPort("RDAddr" + (String)i);
}
createInputPort("WE");
createInputPort("CK");
createOutputPort("Out", makeNetIndex(0, number_bits-1));
// Create energy, power, and area results
createElectricalResults();
getEventInfo("Idle")->setStaticTransitionInfos();
getEventInfo("Idle")->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0));
getEventInfo("Idle")->setTransitionInfo("WE", TransitionInfo(1.0, 0.0, 0.0));
createElectricalEventResult("Read");
getEventInfo("Read")->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0));
getEventInfo("Read")->setTransitionInfo("WE", TransitionInfo(1.0, 0.0, 0.0));
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
getEventInfo("Read")->setTransitionInfo("WRAddr" + (String)i, TransitionInfo(0.5, 0.0, 0.5));
}
createElectricalEventResult("Write");
getEventInfo("Write")->setTransitionInfo("CK", TransitionInfo(0.0, 1.0, 0.0));
getEventInfo("Write")->setTransitionInfo("WE", TransitionInfo(0.0, 0.0, 1.0));
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
getEventInfo("Write")->setTransitionInfo("RDAddr" + (String)i, TransitionInfo(0.5, 0.0, 0.5));
}
// Init components - DFF array, Dec, Mux
vector<String> dff_names(number_entries, "");
vector<StdCell*> dffs(number_entries, NULL);
for(unsigned int i = 0; i < number_entries; ++i)
{
dff_names[i] = "DFF_" + (String)i;
dffs[i] = getTechModel()->getStdCellLib()->createStdCell("DFFQ", dff_names[i]);
dffs[i]->construct();
}
const String& dec_name = "Dec";
Decoder* dec = new Decoder(dec_name, getTechModel());
dec->setParameter("NumberOutputs", number_entries);
dec->construct();
const String& mux_name = "Mux";
Multiplexer* mux = new Multiplexer(mux_name, getTechModel());
mux->setParameter("NumberInputs", number_entries);
mux->setParameter("NumberBits", 1);
mux->setParameter("BitDuplicate", "TRUE");
mux->construct();
// Init components - CK & WE
const String& nand2cg0_name = "NAND2_CKGate0";
StdCell* nand2cg0 = getTechModel()->getStdCellLib()->createStdCell("NAND2", nand2cg0_name);
nand2cg0->construct();
const String& invcg0_name = "INV_CKGate0";
StdCell* invcg0 = getTechModel()->getStdCellLib()->createStdCell("INV", invcg0_name);
invcg0->construct();
// Init components - (CK & WE) & DecOut[i]
vector<String> nand2cg1_names(number_entries, "");
vector<StdCell*> nand2cg1s(number_entries, NULL);
vector<String> invcg1_names(number_entries, "");
vector<StdCell*> invcg1s(number_entries, NULL);
for(unsigned int i = 0; i < number_entries; ++i)
{
nand2cg1_names[i] = "NAND2_CKGate1_" + (String)i;
nand2cg1s[i] = getTechModel()->getStdCellLib()->createStdCell("NAND2", nand2cg1_names[i]);
nand2cg1s[i]->construct();
invcg1_names[i] = "INV_CKGate1_" + (String)i;
invcg1s[i] = getTechModel()->getStdCellLib()->createStdCell("INV", invcg1_names[i]);
invcg1s[i]->construct();
}
// Connect Decoder
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
portConnect(dec, "Addr" + (String)i, "WRAddr" + (String)i);
}
for(unsigned int i = 0; i < number_entries; ++i)
{
createNet("Dec_Out" + (String)i);
portConnect(dec, "Out" + (String)i, "Dec_Out" + (String)i);
}
// Connect CKGate0 - CK, WE
createNet("NAND2_CKGate0_Out");
createNet("CKGate0_Out");
portConnect(nand2cg0, "A", "CK");
portConnect(nand2cg0, "B", "WE");
portConnect(nand2cg0, "Y", "NAND2_CKGate0_Out");
portConnect(invcg0, "A", "NAND2_CKGate0_Out");
portConnect(invcg0, "Y", "CKGate0_Out");
// Connect CKGate1 - CKGate0, Dec_Out
for(unsigned int i = 0; i < number_entries; ++i)
{
createNet("NAND2_CKGate1_Outs" + (String)i);
createNet("CKGate1_Outs" + (String)i);
portConnect(nand2cg1s[i], "A", "CKGate0_Out");
portConnect(nand2cg1s[i], "B", "Dec_Out" + (String)i);
portConnect(nand2cg1s[i], "Y", "NAND2_CKGate1_Outs" + (String)i);
portConnect(invcg1s[i], "A", "NAND2_CKGate1_Outs" + (String)i);
portConnect(invcg1s[i], "Y", "CKGate1_Outs" + (String)i);
}
// Connect DFF array
for(unsigned int i = 0; i < number_entries; ++i)
{
createNet("DFF_Out" + (String)i);
for(unsigned int n = 0; n < number_bits; ++n)
{
portConnect(dffs[i], "D", "In", makeNetIndex(n));
portConnect(dffs[i], "CK", "CKGate1_Outs" + (String)i);
}
portConnect(dffs[i], "Q", "DFF_Out" + (String)i);
}
// Connect Multiplexer
createNet("Mux_Out");
for(unsigned int i = 0; i < number_entries; ++i)
{
portConnect(mux, "In" + (String)i, "DFF_Out" + (String)i);
}
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
portConnect(mux, "Sel" + (String)i, "RDAddr" + (String)i);
}
portConnect(mux, "Out", "Mux_Out");
// Use driver multiplier to connect Mux_Out to Out
createDriverMultiplier("OutMult");
ElectricalDriverMultiplier* drive_mult = getDriverMultiplier("OutMult");
getNet("Mux_Out")->addDownstreamNode(drive_mult);
for(unsigned int n = 0; n < number_bits; ++n)
{
drive_mult->addDownstreamNode(getNet("Out", makeNetIndex(n)));
}
// Add area and power results
for(unsigned int i = 0; i < number_entries; ++i)
{
addSubInstances(dffs[i], number_bits);
addElectricalSubResults(dffs[i], number_bits);
}
addSubInstances(dec, 1.0);
addElectricalSubResults(dec, 1.0);
addSubInstances(mux, number_bits);
addElectricalSubResults(mux, number_bits);
addSubInstances(nand2cg0, 1.0);
addElectricalSubResults(nand2cg0, 1.0);
addSubInstances(invcg0, 1);
addElectricalSubResults(invcg0, 1.0);
for(unsigned int i = 0; i < number_entries; ++i)
{
addSubInstances(nand2cg1s[i], 1);
addElectricalSubResults(nand2cg1s[i], 1.0);
addSubInstances(invcg1s[i], 1);
addElectricalSubResults(invcg1s[i], 1.0);
}
// Add write event
Result* write_event = getEventResult("Write");
write_event->addSubResult(nand2cg0->getEventResult("NAND2"), nand2cg0_name, 1.0);
write_event->addSubResult(invcg0->getEventResult("INV"), invcg0_name, 1.0);
write_event->addSubResult(dec->getEventResult("Decode"), dec_name, 1.0);
for(unsigned int i = 0; i < number_entries; ++i)
{
write_event->addSubResult(nand2cg1s[i]->getEventResult("NAND2"), nand2cg1_names[i], 1.0);
write_event->addSubResult(invcg1s[i]->getEventResult("INV"), invcg1_names[i], 1.0);
write_event->addSubResult(dffs[i]->getEventResult("DFFD"), dff_names[i], number_bits);
write_event->addSubResult(dffs[i]->getEventResult("DFFQ"), dff_names[i], number_bits);
write_event->addSubResult(dffs[i]->getEventResult("CK"), dff_names[i], number_bits);
}
// Add read event
Result* read_event = getEventResult("Read");
//for(unsigned int i = 0; i < number_entries; ++i)
//{
// read_event->addSubResult(dffs[i]->getEventResult("DFFQ"), dff_names[i], number_bits);
//}
read_event->addSubResult(mux->getEventResult("Mux"), mux_name, number_bits);
return;
}
void DFFRAM::propagateTransitionInfo()
{
// Update probability
unsigned int number_entries = (unsigned int)getParameter("NumberEntries");
unsigned int number_addr_bits = (unsigned int)ceil(log2(number_entries));
// Update decoder
ElectricalModel* dec = (ElectricalModel*)getSubInstance("Dec");
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
propagatePortTransitionInfo(dec, "Addr" + (String)i, "WRAddr" + (String)i);
}
dec->use();
// Update CKGate0 nands + invs
ElectricalModel* nand2cg0 = (ElectricalModel*)getSubInstance("NAND2_CKGate0");
propagatePortTransitionInfo(nand2cg0, "A", "CK");
propagatePortTransitionInfo(nand2cg0, "B", "WE");
nand2cg0->use();
ElectricalModel* invcg0 = (ElectricalModel*)getSubInstance("INV_CKGate0");
propagatePortTransitionInfo(invcg0, "A", nand2cg0, "Y");
invcg0->use();
// Update CKGate1 nands + invs
vector<ElectricalModel*> nand2cg1s(number_entries, NULL);
vector<ElectricalModel*> invcg1s(number_entries, NULL);
for(unsigned int i = 0; i < number_entries; ++i)
{
nand2cg1s[i] = (ElectricalModel*)getSubInstance("NAND2_CKGate1_" + (String)i);
propagatePortTransitionInfo(nand2cg1s[i], "A", invcg0, "Y");
propagatePortTransitionInfo(nand2cg1s[i], "B", dec, "Out" + (String)i);
nand2cg1s[i]->use();
invcg1s[i] = (ElectricalModel*)getSubInstance("INV_CKGate1_" + (String)i);
propagatePortTransitionInfo(invcg1s[i], "A", nand2cg1s[i], "Y");
invcg1s[i]->use();
}
// Update DFF
vector<ElectricalModel*> dffs(number_entries, NULL);
for(unsigned int i = 0; i < number_entries; ++i)
{
dffs[i] = (ElectricalModel*)getSubInstance("DFF_" + (String)i);
propagatePortTransitionInfo(dffs[i], "D", "In");
propagatePortTransitionInfo(dffs[i], "CK", invcg1s[i], "Y");
dffs[i]->use();
}
// Update Mux
ElectricalModel* mux = (ElectricalModel*)getSubInstance("Mux");
for(unsigned int i = 0; i < number_entries; ++i)
{
propagatePortTransitionInfo(mux, "In" + (String)i, dffs[i], "Q");
}
for(unsigned int i = 0; i < number_addr_bits; ++i)
{
propagatePortTransitionInfo(mux, "Sel" + (String)i, "RDAddr" + (String)i);
}
mux->use();
// Set output probability
getOutputPort("Out")->setTransitionInfo(mux->getOutputPort("Out")->getTransitionInfo());
return;
}
} // namespace DSENT