An autonomic operating system via applications monitoring and performance aware scheduling

The last decade signed a turning point in the way computing systems are engineered and built. The applications still require ever-increasing computing power and efficiency, but this cannot be achieved by just enhancing (e.g., by increasing the operating frequency) a well-established architecture, as it happened before. Even in embedded and mobile devices, the traditional architecture based on a single central processing unit is becoming obsolete in favor of multi-core architectures, where different processing cores are available for leveraging parallel computation. This change in the structure of the computing architectures from a centralized processing unit to several independent cores requires a reworking of the programming style needed to produce efficient and reliable applications for supporting the new architectures. Moreover, performance requirements (e.g., in terms of quality of service) and runtime bounds (e.g., limits on power consumption or working temperature) are more and more specific and demanding in a variety of scenarios (from cloud computing facilities to embedded and mobile devices). This situation makes it hard for application developers to retain, beyond the expertise in the specific domain of the application, also competence in tuning their software for the underlying architecture. A possibility for relieving this overburden from application developers is to devise computing systems equipped with the capability of adapting their structure and behavior to the needs of the running applications. System developers can create a low-level layer able to enhance the bare computing architecture with self-adaptive capabilities, enabling the computing system to both pursue the goal of maximum performance under any working conditions and maintain its status inside any wanted boundary (e.g. power consumption, system temperature, ...). A system capable of this behavior is named autonomic, or self-adaptive and researchers from computer science and control have gathered in an autonomic computing research community able to build innovation in the self-management of computing systems. The structure of almost all the modern computing systems can be divided in three main layers: the hardware components, the operating system and the applications. The hardware layer is quite heterogeneous and its components export very low-level interfaces that would be too complex to be directly used by the applications. The operating system takes care of managing the hardware layer and to export more suitable interfaces to the applications. The applications use the system resources exposed by the operating system to execute the tasks the system was built for. Since the operating system is the component that is in charge of managing the resources of the computing system, this is the first system layer that should be extended to enable the system towards an autonomic operation, as described above. To extend the concept of operating system in this direction, the current open loop operation mode must be changed to a closed loop control. In such control loop, monitors allow the system to gather knowledge about its status, a decision engine analyzes these data and evaluates possible actions that are provided by actuators that can alter the system status according to its needs. One of the operating system components which has a great impact on the runtime behavior of the overall system is the process scheduler. In fact, this is the component that decides how the processing capabilities offered by the underlying architecture are to be allotted to the running applications. This activity became fundamental when multitasking uniprocessor systems were introduced and has become even more important with the introduction of multicore and simultaneous multithreading enabled processors. The idea that gave birth to this thesis is to create a performance aware adaptive process scheduler able to take into account the current and desired performance of the running applications when deciding how to assign the computing resources. In order to realize this idea, the first step is to provide the operating system with a monitor to gather information on the current performance of the running applications and a means of defining performance goals for these applications. Then, it is necessary to determine a suitable way for acting on the scheduler and an adaptation policy able to take decisions about what actions are to be taken based on the current measured performance and the performance goals. The aim of the work presented in this thesis is to develop all of these steps, designing a methodology for enhancing a commodity operating system with self-adaptive capabilities and implementing a performance aware adaptive scheduler capable of taking into consideration the status of the system and the performance goals when deciding how to share the available computing resources among the running applications. More in details, the first contribution of this thesis is the formalization, by defining a suitable vocabulary and a methodology, of a high-level approach to the problem of enhancing a commodity operating system with autonomic capabilities. The work proposed in this thesis, however, goes beyond the mere formalization of a methodology by actually designing an autonomic operating system (named AcOS) and implementing it as an extension of the Linux kernel. The implementation is focused on the creation of the first two autonomic components in AcOS: a general-purpose software monitoring system, called ``Heart Rate Monitor'', and an extension to the process scheduler, named ``Performance-Aware Fair Scheduler'', which uses the monitor to bring performance-awareness into the scheduling decisions. The results of this implementation demonstrate that this approach is applicable and lay a base for future works focused on extending AcOS with more autonomic features.

