SimOps 101: CAE License Management: Why Licenses, Not Hardware, Are the Bottleneck
In our Top CAE Software Compared guide, one finding kept coming back: how a tool is licensed often matters as much as what it costs. This article picks up that thread.
Picture a common Monday morning in a simulation team. The cluster has plenty of free nodes. Three CFD jobs sit in the queue. Two engineers are waiting for results before a design review. Nothing is broken, and no hardware is missing. The jobs are waiting for license tokens that are checked out by a GUI session someone left open on Friday, and by a parametric study that holds more cores than it needs.
Hardware is bought once, while commercial solver licenses are usually leased every year and counted per core, per session, or per token. In many organizations, the license server, not the cluster, decides how fast simulations run.
This guide explains how CAE license management works: how the major vendors approach simulation software licensing, where license capacity is wasted, how to make a scheduler license-aware, and what to measure before the next renewal.

Why Licenses Became the Bottleneck
Two trends pulled licensing to the center of HPC operations.
First, core counts per node grew much faster than license budgets. A single modern dual-socket server can hold several hundred cores. Buying the hardware is a capital decision made every few years. Enabling all of those cores for a commercial solver is an operating cost paid every year, and for many tools it grows with every core a job uses.
Second, simulation workloads became more parallel and more numerous. Design studies, optimization loops, and training data for AI surrogate models all mean many runs instead of one. Each run needs a license, so the license pool is shared by more jobs than ever.
As we discussed in SimOps vs. DevOps vs. MLOps, this is one of the constraints that makes simulation operations different from software operations. A software build does not wait for a license token. A simulation often does.
How CAE Licenses Are Counted
Every vendor counts differently, and the counting rule shapes how jobs should be sized. The examples below cover the most common models. Terms are negotiated per customer and change over time, so treat them as a starting point and confirm current terms with each vendor.
Ansys: Solver Licenses Plus HPC Packs
Most Ansys solver licenses include four cores for parallel processing. The exact allowance depends on the application and license configuration. Additional cores are enabled with HPC licenses. The most common form is the HPC Pack: according to Ansys, packs enable 8 × 4^(packs − 1) cores for a single simulation, so each additional pack multiplies the pack cores by four [1][2][3]:
HPC Packs | HPC Pack cores | Included solver cores | Total cores per job |
0 | 0 | 4 | 4 |
1 | 8 | 4 | 12 |
2 | 32 | 4 | 36 |
3 | 128 | 4 | 132 |
4 | 512 | 4 | 516 |
5 | 2,048 | 4 | 2,052 |
The cores enabled by a set of packs cannot be split across multiple runs [3]. Ansys also offers HPC Workgroup (pool) licensing, where individual HPC licenses are counted per core and can be shared across jobs, and Elastic Licensing, a pay-per-use model based on prepaid Ansys Elastic Units, aimed at peak demand and occasional users [3][5].
GPUs are counted too, and the rules vary by product. Exxact's 2025 guide describes how Ansys counts a GPU's streaming multiprocessors (SMs) against HPC Pack cores, so a large GPU can require several packs [2]. With 2025 R1, Ansys also introduced CFD HPC Ultimate, which lets one enterprise-level CFD job run on multiple CPU cores or GPUs without additional HPC licenses [4]. If you are planning a GPU purchase, as covered in our GPU vs. CPU guide, check the licensing impact before the hardware order.
Abaqus: Tokens That Grow Slower Than Cores
Abaqus uses a token pool. For Abaqus/Standard, Abaqus/Explicit, and Abaqus/CFD, the number of tokens a job needs is calculated as int(5 × N^0.422), where N is the number of cores, with a minimum of five tokens per job [6][7][8]. Other Abaqus products use different base values, for example 3 for Abaqus/Foundation and 6 for Abaqus/Aqua and Abaqus/Design [6]. For Standard, Explicit, and CFD:
Cores | Tokens | Tokens per core |
1 | 5 | 5.0 |
4 | 8 | 2.0 |
8 | 12 | 1.5 |
16 | 16 | 1.0 |
32 | 21 | 0.66 |
64 | 28 | 0.44 |
Because tokens grow much more slowly than cores, large jobs use tokens more efficiently than small ones. Seven 8-core jobs need 84 tokens. One 56-core job needs 27. Token efficiency is only half of the picture: whether the large job also finishes sooner depends on its parallel efficiency, as discussed below. On the 3DEXPERIENCE platform, Abaqus can also consume credits per hour, and some teams combine tokens for the base load with credits for peaks [8].
Simcenter STAR-CCM+: Sessions Instead of Cores
Siemens offers Power licensing for Simcenter STAR-CCM+ in three forms [9][10]:
Power Session: one authorized user runs a single session on an unlimited number of cores, for a fixed annual price.
Power-on-Demand: metered usage of unlimited-core sessions, aimed at cloud, burst, and sporadic use.
Power Tokens: one token per additional core, added to a serial session.
With a Power Session, the cost of a job no longer depends on its core count. The constraint moves from cores to the number of concurrent sessions.
Other Models
Altair Units, now under Siemens, are a shared pool that can be spent across the former Altair portfolio. COMSOL uses a base package plus add-on modules, with a floating network license for cluster runs. MSC Nastran and Adams, now part of Cadence, have commonly used token-based licensing, with terms that vary by product and agreement. OpenFOAM has no license fee at all: the cost moves to building, validating, and supporting the software environment.
What the Counting Rules Mean for Job Sizing
The counting rule should decide how jobs are sized, and it often does not.
Match core counts to license steps. With two Ansys HPC Packs, a job can use 36 cores. On a cluster with 32-core nodes, that job either uses one node and leaves 4 licensed cores unused, or spans two nodes and leaves 28 physical cores idle. A 37-core job needs a third pack. Sizing jobs to the license steps, not to round numbers, avoids paying for capacity that cannot be used.
Weigh token efficiency against parallel efficiency. Abaqus tokens favor large jobs, but solver speedup does not grow in a straight line with cores. For many implicit models, doubling cores gives far less than double the speed. The right job size is the one that delivers the most results per token per day, and that has to be measured per model type, not assumed.
Use the free cores. Unlimited-core models such as Power Session change the logic completely. If the license does not count cores, the limit is the hardware, and the best job size is the one with the best parallel efficiency on the available nodes.
Separate interactive and batch use. Pre-processing and post-processing often check out the same licenses as the solver. A GUI session that sits idle for hours blocks a batch job that could have run.
How a License Server Works
Most commercial CAE tools use a network license server. FlexNet Publisher (formerly FLEXlm) from Revenera is the most widespread. A license manager daemon runs alongside a vendor daemon, and the solver checks out a "feature" when it starts and returns it when it finishes. Some vendors use their own license managers or alternatives.
Three parts of a FlexNet setup matter most for operations:
The status query. The lmstat utility shows which features are in use, by whom, and since when. It is the quickest way to see who holds a license right now.
The debug log. The vendor daemon log records every checkout, checkin, and denial. A denial is a job or user that asked for a license and did not get one. Over weeks, this log is the most accurate record of real demand.
The options file. Administrators can control usage per feature, user, or group. RESERVE sets licenses aside for a user or group, MAX caps how many a group can use, TIMEOUT returns an idle license to the pool after a set time, and TIMEOUTALL applies a timeout to all features [11].
TIMEOUT is often the quickest fix for idle interactive sessions, one of the most common sources of waste. Not every vendor daemon supports it for every feature, so check the vendor documentation.
Where License Capacity Is Wasted
The waste is rarely dramatic. It is a set of small losses that add up every day.
Idle checkouts. GUI sessions and stalled jobs hold licenses without computing.
Startup failures. A job that starts on reserved nodes, finds no license, and exits has wasted both the queue wait and the node allocation.
Stranded cores. Nodes allocated to a job that is waiting for a license, or cores that are licensed but not physically available to the job.
Step mismatch. Jobs sized just above an HPC Pack step or just below the efficient token range.
Over-reservation. Reservations made for one project that stay in the options file long after the project ends.
Buying for the peak. A pool sized for the busiest week of the year sits underused for the other fifty-one.
None of these show up in cluster utilization reports. The cluster looks busy or idle, while the actual limit is in the license pool.
Making the Scheduler License-Aware
A scheduler that knows about licenses keeps jobs pending until their licenses are free, instead of starting them and letting them fail. Below are two examples: Slurm and Gridware Cluster Scheduler.
Slurm
In Slurm, this works in two ways. The examples below follow the Slurm Licenses Guide for version 26.05 [12].
Local licenses are defined in slurm.conf and counted by the scheduler for that cluster:
Licenses=fluent:30,ansys:100Jobs request them at submission, and Slurm holds them in the queue if the count is not available:
sbatch -L ansys:2 script.shRemote licenses are stored in the Slurm database and can be shared across clusters. They are created with sacctmgr and requested with the name and server:
sacctmgr add resource name=nastran cluster=fluid,pdf count=100 allowed=50 server=flex_host servertype=flexlm type=license
sbatch -L nastran@flex_host script.shThe Slurm documentation states that if licenses are not available, jobs are kept pending until they become available [12]. It also states that remote licenses do not integrate with third-party license managers by themselves. The counts in Slurm and the real usage on the FlexNet server can drift apart, for example when an engineer checks out a license from a desktop outside the scheduler.
Since Slurm 23.02, a remote license has a LastConsumed field that can be updated periodically with the real usage from the license server. The Slurm guide shows a script that reads the in-use count from lmstat and writes it back with sacctmgr, run on a schedule [12]. This closes most of the gap between what the scheduler thinks is free and what the license server actually has.
Gridware Cluster Scheduler
Gridware Cluster Scheduler treats CAE licenses as first-class scheduling resources. Each license feature is modeled as a consumable counter that jobs request at submission, and the scheduler guarantees that features are never oversubscribed, so a solver job only starts when its licenses are actually available rather than failing minutes later at checkout.
For FlexLM/FlexNet-based products, which cover a large share of the CAE market, Gridware goes further with a deep integration that configures and monitors license features directly from the license server, so actual usage on the license server can be compared with what the cluster itself is consuming. Where a pool is shared, for example with interactive workstation users or a second cluster, administrators can set aside a defined number of licenses for that external use, so the cluster never plans with licenses that are committed elsewhere.
On the scheduling side, licenses can be released from running jobs once they are no longer needed, for example after the solver phase, which returns expensive features to the pool sooner. The accounting and reporting tool can also feed the customer's own external SQL database, recording the license features each job requested along with its owner, group, project, and department.
Other schedulers, such as PBS Professional, offer similar license-tracking features. The principle is the same: the scheduler should never start a job that cannot get its licenses.
Measure Before You Renew
License renewals are often negotiated on last year's count plus a margin. A few months of data gives a much stronger position. The most useful measures are:
Peak and average concurrent use per feature, by hour and by day of the week.
Denials: how often a request failed, and for which feature.
License wait time per job: how long jobs stayed pending for licenses, not for nodes.
Idle checkout time: licenses checked out by sessions that used no CPU.
Cost per simulation: license, compute, and storage cost attributed to each workload.
The clearest picture comes from combining two data sources: license server logs and scheduler accounting. Together they show which jobs waited for which licenses, which licenses were held by idle sessions, and which cores sat idle because a license was missing.
This data also informs the license mix. Annual licenses can be more cost-effective for predictable, steady demand. Pay-per-use options such as Ansys Elastic Units, Abaqus credits, or STAR-CCM+ Power-on-Demand may offer more flexibility for occasional users and temporary peaks. The right split depends on usage patterns, pricing terms, and workload requirements. Without measurement, it is a guess.
Licensing in the Cloud
Moving simulation to the cloud does not remove licensing; it adds new questions. The Cloud HPC vs. On-Premise decision often depends on them.
Bring your own license (BYOL) means cloud jobs check out licenses from your own license server. The server must be reachable from the cloud, usually over a VPN, and network latency or outages can stop jobs.
On-demand licenses are billed by usage, often per hour, through the vendor or a cloud platform. They avoid new annual commitments but need cost controls, because an unlimited-core job on an hourly license can become expensive quickly.
Mixed setups keep the baseline on premises and burst to the cloud with metered licenses. They work best when placement rules include licensing, not only hardware price.
How SimOps Frames CAE License Management
CAE license management is not only a procurement task. It connects engineering workloads, HPC scheduling, infrastructure use, and software cost, and it works best when these are managed together. That is why it appears directly in the 20 SimOps Best Practices [13]:
Best Practice 17, Optimize License & Hardware Utilization, calls for token servers, license queuing, and hardware reservation policies, and recommends correlating license checkout logs with job telemetry to find idle tokens or stranded cores.
Best Practice 8, Track, Forecast, and Optimize Simulation Cost, recommends tagging every workload, comparing CPU and GPU economics, and negotiating elastic license models.
Best Practice 5, Adopt a Hybrid-Cloud HPC Strategy, recommends placement policies that account for cost, latency, data gravity, and tool licensing.
Best Practice 16, Monitor User Experience in Real Time, includes queue wait times, where license waits usually first become visible to engineers.
In practice, HPC license management sits between groups. Engineering uses the licenses, IT or the HPC team runs the license server, procurement negotiates with vendors, and finance pays the renewal. A SimOps Center of Excellence (Best Practice 6) is a natural owner, because it already holds vendor relations and standards. The SimOps Fundamentals certification covers these operational skills for simulation engineers and HPC practitioners.
A Practical Checklist
List every licensed feature, its count, its counting rule, and its renewal date.
Turn on vendor daemon debug logging and keep the logs for at least a full quarter.
Configure license tracking in the scheduler, and sync it with the license server.
Set idle timeouts for interactive features where the vendor supports them.
Publish recommended job sizes per solver that match license steps and parallel efficiency.
Review reservations and group limits in the options file every quarter.
Report license wait time and denials next to cluster utilization.
Bring utilization data, not last year's count, to the next renewal.
Key Takeaways
Licenses, not hardware, often limit simulation throughput, because core counts grew faster than license budgets.
Each vendor counts differently: Ansys HPC Packs multiply cores by four per pack, Abaqus/Standard tokens grow with int(5 × N^0.422), and STAR-CCM+ Power Sessions remove the core limit per session.
Job sizes should follow the counting rule and measured parallel efficiency, not round numbers.
A license-aware scheduler keeps jobs pending instead of failing, and syncing it with the license server keeps its counts accurate.
Idle checkouts, startup failures, and buying for the peak are the most common sources of waste.
License server logs joined with scheduler data are the strongest input to any renewal negotiation.
Frequently Asked Questions
What is CAE license management?
CAE license management is the practice of planning, monitoring, and controlling the software licenses that simulation tools need to run. It covers license servers, scheduler integration, usage monitoring, job sizing, and renewal planning.
How many cores does an Ansys HPC Pack enable?
With most Ansys solvers, one HPC Pack enables 12 cores per job, counting the four cores in the solver license. Each additional pack multiplies the pack cores by four: 36 cores with two packs, 132 with three, 516 with four, and 2,052 with five.
How are Abaqus license tokens calculated?
For Abaqus/Standard, Explicit, and CFD, the tokens for a job are int(5 × N^0.422), where N is the number of cores, with a minimum of five tokens. An 8-core job needs 12 tokens, a 16-core job needs 16, and a 32-core job needs 21. Other Abaqus products, such as Foundation, Aqua, and Design, use different base values.
What is a FlexNet license server?
FlexNet Publisher, formerly FLEXlm, is the license management system used by many commercial CAE tools. Solvers check out licenses from it when they start and return them when they finish. Its logs and options file are the main tools for monitoring and controlling usage.
How do I make Slurm aware of software licenses?
Define licenses in slurm.conf for a single cluster, or create remote licenses with sacctmgr for several clusters, and request them with sbatch -L. Since Slurm 23.02, a script can update remote license usage from the license server so the scheduler's counts stay accurate.
Are cloud licenses cheaper than on-premises licenses?
Not by default. Pay-per-use licenses can be more cost-effective for peaks and occasional use, and annual licenses for steady baseline use, but this depends on pricing terms and usage patterns. Usage data shows where the line sits for your organization.
What's Next in This Series?
This is part of SimOps' Simulation 101 series. Related reading:
References
Ansys. (2023, January 25). How Many Cores Are Supported with a Single or Multiple Ansys HPC Pack? Ansys Knowledge. innovationspace.ansys.com
Exxact Corporation. (2025, August 1). Ansys HPC Pack: Ansys Licensing for CPUs and GPUs Explained in 2025. exxactcorp.com
Moody, A. (2024, February 16). Looking Under the Hood of Ansys HPC Licensing. PADT. padtinc.com
Ansys. (2025, February 4). Ansys 2025 R1 Delivers Data-Driven Insights with Powerful Digital Engineering Technology. ansys.com
Petrone, G. (2019, October 3). What Is Elastic Licensing and Why It's a Hot Topic for Engineers. Ansys. ansys.com
University of Birmingham. Abaqus. BEAR Technical Docs. docs.bear.bham.ac.uk
Ohio Supercomputer Center. Abaqus. osc.edu
Obbink-Huizer, C. Abaqus Hardware and Licensing Options. TECHNIA. blog.technia.com
Siemens. Simcenter STAR-CCM+ Supports Simulation with Flexible, Cost-Effective Licensing Solutions. resources.sw.siemens.com
Femto Engineering. (2019, October 30). Simcenter STAR-CCM+ Licensing Options. femto.eu
Revenera. FlexNet Publisher 2026 R1 License Administration Guide: Options File Syntax. docs.revenera.com
SchedMD. Slurm Licenses Guide (version 26.05). slurm.schedmd.com
SimOps. SimOps Best Practices. simops.com
About SimOps
Software development was transformed when teams stopped treating infrastructure as an afterthought and started building shared practices around it. That's what DevOps did for code. SimOps is doing the same thing for simulation.
Simulation and HPC have long operated in silos: different tools, different teams, different workflows, with no shared language or common standards. SimOps exists to change that. We're building a framework and a community where simulation engineers, HPC specialists, and CAE teams can work from the same playbook, share best practices, and push the field forward together.
If that mission resonates with you, this series is a starting point. And our community is where the conversation continues.


