Rui's Blog
  • Rui's Blog/Paper Reading Notes - Introduction
  • Personal Blog
    • Personal Blog - Index
      • How to Create Picture-in-Picture Effect / Video Overlay for a Presentation Video
      • How to Do Your Part to Protect the Environment in Wisconsin
      • How to Get a Driver's License in Wisconsin
      • How to Travel from the U.S. to China onboard AA127 in June 2021
      • How to Transfer Credits Back to UW-Madison
      • Resources on Learning Academic Writing (for Computer Science)
    • Towards applying to CS Ph.D. programs
  • Machine Learning Systems
    • Machine Learning Systems - Index
      • MLSys Papers - Short Notes
      • [2011 NSDI] Dominant Resource Fairness: Fair Allocation of Multiple Resource Types
      • [2014 OSDI] Scaling Distributed Machine Learning with the Parameter Server
      • [2018 OSDI] Gandiva: Introspective Cluster Scheduling for Deep Learning
      • [2018 SIGCOMM] Chameleon: Scalable Adaptation of Video Analytics via Temporal and Cross-camera ...
      • [2018 NIPS] Dynamic Space-Time Scheduling for GPU Inference
      • [2019 ATC] Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training Workloads
      • [2019 NSDI] Tiresias: A GPU Cluster Manager for Distributed Deep Learning
      • [2019 SOSP] ByteScheduler: A Generic Communication Scheduler for Distributed DNN Training ...
      • [2019 SOSP] PipeDream: Generalized Pipeline Parallelism for DNN Training
      • [2019 SOSP] Parity Models: Erasure-Coded Resilience for Prediction Serving Systems
      • [2019 NIPS] GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism
      • [2019 SC] ZeRO: memory optimizations toward training trillion parameter models
      • [2020 OSDI] Gavel: Heterogeneity-Aware Cluster Scheduling Policies for Deep Learning Workloads
      • [2020 OSDI] AntMan: Dynamic Scaling on GPU Clusters for Deep Learning
      • [2020 OSDI] BytePS: A High Performance and Generic Framework for Distributed DNN Training
      • [2020 SIGCOMM] Reducto: On-Camera Filtering for Resource-Efficient Real-Time Video Analytics
        • [2020 MLSys] Salus: Fine-Grained GPU Sharing Primitives for Deep Learning Applications
      • [2020 EuroSys] AlloX: Compute Allocation in Hybrid Clusters
      • [2020 VLDB] PyTorch Distributed: Experiences on Accelerating Data Parallel Training
      • [2020 NetAI] Is Network the Bottleneck of Distributed Training?
      • [2020 NSDI] Themis: Fair and Efficient GPU Cluster Scheduling
      • [2021 MLSys] Accordion: Adaptive Gradient Communication via Critical Learning Regime Identification
      • [2021 VLDB] Analyzing and Mitigating Data Stalls in DNN Training
      • [2021 FAST] CheckFreq: Frequent, Fine-Grained DNN Checkpointing
      • [2021 EuroMLSys] Interference-Aware Scheduling for Inference Serving
      • [2021 OSDI] Pollux: Co-adaptive Cluster Scheduling for Goodput-Optimized Deep Learning
      • [2021 MLSys] Wavelet: Efficient DNN Training with Tick-Tock Scheduling
      • [2021 NSDI] SwitchML: Scaling Distributed Machine Learning with In-Network Aggregation
    • Big Data Systems - Index
      • Big Data Systems Papers - Short Notes
      • [2003 SOSP] The Google File System
      • [2004 OSDI] MapReduce: Simplified Data Processing on Large Clusters
      • [2010 SIGMOD] Pregel: A System for Large-Scale Graph Processing
      • [2011 NSDI] Mesos: A Platform for Fine-Grained Resource Sharing in the Data Center
      • [2012 NSDI] Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster ...
      • [2012 OSDI] PowerGraph: Distributed Graph-Parallel Computation on Natural Graphs
      • [2019 FAST] DistCache: Provable Load Balancing for Large-Scale Storage Systems with Distributed...
      • [2021 HotOS] From Cloud Computing to Sky Computing
      • [2021 EuroSys] NextDoor: Accelerating graph sampling for graph machine learning using GPUs
  • Earlier Readings & Notes
    • High Performance Computing Course Notes
      • Lecture 1: Course Overview
      • Lecture 2: From Code to Instructions. The FDX Cycle. Instruction Level Parallelism.
      • Lecture 3: Superscalar architectures. Measuring Computer Performance. Memory Aspects.
      • Lecture 4: The memory hierarchy. Caches.
      • Lecture 5: Caches, wrap up. Virtual Memory.
      • Lecture 6: The Walls to Sequential Computing. Moore’s Law.
      • Lecture 7: Parallel Computing. Flynn's Taxonomy. Amdahl's Law.
      • Lecture 8: GPU Computing Intro. The CUDA Programming Model. CUDA Execution Configuration.
      • Lecture 9: GPU Memory Spaces
      • Lecture 10: GPU Scheduling Issues.
      • Lecture 11: Execution Divergence. Control Flow in CUDA. CUDA Shared Memory Issues.
      • Lecture 12: Global Memory Access Patterns and Implications.
      • Lecture 13: Atomic operations in CUDA. GPU ode optimization rules of thumb.
      • Lecture 14: CUDA Case Studies. (1) 1D Stencil Operation. (2) Vector Reduction in CUDA.
      • Lecture 15: CUDA Case Studies. (3) Parallel Prefix Scan on the GPU. Using Multiple Streams in CUDA.
      • Lecture 16: Streams, and overlapping data copy with execution.
      • Lecture 17: GPU Computing: Advanced Features.
      • Lecture 18: GPU Computing with thrust and cub.
      • Lecture 19: Hardware aspects relevant in multi-core, shared memory parallel computing.
      • Lecture 20: Multi-core Parallel Computing with OpenMP. Parallel Regions.
      • Lecture 21: OpenMP Work Sharing.
      • Lecture 22: OpenMP Work Sharing
      • Lecture 23: OpenMP NUMA Aspects. Caching and OpenMP.
      • Lecture 24: Critical Thinking. Code Optimization Aspects.
      • Lecture 25: Computing with Supercomputers.
      • Lecture 26: MPI Parallel Programming General Introduction. Point-to-Point Communication.
      • Lecture 27: MPI Parallel Programming Point-to-Point communication: Blocking vs. Non-blocking sends.
      • Lecture 28: MPI Parallel Programming: MPI Collectives. Overview of topics covered in the class.
    • Cloud Computing Course Notes
      • 1.1 Introduction to Clouds, MapReduce
      • 1.2 Gossip, Membership, and Grids
      • 1.3 P2P Systems
      • 1.4 Key-Value Stores, Time, and Ordering
      • 1.5 Classical Distributed Algorithms
      • 4.1 Spark, Hortonworks, HDFS, CAP
      • 4.2 Large Scale Data Storage
    • Operating Systems Papers - Index
      • CS 736 @ UW-Madison Fall 2020 Reading List
      • All File Systems Are Not Created Equal: On the Complexity of Crafting Crash-Consistent Applications
      • ARC: A Self-Tuning, Low Overhead Replacement Cache
      • A File is Not a File: Understanding the I/O Behavior of Apple Desktop Applications
      • Biscuit: The benefits and costs of writing a POSIX kernel in a high-level language
      • Data Domain: Avoiding the Disk Bottleneck in the Data Domain Deduplication File System
      • Disco: Running Commodity Operating Systems on Scalable Multiprocessors
      • FFS: A Fast File System for UNIX
      • From WiscKey to Bourbon: A Learned Index for Log-Structured Merge Trees
      • LegoOS: A Disseminated, Distributed OS for Hardware Resource Disaggregation
      • LFS: The Design and Implementation of a Log-Structured File System
      • Lottery Scheduling: Flexible Proportional-Share Resource Management
      • Memory Resource Management in VMware ESX Server
      • Monotasks: Architecting for Performance Clarity in Data Analytics Frameworks
      • NFS: Sun's Network File System
      • OptFS: Optimistic Crash Consistency
      • RAID: A Case for Redundant Arrays of Inexpensive Disks
      • RDP: Row-Diagonal Parity for Double Disk Failure Correction
      • Resource Containers: A New Facility for Resource Management in Server Systems
      • ReVirt: Enabling Intrusion Analysis through Virtual-Machine Logging and Replay
      • Scheduler Activations: Effective Kernel Support for the User-Level Management of Parallelism
      • SnapMirror: File-System-Based Asynchronous Mirroring for Disaster Recovery
      • The Linux Scheduler: a Decade of Wasted Cores
      • The Unwritten Contract of Solid State Drives
      • Venti: A New Approach to Archival Storage
    • Earlier Notes
      • How to read a paper
  • FIXME
    • Template for Paper Reading Notes
