Skip to Main Content
Talk Intermediate MIT (source code); CC BY-SA 4.0 (talk slides and original materials)

Beyond Greedy Scheduling: Building an Open-Source Edge–Cloud Scheduler in C++

Proposal status is Review Pending
Session Description

While participating in the ICPC 2026 Online Challenge powered by Huawei, I built a C++17 scheduler for an edge–cloud computing pipeline. What initially appeared to be an algorithmic optimization problem became an exercise in understanding resource contention, batching, and the limits of greedy scheduling.

The challenge was coordinating requests across a shared Edge processor, multiple Cloud workers, FIFO communication links, and repeated Prefill/Decode operations. A decision that improved one stage could introduce delays elsewhere.

In this talk, I'll walk through how my implementation evolved into an open-source, portfolio-based scheduling system.

What I'll cover:

  • The scheduling problem: Modelling request dependencies, compute resources, communication delays, and competing performance objectives.

  • Why greedy heuristics struggled: How locally efficient decisions sometimes reduced overall performance.

  • Bounded work-in-progress: Using Prefill admission limits and adaptive backpressure to manage congestion without unnecessarily starving resources.

  • Coherent Decode scheduling: Understanding why preserving useful Decode batches mattered.

  • Concurrent warm execution: Overlapping residual Prefill work with prioritized Decode processing to utilize otherwise idle Edge and Cloud capacity.

  • Portfolio-based scheduling: Why different workload regimes benefited from specialized strategies rather than one universal heuristic.

  • Experiment-driven optimization: Using controlled variants, public-judge measurements, regression checks, and unsuccessful experiments to guide development.

Across 22 public evaluation cases, the preserved total score improved from 16,141.82 to 16,315.79. These are contest-specific measurements, not production benchmarks.

I'll also share how I documented the implementation, experiments, and technical decisions in an MIT-licensed GitHub repository.

The central lesson is that effective optimization requires understanding the active bottleneck and validating changes against evidence, not simply choosing a clever priority rule.

Key Takeaways
  • Understand why simple greedy scheduling can fail when multiple computational resources and task dependencies interact.

  • Learn how bounded work-in-progress and adaptive backpressure can help manage resource contention.

  • Explore how coherent batching and concurrent execution can improve resource utilization.

  • Understand why different workload characteristics sometimes require different scheduling strategies.

  • Learn how controlled experiments, regression testing, and documenting failed approaches lead to more reliable performance engineering.

References

Session Categories

Technology architecture
Engineering practice - productivity, debugging
Introducing a FOSS project or a new version of a popular project
Talk License: MIT (source code); CC BY-SA 4.0 (talk slides and original materials)
Speakers are hidden and anonymized for this event.