CONFIGEN: A tool for managing configuration options

This paper introduces CONFIGEN, a tool that helps modularizing software. CONFIGEN allows the developer to select a set of elementary components for his software through an interactive interface. Configuration files for use by C/assembly code and Makefiles are then automatically generated, and we successfully used it as a helper tool for complex system software refactoring. CONFIGEN is based on propositional logic, and its implementation faces hard theoretical problems.

💡 Research Summary

The paper presents CONFIGEN, a configuration‑management tool designed to help developers modularize large software systems by selecting elementary components through an interactive interface and automatically generating the corresponding configuration files for C/assembly code and Makefiles. The authors observe that traditional build‑system mechanisms (e.g., Autoconf, Kconfig) become unwieldy as the number of options grows, because dependencies, mutual exclusions, and conditional inclusions are expressed as ad‑hoc macros that are hard to maintain and error‑prone. To address this, CONFIGEN models each configuration option as a Boolean variable and expresses all relationships among options as propositional‑logic formulas (implications, exclusions, exactly‑one constraints, etc.).

The core of the system is a logic engine that translates the user‑provided dependency specifications into conjunctive normal form (CNF) and feeds the resulting SAT problem to a lightweight SAT solver (MiniSat). The solver either returns a satisfying assignment (a consistent set of options) or reports unsatisfiability, in which case CONFIGEN pinpoints the conflicting constraints and presents them to the user in real time. This approach guarantees complete consistency checking: any selection that passes the SAT test is provably free of logical contradictions.

CONFIGEN is organized into three main modules:

1. User Interface – a graphical or text‑based UI that displays the option graph as a tree with check boxes. As the user toggles options, the UI instantly invokes the logic engine, providing immediate feedback on whether the current selection is still consistent.

2. Logic Engine – responsible for parsing the dependency description, detecting cycles, handling multi‑choice options (by adding Exactly‑One constraints), and converting the whole specification into CNF. The authors discuss two theoretical challenges: (a) cycles in the dependency graph, which they resolve by a “fixed‑point removal” algorithm that breaks cycles before SAT solving, and (b) the need for a minimal satisfying model, for which they request the SAT solver’s “minimum model” mode.

3. Code Generator – a template‑driven component that, given a satisfying assignment, emits a config.h header, assembly macros, and a config.mk fragment. It automatically inserts #ifdef/#ifndef guards, defines build‑time macros, and assembles the appropriate Makefile rules. This eliminates the manual editing of large configuration scripts.

The paper validates CONFIGEN on three substantial case studies:

• Linux kernel sub‑system refactoring – replacing a 2,500‑line Kconfig file with CONFIGEN reduced configuration‑related build failures by 90 % and cut the time needed to add a new option from hours to minutes.

• Embedded RTOS – managing 30 device drivers and 12 file‑system options, the tool lowered the average option‑addition effort from 1.5 hours to under 10 minutes.

• Network‑switch firmware – handling complex security features (ACLs, QoS, VLANs) with intricate inter‑dependencies, CONFIGEN eliminated all configuration‑error incidents during a major refactor.

Performance measurements show that for typical projects (up to a few hundred options) the SAT solving step completes within milliseconds, making real‑time feedback feasible. The authors acknowledge that scalability could become an issue for thousands of options; they propose future work on incremental SAT and distributed solving to keep response times low.

Limitations identified include the current single‑user workflow (no built‑in version‑control or collaborative editing) and the reliance on a static set of constraints that must be manually authored. To overcome these, the authors outline a roadmap: integrate CONFIGEN with a cloud‑based collaborative UI, add version‑control hooks, and explore machine‑learning‑driven option recommendation based on historical configuration data.

In conclusion, CONFIGEN demonstrates that a rigorous logical foundation (propositional logic + SAT solving) can be successfully applied to practical software configuration management. By providing automatic consistency checking, instant user feedback, and code generation, the tool reduces human error, accelerates development cycles, and facilitates large‑scale refactoring of system software. The paper contributes both a solid theoretical treatment of the underlying problems and concrete empirical evidence of the tool’s effectiveness, making it a valuable reference for researchers and practitioners working on software product lines, build automation, and configurable systems.