ANSYS HPC performance depends on the interaction between simulation software and the systems running it. Processor cores matter, but so do memory capacity, local storage, network interconnects and the way each solver scales across nodes. Benchmark findings for CFX, Fluent and Mechanical illustrate why compute clusters for digital manufacturing should be designed around actual CAE workloads rather than a single generic configuration.
A building-block approach offers one way to do that. Infrastructure, compute, storage and networking can be combined to suit a deploymentâs workload and operational needs, with room to expand as requirements change. The practical lesson is that CFD and finite element analysis (FEA) can place quite different demands on the same HPC environment.
ANSYS HPC performance starts with workload-aware design
In the tested architecture, infrastructure servers handled system administration and user access, while compute building blocks supplied the resources for simulations. A master node was required to deploy and manage the cluster; login nodes were optional. For larger environments, a separate high-speed, low-latency fabric was recommended alongside the administration network.
Storage decisions also depend on how a simulation uses data. Scratch storage holds temporary working data, while operational storage retains project files and results for ongoing access. Archival storage is intended for longer-term preservation. For many CAE simulations, direct-attached storage on compute nodes can offer a suitable balance of cost and performance. Workloads that require shared access or exceed local capacity may call for a shared file system instead.
This distinction is especially relevant for Mechanical workloads. Implicit FEA can place substantial demands on memory and disk I/O when a problem does not fit in system RAM. By contrast, the CFX and Fluent solver workloads described in the benchmark analysis generally had modest memory requirements and limited solver-stage disk activity, although large transient simulations can have higher I/O demands.
CFD benchmarks: CFX and Fluent scaling
CFX and Fluent are computational fluid dynamics (CFD) applications, and the evaluated cases generally made effective use of additional processor cores and servers. In the CFX tests, measured solver elapsed time was used to compare standard benchmark cases. The results showed an advantage for the tested second-generation Intel Xeon Scalable processor systems over the prior generations included in the comparison. Higher-core-count processors also benefited the CFX benchmarks.
When CFX was run across as many as eight compute nodes, the tested models showed good overall parallel scalability. The largest model demonstrated super-linear scaling, attributed in the analysis to a cache effect: as more nodes were used, a greater portion of the problem dataset could fit in cache. This result is specific to the tested model and configuration, not a guarantee that every simulation will scale the same way.
Fluent was evaluated using 15 benchmark problems, with performance expressed as a solver rating: the number of 25-iteration solves that could be completed in a day. Most tested cases scaled well across nodes, and many could use the higher-core-count processors. One small case, ice_2m, scaled less effectively. Its limited scaling was consistent with the modelâs small size and its dynamic mesh and combustion characteristics.
For engineers sizing CFD resources, these results point to two useful checks: whether the target models can exploit more cores, and whether the expected workload is large enough to benefit from distributing work across multiple nodes.
ANSYS Mechanical performance requires closer tuning
Mechanical performance was less uniform because FEA scaling depends on problem type, solution method and model size. The tests used the Distributed Memory Parallel (DMP) solver, which generally offered equivalent or better performance than Shared Memory Parallel (SMP), particularly when using all cores on a processor. The reported Core Solver Rating focused on solver performance, excluding pre- and post-processing.
For the standard benchmark cases, single-node DMP scaling was reasonable up to 32 cores. Moving beyond 32 cores per server delivered only small additional performance increases for most cases. Across multiple nodes, some benchmarks scaled to eight nodes, but parallel scaling above four nodes was limited overall. Larger models could scale more effectively, reinforcing the need to evaluate representative production jobs rather than assume that adding nodes will deliver proportional gains.
Memory and storage should be planned alongside compute. Example configurations in the analysis paired a 384 GB compute node with local SSD storage for general use and described a 768 GB configuration for relatively large simulations. These are example configurations, not universal sizing rules: the appropriate choice depends on whether a workload fits in memory and its local I/O requirements.
GPU acceleration is solver-dependent
Tests of Mechanical with NVIDIA Tesla V100 GPUs produced mixed results. Some solution types benefited, while others performed worse or could not use GPUs. Results also varied when comparing GPU and CPU combinations under the same base software license. The practical implication is to verify GPU support and benchmark the specific analysis types in use before making GPU acceleration part of a system design.
Basic building blocks for incremental HPC
A four-socket server-based Basic Building Block (BBB) was presented as an option for smaller deployments seeking to reduce cluster management complexity. Individual servers could be used alone, connected as a two-node couplet, or incorporated into a larger cluster. This provides a path to add compute capacity incrementally while retaining the option to expand the system.
Across the tested BBB configurations, Linux generally delivered better overall performance than Windows. Results varied by application: Fluent and CFX showed strong performance potential, while Mechanicalâs standard benchmarks had more modest parallel scaling. Windows-based systems still offered additional CAE capacity compared with the workstation baseline used in the analysis, but the measured results were generally below the Linux configurations.
Practical implications for CAE teams
The benchmark findings support a workload-first approach to HPC planning:
- For CFD: assess whether representative CFX or Fluent cases benefit from higher core counts and multi-node execution.
- For Mechanical: prioritize memory and local I/O needs, and validate scaling for the specific solver and model sizes.
- For GPUs: confirm that the target analysis supports acceleration and test the expected workload.
- For storage and networking: distinguish temporary scratch needs from shared operational data, and select a fabric appropriate to cluster size and communication needs.
- For growth: consider building blocks that can be added or connected as simulation demand increases.
There is no single configuration that optimizes every ANSYS workload. CFX and Fluent can scale well across cores and nodes in the tested cases, while Mechanical performance is more sensitive to problem characteristics, memory and I/O. For industrial automation and manufacturing engineering teams, the most useful next step is to map representative simulations to system resources and validate the design with relevant workloads. That approach helps align compute investment with engineering requirements while leaving room for the HPC environment to grow.
Access Official Technical PDF