PREEMPT-RT —
Gerçek Zamanlı Linux.

# Mevcut RT kernel paketlerini listele
apt-cache search linux-image-rt

# Kur
sudo apt install linux-image-rt-amd64 linux-headers-rt-amd64

# Yeniden başlat ve RT kernel'i seç (GRUB menüsünde)
sudo reboot

# Doğrula
uname -a
# → Linux hostname 6.1.0-28-rt-amd64 #1 SMP PREEMPT_RT ...

# 1) Kernel kaynağını indir (örnek: 6.6.x)
wget https://cdn.kernel.org/pub/linux/kernel/v6.x/linux-6.6.30.tar.xz
tar xf linux-6.6.30.tar.xz
cd linux-6.6.30

# 2) Karşılık gelen RT patch'i indir
wget https://cdn.kernel.org/pub/linux/kernel/projects/rt/6.6/\
patch-6.6.30-rt30.patch.xz
xz -d patch-6.6.30-rt30.patch.xz

# 3) Patch'i uygula
patch -p1 < patch-6.6.30-rt30.patch

# 4) Mevcut konfigürasyondan başla
cp /boot/config-$(uname -r) .config
make olddefconfig

# 5) menuconfig ile PREEMPT_RT'yi aktif et
make menuconfig
# General Setup → Preemption Model → Fully Preemptible Kernel (Real-Time)

CONFIG_PREEMPT_RT=y          # Tam RT preemption
CONFIG_HZ_1000=y             # 1000 Hz tick — daha iyi resolüsyon
CONFIG_NO_HZ_FULL=y          # Tickless RT CPU'lar için
CONFIG_HIGH_RES_TIMERS=y     # Yüksek çözünürlüklü timer
CONFIG_CPU_ISOLATION=y       # isolcpus desteği
CONFIG_IKCONFIG_PROC=y       # /proc/config.gz — runtime doğrulama

# Kapatılması önerilen özellikler
# CONFIG_NUMA_BALANCING is not set
# CONFIG_TRANSPARENT_HUGEPAGE is not set  (jitter kaynağı)

# Çok çekirdekli derleme (-j ile)
make -j$(nproc) LOCALVERSION="-rt-custom"

# Modülleri kur
sudo make modules_install

# Kernel'i kur (GRUB otomatik güncellenir)
sudo make install

sudo reboot
uname -v
# → #1 SMP PREEMPT_RT Sat Apr 12 12:00:00 UTC 2025

# RPi OS (Bookworm) üzerinde
sudo apt install linux-image-rt-arm64   # RPi 4/5 için

# Veya rpi-rt kaynak fork'u ile çapraz derleme:
git clone --depth=1 -b rpi-6.6.y-rt \
  https://github.com/raspberrypi/linux rpi-rt-kernel

# Çapraz derleme toolchain
sudo apt install gcc-aarch64-linux-gnu

cd rpi-rt-kernel
ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- make bcm2711_defconfig
ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- make -j$(nproc)

# linux-yocto-rt recipe'sini kullan
PREFERRED_PROVIDER_virtual/kernel = "linux-yocto-rt"

# Kernel özelliğini etkinleştir
KERNEL_FEATURES:append = " features/preempt-rt/preempt-rt.scc"

# RT için önerilen ek konfigürasyon
KERNEL_EXTRA_FEATURES = "features/preempt-rt/preempt-rt.scc"

# rt-tests paketini kur
sudo apt install rt-tests

# Temel ölçüm: 4 thread, 100.000 iterasyon, 1ms periyot, RT prio 99
sudo cyclictest -p 99 -t 4 -n -i 1000 -l 100000

# CPU 2'ye affinity, quiet mod (yalnızca özet)
sudo cyclictest -p 99 -t 1 -n -i 1000 -l 1000000 -a 2 -q

# RT kernel üzerinde tipik çıktı:
T: 0 ( 1234) P:99 I:1000 C: 100000 Min:      3 Act:    7 Avg:    8 Max:     42
T: 1 ( 1235) P:99 I:1000 C: 100000 Min:      3 Act:    6 Avg:    8 Max:     38
T: 2 ( 1236) P:99 I:1000 C: 100000 Min:      4 Act:    9 Avg:    9 Max:     51

