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

401 lines
18 KiB
C++
Raw Normal View History

#include "model/electrical/BroadcastHTree.h"
#include <cmath>
#include <vector>
#include "model/PortInfo.h"
#include "model/EventInfo.h"
#include "model/TransitionInfo.h"
#include "model/std_cells/StdCellLib.h"
#include "model/std_cells/StdCell.h"
#include "model/timing_graph/ElectricalLoad.h"
#include "model/timing_graph/ElectricalDelay.h"
#include "model/timing_graph/ElectricalDriver.h"
#include "model/timing_graph/ElectricalTimingTree.h"
#include "model/timing_graph/ElectricalNet.h"
namespace DSENT
{
using std::pow;
using std::vector;
BroadcastHTree::BroadcastHTree(const String& instance_name_, const TechModel* tech_model_)
: ElectricalModel(instance_name_, tech_model_)
{
initParameters();
initProperties();
m_leaf_load_ = NULL;
m_leaf_head_driver_ = NULL;
m_leaf_head_load_ = NULL;
}
BroadcastHTree::~BroadcastHTree()
{
clearPtrVector<StdCell>(&m_repeaters_);
clearPtrVector<ElectricalLoad>(&m_repeater_loads_);
clearPtrVector<ElectricalTimingTree>(&m_timing_trees_);
clearPtrVector<StdCell>(&m_leaf_drivers_);
delete m_leaf_load_;
delete m_leaf_head_driver_;
delete m_leaf_head_load_;
}
void BroadcastHTree::initParameters()
{
addParameterName("NumberLevels");
addParameterName("NumberBits");
addParameterName("WireLayer");
addParameterName("WireWidthMultiplier", 1.0);
addParameterName("WireSpacingMultiplier", 1.0);
return;
}
void BroadcastHTree::initProperties()
{
addPropertyName("SitePitch");
addPropertyName("TotalLoadCapPerBit");
return;
}
BroadcastHTree* BroadcastHTree::clone() const
{
// TODO
return NULL;
}
void BroadcastHTree::constructModel()
{
// Get parameters
unsigned int number_levels = getParameter("NumberLevels").toUInt();
unsigned int number_bits = getParameter("NumberBits").toUInt();
const String& wire_layer = getParameter("WireLayer");
double wire_width_multiplier = getParameter("WireWidthMultiplier").toDouble();
double wire_spacing_multiplier = getParameter("WireSpacingMultiplier").toDouble();
ASSERT(number_levels > 0, "[Error] " + getInstanceName() +
" -> Number of levels must be > 0!");
ASSERT(number_bits > 0, "[Error] " + getInstanceName() +
" -> Number of bits must be > 0!");
ASSERT(getTechModel()->isWireLayerExist(wire_layer), "[Error] " + getInstanceName() +
" -> Wire layer does not exist!");
ASSERT(wire_width_multiplier >= 1.0, "[Error] " + getInstanceName() +
" -> Wire width multiplier must be >= 1.0!");
ASSERT(wire_spacing_multiplier >= 1.0, "[Error] " + getInstanceName() +
" -> Wire spacing multiplier must be >= 1.0!");
double wire_min_width = getTechModel()->get("Wire->" + wire_layer + "->MinWidth").toDouble();
double wire_min_spacing = getTechModel()->get("Wire->" + wire_layer + "->MinSpacing").toDouble();
double wire_width = wire_min_width * wire_width_multiplier;
double wire_spacing = wire_min_spacing * wire_spacing_multiplier;
double wire_cap_per_len = getTechModel()->calculateWireCapacitance(wire_layer, wire_width, wire_spacing, 1.0);
double wire_res_per_len = getTechModel()->calculateWireResistance(wire_layer, wire_width, 1.0);
getGenProperties()->set("WireWidth", wire_width);
getGenProperties()->set("WireSpacing", wire_spacing);
getGenProperties()->set("WireCapacitancePerLength", wire_cap_per_len);
getGenProperties()->set("WireResistancePerLength", wire_res_per_len);
// Create ports
createInputPort("In", makeNetIndex(0, number_bits-1));
createOutputPort("Out", makeNetIndex(0, number_bits-1));
// Create connections
createNet("InTmp");
createNet("OutTmp");
assignVirtualFanin("InTmp", "In");
assignVirtualFanout("Out", "OutTmp");
createLoad("In_Cap");
createDelay("In_to_Out_delay");
ElectricalLoad* in_cap = getLoad("In_Cap");
ElectricalDelay* in_to_out_delay = getDelay("In_to_Out_delay");
getNet("InTmp")->addDownstreamNode(in_cap);
in_cap->addDownstreamNode(in_to_out_delay);
// Init
for(unsigned int i = 0; i < number_levels; ++i)
{
StdCell* repeater = getTechModel()->getStdCellLib()->createStdCell("INV", "Repeater" + (String)i);
ElectricalLoad* repeater_load = new ElectricalLoad("RepeaterIn_Cap" + (String)i, this);
ElectricalTimingTree* timing_tree = new ElectricalTimingTree("RepeatedLink" + (String)i, this);
repeater->construct();
repeater->getNet("Y")->addDownstreamNode(repeater_load);
m_repeaters_.push_back(repeater);
m_repeater_loads_.push_back(repeater_load);
m_timing_trees_.push_back(timing_tree);
}
// Create area, power, and event results
createElectricalAtomicResults();
createElectricalEventResult("Send");
addEventResult(new AtomicResult("DriveLoad"));
addEventResult(new AtomicResult("DriveTree"));
getEventResult("Send")->addSubResult(getEventResult("DriveLoad"), "Self", 1.0);
getEventResult("Send")->addSubResult(getEventResult("DriveTree"), "Self", 1.0);
return;
}
void BroadcastHTree::updateModel()
{
// Get properties
double site_pitch = getProperty("SitePitch").toDouble();
double total_load_cap_per_bit = getProperty("TotalLoadCapPerBit").toDouble();
ASSERT(site_pitch > 0, "[Error] " + getInstanceName() +
" -> Site pitch must be > 0!");
ASSERT(total_load_cap_per_bit >= 0.0, "[Error] " + getInstanceName() +
" -> Total load capacitance per bit must be >= 0!");
// Get parameters
unsigned int number_levels = getParameter("NumberLevels");
unsigned int number_bits = getParameter("NumberBits");
const String& wire_layer = getParameter("WireLayer");
double wire_width = getGenProperties()->get("WireWidth").toDouble();
double wire_spacing = getGenProperties()->get("WireSpacing").toDouble();
double wire_cap_per_len = getGenProperties()->get("WireCapacitancePerLength").toDouble();
double wire_res_per_len = getGenProperties()->get("WireResistancePerLength").toDouble();
double leaf_load_cap = total_load_cap_per_bit / pow(2.0, (double)(number_levels-1));
vector<double> wire_caps(number_levels, 0.0);
vector<double> wire_ress(number_levels, 0.0);
double wire_length = site_pitch / 2.0;
for(unsigned int i = 0; i < number_levels; ++i)
{
wire_caps[i] = wire_cap_per_len * wire_length;
wire_ress[i] = wire_res_per_len * wire_length;
wire_length /= 2.0;
}
// Start sizing each stage of repeaters for a transition times. TODO: Find a heuristic about
// how the transition time is done...place and route tools make this user-specified
double required_transition = 40e-12;
m_number_segments_.resize(number_levels, 1);
for(unsigned int i = 0; i < number_levels; ++i)
{
Log::printLine(getInstanceName() + " -> Beginning Repeater Insertion " + (String)i);
double transition;
unsigned int iteration = 0;
m_repeaters_[i]->setMinDrivingStrength();
m_repeaters_[i]->getNet("Y")->setDistributedCap(wire_caps[i] / m_number_segments_[i]);
m_repeaters_[i]->getNet("Y")->setDistributedRes(wire_ress[i] / m_number_segments_[i]);
m_repeater_loads_[i]->setLoadCap(m_repeaters_[i]->getNet("A")->getTotalDownstreamCap());
transition = m_timing_trees_[i]->calculateNodeTransition(m_repeaters_[i]->getNet("Y"));
while(required_transition < transition)
{
Log::printLine(getInstanceName() + " -> Repeater Insertion Iteration " + (String)iteration +
": Required transition = " + (String)required_transition +
", Transition = " + (String)transition +
", Slack = " + (String)(required_transition - transition) +
", Number of repeaters = " + (String)m_number_segments_[i]);
// Size up if transition is not met
while(required_transition < transition)
{
if(m_repeaters_[i]->hasMaxDrivingStrength())
{
break;
}
m_repeaters_[i]->increaseDrivingStrength();
m_repeater_loads_[i]->setLoadCap(m_repeaters_[i]->getNet("A")->getTotalDownstreamCap());
transition = m_timing_trees_[i]->calculateNodeTransition(m_repeaters_[i]->getNet("Y"));
iteration++;
Log::printLine(getInstanceName() + " -> Slack: " + (String)(required_transition - transition));
}
// Increase number of segments if thansition is not met
if(required_transition < transition)
{
m_number_segments_[i]++;
m_repeaters_[i]->setMinDrivingStrength();
m_repeaters_[i]->getNet("Y")->setDistributedCap(wire_caps[i] / m_number_segments_[i]);
m_repeaters_[i]->getNet("Y")->setDistributedRes(wire_ress[i] / m_number_segments_[i]);
m_repeater_loads_[i]->setLoadCap(m_repeaters_[i]->getNet("A")->getTotalDownstreamCap());
transition = m_timing_trees_[i]->calculateNodeTransition(m_repeaters_[i]->getNet("Y"));
}
}
Log::printLine(getInstanceName() + " -> Repeater Insertion " + (String)i + " Ended after Iteration: " + (String)iteration +
": Required transition = " + (String)required_transition +
", Transition = " + (String)transition +
", Slack = " + (String)(required_transition - transition) +
", Number of repeaters = " + (String)m_number_segments_[i]);
}
// Insert inverters to ensure the transition time at the leaf
int min_driving_strength_idx = m_repeaters_[number_levels-1]->getDrivingStrengthIdx();
// Remove everything and rebuild again
clearPtrVector<StdCell>(&m_leaf_drivers_);
delete m_leaf_load_;
delete m_leaf_head_driver_;
delete m_leaf_head_load_;
m_leaf_head_driver_ = getTechModel()->getStdCellLib()->createStdCell("INV", "LeafHeadDriver");
m_leaf_head_driver_->construct();
m_leaf_head_driver_->setDrivingStrengthIdx(min_driving_strength_idx);
m_leaf_head_load_ = new ElectricalLoad("LeafHead_Cap", this);
m_leaf_head_driver_->getNet("Y")->addDownstreamNode(m_leaf_head_load_);
m_leaf_load_ = new ElectricalLoad("Leaf_Cap", this);
m_leaf_load_->setLoadCap(leaf_load_cap);
StdCell* inv = getTechModel()->getStdCellLib()->createStdCell("INV", "LeafDriver0");
inv->construct();
inv->getNet("Y")->addDownstreamNode(m_leaf_load_);
inv->setDrivingStrengthIdx(min_driving_strength_idx);
m_leaf_drivers_.push_back(inv);
m_leaf_head_load_->setLoadCap(m_leaf_drivers_[0]->getNet("A")->getTotalDownstreamCap());
// Start inserting the buffers
ElectricalTimingTree t2("LeafHead", m_leaf_head_driver_);
int curr_driver = 0;
unsigned int iteration = 0;
while(true)
{
ElectricalTimingTree t("LeafDriver", m_leaf_drivers_[curr_driver]);
double transition = t.calculateNodeTransition(m_leaf_drivers_[curr_driver]->getNet("Y"));
Log::printLine(getInstanceName() + " -> Buffer Insertion : " + (String)iteration +
": Required transition = " + (String)required_transition +
", Transition = " + (String)transition +
", Slack = " + (String)(required_transition - transition) +
", Number of buffers = " + (String)(curr_driver+1));
// Size up the inverter at curr_driver so that it could drive the next stage
while(required_transition < transition)
{
if(m_leaf_drivers_[curr_driver]->hasMaxDrivingStrength())
{
const String& warning_msg = "[Warning] " + getInstanceName() + " -> Transition not met" +
": Required transition = " + (String)required_transition +
", Transition = " + (String)transition +
", Slack = " + (String)(required_transition - transition);
Log::printLine(std::cerr, warning_msg);
break;
}
m_leaf_drivers_[curr_driver]->increaseDrivingStrength();
transition = t.calculateNodeTransition(m_leaf_drivers_[curr_driver]->getNet("Y"));
iteration++;
}
// Add an additional inverter if the transition for the first stage does not meet the required transition
m_leaf_head_load_->setLoadCap(m_leaf_drivers_[curr_driver]->getNet("A")->getTotalDownstreamCap());
transition = t2.calculateNodeTransition(m_leaf_head_driver_->getNet("Y"));
if(required_transition < transition)
{
inv = getTechModel()->getStdCellLib()->createStdCell("INV", "LeafDriver" + (String)(curr_driver+1));
inv->construct();
inv->getNet("Y")->addDownstreamNode(m_leaf_drivers_[curr_driver]->getNet("A"));
inv->setDrivingStrengthIdx(min_driving_strength_idx);
m_leaf_drivers_.push_back(inv);
curr_driver++;
}
else
{
Log::printLine(getInstanceName() + " -> Buffer Insertion Ended after Iteration: " + (String)iteration +
", Number of buffers = " + (String)(curr_driver+1));
break;
}
}
// Update electrical interfaces
getLoad("In_Cap")->setLoadCap(m_repeaters_[0]->getNet("A")->getTotalDownstreamCap());
// TODO
getDelay("In_to_Out_delay")->setDelay(0.0);
// Reset all the atomic results to 0 before start updating new results
resetElectricalAtomicResults();
// Update area, power results
double wire_area = 0.0;
wire_length = site_pitch / 2.0;
unsigned int number_branches = 1;
for(unsigned int i = 0; i < number_levels; ++i)
{
wire_area += wire_length * (wire_width + wire_spacing) * number_branches * number_bits;
addElecticalAtomicResultValues(m_repeaters_[i], m_number_segments_[i] * number_branches * number_bits);
wire_length /= 2.0;
number_branches *= 2;
}
number_branches = (unsigned int)pow(2.0, (double)number_levels-1);
addElecticalAtomicResultValues(m_leaf_head_driver_, number_branches * number_bits);
for(unsigned int i = 0; i < m_leaf_drivers_.size(); ++i)
{
addElecticalAtomicResultValues(m_leaf_drivers_[i], number_branches * number_bits);
}
addElecticalWireAtomicResultValue(wire_layer, wire_area);
return;
}
void BroadcastHTree::useModel()
{
unsigned int number_bits = getParameter("NumberBits").toUInt();
unsigned int number_levels = getParameter("NumberLevels").toUInt();
// Update the transition information for the modeled repeaters
// Since we only modeled one repeater. So the transition information for 0->0 and 1->1
// is averaged out
const TransitionInfo& trans_In = getInputPort("In")->getTransitionInfo();
double average_static_transition = (trans_In.getNumberTransitions00() + trans_In.getNumberTransitions11()) / 2.0;
TransitionInfo mod_trans_In(average_static_transition, trans_In.getNumberTransitions01(), average_static_transition);
// Propagate the transition information
propagateTransitionInfo();
// Update leakage and event
double energy = 0.0;
double power = 0.0;
unsigned int number_branches = 1;
for(unsigned int i = 0; i < number_levels; ++i)
{
assignPortTransitionInfo(m_repeaters_[i], "A", mod_trans_In);
m_repeaters_[i]->use();
power += m_repeaters_[i]->getNddPowerResult("Leakage")->calculateSum() * m_number_segments_[i] * number_branches;
energy += m_repeaters_[i]->getEventResult("INV")->calculateSum() * m_number_segments_[i] * number_branches;
number_branches *= 2;
}
energy *= number_bits;
getEventResult("DriveTree")->setValue(energy);
energy = 0.0;
assignPortTransitionInfo(m_leaf_head_driver_, "A", mod_trans_In);
m_leaf_head_driver_->use();
number_branches = (unsigned int)pow(2.0, (double)number_levels-1);
power += m_leaf_head_driver_->getNddPowerResult("Leakage")->calculateSum() * number_branches;
energy += m_leaf_head_driver_->getEventResult("INV")->calculateSum() * number_branches;
for(unsigned int i = 0; i < m_leaf_drivers_.size(); ++i)
{
assignPortTransitionInfo(m_leaf_drivers_[i], "A", mod_trans_In);
m_leaf_drivers_[i]->use();
power += m_leaf_drivers_[i]->getNddPowerResult("Leakage")->calculateSum() * number_branches;
energy += m_leaf_drivers_[i]->getEventResult("INV")->calculateSum() * number_branches;
}
power *= number_bits;
energy *= number_bits;
getEventResult("DriveLoad")->setValue(energy);
getNddPowerResult("Leakage")->setValue(power);
return;
}
void BroadcastHTree::propagateTransitionInfo()
{
propagatePortTransitionInfo("Out", "In");
return;
}
} // namespace DSENT