Change rapl reporter to timer based sleep

[ribalba]

In https://arxiv.org/abs/2401.15985 the authors argue that a sleep based solution is suboptimal:

When we implemented the tool, we found that using the sleep function in the polling loop was not reliable enough. The variations between each sleep were big enough to be detectable, and it was impossible to reliably reach a frequency of 1000 Hz.

When looking at the graph there seems to be some drift in measurements.

We use sleep in

green-metrics-tool/metric_providers/cpu/energy/rapl/msr/component/source.c

Line 446 in 7a0d9ea

usleep(msleep_time*1000);

We should change this to a timerfd timer to be more accurate.

This is quite low priority as we only allow sleeps in the ms scale so things should be fine.

[ArneTR]

That raises some intersting discussion points, therefore moved to discussions

[ArneTR]

Nice to see that it is apparently quite easy to implement a more accurate sleep.

The question that naturally arises for me:

• At what cost
• What is the benefit for us?

All of our reporters work by adding timestamps so even if they report instantaneous valeous the timespan is then respected and the calculations for power*time are made over a wider window.

In the case of RAPL it is even the case that the subsystem reports energy in the first place.

So the question is: what are we really gaining from removing the time jitter?
1 ms is anyway too high for hardcore profiling. And if you are anyway way above 1 ms it does not matter if the timer has jitter. or?

However something else caught my eye: Using perf-events is QUICKER than using MSR. I am shocked.
Also better maintainable as the kernel handles overflow and value conversion.

I would definitely vouch for a testing script that checks:

• Are values with perf-events better / less overhead / less overflows than our MSR implementation
• Also, once we are at it, see how much overhead the timerfd has (actually timerfd might not even be necessary, timer_set should work as well without filepointer)

Open for feedback :)

[ArneTR]

Source: https://github.com/TheElectronWill/cpu-energy-consumption-comparative-analysis/blob/master/rapl_probes/src/perf_event.rs

[ArneTR]

Also an addition: ChatGPT converted the Rust Code from the paper to C. This is the result for later use:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <linux/perf_event.h>
#include <errno.h>
#include <sys/syscall.h>

#define PERF_MAX_ENERGY UINT64_MAX

typedef struct {
    char* name;           // Name of the power event, corresponds to a RAPL domain name
    int domain;           // Domain as an enum (replace with your enum type)
    uint8_t code;         // Event code for perf_event_open
    char* unit;           // Should be "Joules"
    float scale;          // Scale to get joules (energy_j = count * scale)
} PowerEvent;

// A struct to hold the file descriptor and related event metadata
typedef struct {
    int fd;               // File descriptor returned by perf_event_open
    double scale;         // Scale factor for the event
    uint32_t socket;      // CPU socket
    int domain;           // Domain type (replace with your enum)
} OpenedPowerEvent;

// Function to open a perf event for the given event and CPU
int perf_event_open(PowerEvent* event, uint32_t pmu_type, uint32_t cpu_id) {
    struct perf_event_attr attr;
    memset(&attr, 0, sizeof(attr));
    
    attr.type = pmu_type;
    attr.size = sizeof(struct perf_event_attr);
    attr.config = event->code;

    int pid = -1;  // Monitor all processes
    int cpu = (int)cpu_id;  // Monitor the given CPU
    int group_fd = -1;  // No group monitoring
    int flags = 0;

    int fd = syscall(__NR_perf_event_open, &attr, pid, cpu, group_fd, flags);
    if (fd == -1) {
        perror("perf_event_open");
        return -1;
    }

    return fd;
}

// Function to retrieve the type of the RAPL PMU (Power Monitoring Unit) from the Linux kernel
uint32_t pmu_type() {
    FILE* file = fopen("/sys/devices/power/type", "r");
    if (!file) {
        perror("Failed to open power/type");
        return 0;
    }

    uint32_t type;
    if (fscanf(file, "%u", &type) != 1) {
        fprintf(stderr, "Failed to read PMU type\n");
        fclose(file);
        return 0;
    }

    fclose(file);
    return type;
}

// Function to read the perf event
uint64_t read_perf_event(int fd) {
    uint64_t buf;
    if (read(fd, &buf, sizeof(buf)) != sizeof(buf)) {
        perror("read_perf_event");
        return 0;
    }
    return buf;
}

// Structure for Energy Measurements (define this according to your needs)
typedef struct {
    // Implementation based on your Rust `EnergyMeasurements` struct
} EnergyMeasurements;

// Structure for PerfEventProbe (based on your Rust code)
typedef struct {
    EnergyMeasurements measurements;
    OpenedPowerEvent* events;
    size_t event_count;
} PerfEventProbe;

// Function to initialize a PerfEventProbe
PerfEventProbe* perf_event_probe_new(uint32_t* cpu_ids, size_t cpu_count, PowerEvent** events, size_t event_count) {
    PerfEventProbe* probe = malloc(sizeof(PerfEventProbe));
    if (!probe) {
        perror("malloc");
        return NULL;
    }

    probe->event_count = cpu_count * event_count;
    probe->events = malloc(probe->event_count * sizeof(OpenedPowerEvent));
    if (!probe->events) {
        perror("malloc");
        free(probe);
        return NULL;
    }

    uint32_t pmu_type_val = pmu_type();
    if (pmu_type_val == 0) {
        free(probe->events);
        free(probe);
        return NULL;
    }

    for (size_t i = 0; i < cpu_count; ++i) {
        uint32_t cpu_id = cpu_ids[i];
        for (size_t j = 0; j < event_count; ++j) {
            int fd = perf_event_open(events[j], pmu_type_val, cpu_id);
            if (fd == -1) {
                free(probe->events);
                free(probe);
                return NULL;
            }

            probe->events[i * event_count + j].fd = fd;
            probe->events[i * event_count + j].scale = events[j]->scale;
            probe->events[i * event_count + j].socket = i;  // Assuming socket == CPU index
            probe->events[i * event_count + j].domain = events[j]->domain;
        }
    }

    // Initialize EnergyMeasurements (use your own struct definition)
    // probe->measurements = energy_measurements_new();

    return probe;
}

// Function to poll energy measurements (based on your Rust poll function)
int perf_event_probe_poll(PerfEventProbe* probe) {
    for (size_t i = 0; i < probe->event_count; ++i) {
        OpenedPowerEvent* event = &probe->events[i];
        uint64_t counter_value = read_perf_event(event->fd);
        if (counter_value == 0) {
            return -1;
        }

        // Process the measurement and store it in probe->measurements
        // (This part depends on how you define EnergyMeasurements and the processing logic)
    }

    return 0;
}

// Clean up resources when done
void perf_event_probe_free(PerfEventProbe* probe) {
    for (size_t i = 0; i < probe->event_count; ++i) {
        close(probe->events[i].fd);
    }
    free(probe->events);
    free(probe);
}

int main() {
    // Example usage (fill in your CPU and event details)
    uint32_t cpu_ids[] = {0, 1};  // List of CPUs to monitor
    size_t cpu_count = sizeof(cpu_ids) / sizeof(cpu_ids[0]);

    PowerEvent event1 = {"pkg", 0, 0x01, "Joules", 1.0f};  // Example event
    PowerEvent* events[] = {&event1};
    size_t event_count = sizeof(events) / sizeof(events[0]);

    PerfEventProbe* probe = perf_event_probe_new(cpu_ids, cpu_count, events, event_count);
    if (probe) {
        if (perf_event_probe_poll(probe) == 0) {
            printf("Polling successful!\n");
        } else {
            printf("Polling failed!\n");
        }

        perf_event_probe_free(probe);
    }

    return 0;
}