# Standart kernel (PREEMPT) üzerinde tipik çıktı:
T: 0 ( 5678) P:99 I:1000 C: 100000 Min:     12 Act:   85 Avg:   91 Max:   4821
T: 1 ( 5679) P:99 I:1000 C: 100000 Min:     11 Act:  120 Avg:  102 Max:   6340

# Histogram verisi üret (200 µs'ye kadar)
sudo cyclictest -p 99 -t 4 -n -i 1000 -l 1000000 \
  --histogram=200 --histfile=histogram.dat

# gnuplot ile görselleştir
cat > plot.gp <<'EOF'
set terminal png size 900,400
set output "latency.png"
set title "Latency Histogram — PREEMPT_RT"
set xlabel "Latency (µs)"
set ylabel "Occurrences"
set logscale y
plot "histogram.dat" using 1:2 with impulses lc rgb "#9ab6ff" title "CPU0", \
     "histogram.dat" using 1:3 with impulses lc rgb "#b07dcc" title "CPU1"
EOF
gnuplot plot.gp

#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

static pthread_mutex_t g_mutex;

void init_pi_mutex(void) {
    pthread_mutexattr_t attr;

    /* mutex attribute nesnesi oluştur */
    pthread_mutexattr_init(&attr);

    /* PTHREAD_PRIO_INHERIT: mutex bekleyen yüksek prio task varsa
       tutan task'ın prio'sunu geçici yükselt */
    pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);

    /* Mutex tipini ERRORCHECK yap (debug için) */
    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ERRORCHECK);

    pthread_mutex_init(&g_mutex, &attr);
    pthread_mutexattr_destroy(&attr);
}

int main(void) {
    init_pi_mutex();
    /* ... RT task'lar bu mutex'i kullanır ... */
    pthread_mutex_destroy(&g_mutex);
    return 0;
}

pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_CEILING);
/* Tavan: sistemi kullanan en yüksek RT prio + 1 */
pthread_mutexattr_setprioceiling(&attr, 91);
pthread_mutex_init(&g_mutex, &attr);

#define _GNU_SOURCE
#include <pthread.h>
#include <sched.h>
#include <sys/mman.h>
#include <string.h>
#include <time.h>
#include <stdio.h>
#include <errno.h>

#define PERIOD_NS     1000000LL   /* 1 ms */
#define RT_PRIORITY   90
#define STACK_PREFAULT (8 * 1024 * 1024)  /* 8 MB */

/* Zaman yardımcıları */
static inline void timespec_add_ns(struct timespec *ts, long long ns) {
    ts->tv_nsec += ns;
    while (ts->tv_nsec >= 1000000000LL) {
        ts->tv_sec++;
        ts->tv_nsec -= 1000000000LL;
    }
}

void *rt_task_func(void *arg) {
    struct timespec next;
    unsigned char stack_buf[STACK_PREFAULT];

    /* ── Adım 1: Stack prefault — page fault'ları RT döngüsü dışına al ── */
    memset(stack_buf, 0, sizeof(stack_buf));

    /* ── Adım 2: Scheduling policy ve öncelik ayarla ── */
    struct sched_param sp = { .sched_priority = RT_PRIORITY };
    if (pthread_setschedparam(pthread_self(), SCHED_FIFO, &sp) != 0) {
        perror("pthread_setschedparam");
        return NULL;
    }

    /* ── Adım 3: CPU affinity — bu thread'i CPU2'ye pinle ── */
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(2, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

    /* ── Adım 4: Başlangıç zamanı al ── */
    clock_gettime(CLOCK_MONOTONIC, &next);

    while (1) {
        /* Bir sonraki periyota ilerle */
        timespec_add_ns(&next, PERIOD_NS);

        /* Mutlak zamana kadar bekle (TIMER_ABSTIME: drift birikmez) */
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);

        /* ── Gerçek RT çalışma kodu buraya ── */
        do_control_loop();
    }
    return NULL;
}

