operation count optimization

In logic synthesis, restructuring operations incur high computational overhead; conventional iterative cut enumeration fails in up to 98% of cases, leading to extensive redundant resynthesis. To address this, we propose a machine learning–based pruning optimization: a classifier is introduced to predict and preemptively prune cuts with high failure probability, significantly reducing unnecessary computation. Our method tightly integrates the classifier into the standard logic synthesis flow without modifying the underlying synthesis engine. Experiments on the EPFL benchmarks and ten large industrial circuits demonstrate an average speedup of 3.9× over the latest ABC implementation. The core innovation lies in shifting failure prediction from a posteriori evaluation to a proactive pruning mechanism—breaking the traditional optimization paradigm while preserving both efficiency and toolchain compatibility.

Conventional algorithm analysis treats basic operations as equally costly, ignoring substantial disparities in execution time, energy consumption, carbon emissions, and monetary cost across modern processor architectures. Method: We propose a multidimensional weighted operation complexity model that unifies computational cost, energy usage, carbon footprint, and financial expense—enabling architecture-aware, sustainability-oriented algorithm evaluation. Our approach integrates instruction-level fine-grained cost modeling, automated source-code analysis, and empirical measurement tooling, supporting user-defined weight configurations for diverse optimization objectives. Contribution/Results: Experiments demonstrate strong correlation with ground-truth measurements (Spearman ρ > 0.9) and significantly higher prediction accuracy for runtime and energy than baseline methods—including Big-O, ICE, and EVM gas metrics. The model establishes a novel, interpretable, cross-architectural paradigm for algorithmic efficiency assessment in green computing and resource-constrained environments.

This work addresses key challenges in Profile-Guided Optimization (PGO): high sampling overhead, poor adaptability to dynamic inputs, and weak cross-architecture portability. We systematically survey and restructure the PGO technical landscape, proposing the first multi-dimensional classification framework for PGO—explicitly identifying three core research directions: low-overhead profiling, dynamic workload adaptation, and cross-architecture profile migration. Our approach unifies instrumentation- and sampling-based analysis, enabling compiler- and linker-time collaborative optimization in GCC and LLVM across heterogeneous targets including x86 and ARM. Empirical evaluation on standard benchmarks demonstrates an average performance improvement of 12.3%, while reducing profiling overhead to under 0.8%. These results significantly enhance the industrial deployability and generalization capability of PGO.

Repetitive computation in change-sensitive programs—such as database queries, compilers, and real-time analytics—incurs substantial overhead and undermines complexity control. Method: We propose the “incrementalization” paradigm, formalizing incremental computation as a discrete analogue of differentiation and establishing its theoretical foundation in discrete computation. Our approach introduces an “iterate–incrementalize–implement” design framework, featuring a novel meta-level abstraction-driven model for algorithmic complexity refinement, integrating higher-order abstractions over data, control flow, and modules with formal incrementalization transformations. Contribution/Results: We deliver a reusable, formally verifiable incrementalization methodology that guarantees correctness while significantly improving computational efficiency and enhancing controllability of algorithmic complexity. The framework enables systematic, principled application of incremental computation across diverse domains, bridging theory and practice in program optimization and reactive systems.

Symbolic execution provides formal verification guarantees but suffers from path explosion and high SMT-solving complexity, limiting scalability to real-world software. To address this, we propose the first divide-and-conquer symbolic execution framework based on program slicing: the program is decomposed into independent slices, each executed symbolically in isolation; memory and control-flow side effects are then modeled and incrementally merged, thereby avoiding global path explosion. Our core contributions are (1) a composable side-effect merging mechanism and (2) a constraint decomposition strategy—enabling, for the first time, incremental and formally verifiable modular symbolic execution. Experimental evaluation demonstrates that our approach achieves a 3.2× speedup in path exploration while reducing memory overhead by 57%, all while preserving formal correctness guarantees.

This work addresses the challenges in logic synthesis posed by the vast and opaque set of optimization operators, which leads to a complex search space and inefficient scheduling. For the first time, it introduces a large language model (LLM) agent that automatically infers theoretical relationships among operators from the source code semantics of ABC and mockturtle. These relationships are rigorously validated through adversarial auditing to define their applicability boundaries, enabling a deterministic gating mechanism that prunes redundant operators. The approach achieves operator compression grounded in formal relationships and exact Pareto coverage, surpassing conventional heuristic-based scheduling. Experiments demonstrate that the operator set is reduced from 40 to 31; TACO yields an 11% runtime reduction across 66 circuits with identical bit-level results; under fixed comparisons, node count and logic depth decrease by 1.0% and 3.2% on average, respectively, with a 2.6× speedup; and TACO-max attains a geometric mean NDP of 0.903 on the HeLO benchmark.

Traditional least fixed-point semantics often fails to support precise static cost analysis due to its neglect of recursive structural information. This work proposes operator semantics as an intermediate representation bridging syntax and denotational semantics, treating programs as operators and constructing a higher-order abstract domain grounded in category theory, with composition as the core primitive. This framework enables abstract compilation that simultaneously achieves soundness, precision, and modularity. The approach supports cost analysis for general functional unknowns and generalized fold-based metrics, leveraging a solver-agnostic technique for extracting optimal recurrence relations. Consequently, it facilitates precise static cost analysis of recursive programs over algebraic data types, encompassing generalized size metrics beyond the reach of conventional methods.

本文针对编译器优化启发式算法导致的性能差和编译时间不可预测问题，提出验证编译阶段的性能与编译时间属性的方法，并以内联扩展为例进行了证明。

This work addresses the limitations of existing code optimization techniques, which struggle to effectively handle dynamic languages and are often confined to single-level transformations, thereby failing to precisely identify performance bottlenecks. To overcome these challenges, we propose Optimo—a multi-level, pattern-aware code optimization framework powered by a Mixture-of-Prompts (MoP) architecture that, for the first time, integrates the mixture-of-experts paradigm into code optimization. Optimo employs differential profiling to pinpoint critical code structures and performs coordinated optimizations across four abstraction levels—from algorithms down to APIs. Experimental results demonstrate that Optimo achieves up to a 57.48% optimization success rate with a 3.97× speedup on human-written code, and a 42.42% success rate with a 13.51× speedup on LLM-generated code, significantly outperforming current baselines on the COFFE and Effibench benchmarks.

Existing approaches to program resource analysis struggle to simultaneously achieve the completeness of static analysis and the worst-case coverage afforded by dynamic analysis. To address this limitation, this work proposes a hybrid analysis method that integrates dynamic symbolic execution with mixed-integer linear programming to systematically enumerate execution paths within a bounded input space and derive empirically sound upper bounds on maximum resource consumption. This approach represents the first deep integration of dynamic symbolic execution and linear programming for inferring tight and effective worst-case resource bounds for functional programs. The prototype tool CompAS demonstrates both practical utility and theoretical guarantees in estimating resource usage on complex programs.