/*****************************************************************************
* McPAT/CACTI
* SOFTWARE LICENSE AGREEMENT
* Copyright 2012 Hewlett-Packard Development Company, L.P.
* Copyright (c) 2010-2013 Advanced Micro Devices, Inc.
* All Rights Reserved
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met: redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer;
* redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution;
* neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
***************************************************************************/
#include "wire.h"
#include "cmath"
// use this constructor to calculate wire stats
Wire::Wire(
enum Wire_type wire_model,
double wl,
int n,
double w_s,
double s_s,
enum Wire_placement wp,
double resistivity,
TechnologyParameter::DeviceType *dt
): wt(wire_model), wire_length(wl*1e-6), nsense(n), w_scale(w_s),
s_scale(s_s),
resistivity(resistivity), deviceType(dt) {
wire_placement = wp;
min_w_pmos = deviceType->n_to_p_eff_curr_drv_ratio * g_tp.min_w_nmos_;
in_rise_time = 0;
out_rise_time = 0;
if (initialized != 1) {
cout << "Wire not initialized. Initializing it with default values\n";
Wire winit;
}
calculate_wire_stats();
// change everything back to seconds, microns, and Joules
repeater_spacing *= 1e6;
wire_length *= 1e6;
wire_width *= 1e6;
wire_spacing *= 1e6;
assert(wire_length > 0);
assert(power.readOp.dynamic > 0);
assert(power.readOp.leakage > 0);
assert(power.readOp.gate_leakage > 0);
}
// the following values are for peripheral global technology
// specified in the input config file
Component Wire::global;
Component Wire::global_5;
Component Wire::global_10;
Component Wire::global_20;
Component Wire::global_30;
Component Wire::low_swing;
int Wire::initialized;
double Wire::wire_width_init;
double Wire::wire_spacing_init;
Wire::Wire(double w_s, double s_s, enum Wire_placement wp, double resis,
TechnologyParameter::DeviceType *dt) {
w_scale = w_s;
s_scale = s_s;
deviceType = dt;
wire_placement = wp;
resistivity = resis;
min_w_pmos = deviceType->n_to_p_eff_curr_drv_ratio * g_tp.min_w_nmos_;
in_rise_time = 0;
out_rise_time = 0;
switch (wire_placement) {
case outside_mat:
wire_width = g_tp.wire_outside_mat.pitch;
break;
case inside_mat :
wire_width = g_tp.wire_inside_mat.pitch;
break;
default:
wire_width = g_tp.wire_local.pitch;
break;
}
wire_spacing = wire_width;
wire_width *= (w_scale * 1e-6 / 2) /* (m) */;
wire_spacing *= (s_scale * 1e-6 / 2) /* (m) */;
initialized = 1;
init_wire();
wire_width_init = wire_width;
wire_spacing_init = wire_spacing;
assert(power.readOp.dynamic > 0);
assert(power.readOp.leakage > 0);
assert(power.readOp.gate_leakage > 0);
}
Wire::~Wire() {
}
void
Wire::calculate_wire_stats() {
if (wire_placement == outside_mat) {
wire_width = g_tp.wire_outside_mat.pitch;
} else if (wire_placement == inside_mat) {
wire_width = g_tp.wire_inside_mat.pitch;
} else {
wire_width = g_tp.wire_local.pitch;
}
wire_spacing = wire_width;
wire_width *= (w_scale * 1e-6 / 2) /* (m) */;
wire_spacing *= (s_scale * 1e-6 / 2) /* (m) */;
if (wt != Low_swing) {
// delay_optimal_wire();
if (wt == Global) {
delay = global.delay * wire_length;
power.readOp.dynamic = global.power.readOp.dynamic * wire_length;
power.readOp.leakage = global.power.readOp.leakage * wire_length;
power.readOp.gate_leakage = global.power.readOp.gate_leakage * wire_length;
repeater_spacing = global.area.w;
repeater_size = global.area.h;
area.set_area((wire_length / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_size,
g_tp.min_w_nmos_ * repeater_size,
g_tp.cell_h_def));
} else if (wt == Global_5) {
delay = global_5.delay * wire_length;
power.readOp.dynamic = global_5.power.readOp.dynamic * wire_length;
power.readOp.leakage = global_5.power.readOp.leakage * wire_length;
power.readOp.gate_leakage = global_5.power.readOp.gate_leakage * wire_length;
repeater_spacing = global_5.area.w;
repeater_size = global_5.area.h;
area.set_area((wire_length / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_size,
g_tp.min_w_nmos_ * repeater_size,
g_tp.cell_h_def));
} else if (wt == Global_10) {
delay = global_10.delay * wire_length;
power.readOp.dynamic = global_10.power.readOp.dynamic * wire_length;
power.readOp.leakage = global_10.power.readOp.leakage * wire_length;
power.readOp.gate_leakage = global_10.power.readOp.gate_leakage * wire_length;
repeater_spacing = global_10.area.w;
repeater_size = global_10.area.h;
area.set_area((wire_length / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_size,
g_tp.min_w_nmos_ * repeater_size,
g_tp.cell_h_def));
} else if (wt == Global_20) {
delay = global_20.delay * wire_length;
power.readOp.dynamic = global_20.power.readOp.dynamic * wire_length;
power.readOp.leakage = global_20.power.readOp.leakage * wire_length;
power.readOp.gate_leakage = global_20.power.readOp.gate_leakage * wire_length;
repeater_spacing = global_20.area.w;
repeater_size = global_20.area.h;
area.set_area((wire_length / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_size,
g_tp.min_w_nmos_ * repeater_size,
g_tp.cell_h_def));
} else if (wt == Global_30) {
delay = global_30.delay * wire_length;
power.readOp.dynamic = global_30.power.readOp.dynamic * wire_length;
power.readOp.leakage = global_30.power.readOp.leakage * wire_length;
power.readOp.gate_leakage = global_30.power.readOp.gate_leakage * wire_length;
repeater_spacing = global_30.area.w;
repeater_size = global_30.area.h;
area.set_area((wire_length / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_size,
g_tp.min_w_nmos_ * repeater_size,
g_tp.cell_h_def));
}
out_rise_time = delay * repeater_spacing / deviceType->Vth;
} else if (wt == Low_swing) {
low_swing_model ();
repeater_spacing = wire_length;
repeater_size = 1;
} else {
assert(0);
}
}
/*
* The fall time of an input signal to the first stage of a circuit is
* assumed to be same as the fall time of the output signal of two
* inverters connected in series (refer: CACTI 1 Technical report,
* section 6.1.3)
*/
double
Wire::signal_fall_time () {
/* rise time of inverter 1's output */
double rt;
/* fall time of inverter 2's output */
double ft;
double timeconst;
timeconst = (drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
gate_C(min_w_pmos + g_tp.min_w_nmos_, 0)) *
tr_R_on(min_w_pmos, PCH, 1);
rt = horowitz (0, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, FALL) /
(deviceType->Vdd - deviceType->Vth);
timeconst = (drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
gate_C(min_w_pmos + g_tp.min_w_nmos_, 0)) *
tr_R_on(g_tp.min_w_nmos_, NCH, 1);
ft = horowitz (rt, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, RISE) / deviceType->Vth;
return ft;
}
double Wire::signal_rise_time () {
/* rise time of inverter 1's output */
double ft;
/* fall time of inverter 2's output */
double rt;
double timeconst;
timeconst = (drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
gate_C(min_w_pmos + g_tp.min_w_nmos_, 0)) *
tr_R_on(g_tp.min_w_nmos_, NCH, 1);
rt = horowitz (0, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, RISE) / deviceType->Vth;
timeconst = (drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
gate_C(min_w_pmos + g_tp.min_w_nmos_, 0)) *
tr_R_on(min_w_pmos, PCH, 1);
ft = horowitz (rt, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, FALL) /
(deviceType->Vdd - deviceType->Vth);
return ft; //sec
}
/* Wire resistance and capacitance calculations
* wire width
*
* /__/
* | |
* | | height = ASPECT_RATIO*wire width (ASPECT_RATIO = 2.2, ref: ITRS)
* |__|/
*
* spacing between wires in same level = wire width
* spacing between wires in adjacent levels = wire width---this is incorrect,
* according to R.Ho's paper and thesis. ILD != wire width
*
*/
double Wire::wire_cap (double len /* in m */, bool call_from_outside) {
//TODO: this should be consistent with the wire_res in technology file
double sidewall, adj, tot_cap;
double wire_height;
double epsilon0 = 8.8542e-12;
double aspect_ratio;
double horiz_dielectric_constant;
double vert_dielectric_constant;
double miller_value;
double ild_thickness;
switch (wire_placement) {
case outside_mat: {
aspect_ratio = g_tp.wire_outside_mat.aspect_ratio;
horiz_dielectric_constant = g_tp.wire_outside_mat.horiz_dielectric_constant;
vert_dielectric_constant = g_tp.wire_outside_mat.vert_dielectric_constant;
miller_value = g_tp.wire_outside_mat.miller_value;
ild_thickness = g_tp.wire_outside_mat.ild_thickness;
break;
}
case inside_mat : {
aspect_ratio = g_tp.wire_inside_mat.aspect_ratio;
horiz_dielectric_constant = g_tp.wire_inside_mat.horiz_dielectric_constant;
vert_dielectric_constant = g_tp.wire_inside_mat.vert_dielectric_constant;
miller_value = g_tp.wire_inside_mat.miller_value;
ild_thickness = g_tp.wire_inside_mat.ild_thickness;
break;
}
default: {
aspect_ratio = g_tp.wire_local.aspect_ratio;
horiz_dielectric_constant = g_tp.wire_local.horiz_dielectric_constant;
vert_dielectric_constant = g_tp.wire_local.vert_dielectric_constant;
miller_value = g_tp.wire_local.miller_value;
ild_thickness = g_tp.wire_local.ild_thickness;
break;
}
}
if (call_from_outside) {
wire_width *= 1e-6;
wire_spacing *= 1e-6;
}
wire_height = wire_width / w_scale * aspect_ratio;
/*
* assuming height does not change. wire_width = width_original*w_scale
* So wire_height does not change as wire width increases
*/
// capacitance between wires in the same level
// sidewall = 2*miller_value * horiz_dielectric_constant * (wire_height/wire_spacing)
// * epsilon0;
sidewall = miller_value * horiz_dielectric_constant *
(wire_height / wire_spacing)
* epsilon0;
// capacitance between wires in adjacent levels
//adj = miller_value * vert_dielectric_constant *w_scale * epsilon0;
//adj = 2*vert_dielectric_constant *wire_width/(ild_thickness*1e-6) * epsilon0;
adj = miller_value * vert_dielectric_constant * wire_width /
(ild_thickness * 1e-6) * epsilon0;
//Change ild_thickness from micron to M
//tot_cap = (sidewall + adj + (deviceType->C_fringe * 1e6)); //F/m
tot_cap = (sidewall + adj + (g_tp.fringe_cap * 1e6)); //F/m
if (call_from_outside) {
wire_width *= 1e6;
wire_spacing *= 1e6;
}
return (tot_cap*len); // (F)
}
double
Wire::wire_res (double len /*(in m)*/) {
double aspect_ratio;
double alpha_scatter = 1.05;
double dishing_thickness = 0;
double barrier_thickness = 0;
//TODO: this should be consistent with the wire_res in technology file
//The whole computation should be consistent with the wire_res in technology.cc too!
switch (wire_placement) {
case outside_mat: {
aspect_ratio = g_tp.wire_outside_mat.aspect_ratio;
break;
}
case inside_mat : {
aspect_ratio = g_tp.wire_inside_mat.aspect_ratio;
break;
}
default: {
aspect_ratio = g_tp.wire_local.aspect_ratio;
break;
}
}
return (alpha_scatter * resistivity * 1e-6 * len /
((aspect_ratio*wire_width / w_scale - dishing_thickness -
barrier_thickness)*
(wire_width - 2*barrier_thickness)));
}
/*
* Calculates the delay, power and area of the transmitter circuit.
*
* The transmitter delay is the sum of nand gate delay, inverter delay
* low swing nmos delay, and the wire delay
* (ref: Technical report 6)
*/
void
Wire::low_swing_model() {
double len = wire_length;
double beta = pmos_to_nmos_sz_ratio();
double inputrise = (in_rise_time == 0) ? signal_rise_time() : in_rise_time;
/* Final nmos low swing driver size calculation:
* Try to size the driver such that the delay
* is less than 8FO4.
* If the driver size is greater than
* the max allowable size, assume max size for the driver.
* In either case, recalculate the delay using
* the final driver size assuming slow input with
* finite rise time instead of ideal step input
*
* (ref: Technical report 6)
*/
double cwire = wire_cap(len); /* load capacitance */
double rwire = wire_res(len);
#define RES_ADJ (8.6) // Increase in resistance due to low driving vol.
double driver_res = (-8 * g_tp.FO4 / (log(0.5) * cwire)) / RES_ADJ;
double nsize = R_to_w(driver_res, NCH);
nsize = MIN(nsize, g_tp.max_w_nmos_);
nsize = MAX(nsize, g_tp.min_w_nmos_);
if (rwire*cwire > 8*g_tp.FO4) {
nsize = g_tp.max_w_nmos_;
}
// size the inverter appropriately to minimize the transmitter delay
// Note - In order to minimize leakage, we are not adding a set of inverters to
// bring down delay. Instead, we are sizing the single gate
// based on the logical effort.
double st_eff = sqrt((2 + beta / 1 + beta) * gate_C(nsize, 0) /
(gate_C(2 * g_tp.min_w_nmos_, 0)
+ gate_C(2 * min_w_pmos, 0)));
double req_cin = ((2 + beta / 1 + beta) * gate_C(nsize, 0)) / st_eff;
double inv_size = req_cin / (gate_C(min_w_pmos, 0) +
gate_C(g_tp.min_w_nmos_, 0));
inv_size = MAX(inv_size, 1);
/* nand gate delay */
double res_eq = (2 * tr_R_on(g_tp.min_w_nmos_, NCH, 1));
double cap_eq = 2 * drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
drain_C_(2 * g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
gate_C(inv_size * g_tp.min_w_nmos_, 0) +
gate_C(inv_size * min_w_pmos, 0);
double timeconst = res_eq * cap_eq;
delay = horowitz(inputrise, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, RISE);
double temp_power = cap_eq * deviceType->Vdd * deviceType->Vdd;
inputrise = delay / (deviceType->Vdd - deviceType->Vth); /* for the next stage */
/* Inverter delay:
* The load capacitance of this inv depends on
* the gate capacitance of the final stage nmos
* transistor which in turn depends on nsize
*/
res_eq = tr_R_on(inv_size * min_w_pmos, PCH, 1);
cap_eq = drain_C_(inv_size * min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
drain_C_(inv_size * g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def) +
gate_C(nsize, 0);
timeconst = res_eq * cap_eq;
delay += horowitz(inputrise, timeconst, deviceType->Vth / deviceType->Vdd,
deviceType->Vth / deviceType->Vdd, FALL);
temp_power += cap_eq * deviceType->Vdd * deviceType->Vdd;
transmitter.delay = delay;
/* since it is a diff. model*/
transmitter.power.readOp.dynamic = temp_power * 2;
transmitter.power.readOp.leakage = deviceType->Vdd *
(4 * cmos_Isub_leakage(g_tp.min_w_nmos_, min_w_pmos, 2, nand) +
4 * cmos_Isub_leakage(g_tp.min_w_nmos_, min_w_pmos, 1, inv));
transmitter.power.readOp.gate_leakage = deviceType->Vdd *
(4 * cmos_Ig_leakage(g_tp.min_w_nmos_, min_w_pmos, 2, nand) +
4 * cmos_Ig_leakage(g_tp.min_w_nmos_, min_w_pmos, 1, inv));
inputrise = delay / deviceType->Vth;
/* nmos delay + wire delay */
cap_eq = cwire + drain_C_(nsize, NCH, 1, 1, g_tp.cell_h_def) * 2 +
nsense * sense_amp_input_cap(); //+receiver cap
/*
* NOTE: nmos is used as both pull up and pull down transistor
* in the transmitter. This is because for low voltage swing, drive
* resistance of nmos is less than pmos
* (for a detailed graph ref: On-Chip Wires: Scaling and Efficiency)
*/
timeconst = (tr_R_on(nsize, NCH, 1) * RES_ADJ) * (cwire +
drain_C_(nsize, NCH, 1, 1, g_tp.cell_h_def) * 2) +
rwire * cwire / 2 +
(tr_R_on(nsize, NCH, 1) * RES_ADJ + rwire) *
nsense * sense_amp_input_cap();
/*
* since we are pre-equalizing and overdriving the low
* swing wires, the net time constant is less
* than the actual value
*/
delay += horowitz(inputrise, timeconst, deviceType->Vth /
deviceType->Vdd, .25, 0);
#define VOL_SWING .1
temp_power += cap_eq * VOL_SWING * .400; /* .4v is the over drive voltage */
temp_power *= 2; /* differential wire */
l_wire.delay = delay - transmitter.delay;
l_wire.power.readOp.dynamic = temp_power - transmitter.power.readOp.dynamic;
l_wire.power.readOp.leakage = deviceType->Vdd *
(4 * cmos_Isub_leakage(nsize, 0, 1, nmos));
l_wire.power.readOp.gate_leakage = deviceType->Vdd *
(4 * cmos_Ig_leakage(nsize, 0, 1, nmos));
//double rt = horowitz(inputrise, timeconst, deviceType->Vth/deviceType->Vdd,
// deviceType->Vth/deviceType->Vdd, RISE)/deviceType->Vth;
delay += g_tp.sense_delay;
sense_amp.delay = g_tp.sense_delay;
out_rise_time = g_tp.sense_delay / (deviceType->Vth);
sense_amp.power.readOp.dynamic = g_tp.sense_dy_power;
sense_amp.power.readOp.leakage = 0; //FIXME
sense_amp.power.readOp.gate_leakage = 0;
power.readOp.dynamic = temp_power + sense_amp.power.readOp.dynamic;
power.readOp.leakage = transmitter.power.readOp.leakage +
l_wire.power.readOp.leakage +
sense_amp.power.readOp.leakage;
power.readOp.gate_leakage = transmitter.power.readOp.gate_leakage +
l_wire.power.readOp.gate_leakage +
sense_amp.power.readOp.gate_leakage;
}
double
Wire::sense_amp_input_cap() {
return drain_C_(g_tp.w_iso, PCH, 1, 1, g_tp.cell_h_def) +
gate_C(g_tp.w_sense_en + g_tp.w_sense_n, 0) +
drain_C_(g_tp.w_sense_n, NCH, 1, 1, g_tp.cell_h_def) +
drain_C_(g_tp.w_sense_p, PCH, 1, 1, g_tp.cell_h_def);
}
void Wire::delay_optimal_wire () {
double len = wire_length;
//double min_wire_width = wire_width; //m
double beta = pmos_to_nmos_sz_ratio();
double switching = 0; // switching energy
double short_ckt = 0; // short-circuit energy
double tc = 0; // time constant
// input cap of min sized driver
double input_cap = gate_C(g_tp.min_w_nmos_ + min_w_pmos, 0);
// output parasitic capacitance of
// the min. sized driver
double out_cap = drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def);
// drive resistance
double out_res = (tr_R_on(g_tp.min_w_nmos_, NCH, 1) +
tr_R_on(min_w_pmos, PCH, 1)) / 2;
double wr = wire_res(len); //ohm
// wire cap /m
double wc = wire_cap(len);
// size the repeater such that the delay of the wire is minimum
// len will cancel
double repeater_scaling = sqrt(out_res * wc / (wr * input_cap));
// calc the optimum spacing between the repeaters (m)
repeater_spacing = sqrt(2 * out_res * (out_cap + input_cap) /
((wr / len) * (wc / len)));
repeater_size = repeater_scaling;
switching = (repeater_scaling * (input_cap + out_cap) +
repeater_spacing * (wc / len)) * deviceType->Vdd *
deviceType->Vdd;
tc = out_res * (input_cap + out_cap) +
out_res * wc / len * repeater_spacing / repeater_scaling +
wr / len * repeater_spacing * input_cap * repeater_scaling +
0.5 * (wr / len) * (wc / len) * repeater_spacing * repeater_spacing;
delay = 0.693 * tc * len / repeater_spacing;
#define Ishort_ckt 65e-6 /* across all tech Ref:Banerjee et al. {IEEE TED} */
short_ckt = deviceType->Vdd * g_tp.min_w_nmos_ * Ishort_ckt * 1.0986 *
repeater_scaling * tc;
area.set_area((len / repeater_spacing) *
compute_gate_area(INV, 1, min_w_pmos * repeater_scaling,
g_tp.min_w_nmos_ * repeater_scaling,
g_tp.cell_h_def));
power.readOp.dynamic = ((len / repeater_spacing) * (switching + short_ckt));
power.readOp.leakage = ((len / repeater_spacing) *
deviceType->Vdd *
cmos_Isub_leakage(g_tp.min_w_nmos_ *
repeater_scaling, beta *
g_tp.min_w_nmos_ *
repeater_scaling, 1, inv));
power.readOp.gate_leakage = ((len / repeater_spacing) *
deviceType->Vdd *
cmos_Ig_leakage(g_tp.min_w_nmos_ *
repeater_scaling, beta *
g_tp.min_w_nmos_ *
repeater_scaling, 1, inv));
}
// calculate power/delay values for wires with suboptimal repeater sizing/spacing
void
Wire::init_wire() {
wire_length = 1;
delay_optimal_wire();
double sp, si;
powerDef pow;
si = repeater_size;
sp = repeater_spacing;
sp *= 1e6; // in microns
double i, j, del;
repeated_wire.push_back(Component());
for (j = sp; j < 4*sp; j += 100) {
for (i = si; i > 1; i--) {
pow = wire_model(j * 1e-6, i, &del);
if (j == sp && i == si) {
global.delay = del;
global.power = pow;
global.area.h = si;
global.area.w = sp * 1e-6; // m
}
// cout << "Repeater size - "<< i <<
// " Repeater spacing - " << j <<
// " Delay - " << del <<
// " PowerD - " << pow.readOp.dynamic <<
// " PowerL - " << pow.readOp.leakage <<endl;
repeated_wire.back().delay = del;
repeated_wire.back().power.readOp = pow.readOp;
repeated_wire.back().area.w = j * 1e-6; //m
repeated_wire.back().area.h = i;
repeated_wire.push_back(Component());
}
}
repeated_wire.pop_back();
update_fullswing();
Wire *l_wire = new Wire(Low_swing, 0.001/* 1 mm*/, 1);
low_swing.delay = l_wire->delay;
low_swing.power = l_wire->power;
delete l_wire;
}
void Wire::update_fullswing() {
list<Component>::iterator citer;
double del[4];
del[3] = this->global.delay + this->global.delay * .3;
del[2] = global.delay + global.delay * .2;
del[1] = global.delay + global.delay * .1;
del[0] = global.delay + global.delay * .05;
double threshold;
double ncost;
double cost;
int i = 4;
while (i > 0) {
threshold = del[i-1];
cost = BIGNUM;
for (citer = repeated_wire.begin(); citer != repeated_wire.end();
citer++) {
if (citer->delay > threshold) {
citer = repeated_wire.erase(citer);
citer --;
} else {
ncost = citer->power.readOp.dynamic /
global.power.readOp.dynamic +
citer->power.readOp.leakage / global.power.readOp.leakage;
if (ncost < cost) {
cost = ncost;
if (i == 4) {
global_30.delay = citer->delay;
global_30.power = citer->power;
global_30.area = citer->area;
} else if (i == 3) {
global_20.delay = citer->delay;
global_20.power = citer->power;
global_20.area = citer->area;
} else if (i == 2) {
global_10.delay = citer->delay;
global_10.power = citer->power;
global_10.area = citer->area;
} else if (i == 1) {
global_5.delay = citer->delay;
global_5.power = citer->power;
global_5.area = citer->area;
}
}
}
}
i--;
}
}
powerDef Wire::wire_model (double space, double size, double *delay) {
powerDef ptemp;
double len = 1;
//double min_wire_width = wire_width; //m
double beta = pmos_to_nmos_sz_ratio();
// switching energy
double switching = 0;
// short-circuit energy
double short_ckt = 0;
// time constant
double tc = 0;
// input cap of min sized driver
double input_cap = gate_C (g_tp.min_w_nmos_ +
min_w_pmos, 0);
// output parasitic capacitance of
// the min. sized driver
double out_cap = drain_C_(min_w_pmos, PCH, 1, 1, g_tp.cell_h_def) +
drain_C_(g_tp.min_w_nmos_, NCH, 1, 1, g_tp.cell_h_def);
// drive resistance
double out_res = (tr_R_on(g_tp.min_w_nmos_, NCH, 1) +
tr_R_on(min_w_pmos, PCH, 1)) / 2;
double wr = wire_res(len); //ohm
// wire cap /m
double wc = wire_cap(len);
repeater_spacing = space;
repeater_size = size;
switching = (repeater_size * (input_cap + out_cap) +
repeater_spacing * (wc / len)) * deviceType->Vdd *
deviceType->Vdd;
tc = out_res * (input_cap + out_cap) +
out_res * wc / len * repeater_spacing / repeater_size +
wr / len * repeater_spacing * out_cap * repeater_size +
0.5 * (wr / len) * (wc / len) * repeater_spacing * repeater_spacing;
*delay = 0.693 * tc * len / repeater_spacing;
#define Ishort_ckt 65e-6 /* across all tech Ref:Banerjee et al. {IEEE TED} */
short_ckt = deviceType->Vdd * g_tp.min_w_nmos_ * Ishort_ckt * 1.0986 *
repeater_size * tc;
ptemp.readOp.dynamic = ((len / repeater_spacing) * (switching + short_ckt));
ptemp.readOp.leakage = ((len / repeater_spacing) *
deviceType->Vdd *
cmos_Isub_leakage(g_tp.min_w_nmos_ *
repeater_size, beta *
g_tp.min_w_nmos_ *
repeater_size, 1, inv));
ptemp.readOp.gate_leakage = ((len / repeater_spacing) *
deviceType->Vdd *
cmos_Ig_leakage(g_tp.min_w_nmos_ *
repeater_size, beta *
g_tp.min_w_nmos_ *
repeater_size, 1, inv));
return ptemp;
}
void
Wire::print_wire() {
cout << "\nWire Properties:\n\n";
cout << " Delay Optimal\n\tRepeater size - " << global.area.h <<
" \n\tRepeater spacing - " << global.area.w*1e3 << " (mm)"
" \n\tDelay - " << global.delay*1e6 << " (ns/mm)"
" \n\tPowerD - " << global.power.readOp.dynamic *1e6 << " (nJ/mm)"
" \n\tPowerL - " << global.power.readOp.leakage << " (mW/mm)"
" \n\tPowerLgate - " << global.power.readOp.gate_leakage <<
" (mW/mm)\n";
cout << "\tWire width - " << wire_width_init*1e6 << " microns\n";
cout << "\tWire spacing - " << wire_spacing_init*1e6 << " microns\n";
cout << endl;
cout << " 5% Overhead\n\tRepeater size - " << global_5.area.h <<
" \n\tRepeater spacing - " << global_5.area.w*1e3 << " (mm)"
" \n\tDelay - " << global_5.delay *1e6 << " (ns/mm)"
" \n\tPowerD - " << global_5.power.readOp.dynamic *1e6 << " (nJ/mm)"
" \n\tPowerL - " << global_5.power.readOp.leakage << " (mW/mm)"
" \n\tPowerLgate - " << global_5.power.readOp.gate_leakage <<
" (mW/mm)\n";
cout << "\tWire width - " << wire_width_init*1e6 << " microns\n";
cout << "\tWire spacing - " << wire_spacing_init*1e6 << " microns\n";
cout << endl;
cout << " 10% Overhead\n\tRepeater size - " << global_10.area.h <<
" \n\tRepeater spacing - " << global_10.area.w*1e3 << " (mm)"
" \n\tDelay - " << global_10.delay *1e6 << " (ns/mm)"
" \n\tPowerD - " << global_10.power.readOp.dynamic *1e6 << " (nJ/mm)"
" \n\tPowerL - " << global_10.power.readOp.leakage << " (mW/mm)"
" \n\tPowerLgate - " << global_10.power.readOp.gate_leakage <<
" (mW/mm)\n";
cout << "\tWire width - " << wire_width_init*1e6 << " microns\n";
cout << "\tWire spacing - " << wire_spacing_init*1e6 << " microns\n";
cout << endl;
cout << " 20% Overhead\n\tRepeater size - " << global_20.area.h <<
" \n\tRepeater spacing - " << global_20.area.w*1e3 << " (mm)"
" \n\tDelay - " << global_20.delay *1e6 << " (ns/mm)"
" \n\tPowerD - " << global_20.power.readOp.dynamic *1e6 << " (nJ/mm)"
" \n\tPowerL - " << global_20.power.readOp.leakage << " (mW/mm)"
" \n\tPowerLgate - " << global_20.power.readOp.gate_leakage <<
" (mW/mm)\n";
cout << "\tWire width - " << wire_width_init*1e6 << " microns\n";
cout << "\tWire spacing - " << wire_spacing_init*1e6 << " microns\n";
cout << endl;
cout << " 30% Overhead\n\tRepeater size - " << global_30.area.h <<
" \n\tRepeater spacing - " << global_30.area.w*1e3 << " (mm)"
" \n\tDelay - " << global_30.delay *1e6 << " (ns/mm)"
" \n\tPowerD - " << global_30.power.readOp.dynamic *1e6 << " (nJ/mm)"
" \n\tPowerL - " << global_30.power.readOp.leakage << " (mW/mm)"
" \n\tPowerLgate - " << global_30.power.readOp.gate_leakage <<
" (mW/mm)\n";
cout << "\tWire width - " << wire_width_init*1e6 << " microns\n";
cout << "\tWire spacing - " << wire_spacing_init*1e6 << " microns\n";
cout << endl;
cout << " Low-swing wire (1 mm) - Note: Unlike repeated wires, \n\t" <<
"delay and power values of low-swing wires do not\n\t" <<
"have a linear relationship with length." <<
" \n\tdelay - " << low_swing.delay *1e9 << " (ns)"
" \n\tpowerD - " << low_swing.power.readOp.dynamic *1e9 << " (nJ)"
" \n\tPowerL - " << low_swing.power.readOp.leakage << " (mW)"
" \n\tPowerLgate - " << low_swing.power.readOp.gate_leakage <<
" (mW)\n";
cout << "\tWire width - " << wire_width_init * 2 /* differential */ <<
" microns\n";
cout << "\tWire spacing - " << wire_spacing_init * 2 /* differential */ <<
" microns\n";
cout << endl;
cout << endl;
}