int main(void) {
    /* ── Tüm memory'yi kilitle: page fault RT döngüsünde olmasın ── */
    if (mlockall(MCL_CURRENT | MCL_FUTURE) != 0) {
        perror("mlockall");
        return 1;
    }

    pthread_t tid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    /* Stack boyutunu büyüt */
    pthread_attr_setstacksize(&attr, 8 * 1024 * 1024);

    pthread_create(&tid, &attr, rt_task_func, NULL);
    pthread_join(tid, NULL);

    munlockall();
    return 0;
}

# /proc/interrupts: her CPU'da interrupt sayıları
cat /proc/interrupts | head -20

# IRQ kernel thread'lerini listele (irq/ prefix'i ile)
ps -eo pid,policy,rtprio,comm | grep "^.*irq"
# Örnek çıktı:
#  234 FF  50 irq/32-eth0
#  235 FF  50 irq/33-snd_hda
#  189 FF  50 irq/16-ehci_hcd

# Belirli IRQ'nun thread bilgisi
cat /proc/irq/32/sched

# IRQ thread PID'ini bul
IRQ_PID=$(ps -eo pid,comm | awk '/irq\/32-eth0/{print $1}')

# Priority'yi SCHED_FIFO:90 yap
sudo chrt -f -p 90 $IRQ_PID

# Veya doğrudan PID ile
sudo chrt -f -p 90 234

/* Legacy donanım: threaded IRQ istemiyoruz */
request_irq(irq_num, my_handler,
            IRQF_SHARED | IRQF_NO_THREAD,
            "my_legacy_device", dev);

/* Modern sürücü: threaded IRQ tercih edilir */
request_threaded_irq(irq_num,
    my_hardirq_handler,   /* top-half: hızlı, ACK yeterli */
    my_thread_handler,    /* bottom-half: thread içinde çalışır */
    IRQF_ONESHOT,
    "my_device", dev);

# CPU 2 ve 3'ü izole et (4 çekirdekli sistemde)
GRUB_CMDLINE_LINUX_DEFAULT="quiet isolcpus=2,3 nohz_full=2,3 rcu_nocbs=2,3"

# Değişikliği uygula
# sudo update-grub && sudo reboot

# Uygulamayı CPU 2'de başlat
sudo taskset -c 2 ./rt_app

# Çalışan process'in affinity'sini değiştir
sudo taskset -c 2,3 -p $PID

# Mevcut affinity'yi oku
taskset -c -p $PID

# cset kurulumu
sudo apt install cpuset

# RT shield oluştur: CPU 2,3 için (kthread'ler dahil)
sudo cset shield --cpu=2,3 --kthread=on

# RT uygulamayı shield içine al
sudo cset shield --exec ./rt_app

# Shield durumunu göster
sudo cset shield --shield

# Shield'i kaldır
sudo cset shield --reset

# IRQ 32'yi CPU 0 ve 1'e yönlendir (bitmask: 0x3 = CPU0+CPU1)
echo 3 | sudo tee /proc/irq/32/smp_affinity

# Tüm IRQ'ları CPU 0,1'e yönlendirmek için döngü
for irq in /proc/irq/[0-9]*/smp_affinity; do
    echo 3 | sudo tee $irq 2>/dev/null
done

# irqbalance servisini durdur (RT sistemde otomatik IRQ taşımasını kapat)
sudo systemctl stop irqbalance
sudo systemctl disable irqbalance

# rt-tests içinde gelir
sudo hwlatdetect --duration=60 --threshold=10

# Örnek çıktı — SMI yakalandıysa:
# hwlatdetect:  0 samples > threshold (10 us)
# hwlatdetect:  Maximum latency: 8.12 us

# SMI varsa:
# hwlatdetect:  3 samples > threshold (10 us)
# hwlatdetect:  Maximum latency: 47.3 us   ← BIOS SMI

# trace-cmd kur
sudo apt install trace-cmd

# RT process'in scheduling olaylarını kaydet (5 saniye)
sudo trace-cmd record -e sched_switch -P $RT_PID -s 5000 &
sudo ./rt_app &
wait

# Raporu görüntüle
trace-cmd report | head -50

TRACING=/sys/kernel/debug/tracing

# preemptirq latency tracer'ı etkinleştir
echo preemptirq | sudo tee $TRACING/current_tracer

