Your cart 0 items
Your cart is empty.
Searching the site...
No matches. Try another word.
Servers & compute

Compute cluster

A room full of identical CPU nodes wired together with low-latency InfiniBand, one parallel filesystem, and a scheduler that keeps them busy. It runs the simulation and batch work that will not fit, or will not finish, on a single machine.

The problem

Waiting

A workstation runs one job at a time and a cloud VM charges by the hour whether the core is working or idle. When a fluid model, a crash simulation or a genomics pipeline outgrows a single box, the honest options run out fast. Engineers queue behind each other for the one fast machine, runs that should take an afternoon spill into the next week, and nobody can tell whether the bottleneck is the code, the memory or the network. Renting the same capacity by the hour looks flexible until the finance team sees a year of it. What most teams actually need is a fixed pool of cores they own, wired so a job can spread across many nodes at once, with a queue that shares them fairly. That is a cluster, not a bigger desktop.

Design targets
192 cores Per compute node, dual EPYC
400 Gb/s NDR InfiniBand per node
< 1.2 us MPI message latency, node to node
40 GB/s Parallel filesystem read, sustained
The system

Three layers, one machine.

Compute, fabric and storage. Each layer is sized against the others so no part sits idle waiting on another. Open a layer for what it does and how far it scales.

192 cores/node
Imagery in production

Compute nodes

Where the work runs

2x AMD EPYC 9654, 96 cores each 768 GB DDR5-4800, 12 channels/socket ~920 GB/s memory bandwidth per node
192 cores/node
Imagery in production

Compute nodes

Where the work runs

2x AMD EPYC 9654, 96 cores each 768 GB DDR5-4800, 12 channels/socket ~920 GB/s memory bandwidth per node

Each node is a dual-socket server carrying two 96-core EPYC 9654 processors, 768 GB of DDR5-4800 across all 24 memory channels, and a single NDR InfiniBand port. Nodes are identical on purpose: a job that runs on one runs on all of them, and a failed node is swapped without touching the image. Memory bandwidth, not clock speed, is what most simulation code waits on. Twelve channels per socket give roughly 920 GB/s per node, which keeps stencil and sparse-matrix kernels fed where a desktop starves them. Nodes boot stateless over the network, so the whole pool holds one identical software image and grows by racking more of the same.

NDR InfiniBand
Imagery in production

Interconnect fabric

How nodes talk

NVIDIA Quantum-2 NDR, 400 Gb/s per port Non-blocking fat-tree topology ~1.1 us end-to-end MPI latency
NDR InfiniBand
Imagery in production

Interconnect fabric

How nodes talk

NVIDIA Quantum-2 NDR, 400 Gb/s per port Non-blocking fat-tree topology ~1.1 us end-to-end MPI latency

A single MPI job spread over 64 nodes is only as fast as the slowest message between them. The fabric is NDR InfiniBand at 400 Gb/s per port on NVIDIA Quantum-2 switches, wired as a non-blocking fat-tree so every node can talk to every other node at full rate at the same time. Latency matters more than raw bandwidth for tightly coupled work. End-to-end MPI latency lands near 1.1 microseconds, and RDMA moves data straight between node memories without waking the CPU. Adaptive routing steers around a congested link instead of stalling on it. The same fabric carries storage traffic on a separate partition so a heavy write does not starve the message passing.

Lustre on NVMe
Imagery in production

Parallel filesystem

Where data lives

Lustre, NVMe OSTs over InfiniBand 40 GB/s+ read, 25 GB/s+ write sustained Single POSIX namespace, no per-node copies
Lustre on NVMe
Imagery in production

Parallel filesystem

Where data lives

Lustre, NVMe OSTs over InfiniBand 40 GB/s+ read, 25 GB/s+ write sustained Single POSIX namespace, no per-node copies

One thousand cores writing checkpoints at once will flatten an ordinary file server. Storage is a Lustre parallel filesystem: metadata on one tier, data striped across many NVMe object storage targets, all on the same InfiniBand fabric. A single large file is split across targets so many nodes read and write it in parallel, giving sustained figures past 40 GB/s read and 25 GB/s write. Every node sees one POSIX namespace at the same path, so job scripts do not stage or copy data between local disks. Stripe count and size are tunable per directory, so a few enormous files and millions of tiny ones can each be laid out the way they read best.

Stateless boot
Imagery in production

Management and provisioning

How it stays identical

Warewulf stateless node images Slurm scheduler on a redundant head Spack + Lmod software modules
Stateless boot
Imagery in production

Management and provisioning

How it stays identical

Warewulf stateless node images Slurm scheduler on a redundant head Spack + Lmod software modules

