From 80eb0fca3e5e326912cadc943fb46f1c8c667032 Mon Sep 17 00:00:00 2001 From: Ashton Snelgrove Date: Tue, 19 Apr 2022 12:41:09 -0600 Subject: [PATCH] Properly setup ABC enable flag in optimization algorithms --- core/algorithms/optimization/resynthesis.cpp | 295 +++++++++++++++---- core/algorithms/optimization/resynthesis.hpp | 13 +- core/commands/optimization/optimize.hpp | 19 +- 3 files changed, 263 insertions(+), 64 deletions(-) diff --git a/core/algorithms/optimization/resynthesis.cpp b/core/algorithms/optimization/resynthesis.cpp index 8cff58db0..47f1cbd2c 100644 --- a/core/algorithms/optimization/resynthesis.cpp +++ b/core/algorithms/optimization/resynthesis.cpp @@ -24,11 +24,12 @@ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ -#ifdef ENABLE_OPENSTA -#ifdef ENABLE_ABC #include #include +#include "algorithms/output/verilog_utilities.hpp" + +#ifdef ENABLE_STA #include #include #include @@ -42,15 +43,13 @@ #include #include -#include "algorithms/output/verilog_utilities.hpp" - namespace sta { extern const char *tcl_inits[]; } extern "C" { extern int Sta_Init(Tcl_Interp *interp); } - +#endif #include #include @@ -68,6 +67,7 @@ extern int Sta_Init(Tcl_Interp *interp); #include "algorithms/optimization/xag_script.hpp" #include "algorithms/optimization/xmg_script.hpp" #include "algorithms/partitioning/slack_view.hpp" +#include "algorithms/partitioning/partition_manager_junior.hpp" #include "utility.hpp" // TODO replace "pi/po" with "ci/co" namespace oracle @@ -79,6 +79,7 @@ using xmg_names = mockturtle::names_view; using xmg_manager = partition_manager_junior; using xmg_partition = mockturtle::window_view>; +#ifdef ENABLE_ABC template std::string basic_techmap(const std::string &tech_script, const std::string &abc_exec, const T &optimal, const std::string &temp_prefix) { @@ -131,6 +132,7 @@ template std::string basic_techmap(const std::string &, const std::st template std::string basic_techmap(const std::string &, const std::string &, const xag_names &, const std::string &); template std::string basic_techmap(const std::string &, const std::string &, const mig_names &, const std::string &); template std::string basic_techmap(const std::string &, const std::string &, const xmg_names &, const std::string &); +#endif template std::string get_po_name_or_default(const network &ntk, const typename network::signal &signal) { @@ -240,17 +242,18 @@ mockturtle::window_view> fix_names2(partition_ma return part; } -template -class noop: public optimizer +template class noop: public optimizer { using names = mockturtle::names_view; using partition = mockturtle::window_view; // using manager = partition_manager_junior; public: - noop(int index, const partition &part, optimization_strategy target, const std::string &abc_exec): index(index), original(part), strategy(target), abc_exec(abc_exec) - { - } +#ifdef ENABLE_ABC + noop(int index, const partition &part, optimization_strategy target, const std::string &abc_exec): index(index), original(part), strategy(target), abc_exec(abc_exec) {} +#else + noop(int index, const partition &part, optimization_strategy target): index(index), original(part), strategy(target) {} +#endif const std::string optimizer_name() { @@ -260,7 +263,11 @@ class noop: public optimizer optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new noop(index, part, this->strategy, this->abc_exec); +#else + return new noop(index, part, this->strategy); +#endif } @@ -300,7 +307,7 @@ class noop: public optimizer void optimize() { } - +#ifdef ENABLE_ABC std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) { if (techmapped.empty()) { @@ -311,6 +318,7 @@ class noop: public optimizer } return techmapped; } +#endif node_depth independent_metric() { @@ -327,7 +335,9 @@ class noop: public optimizer node_depth metric; optimization_strategy strategy; std::string techmapped; +#ifdef ENABLE_ABC const std::string &abc_exec; +#endif }; template class noop; template class noop; @@ -342,9 +352,11 @@ class mig_optimizer: public optimizer using manager = mockturtle::window_view; public: - mig_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) - { - } +#ifdef ENABLE_ABC + mig_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) {} +#else + mig_optimizer(int index, const partition &original, optimization_strategy target): index(index), original(original), strategy(target) {} +#endif xmg_names export_superset() { @@ -378,6 +390,7 @@ class mig_optimizer: public optimizer return metric; } +#ifdef ENABLE_ABC std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) { if (techmapped.empty()) { @@ -388,6 +401,7 @@ class mig_optimizer: public optimizer } return techmapped; } +#endif optimization_strategy target() { @@ -402,7 +416,9 @@ class mig_optimizer: public optimizer string techmapped; string name; optimization_strategy strategy; +#ifdef ENABLE_ABC const std::string &abc_exec; +#endif }; template class mig_optimizer; @@ -411,9 +427,11 @@ class aig_optimizer: public optimizer { using partition = mockturtle::window_view>; public: - aig_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) - { - } +#ifdef ENABLE_ABC + aig_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) {} +#else + aig_optimizer(int index, const partition &original, optimization_strategy target): index(index), original(original), strategy(target) {} +#endif xmg_names export_superset() { @@ -442,6 +460,7 @@ class aig_optimizer: public optimizer return metric; } +#ifdef ENABLE_ABC std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) { if (techmapped.empty()) { @@ -454,6 +473,7 @@ class aig_optimizer: public optimizer } return techmapped; } +#endif optimization_strategy target() { @@ -467,12 +487,15 @@ class aig_optimizer: public optimizer node_depth metric; string techmapped; optimization_strategy strategy; +#ifdef ENABLE_ABC const std::string &abc_exec; +#endif }; template class aig_optimizer; -template< typename network> +#ifdef ENABLE_ABC +template class abc_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; @@ -521,15 +544,18 @@ class abc_optimizer: public aig_optimizer this->optimal.set_network_name(this->converted.get_network_name()); } }; +#endif template class xag_optimizer: public optimizer { using partition = mockturtle::window_view>; public: - xag_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) - { - } +#ifdef ENABLE_ABC + xag_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) {} +#else + xag_optimizer(int index, const partition &original, optimization_strategy target): index(index), original(original), strategy(target) {} +#endif xmg_names export_superset() { @@ -537,9 +563,13 @@ class xag_optimizer: public optimizer return mockturtle::node_resynthesis(optimal, resyn); } - optimizer *reapply(int index, const xmg_partition &part) + optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new xag_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new xag_optimizer(index, part, this->strategy); +#endif } void convert() @@ -563,6 +593,7 @@ class xag_optimizer: public optimizer return metric; } +#ifdef ENABLE_ABC std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) { if (techmapped.empty()) { @@ -575,6 +606,7 @@ class xag_optimizer: public optimizer } return techmapped; } +#endif const std::string optimizer_name() { @@ -600,7 +632,9 @@ class xag_optimizer: public optimizer node_depth metric; string techmapped; optimization_strategy strategy; +#ifdef ENABLE_ABC const std::string &abc_exec; +#endif }; template class xag_optimizer; @@ -609,13 +643,19 @@ class xmg_optimizer: public optimizer { using partition = mockturtle::window_view>; public: - xmg_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) - { - } +#ifdef ENABLE_ABC + xmg_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): index(index), original(original), strategy(target), abc_exec(abc_exec) {} +#else + xmg_optimizer(int index, const partition &original, optimization_strategy target): index(index), original(original), strategy(target) {} +#endif - optimizer *reapply(int index, const xmg_partition &part) + optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new xmg_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new xmg_optimizer(index, part, this->strategy); +#endif } xmg_names export_superset() @@ -645,6 +685,7 @@ class xmg_optimizer: public optimizer return metric; } +#ifdef ENABLE_ABC std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) { if (techmapped.empty()) { @@ -656,6 +697,7 @@ class xmg_optimizer: public optimizer } return techmapped; } +#endif const std::string optimizer_name() { @@ -681,7 +723,9 @@ class xmg_optimizer: public optimizer node_depth metric; string techmapped; optimization_strategy strategy; +#ifdef ENABLE_ABC const std::string &abc_exec; +#endif }; template class xmg_optimizer; @@ -690,7 +734,12 @@ class migscript_optimizer: public mig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC migscript_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): mig_optimizer(index, original, target, abc_exec) {} +#else + migscript_optimizer(int index, const partition &original, optimization_strategy target): mig_optimizer(index, original, target) {} +#endif + const std::string optimizer_name() { @@ -699,7 +748,11 @@ class migscript_optimizer: public mig_optimizer optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new migscript_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new migscript_optimizer(index, part, this->strategy); +#endif } void optimize() @@ -714,7 +767,12 @@ class migscript2_optimizer: public mig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC migscript2_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): mig_optimizer(index, original, target, abc_exec) {} +#else + migscript2_optimizer(int index, const partition &original, optimization_strategy target): mig_optimizer(index, original, target) {} +#endif + const std::string optimizer_name() { @@ -723,7 +781,11 @@ class migscript2_optimizer: public mig_optimizer optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new migscript2_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new migscript2_optimizer(index, part, this->strategy); +#endif } void optimize() @@ -738,11 +800,19 @@ class migscript3_optimizer: public mig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC migscript3_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): mig_optimizer(index, original, target, abc_exec) {} +#else + migscript3_optimizer(int index, const partition &original, optimization_strategy target): mig_optimizer(index, original, target) {} +#endif optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new migscript3_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new migscript3_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -762,11 +832,20 @@ class aigscript_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC aigscript_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): aig_optimizer(index, original, target, abc_exec) {} +#else + aigscript_optimizer(int index, const partition &original, optimization_strategy target): aig_optimizer(index, original, target) {} +#endif + optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new aigscript_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new aigscript_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -786,11 +865,20 @@ class aigscript2_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC aigscript2_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): aig_optimizer(index, original, target, abc_exec) {} +#else + aigscript2_optimizer(int index, const partition &original, optimization_strategy target): aig_optimizer(index, original, target) {} +#endif + optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new aigscript2_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new aigscript2_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -810,11 +898,19 @@ class aigscript3_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC aigscript3_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): aig_optimizer(index, original, target, abc_exec) {} +#else + aigscript3_optimizer(int index, const partition &original, optimization_strategy target): aig_optimizer(index, original, target) {} +#endif optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new aigscript3_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new aigscript3_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -834,11 +930,19 @@ class aigscript4_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC aigscript4_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): aig_optimizer(index, original, target, abc_exec) {} +#else + aigscript4_optimizer(int index, const partition &original, optimization_strategy target): aig_optimizer(index, original, target) {} +#endif optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new aigscript4_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new aigscript4_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -858,11 +962,19 @@ class aigscript5_optimizer: public aig_optimizer { using partition = mockturtle::window_view>; public: +#ifdef ENABLE_ABC aigscript5_optimizer(int index, const partition &original, optimization_strategy target, const std::string &abc_exec): aig_optimizer(index, original, target, abc_exec) {} +#else + aigscript5_optimizer(int index, const partition &original, optimization_strategy target): aig_optimizer(index, original, target) {} +#endif optimizer *reapply(int index, const xmg_partition &part) { +#ifdef ENABLE_ABC return new aigscript5_optimizer(index, part, this->strategy, this->abc_exec); +#else + return new aigscript5_optimizer(index, part, this->strategy); +#endif } const std::string optimizer_name() @@ -917,29 +1029,30 @@ class d_strategy : public optimization_strategy_comparator } }; - template - class n_strategy : public optimization_strategy_comparator - { - bool operator()(optimizer &a, optimizer &b) - { - node_depth x = a.independent_metric(); - node_depth y = b.independent_metric(); - +template +class n_strategy : public optimization_strategy_comparator +{ + bool operator()(optimizer &a, optimizer &b) + { + node_depth x = a.independent_metric(); + node_depth y = b.independent_metric(); return x.nodes < y.nodes; - } - const string name() - { - return "node"; - } + } + const string name() + { + return "node"; + } }; template optimizer *optimize(optimization_strategy_comparator &comparator, optimization_strategy strategy, partition_manager_junior &partman, - int index, - const std::string &abc_exec) - + int index +#ifdef ENABLE_ABC + , const std::string &abc_exec +#endif +) { std::cout << "******************************** optimizing partition " << index << " ********************************" << std::endl; std::cout << "Optimizing based on strategy " << comparator.name() << std::endl; @@ -951,6 +1064,7 @@ optimizer *optimize(optimization_strategy_comparator &comparat // todo remove double network. // fix_names(partman, part, partman.get_network(), index); const mockturtle::window_view> part = fix_names2(partman, index); +#ifdef ENABLE_ABC std::vector*>optimizers { new noop(index, part, strategy, abc_exec), new migscript_optimizer(index, part, strategy, abc_exec), @@ -965,6 +1079,21 @@ optimizer *optimize(optimization_strategy_comparator &comparat new xag_optimizer(index, part, strategy, abc_exec), // new abc_optimizer(index, part, strategy, abc_exec), }; +#else + std::vector*>optimizers { + new noop(index, part, strategy), + new migscript_optimizer(index, part, strategy), + new migscript2_optimizer(index, part, strategy), + new migscript3_optimizer(index, part, strategy), + new aigscript_optimizer(index, part, strategy), + new aigscript2_optimizer(index, part, strategy), + new aigscript3_optimizer(index, part, strategy), + new aigscript4_optimizer(index, part, strategy), + new aigscript5_optimizer(index, part, strategy), + new xmg_optimizer(index, part, strategy), + new xag_optimizer(index, part, strategy), + }; +#endif optimizer *best = nullptr; for (auto opt = optimizers.begin(); opt != optimizers.end(); opt++) { std::cout << "running optimization " << (*opt)->optimizer_name() << std::endl; @@ -1042,6 +1171,7 @@ std::set get_wire_names(oracle::partition_manager_junior & return wires; } +#ifdef ENABLE_STA template void write_child(int index, partition_manager_junior &partman, @@ -1066,7 +1196,9 @@ void write_child(int index, verilog.seekp(verilog.tellp() - 2L); // Truncate last comma verilog << "\n);\n" << std::endl; } +#endif +#ifdef ENABLE_ABC template string techmap( oracle::partition_manager_junior partitions, @@ -1119,7 +1251,9 @@ string techmap( return output_file; } +#endif +#ifdef ENABLE_STA void print_path(sta::ConcreteInstance *i) { if (sta::ConcreteInstance *p = i->parent()) { @@ -1369,6 +1503,7 @@ void reset_sta() Tcl_Eval(tcl_interp, "sta::define_sta_cmds"); Tcl_Eval(tcl_interp, "namespace import sta::*"); } +#endif template @@ -1436,6 +1571,8 @@ xmg_names setup_output( return partitions_out.get_network(); } +#ifdef ENABLE_ABC +#ifdef ENABLE_STA /* * Mixed synthesis followed by XMG resynthesis and combination. */ @@ -1500,19 +1637,30 @@ template xmg_names optimize_timing( // Output network return setup_output(partitions, optimized); } - +#endif +#endif /* Mixed synthesis followed by XMG resynthesis and combiniation */ -template xmg_names optimize_resynthesis( - oracle::partition_manager_junior &partitions, const string &abc_exec) +template +#ifdef ENABLE_ABC +xmg_names optimize_resynthesis(oracle::partition_manager_junior &partitions, const string &abc_exec) +#else +xmg_names optimize_resynthesis(oracle::partition_manager_junior &partitions) +#endif { int num_parts = partitions.count(); std::vector*> optimized(num_parts); for (int i = 0; i < num_parts; i++) { n_strategy strategy; + +#ifdef ENABLE_ABC optimized[i] = optimize(strategy, optimization_strategy::size, partitions, i, abc_exec); +#else + optimized[i] = optimize(strategy, optimization_strategy::size, partitions, i); +#endif + } assert(num_parts == optimized.size()); @@ -1534,10 +1682,22 @@ template xmg_names optimize_resynthesis( } if (optimized[worst_part]->target() == optimization_strategy::size) { ndp_strategy strategy; + +#ifdef ENABLE_ABC optimized[worst_part] = optimize(strategy, optimization_strategy::balanced, partitions, worst_part, abc_exec); +#else + optimized[worst_part] = optimize(strategy, optimization_strategy::balanced, partitions, worst_part); +#endif + } else if (optimized[worst_part]->target() == optimization_strategy::balanced) { d_strategy strategy; + +#ifdef ENABLE_ABC optimized[worst_part] = optimize(strategy, optimization_strategy::depth, partitions, worst_part, abc_exec); +#else + optimized[worst_part] = optimize(strategy, optimization_strategy::depth, partitions, worst_part); +#endif + } else if (optimized[worst_part]->target() == optimization_strategy::depth) { std::cout << "previous result was already the best we can do." << std::endl; break; // met timing, or it's the best we can do. @@ -1554,10 +1714,13 @@ template xmg_names optimize_resynthesis( * Mixed synthesis optimization followed by XMG resynthesis and combination. */ template -xmg_names optimize_basic ( - oracle::partition_manager_junior &partitions, - const string &abc_exec, - optimization_strategy strategy) +#ifdef ENABLE_ABC +xmg_names optimize_basic (oracle::partition_manager_junior &partitions, + const string &abc_exec, optimization_strategy strategy) +#else +xmg_names optimize_basic (oracle::partition_manager_junior &partitions, + optimization_strategy strategy) +#endif { int num_parts = partitions.count(); std::vector*> optimized(num_parts); @@ -1575,7 +1738,11 @@ xmg_names optimize_basic ( } std::cout << std::endl; for (int i = 0; i < num_parts; i++) { - optimized[i] = optimize(*target, strategy, partitions, i, abc_exec); +#ifdef ENABLE_ABC + optimized[i] = optimize(*target, strategy, partitions, i, abc_exec); +#else + optimized[i] = optimize(*target, strategy, partitions, i); +#endif } delete target; assert(num_parts == optimized.size()); @@ -1584,12 +1751,7 @@ xmg_names optimize_basic ( } /**************** Template instances ****************/ -template xmg_names -optimize_timing -( - oracle::partition_manager_junior &, - const std::string &, const std::string &, const std::string &, const std::string &, const std::string &, const std::string &, const std::string &); - +#ifdef ENABLE_ABC template xmg_names optimize_basic ( @@ -1604,5 +1766,26 @@ optimize_resynthesis const std::string &); } +#else +template xmg_names +optimize_basic +( + oracle::partition_manager_junior &, const optimization_strategy); + +template xmg_names +optimize_resynthesis +( + oracle::partition_manager_junior &); + +} +#endif + +#ifdef ENABLE_STA +#ifdef ENABLE_ABC +template xmg_names +optimize_timing +( + oracle::partition_manager_junior &, + const std::string &, const std::string &, const std::string &, const std::string &, const std::string &, const std::string &, const std::string &); #endif #endif diff --git a/core/algorithms/optimization/resynthesis.hpp b/core/algorithms/optimization/resynthesis.hpp index 290e23194..bb346991e 100644 --- a/core/algorithms/optimization/resynthesis.hpp +++ b/core/algorithms/optimization/resynthesis.hpp @@ -26,7 +26,6 @@ */ #pragma once -#ifdef ENABLE_ABC #include #include "algorithms/partitioning/partition_manager_junior.hpp" #include "utility.hpp" @@ -48,12 +47,18 @@ enum optimization_strategy { size, balanced, depth }; template mockturtle::names_view optimize_basic( oracle::partition_manager_junior &partitions, +#ifdef ENABLE_ABC const std::string &abc_exec, +#endif const optimization_strategy strategy); template mockturtle::names_view optimize_resynthesis( - oracle::partition_manager_junior &partitions, const std::string &abc_exec); + oracle::partition_manager_junior &partitions +#ifdef ENABLE_ABC + , const std::string &abc_exec +#endif + ); struct node_depth { int nodes; @@ -85,10 +90,12 @@ class optimizer * List the type of optimization: area, delay, or balanced. */ virtual optimization_strategy target() = 0; +#ifdef ENABLE_ABC /** * Techmap, then return a path to a file containing the techmapped verilog. */ virtual std::string techmap(const std::string &liberty_file, const std::string &temp_prefix) = 0; +#endif /** * convert the network to the superset. */ @@ -99,5 +106,3 @@ class optimizer virtual optimizer *reapply(int index, const mockturtle::window_view> &part) = 0; }; } - -#endif diff --git a/core/commands/optimization/optimize.hpp b/core/commands/optimization/optimize.hpp index d877afdbe..a4813acb2 100644 --- a/core/commands/optimization/optimize.hpp +++ b/core/commands/optimization/optimize.hpp @@ -38,10 +38,12 @@ class optimize_command : public alice::command public: explicit optimize_command(const environment::ptr &env) - : command(env, "Perform timing driven mixed synthesis.") + : command(env, "Perform mixed synthesis.") { + #ifdef ENABLE_ABC opts.add_option("--abc_exec", abc_exec, "ABC executable, defaults to using path."); + #endif opts.add_flag("--ndp", "Node Depth Product target"); opts.add_flag("--nodes", "Node Count target"); opts.add_flag("--depth", "Depth target"); @@ -73,7 +75,11 @@ class optimize_command : public alice::command auto start = std::chrono::high_resolution_clock::now(); mockturtle::names_view ntk_result; if (is_set("resynth")) { - ntk_result = oracle::optimize_resynthesis(partitions_jr, abc_exec); + ntk_result = oracle::optimize_resynthesis(partitions_jr +#ifdef ENABLE_ABC + , abc_exec +#endif + ); } else { oracle::optimization_strategy strategy; if (is_set("depth")) { @@ -84,7 +90,11 @@ class optimize_command : public alice::command strategy = oracle::optimization_strategy::balanced; } - ntk_result = oracle::optimize_basic(partitions_jr, abc_exec, strategy); + ntk_result = oracle::optimize_basic(partitions_jr, +#ifdef ENABLE_ABC + abc_exec, +#endif + strategy); } auto stop = std::chrono::high_resolution_clock::now(); @@ -107,8 +117,9 @@ class optimize_command : public alice::command store>>().extend() = std::make_shared>(ntk_result); } - +#ifdef ENABLE_ABC string abc_exec{"abc"}; +#endif }; ALICE_ADD_COMMAND(optimize, "Optimization"); }