TechnicalBeginner5 min read
Anatomy of a cluster
The five components of an HPC cluster and the life of a computation in seven steps, from submission to result, told through one researcher's run.
For: engineers and SREs · architects · team managers · executives and CIOsPrerequisites: None.
Illustrative scenario. A climate researcher wants to simulate how an ocean evolves over several decades. She never sits in front of the supercomputer and will never see it. From her office, she connects to a front-door machine, writes a short file describing her computation and what it needs, then drops it into a queue. A few hours later, the computation starts on dozens of servers. The next day, a message tells her it has finished and her results are waiting.
That journey goes through the five components found in every cluster. Knowing them is enough to follow most conversations with a computing team.
The five components of a cluster
Section titled “The five components of a cluster”The first is the login node. A node is simply one machine in the cluster, a server. This one is the reception desk: you connect to it to prepare and submit your work, never to compute.
The second is the scheduler, the software that runs the queue, sets priorities and hands out machines. The third is the set of compute nodes: the servers that do the work, with their processors and accelerators. The fourth is the interconnect, the very fast network linking the nodes to each other. The fifth is parallel storage, a file space shared by every machine and built to deliver huge amounts of data at once.
Work always follows the same path. The user prepares it on the login node and submits it to the scheduler, which reserves compute nodes. Those nodes talk over the interconnect, then read from and write to parallel storage.
flowchart TB
U["User"] --> L["Login<br/>node"]
L -->|"submits"| S["Scheduler"]
S -->|"reserves"| C1["Compute node 1<br/>CPU, GPU"]
S -->|"reserves"| C2["Compute node 2<br/>CPU, GPU"]
C1 <--> IC["Interconnect"]
C2 <--> IC
C1 <--> FS[("Parallel<br/>storage")]
C2 <--> FS
Compute nodes and accelerators
Section titled “Compute nodes and accelerators”If a node is a house, the cluster is the city. Each node is a powerful server with its processors (the CPUs, which run programs), its memory and its network link. A cluster has from a few hundred to several thousand of them. Each one could work alone; the power comes from their cooperation on the same problem.
Many nodes also carry accelerators, most often GPUs (graphics processing units). A classic processor is like a handful of highly versatile craftsmen. A GPU is more like an army of workers who each know one simple task but all do it at the same time: it holds thousands of small specialized compute cores. Originally designed for graphics, GPUs excel at repetitive mathematical computation, for simulation as for AI. On the right workload, a GPU outperforms a classic processor by a factor of ten or more. A node often carries several.
Interconnect and parallel storage
Section titled “Interconnect and parallel storage”The interconnect is the cluster’s nervous system. Nodes working on the same problem constantly swap results and every wait costs time. This network therefore targets a latency (the delay between sending a message and receiving it) in the order of a microsecond, which is, as an order of magnitude, a hundred to a thousand times lower than an office network, depending on the software stack. It is mostly InfiniBand, a networking technology built for computing, plus high-speed Ethernet.
Parallel storage works like a library where hundreds of readers can consult the same books at the same time. Data is spread across many disks and servers, so it can be read in pieces, in parallel. Its aggregate throughput ranges from a few tens of gigabytes per second (GB/s) to several terabytes per second (TB/s) depending on the size of the system. Common solutions are Lustre, IBM Storage Scale (formerly Spectrum Scale, or GPFS) and BeeGFS.
The scheduler, the cluster’s air traffic controller
Section titled “The scheduler, the cluster’s air traffic controller”With thousands of users, nobody can run whatever they want whenever they want, any more than a pilot can take off without clearance from the tower. Each piece of submitted work is called a job. The scheduler queues jobs, decides their priority by applying fairness rules between teams, reserves resources and then starts each job. It also accounts for usage per project or per user: fair sharing and chargeback both rest on that record.
The reference tool is Slurm, where you submit a job with the sbatch command. Others exist, such as PBS or OpenPBS and IBM LSF.
The life of a job in seven steps
Section titled “The life of a job in seven steps”Back to our researcher. She starts by writing her job script: the program to run, the resources requested (how many nodes, how many GPUs) and the expected duration. She then submits it, with sbatch on Slurm. The job joins the queue. When its turn comes near, the scheduler makes a decision by applying priority and fairness rules. Then comes allocation: nodes are reserved for this job alone. Execution follows, made of computation, exchanges between nodes and writing results. At the end the resources are released, the scheduler records the consumption and notifies the researcher.
The diagram shows the same steps as the job’s successive states:
stateDiagram-v2 state "Script written" as Script state "Submitted" as Soumis state "Queued" as EnFile state "Prioritized" as Decide state "Allocated" as Alloue state "Running" as Exec state "Released" as Libere [*] --> Script Script --> Soumis: sbatch Soumis --> EnFile EnFile --> Decide: priority and fairness Decide --> Alloue: nodes reserved Alloue --> Exec Exec --> Libere: computation ends Libere --> [*]: accounting, notification
One detail often surprises newcomers: users do not pick a compute node themselves to launch their work. They always go through the login node, from which they submit the job to the scheduler. Many sites then allow a remote connection (over SSH, the standard tool for secure command-line access) to the nodes allocated to one of the user’s running jobs, to follow its execution, but not to other nodes.
Revised on 2 October 2026: interconnect latency presented as an order of magnitude (in the order of a microsecond, a hundred to a thousand times lower than an office network depending on the software stack). Unsourced claim about its cost removed; IBM Storage Scale instead of Spectrum Scale, parallel storage throughputs aligned with the reference course.