A cluster only stays trustworthy if every node is provably identical. Nodes network-boot a single Warewulf image held on redundant head nodes, so a reboot returns a node to a known-good state and a new node inherits it with no hand configuration. Slurm runs the queue from the head nodes with a standby that takes over if the primary fails. Application software is delivered through Spack-built stacks exposed as Lmod modules, so a user loads a named compiler and MPI version instead of fighting library paths. Everything a user sees, from the login shell to the module tree, is the same on the first node and the five hundredth.

Solution optimized products

Configured hardware.

The parts we rack for a general CPU cluster, sized as a starting point and tuned to the workload.

Imagery in production
Compute

Calyraen Serve Compute node

2x EPYC 9654, 192 cores, 768 GB

Dual-socket 1U server, 96 cores per socket, one NDR InfiniBand port. The unit the pool is built from.

Imagery in production
Compute

Calyraen Serve head node pair

Redundant, Slurm + provisioning

A redundant pair running the scheduler, provisioning and user logins, so the loss of one does not stop the queue.

Imagery in production
Fabric

Quantum-2 NDR switch

64 ports, 400 Gb/s each

The leaf and spine of the fat-tree. Non-blocking, with adaptive routing across the fabric.

Imagery in production
Storage

Lustre NVMe storage shelf

40 GB/s+ read, one namespace

Metadata and NVMe object targets on the InfiniBand fabric, presented as a single parallel filesystem.

Imagery in production
Facility

Direct-to-chip liquid cooling rack

Up to 60 kW per rack

Cold plates on each CPU and a rear manifold carry heat to facility water, so a dense rack stays quiet and within thermal limits.

What is included

Turnkey, not a pallet.

Installed and benchmarked

Running

We rack, cable, cool and burn in the whole cluster, then hand it over having proven the numbers. Before sign-off it passes a Linpack run, an MPI latency and bandwidth sweep, and a filesystem throughput test, with the results written into the acceptance report. You get a machine that already works, not a room of boxes.

Imagery in production

Compute pool

Identical dual-EPYC nodes, stateless-booted from one image so the pool grows without drift.

Low-latency fabric

Non-blocking NDR InfiniBand fat-tree wired and verified end to end, storage on its own partition.

Parallel storage

A Lustre filesystem sized to the node count so checkpoints do not become the bottleneck.

Scheduler

Slurm configured with your partitions, fair-share and limits, so the queue reflects how your teams actually share time.

“We stopped renting cores by the hour and bought the pool outright. The crash-safety runs that used to spill across a week now finish overnight, and the queue is finally something the whole team trusts.”
Head of simulation, automotive engineering
Architecture

Balance

A cluster is a balancing act between cores, the network between them and the storage under them. Oversize one and the others become the wall every job hits. Here is how the three are matched.

Under the hood

How it fits together.

Imagery in production
Compute

Many identical nodes

The pool is built from one node type: a dual-socket server with two 96-core EPYC 9654 processors and 768 GB of DDR5 across 24 channels. Identical hardware means a job is portable across the whole pool and capacity grows by adding more of the same unit. Nodes hold no local state worth keeping; they boot a shared image over the network and mount the parallel filesystem at a fixed path. A dead node is pulled and replaced without a rebuild.

Imagery in production
Fabric

A non-blocking fat-tree

Nodes connect with NDR InfiniBand at 400 Gb/s per port through NVIDIA Quantum-2 switches, wired as a two-level fat-tree with no oversubscription. Every node can reach every other node at full line rate at once, which is what a large MPI job needs when all ranks exchange data in the same step. RDMA moves buffers between node memories without involving the CPU, and adaptive routing spreads traffic around a hot link instead of queueing behind it.

Imagery in production
Storage

One parallel namespace

A Lustre filesystem stripes each large file across many NVMe targets so hundreds of nodes read and write in parallel rather than one at a time. Metadata sits on its own tier so opening millions of small files does not stall the data path. Every node sees the same POSIX tree at the same path, so job scripts never copy data between local disks, and stripe layout is tuned per directory to match how each dataset is read.

Sized for growth

Modular by design.

A cluster you can grow one leaf at a time.

Node

Add cores

Rack another identical node, boot it from the shared image, and Slurm sees it in minutes. No re-tuning of the ones already there.

Fabric

Add a leaf

The fat-tree grows by adding leaf switches under the spine. Non-blocking up to the design node count, then extended with more spine as it scales.

Storage

Add a target

Throughput and capacity both rise by adding NVMe object targets. The namespace does not change, so users see more speed at the same path.

What a starting rack holds

16 Compute nodes per rack
400 Gb/s InfiniBand per node
768 GB Memory per node
60 kW Cooling per rack, liquid
Engineering questions

