c1aecc05e6
This patch extensively modifies DSENT so that it can be accessed using Python. To access the Python interface, DSENT needs to compiled as a shared library. For this purpose a CMakeLists.txt file has been added. Some of the code that is not required is being removed.
247 lines
12 KiB
C++
247 lines
12 KiB
C++
/* 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/MuxTreeSerializer.h"
|
|
|
|
#include <cmath>
|
|
|
|
#include "model/PortInfo.h"
|
|
#include "model/TransitionInfo.h"
|
|
#include "model/EventInfo.h"
|
|
#include "model/std_cells/StdCellLib.h"
|
|
#include "model/std_cells/StdCell.h"
|
|
#include "model/electrical/Multiplexer.h"
|
|
#include "model/timing_graph/ElectricalNet.h"
|
|
|
|
namespace DSENT
|
|
{
|
|
using std::ceil;
|
|
|
|
MuxTreeSerializer::MuxTreeSerializer(const String& instance_name_, const TechModel* tech_model_)
|
|
: ElectricalModel(instance_name_, tech_model_)
|
|
{
|
|
initParameters();
|
|
initProperties();
|
|
}
|
|
|
|
MuxTreeSerializer::~MuxTreeSerializer()
|
|
{}
|
|
|
|
void MuxTreeSerializer::initParameters()
|
|
{
|
|
addParameterName("InDataRate");
|
|
addParameterName("OutDataRate");
|
|
addParameterName("InBits"); //Output width will just be input width / serialization ratio
|
|
}
|
|
|
|
void MuxTreeSerializer::initProperties()
|
|
{
|
|
return;
|
|
}
|
|
|
|
MuxTreeSerializer* MuxTreeSerializer::clone() const
|
|
{
|
|
// TODO
|
|
return NULL;
|
|
}
|
|
|
|
void MuxTreeSerializer::constructModel()
|
|
{
|
|
// Get parameters
|
|
double in_data_rate = getParameter("InDataRate").toDouble();
|
|
double out_data_rate = getParameter("OutDataRate").toDouble();
|
|
unsigned int in_bits = getParameter("InBits").toUInt();
|
|
|
|
// Calculate serialization ratio
|
|
unsigned int serialization_ratio = (unsigned int) floor(out_data_rate / in_data_rate);
|
|
ASSERT(serialization_ratio == out_data_rate / in_data_rate,
|
|
"[Error] " + getInstanceName() + " -> Cannot have non-integer serialization ratios " +
|
|
"(" + (String) (in_data_rate / out_data_rate) + ")!");
|
|
|
|
// Calculate output width
|
|
ASSERT(floor((double) in_bits / serialization_ratio) == (double) in_bits / serialization_ratio,
|
|
"[Error] " + getInstanceName() + " -> Input width (" + (String) in_bits + ") " +
|
|
"must be a multiple of the serialization ratio (" + (String) serialization_ratio + ")!");
|
|
unsigned int output_bits = in_bits / serialization_ratio;
|
|
|
|
// Calculate the number of multiplexer stages
|
|
unsigned int number_stages = (unsigned int)ceil(log2((double) serialization_ratio));
|
|
|
|
// Store calculated values
|
|
getGenProperties()->set("SerializationRatio", serialization_ratio);
|
|
getGenProperties()->set("OutputBits", output_bits);
|
|
getGenProperties()->set("NumberStages", number_stages);
|
|
|
|
// Create ports
|
|
createInputPort("In", makeNetIndex(0, in_bits-1));
|
|
createInputPort("OutCK");
|
|
createOutputPort("Out", makeNetIndex(0, output_bits-1));
|
|
|
|
//Create energy, power, and area results
|
|
createElectricalResults();
|
|
createElectricalEventResult("Serialize");
|
|
getEventInfo("Serialize")->setTransitionInfo("OutCK", TransitionInfo(0.0, (double) serialization_ratio / 2.0, 0.0));
|
|
//Set conditions during idle state
|
|
getEventInfo("Idle")->setStaticTransitionInfos();
|
|
getEventInfo("Idle")->setTransitionInfo("OutCK", TransitionInfo(0.0, (double) serialization_ratio / 2.0, 0.0));
|
|
|
|
// Mark OutCK as a false path (since timing tool will do strange stuff due to all the clock divides and stuff)
|
|
getNet("OutCK")->setFalsePath(true);
|
|
|
|
// Create mux-tree instance
|
|
if (serialization_ratio == 1)
|
|
{
|
|
// No need to do anything, hohoho
|
|
assign("Out", "In");
|
|
}
|
|
else
|
|
{
|
|
// Create multiplexer
|
|
String mux_tree_name = "MuxTree";
|
|
ElectricalModel* mux_tree = new Multiplexer(mux_tree_name, getTechModel());
|
|
mux_tree->setParameter("NumberInputs", serialization_ratio);
|
|
mux_tree->setParameter("NumberBits", output_bits);
|
|
mux_tree->setParameter("BitDuplicate", "TRUE");
|
|
mux_tree->construct();
|
|
// Create nets
|
|
if (number_stages > 1)
|
|
createNet("MuxSel_b", makeNetIndex(0, number_stages-2));
|
|
createNet("MuxSel", makeNetIndex(0, number_stages-1));
|
|
assign("MuxSel", makeNetIndex(number_stages-1), "OutCK");
|
|
// Create reindexed net (to help out with indexing)
|
|
createNet("InTmp", makeNetIndex(0, in_bits-1));
|
|
for (unsigned int i = 0; i < serialization_ratio; ++i)
|
|
for (unsigned int j = 0; j < output_bits; ++j)
|
|
assign("InTmp", makeNetIndex(i*output_bits+j), "In", makeNetIndex(j*serialization_ratio+i));
|
|
|
|
// Connect ports
|
|
for (unsigned int i = 0; i < serialization_ratio; ++i)
|
|
portConnect(mux_tree, "In" + (String) i, "InTmp", makeNetIndex(i*output_bits, (i+1)*output_bits-1));
|
|
|
|
for (unsigned int i = 0; i < number_stages; ++i)
|
|
portConnect(mux_tree, "Sel" + (String) i, "MuxSel", makeNetIndex(i));
|
|
portConnect(mux_tree, "Out", "Out");
|
|
|
|
// Add subinstance and events
|
|
addSubInstances(mux_tree, 1.0);
|
|
addElectricalSubResults(mux_tree, 1.0);
|
|
// Add serialize event/power
|
|
getEventResult("Serialize")->addSubResult(mux_tree->getEventResult("Mux"), mux_tree_name, 1.0);
|
|
|
|
// Create clock dividers (assumes power of 2...), don't need divider for fastest output stage
|
|
for (unsigned int i = 0; i < number_stages - 1; ++i)
|
|
{
|
|
// Clk dividing registers
|
|
const String& clk_div_dff_name = "ClkDivDFF_" + (String) i;
|
|
StdCell* clk_div_dff = getTechModel()->getStdCellLib()->createStdCell("DFFQ", clk_div_dff_name);
|
|
clk_div_dff->construct();
|
|
portConnect(clk_div_dff, "D", "MuxSel_b", makeNetIndex(i));
|
|
portConnect(clk_div_dff, "Q", "MuxSel", makeNetIndex(i));
|
|
portConnect(clk_div_dff, "CK", "MuxSel", makeNetIndex(i+1));
|
|
addSubInstances(clk_div_dff, 1.0);
|
|
addElectricalSubResults(clk_div_dff, 1.0);
|
|
|
|
// Inversions
|
|
const String& clk_div_inv_name = "ClkDivINV_" + (String) i;
|
|
StdCell* clk_div_inv = getTechModel()->getStdCellLib()->createStdCell("INV", clk_div_inv_name);
|
|
clk_div_inv->construct();
|
|
portConnect(clk_div_inv, "A", "MuxSel", makeNetIndex(i));
|
|
portConnect(clk_div_inv, "Y", "MuxSel_b", makeNetIndex(i));
|
|
addSubInstances(clk_div_inv, 1.0);
|
|
addElectricalSubResults(clk_div_inv, 1.0);
|
|
|
|
getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("CK"), clk_div_dff_name, 1.0);
|
|
getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("DFFD"), clk_div_dff_name, 1.0);
|
|
getEventResult("Serialize")->addSubResult(clk_div_dff->getEventResult("DFFQ"), clk_div_dff_name, 1.0);
|
|
getEventResult("Serialize")->addSubResult(clk_div_inv->getEventResult("INV"), clk_div_inv_name, 1.0);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
void MuxTreeSerializer::propagateTransitionInfo()
|
|
{
|
|
// Get some generated properties
|
|
const unsigned int serialization_ratio = getGenProperties()->get("SerializationRatio");
|
|
const unsigned int number_stages = getGenProperties()->get("NumberStages");
|
|
|
|
// Set transition info of the mux tree and clock divide DFF
|
|
if (serialization_ratio == 1)
|
|
{
|
|
// If no serialization, then just propagate input transition info to output port
|
|
propagatePortTransitionInfo("Out", "In");
|
|
}
|
|
else
|
|
{
|
|
|
|
// Propagate transition probabilities to the mux tree
|
|
ElectricalModel* mux_tree = (ElectricalModel*) getSubInstance("MuxTree");
|
|
// All input ports of the mux have the same probability
|
|
for (unsigned int i = 0; i < serialization_ratio; ++i)
|
|
propagatePortTransitionInfo(mux_tree, "In" + (String) i, "In");
|
|
// Connect last stage of the mux
|
|
propagatePortTransitionInfo(mux_tree, "Sel" + (String) (number_stages - 1), "OutCK");
|
|
// Keep track of the last clock divider
|
|
ElectricalModel* last_clk_div_dff = NULL;
|
|
// Find P01 of OutCK
|
|
double last_P01_CK = getInputPort("OutCK")->getTransitionInfo().getNumberTransitions01();
|
|
// Start from the last stage (since it is the stage with no clock division)
|
|
for (unsigned int i = 0; i < number_stages - 1; ++i)
|
|
{
|
|
const String& clk_div_dff_name = "ClkDivDFF_" + (String) (number_stages - i - 2);
|
|
const String& clk_div_inv_name = "ClkDivINV_" + (String) (number_stages - i - 2);
|
|
|
|
ElectricalModel* clk_div_dff = (ElectricalModel*) getSubInstance(clk_div_dff_name);
|
|
if (last_clk_div_dff == NULL)
|
|
propagatePortTransitionInfo(clk_div_dff, "CK", "OutCK");
|
|
else
|
|
propagatePortTransitionInfo(clk_div_dff, "CK", last_clk_div_dff, "Q");
|
|
// Since it is a clock divider, P01 is D and Q are simply half the P01 of D and Q of
|
|
// the input clock
|
|
if (last_P01_CK != 0) clk_div_dff->getInputPort("D")->setTransitionInfo(TransitionInfo(0.0, last_P01_CK * 0.5, 0.0));
|
|
else clk_div_dff->getInputPort("D")->setTransitionInfo(TransitionInfo(0.5, 0.0, 0.5));
|
|
|
|
clk_div_dff->use();
|
|
|
|
ElectricalModel* clk_div_inv = (ElectricalModel*) getSubInstance(clk_div_inv_name);
|
|
propagatePortTransitionInfo(clk_div_inv, "A", clk_div_dff, "Q");
|
|
clk_div_inv->use();
|
|
|
|
// Connect select port of the mux
|
|
propagatePortTransitionInfo(mux_tree, "Sel" + (String) (number_stages - i - 2), clk_div_dff, "Q");
|
|
|
|
// Clk divide by 2;
|
|
last_P01_CK = last_P01_CK * 0.5;
|
|
// Remember the last clk div DFF
|
|
last_clk_div_dff = clk_div_dff;
|
|
}
|
|
|
|
mux_tree->use();
|
|
// Set output transition info to be the output transition info of the mux tree
|
|
propagatePortTransitionInfo("Out", mux_tree, "Out");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
} // namespace DSENT
|
|
|