mirrors/yosys
3
0
Fork 0
mirror of https://github.com/YosysHQ/yosys synced 2026-07-04 22:46:10 +00:00
Code Activity

Fix OptCleanPass usage of CleanRunContext to avoid constructing extra KeepCache and ParallelDispatchThreadPool

Browse source
This commit is contained in:
Robert O'Callahan 2026-03-05 02:20:58 +00:00
parent 32f5044eaf
commit 8d8c05b338
2 changed files with 18 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

25
passes/opt/opt_clean/opt_clean.cc
View file

@ -40,6 +40,7 @@ void rmunused_module(RTLIL::Module *module, bool rminit, CleanRunContext &clean_
if (rminit && rmunused_module_init(module, subpool, clean_ctx.flags.verbose)) if (rminit && rmunused_module_init(module, subpool, clean_ctx.flags.verbose))
while (rmunused_module_signals(module, subpool, clean_ctx)) { } while (rmunused_module_signals(module, subpool, clean_ctx)) { }
} }
struct OptCleanPass : public Pass { struct OptCleanPass : public Pass {
OptCleanPass() : Pass("opt_clean", "remove unused cells and wires") { } OptCleanPass() : Pass("opt_clean", "remove unused cells and wires") { }
void help() override void help() override
@ -76,18 +77,12 @@ struct OptCleanPass : public Pass {
} }
extra_args(args, argidx, design); extra_args(args, argidx, design);
std::vector<RTLIL::Module*> selected_modules;
for (auto module : design->selected_whole_modules_warn())
if (!module->has_processes_warn())
selected_modules.push_back(module);
int thread_pool_size = 0;
for (RTLIL::Module *m : selected_modules)
thread_pool_size = std::max(thread_pool_size, ThreadPool::work_pool_size(0, m->cells_size(), 1000));
ParallelDispatchThreadPool thread_pool(thread_pool_size);
KeepCache keep_cache(purge_mode, thread_pool, selected_modules);
{ {
CleanRunContext clean_ctx(design, {purge_mode, true}); std::vector<RTLIL::Module*> selected_modules;
for (auto module : design->selected_whole_modules_warn())
if (!module->has_processes_warn())
selected_modules.push_back(module);
CleanRunContext clean_ctx(design, selected_modules, {purge_mode, true});
for (auto module : selected_modules) for (auto module : selected_modules)
rmunused_module(module, true, clean_ctx); rmunused_module(module, true, clean_ctx);
clean_ctx.stats.log(); clean_ctx.stats.log();
@ -134,8 +129,12 @@ struct CleanPass : public Pass {
extra_args(args, argidx, design); extra_args(args, argidx, design);
{ {
CleanRunContext clean_ctx(design, {purge_mode, ys_debug()}); std::vector<RTLIL::Module*> selected_modules;
for (auto module : clean_ctx.selected_modules) for (auto module : design->selected_unboxed_whole_modules())
if (!module->has_processes())
selected_modules.push_back(module);
CleanRunContext clean_ctx(design, selected_modules, {purge_mode, ys_debug()});
for (auto module : selected_modules)
rmunused_module(module, true, clean_ctx); rmunused_module(module, true, clean_ctx);
log_suppressed(); log_suppressed();

23
passes/opt/opt_clean/opt_clean.h
View file

@ -55,33 +55,22 @@ struct CleanRunContext {
NewCellTypes ct_all; NewCellTypes ct_all;
RmStats stats; RmStats stats;
ParallelDispatchThreadPool thread_pool; ParallelDispatchThreadPool thread_pool;
std::vector<RTLIL::Module*> selected_modules;
KeepCache keep_cache; KeepCache keep_cache;
Flags flags; Flags flags;
private: private:
// Helper to compute thread pool size // Helper to compute thread pool size
static int compute_thread_pool_size(RTLIL::Design* design) { static int compute_thread_pool_size(const std::vector<RTLIL::Module*>& selected_modules) {
int thread_pool_size = 0; int thread_pool_size = 0;
for (auto module : design->selected_unboxed_whole_modules()) for (auto module : selected_modules)
if (!module->has_processes()) thread_pool_size = std::max(thread_pool_size,
thread_pool_size = std::max(thread_pool_size, ThreadPool::work_pool_size(0, module->cells_size(), 1000));
ThreadPool::work_pool_size(0, module->cells_size(), 1000));
return thread_pool_size; return thread_pool_size;
} }
static std::vector<RTLIL::Module*> get_selected_modules(RTLIL::Design* design) {
std::vector<RTLIL::Module*> modules;
for (auto module : design->selected_unboxed_whole_modules())
if (!module->has_processes())
modules.push_back(module);
return modules;
}
public: public:
CleanRunContext(RTLIL::Design* design, Flags f) CleanRunContext(RTLIL::Design* design, const std::vector<RTLIL::Module*>& selected_modules, Flags f)
: thread_pool(compute_thread_pool_size(design)), : thread_pool(compute_thread_pool_size(selected_modules)),
selected_modules(get_selected_modules(design)),
keep_cache(f.purge, thread_pool, selected_modules), keep_cache(f.purge, thread_pool, selected_modules),
flags(f) flags(f)
{ {