Tutorial Control for Computing

Link to this page: https://tinyurl.com/CtrlComputing

Link to the slides: here

Introduction

This tutorial aims at introducing the tools and notions of the Control-Theory field to computer scientists, and relies on Jupyter notebooks, and is composed of two parts:

  • In the first part, attendees get familiar with the concepts, tools, and methodology of Control-Theory.

  • In the second part, attendees are given a pseudo-realistic system and have to design a controller to regulate its behavior.

Requirements

  • a recent web browser (Firefox 90+, Chromium 89+)

  • basic python knowledge

  • basic math knowledge is a plus

Start the tutorial here

Motivation

Motivation of Control for Computing

Computing systems are getting more and more complex.

The software stacks are growing, and are executed on top of complex hardware. The behavior of applications is thus becoming extremely difficult to predict, or model, correctly.

We need regulation to provide Quality-of-Service guarantees.

One approach is to have a theoretical model of the system and design complex algorithm based on this model. Such an approach is limited by the quality of the model. Modelling all the possible cases, and behaviors is tedious and error-prone.

A different approach to regulate the behavior of a computing system is to periodically take measurements of the system metrics, and adapt the input based on these measurements. This approach is called closed-loop, and this is the interest of the Autonomic Computing community.

There are several ways to adapt the input of the system. One can use ad-hoc solutions based on arbitrary rules or IA for example.

These solutions do not provide any proven guarantees on the closed-loop system. On the other hand, the Control Theory field has been applying math-proven methods to closed-loop physical systems for decades. But the application of Control Theory to computing systems is only quite recent.

One example is the one described by Cerf et al. in Sustaining performance while reducing energy consumption: a control theory approach. The motivation is the following: HPC applications are a succession of iterations that are composed of phases. These phases can be CPU-intensive, IO-intensive, memory-intensive, etc. During memory-intensive phases, for example, it is useless for the CPU to be at maximum frequency as it will be idle. Thus, one could decrease the CPU frequency of the compute node with RAPL technology to reduce its energy consumption. This decrease might introduce some overhead in the execution time of the application. The aforementioned paper performs an online regulation of compute node CPU frequency based on an accepted degradation given by the user.

The intuition is the following: If the application is running slower than desired (too much degradation), the CPU frequency is increased to meet user requirements. If the application is running faster than desired (too small degradation), the CPU frequency is decreased to reduce energy consumption.

This regulation was done using Control Theory tools and was showed to lead to significant energy saving with 10% degradation levels.

Motivation of this tutorial

We believe that numerous computing systems or applications could benefit from feedback loops architecture, and that tools from Control Theory provide interesting guarantees compared to other strategies (ad-hoc, AI, etc.).

This tutorial aims at introducing the attendees with Control Theory, and present the methodology through a practical example.

At the end of the tutorial, attendees will have:

  • Learned about Control Theory motivations and tools

  • Identified a model of a system

  • Designed a Proportional Controller, and understood its limitations

  • Designed a more complex controller: a Proportional-Integral Controller

Frequent Problems

The online Jupyter does not execute the notebooks

We are using a WebAssembly implementation of Jupyter to avoid having to manage a server. However, the WebAssembly technology is still young, and the version your browser might not be recent enough to run it.

Either you update your browser, or the simplest solution would be to download the notebooks and execute them on your own Jupyter instance.

Download the notebooks here

Publications

Here is a list of publications on the topic of Control for Computing:

Methodology

  • Hellerstein et al. Feedback control of computing systems, John Wiley & Sons, pdf

  • Filieri et al. Software engineering meets control theory, 2015 IEEE/ACM 10th International Symposium on Software Engineering for Adaptive and Self-Managing Systems, pdf

  • Filieri et al. Control Strategies for Self-Adaptive Software Systems, ACM Trans. Auton. Adapt. Syst. 11, 4 (2017), pdf

  • Litoiu et al. What can control theory teach us about assurances in self-adaptive software systems?, Springer Software Engineering for Self-Adaptive Systems III, pdf

  • Rutten et al. Feedback control as MAPE-K loop in autonomic computing, Springer Software engineering for self-adaptive systems 2017, pdf

Applications

  • Cerf et al. Sustaining Performance While Reducing Energy Consumption: A Control Theory Approach, EUROPAR 2021, pdf

  • Cerf et al. Cost function based event triggered Model Predictive Controllers application to Big Data Cloud services, CDC 2016, pdf

  • Guilloteau et al. Controlling the Injection of Best-Effort Tasks to Harvest Idle Computing Grid Resources, ICSTCC 2021, pdf

Sessions

This tutorial has been given at the following events:

Contacts

The authors of this tutorial are:

All the source code is available here.

Feel free to make contributions! :)