Three ways to share a QPU: Scheduling strategies for hybrid Quantum-HPC applications
This paper investigates and experimentally validates three distinct scheduling strategies—time-based multiplexing, dynamic resource management, and workflow decomposition—for hybrid HPC-QC systems, demonstrating that malleability and workflow approaches optimize classical resource utilization for balanced workloads while time-multiplexing maximizes QPU efficiency for imbalanced scenarios.
Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer
Imagine you are running a massive, high-tech kitchen (an HPC Cluster) where thousands of chefs (classical computers) are preparing complex meals. Suddenly, you acquire a very rare, magical oven (a Quantum Processor or QPU). This oven can bake a specific type of cake in seconds that would take the chefs hours to make, but it's incredibly expensive, there's only one of them, and it's very finicky.
The problem? The chefs are fast, but the magical oven is slow to heat up and cool down. If you let one chef use the oven for their whole shift, the oven sits idle 99% of the time while the chef does the prep work. This is a waste of your most valuable asset.
This paper asks: "How do we share this one magical oven among hundreds of chefs so everyone gets fed faster without wasting the oven?"
The authors propose three different ways to solve this, depending on how the kitchen is organized.
1. The "Time-Share" Strategy (Virtual QPUs)
The Analogy: Imagine the magical oven is a shared conference room. Instead of letting Chef A book the whole room for the day, you give Chef A a 10-minute slot, then Chef B a 10-minute slot, then Chef C, and so on.
- How it works: The kitchen manager (the scheduler) slices the oven's time into tiny pieces. While Chef A is chopping vegetables (classical work), Chef B is actually using the oven. The oven is never sitting idle waiting for a single chef to finish their prep.
- Best for: When the "oven time" is very short compared to the "prep time."
- The Catch: Sometimes a chef might have to wait a few extra minutes in line for their turn, but the whole kitchen finishes all the meals much faster.
- Who needs this: Anyone who wants to use the oven without changing how they cook. It's a "plug-and-play" solution.
2. The "Flexible Team" Strategy (Dynamic Resource Management)
The Analogy: Imagine a cooking team that starts with 10 chefs. When they need to use the magical oven, they don't need all 10 chefs standing around watching. So, 9 chefs pack up their knives and leave the kitchen to go help in the pantry (or go home), leaving just 1 chef to watch the oven. Once the oven is done, the 9 chefs come back.
- How it works: The software (called DMR) tells the classical computers: "Hey, we are waiting for the quantum part. You can shrink your team size now to save electricity and space." When the quantum part is done, the team expands back to full size.
- Best for: When the quantum part takes a long time (like a slow-baking cake).
- The Benefit: You save a massive amount of energy and computer power because you aren't paying for 10 chefs to stand around doing nothing for 20 minutes.
- The Catch: The chefs need to be trained to know when to shrink and grow (the code needs a little update).
3. The "Project Manager" Strategy (Workflow Decomposition)
The Analogy: Instead of one big team trying to do everything at once, you break the recipe into tiny, independent steps managed by a strict Project Manager (a Workflow System).
- Step 1: Chef A chops onions (uses 2 computers).
- Step 2: Chef B uses the magical oven (uses 0 computers).
- Step 3: Chef C mixes the batter (uses 4 computers).
The Project Manager only hires the specific number of chefs needed for that specific step. If Step 2 doesn't need any chefs, the kitchen hires zero chefs for that moment.
- How it works: The application is built as a chain of tasks. The system only turns on the lights (computers) when a task is actually happening.
- Best for: Complex, new recipes where the quantum part is a long, distinct phase.
- The Benefit: This is the most efficient way to save resources (up to 64% less waste!).
- The Catch: You have to design the recipe from scratch as a series of steps. It's harder to set up than the other two methods.
The Big Picture: Which one should you choose?
The paper tested these strategies on real supercomputers and a real quantum computer. Here is the verdict:
- If your quantum part is super fast (like a microwave): Use Strategy #1 (Time-Share). It makes the oven work harder, and the whole system finishes faster. You don't even need to change your code.
- If your quantum part is slow (like a slow cooker): Use Strategy #2 (Flexible Team) or Strategy #3 (Project Manager). These stop you from wasting money on idle computers while waiting for the slow cooker to finish.
- Strategy #2 is great if you already have a big team (MPI app) and just want to shrink them temporarily.
- Strategy #3 is the ultimate resource saver if you are building a new app from the ground up.
The Takeaway:
You don't have to pick just one. You can use a Project Manager (Strategy #3) to run your app, and inside that app, use a Flexible Team (Strategy #2) to save power. And underneath it all, the kitchen can use Time-Sharing (Strategy #1) to make sure the magical oven is never sitting empty.
By mixing and matching these strategies, we can make the transition to "Quantum-Hybrid" computing smooth, efficient, and ready for the future.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.