← All news & insights

MQSC Facilitates Quantum Resource Orchestration via Slurm with the MQSC Orchestrator

As a collaborator on NVIDIA’s expansion of Slurm for quantum computing, MQSC brings quantum resources into scheduled HPC workflows. The MQSC Orchestrator combines Slurm’s Hierarchical Resources (HRES) with QDMI, compilation, and hybrid execution, giving computing centers a common way to manage quantum access across providers.

MQSC Orchestrator, NVIDIA and Slurm connect HPC through the MQT Compiler Collection and QDMI to quantum hardware

Many scientific workflows combine classical preparation, quantum computation, and classical processing of the results. Coordinating these stages means bringing quantum systems into the infrastructure that researchers and computing centers already use.

Quantum processors and classical supercomputers are at the center of future scientific computing. Slurm, developed and maintained by NVIDIA, provides an established foundation for scheduling these workflows.

With the expansion of Slurm to include quantum resources, we connect Hierarchical Resources (HRES) to the Quantum Device Management Interface (QDMI). The MQSC Orchestrator brings together device access, compilation, and hybrid execution in a deployment that computing centers can explore and adapt. HRES makes quantum access limits, node eligibility, and device availability part of Slurm’s resource management.

In our earlier integration, administrators configured quantum access as Slurm licenses, while a separate health monitor maintained reservations to block unavailable devices. With HRES, a resource definition and a QDMI-backed maintenance hook replace that separate license setup and monitor. Slurm manages admission directly, with fewer services and less configuration to keep in sync.

HRES: Resource Management Beyond the Compute Node

A quantum processor may be accessible from several nodes in an HPC system, shared among users, and operated locally or through a cloud service. Its availability can change independently of the classical nodes that communicate with it. A scheduler needs to represent these relationships to make informed allocation decisions.

Slurm’s Hierarchical Resources describe shared resources, their capacity, and the groups of nodes that can access them. The hierarchy can express several levels of resource constraints, giving sites a way to model access across their infrastructure. Quantum processors fit naturally into this model: a job requests quantum access together with the classical resources needed to use it.

The Slurm 26.11 release candidate used in our integration extends HRES with plugin support for external services. Device availability and job lifecycle events can become part of resource management. This provides an integration point for QDMI, whose common interface exposes device information and quantum job operations across providers.

HRES supplies the scheduling model; QDMI connects that model to the quantum system. Slurm continues to own allocation and accounting, while QDMI device implementations handle communication with each provider.

Connecting Quantum Resources Through QDMI

In typical HPCQC deployments, quantum access nodes (QANs) provide the software and connectivity needed to reach quantum systems. Classical compute nodes handle preparation and subsequent computation. HRES associates a quantum resource with the nodes from which it can be accessed.

The available QDMI implementations cover IQM, Amazon Braket, IBM, MQT DDSIM, and Pasqal. This shared interface lets a site integrate different quantum resources into the same scheduling environment.

For example, a site can expose IQM Emerald, a 54-qubit system, through QDMI-on-IQM and define its access policy in Slurm’s resources.yaml:

- resource: iqm.emerald
  mode: MODE_1
  plugin:
    type: hres/lua
    config:
      - name: path
        value: /etc/slurm/hres_qdmi.lua
    maintenance_cycle: 30
    maintenance_timeout: 15
  layers:
    - layer_name: quantum
      nodes: ["qan[1-2]"]
      count: 2

With count: 2, two local allocations can access Emerald concurrently through the QANs. This allows multiple users to submit work to IQM’s queue; the provider still schedules execution on the QPU. Administrators can tune this count to match their site’s access policy. The iqm.emerald identifier is supplied by QDMI-on-IQM.

Credentials remain in the provider configuration, separate from the HRES resource definition. QDMI-on-IQM’s authentication guide covers setup for availability checks and user jobs.

Users request the resource through Slurm’s existing --licenses option; HRES supplies the resource definition and manages its availability:

sbatch --partition=quantum --licenses=iqm.emerald:1 quantum-job.sh

Here, --licenses=iqm.emerald:1 requests one unit of the configured HRES resource for the job. That unit represents a share of the site’s quantum access capacity, not a qubit or a software license. quantum-job.sh contains the user’s quantum application. Slurm determines when and where it can start. The MQSC Orchestrator’s application integration reads the granted resource and uses the corresponding QDMI device for both compilation and execution.

Device Availability Becomes a Scheduling Input

A QDMI device implementation connects to its backend and exposes the system’s status through a common interface. HRES uses that status to decide whether new work can be admitted. The maintenance hook below translates a QDMI device check into Slurm resource state, independently of the provider:

local function quote(value)
    return "'" .. (tostring(value):gsub("'", "'\\''")) .. "'"
end

function hres_create_context(ctx, layers)
    return slurm.ESLURM_HRES_MAINTENANCE_DISABLE
end

function hres_maintenance(ctx, layers)
    local command = string.format(
        "/usr/bin/timeout --kill-after=2s 10s " ..
        "/usr/local/libexec/mqt-qdmi-probe %s </dev/null >/dev/null 2>&1",
        quote(ctx.name))
    local available = os.execute(command) == true
    for _, layer in ipairs(layers) do
        layer.disable_layer = not available
    end
    return slurm.SUCCESS
end

Admission remains closed until the first successful check. The probe opens the configured QDMI device and treats IDLE and BUSY as operational states, allowing for providers that accept queued work. Each check has a time limit, so an unresponsive service cannot leave it waiting indefinitely.

When the device becomes unavailable, new jobs requesting it remain pending without occupying execution nodes. A later successful check makes them eligible to run again. Other configured devices can continue serving work independently. HRES governs access within the HPC system; provider authorization and remote QPU scheduling remain with the provider.

The same hook works with the QDMI implementations listed above. MQT DDSIM provides a simulator alternative for development and testing within the same resource-management model.

From an Allocation to a Hybrid Application

The MQSC Orchestrator connects applications to Slurm HRES, compilation and QDMI execution on quantum access nodes, IQM and other providers, and classical continuation.

HRES connects resource availability to allocation. The MQSC Orchestrator carries that allocation through compilation, quantum execution, and classical continuation. Dashed arrows show scheduling and status; solid arrows show work and results.

Applications enter through familiar tools such as Qiskit and PennyLane. Inside the allocation, the MQT Compiler Collection prepares quantum programs for the selected device. MQT Core’s adapters and QDMI driver then submit them and reconstruct the results for the application. Keeping the allocated device consistent across these stages connects the scheduler’s decision to the computation that actually runs.

Our work integrating HRES has also tested the deployment’s operational behavior: enforcing access limits, retaining waiting jobs during device outages, resuming them after recovery, and accounting for their allocations. These are the capabilities that make quantum access manageable within a shared computing environment.

Bringing Quantum Resources into Existing HPC Practice

NVIDIA’s expansion of Slurm’s resource model gives computing centers a practical way to bring quantum systems into the scheduling practices on which they already depend. This advances the infrastructure for accelerated quantum supercomputing.

At MQSC, we build the system software that connects quantum hardware to users. The MQSC Orchestrator brings together device access, compilation, and hybrid execution around that goal. With HRES and QDMI, we can connect quantum systems from different providers to existing HPC workflows through reusable interfaces.

Explore the MQSC Orchestrator or connect with MQSC to discuss quantum integration in your infrastructure.

← All news & insights