Light at the end of the SdV OS tunnel

Traditionally, operating systems, especially their kernel components, have played a pivotal role as an essential intermediary layer between application software and hardware. In this well-established configuration, a significant portion of CPU resources, approximately 20% on average, is allocated to the functioning of the OS kernel. However, these conventional OS designs can be limiting, particularly when dealing with I/O-intensive workloads. This limitation stems from the multifaceted nature of the kernel’s responsibilities, encompassing crucial functions like resource allocation, process management, memory management, I/O device oversight, process scheduling, system calls, and more.

A revolutionary paradigm shift in OS architecture, spearheaded by Dawson Engler and his team, revolves around the innovative concept of encapsulating application-specific OS services within a Library OS (LibOS) operating in user mode. This transformative approach facilitates the implementation of shared services, such as file systems, as shared servers, thereby departing from the traditional monolithic OS model of service versus server.

Unikernel, a relatively recent concept introduced around 2013 by Anil Madhavapeddy in his paper titled “Unikernels: Library Operating Systems for the Cloud,” represents a highly specialized iteration of LibOS. Unikernels are meticulously compiled alongside applications, resulting in a unified, streamlined binary that can be directly executed on bare-metal hardware.

The advantages of Library OS and Unikernels are numerous, including:

• Bolstered security achieved through a reduction in code footprint.
• Expedited boot times by minimizing superfluous code.
• The flexibility to select a LibOS that optimally implements system objects.
• Static resource allocation.

However, Unikernels come with certain limitations that warrant consideration:

• They are presently best suited for single microservices, sometimes referred to as servers, which might restrict their broader applicability.
• Debugging can present a substantial challenge due to the absence of traditional processes, potentially impeding their readiness for production use. It’s worth noting that this statement may no longer hold true with the development of debugging solutions (e.g., Unikraft’s debugging features).
• Current, comprehensive tooling, such as IDE support, is still evolving, although positive steps have been taken (e.g., the Unikraft KraftKit and VSCode IDE support).
• Careful selection of drivers is necessary for specific target environments.
• Particular configurations must be considered, especially when integrating with the Linux OS kernel. While Linux traditionally relies on a jiffy-based timer mechanism, which can be less precise, modern hardware supports high-resolution timers (HRTs) that offer microsecond-level accuracy. Configuration options like CONFIG_HIGH_RES_TIMERS enable these high-resolution timers, allowing for more accurate sleep and timer system calls.

#define _POSIX_C_SOURCE 199309L  // For high-resolution timers
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <pthread.h>
#include <time.h>

#define TIMER_INTERVAL_NS 100000000  // 100ms in nanoseconds

void timer_thread_handler(union sigval sv) {
    // This function is called when the timer expires
    printf("Timer triggered at %ld seconds %ld nanoseconds\n", sv.sival_int / 1000000000, sv.sival_int % 1000000000);
}

int main() {
    timer_t timerid;
    struct sigevent sev;
    struct itimerspec its;

    // Create a timer
    sev.sigev_notify = SIGEV_THREAD;
    sev.sigev_notify_function = timer_thread_handler;
    sev.sigev_value.sival_int = 0;

    if (timer_create(CLOCK_REALTIME, &sev, &timerid) == -1) {
        perror("timer_create");
        exit(EXIT_FAILURE);
    }

    // Set the timer to trigger at a fixed interval
    its.it_value.tv_sec = 0;
    its.it_value.tv_nsec = TIMER_INTERVAL_NS;
    its.it_interval.tv_sec = 0;
    its.it_interval.tv_nsec = TIMER_INTERVAL_NS;

    if (timer_settime(timerid, 0, &its, NULL) == -1) {
        perror("timer_settime");
        exit(EXIT_FAILURE);
    }

    // Keep the main thread alive
    pthread_exit(NULL);
}