The engine room of allocation
Five rule sets. Eighteen rules. One precise execution order. Dimensions gave the model its axes. Models gave it a context. Rule sets give it its logic — the step-by-step instructions that move NovaPrism's $134M from Enterprise Support into every corner of the three operating divisions.
What a rule set is — and why the sequence matters
A rule set is a named, ordered container of rules. The container has an execution mode (Serial or Parallel) and a sequence number. The sequence number is not cosmetic — it is the execution order contract.
In EPCM, a rule set is the fundamental unit of allocation logic. Each rule set contains one or more rules — specific instructions that move money between PCM_Balance members across dimension intersections. When a model runs, it executes all assigned rule sets in ascending sequence order, respecting the execution mode of each.
The reason NovaPrism cannot collapse its five rule sets into one is dependency. The IT Allocation (seq:40) depends on the IT Cost Pool Formation (seq:10) having already staged the pool total into an intermediate member. If they ran in a single rule set without sequence enforcement, seq:40 might read a zero or stale IT pool value — producing a wrong allocation silently. The sequence number is the mechanism that prevents this.
Serial vs Parallel execution — when order matters
Serial execution runs rules one at a time, in rule order within the set. Parallel execution runs all rules simultaneously. The choice is not a performance preference — it is determined by whether later rules in the set depend on earlier ones having written their values first.
The three rule types
Every rule in EPCM is one of three types. The type determines how the rule calculates its output — not what it allocates, but the mathematical method it uses.
IT_Pool_Staged member, ready for the Allocation rule in seq:40 to read. Not an Allocation rule — it sets up the source.NovaPrism's 5 rule sets — full technical specification
Each rule set below is exactly as defined in constants.js. Click any rule set to expand its full rule list, execution notes, and the specific PCM_Balance members it reads from and writes to.
Execution sequence diagram
How the five rule sets flow in time. Serial rule sets must complete before dependent serial rule sets begin. Parallel rule sets run concurrently with no dependencies between their rules.
Seq:10 and seq:40 are Serial — seq:40 cannot start until seq:10 has committed the IT pool total. Seq:20 and seq:30 run in Parallel immediately after seq:10 — they share no data with each other. Seq:50 runs Parallel after all other pools have completed, ensuring fully-loaded costs are available at the Entity level before being pushed to engagement codes.
Calculation threads and the calcThreads setting
Parallel rule sets only deliver their performance benefit if EPCM has enough threads available to run them simultaneously. NovaPrism's application is configured for 5 calculation threads — a deliberate design decision.
The calcThreads property (set to 5 in NovaPrism's application, per constants.js) tells EPCM how many rules it can execute concurrently at any moment during a model run. For NovaPrism's parallel rule sets, this means seq:20 and seq:30 can each run their 3 and 4 rules respectively — all simultaneously, up to the thread limit — while the platform queues any excess.
In practice: seq:20 has 3 parallel rules (one per division), and seq:30 has 4 parallel rules (Finance × 3 divisions + HR weighted). With 5 threads, 5 of these 7 rules start immediately; the remaining 2 start as threads free. The net effect is that seq:20+seq:30 together complete in approximately the time of the 2 slowest rules, not the sum of all 7.
| calcThreads setting | Effect on NovaPrism's parallel rule sets | Risk |
|---|---|---|
| 1 (minimum) | All rules run sequentially regardless of rule set type — parallel sets lose their performance advantage entirely | Slowest |
| 3 | Most parallel rules in seq:20+seq:30 queue; 2 divisions always wait. Seq:50's 6 engagement rules run 3 at a time | Suboptimal |
| 5 (NovaPrism default) | Seq:20+seq:30 complete in ≈2× single-rule time. Seq:50's 6 rules complete in 2 batches. Good throughput vs resource balance | Balanced |
| 10+ | Minimal further gain for NovaPrism's 18-rule model — most threads idle. Could compete with other EPM processes on shared infrastructure | Diminishing returns |
NP.app.calcThreads in constants.js. The default if not set is typically 1 — meaning parallel rule sets would run sequentially unless you explicitly configure threads.Rule Set Execution Simulator
Step through NovaPrism's M01 model execution one rule set at a time. Watch the $134M allocate in sequence — see which steps depend on which, and what happens at each stage.
Simulation ready. Press Step Forward to begin.
Build NovaPrism's rule set configuration
The Models Pavilion has the four models approved and configured. Now you must design the rule sets that those models will execute. Nothing runs until the rule sets are defined.
IT_Pool_Staged at PCM_Input. Seq:40's Allocation rule then reads IT_Pool_Staged at PCM_Input as its source. If seq:10 hasn't run, IT_Pool_Staged is zero — and seq:40 allocates nothing, silently.What Hall of Logic covers on the exam
Hall 4 maps to the fourth syllabus topic: Managing Rule Sets and Rules. This is the highest-weighted topic on the exam — expect 8–10 questions across the 50-question paper.
Sub-bullet 2: Describe rules. Know all three rule types (Allocation, Custom Calculation, Offset). Know which PCM_Balance members each type reads from and writes to.
Sub-bullet 3: Manage rule sets and rules. Know how to add, sequence, and configure rules in the EPCM UI. Know the calcThreads application setting and its effect on parallel execution. Know what happens when a Serial rule set has a dependency on a prior Serial rule set.
Sub-bullet 4: Calculate models. Know the phases of model calculation (Clear → execute rule sets in sequence → balance check). Know that Logical Clear is the default.
FALSE when calcThreads = 1 (rules queue anyway). Only faster when threads are available AND rules have no intra-set dependencies.
Trap 2: "In a Parallel rule set, later rules can read values written by earlier rules."
FALSE. Parallel rules run simultaneously — no rule can read another's freshly written value. Use Serial when intra-set read/write dependencies exist.
Trap 3: "An Allocation rule can be used to form a cost pool from GL account members."
FALSE. Pool formation from multiple GL accounts requires a Custom Calculation rule. An Allocation rule requires a pre-existing source pool total. Use Custom Calc for aggregation; use Allocation for distributing the aggregated total.
Trap 4: "calcThreads is set per rule set, not per application."
FALSE. calcThreads is an application-level property. It applies to all models and all rule sets in the application. You cannot set different thread counts per rule set.
| Concept | Exam answer | Implementation reality |
|---|---|---|
| Serial vs Parallel rule sets | Serial = sequential execution (later rules see earlier writes). Parallel = simultaneous (no intra-set read dependencies allowed) | Most real models mix both — pool formation serial, allocation parallel, pool-of-pools serial again |
| Three rule types | Allocation (driver-based distribution), Custom Calculation (Essbase calc script), Offset (zero-out balancing entry) | Allocation rules do the heavy lifting. Custom Calc handles aggregation, staging, and complex logic. Offset is the final audit step |
| calcThreads | Application-level property. Controls max concurrent rule execution. Default = 1 if not set | Most production EPCM implementations use 5–8 threads. More threads = more database server resource consumption |
| Sequence number gaps | Not required by the product — but best practice to leave gaps (10, 20, 30...) for future insertions | Every serious implementation uses gaps. It saves a painful renumbering exercise when business logic changes require a new intermediate step |
| Dependency enforcement | Enforced by sequence number — EPCM runs rulesets in ascending sequence order, never out of order | No additional configuration needed — the sequence number IS the dependency contract. seq:40 simply has a higher number than seq:10 |
EPM Automate:
epmautomate calculateModel "NovaPrism_EPCM_PROD" "M01" — runs all 5 rule sets in ascending sequence order from a scheduled shell script. Git-managed, DevOps-friendly, no browser required.Groovy: A Calculation Manager business rule calls the EPCM REST API to trigger
calculateModel — the only way to include the model calculation inside a Pipeline job step (Pipeline cannot call native rule sets directly).Hybrid: Groovy validates pool totals before the run, calls
epmAutomate("calculateModel",...) inline, then writes a completion status flag back to the cube for Rule Balancing visibility.For the full debate — 8 rounds, side-by-side pipelines, and a 14-scenario decision matrix — see the EPM Automate vs Groovy reference page.