diff --git a/libs/EXTERNAL/libblifparse/src/blif_parser.y b/libs/EXTERNAL/libblifparse/src/blif_parser.y index 495d495b6d8..95c059828bb 100644 --- a/libs/EXTERNAL/libblifparse/src/blif_parser.y +++ b/libs/EXTERNAL/libblifparse/src/blif_parser.y @@ -193,12 +193,12 @@ subckt: DOT_SUBCKT STRING { $$ = SubCkt(); $$.model = $2; } latch: DOT_LATCH STRING STRING { //Input and output only callback.lineno(lexer.lineno()); - callback.latch($2, $3, LatchType::UNSPECIFIED, "", LogicValue::UNKOWN); + callback.latch($2, $3, LatchType::UNSPECIFIED, "", LogicValue::UNKNOWN); } | DOT_LATCH STRING STRING latch_type latch_control { //Input, output, type and control callback.lineno(lexer.lineno()); - callback.latch($2, $3, $4, $5, LogicValue::UNKOWN); + callback.latch($2, $3, $4, $5, LogicValue::UNKNOWN); } | DOT_LATCH STRING STRING latch_type latch_control latch_init { //Input, output, type, control and init-value @@ -215,7 +215,7 @@ latch: DOT_LATCH STRING STRING { latch_init: LOGIC_TRUE { $$ = LogicValue::TRUE; } | LOGIC_FALSE { $$ = LogicValue::FALSE; } | LATCH_INIT_2 { $$ = LogicValue::DONT_CARE; } - | LATCH_INIT_3 { $$ = LogicValue::UNKOWN; } + | LATCH_INIT_3 { $$ = LogicValue::UNKNOWN; } ; latch_control: STRING { $$ = $1;} diff --git a/libs/EXTERNAL/libblifparse/src/blif_pretty_print.cpp b/libs/EXTERNAL/libblifparse/src/blif_pretty_print.cpp index 7de25d73481..dbd5e306905 100644 --- a/libs/EXTERNAL/libblifparse/src/blif_pretty_print.cpp +++ b/libs/EXTERNAL/libblifparse/src/blif_pretty_print.cpp @@ -112,7 +112,7 @@ void BlifPrettyPrinter::latch(std::string input, std::string output, LatchType t case LogicValue::FALSE: printf("%s0", indent().c_str()); break; case LogicValue::TRUE: printf("%s1", indent().c_str()); break; case LogicValue::DONT_CARE: printf("%s2", indent().c_str()); break; - case LogicValue::UNKOWN: printf("%s3", indent().c_str()); break; + case LogicValue::UNKNOWN: printf("%s3", indent().c_str()); break; default: assert(false); } --indent_level_; diff --git a/libs/EXTERNAL/libblifparse/src/blifparse.hpp b/libs/EXTERNAL/libblifparse/src/blifparse.hpp index 1206a18d67b..66b720aa6b6 100644 --- a/libs/EXTERNAL/libblifparse/src/blifparse.hpp +++ b/libs/EXTERNAL/libblifparse/src/blifparse.hpp @@ -108,7 +108,7 @@ enum class LogicValue { FALSE = 0, //Logic zero TRUE = 1, //Logic one DONT_CARE, //Don't care - UNKOWN //Unkown (e.g. latch initial state) + UNKNOWN //Unkown (e.g. latch initial state) }; enum class LatchType { diff --git a/libs/EXTERNAL/libtatum/libtatum/tatum/base/TimingType.hpp b/libs/EXTERNAL/libtatum/libtatum/tatum/base/TimingType.hpp index 87bea4b8790..ed6addfc5f2 100644 --- a/libs/EXTERNAL/libtatum/libtatum/tatum/base/TimingType.hpp +++ b/libs/EXTERNAL/libtatum/libtatum/tatum/base/TimingType.hpp @@ -7,7 +7,7 @@ namespace tatum { enum class TimingType { SETUP, HOLD, - UNKOWN + UNKNOWN }; } //namespace diff --git a/libs/EXTERNAL/libtatum/libtatum/tatum/report/TimingPath.hpp b/libs/EXTERNAL/libtatum/libtatum/tatum/report/TimingPath.hpp index dbbaf955e9c..9d2eb7608fd 100644 --- a/libs/EXTERNAL/libtatum/libtatum/tatum/report/TimingPath.hpp +++ b/libs/EXTERNAL/libtatum/libtatum/tatum/report/TimingPath.hpp @@ -39,7 +39,7 @@ class TimingPathInfo { DomainId capture_domain() const { return capture_domain_; } private: - TimingType path_type_ = TimingType::UNKOWN; + TimingType path_type_ = TimingType::UNKNOWN; Time delay_; Time slack_; diff --git a/libs/EXTERNAL/libtatum/libtatum/tatum/report/graphviz_dot_writer.cpp b/libs/EXTERNAL/libtatum/libtatum/tatum/report/graphviz_dot_writer.cpp index 807a0eb963c..e2937c55051 100644 --- a/libs/EXTERNAL/libtatum/libtatum/tatum/report/graphviz_dot_writer.cpp +++ b/libs/EXTERNAL/libtatum/libtatum/tatum/report/graphviz_dot_writer.cpp @@ -38,7 +38,7 @@ void GraphvizDotWriter::write_dot_file(std::ostream& os) { for(NodeId node : nodes_to_dump_) { node_slacks[node] = std::vector(); //No slacks } - TimingType timing_type = TimingType::UNKOWN; + TimingType timing_type = TimingType::UNKNOWN; write_dot_format(os, node_tags, node_slacks, timing_type); } @@ -175,7 +175,7 @@ void GraphvizDotWriter::write_dot_edge(std::ostream& os, const EdgeId edge, cons } else if (timing_type == TimingType::HOLD) { os << "\\n"<< delay_calc_.hold_time(tg_, edge) << " (thld)"; } else { - TATUM_ASSERT(timing_type == TimingType::UNKOWN); + TATUM_ASSERT(timing_type == TimingType::UNKNOWN); //Create both setup and hold edges if type is unknown os << "\\n"<< -delay_calc_.setup_time(tg_, edge) << " (-tsu)"; os << "\\n"<< delay_calc_.hold_time(tg_, edge) << " (thld)"; @@ -190,7 +190,7 @@ void GraphvizDotWriter::write_dot_edge(std::ostream& os, const EdgeId edge, cons } else if (timing_type == TimingType::HOLD) { os << "\\n" << delay_calc_.min_edge_delay(tg_, edge); } else { - TATUM_ASSERT(timing_type == TimingType::UNKOWN); + TATUM_ASSERT(timing_type == TimingType::UNKNOWN); os << "\\n" << delay_calc_.max_edge_delay(tg_, edge) << " (tmax)"; os << "\\n" << delay_calc_.min_edge_delay(tg_, edge) << " (tmin)"; } diff --git a/libs/libvtrutil/src/vtr_logic.h b/libs/libvtrutil/src/vtr_logic.h index b5752c7941c..ab5854113d6 100644 --- a/libs/libvtrutil/src/vtr_logic.h +++ b/libs/libvtrutil/src/vtr_logic.h @@ -27,7 +27,7 @@ enum class LogicValue { FALSE = 0, TRUE = 1, DONT_CARE = 2, - UNKOWN = 3, + UNKNOWN = 3, NUM_LOGIC_VALUE_TYPES = 4 }; diff --git a/vpr/src/base/atom_netlist_utils.cpp b/vpr/src/base/atom_netlist_utils.cpp index 64590307bda..0630a9f6234 100644 --- a/vpr/src/base/atom_netlist_utils.cpp +++ b/vpr/src/base/atom_netlist_utils.cpp @@ -210,7 +210,7 @@ void print_netlist_as_blif(FILE* f, const AtomNetlist& netlist, const LogicalMod case vtr::LogicValue::DONT_CARE: init_val = 2; break; - case vtr::LogicValue::UNKOWN: + case vtr::LogicValue::UNKNOWN: init_val = 3; break; default: diff --git a/vpr/src/base/logic_vec.cpp b/vpr/src/base/logic_vec.cpp index 2d2ead54492..6701279ba6e 100644 --- a/vpr/src/base/logic_vec.cpp +++ b/vpr/src/base/logic_vec.cpp @@ -9,7 +9,7 @@ std::ostream& operator<<(std::ostream& os, vtr::LogicValue val) { os << "1"; else if (val == vtr::LogicValue::DONT_CARE) os << "-"; - else if (val == vtr::LogicValue::UNKOWN) + else if (val == vtr::LogicValue::UNKNOWN) os << "x"; else VTR_ASSERT(false); diff --git a/vpr/src/base/netlist_writer.cpp b/vpr/src/base/netlist_writer.cpp index 305ab659f0f..45213c6d5f2 100644 --- a/vpr/src/base/netlist_writer.cpp +++ b/vpr/src/base/netlist_writer.cpp @@ -594,7 +594,7 @@ class LatchInst : public Instance { os << "1'b0"; else if (initial_value_ == vtr::LogicValue::DONT_CARE) os << "1'bx"; - else if (initial_value_ == vtr::LogicValue::UNKOWN) + else if (initial_value_ == vtr::LogicValue::UNKNOWN) os << "1'bx"; else VTR_ASSERT(false); @@ -2395,7 +2395,7 @@ class NetlistWriterVisitor : public NetlistVisitor { size_t i = 0; //Walk through each input in the input cube for this row while (names_row[i] != ' ') { - vtr::LogicValue input_val = vtr::LogicValue::UNKOWN; + vtr::LogicValue input_val = vtr::LogicValue::UNKNOWN; if (names_row[i] == '1') { input_val = vtr::LogicValue::TRUE; } else if (names_row[i] == '0') { diff --git a/vpr/src/base/read_blif.cpp b/vpr/src/base/read_blif.cpp index 4de3020a3ba..afb36300451 100644 --- a/vpr/src/base/read_blif.cpp +++ b/vpr/src/base/read_blif.cpp @@ -634,7 +634,7 @@ struct BlifAllocCallback : public blifparse::Callback { }; vtr::LogicValue to_vtr_logic_value(blifparse::LogicValue val) { - vtr::LogicValue new_val = vtr::LogicValue::UNKOWN; + vtr::LogicValue new_val = vtr::LogicValue::UNKNOWN; switch (val) { case blifparse::LogicValue::TRUE: new_val = vtr::LogicValue::TRUE; @@ -645,8 +645,8 @@ vtr::LogicValue to_vtr_logic_value(blifparse::LogicValue val) { case blifparse::LogicValue::DONT_CARE: new_val = vtr::LogicValue::DONT_CARE; break; - case blifparse::LogicValue::UNKOWN: - new_val = vtr::LogicValue::UNKOWN; + case blifparse::LogicValue::UNKNOWN: + new_val = vtr::LogicValue::UNKNOWN; break; default: VTR_ASSERT_OPT_MSG(false, "Unknown logic value"); diff --git a/vpr/src/power/PowerSpicedComponent.cpp b/vpr/src/power/PowerSpicedComponent.cpp index 1d5c16a1aa2..c199c0513d7 100644 --- a/vpr/src/power/PowerSpicedComponent.cpp +++ b/vpr/src/power/PowerSpicedComponent.cpp @@ -10,45 +10,45 @@ #include "vpr_error.h" #include "PowerSpicedComponent.h" -bool sorter_PowerCallibSize(PowerCallibSize* a, PowerCallibSize* b); -bool sorter_PowerCallibInputs(PowerCallibInputs* a, PowerCallibInputs* b); +bool sorter_PowerCalibSize(PowerCalibSize* a, PowerCalibSize* b); +bool sorter_PowerCalibInputs(PowerCalibInputs* a, PowerCalibInputs* b); -PowerCallibInputs::PowerCallibInputs(PowerSpicedComponent* parent_, - float inputs) +PowerCalibInputs::PowerCalibInputs(PowerSpicedComponent* parent_, + float inputs) : parent(parent_) , num_inputs(inputs) , sorted(false) - , done_callibration(false) { + , done_calibration(false) { /* Add min/max bounding entries */ add_size(0); add_size(std::numeric_limits::max()); } -PowerCallibInputs::~PowerCallibInputs() { +PowerCalibInputs::~PowerCalibInputs() { for (auto entry : entries) { delete entry; } } -void PowerCallibInputs::add_size(float transistor_size, float power) { - PowerCallibSize* entry = new PowerCallibSize(transistor_size, power); +void PowerCalibInputs::add_size(float transistor_size, float power) { + PowerCalibSize* entry = new PowerCalibSize(transistor_size, power); entries.push_back(entry); sorted = false; } -bool sorter_PowerCallibSize(PowerCallibSize* a, PowerCallibSize* b) { +bool sorter_PowerCalibSize(PowerCalibSize* a, PowerCalibSize* b) { return a->transistor_size < b->transistor_size; } -void PowerCallibInputs::sort_me() { - sort(entries.begin(), entries.end(), sorter_PowerCallibSize); +void PowerCalibInputs::sort_me() { + sort(entries.begin(), entries.end(), sorter_PowerCalibSize); sorted = true; } -void PowerCallibInputs::callibrate() { +void PowerCalibInputs::calibrate() { VTR_ASSERT(entries.size() >= 2); - for (std::vector::iterator it = entries.begin() + 1; + for (std::vector::iterator it = entries.begin() + 1; it != entries.end() - 1; it++) { float est_power = parent->component_usage(num_inputs, (*it)->transistor_size); @@ -61,15 +61,15 @@ void PowerCallibInputs::callibrate() { /* Set max-value placeholder */ entries[entries.size() - 1]->factor = entries[entries.size() - 2]->factor; - done_callibration = true; + done_calibration = true; } -PowerCallibSize* PowerCallibInputs::get_entry_bound(bool lower, - float transistor_size) { - PowerCallibSize* prev = entries[0]; +PowerCalibSize* PowerCalibInputs::get_entry_bound(bool lower, + float transistor_size) { + PowerCalibSize* prev = entries[0]; VTR_ASSERT(sorted); - for (std::vector::iterator it = entries.begin() + 1; + for (std::vector::iterator it = entries.begin() + 1; it != entries.end(); it++) { if ((*it)->transistor_size > transistor_size) { if (lower) @@ -92,7 +92,7 @@ PowerSpicedComponent::PowerSpicedComponent(std::string component_name, // add_entry(std::numeric_limits::max()); add_entry(1000000000); - done_callibration = false; + done_calibration = false; sorted = true; } @@ -102,14 +102,14 @@ PowerSpicedComponent::~PowerSpicedComponent() { } } -PowerCallibInputs* PowerSpicedComponent::add_entry(int num_inputs) { - PowerCallibInputs* entry = new PowerCallibInputs(this, num_inputs); +PowerCalibInputs* PowerSpicedComponent::add_entry(int num_inputs) { + PowerCalibInputs* entry = new PowerCalibInputs(this, num_inputs); entries.push_back(entry); return entry; } -PowerCallibInputs* PowerSpicedComponent::get_entry(int num_inputs) { - std::vector::iterator it; +PowerCalibInputs* PowerSpicedComponent::get_entry(int num_inputs) { + std::vector::iterator it; for (it = entries.begin(); it != entries.end(); it++) { if ((*it)->num_inputs == num_inputs) { @@ -124,12 +124,12 @@ PowerCallibInputs* PowerSpicedComponent::get_entry(int num_inputs) { } } -PowerCallibInputs* PowerSpicedComponent::get_entry_bound(bool lower, - int num_inputs) { - PowerCallibInputs* prev = entries[0]; +PowerCalibInputs* PowerSpicedComponent::get_entry_bound(bool lower, + int num_inputs) { + PowerCalibInputs* prev = entries[0]; VTR_ASSERT(sorted); - for (std::vector::iterator it = entries.begin() + 1; + for (std::vector::iterator it = entries.begin() + 1; it != entries.end(); it++) { if ((*it)->num_inputs > num_inputs) { if (lower) { @@ -150,19 +150,19 @@ PowerCallibInputs* PowerSpicedComponent::get_entry_bound(bool lower, } void PowerSpicedComponent::add_data_point(int num_inputs, float transistor_size, float power) { - VTR_ASSERT(!done_callibration); - PowerCallibInputs* inputs_entry = get_entry(num_inputs); + VTR_ASSERT(!done_calibration); + PowerCalibInputs* inputs_entry = get_entry(num_inputs); inputs_entry->add_size(transistor_size, power); sorted = false; } float PowerSpicedComponent::scale_factor(int num_inputs, float transistor_size) { - PowerCallibInputs* inputs_lower; - PowerCallibInputs* inputs_upper; + PowerCalibInputs* inputs_lower; + PowerCalibInputs* inputs_upper; - PowerCallibSize* size_lower; - PowerCallibSize* size_upper; + PowerCalibSize* size_lower; + PowerCalibSize* size_upper; float factor_lower = 0.; float factor_upper = 0.; @@ -170,14 +170,14 @@ float PowerSpicedComponent::scale_factor(int num_inputs, float perc_upper; - VTR_ASSERT(done_callibration); + VTR_ASSERT(done_calibration); inputs_lower = get_entry_bound(true, num_inputs); inputs_upper = get_entry_bound(false, num_inputs); if (inputs_lower) { /* Interpolation of factor between sizes for lower # inputs */ - VTR_ASSERT(inputs_lower->done_callibration); + VTR_ASSERT(inputs_lower->done_calibration); size_lower = inputs_lower->get_entry_bound(true, transistor_size); size_upper = inputs_lower->get_entry_bound(false, transistor_size); @@ -193,7 +193,7 @@ float PowerSpicedComponent::scale_factor(int num_inputs, if (inputs_upper) { /* Interpolation of factor between sizes for upper # inputs */ - VTR_ASSERT(inputs_upper->done_callibration); + VTR_ASSERT(inputs_upper->done_calibration); size_lower = inputs_upper->get_entry_bound(true, transistor_size); size_upper = inputs_upper->get_entry_bound(false, transistor_size); @@ -221,41 +221,41 @@ float PowerSpicedComponent::scale_factor(int num_inputs, return factor; } -bool sorter_PowerCallibInputs(PowerCallibInputs* a, PowerCallibInputs* b) { +bool sorter_PowerCalibInputs(PowerCalibInputs* a, PowerCalibInputs* b) { return a->num_inputs < b->num_inputs; } void PowerSpicedComponent::sort_me() { - sort(entries.begin(), entries.end(), sorter_PowerCallibInputs); + sort(entries.begin(), entries.end(), sorter_PowerCalibInputs); - for (std::vector::iterator it = entries.begin(); + for (std::vector::iterator it = entries.begin(); it != entries.end(); it++) { (*it)->sort_me(); } sorted = true; } -void PowerSpicedComponent::callibrate() { +void PowerSpicedComponent::calibrate() { sort_me(); - for (std::vector::iterator it = entries.begin(); + for (std::vector::iterator it = entries.begin(); it != entries.end(); it++) { - (*it)->callibrate(); + (*it)->calibrate(); } - done_callibration = true; + done_calibration = true; } -bool PowerSpicedComponent::is_done_callibration() { - return done_callibration; +bool PowerSpicedComponent::is_done_calibration() { + return done_calibration; } void PowerSpicedComponent::print(FILE* fp) { fprintf(fp, "%s\n", name.c_str()); - for (std::vector::iterator it = entries.begin() + 1; + for (std::vector::iterator it = entries.begin() + 1; it != entries.end() - 1; it++) { fprintf(fp, "Num Inputs: %d\n", (*it)->num_inputs); - for (std::vector::iterator it2 = (*it)->entries.begin() - + 1; + for (std::vector::iterator it2 = (*it)->entries.begin() + + 1; it2 != (*it)->entries.end() - 1; it2++) { fprintf(fp, " Transistor Size: %6f Factor: %3f\n", (*it2)->transistor_size, (*it2)->factor); diff --git a/vpr/src/power/PowerSpicedComponent.h b/vpr/src/power/PowerSpicedComponent.h index 2100ee6896d..61be30e87ed 100644 --- a/vpr/src/power/PowerSpicedComponent.h +++ b/vpr/src/power/PowerSpicedComponent.h @@ -22,53 +22,53 @@ /************************* STRUCTS **********************************/ class PowerSpicedComponent; -class PowerCallibSize { +class PowerCalibSize { public: float transistor_size; float power; float factor; - PowerCallibSize(float size, float power_) + PowerCalibSize(float size, float power_) : transistor_size(size) , power(power_) , factor(0.) { } - bool operator<(const PowerCallibSize& rhs) { + bool operator<(const PowerCalibSize& rhs) { return transistor_size < rhs.transistor_size; } }; -class PowerCallibInputs { +class PowerCalibInputs { public: PowerSpicedComponent* parent; int num_inputs; - std::vector entries; + std::vector entries; bool sorted; - PowerCallibInputs(PowerSpicedComponent* parent, float num_inputs); - ~PowerCallibInputs(); + PowerCalibInputs(PowerSpicedComponent* parent, float num_inputs); + ~PowerCalibInputs(); void add_size(float transistor_size, float power = 0.); - PowerCallibSize* get_entry_bound(bool lower, float transistor_size); + PowerCalibSize* get_entry_bound(bool lower, float transistor_size); void sort_me(); - bool done_callibration; - void callibrate(); + bool done_calibration; + void calibrate(); }; class PowerSpicedComponent { public: std::string name; - std::vector entries; + std::vector entries; /* Estimation function for this component */ float (*component_usage)(int num_inputs, float transistor_size); bool sorted; - bool done_callibration; + bool done_calibration; - PowerCallibInputs* add_entry(int num_inputs); - PowerCallibInputs* get_entry(int num_inputs); - PowerCallibInputs* get_entry_bound(bool lower, int num_inputs); + PowerCalibInputs* add_entry(int num_inputs); + PowerCalibInputs* get_entry(int num_inputs); + PowerCalibInputs* get_entry_bound(bool lower, int num_inputs); PowerSpicedComponent(std::string component_name, float (*usage_fn)(int num_inputs, float transistor_size)); @@ -79,7 +79,7 @@ class PowerSpicedComponent { void sort_me(); // void update_scale_factor(float (*fn)(float size)); - void callibrate(); - bool is_done_callibration(); + void calibrate(); + bool is_done_calibration(); void print(FILE* fp); }; diff --git a/vpr/src/power/power.cpp b/vpr/src/power/power.cpp index ab538d52acb..6bad5bfe24d 100644 --- a/vpr/src/power/power.cpp +++ b/vpr/src/power/power.cpp @@ -38,7 +38,7 @@ #include "power_util.h" #include "power_lowlevel.h" #include "power_sizing.h" -#include "power_callibrate.h" +#include "power_calibrate.h" #include "power_cmos_tech.h" #include "physical_types.h" @@ -1332,7 +1332,7 @@ bool power_init(const char* power_out_filepath, power_components_init(); /* Perform calibration */ - power_callibrate(); + power_calibrate(); /* Initialize routing information */ power_routing_init(routing_arch); @@ -1344,7 +1344,7 @@ bool power_init(const char* power_out_filepath, power_sizing_init(); //power_print_spice_comparison(); - // power_print_callibration(); + // power_print_calibration(); return error; } @@ -1386,10 +1386,10 @@ bool power_uninit() { delete mux_info; } /* Free components */ - for (int i = 0; i < POWER_CALLIB_COMPONENT_MAX; ++i) { - delete power_ctx.commonly_used->component_callibration[i]; + for (int i = 0; i < POWER_CALIB_COMPONENT_MAX; ++i) { + delete power_ctx.commonly_used->component_calibration[i]; } - delete[] power_ctx.commonly_used->component_callibration; + delete[] power_ctx.commonly_used->component_calibration; delete power_ctx.commonly_used; diff --git a/vpr/src/power/power.h b/vpr/src/power/power.h index 1621d524246..1ef93fe5d76 100644 --- a/vpr/src/power/power.h +++ b/vpr/src/power/power.h @@ -235,7 +235,7 @@ struct t_power_commonly_used { float INV_2X_C; /* Component Calibrations Array [0..POWER_COMPONENT_MAX_NUM-1] */ - PowerSpicedComponent** component_callibration; + PowerSpicedComponent** component_calibration; /* Subthreshold leakages */ float NMOS_1X_st_leakage; diff --git a/vpr/src/power/power_callibrate.cpp b/vpr/src/power/power_calibrate.cpp similarity index 87% rename from vpr/src/power/power_callibrate.cpp rename to vpr/src/power/power_calibrate.cpp index 6b83daeadaa..29766a37e4a 100644 --- a/vpr/src/power/power_callibrate.cpp +++ b/vpr/src/power/power_calibrate.cpp @@ -22,7 +22,7 @@ /************************* INCLUDES *********************************/ #include "vtr_assert.h" -#include "power_callibrate.h" +#include "power_calibrate.h" #include "power_components.h" #include "power_util.h" #include "globals.h" @@ -64,7 +64,7 @@ void power_print_spice_comparison() { // fprintf(power_ctx.output->out, "Energy of INV (High Activity)\n"); // for (i = 0; i < (sizeof(inv_sizes) / sizeof(float)); i++) { // power_usage_inverter(&sub_power_usage, 2, 0.5, inv_sizes[i], - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%g\t%g\n", inv_sizes[i], // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -73,7 +73,7 @@ void power_print_spice_comparison() { // fprintf(power_ctx.output->out, "Energy of INV (No Activity)\n"); // for (i = 0; i < (sizeof(inv_sizes) / sizeof(float)); i++) { // power_usage_inverter(&sub_power_usage, 0, 1, inv_sizes[i], - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%g\t%g\n", inv_sizes[i], // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -94,7 +94,7 @@ void power_print_spice_comparison() { // } // power_usage_mux_multilevel(&mux_power_usage, // power_get_mux_arch(mux_sizes[i]), prob, dens, 0, false, - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%d\t%g\n", mux_sizes[i], // (mux_power_usage.dynamic + mux_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -119,7 +119,7 @@ void power_print_spice_comparison() { // } // power_usage_mux_multilevel(&mux_power_usage, // power_get_mux_arch(mux_sizes[i]), prob, dens, 0, false, - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%d\t%g\n", mux_sizes[i], // (mux_power_usage.dynamic + mux_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -128,7 +128,7 @@ void power_print_spice_comparison() { // fprintf(power_ctx.output->out, "Energy of Buffer (High Activity)\n"); // for (i = 0; i < (sizeof(buffer_sizes) / sizeof(float)); i++) { // power_usage_buffer(&sub_power_usage, buffer_sizes[i], 0.5, 2, false, - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%g\t%g\n", buffer_sizes[i], // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -137,7 +137,7 @@ void power_print_spice_comparison() { // fprintf(power_ctx.output->out, "Energy of Buffer (No Activity)\n"); // for (i = 0; i < (sizeof(buffer_sizes) / sizeof(float)); i++) { // power_usage_buffer(&sub_power_usage, buffer_sizes[i], 1, 0, false, - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%g\t%g\n", buffer_sizes[i], // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit); @@ -171,7 +171,7 @@ void power_print_spice_comparison() { prob[j] = 0.5; } power_usage_lut(&sub_power_usage, LUT_sizes[i], 1.0, SRAM_bits_chars, prob, - dens, power_callib_period); + dens, power_calib_period); t_power_usage power_usage_mux; @@ -210,7 +210,7 @@ void power_print_spice_comparison() { // prob[j] = 1; // } // power_usage_lut(&sub_power_usage, LUT_sizes[i], SRAM_bits, prob, dens, - // power_callib_period); + // power_calib_period); // fprintf(power_ctx.output->out, "%d\t%g\n", LUT_sizes[i], // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit * 2); @@ -218,12 +218,12 @@ void power_print_spice_comparison() { // fprintf(power_ctx.output->out, "Energy of FF (High Activity)\n"); power_usage_ff(&sub_power_usage, 1.0, 0.5, 3, 0.5, 1, 0.5, 2, - power_callib_period); + power_calib_period); fprintf(power_ctx.output->out, "%g\n", (sub_power_usage.dynamic + sub_power_usage.leakage)); // // fprintf(power_ctx.output->out, "Energy of FF (No Activity)\n"); - // power_usage_ff(&sub_power_usage, 1, 0, 1, 0, 1, 0, power_callib_period); + // power_usage_ff(&sub_power_usage, 1, 0, 1, 0, 1, 0, power_calib_period); // fprintf(power_ctx.output->out, "%g\n", // (sub_power_usage.dynamic + sub_power_usage.leakage) // * power_ctx.solution_inf.T_crit * 2); @@ -243,11 +243,11 @@ void power_print_spice_comparison() { // // power_usage_mux_multilevel(&sub_power_usage, // power_get_mux_arch(sb_mux_sizes[i]), prob, dens, 0, true, - // power_callib_period); + // power_calib_period); // power_add_usage(&sb_power_usage, &sub_power_usage); // // power_usage_buffer(&sub_power_usage, sb_buffer_sizes[i], 0.5, 2, true, - // power_callib_period); + // power_calib_period); // power_add_usage(&sb_power_usage, &sub_power_usage); // // fprintf(power_ctx.output->out, "%d\t%.0f\t%g\n", sb_mux_sizes[i], @@ -276,11 +276,11 @@ void power_print_spice_comparison() { // // power_usage_mux_multilevel(&sub_power_usage, // power_get_mux_arch(sb_mux_sizes[i]), prob, dens, 0, true, - // power_callib_period); + // power_calib_period); // power_add_usage(&sb_power_usage, &sub_power_usage); // // power_usage_buffer(&sub_power_usage, sb_buffer_sizes[i], 1, 0, true, - // power_callib_period); + // power_calib_period); // power_add_usage(&sb_power_usage, &sub_power_usage); // // fprintf(power_ctx.output->out, "%d\t%.0f\t%g\n", sb_mux_sizes[i], @@ -302,30 +302,30 @@ static char binary_not(char c) { } } -float power_usage_buf_for_callibration(int num_inputs, float transistor_size) { +float power_usage_buf_for_calibration(int num_inputs, float transistor_size) { t_power_usage power_usage; VTR_ASSERT(num_inputs == 1); power_usage_buffer(&power_usage, transistor_size, 0.5, 2.0, false, - power_callib_period); + power_calib_period); return power_sum_usage(&power_usage); } -float power_usage_buf_levr_for_callibration(int num_inputs, - float transistor_size) { +float power_usage_buf_levr_for_calibration(int num_inputs, + float transistor_size) { t_power_usage power_usage; VTR_ASSERT(num_inputs == 1); power_usage_buffer(&power_usage, transistor_size, 0.5, 2.0, true, - power_callib_period); + power_calib_period); return power_sum_usage(&power_usage); } -float power_usage_mux_for_callibration(int num_inputs, float transistor_size) { +float power_usage_mux_for_calibration(int num_inputs, float transistor_size) { t_power_usage power_usage; float* dens; float* prob; @@ -339,7 +339,7 @@ float power_usage_mux_for_callibration(int num_inputs, float transistor_size) { power_usage_mux_multilevel(&power_usage, power_get_mux_arch(num_inputs, transistor_size), prob, dens, 0, - false, power_callib_period); + false, power_calib_period); delete[] dens; delete[] prob; @@ -347,7 +347,7 @@ float power_usage_mux_for_callibration(int num_inputs, float transistor_size) { return power_sum_usage(&power_usage); } -float power_usage_lut_for_callibration(int num_inputs, float transistor_size) { +float power_usage_lut_for_calibration(int num_inputs, float transistor_size) { t_power_usage power_usage; char* SRAM_bits; float* dens; @@ -377,7 +377,7 @@ float power_usage_lut_for_callibration(int num_inputs, float transistor_size) { prob[i] = 0.5; } power_usage_lut(&power_usage, lut_size, transistor_size, SRAM_bits, prob, - dens, power_callib_period); + dens, power_calib_period); delete[] SRAM_bits; delete[] dens; @@ -386,33 +386,33 @@ float power_usage_lut_for_callibration(int num_inputs, float transistor_size) { return power_sum_usage(&power_usage); } -float power_usage_ff_for_callibration(int num_inputs, float transistor_size) { +float power_usage_ff_for_calibration(int num_inputs, float transistor_size) { t_power_usage power_usage; VTR_ASSERT(num_inputs == 1); power_usage_ff(&power_usage, transistor_size, 0.5, 3, 0.5, 1, 0.5, 2, - power_callib_period); + power_calib_period); return power_sum_usage(&power_usage); } -void power_callibrate() { +void power_calibrate() { /* Buffers and Mux must be done before LUT/FF */ auto& power_ctx = g_vpr_ctx.power(); - power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER]->callibrate(); - power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR]->callibrate(); - power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX]->callibrate(); - power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT]->callibrate(); - power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF]->callibrate(); + power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER]->calibrate(); + power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER_WITH_LEVR]->calibrate(); + power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_MUX]->calibrate(); + power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_LUT]->calibrate(); + power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_FF]->calibrate(); } -void power_print_callibration() { +void power_print_calibration() { auto& power_ctx = g_vpr_ctx.power(); - power_print_title(power_ctx.output->out, "Callibration Data"); - for (int i = 0; i < POWER_CALLIB_COMPONENT_MAX; i++) { - power_ctx.commonly_used->component_callibration[i]->print(power_ctx.output->out); + power_print_title(power_ctx.output->out, "Calibration Data"); + for (int i = 0; i < POWER_CALIB_COMPONENT_MAX; i++) { + power_ctx.commonly_used->component_calibration[i]->print(power_ctx.output->out); } } diff --git a/vpr/src/power/power_callibrate.h b/vpr/src/power/power_calibrate.h similarity index 57% rename from vpr/src/power/power_callibrate.h rename to vpr/src/power/power_calibrate.h index eaf51cfb90a..2ae271a5a87 100644 --- a/vpr/src/power/power_callibrate.h +++ b/vpr/src/power/power_calibrate.h @@ -21,26 +21,26 @@ */ /************************* DEFINES **********************************/ -const float power_callib_period = 5e-9; +const float power_calib_period = 5e-9; /************************* STRUCTS **********************************/ /************************* ENUMS ************************************/ typedef enum { - POWER_CALLIB_COMPONENT_BUFFER = 0, - POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR, - POWER_CALLIB_COMPONENT_FF, - POWER_CALLIB_COMPONENT_MUX, - POWER_CALLIB_COMPONENT_LUT, - POWER_CALLIB_COMPONENT_MAX -} e_power_callib_component; + POWER_CALIB_COMPONENT_BUFFER = 0, + POWER_CALIB_COMPONENT_BUFFER_WITH_LEVR, + POWER_CALIB_COMPONENT_FF, + POWER_CALIB_COMPONENT_MUX, + POWER_CALIB_COMPONENT_LUT, + POWER_CALIB_COMPONENT_MAX +} e_power_calib_component; /************************* FUNCTION DECLARATIONS ********************/ void power_print_spice_comparison(); -void power_callibrate(); -float power_usage_buf_for_callibration(int num_inputs, float transistor_size); -float power_usage_buf_levr_for_callibration(int num_inputs, - float transistor_size); -float power_usage_mux_for_callibration(int num_inputs, float transistor_size); -float power_usage_lut_for_callibration(int num_inputs, float transistor_size); -float power_usage_ff_for_callibration(int num_inputs, float transistor_size); -void power_print_callibration(); +void power_calibrate(); +float power_usage_buf_for_calibration(int num_inputs, float transistor_size); +float power_usage_buf_levr_for_calibration(int num_inputs, + float transistor_size); +float power_usage_mux_for_calibration(int num_inputs, float transistor_size); +float power_usage_lut_for_calibration(int num_inputs, float transistor_size); +float power_usage_ff_for_calibration(int num_inputs, float transistor_size); +void power_print_calibration(); diff --git a/vpr/src/power/power_cmos_tech.cpp b/vpr/src/power/power_cmos_tech.cpp index 1858c001df4..3f4b55269cd 100644 --- a/vpr/src/power/power_cmos_tech.cpp +++ b/vpr/src/power/power_cmos_tech.cpp @@ -36,7 +36,7 @@ #include "power.h" #include "power_util.h" #include "PowerSpicedComponent.h" -#include "power_callibrate.h" +#include "power_calibrate.h" /************************* FILE SCOPE **********************************/ static t_transistor_inf* f_transistor_last_searched; @@ -154,29 +154,29 @@ static void power_tech_xml_load_component(pugi::xml_node parent, const pugiutil: static void power_tech_xml_load_components(pugi::xml_node parent, const pugiutil::loc_data& loc_data) { auto& power_ctx = g_vpr_ctx.power(); - power_ctx.commonly_used->component_callibration = new PowerSpicedComponent*[POWER_CALLIB_COMPONENT_MAX]; - for (int i = 0; i < POWER_CALLIB_COMPONENT_MAX; i++) - power_ctx.commonly_used->component_callibration[i] = nullptr; + power_ctx.commonly_used->component_calibration = new PowerSpicedComponent*[POWER_CALIB_COMPONENT_MAX]; + for (int i = 0; i < POWER_CALIB_COMPONENT_MAX; i++) + power_ctx.commonly_used->component_calibration[i] = nullptr; power_tech_xml_load_component(parent, loc_data, - &power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER], - "buf", power_usage_buf_for_callibration); + &power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER], + "buf", power_usage_buf_for_calibration); power_tech_xml_load_component(parent, loc_data, - &power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR], - "buf_levr", power_usage_buf_levr_for_callibration); + &power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER_WITH_LEVR], + "buf_levr", power_usage_buf_levr_for_calibration); power_tech_xml_load_component(parent, loc_data, - &power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF], - "dff", power_usage_ff_for_callibration); + &power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_FF], + "dff", power_usage_ff_for_calibration); power_tech_xml_load_component(parent, loc_data, - &power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX], - "mux", power_usage_mux_for_callibration); + &power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_MUX], + "mux", power_usage_mux_for_calibration); power_tech_xml_load_component(parent, loc_data, - &power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT], - "lut", power_usage_lut_for_callibration); + &power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_LUT], + "lut", power_usage_lut_for_calibration); } /** diff --git a/vpr/src/power/power_components.cpp b/vpr/src/power/power_components.cpp index 0b189a72148..bb1e581ab7e 100644 --- a/vpr/src/power/power_components.cpp +++ b/vpr/src/power/power_components.cpp @@ -31,7 +31,7 @@ #include "power_components.h" #include "power_lowlevel.h" #include "power_util.h" -#include "power_callibrate.h" +#include "power_calibrate.h" #include "globals.h" /************************* STRUCTS **********************************/ @@ -110,7 +110,7 @@ void power_usage_ff(t_power_usage* power_usage, float size, float D_prob, float t_power_usage sub_power_usage; float mux_in_dens[2]; float mux_in_prob[2]; - PowerSpicedComponent* callibration; + PowerSpicedComponent* calibration; float scale_factor; power_zero_usage(power_usage); @@ -153,11 +153,11 @@ void power_usage_ff(t_power_usage* power_usage, float size, float D_prob, float power_usage_inverter(&sub_power_usage, Q_dens, Q_prob, size, period); power_add_usage(power_usage, &sub_power_usage); - /* Callibration */ + /* Calibration */ auto& power_ctx = g_vpr_ctx.power(); - callibration = power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_FF]; - if (callibration->is_done_callibration()) { - scale_factor = callibration->scale_factor(1, size); + calibration = power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_FF]; + if (calibration->is_done_calibration()) { + scale_factor = calibration->scale_factor(1, size); power_scale_usage(power_usage, scale_factor); } @@ -209,7 +209,7 @@ void power_usage_lut(t_power_usage* power_usage, int lut_size, float transistor_ float** internal_v; int i; int level_idx; - PowerSpicedComponent* callibration; + PowerSpicedComponent* calibration; float scale_factor; int num_SRAM_bits; @@ -383,10 +383,10 @@ void power_usage_lut(t_power_usage* power_usage, int lut_size, float transistor_ delete[] internal_dens; delete[] internal_v; - /* Callibration */ - callibration = power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_LUT]; - if (callibration->is_done_callibration()) { - scale_factor = callibration->scale_factor(lut_size, transistor_size); + /* Calibration */ + calibration = power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_LUT]; + if (calibration->is_done_calibration()) { + scale_factor = calibration->scale_factor(lut_size, transistor_size); power_scale_usage(power_usage, scale_factor); } @@ -538,7 +538,7 @@ void power_usage_mux_multilevel(t_power_usage* power_usage, float output_prob; float V_out; bool found; - PowerSpicedComponent* callibration; + PowerSpicedComponent* calibration; float scale_factor; int* selector_values = new int[mux_arch->levels]; for (auto i = 0; i < mux_arch->levels; i++) @@ -563,10 +563,10 @@ void power_usage_mux_multilevel(t_power_usage* power_usage, delete[] selector_values; - callibration = power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_MUX]; - if (callibration->is_done_callibration()) { - scale_factor = callibration->scale_factor(mux_arch->num_inputs, - mux_arch->transistor_size); + calibration = power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_MUX]; + if (calibration->is_done_calibration()) { + scale_factor = calibration->scale_factor(mux_arch->num_inputs, + mux_arch->transistor_size); power_scale_usage(power_usage, scale_factor); } } @@ -649,7 +649,7 @@ void power_usage_buffer(t_power_usage* power_usage, float size, float in_prob, f float stage_in_prob; float input_dyn_power; float scale_factor; - PowerSpicedComponent* callibration; + PowerSpicedComponent* calibration; power_zero_usage(power_usage); @@ -685,15 +685,15 @@ void power_usage_buffer(t_power_usage* power_usage, float size, float in_prob, f stage_in_prob = 1 - stage_in_prob; } - /* Callibration */ + /* Calibration */ if (level_restorer) { - callibration = power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER_WITH_LEVR]; + calibration = power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER_WITH_LEVR]; } else { - callibration = power_ctx.commonly_used->component_callibration[POWER_CALLIB_COMPONENT_BUFFER]; + calibration = power_ctx.commonly_used->component_calibration[POWER_CALIB_COMPONENT_BUFFER]; } - if (callibration->is_done_callibration()) { - scale_factor = callibration->scale_factor(1, size); + if (calibration->is_done_calibration()) { + scale_factor = calibration->scale_factor(1, size); power_scale_usage(power_usage, scale_factor); } diff --git a/vpr/src/timing/concrete_timing_info.h b/vpr/src/timing/concrete_timing_info.h index 7e4d0a5dd58..1cbf4eb43d1 100644 --- a/vpr/src/timing/concrete_timing_info.h +++ b/vpr/src/timing/concrete_timing_info.h @@ -33,14 +33,14 @@ class ConcreteSetupTimingInfo : public SetupTimingInfo { public: //Accessors tatum::TimingPathInfo least_slack_critical_path() const override { - if (least_slack_critical_path_.type() == tatum::TimingType::UNKOWN) { + if (least_slack_critical_path_.type() == tatum::TimingType::UNKNOWN) { least_slack_critical_path_ = find_least_slack_critical_path_delay(*timing_constraints_, *setup_analyzer_); } return least_slack_critical_path_; } tatum::TimingPathInfo longest_critical_path() const override { - if (longest_critical_path_.type() == tatum::TimingType::UNKOWN) { + if (longest_critical_path_.type() == tatum::TimingType::UNKNOWN) { longest_critical_path_ = find_longest_critical_path_delay(*timing_constraints_, *setup_analyzer_); } return longest_critical_path_;