Powered by GitBook
On this page
  • One-line Summary
  • Paper Structure Outline
  • Background & Motivation
  • Unpredictable Training Time
  • Over-Aggressive Job Consolidation
  • Preemption is Costly
  • Design and Implementation
  • Scheduling
  • Placement
  • Evaluation
  • New Vocabulary
  • Links

Was this helpful?

  1. Machine Learning Systems
  2. Machine Learning Systems - Index

[2019 NSDI] Tiresias: A GPU Cluster Manager for Distributed Deep Learning

One-line Summary

Tiresias is a cluster manager that uses (1) a Two-Dimensional Attained Service-Based Scheduler to minimize the average JCT and (2) a placement algorithm to relax the consolidation constraints for some models.

Paper Structure Outline

  1. Introduction

  2. Background and Motivation

    1. Distributed Deep Learning (DDL)

    2. Challenges

    3. Potential for Benefits

  3. Tiresias Design

    1. Overall Architecture

    2. Scheduling

      1. Why Two-Dimensional Scheduling?

      2. Two-Dimensional Attained Service-Based Scheduler (2DAS)

      3. Priority Discretization

    3. Placement

      1. Profiler

      2. The Placement Algorithm

    4. Summary

  4. Implementation

  5. Evaluation

    1. Experimental Setup

    2. Tiresias in Testbed Experiments

      1. JCT Improvements

      2. Cluster-Wide GPU Utilization

      3. Sources of Improvements

      4. Overheads

    3. Tiresias in Trace-Driven Simulations

      1. Simulator Fidelity

      2. JCT Improvements

    4. Sensitivity Analysis

      1. Impact of Queue Thresholds

      2. Impact of K (number of priority queues)

      3. Impact of PROMOTEKNOB

  6. Discussion and Future Work

  7. Related Work

  8. Conclusion

