Summary
Slurm 26.11 gives high-performance computing centers a cleaner way to treat a quantum processor as a scheduled cluster resource. Its new Hierarchical Resource, or HRES, plugin interface can track device availability, carry QPU-specific options in a job request, prepare access before a job starts and clean up when the job ends.[1][2]
That sounds like plumbing because it is. It is also the part of quantum-classical computing that has been missing from many demonstrations. A useful hybrid workflow needs more than a CPU calling a remote quantum API. It needs reservations, credentials, health checks, accounting, failure handling and a policy for deciding which compute nodes may reach which device.
Slurm is not turning a QPU into an ordinary GPU. The hardware, execution model and service boundaries are too different for that. The 26.11 work instead gives sites an extension point where quantum middleware can meet the scheduler without putting vendor-specific logic into Slurm itself. Open-source QRMI and QDMI integrations are the first examples.[2][3]
Why node and GPU scheduling were not enough
Slurm's familiar resources mostly belong to a compute node. A node has a fixed number of CPU cores, a known amount of memory and perhaps several GPUs. The scheduler can allocate those resources because their location and ownership are clear.
A QPU often sits beside the cluster rather than inside a node. It may be reachable only from a subset of nodes, shared across several partitions or exposed through a service that creates time-limited sessions. The scheduler also needs to know whether the device is calibrated and available, not merely whether a static resource count exists.
Sites have worked around that mismatch with licenses, custom submission wrappers, SPANK plugins and workflow code. Those approaches can make a demonstration run, but they split policy across too many layers. A wrapper may request a quantum session without reserving the classical nodes that feed it. A scheduler may reserve an abstract license while knowing nothing about device health. Credentials may be created too early, expire while a job waits in the queue or leak into generic workflow logs.
HRES was added in Slurm 25.05 to model resources that are adjacent to a cluster and available only through particular parts of its topology. The feature remains explicitly marked beta in the current documentation, so production sites should expect configuration changes and read release notes carefully.[4] Slurm 26.11 extends the model with a plugin interface aimed at devices that need active lifecycle management, including QPUs.[1][2]
What the HRES plugin changes
The first implementation, hres/lua, runs site or middleware logic through a small Lua plugin. SchedMD's SC26 material describes callbacks at the controller, node and task levels. A maintenance callback can report availability and drain a resource. Pre-run logic can prepare a job, while prolog and epilog hooks can distribute a payload to allocated nodes and remove access afterward.[1]
A site still defines its resource topology in resources.yaml. In the QPU example shown by SchedMD, a resource named qpu is associated with a set of nodes and a Lua plugin. A user can then submit a request shaped like this:
sbatch --resources=qpu:1[qubits=30] hybrid-job.sh
The syntax matters less than the boundary it creates. Cluster administrators retain control of endpoints, reachable nodes, concurrency and local policy in the resource configuration. The plugin author handles device behavior. That separation means a middleware project or QPU provider can maintain an integration without asking SchedMD to merge a new scheduler code path for every backend.[2]
Health is part of scheduling rather than an afterthought. The maintenance callback can mark an HRES unavailable and can optionally terminate jobs that are using it. The controller can also create a job-specific payload, such as short-lived access material, and pass it to node-level hooks. This is a better fit for remote scientific instruments than a static numeric license.
There are limits. SchedMD's SC26 presentation says HRES preemption in 26.11 applies only to Mode 3 resources, runs in the main scheduler rather than backfill and supports cancel or requeue behavior. Suspending a job does not release its HRES allocation.[1] QPU integrations described by NVIDIA use Mode 1, so operators should not assume that quantum reservations gain the new preemption behavior.
QRMI and QDMI take different approaches
The plugin interface is only useful if middleware projects implement it. QRMI and QDMI now provide two concrete patterns.
QRMI, developed in the Qiskit community, presents a common resource-management layer over quantum backends. Its HRES plugin books QPU access before a Slurm job runs, using the submitting user's credentials, then releases the reservation or session when the job ends. Existing applications receive the same environment variables used by the earlier QRMI SPANK integration, which can reduce changes to workflow code.[2][3]
QDMI uses a looser admission model. Its plugin allows a job to start when the quantum resource is available, but the job submits work to the provider's own queue. This distinction is operationally important. Booking a session at Slurm start can align classical and quantum allocations closely, but it requires the backend to support useful reservation semantics. Provider-side queueing is easier to fit around some services, though classical nodes may sit idle while quantum work waits.
Neither model makes QPU time interchangeable with GPU time. They make the differences visible to the scheduler. Sites can choose whether an allocation represents exclusive access, admission to an external queue or another policy encoded by the plugin and resource count.
What infrastructure teams should test
The first test should be failure, not a polished chemistry notebook. Disable the QPU endpoint while jobs are pending and while one is running. Confirm that health changes reach Slurm, that the resource drains as intended and that the site's chosen cancel or requeue policy does not leave classical nodes occupied indefinitely.
Credential handling deserves the same attention. The controller-side pre-run path can generate and distribute access material, but each site must decide where user identity is mapped, how secrets reach job nodes and when they are destroyed. Administrators should verify that credentials do not appear in scontrol output, environment dumps, prolog logs or accounting records. A short-lived credential is useful only if cleanup works after normal completion, cancellation and node failure.
Topology also needs a realistic model. If only a gateway partition has low-latency access to the QPU, the resource should not appear usable from the whole cluster. Otherwise Slurm can produce an allocation that is valid on paper and unusable on the network. The same issue applies when several QPUs share a control plane, cryogenic support equipment or a constrained data path.
Accounting is less settled. A QPU job may consume wall time, shots, circuits, reserved sessions or a provider-specific unit. HRES can enforce a count and expose allocation state, but chargeback and scientific provenance still need a site policy. Teams should record the backend identity, calibration context, plugin version and reservation identifiers with the workflow output. A completed Slurm job is not enough to reproduce a quantum result.
Upgrade planning cannot be separated from the feature. Slurm 26.11 raises the minimum database versions and requires slurmdbd to rewrite job and step tables on first start. SchedMD advises testing that conversion offline; its published examples show storage speed can change the migration time substantially.[1] A center should not combine its first QPU integration with an untested accounting-database upgrade.
This is an operations milestone, not quantum advantage
IBM's SC26 update places the scheduler work beside broader quantum-HPC projects, including GPU-assisted error-correction research and hybrid scientific workflows.[5] Fermilab, IBM and NVIDIA also plan a co-design platform that would physically combine quantum systems with accelerated computing for high-energy and nuclear physics research.[6] Those efforts explain why scheduler integration is arriving now: laboratories are moving from occasional remote calls toward shared facilities with multiple users and tightly coupled classical work.
The announcements do not prove that a QPU will accelerate a production workload, and HRES does not solve error correction, calibration drift or algorithm quality. Vendor and laboratory performance claims must be judged on their own methods. Scheduler support only removes one class of operational friction.
That narrower achievement is still useful. HPC centers already know how to manage queues, reservations, partitions, maintenance windows and user accounting. Slurm 26.11 lets quantum middleware connect to those practices through a defined interface instead of another pile of one-off scripts. For teams evaluating hybrid infrastructure, the next credible demo is not simply a circuit executed from a cluster. It is a circuit that survives queueing, health changes, credential rotation, cancellation and audit.
Sources
- SchedMD: Slurm 26.11 and Beyond, SC26 presentation
- NVIDIA Technical Blog: Integrating QPUs into Supercomputing Centers Using Slurm HRES Plugins
- Qiskit Community: Quantum Resource Management Interface (QRMI)
- SchedMD: Hierarchical Resource (HRES) Scheduling
- IBM Quantum: At SC26, IBM accelerates progress in bringing quantum and HPC together
- Fermilab: Modular quantum computing co-design platform announcement
