[PDS/HPDA Seminar] 17/2/2023 from 10:00 to 12:00 at 4A312 – Etienne Devaux (reading group), Thomas Collignon (reading group), Aleksandar Maksimovic (reading group) and Jana Toljaga (reading group)

During the PDS/HPDA Seminar of 17/2/2023 from 10:00 to 12:00, Etienne Devaux will present a reading group talk, Thomas Collignon will present a reading group talk, Aleksandar Maksimovic will present a reading group talk and Jana Toljaga will present a reading group talk.

Visio: https://webconf.imt.fr/frontend/fra-vcg-byn-fxd

Location: 4A312

# Reading group: Nightcore: efficient and scalable serverless computing for latency-sensitive, interactive microservices (ASPLOS’21)\n\nPresented by Etienne Devaux on 17/2/2023 at 10:00. Attending this presentation is mandatory for the master students.

Paper: https://dl.acm.org/doi/pdf/10.1145/3445814.3446701

Full post: https://www.inf.telecom-sudparis.eu/pds/seminars_cpt/reading-group-36/

## Abstract
The microservice architecture is a popular software engineering approach for building flexible, large-scale online services. Serverless functions, or function as a service (FaaS), provide a simple programming model of stateless functions which are a natural substrate for implementing the stateless RPC handlers of microservices, as an alternative to containerized RPC servers. However, current serverless platforms have millisecond-scale runtime overheads, making them unable to meet the strict sub-millisecond latency targets required by existing interactive microservices. We present Nightcore, a serverless function runtime with microsecond-scale overheads that provides container-based isolation between functions. Nightcore’s design carefully considers various factors having microsecond-scale overheads, including scheduling of function requests, communication primitives, threading models for I/O, and concurrent function executions. Nightcore currently supports serverless functions written in C/C++, Go, Node.js, and Python. Our evaluation shows that when running latency-sensitive interactive microservices, Nightcore achieves 1.36ל2.93× higher throughput and up to 69% reduction in tail latency.

# Reading group: AntMan: Dynamic Scaling on GPU Clusters for Deep Learning (OSDI’20)\n\nPresented by Thomas Collignon on 17/2/2023 at 10:30. Attending this presentation is mandatory for the master students.

Paper: https://www.usenix.org/system/files/osdi20-xiao.pdf

Full post: https://www.inf.telecom-sudparis.eu/pds/seminars_cpt/reading-group-37/

## Abstract
Efficiently scheduling deep learning jobs on large-scale GPU clusters is crucial for job performance, system throughput, and hardware utilization. It is getting ever more  challenging as deep learning workloads become more complex. This paper presents AntMan, a deep learning infrastructure that co-designs cluster schedulers with deep learning frameworks and has been deployed in production at Alibaba to manage tens of thousands of daily deep learning jobs across thousands of GPUs. AntMan accommodates the fluctuating resource demands of deep learning training jobs. As such, it utilizes the spare GPU resources to co-execute multiple jobs on a shared GPU. AntMan exploits unique characteristics of deep learning training to introduce dynamic scaling mechanisms for memory and computation within the deep learning frameworks. This allows fine-grained coordination between jobs and prevents job interference. Evaluations show that AntMan improves the overall GPU memory utilization by 42% and computation utilization by 34% in our multi-tenant cluster without compromising fairness, presenting a new approach to efficiently utilizing GPUs at scale.

# Reading group: Factored Operating Systems (fos): The Case for a Scalable Operating System for Multicores (SIGOPS OS Review’09)\n\nPresented by Aleksandar Maksimovic on 17/2/2023 at 11:00. Attending this presentation is mandatory for the master students.

Paper: https://www.princeton.edu/~wentzlaf/documents/Wentzlaff.2009.OSR.fos.pdf

Full post: https://www.inf.telecom-sudparis.eu/pds/seminars_cpt/reading-group-38/

## Abstract
The next decade will afford us computer chips with 100’s to 1,000’s of cores on a single piece of silicon. Contemporary operating systems have been designed to operate on a  single core or small number of cores and hence are not well suited to manage and provide operating system services at such large scale. If multicore trends continue, the number of cores that an operating system will be managing will continue to double every 18 months. The traditional evolutionary approach of redesigning OS subsystems when there is insufficient parallelism will cease to work because the rate of increasing parallelism will far outpace the rate at which OS designers will be capable of redesigning subsystems. The fundamental design of operating systems and operating system data structures must be rethought to put scalability as the prime design constraint. This work begins by documenting the scalability problems of contemporary operating systems. These studies are used to motivate the design of a factored operating system (fos). fos is a new operating system targeting manycore systems with scalability as the primary design constraint, where space sharing replaces time sharing to increase scalability. We describe fos, which is built in a message passing manner, out of a collection of Internet inspired services. Each operating system service is factored into a set of communicating servers which in aggregate implement a system service. These servers are designed much in the way that distributed Internet services are designed, but instead of providing high level Internet  services, these servers provide traditional kernel services and replace traditional kernel data structures in a factored, spatially distributed manner. fos replaces time sharing with space sharing. In other words, fos’s servers are bound to distinct processing cores and by doing so do not fight with end user applications for implicit resources such as TLBs and caches. We describe how fos’s design is well suited to attack the scalability challenge of future multicores and discuss how traditional application-operating systems interfaces can be redesigned to improve scalability.

# Reading group: Arrakis: The Operating System is the Control Plane (OSDI’14)\n\nPresented by Jana Toljaga on 17/2/2023 at 11:30. Attending this presentation is mandatory for the master students.

Paper: https://www.usenix.org/system/files/conference/osdi14/osdi14-paper-peter_simon.pdf

Full post: https://www.inf.telecom-sudparis.eu/pds/seminars_cpt/reading-group-32/

## Abstract
Recent device hardware trends enable a new approach to the design of network server operating systems. In a traditional operating system, the kernel mediates access to device hardware by server applications, to enforce process isolation as well as network and disk security. We have designed and implemented a new operating system, Arrakis, that splits the traditional role of the kernel in two. Applications have direct access to virtualized I/O devices, allowing most I/O operations to skip the kernel entirely, while the kernel is re-engineered to provide network and disk protection without kernel mediation of every operation. We describe the hardware and software changes needed to take advantage of this new abstraction, and we illustrate its power by showing improvements of 2-5Ă— in latency and 9Ă— in throughput for a popular persistent NoSQL store relative to a well-tuned Linux  implementation.