MLFS: Redefining Cluster Scheduling through Spatial-Temporal ML Features

Executive Summary

TL;DR: MLFS is a cutting-edge job scheduling system designed for the era of giant models. Unlike previous schedulers that treat ML jobs as generic "black-box" tasks, MLFS looks inside the training process. By analyzing spatial features (model partition dependencies) and temporal features (iteration-based accuracy gains), it achieves a massive 53% reduction in JCT and a 64% boost in final accuracy.

Background: Within the academic landscape, MLFS occupies a unique position. It bridges the gap between traditional cluster resource management (like Borg or Graphene) and ML-specific optimization. It is one of the first systems to provide a comprehensive scheduling framework for model parallelism, moving beyond the simpler data-parallel paradigms of the past decade.

Problem & Motivation: The "Black-Box" Scheduler Trap

Prior SOTA schedulers like Tiresias or Gandiva focus on the "What" (resource utilization, fairness) but ignore the "How" (how ML models actually converge).

• The Model Parallelism Gap: As models grow too large for single GPUs, they must be partitioned. Existing schedulers struggle with the complex dependency graphs these partitions create.
• Ignoring Convergence Intuition: In ML training, the first 10% of iterations often contribute 90% of the accuracy gain. Standard schedulers treat early and late iterations with equal priority, wasting critical resources on "diminishing returns" when the system is overloaded.

Methodology: The Core of MLFS

The brilliance of MLFS lies in its multi-layered architecture, integrating human intuition (heuristics) with machine intelligence (RL).

1. Spatial-Temporal Priority Determination

MLFS calculates task priority ($P_{k,J}$) using a weighted combination of:

• Temporal Features: Prioritizing earlier iterations and those with higher loss reduction.
• Spatial Features: Prioritizing larger model partitions and "bottleneck" tasks in the dependency graph that have many child tasks waiting.
• Computation Features: Accounting for deadlines, remaining time, and queue wait times.

2. The RL-Driven Intelligence

While heuristics are robust, they are hard to tune globally. MLFS uses MLF-RL, a Deep Reinforcement Learning agent.

• State: Captures GPU/CPU utilization, job arrival times, and model-specific metadata (algorithm type, dependency graph).
• Action: Decision on task migration and node allocation.
• Reward: A multi-objective function combining JCT, deadline satisfaction, bandwidth cost, and accuracy.

Experiments: Breaking the SOTA

The researchers validated MLFS using Microsoft Philly traces (2,474 GPUs across 550 servers).

• JCT Dominance: MLFS consistently stays at the bottom-left of the JCT curve, meaning it completes jobs significantly faster than TensorFlow's Borg or SLAQ.
• Accuracy Gains: By implementing MLF-C (System Load Control), the system terminates training once "good enough" accuracy is reached during overload, freeing up GPUs for other critical jobs.

Figure: CDF of JCT showing MLFS outperforming all major baselines.

Critical Analysis & Conclusion

Takeaways: The industry is moving toward "Model-Aware Infrastructure." MLFS proves that the scheduler should be as smart as the models it runs. By understanding the task dependency graph of model parallelism, we can eliminate stragglers and maximize throughput.

Limitations:

1. Cold Start: MLF-RL requires initial heuristic data to train effectively.
2. Transferability: An RL model trained on CNNs might struggle when a cluster suddenly shifts to massive Transformer-based LLMs without retraining.

Future Outlook: The integration of Pipeline Parallelism (like GPipe) into this framework is the next logical step. As we enter the trillion-parameter era, MLFS-like systems will be the difference between a cluster that thrives and one that stalls.