Fabric and floor.

Air or liquid cooling?

Both are supported. Up to about 30 kW per rack we cool with a rear-door heat exchanger on chilled water. Above that, direct-to-chip cold plates carry heat straight to facility water and let a rack reach 60 kW without raising the room temperature.

Does it have to be InfiniBand?

For tightly coupled MPI work, InfiniBand's sub-1.2 microsecond latency and RDMA are hard to match. Where a workload is embarrassingly parallel and latency-tolerant, we can build the same pool on 200 or 400 Gb/s RoCE Ethernet at lower cost. We size the fabric to the code, not the brochure.

What filesystem do you use?

Lustre by default for its throughput at scale, or BeeGFS where a simpler operational model matters more than peak numbers. Both present one POSIX namespace on NVMe targets over the same fabric. We benchmark the real workload before committing to either.

Measured, not promised
> 90% Parallel efficiency, 64-node strong scale
1.1 us MPI latency, node to node
780 GB/s STREAM Triad memory bandwidth, per node
40 GB/s Lustre read, sustained under load
How it scales

Where the time actually goes.

Imagery in production
Strong scaling

Same problem, more nodes

Take one fixed simulation and hand it more nodes: the run should get faster in proportion until communication starts to dominate. On a non-blocking fat-tree, tightly coupled solvers hold better than 90 percent parallel efficiency out to 64 nodes before the curve bends. We profile your code with the fabric's own counters to find the node count where adding more stops paying, so you buy the size that matches the work.

Imagery in production
Weak scaling

Bigger problem, more nodes

Grow the mesh and the node count together and the wall-clock time per step should stay flat. This is where a cluster earns its keep: a model too large for any single machine's memory is spread across many nodes, each holding a slice. Because every node has 768 GB and full-rate access to the fabric, the per-step cost stays near constant as the problem grows into the thousands of cores.

Imagery in production
Memory bound

Feeding the cores

Most simulation kernels wait on memory, not arithmetic. Twelve DDR5-4800 channels per socket deliver close to 780 GB/s of measured STREAM bandwidth per node, so stencil, CFD and sparse-solver code that starves on a desktop runs at full tilt here. Where a kernel is genuinely compute-bound, the 192 cores per node carry it; where it is bandwidth-bound, the memory subsystem does.

What it runs

Real jobs.

The kind of work this pool is sized for.

CFD

Fluid dynamics

OpenFOAM and Ansys Fluent cases in the tens of millions of cells, decomposed across dozens of nodes. Latency-sensitive, and where the fabric pays off most.

FEA

Crash and structures

LS-DYNA and Abaqus explicit runs that spill a single machine's memory. Spread across nodes, an overnight queue clears what took a week.

Batch

Genomics and Monte Carlo

High-throughput pipelines and parameter sweeps: thousands of independent tasks packed onto cores by the scheduler, latency-tolerant and storage-hungry.

The difference

Owned versus rented.

Owned clusterCloud by the hour
Interconnect Non-blocking NDR InfiniBand, ~1.1 us Varies by instance, often oversubscribed
Cost at steady load Fixed, falls per-core over its life Per-hour, whether the core works or idles
Data gravity Data sits next to the cores, no egress fee Egress billed every time data leaves
Node placement Known topology, ranks placed by you Placement often opaque across a zone
Best for Steady, tightly coupled, predictable load Spiky or short-lived bursts
“The interconnect is the part you cannot fake. Our old cloud runs stalled the moment a solver got chatty across nodes. On the InfiniBand fabric the same case scales past sixty nodes before it even starts to tail off.”
Lead engineer, aerospace structures
Operations

Sharing

A cluster is only worth owning if its cores stay busy and every team feels the queue is fair. Left alone, a shared machine turns into a standoff: one group's week-long sweep blocks everyone else, small urgent jobs wait behind giants, and idle nodes sit dark while people argue over access. The scheduler is what stops that. Slurm holds every job in a queue, packs them onto free cores, and enforces the rules you set about who gets what share over time. It backfills small jobs into the gaps left by big ones, so utilisation stays high without starving the short work. Run well, nobody has to ask a person for a slot; the policy does it, and the numbers are there to prove it was fair.

The scheduler

Slurm, tuned to your teams.

Fair by policy

Shares

Fair-share scheduling tracks how much each group has used and steadily raises the priority of those who have had less, so heavy users cannot crowd out the rest over a week. Partitions and QOS levels ring-fence capacity for urgent or interactive work. The rules are yours; we configure them to how your teams actually agree to share.

Imagery in production

Backfill

Small jobs slot into the gaps ahead of big reservations, so short work does not wait behind week-long runs.

