Extend your configurator solutions to very large models
Configit Modular Extension is an extension module to Configit Product Modeler that allows you to exploit modularity in product models. It includes a new Modular Compiler and corresponding Modular Runtime.
With Configit Modular Extension, very large product models can efficiently be compiled and configured. Even models that otherwise would not be compilable or would require converting rules into functions in order to reduce the need for making deductions.
This page gives you an overview of the following aspects of the Configit Modular Extension:
How it automatically detects structure to improve performance
Benefits of the Configit Modular Extension
How the Configit Modular Extension works
Automatically detects structure to improve performance
Configit Modular Extension automatically detects the inherent modular structure in a product model using it to improve performance of the constraint solver in the configurator.
Based on the modularity identified, a set of separate Virtual Tables are generated by the Configit Modular Compiler. These tables are then combined at runtime by Configit Modular Runtime to obtain the well-known benefits arising from complete and full deduction in the configurator.
Configit Modular Extension contains the following components:
- Configit Modular Compiler
- Configit Modular Runtime
The module follows the general release plan for Configit Product Modeler.
Benefits of the Configit Modular Extension:
- The module is fully integrated into Configit Product Modeler
- Easy adaptation into the existing product modeling workflow
Automatic modularity detection.
- Automatically detects modularity based on the rules defined in the product model
- No manual effort is required to use the Configit Modular Compiler
Improved performance and larger models
- The sizes of the generated modular Virtual Tables are typically much smaller than with the non-modular compiler
- Gives largely improved performance at runtime
- Extends the range of models that can be immediately compiled
Variable orders are less important
- Small modular Virtual Tables are typically generated directly from the default ordering
Modularity beyond what is defined
- The detected modularity is typically much more detailed than the modeled group structure in the product model
- Allows for improvements beyond the defined modular structures.
Consistent runtime API.
- The Configit Modular Runtime has the same API as the standard runtime
- Includes all the core functions needed for determining valid domains, making user assignments, resolving conflicts, and supporting user interface contracts
Note that a few functions that depend on having the full model compiled into one Virtual Table and are not available in the Modular Runtime.
How the Configit Modular Compiler works
The Configit Modular Compiler is invoked either from within Configit Product Modeler or as a command line tool. The Modular Compiler initially analyzes the product model in order to detect modularity.
The analysis first identifies cyclic dependencies among rules. It then decomposes the product model into a tree of modules each containing a subset of the rules. The modules in the tree fulfill certain conditions with respect to their dependencies to other modules so that in effect the dependencies now form a tree, i.e., a graph with no cycles. This operation is called tree decomposition.
In general, for systems that have a star-like structure with one or more central groups having dependencies to a large collection of otherwise mostly independent groups, there is a lot of modularity to be detected and utilized. The two figures below show an example.
- Figure 1 shows the dependency structure of a product model. Each circle is a constraint in the model and each edge shows sharing of one or more variables. The graph reveals that there are many cyclic dependencies between the constraints.
- Figure 2 illustrates that after the modular compiler has decomposed the product model, the structures has no cycles and the constraints are organized into modules, that are compiled separately and then combined at runtime.