LIFL: A Lightweight, Event-driven Serverless Platform for Federated Learning

Shixiong Qi, K. K. Ramakrishnan, Myungjin Lee

TL;DR

This paper introduces LIFL, a novel serverless platform designed to significantly improve the efficiency and speed of federated learning (FL) model aggregation. By leveraging eBPF, shared memory, and a hierarchical, event-driven architecture, LIFL drastically reduces resource consumption and aggregation latency compared to existing serverful and serverless FL systems.

What Problem Does This Paper Address?

Federated Learning (FL) enables collaborative model training across decentralized devices without centralizing raw data. A crucial step in FL is model aggregation, where updates from individual devices are combined to form a global model. Traditional FL systems often rely on always-on, serverful architectures for aggregation, which are inefficient in resource utilization and struggle to adapt to the dynamic nature of FL environments (varying numbers of devices, heterogeneous hardware). While serverless computing offers elasticity, existing serverless FL systems suffer from high overheads due to indirect networking, inefficient message queuing, and heavyweight sidecars. This paper addresses the need for a lightweight, elastic, and efficient serverless platform specifically optimized for FL model aggregation at scale.

Methods

LIFL introduces several key innovations:

  • Lightweight, Event-Driven Serverless Design: LIFL eliminates traditional message brokers and inefficient container-based sidecars. Instead, it uses eBPF-based proxies for event-driven processing, ensuring resource usage is truly load-proportional.
  • Shared Memory Processing: For aggregators co-located on the same node, LIFL utilizes shared memory for zero-copy communication, drastically reducing data plane overheads and avoiding kernel networking bottlenecks.
  • In-place Message Queuing: Model updates are buffered directly into shared memory, bypassing intermediate message queues and their associated delays.
  • Locality-Aware Placement: LIFL intelligently places aggregators to maximize the benefits of shared memory processing and minimize inter-node communication.
  • Hierarchy-Aware Autoscaling: The platform dynamically adjusts the aggregation hierarchy based on incoming load, optimizing parallelism and resource utilization.
  • Aggregator Runtime Reuse: LIFL reuses warm aggregator instances to mitigate cold-start delays, a common issue in serverless environments.
  • eBPF-based Sidecar: A lightweight eBPF sidecar is used for essential functions like metrics collection, attached directly to kernel hooks, avoiding dedicated resources.
  • Direct Routing: LIFL enables direct routing between aggregators, both within and across nodes, by leveraging eBPF's sockmap and gateways, bypassing traditional message brokers.

Datasets

The paper uses the following datasets for evaluation:

  • FEMNIST: Used for image classification tasks with ResNet models.
  • Non-IID datasets from FedScale: These datasets are used to simulate realistic client data distributions.

The paper does not introduce new benchmarks but evaluates LIFL against existing serverful and serverless FL systems using these standard datasets.

Key Insights and Ideas

  • The "serverless tax" is real, but manageable: While serverless platforms introduce their own overheads (e.g., gateways), LIFL demonstrates that these can be significantly lower than those in traditional serverful or less optimized serverless FL systems.
  • Shared memory is a game-changer for co-located aggregators: The ability to perform zero-copy communication between aggregators on the same node is a critical factor in achieving high performance for hierarchical aggregation.
  • Event-driven processing with eBPF is key to lightweight serverless: By moving critical data plane functions into eBPF, LIFL avoids the overhead of separate containers and achieves true on-demand resource utilization.
  • Orchestration matters as much as the data plane: LIFL's combination of locality-aware placement, hierarchy planning, and aggregator reuse significantly boosts performance beyond just an efficient data plane.
  • Eager aggregation is beneficial in serverless FL: By masking cold-start delays with model update transfers, eager aggregation can reduce overall aggregation completion time.

Key Results

LIFL demonstrates significant improvements across various metrics:

  • Latency Reduction:
    • 3x reduction compared to serverful systems.
  • 5.8x reduction compared to serverless systems (for intra-node data plane).
  • Achieves up to 2.1x additional latency reduction with locality-aware placement.
  • Resource Efficiency (CPU Cost):
    • 5x less CPU cost compared to existing serverless FL systems for a real FL workload.
  • 1.8x less CPU cost than serverful systems for ResNet-18.
  • 4.23x fewer CPU cycles for training ResNet-152.
  • Aggregation Speed (Time-to-Accuracy):
    • 2.7x reduction in time-to-accuracy for ResNet-18 compared to serverless systems.
  • 1.68x faster for ResNet-152 compared to serverless systems.
  • Model Update Transfer:
    • 2x and 6x higher latency for serverless systems compared to LIFL.
  • Significant CPU usage reduction for LIFL.

Limitations and Future Work

  • Synchronous FL: The current implementation of LIFL only supports synchronous FL. The authors mention that supporting asynchronous FL is a part of their future work.
  • Homogeneous Nodes: While the paper mentions that heterogeneous nodes might have varying MCi, the primary testbed used homogeneous nodes.
  • Future Work: The authors suggest that LIFL can be used as a representative case to guide the future development of other FL platforms. They also mention that supporting asynchronous FL is a future direction.

Summary updated

Abstract

Federated Learning (FL) typically involves a large-scale, distributed system with individual user devices/servers training models locally and then aggregating their model updates on a trusted central server. Existing systems for FL often use an always-on server for model aggregation, which can be inefficient in terms of resource utilization. They may also be inelastic in their resource management. This is particularly exacerbated when aggregating model updates at scale in a highly dynamic environment with varying numbers of heterogeneous user devices/servers. We present LIFL, a lightweight and elastic serverless cloud platform with fine-grained resource management for efficient FL aggregation at scale. LIFL is enhanced by a streamlined, event-driven serverless design that eliminates the individual heavy-weight message broker and replaces inefficient container-based sidecars with lightweight eBPF-based proxies. We leverage shared memory processing to achieve high-performance communication for hierarchical aggregation, which is commonly adopted to speed up FL aggregation at scale. We further introduce locality-aware placement in LIFL to maximize the benefits of shared memory processing. LIFL precisely scales and carefully reuses the resources for hierarchical aggregation to achieve the highest degree of parallelism while minimizing the aggregation time and resource consumption. Our experimental results show that LIFL achieves significant improvement in resource efficiency and aggregation speed for supporting FL at scale, compared to existing serverful and serverless FL systems.
BibTeX
@inproceedings{qi2024lifl,
  author = {Shixiong Qi and K. K. Ramakrishnan and Myungjin Lee},
  title = {{LIFL: A Lightweight, Event-driven Serverless Platform for Federated Learning}},
  booktitle = {MLSys},
  year = {2024},
  url = {https://openreview.net/forum?id=2JuKtVNTY0},
}
Figure