Configuration feels slow long before anyone measures it. A sales rep says the screen freezes. A BOM takes twenty seconds to explode.
The first instinct is to ask for a developer. That is usually unnecessary, and the instinct that costs more time is this one: find the dependency that runs most often and optimise it. Measured data says that is the wrong target.
This article covers what the trace records, how to rank dependencies by cost, and what one real production set looked like. The measurements come from 20 ST13 VARCONF exports, covering 11 configurations of one product family. They serve as a worked case, not a benchmark.
Four causes, four different fixes
Guessing picks the wrong one most of the time.
| Symptom | Likely cause | Who can see it |
|---|---|---|
| Slow on every value change, single level | Too many dependency rounds | Modeler |
| Slow only when the bill of materials (BOM) explodes | Cost multiplied across levels | Modeler |
| Slow after a lower-level item is configured | Values assigned upward, forcing parent re-derivation | Modeler |
| Slow only on save, or only in the sales order | Database round trips, not dependency logic | System support |
The first three rows are the common case and they do not need a developer.
The cost model
cost = (dependency rounds per change) x (cost per round) x (number of levels)
The middle term is set by the engine. The first and third terms are set by the model, and a trace shows both.
Loop weight matters, but it is not the whole story. A dependency that runs two thousand times at a tenth of a millisecond is noise. A dependency that runs sixty times at six hundred milliseconds is a quarter of the configuration. Ranking by call count finds the first one and hides the second.
Two levels, not five
VC performance work needs two kinds of access. Everything else is the same person with a different transaction open.
| Level | Who | Tools | What it answers |
|---|---|---|---|
| Modeler | the person who owns the model | CUTRC, CU50, PMEVC, and the ST13 VARCONF export |
Which dependency, which level, how often, and how long |
| System support | basis or a developer | ST05, SAT, SAAB with VC_DB_INTERFACE |
Where the time sits when it is not in the dependency logic |
The modeler level answers almost every question. Rounds, per-dependency cost, level, and call order all come from the same access a modeler already holds to run CU50 and PMEVC.
The system support level exists for one case: the export shows healthy per-call times and the screen is still slow. At that point the time is outside dependency evaluation, and only a database trace or an ABAP runtime split finds it.
Reproducing in the sales order is not a third level. A modeler or a sales colleague opens VA01, and that tells you whether the problem exists outside the simulator. It is a place to look, not an authorization.
Modeler: CUTRC, the trace in its own window
CU50 is the configuration simulator. CUTRC is the instrument that watches it. Run the trace in CUTRC, configure in CU50, and the trace records in a separate window.
/nCUTRC open the trace in an independent window
set trace level and areas, then activate
/nCU50 configure here, or switch to the sales order
the trace keeps recording while you work
CU50 also has an embedded trace under Extras, Trace, Activate. It works, but the window competes with your configuration session and it stops when you leave. CUTRC stays open across several CU50 or VA01 sessions, which is what you need when the problem only appears after a sequence of actions.
At this level record rounds per value change. One is healthy. Several means something is looping. Round count is cheap to read and it answers a different question from elapsed time.
The ST13 VARCONF export
Everything about ST13 sits in this section, because the rest of the article depends on what it produces.
ST13 is the analysis tool launcher. For variant configuration the tool name is VARCONF and it opens with project CUP.
/nST13
Tool name : VARCONF
Project : CUP
Group : select from the list
VARCONF analyses dependency knowledge, which is the subject of this article. It is the right instrument here, not an unrelated last resort. SAP Note 1121318 is titled Analysis of the performance of dependency knowledge in VC, and its documented path is ST13, then tool VARCONF, then project CUP.
The same path reports trace table consistency. SAP Note 1667903 covers the Trace table mismatch! message raised there. For a performance figure without the launcher, SAP Note 926714 documents report RCU_VC_PERFORMANCE.
The export needs ST13 authorization. A modeler asks for it once, or asks a colleague to produce the spreadsheet. The analysis itself needs nothing beyond a pivot table.
The eight columns
| Column | Meaning |
|---|---|
Number | the order the dependency was processed |
Line SE30 | line in the runtime analysis |
Line Dep. | line inside the dependency |
Level | the configuration level |
Gross [micro s] | elapsed time for that processing, in microseconds |
Dependency | the dependency name |
Type | Procedure executed, Procedure terminated, Use of constraint, Selection condition fulfilled or not |
Proc./Constr. | the procedure or constraint identifier |
Gross is the column that matters. It is elapsed time per processing event, in microseconds, so divide by a thousand for milliseconds.
This is a case study, not a benchmark
The numbers in the next four sections come from one set of exports: 20 files, 11 configurations of one product family, taken over eight days in late 2025.
Do not read them as typical values. A different product family, a different model, or a different release gives different numbers. The percentages will move. The most expensive dependency in your model will not be the one in this article.
What transfers is the method. Build these two pivots. Compare the same dependency across levels, then across configurations. Use the three signatures below to decide where the fix belongs. That method needs no benchmark and no baseline to be useful.
Read the figures that follow as an example of what the method exposes, not as a target to compare your system against.
Two pivots, and why they disagree
Export to a spreadsheet and build two pivot tables.
- Sum
GrossbyDependency. This is where the time goes. - Count rows by
Dependency. This is how often each one runs.
Then compare the two lists. They rarely match, and the mismatch is the finding.
Measured on a production set of 20 exports and 11 configurations, 38,152 records and 172.9 seconds of gross time:
| Measure | Result |
|---|---|
| Distinct dependencies | 560 |
| Dependencies averaging 100 to 1000 ms per call | 3 |
| Their share of all elapsed time | 37% |
| Dependencies averaging under 1 ms per call | 339 |
| Their share of all elapsed time | 2.9% |
| Most-called dependency | 1,938 calls, 0.09 ms each |
| Most expensive dependency | 60 calls, 639 ms each |
The most-called dependency and the most expensive dependency were different dependencies. The top fifteen by count and the top fifteen by cost shared exactly one entry.
In that set, 65% of all records cost 2.9% of the time. Three dependencies out of 560 cost 37%.
Rank by total gross time, and keep the per-call average in the next column. A high count with a low average is a rounding error. A low count with a high average is your project.
Three cost signatures, and they need different fixes
A single total per dependency hides the mechanism. Compare the same dependency across levels first, then across configurations. Three signatures appear, and each points somewhere else.
Signature 1: the level decides
One dependency, 15 configurations:
| Level | Cost per call, all 15 configurations |
|---|---|
| 2 | 476 to 511 ms |
| 4 | 11 to 13 ms |
| 6 | 10 to 12 ms |
A factor of 45 inside every configuration, and the configuration never mattered. The spread between the best and worst configuration at one level was a few percent.
A second dependency showed the same signature with a different shape: 776 to 1,522 ms at level 4, 15 to 25 ms at level 2, 10 to 14 ms at level 6. A factor of 119, and again every configuration behaved alike.
When the level sets the cost, the cost is structural. Something about that level determines the work: how many objects it covers, how they are grouped, what the dependency reads across them. Optimising "the dependency" without naming the level is not a plan.
Signature 2: the configuration decides
A third dependency, four calls per configuration, every call moving together:
| Configurations | Cost per call, every level |
|---|---|
| 10 of 15 | 9 to 18 ms |
| 2 | 446 to 480 ms |
| 2 | 1,215 to 1,228 ms |
Inside one configuration the ratio between the most and least expensive level was 1.0 to 1.9, so the level contributes nothing. Across configurations it was 70 times.
Two of those configurations held 2,769 and 2,681 records, and cost 18 ms and 1,217 ms on this dependency. Almost the same size, 67 times apart.
When the configuration sets the cost, the cost lives in the data values. The dependency takes an expensive path for certain values and a cheap path for others, and only the export shows that the path exists.
Signature 3: the cost does not follow volume
For the cheap invocations of the level-decided dependency, cost tracks the record count. For the expensive invocation it does not:
| Invocation | Cost | Correlation with record count |
|---|---|---|
| Level 4, cheap | 11 to 13 ms | +0.83 |
| Level 2, expensive | 476 to 511 ms | -0.22 |
The expensive call does not scale with the number of objects. It costs 476 ms in a configuration of 2,045 records and 511 ms in a configuration of 2,769 records, a spread of 2% across a 35% difference in volume.
That one comparison rules out whole categories of fix. If the cost does not follow volume, then reducing characteristics, splitting levels or adding hardware changes nothing. The cost is per invocation.
The diagnostic rule
| What moves | What it means | Where the fix is |
|---|---|---|
| Levels differ, configurations identical | Structural cost | The model at that level, or the build mode |
| Configurations differ, levels identical | Data cost | The characteristic value that opens the expensive path |
| Cost does not track record count | Per-invocation cost | Inside the dependency, not in the model shape |
Run the first two comparisons on the same dependency before touching anything. The answer costs one pivot table.
The practical follow-up
When signature 2 appears, two configurations of the same product family differ by a large factor on one dependency and are nearly identical in size. Compare their characteristic values field by field and the trigger is usually one characteristic with a different value.
That comparison is a conversation with sales or engineering, not a development ticket. It is also the cheapest performance project available, because the dependency does not change.
Level distribution: records mislead
The Level column gives the configuration level of each processing event.
| Level | Records | Share of records | Gross | Share of time |
|---|---|---|---|---|
| 2 | 833 | 2.2% | 27.657 s | 16.1% |
| 3 | 1,528 | 4.1% | 0.750 s | 0.4% |
| 4 | 8,375 | 22.3% | 89.049 s | 51.8% |
| 5 | 776 | 2.1% | 0.409 s | 0.2% |
| 6 | 25,269 | 67.2% | 53.498 s | 31.1% |
| 8 | 784 | 2.1% | 0.675 s | 0.4% |
Level 6 holds two thirds of the records and 31% of the time. Level 4 holds a fifth of the records and 52% of the time.
Counting records by level points at the wrong level. Optimising level 6 for volume puts the effort on the cheaper half. Sort the same data by gross and the target moves.
Procedures carry the cost, constraints do not
The Type column separates four event kinds. Aggregated:
| Kind | Records | Share of records | Gross | Share of time | Average per record |
|---|---|---|---|---|---|
| Procedure | 29,135 | 77.5% | 162.780 s | 94.6% | 5.59 ms |
| Use of constraint | 8,370 | 22.3% | 9.262 s | 5.4% | 1.11 ms |
This corrects a common assumption, including one an earlier draft of this article made.
Constraint re-evaluation inflates the round count. In AVC a constraint can be re-evaluated after each individual procedure assignment, not once at the end. A procedure with twelve assignments on a wide constraint net can trigger twelve constraint evaluations instead of one. That is documented and it is real.
But a constraint evaluation is cheap per call. It costs 1.11 ms against 5.59 ms for a procedure. Constraints raise the count. Procedures carry the time.
So use the two measures for two different jobs:
- Round count finds looping. Cheap to read, needs only CUTRC.
- Gross time finds cost. Needs the ST13 export.
Neither answers the other's question.
Source for the AVC re-evaluation behaviour: SAP S/4HANA 2025 FPS01, Advanced Variant Configuration, Processing Sequence, p.27.
Round count, and what drives it
In LO-VC, Actions run in multiple rounds until nothing new can be inferred. That loop is the classic source of a high round count. Actions are obsolete too, so they are also the easiest cause to remove.
Removing Actions is the easy case. The harder case is a model with no Actions that still runs many rounds. One round does not mean one pass over the model. Within a round the engine evaluates every dependency that applies to the current state. A wide constraint net alone raises the per-round cost, before any looping happens.
In AVC the shape changes. Procedures run exactly once, in order: profile procedures, then characteristic procedures, then characteristic value procedures. Constraints and preconditions on characteristic values run in parallel with that sequence.
BOM explosion: the multiplier
A multi-level BOM is not one configuration. Each configurable material in the structure is its own configuration instance with its own dependency processing.
That makes the level count a multiplier, not an addition. Three levels at one second each is three seconds before any interaction between levels.
The measured level table above confirms the shape while correcting the intuition about where it sits. Six levels of structure produced the time, and the largest single share came from level 4 rather than the deepest level.
Assigning from a lower level to a higher level
This pattern hurts because of what it forces.
A top-down assignment writes a parent value into a child. The parent is already configured when the child is created, so the value is available and the child processes once.
A bottom-up assignment runs the other way. A child-level dependency writes into the parent. The parent value cannot be final until its children are configured and evaluated. Every child that writes upward forces the parent dependency set to be re-processed with a new input.
Take N children under one parent. One bottom-up assignment can mean N parent re-evaluations. Each of those can cascade to the grandparent.
The engine difference matters here
In LO-VC, constraints cannot use $SELF, $PARENT, or $ROOT at all. Objects must be declared by class with IS_A, and the parent-child relationship is expressed through the structure function:
OBJECTS:
PARENT IS_A (300) PARENT_CLASS,
CHILD IS_A (300) CHILD_CLASS
CONDITION:
SUBPART_OF (CHILD, PARENT)
RESTRICTIONS:
PARENT.DESIGN_CODE = CHILD.DESIGN_CODE
That restriction line is a bottom-up assignment. The parent characteristic is derived from the child. It works, and it costs what it costs.
In AVC, the object-variable alias makes the same direction easy to write:
OBJECTS:
Z AS $PARENT
Easy to write is not cheap to run. The re-derivation cost belongs to the processing model, not to the syntax.
What to do instead
- Push values down, not up. If a parent needs information only a child knows, look for a way to make it a top-down input or a model-level characteristic rather than a derived parent value.
- Make the dependency conditional. A bottom-up assignment that runs only when a specific child is present costs far less than one that runs for every instantiation.
- Find it in the export. Filter the trace for the deeper level and look for a parent-level dependency appearing many times with a small per-call time. That signature is the cascade. The total is what matters, not the individual event.
Constraint assignments and defaults in the same model
SAP documents two classes of assignment, and the conflict rule between them is absolute.
| Class | Sources |
|---|---|
| Hard | User assignment, external assignment, constraint assignment, procedure assignment, reference characteristic |
| Soft | Customer material info records (CMIR), vendor material info records (VMIR), and defaults through ?= or $set_default |
Hard assignments override soft ones. Two conflicting hard assignments from different sources leave the configuration inconsistent.
Source: Authors and Their Rights, AVC PDF p.26. Hard valuation behavior, p.28.
Three consequences follow, and all three bite in real models.
A default never wins against a constraint. If a constraint assigns a value and a default offers another, the default is silently discarded. The model appears to respect the default in testing and ignores it in production, or the reverse, depending on whether that constraint fires in the current context.
A controlling constraint silently overrides documentation. If you wrote a default intending it to be the normal case and a constraint later takes that characteristic, the documented behaviour and the real behaviour diverge. Nobody notices until a customer picks the value and the system refuses.
Two hard sources on one characteristic is an inconsistency, not a preference. A constraint and a procedure both hard-assigning the same characteristic produces an inconsistent configuration. The engine keeps re-evaluating while trying to satisfy rules that cannot all hold, which is also why the model can be slow on its way to failing.
The rule
Use a default for a value the user can override. Use a constraint for a value that must hold. Never use both on one characteristic. Treat any model that does as a defect, whether or not it runs fast today.
System support: when the trace is not enough
Go to system support only when the export shows healthy per-call times and the screen is still slow. That means the time is not in dependency logic, and no amount of model cleanup will help.
Reproduce outside the simulator
Reproduce in VA01 or VA02. Two things you learn that CU50 cannot tell you:
- Whether the problem exists in the real document flow at all, or only in the simulator.
- The real elapsed time, including storage and retrieval.
If it is fast in CU50 and slow in the sales order, the problem is not the dependency model. Stop tuning dependencies.
Database and runtime tools
Three tools, in this order:
| Tool | Question it answers |
|---|---|
SAAB with checkpoint group VC_DB_INTERFACE |
Is the time in dependency evaluation or in configuration instance storage and retrieval |
| ST05 | Which database reads repeat, and whether the dependency tables CUOB, CUKN and CUKB are being re-read |
| SAT, the ABAP runtime analysis | Where inside the ABAP call the time sits |
SAAB with VC_DB_INTERFACE is the fastest way to separate a logic problem from a storage problem. See SAP Knowledge Base Article 3284731.
Ranked fixes, most leverage first
| Fix | Verify with | Effort | Typical effect |
|---|---|---|---|
| Compare the top three dependencies across levels, then across configurations | Pivot | Low | Separates structural cost from data cost, and picks the right fix |
| Convert bottom-up parent assignment to a top-down input | Pivot | Medium | Removes parent re-derivation per child |
| Remove Actions, replace with Procedures | CUTRC | Low | Collapses multi-round inference to one pass |
| Reduce assignments inside one Procedure (AVC) | PMEVC | Medium | Cuts constraint re-evaluations from one per assignment to one per group |
| Take defaults and constraint assignments off the same characteristic | CUTRC | Low | Removes silent override and inconsistent configurations |
| Split dependencies longer than roughly 2886 characters | CUTRC | Low | Fewer CUKN blocks per read, easier to maintain |
| Reduce the number of active characteristics | PMEVC | High | A redesign, not tuning |
The first row is the one the measured data supports most strongly, and it is also the cheapest.
Regression testing after a performance change
A faster model that configures differently is worse than a slow correct one.
- Write down test configurations with expected results. Twenty usually catches a broken dependency.
- Record total gross time and the top three dependencies per configuration before the change.
- Make one change.
- Re-run the same set. Compare results and numbers.
A drop in gross time with identical results is a clean win. A drop with changed results is a behaviour change wearing a performance costume.
Three things that rarely help
Optimising the most-called dependency. In the measured set the most-called dependency averaged 0.09 ms and accounted for 0.1% of total time. Effort spent there returns nothing.
Adding hardware. Dependency evaluation is CPU work on a mostly buffered model. A faster application server moves a two-second configuration to 1.8 seconds.
Converting LO-VC to AVC purely for speed. AVC multiplies constraint evaluation against procedure assignment. A wide constraint net re-evaluating after each assignment can be slower than the LO-VC model it replaced.
Summary
Sort by gross time, not by call count. In a production set of 560 dependencies, three of them carried 37% of the time and two thirds of all records carried 3%.
Procedures carry 95% of the elapsed time. Constraints raise the round count and cost little per call, so use round count to find looping and gross time to find cost.
The most actionable measurement is not any total. Compare the same dependency across levels, then across configurations. Levels differ and configurations agree means the cost is structural. Configurations differ and levels agree means the cost is in the data, and data is the cheapest thing to change. A cost that does not track record count means volume reasoning will mislead you, and no amount of model cleanup will help.
Sources
- Processing sequence, parallel constraint evaluation, assignment classes and conflict rules, hard valuation: SAP S/4HANA 2025 FPS01, Advanced Variant Configuration, SAP Help Portal, pp. 26 to 31.
- Constraint syntax, and the prohibition on
$SELF,$ROOT,$PARENTinside LO-VC constraints: SAP LO-VC 4.6C documentation, constraint syntax chapter. $SELF,$PARENT,$ROOTbehaviour by assignment location: LO-VC object dependency documentation.- Dependency storage in
CUKB,CUKN, andCUOB, and the 2886-character block size: standard SAP VC data model. - CUTRC as a standalone trace transaction, CU50 as the configuration simulator: standard SAP GUI VC tooling.
VC_DB_INTERFACEcheckpoint group: SAP Knowledge Base Article 3284731.- Tool
VARCONFwith projectCUPinside ST13, and its purpose: SAP Note 1121318, Analysis of the performance of dependency knowledge in VC. Trace table consistency: SAP Note 1667903. ReportRCU_VC_PERFORMANCE: SAP Note 926714.
The measured tables come from 20 ST13 VARCONF exports covering 11 configurations of one product family, taken over eight days in late 2025. No dependency name, material number or model identifier appears in this article. The correlations quoted are Pearson coefficients across 15 configurations. Where this article reasons from the documented processing model to a performance consequence, it says so.