Limits and QOS

Per-group caps on cores, walltime and running jobs keep one project from swallowing the machine.

Reservations

Carve out nodes for a deadline, a course or maintenance without emptying the whole queue.

Accounting

Every job's cores, memory and walltime are logged, so usage and fairness are reported, not argued.

From login to results

How a job runs.

  1. Log in and load

    A user signs in to a login node and loads the compiler and MPI version they need as Lmod modules. No admin ticket, no library hunt.

  2. Write a batch script

    A short Slurm script asks for nodes, cores and walltime and names the program to run. The same script runs on 4 nodes or 400.

  3. Submit and wait

    Slurm queues the job, places its ranks on free nodes by fair-share and backfill, and starts it when its turn and resources line up.

  4. Collect and repeat

    Output lands in the parallel filesystem at the same path from every node. Results are ready to post-process without copying anything back.

Running questions

Day to day.

Who keeps it patched and healthy?

You can run it in-house with the runbooks and monitoring we hand over, or take a managed contract where we watch the fabric, filesystem and scheduler, apply firmware and OS updates in maintenance windows, and hold spares for node swaps. Most teams start managed and take over as they grow confident.

What happens when a node dies mid-job?

Slurm marks the node down and requeues affected jobs by policy. Because nodes are stateless, a failed one is drained, physically swapped, and network-booted back into the pool from the same image, usually without a maintenance window.

Specify it with us

Size it to your work.

Bring us your codes and your busiest week and we will size the cluster against them, not a benchmark. You get a machine matched to the jobs you actually run.

Resources

Proof

The briefs, sizing notes and worked cases behind the design. Open one for the detail, or request the full documents.

Reading room

Briefs and cases.

How the design holds up on paper and in the field. Open one to read the detail.

Fabric
Imagery in production

Interconnect sizing brief

Choosing the fabric to the code

8 pages InfiniBand vs RoCE Latency and bandwidth data
Fabric
Imagery in production

Interconnect sizing brief

Choosing the fabric to the code

8 pages InfiniBand vs RoCE Latency and bandwidth data

Why a tightly coupled solver lives or dies on interconnect latency, and how to decide between NDR InfiniBand and 400 Gb/s RoCE Ethernet for a given workload. Includes measured latency and bandwidth curves, the cost delta between fabrics, and a decision tree keyed to MPI communication patterns. Written for the engineer who has to justify the fabric line on the quote.

Use case
Imagery in production

Weather modelling cluster

A regional forecasting centre

48 nodes, NDR fabric WRF at 1 km resolution 6-hour forecast cycle
Use case
Imagery in production

Weather modelling cluster

A regional forecasting centre

48 nodes, NDR fabric WRF at 1 km resolution 6-hour forecast cycle

A regional met service running WRF at 1 km resolution needed each forecast cycle to finish inside six hours to be worth issuing. The old shared servers took nine. A 48-node cluster on a non-blocking NDR fat-tree brought the cycle to under four hours with room to raise resolution. Weak scaling held flat as the domain grew, and the Lustre filesystem absorbed the model's heavy checkpoint writes without stalling compute. Names and figures are illustrative of a typical deployment.

Use case
Imagery in production

Crash-safety simulation

An automotive supplier

64 nodes, LS-DYNA Week to overnight Owned vs cloud cost
Use case
Imagery in production

Crash-safety simulation

An automotive supplier

64 nodes, LS-DYNA Week to overnight Owned vs cloud cost

A tier-one automotive supplier was renting cloud cores for LS-DYNA crash runs and watching a full test matrix spill across a week, with a cloud bill that climbed every quarter. An owned 64-node cluster cleared the same matrix overnight and paid back the capital inside eighteen months against the prior cloud spend. The tightly coupled explicit solver held above 90 percent efficiency to 64 nodes on the InfiniBand fabric. Figures are illustrative of a typical deployment.

Sizing note
Imagery in production

Storage sizing note

Matching Lustre to node count

6 pages Stripe and target math Checkpoint bandwidth rules
Sizing note
Imagery in production

Storage sizing note

Matching Lustre to node count

6 pages Stripe and target math Checkpoint bandwidth rules

A short working note on sizing a parallel filesystem so checkpoint writes never become the bottleneck: how many NVMe object targets a given node count needs, how stripe count and size change the numbers, and the rule of thumb we use for aggregate checkpoint bandwidth. Meant to be read alongside a real job's I/O profile, not in place of one.

Request the files

Documents.

Datasheets, sizing worksheets and a sample acceptance report, sent on request.

Specify it with us

Start with your codes.

Send us the applications and problem sizes you run today. We will come back with a cluster sized to them and the benchmarks to prove it.