# Latency eşiğini 50 µs olarak ayarla
echo 50 | sudo tee $TRACING/tracing_thresh

# Tracer'ı başlat
echo 1 | sudo tee $TRACING/tracing_on

# ... RT uygulamayı çalıştır ...

# Worst-case latency değerini oku
cat $TRACING/tracing_max_latency

# Trace verisini al (worst-case olayı içerir)
cat $TRACING/trace | head -100

# Tracer'ı sıfırla
echo nop | sudo tee $TRACING/current_tracer

GRUB_CMDLINE_LINUX_DEFAULT="quiet isolcpus=2 nohz_full=2 rcu_nocbs=2 \
  processor.max_cstate=1 intel_idle.max_cstate=0 \
  intel_pstate=disable cpufreq.default_governor=performance"

#define _GNU_SOURCE
#include <pthread.h>
#include <sched.h>
#include <sys/mman.h>
#include <time.h>
#include <stdio.h>
#include <string.h>
#include <stdint.h>

#define PERIOD_NS      1000000LL    /* 1 ms = 1 kHz */
#define RT_CPU         2
#define RT_PRIO        90
#define JITTER_LIMIT   100000LL     /* 100 µs worst-case hedef */
#define LOG_SIZE       10000

static long long jitter_log[LOG_SIZE];
static int       jitter_idx = 0;
static long long max_jitter = 0;

static inline long long ts_to_ns(const struct timespec *ts) {
    return (long long)ts->tv_sec * 1000000000LL + ts->tv_nsec;
}

void *motor_ctrl_thread(void *arg) {
    struct timespec now, next;
    unsigned char prefault_buf[1024 * 1024];

    /* Stack prefault */
    memset(prefault_buf, 0, sizeof(prefault_buf));

    /* SCHED_FIFO priority */
    struct sched_param sp = { .sched_priority = RT_PRIO };
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &sp);

    /* CPU affinity: sadece RT_CPU */
    cpu_set_t cpuset;
    CPU_ZERO(&cpuset);
    CPU_SET(RT_CPU, &cpuset);
    pthread_setaffinity_np(pthread_self(), sizeof(cpuset), &cpuset);

    /* Başlangıç zamanı */
    clock_gettime(CLOCK_MONOTONIC, &next);

    while (1) {
        /* Bir sonraki wake-up zamanı */
        long long target_ns = ts_to_ns(&next) + PERIOD_NS;
        next.tv_sec  = target_ns / 1000000000LL;
        next.tv_nsec = target_ns % 1000000000LL;

        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next, NULL);

        /* Gerçek wake-up zamanını ölç */
        clock_gettime(CLOCK_MONOTONIC, &now);
        long long actual_ns  = ts_to_ns(&now);
        long long jitter     = actual_ns - target_ns;
        if (jitter < 0) jitter = -jitter;

        /* Jitter log */
        if (jitter_idx < LOG_SIZE)
            jitter_log[jitter_idx++] = jitter;
        if (jitter > max_jitter) {
            max_jitter = jitter;
            if (jitter > JITTER_LIMIT)
                fprintf(stderr,
                    "[WARN] jitter = %lld ns (limit: %lld ns)\n",
                    jitter, JITTER_LIMIT);
        }

        /* ── Motor control loop ── */
        read_encoder();
        compute_pid();
        write_pwm();
    }
    return NULL;
}

int main(void) {
    if (mlockall(MCL_CURRENT | MCL_FUTURE)) {
        perror("mlockall"); return 1;
    }

    pthread_t tid;
    pthread_create(&tid, NULL, motor_ctrl_thread, NULL);
    pthread_join(tid, NULL);

    printf("Max jitter observed: %lld ns\n", max_jitter);
    munlockall();
    return 0;
}

# CPU, bellek ve I/O yükü oluştur
stress-ng --cpu 4 --io 2 --vm 1 --vm-bytes 256M &
STRESS_PID=$!

# RT uygulamayı çalıştır
sudo ./motor_control &
RT_PID=$!

# Aynı anda cyclictest ile bağımsız doğrulama
sudo cyclictest -p 85 -t 1 -a 2 -n -i 1000 -l 60000 -q

# Yükü durdur
kill $STRESS_PID