From 3be71b43e43b0b9e2d5bdfde6292584d354a52ff Mon Sep 17 00:00:00 2001
From: Andrew <andreasohaodha@proton.me>
Date: Wed, 19 Mar 2025 09:42:07 +0000
Subject: [PATCH] [CT420]: Assignment 2 move benchmarks

---
 .../assignment2/code/benchmarks/bm1.c         | 104 ++++++++++++
 .../assignment2/code/benchmarks/bm2.c         | 106 ++++++++++++
 .../assignment2/code/benchmarks/merged        | Bin 0 -> 17168 bytes
 .../assignment2/code/benchmarks/merged.c      | 159 ++++++++++++++++++
 4 files changed, 369 insertions(+)
 create mode 100644 year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm1.c
 create mode 100644 year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm2.c
 create mode 100755 year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged
 create mode 100644 year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged.c

diff --git a/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm1.c b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm1.c
new file mode 100644
index 00000000..768981c2
--- /dev/null
+++ b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm1.c
@@ -0,0 +1,104 @@
+// Compile code with gcc -o bm1 bm1.c -lrt -Wall -O2
+// Execute code with sudo ./bm1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sched.h>
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+
+#define ITERATIONS 1000
+#define NS_PER_SEC 1000000000L
+
+volatile sig_atomic_t signal_received = 0;
+struct timespec start, end, sleep_time;
+
+void signal_handler(int signum) {
+    signal_received = 1;
+	clock_gettime(CLOCK_MONOTONIC, &end);
+}
+
+void configure_realtime_scheduling() {
+    struct sched_param param;
+    param.sched_priority = sched_get_priority_max(SCHED_FIFO);
+    if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
+        perror("sched_setscheduler");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void lock_memory() {
+    if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
+        perror("mlockall");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void benchmark_nanosleep() {
+    // struct timespec start, end, sleep_time;
+    long long total_jitter = 0;
+    long long max_jitter = 0;
+    long long min_jitter = LLONG_MAX;
+
+    sleep_time.tv_sec = 0;
+    sleep_time.tv_nsec = 1000000; // 1 ms
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        clock_gettime(CLOCK_MONOTONIC, &start);
+        nanosleep(&sleep_time, NULL);
+        clock_gettime(CLOCK_MONOTONIC, &end);
+
+        long long elapsed = (end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec);
+        long long jitter = elapsed - sleep_time.tv_nsec;
+
+        total_jitter += llabs(jitter);
+        if (jitter > max_jitter) max_jitter = jitter;
+        if (jitter < min_jitter) min_jitter = jitter;
+    }
+
+    printf("Nanosleep Benchmark:\n");
+    printf("Average jitter: %lld ns\n", total_jitter / ITERATIONS);
+    printf("Max jitter: %lld ns\n", max_jitter);
+    printf("Min jitter: %lld ns\n", min_jitter);
+}
+
+void benchmark_signal_latency() {
+    long long total_latency = 0;
+    long long max_latency = 0;
+    long long min_latency = LLONG_MAX;
+
+    signal(SIGUSR1, signal_handler);
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        clock_gettime(CLOCK_MONOTONIC, &start);
+        kill(getpid(), SIGUSR1);
+        while (!signal_received);
+
+        long long latency = (end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec);
+        total_latency += latency;
+        if (latency > max_latency) max_latency = latency;
+        if (latency < min_latency) min_latency = latency;
+
+        signal_received = 0;
+    }
+
+    printf("\nSignal Latency Benchmark:\n");
+    printf("Average latency: %lld ns\n", total_latency / ITERATIONS);
+    printf("Max latency: %lld ns\n", max_latency);
+    printf("Min latency: %lld ns\n", min_latency);
+}
+
+int main() {
+    configure_realtime_scheduling();
+    lock_memory();
+
+    benchmark_nanosleep();
+    benchmark_signal_latency();
+
+    return 0;
+}
\ No newline at end of file
diff --git a/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm2.c b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm2.c
new file mode 100644
index 00000000..7e06f2d7
--- /dev/null
+++ b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/bm2.c
@@ -0,0 +1,106 @@
+// Compile code with gcc -o bm2 bm2.c -lrt -Wall -O2
+// Execute code with sudo ./bm2
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sched.h>
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+
+#define ITERATIONS 1000
+#define NS_PER_SEC 1000000000L
+
+timer_t timer_id;
+volatile sig_atomic_t timer_expired = 0;
+struct timespec start, end;
+
+void timer_handler(int signum) {
+    timer_expired = 1;
+    clock_gettime(CLOCK_MONOTONIC, &end);
+}
+
+void configure_realtime_scheduling() {
+    struct sched_param param;
+    param.sched_priority = sched_get_priority_max(SCHED_FIFO);
+    if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
+        perror("sched_setscheduler");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void lock_memory() {
+    if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
+        perror("mlockall");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void benchmark_timer() {
+    long long total_jitter = 0;
+    long long max_jitter = 0;
+    long long min_jitter = LLONG_MAX;
+
+    struct sigevent sev;
+    sev.sigev_notify = SIGEV_SIGNAL;
+    sev.sigev_signo = SIGRTMIN;
+    sev.sigev_value.sival_ptr = &timer_id;
+
+    if (timer_create(CLOCK_MONOTONIC, &sev, &timer_id) == -1) {
+        perror("timer_create");
+        exit(EXIT_FAILURE);
+    }
+
+    struct itimerspec its;
+    its.it_value.tv_sec = 0;
+    its.it_value.tv_nsec = 1000000; // 1 ms
+    its.it_interval = its.it_value;
+
+    signal(SIGRTMIN, timer_handler);
+
+    if (timer_settime(timer_id, 0, &its, NULL) == -1) {
+        perror("timer_settime");
+        exit(EXIT_FAILURE);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    for (int i = 0; i < ITERATIONS; i++) {
+        // while (!timer_expired);
+
+        while (!timer_expired) {
+            struct timespec ts = {0, 100};
+            nanosleep(&ts, NULL);
+        }
+
+        clock_gettime(CLOCK_MONOTONIC, &end);
+
+        long long elapsed = (end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec);
+        long long jitter = elapsed - its.it_interval.tv_nsec;
+
+        total_jitter += llabs(jitter);
+        if (jitter > max_jitter) max_jitter = jitter;
+        if (jitter < min_jitter) min_jitter = jitter;
+
+        timer_expired = 0;
+        start = end;
+    }
+
+    printf("\nTimer Benchmark:\n");
+    printf("Average jitter: %lld ns\n", total_jitter / ITERATIONS);
+    printf("Max jitter: %lld ns\n", max_jitter);
+    printf("Min jitter: %lld ns\n", min_jitter);
+
+    timer_delete(timer_id);
+}
+
+int main() {
+    configure_realtime_scheduling();
+    lock_memory();
+
+    benchmark_timer();
+
+    return 0;
+}
diff --git a/year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged
new file mode 100755
index 0000000000000000000000000000000000000000..b3355225f2115c2b7e1287e5b57399bc8c2a9f6a
GIT binary patch
literal 17168
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
Ku5l<hSn=Q9e70l&

literal 0
HcmV?d00001

diff --git a/year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged.c b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged.c
new file mode 100644
index 00000000..016e5dd1
--- /dev/null
+++ b/year4/semester2/CT420/assignments/assignment2/code/benchmarks/merged.c
@@ -0,0 +1,159 @@
+// Compile code with gcc -o bm1 bm1.c -lrt -Wall -O2
+// Execute code with sudo ./bm1
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#include <sched.h>
+#include <errno.h>
+#include <string.h>
+#include <limits.h>
+
+#define ITERATIONS 10000
+#define NS_PER_SEC 1000000000L
+
+timer_t timer_id;
+volatile sig_atomic_t timer_expired = 0;
+volatile sig_atomic_t signal_received = 0;
+struct timespec start, end, sleep_time;
+
+void save_results(const char *filename, long long *data) {
+    FILE *file = fopen(filename, "w");
+    if (!file) {
+        perror("fopen");
+        exit(EXIT_FAILURE);
+    }
+    fprintf(file, "Iteration,Latency/Jitter (ns)\n");
+    for (int i = 0; i < ITERATIONS; i++) {
+        fprintf(file, "%d,%lld\n", i, data[i]);
+    }
+    fclose(file);
+}
+
+void signal_handler(int signum) {
+    signal_received = 1;
+	clock_gettime(CLOCK_MONOTONIC, &end);
+}
+
+void timer_handler(int signum) {
+    timer_expired = 1;
+    clock_gettime(CLOCK_MONOTONIC, &end);
+}
+
+void configure_realtime_scheduling() {
+    struct sched_param param;
+    param.sched_priority = sched_get_priority_max(SCHED_FIFO);
+    if (sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
+        perror("sched_setscheduler");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void lock_memory() {
+    if (mlockall(MCL_CURRENT | MCL_FUTURE) == -1) {
+        perror("mlockall");
+        exit(EXIT_FAILURE);
+    }
+}
+
+void benchmark_nanosleep() {
+    long long jitter_data[ITERATIONS];
+    sleep_time.tv_sec = 0;
+    sleep_time.tv_nsec = 1000000; // 1 ms
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        clock_gettime(CLOCK_MONOTONIC, &start);
+        nanosleep(&sleep_time, NULL);
+        clock_gettime(CLOCK_MONOTONIC, &end);
+
+        jitter_data[i] = ((end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec)) - sleep_time.tv_nsec;
+    }
+    save_results("nanosleep.csv", jitter_data);
+}
+
+void benchmark_signal_latency() {
+    long long latency_data[ITERATIONS];
+    signal(SIGUSR1, signal_handler);
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        clock_gettime(CLOCK_MONOTONIC, &start);
+        kill(getpid(), SIGUSR1);
+        while (!signal_received);
+
+        latency_data[i] = (end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec);
+        signal_received = 0;
+    }
+    save_results("signal_latency.csv", latency_data);
+}
+
+void benchmark_timer() {
+    long long jitter_data[ITERATIONS];
+    struct sigevent sev;
+    sev.sigev_notify = SIGEV_SIGNAL;
+    sev.sigev_signo = SIGRTMIN;
+    sev.sigev_value.sival_ptr = &timer_id;
+
+    if (timer_create(CLOCK_MONOTONIC, &sev, &timer_id) == -1) {
+        perror("timer_create");
+        exit(EXIT_FAILURE);
+    }
+
+    struct itimerspec its;
+    its.it_value.tv_sec = 0;
+    its.it_value.tv_nsec = 1000000; // 1 ms
+    its.it_interval = its.it_value;
+    signal(SIGRTMIN, timer_handler);
+
+    if (timer_settime(timer_id, 0, &its, NULL) == -1) {
+        perror("timer_settime");
+        exit(EXIT_FAILURE);
+    }
+    clock_gettime(CLOCK_MONOTONIC, &start);
+    for (int i = 0; i < ITERATIONS; i++) {
+        while (!timer_expired) {
+            struct timespec ts = {0, 100};
+            nanosleep(&ts, NULL);
+        }
+
+        clock_gettime(CLOCK_MONOTONIC, &end);
+        jitter_data[i] = ((end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec)) - its.it_interval.tv_nsec;
+        timer_expired = 0;
+        start = end;
+    }
+    save_results("timer.csv", jitter_data);
+}
+
+void benchmark_usleep() {
+    long long jitter_data[ITERATIONS];
+
+    for (int i = 0; i < ITERATIONS; i++) {
+        clock_gettime(CLOCK_MONOTONIC, &start);
+        usleep(1000); // 1 ms
+        clock_gettime(CLOCK_MONOTONIC, &end);
+
+        jitter_data[i] = ((end.tv_sec - start.tv_sec) * NS_PER_SEC + (end.tv_nsec - start.tv_nsec)) - 1000000;
+    }
+    save_results("usleep.csv", jitter_data);
+}
+
+int main() {
+    configure_realtime_scheduling();
+    lock_memory();
+
+    printf("Getting nanosleep benchmark\n");
+    benchmark_nanosleep();
+
+    printf("Getting signal benchmark\n");
+    benchmark_signal_latency();
+
+    printf("Getting timer benchmark\n");
+    benchmark_timer();
+
+    printf("Getting usleep benchmark\n");
+    benchmark_usleep();
+
+    return 0;
+}