From be1845a71a9932f2e570dea6faeeb50ba10f35f4 Mon Sep 17 00:00:00 2001 From: AlexandreSinger Date: Thu, 27 Nov 2025 22:31:11 -0500 Subject: [PATCH 1/2] [Spelling] Renamed Misspelled "Unknown" and "callibration" There were several cases where an enum was created for an "Unknown" value, but it was spelled "Unkown". This was fixed. In power, there was an entire sub-class of the power analysis where every use of "calibration" was spelled with 2 Ls. This has been resolved. --- libs/EXTERNAL/libblifparse/src/blif_parser.y | 6 +- .../libblifparse/src/blif_pretty_print.cpp | 2 +- libs/EXTERNAL/libblifparse/src/blifparse.hpp | 2 +- .../libtatum/tatum/base/TimingType.hpp | 2 +- .../libtatum/tatum/report/TimingPath.hpp | 2 +- .../tatum/report/graphviz_dot_writer.cpp | 6 +- libs/libvtrutil/src/vtr_logic.h | 2 +- vpr/src/base/atom_netlist_utils.cpp | 2 +- vpr/src/base/logic_vec.cpp | 2 +- vpr/src/base/netlist_writer.cpp | 4 +- vpr/src/base/read_blif.cpp | 6 +- vpr/src/power/PowerSpicedComponent.cpp | 88 +++++++++---------- vpr/src/power/PowerSpicedComponent.h | 34 +++---- vpr/src/power/power.cpp | 12 +-- vpr/src/power/power.h | 2 +- ...wer_callibrate.cpp => power_calibrate.cpp} | 70 +++++++-------- .../{power_callibrate.h => power_calibrate.h} | 30 +++---- vpr/src/power/power_cmos_tech.cpp | 28 +++--- vpr/src/power/power_components.cpp | 42 ++++----- vpr/src/timing/concrete_timing_info.h | 4 +- 20 files changed, 173 insertions(+), 173 deletions(-) rename vpr/src/power/{power_callibrate.cpp => power_calibrate.cpp} (87%) rename vpr/src/power/{power_callibrate.h => power_calibrate.h} (61%) 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..44a0f48935d 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_, +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, +PowerCalibSize* PowerCalibInputs::get_entry_bound(bool lower, float transistor_size) { - PowerCallibSize* prev = entries[0]; + 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, +PowerCalibInputs* PowerSpicedComponent::get_entry_bound(bool lower, int num_inputs) { - PowerCallibInputs* prev = entries[0]; + 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,40 +221,40 @@ 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() + for (std::vector::iterator it2 = (*it)->entries.begin() + 1; it2 != (*it)->entries.end() - 1; it2++) { fprintf(fp, " Transistor Size: %6f Factor: %3f\n", 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..cde61d07bdc 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 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 61% rename from vpr/src/power/power_callibrate.h rename to vpr/src/power/power_calibrate.h index eaf51cfb90a..63d6f9dcbeb 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, +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_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(); +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..5ee7d1c22f6 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,9 +563,9 @@ 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, + 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_; From f52f6127c2ef7351f0837dc7806fcb75aadc354d Mon Sep 17 00:00:00 2001 From: AlexandreSinger Date: Fri, 28 Nov 2025 12:21:40 -0500 Subject: [PATCH 2/2] [Format] Fixed Formatting --- vpr/src/power/PowerSpicedComponent.cpp | 8 ++++---- vpr/src/power/power_calibrate.cpp | 2 +- vpr/src/power/power_calibrate.h | 2 +- vpr/src/power/power_components.cpp | 2 +- 4 files changed, 7 insertions(+), 7 deletions(-) diff --git a/vpr/src/power/PowerSpicedComponent.cpp b/vpr/src/power/PowerSpicedComponent.cpp index 44a0f48935d..c199c0513d7 100644 --- a/vpr/src/power/PowerSpicedComponent.cpp +++ b/vpr/src/power/PowerSpicedComponent.cpp @@ -14,7 +14,7 @@ bool sorter_PowerCalibSize(PowerCalibSize* a, PowerCalibSize* b); bool sorter_PowerCalibInputs(PowerCalibInputs* a, PowerCalibInputs* b); PowerCalibInputs::PowerCalibInputs(PowerSpicedComponent* parent_, - float inputs) + float inputs) : parent(parent_) , num_inputs(inputs) , sorted(false) @@ -65,7 +65,7 @@ void PowerCalibInputs::calibrate() { } PowerCalibSize* PowerCalibInputs::get_entry_bound(bool lower, - float transistor_size) { + float transistor_size) { PowerCalibSize* prev = entries[0]; VTR_ASSERT(sorted); @@ -125,7 +125,7 @@ PowerCalibInputs* PowerSpicedComponent::get_entry(int num_inputs) { } PowerCalibInputs* PowerSpicedComponent::get_entry_bound(bool lower, - int num_inputs) { + int num_inputs) { PowerCalibInputs* prev = entries[0]; VTR_ASSERT(sorted); @@ -255,7 +255,7 @@ void PowerSpicedComponent::print(FILE* fp) { it != entries.end() - 1; it++) { fprintf(fp, "Num Inputs: %d\n", (*it)->num_inputs); for (std::vector::iterator it2 = (*it)->entries.begin() - + 1; + + 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/power_calibrate.cpp b/vpr/src/power/power_calibrate.cpp index cde61d07bdc..29766a37e4a 100644 --- a/vpr/src/power/power_calibrate.cpp +++ b/vpr/src/power/power_calibrate.cpp @@ -314,7 +314,7 @@ 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 transistor_size) { t_power_usage power_usage; VTR_ASSERT(num_inputs == 1); diff --git a/vpr/src/power/power_calibrate.h b/vpr/src/power/power_calibrate.h index 63d6f9dcbeb..2ae271a5a87 100644 --- a/vpr/src/power/power_calibrate.h +++ b/vpr/src/power/power_calibrate.h @@ -39,7 +39,7 @@ void power_print_spice_comparison(); 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 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); diff --git a/vpr/src/power/power_components.cpp b/vpr/src/power/power_components.cpp index 5ee7d1c22f6..bb1e581ab7e 100644 --- a/vpr/src/power/power_components.cpp +++ b/vpr/src/power/power_components.cpp @@ -566,7 +566,7 @@ void power_usage_mux_multilevel(t_power_usage* power_usage, 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); + mux_arch->transistor_size); power_scale_usage(power_usage, scale_factor); } }