Background & Motivation

More and more deep learning jobs are being trained on GPU clusters. The design objectives of GPU managers include:

  1. Minimizing cluster-wide average job completion time (JCT)

  2. Achieve high resource (GPU) utilization

There are some challenges:

Unpredictable Training Time

Algorithms like SJF and SRTF (despite good in minimizing the avg. JCT) require the prior knowledge of a job's (remaining) execution time, which is often unknown for DL training jobs. Existing solutions include predicting the remaining execution time using the smooth loss curve. However, not all jobs have smooth loss curves & run to completion IRL. Thus, state-of-the-art managers are naive.

Over-Aggressive Job Consolidation

Existing cluster managers try to send jobs onto as few as possible number of servers to improve locality and reduce the network bottleneck. This leads to fragmented free GPUs in the cluster and longer queueing delays for jobs that require a large number of GPUs. In this work, the authors found that only some of the models have structures that are sensitive to placement.

Preemption is Costly

Existing clusters do not preempt jobs because of the large time overhead.

Design and Implementation

Tiresias addresses the two aforementioned issues by:

  1. Using an age-based scheduler to minimize JCT w/o complete knowledge of jobs

  2. Doing model profile-based placement to place jobs w/o additional information from users

A job lifecycle is as follows:

  • 1: As soon as a job is submitted, its GPU requirements are known, and the job is appended to a WAITQUEUE

  • 2: Scheduler

    • 2a: The scheduler schedules jobs from the WAITQUEUE

    • 2b: The scheduler preempts running jobs from the cluster to the WAITQUEUE

  • 3: The placement module accepts starting/resuming jobs for GPU allocation

  • 4: For new jobs, the profiler decides if they should be consolidated or not

Scheduling

In DDL job scheduling, both the spatial (#GPUs) and temporal (time) aspects of the jobs need to be considered. In Tiresias, the authors present a Two-Dimensional Attained Service-Based Scheduler (2DAS) that generalizes:

  1. The classic least-attained-services (LAS) scheduling discipline (2D-LAS)

  2. The Gittins index policy (2D-Gittins Index)

...to consider both spatial and temporal aspects of the jobs. LAS prefers jobs that received less service, while the Gittins index value represents how likely the job that has received some amount of service can complete within the next service quantum.

Priority Discretization

Using continuous priorities lead to preemptions and resumptions (which are costly), and continuous preemption degenerates 2DAS to fair sharing by time-division multiplexing. In Tiresias, a MLFQ is used for priority discretization.

Placement

The skew level of a model is a good predictor of whether a job benefits from consolidation, as the message size distribution depends on the tensor size distribution of the model. Observing the network communications sent out by the PS can inform us of the skew. The authors built a RDMA-level traffic monitoring tool for Tiresias as most production DL jobs use RDMA (e.g., InfiniBand in Microsoft) for PS-worker communication. The placement algorithm compares the model skew with a threshold, and if the skew is larger than the threshold, consolidation is performed.

Evaluation

New Vocabulary

  • SRSF (Shortest Remaining Service First): The multiplication of a job's remaining time and the number of GPUs.

  • Preemption: The act of temporarily interrupting a task being executed (w/o requiring its cooperation) and with the intention of resuming the task later. Such changes are known as context switches.

  • ILP formulation: The mathematical formulation of an optimization problem in which variables are restricted to integer values and the constraints and objective function are linear. Mixed integer linear programming (MILP) refers to optimization problems in which some of the variables are continuous.

Links

Previous[2019 ATC] Analysis of Large-Scale Multi-Tenant GPU Clusters for DNN Training WorkloadsNext[2019 SOSP] ByteScheduler: A Generic Communication Scheduler for Distributed DNN Training ...

Last updated 2 years ago

Was this helpful?

Apache Hadoop YARN
Paper PDF
Presentation video at NSDI '19
Presentation slides
Tiresias on GitHub
Xiangfeng Zhu's paper reading notes
[EuroSys 18'] Optimus: An Efficient Dynamic Resource Scheduler for Deep Learning Clusters
Expectation vs. reality. Here, job 2 gets terminated early.
Motivation: None of the existing solutions handles the two problems well!
Each job is assigned a priority based on its attained service. If no job duration information is provided, the LAS algorithm is applied where the priority is inverse to its attained service. If the distribution of job duration is provided, a job's priority equals its Gittins index value.
The avg JCTs are 9.3, 10, and 11.7 for SRSF, 2D-Gittins, and 2D-LAS. For a more detailed walkthrough of this example, see the NSDI presentation video.
K queues are maintained