Gli ultimi anni hanno rappresentato un punto di svolta nelle modalità di progettazione e costruzione dei sistemi di calcolo. Le applicazioni continuano a richiedere maggior potenza di calcolo ed efficienza, ma questi obiettivi non possono essere raggiunti sultanto migliorando (ad esempio, incrementandone la frequenza operativa) una stessa architettura di sistema, come è avvenuto per lungo tempo. Anche nei sistemi embedded e portatili, l'architettura di calcolo tradizionale, basata su una singola unità computazionale centrale, sta diventando obsoleta a favore di architetture multi-core, in cui diverse unità computazionali sono a disposizione, permettendo di sfruttare l'esecuzione di task paralleli. Questo cambiamento nella struttura delle architetture di calcolo da un processore centralizzato a un numero crescente di core indipendenti richiede un ripensamento dello stile di programmazione, per riuscire a scrivere applicazioni efficienti e affidabili in grado di sfruttare le nuove architetture. Inoltre, i requisiti in termini di prestazioni (ad esempio, a livello di qualità del servizio) e i limiti esterni (come limitazioni sul consumo di potenza o sulla massima temperatura raggiungibile) sono sempre più stringenti in un ampio ventaglio di scenari (dalle infrastrutture di cloud computing ai dispositivi mobili). Questa situazione rende difficile per gli sviluppatori applicativi, oltre che essere esperti nel loro specifico campo, rimanere anche aggiornati sulle competenze di sistema necessarie per essere in grado di ottimizzare il software per le architetture che vogliono supportare. Una possibilità per ridurre questo sovraccarico dagli sviluppatori di applicazioni, è creare sistemi di calcolo capaci di adattare la loro struttura e il loro comportamento alle necessità delle applicazioni. Gli sviluppatori di sistema possono realizzare uno strato software di basso livello capace di dare all'architettura di calcolo capacità di auto-adattamento, permettendo ai sistemi di calcolo di perseguire sia l'obiettivo di raggiungere massime prestazioni sotto diverse condizioni operative sia di mantenere il proprio stato all'interno di un confine desiderato (per esempio, in termini di consumo di potenza, temperature, ...). Un sistema capace di esibire questo comportamento è detto autonomico, o auto-adattativo e ricercatori con background in informatica e teoria del controllo si sono aggregati in una comunità di ricerca che si occupa di creare innovazione in termini di capacità dei sistemi di calcolo di auto-gestire i propri parametri di esecuzione. La struttura di quasi quasi tutti i moderni sistemi di calcolo può essere suddivisa in tre livelli principali: i componenti hardware, il sistema operativo e le applicazioni. Il livello dell'hardware è piuttosto eterogeneo e i suoi componenti sono raggiungibili attraverso interfacce di basso livello che sarebbe troppo complesso utilizzare direttamente. Il sistema operativo si occupa di gestire l'hardware ed esporre delle interfacce di più alto livello alle applicazioni. Le applicazioni utilizzano le astrazioni offerte dal sistema operativo per raggiungere gli obiettivi per cui il sistema di calcolo viene utilizzato. Poiché il sistema operativo è il componente che è incaricato di gestire le risorse di sistema, esso è il primo strato su cui si deve lavorare per permettere al sistema di ragggiungere caratteristiche autonomiche, come descritto sopra. Per estendere il concetto di sistema operativo in questa direzione, è necessario adottare un sistema di controllo basato su un anello in retroazione, all'interno del quale dei monitor raccolgano informazioni riguardo lo stato del sistema e il suo ambiente e dei motori decisionali siano in grado di analizzare questa conoscenza per mettere in atto azioni correttive per mantenere il sistema all'interno dello spazio di stato desiderato. Uno dei componenti del sistema operativo che ha maggior impatto sul comportamento a runtime di un sistema di calcolo è lo scheduler dei processi. Di fatto, lo scheduler è il componente che determina in che modo le capacità computazionali offerte dall'architettura di calcolo vengano assegnate alle applicazioni in esecuzione. Questo compito è diventato di grande importanza con il supporto del multitasking nei vecchi sistemi con singolo processore ed è diventato ancora più cruciale con l'introduzione di processori multicore e capaci di supportare più thread in parallelo (SMT). L'idea che ha dato origine a questa tesi è la creazione di uno scheduler capace di valutare le prestazioni delle applicazioni e di adattare le proprie decisioni basandosi sulle necessità, in termini di prestazioni desiderate, delle applicazioni stesse. Per realizzare questa idea, il primo passo è la creazione di un monitor per raccogliere le informazioni riguardo le prestazioni delle applicazioni e la definizione di una modalità per definire degli obiettivi prestazionali. In seguito, va determinata una politica di adattamento capace di confrontare le prestazioni misurate con quelle desiderate e di agire sullo scheduler modificandone le decisioni per permettere alle applicazioni di raggiungere gli obiettivi predefiniti. Lo scopo del lavoro prosentato in questa tesi è quello di sviluppare tutti questi passi, progettando una metodologia per dotare un sistema operativo di capacità di auto-adattamento e implementando uno scheduler adattativo capace di prendere in considerazione lo stato del sistema e gli obiettivi prestazionali della applicazioni nel decidere come assegnare alle applicazioni in esecuzione le risorse computazionali a disposizione. Più nel dettaglio, il primo contributo di questa tesi è la formalizzazione, attraverso la definizione di termini appropriati e di una metodologia, di un approccio di alto livello al problema di creare un sistema operativo autonomico migliorando quelli esistenti. Il lavoro proposto in questa tesi, però, non si limita a formalizzare e presentare la metodologia e va oltre, progettando un sistema operativo autonomico (denominato AcOS) e implementandolo come una estensione del kernel Linux. La fase implementativa è focalizzata sulla creazione dei primi due componenti autonomici di AcOS: una interfaccia di monitoring delle applicazioni, chiamata ``Heart Rate Monitor'' e una estensione dello scheduler, chiamata ``Performance-Aware Fair Scheduler'', che utilizza il monitor per modificare il meccanismo di scheduling a seconda delle prestazioni e degli obiettivi delle applicazioni. I risultati di questa implementazione dimostrano che l'approccio propost è realizzabile e pongono le basi per lavori futuri, che si focalizzeranno sull'estensione di AcOS con altre capacità autonomiche.