SAP VC LO-VC AVC Performance CUTRC ST13 VARCONF BOM

SAP VC Dependency Performance: What ST13 VARCONF Measures

LO-VC AVC PJ / 2026-10-29

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

ColumnMeaning
Numberthe order the dependency was processed
Line SE30line in the runtime analysis
Line Dep.line inside the dependency
Levelthe configuration level
Gross [micro s]elapsed time for that processing, in microseconds
Dependencythe dependency name
TypeProcedure 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.

  1. Sum Gross by Dependency. This is where the time goes.
  2. 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:

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


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:

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.

  1. Write down test configurations with expected results. Twenty usually catches a broken dependency.
  2. Record total gross time and the top three dependencies per configuration before the change.
  3. Make one change.
  4. 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

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.

Trace Before You Rewrite

Most slow configurations come from a few model patterns, not from the engine. The SAP VC for Beginner book covers the dependency processing model that explains why.

Get the Book — $9.99