Un proces periodic rulează corect de mii de ori, apoi întârzie brusc cu câteva milisecunde. Media rămâne bună, însă aplicația audio, controlerul industrial sau serviciul de tranzacționare observă exact vârful pe care un benchmark obișnuit îl ascunde.
În acest laborator vom produce controlat un asemenea vârf pe CPU 2, îl vom clasifica prin osnoise, apoi vom folosi timerlat pentru a păstra urma care indică procesul responsabil. La final rămân un serviciu de test limitat, un diagnostic automat, jurnale rotite și un timer systemd pentru verificări periodice.
Laboratorul este destinat exclusiv unui server de test cu cel puțin patru procesoare logice. Generatorul folosește temporar politica SCHED_FIFO cu prioritate ridicată; nu îl porni pe un sistem de producție și nu îl muta pe CPU 0.
Rezultatul urmărit: un vârf controlat și numele procesului care l-a produs
Vom instala pe Ubuntu Server 24.04 LTS un program numit jitter-pulse. Acesta doarme aproximativ 100 ms, apoi ocupă CPU 2 timp de aproximativ 2 ms. Serviciul systemd îi aplică politica SCHED_FIFO, prioritatea 98 și afinitatea la un singur CPU.
Diagnosticul rulează două măsurători succesive:
rtla osnoise toparată că CPU 2 acumulează zgomot atribuit execuției altui thread;rtla timerlat topfolosește pragul automat de 500 µs și păstrează urma în care aparejitter-pulse;- scriptul scrie rezultatele în
/var/log/latency-lab; - dacă numele generatorului apare în captura
timerlat, este creat fișierulALERTși este emis un mesaj în jurnal.
osnoise și timerlat nu răspund la aceeași întrebare. Primul separă timpul consumat de NMI, IRQ, softirq și thread-uri. Al doilea urmărește latența dintre expirarea timerului, handlerul IRQ și trezirea threadului periodic. Împreună permit trecerea de la „există jitter” la „această activitate a întârziat threadul măsurat”.
Pentru analiza detaliată a funcțiilor kernelului după identificarea evenimentului, continuarea firească este urmărirea latenței cu function_graph tracer. Dacă vârful coincide cu operații de disc, diagnosticul trebuie corelat separat cu iostat, pidstat, blktrace și PSI.
Fixăm laboratorul la CPU 2 și la un kernel cu tracerele necesare
Configurația folosită este:
- Ubuntu Server 24.04 LTS;
- kernel generic Ubuntu din seria 6.8, împreună cu pachetul
linux-toolscorespunzător exact kernelului pornit; rtlafurnizat de pachetul Ubuntu pentru acel kernel;systemddin Ubuntu 24.04;- minimum patru procesoare logice;
- aproximativ 100 MB liberi;
- acces administrativ prin
sudo; - 15-20 de minute pentru instalare și test.
Versiunea completă a kernelului depinde de actualizările instalate. Nu combina binarul rtla al altui kernel cu sistemul curent. Verifică mediul înainte să creezi serviciile:
cat /etc/os-release
uname -r
nproc
rtla version 2>/dev/null || true
systemd-analyze --version | head -n 1
gcc --version | head -n 1
grep -E 'CONFIG_(OSNOISE_TRACER|TIMERLAT_TRACER)=' "/boot/config-$(uname -r)"
grep -wE 'osnoise|timerlat' /sys/kernel/tracing/available_tracers
Un exemplu de rezultat compatibil este:
NAME="Ubuntu"
VERSION="24.04 LTS (Noble Numbat)"
6.8.0-xx-generic
4
CONFIG_OSNOISE_TRACER=y
CONFIG_TIMERLAT_TRACER=y
timerlat osnoise
Numărul de revizie xx, versiunea exactă rtla și ordinea tracerelor pot diferi. Condițiile obligatorii sunt existența CPU 2 și prezența cuvintelor osnoise și timerlat în available_tracers.
Dacă /sys/kernel/tracing nu este montat, montează tracefs, apoi repetă ultima verificare:
sudo mount -t tracefs nodev /sys/kernel/tracing
Instalarea rămâne într-un singur bloc. Pachetul construit pentru uname -r evită nealinierea dintre kernel și uneltele sale:
sudo apt update
sudo apt install -y
build-essential
linux-tools-common
"linux-tools-$(uname -r)"
util-linux
logrotate
command -v rtla
command -v gcc
command -v flock
Outputul așteptat pentru ultimele comenzi conține căile executabilelor, de regulă:
/usr/bin/rtla
/usr/bin/gcc
/usr/bin/flock
Punct de control: dacă pachetul linux-tools-$(uname -r) nu există, sistemul rulează probabil un kernel din alt depozit sau unul pentru care nu sunt instalate uneltele potrivite; nu continua până când kernelul și pachetul linux-tools nu provin din aceeași sursă.
Cele șapte fișiere separă interferența, măsurarea și retenția
Proiectul va avea această structură:
/usr/local/src/latency-lab/
└── jitter-pulse.c generatorul periodic, limitat la 2 ms
/usr/local/libexec/latency-lab/
├── jitter-pulse binarul compilat
└── run-diagnostic.sh rulează osnoise și timerlat succesiv
/etc/systemd/system/
├── latency-jitter.service aplică CPUAffinity și SCHED_FIFO generatorului
├── latency-diagnostic.service lansează măsurarea cu privilegii administrative
└── latency-diagnostic.timer programează verificarea periodică
/etc/logrotate.d/
└── latency-lab comprimă și limitează istoricul
Datele rezultate apar în subdirectoare cu marcaj temporal din /var/log/latency-lab. Generatorul rulează ca utilizatorul fără login latnoise; numai diagnosticul rulează ca root, deoarece rtla trebuie să configureze tracerele kernelului.
Pasul 1 — Compilăm un generator periodic care cedează CPU-ul după 2 ms
Programul trebuie să producă o interferență măsurabilă fără o buclă infinită care monopolizează complet procesorul. El folosește somn absolut pe ceasul CLOCK_MONOTONIC, apoi execută o buclă ocupată până la expirarea ferestrei de 2 ms.
Avertisment: serviciul va primi ulterior prioritatea real-time 98. Folosește numai CPU 2 al serverului de test și păstrează o sesiune administrativă deschisă pe alt CPU.
Creează utilizatorul, directoarele și fișierul /usr/local/src/latency-lab/jitter-pulse.c:
sudo useradd --system --no-create-home --shell /usr/sbin/nologin latnoise 2>/dev/null || true
sudo install -d -m 0755 /usr/local/src/latency-lab
sudo install -d -m 0755 /usr/local/libexec/latency-lab
sudo install -d -m 0750 /var/log/latency-lab
sudo tee /usr/local/src/latency-lab/jitter-pulse.c >/dev/null <<'EOF'
#define _GNU_SOURCE
#include <errno.h>
#include <signal.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/prctl.h>
#include <time.h>
#include <unistd.h>
static volatile sig_atomic_t keep_running = 1;
static void stop_handler(int signo)
{
(void)signo;
keep_running = 0;
}
static int64_t to_ns(const struct timespec *value)
{
return (int64_t)value->tv_sec * 1000000000LL + value->tv_nsec;
}
static struct timespec from_ns(int64_t value)
{
struct timespec result;
result.tv_sec = value / 1000000000LL;
result.tv_nsec = value % 1000000000LL;
return result;
}
int main(void)
{
const int64_t period_ns = 100000000LL;
const int64_t busy_ns = 2000000LL;
struct timespec wake;
struct timespec now;
int sleep_result;
if (signal(SIGTERM, stop_handler) == SIG_ERR ||
signal(SIGINT, stop_handler) == SIG_ERR) {
perror("signal");
return EXIT_FAILURE;
}
if (prctl(PR_SET_NAME, "jitter-pulse", 0, 0, 0) == -1) {
perror("prctl");
return EXIT_FAILURE;
}
if (clock_gettime(CLOCK_MONOTONIC, &wake) == -1) {
perror("clock_gettime");
return EXIT_FAILURE;
}
fprintf(stdout, "jitter-pulse: period=100000us busy=2000usn");
fflush(stdout);
while (keep_running) {
wake = from_ns(to_ns(&wake) + period_ns);
do {
sleep_result = clock_nanosleep(
CLOCK_MONOTONIC,
TIMER_ABSTIME,
&wake,
NULL
);
} while (sleep_result == EINTR && keep_running);
if (sleep_result != 0 && sleep_result != EINTR) {
errno = sleep_result;
perror("clock_nanosleep");
return EXIT_FAILURE;
}
if (!keep_running) {
break;
}
if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) {
perror("clock_gettime");
return EXIT_FAILURE;
}
{
const int64_t busy_until = to_ns(&now) + busy_ns;
do {
if (clock_gettime(CLOCK_MONOTONIC, &now) == -1) {
perror("clock_gettime");
return EXIT_FAILURE;
}
} while (keep_running && to_ns(&now) < busy_until);
}
}
return EXIT_SUCCESS;
}
EOF
sudo gcc
-O2
-Wall
-Wextra
-Werror
-std=c11
/usr/local/src/latency-lab/jitter-pulse.c
-o /usr/local/libexec/latency-lab/jitter-pulse
sudo chown root:root /usr/local/libexec/latency-lab/jitter-pulse
sudo chmod 0755 /usr/local/libexec/latency-lab/jitter-pulse
TIMER_ABSTIME împiedică acumularea erorilor de perioadă: următoarea trezire rămâne raportată la calendarul monoton, nu la momentul în care s-a terminat iterația precedentă. Cele două valori sunt fixe tocmai pentru ca laboratorul să aibă o singură configurație reproductibilă.
Verifică binarul fără prioritate real-time:
timeout --signal=TERM 1s /usr/local/libexec/latency-lab/jitter-pulse
Exemplul de output este:
jitter-pulse: period=100000us busy=2000us
Punct de control: dacă compilarea eșuează, nu relaxa opțiunile -Werror; mesajul compilatorului trebuie rezolvat înainte ca binarul să fie instalat ca serviciu privilegiat de scheduler.
Pasul 2 — Izolăm generatorul pe CPU 2 și îi limităm privilegiile
Fișierul /etc/systemd/system/latency-jitter.service stabilește afinitatea și politica de scheduling înainte de lansarea procesului:
[Unit]
Description=Controlled latency jitter generator for CPU 2
Documentation=https://docs.kernel.org/trace/osnoise-tracer.html
ConditionPathIsExecutable=/usr/local/libexec/latency-lab/jitter-pulse
[Service]
Type=simple
User=latnoise
Group=latnoise
ExecStart=/usr/local/libexec/latency-lab/jitter-pulse
Restart=on-failure
RestartSec=2s
CPUAffinity=2
CPUSchedulingPolicy=fifo
CPUSchedulingPriority=98
LimitRTPRIO=98
Nice=-20
NoNewPrivileges=yes
PrivateTmp=yes
PrivateDevices=yes
ProtectSystem=strict
ProtectHome=yes
ProtectControlGroups=yes
ProtectKernelModules=yes
ProtectKernelTunables=yes
RestrictAddressFamilies=AF_UNIX
LockPersonality=yes
MemoryDenyWriteExecute=yes
[Install]
WantedBy=multi-user.target
Aplică unitatea și pornește generatorul numai după ce confirmi că CPU 2 este online:
test -d /sys/devices/system/cpu/cpu2
grep -qw 2 /sys/devices/system/cpu/online || grep -qw '0-3' /sys/devices/system/cpu/online
sudo systemctl daemon-reload
sudo systemctl start latency-jitter.service
systemctl --no-pager --full status latency-jitter.service
ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse'
CPUAffinity=2 împiedică generatorul să migreze. CPUSchedulingPriority=98 îl plasează deasupra threadului timerlat folosit în mod uzual pentru măsurare, iar NoNewPrivileges=yes împiedică procesul să obțină ulterior privilegii noi. Setările de protecție sunt posibile deoarece generatorul nu citește configurația kernelului și nu scrie fișiere.
Outputul ps trebuie să arate clasa FF, prioritatea real-time 98, procesorul 2 și numele jitter-pulse:
PID TID CLS RTPRIO PSR COMMAND
... ... FF 98 2 jitter-pulse
PID-ul diferă la fiecare pornire.
Punct de control: dacă PSR nu este 2 sau CLS nu este FF, oprește serviciul și inspectează journalctl -u latency-jitter.service; măsurarea nu mai testează scenariul definit aici.
Pasul 3 — Legăm clasificarea osnoise de captura timerlat
osnoise rulează primul pentru a confirma categoria interferenței. timerlat rulează apoi cu prag automat de 500 µs, suficient de mic față de pulsul controlat de aproximativ 2 ms. Cele două nu sunt lansate simultan, deoarece ambele configurează infrastructura globală de tracing.
Fișierul complet /usr/local/libexec/latency-lab/run-diagnostic.sh este:
#!/usr/bin/env bash
set -euo pipefail
readonly CPU=2
readonly THRESHOLD_US=500
readonly OUTPUT_ROOT=/var/log/latency-lab
readonly TRACEFS=/sys/kernel/tracing
readonly LOCK_FILE=/run/lock/latency-lab.lock
readonly RTLA=/usr/bin/rtla
fail() {
printf 'ERROR: %sn' "$*" >&2
exit 1
}
[[ ${EUID} -eq 0 ]] || fail "diagnostic must run as root"
[[ -x ${RTLA} ]] || fail "rtla is not executable at /usr/bin/rtla"
[[ -d /sys/devices/system/cpu/cpu${CPU} ]] || fail "CPU 2 does not exist"
grep -qw "${CPU}" /sys/devices/system/cpu/online ||
grep -Eq "(^|,)0-${CPU}(,|$)" /sys/devices/system/cpu/online ||
fail "CPU 2 is not online"
[[ -r ${TRACEFS}/available_tracers ]] ||
fail "tracefs is unavailable at /sys/kernel/tracing"
grep -qw osnoise "${TRACEFS}/available_tracers" ||
fail "osnoise tracer is unavailable"
grep -qw timerlat "${TRACEFS}/available_tracers" ||
fail "timerlat tracer is unavailable"
exec 9>"${LOCK_FILE}"
flock -n 9 || fail "another latency-lab diagnostic holds the lock"
readonly RUN_ID
RUN_ID="$(date -u +%Y%m%dT%H%M%SZ)"
readonly RUN_DIR="${OUTPUT_ROOT}/${RUN_ID}"
install -d -m 0750 "${RUN_DIR}"
{
printf 'run_id=%sn' "${RUN_ID}"
printf 'kernel=%sn' "$(uname -r)"
printf 'cpu=%sn' "${CPU}"
printf 'threshold_us=%sn' "${THRESHOLD_US}"
printf 'rtla='
"${RTLA}" version 2>&1 || true
} >"${RUN_DIR}/environment.txt"
printf 'Running osnoise on CPU %sn' "${CPU}"
"${RTLA}" osnoise top
-c "${CPU}"
-d 20s
2>&1 | tee "${RUN_DIR}/osnoise.txt"
printf 'Running timerlat on CPU %s with %s us automatic thresholdn'
"${CPU}" "${THRESHOLD_US}"
"${RTLA}" timerlat top
-c "${CPU}"
-d 30s
-a "${THRESHOLD_US}"
2>&1 | tee "${RUN_DIR}/timerlat.txt"
if grep -Fq 'jitter-pulse' "${RUN_DIR}/timerlat.txt"; then
printf 'source=jitter-pulsenstatus=threshold-triggeredn'
>"${RUN_DIR}/ALERT"
logger -p daemon.warning -t latency-lab
"timerlat identified jitter-pulse on CPU ${CPU}; results: ${RUN_DIR}"
printf 'ALERT: timerlat trace contains jitter-pulsen'
else
printf 'INFO: jitter-pulse was not present in the captured timerlat outputn'
fi
printf 'RESULT_DIR=%sn' "${RUN_DIR}"
Instalează permisiunile:
sudo chown root:root /usr/local/libexec/latency-lab/run-diagnostic.sh
sudo chmod 0750 /usr/local/libexec/latency-lab/run-diagnostic.sh
sudo bash -n /usr/local/libexec/latency-lab/run-diagnostic.sh
-c 2 restrânge măsurarea la CPU 2. -d pune o limită explicită ambelor etape. În comanda timerlat, -a 500 activează modul automat și oprește captura când latența depășește 500 µs, păstrând informația de tracing asociată evenimentului.
Outputul final al scriptului trebuie să conțină:
Running osnoise on CPU 2
Running timerlat on CPU 2 with 500 us automatic threshold
ALERT: timerlat trace contains jitter-pulse
RESULT_DIR=/var/log/latency-lab/<marcaj-UTC>
Rândurile și valorile măsurate de rtla diferă între sisteme. În raportul osnoise, coloana asociată thread-urilor trebuie să fie nenulă; în captura timerlat trebuie căutat numele jitter-pulse, nu o valoare identică de latență.
Punct de control: dacă osnoise vede interferență de thread, dar timerlat.txt nu conține numele generatorului, verifică mai întâi clasa, prioritatea și CPU-ul prin comanda ps din pasul anterior.
Pasul 4 — Rulăm diagnosticul ca unitate și îl programăm săptămânal
Diagnosticul trebuie să configureze tracefs, deci rulează ca root. Suprafața sa este totuși limitată: nu primește acces la rețea, scrie numai în directorul jurnalelor și este omorât dacă depășește două minute.
Fișierul /etc/systemd/system/latency-diagnostic.service:
[Unit]
Description=Measure CPU 2 jitter with osnoise and timerlat
Documentation=https://docs.kernel.org/tools/rtla/rtla-osnoise.html
Documentation=https://docs.kernel.org/tools/rtla/rtla-timerlat.html
RequiresMountsFor=/sys/kernel/tracing
ConditionPathIsExecutable=/usr/bin/rtla
ConditionPathIsExecutable=/usr/local/libexec/latency-lab/run-diagnostic.sh
[Service]
Type=oneshot
User=root
Group=root
ExecStart=/usr/local/libexec/latency-lab/run-diagnostic.sh
TimeoutStartSec=2min
CPUAffinity=0
Nice=10
PrivateTmp=yes
ProtectHome=yes
ProtectSystem=strict
ReadWritePaths=/var/log/latency-lab /run/lock
RestrictAddressFamilies=AF_UNIX
LockPersonality=yes
RestrictRealtime=yes
SystemCallArchitectures=native
Procesul de control rulează pe CPU 0, în timp ce thread-urile tracerului sunt create pentru CPU 2 prin opțiunea -c 2. Nu activa ProtectKernelTunables=yes aici: rtla trebuie să scrie legitim în controalele tracefs.
Fișierul /etc/systemd/system/latency-diagnostic.timer:
[Unit]
Description=Weekly CPU 2 latency diagnostic
[Timer]
OnCalendar=Sun *-*-* 03:00:00
RandomizedDelaySec=5min
Persistent=true
Unit=latency-diagnostic.service
[Install]
WantedBy=timers.target
Instalează unitățile și execută prima măsurare manual:
sudo systemctl daemon-reload
sudo systemctl enable --now latency-diagnostic.timer
sudo systemctl start latency-diagnostic.service
systemctl --no-pager --full status latency-diagnostic.service
systemctl list-timers latency-diagnostic.timer --all
journalctl -u latency-diagnostic.service --no-pager
journalctl -t latency-lab --no-pager
Persistent=true face ca o rulare ratată în timp ce serverul era oprit să fie recuperată după pornire. RandomizedDelaySec=5min evită suprapunerea exactă cu alte activități săptămânale programate la aceeași oră.
Exemplul de stare reușită este:
Active: inactive (dead)
Result: success
O unitate oneshot terminată corect apare ca inactivă; aceasta nu indică un eșec. Jurnalul cu identificatorul latency-lab trebuie să indice directorul în care a fost găsită sursa.
Punct de control: verifică Result: success și existența unui director nou. Nu interpreta simplul cuvânt inactive ca problemă.
Pasul 5 — Păstrăm opt rotații fără să pierdem directorul ultimei capturi
Fiecare execuție produce fișiere text într-un director separat. logrotate poate procesa aceste fișiere fără să trimită semnale serviciilor, deoarece ele nu țin descriptorii deschiși după terminarea diagnosticului.
Fișierul /etc/logrotate.d/latency-lab:
/var/log/latency-lab/*/*.txt /var/log/latency-lab/*/ALERT {
weekly
rotate 8
compress
delaycompress
missingok
notifempty
su root root
}
Testează sintaxa și simulează decizia de rotație:
sudo logrotate --debug /etc/logrotate.d/latency-lab
weekly stabilește frecvența, iar rotate 8 păstrează opt generații. delaycompress lasă ultima rotație necomprimată și comprimă generațiile mai vechi. Directoarele cu marcaj temporal rămân disponibile pentru corelarea fișierelor din aceeași măsurare.
Outputul de debug trebuie să enumere fișierele din /var/log/latency-lab și să precizeze dacă au nevoie sau nu de rotație. Modul --debug nu modifică fișierele.
Punct de control: dacă apare mesajul error: skipping ... because parent directory has insecure permissions, verifică proprietarul și readu directorul la root:root, cu modul 0750.
Testul de capăt: dintr-o singură rulare obținem clasificarea și procesul
Rulează întregul traseu și verifică ultimul director:
sudo systemctl restart latency-jitter.service
sudo systemctl start latency-diagnostic.service
LATEST_DIR="$(
sudo find /var/log/latency-lab
-mindepth 1
-maxdepth 1
-type d
-printf '%fn' |
sort |
tail -n 1
)"
sudo test -n "${LATEST_DIR}"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/environment.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/osnoise.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/timerlat.txt"
sudo test -s "/var/log/latency-lab/${LATEST_DIR}/ALERT"
sudo grep -F 'source=jitter-pulse'
"/var/log/latency-lab/${LATEST_DIR}/ALERT"
sudo grep -F 'jitter-pulse'
"/var/log/latency-lab/${LATEST_DIR}/timerlat.txt"
Rezultatul acceptat include:
source=jitter-pulse
A doua comandă grep trebuie să afișeze cel puțin o linie din captura timerlat care conține același nume. Timestampurile, PID-urile și latențele diferă în mod legitim.
Interpretarea se face în această ordine:
osnoise.txtconfirmă că pe CPU 2 există timp consumat de alt thread, nu doar de IRQ sau softirq.timerlat.txtconfirmă depășirea pragului de 500 µs.- Urma păstrată conține
jitter-pulse. ALERTleagă rezultatul automat de directorul măsurării.
Dacă într-un sistem real predomină IRQ sau softirq în locul categoriei thread, verifică afinitatea întreruperilor și dispozitivul asociat înainte să modifici schedulerul. Dacă problema indică wakeup-uri și întârzieri de rulare ale proceselor obișnuite, analiza schedulerului EEVDF oferă traseul următor. Optimizări precum rseq time slice extension se evaluează abia după identificarea mecanismului, nu ca remediu generic pentru orice vârf.
Cinci defecțiuni care localizează ruptura laboratorului
ERROR: CPU 2 does not exist
Mașina are mai puțin de trei procesoare logice sau CPU 2 nu este expus mediului virtual. Confirmă:
nproc
ls -d /sys/devices/system/cpu/cpu[0-9]*
Acest laborator cere minimum patru procesoare logice. Nu schimba mecanic valoarea în toate fișierele fără să alegi un CPU care nu găzduiește sesiunea administrativă.
ERROR: timerlat tracer is unavailable
Kernelul pornit nu include tracerul sau tracefs nu este montat. Separă cele două cauze:
mountpoint /sys/kernel/tracing || sudo mount -t tracefs nodev /sys/kernel/tracing
grep CONFIG_TIMERLAT_TRACER "/boot/config-$(uname -r)"
grep -w timerlat /sys/kernel/tracing/available_tracers
Dacă opțiunea kernelului nu este activă, pornește un kernel Ubuntu care o furnizează și instalează pachetul linux-tools al acelei versiuni.
ERROR: another latency-lab diagnostic holds the lock
Timerul și o rulare manuală s-au suprapus. Nu șterge fișierul de lock cât timp procesul există. Verifică unitatea și așteaptă terminarea:
systemctl status latency-diagnostic.service
journalctl -u latency-diagnostic.service -n 50 --no-pager
flock eliberează automat blocarea când procesul se încheie.
Failed to set SCHED_FIFO în jurnalul generatorului
Managerul de servicii nu a putut aplica politica cerută, de regulă din cauza unei limite real-time impuse sistemului sau containerului. Verifică unitatea și mediul:
systemctl show latency-jitter.service
-p CPUSchedulingPolicy
-p CPUSchedulingPriority
-p LimitRTPRIO
systemd-detect-virt
Laboratorul trebuie rulat pe o mașină sau mașină virtuală care permite scheduling real-time. Nu rezolva problema prin rularea binarului ca root; utilizatorul dedicat trebuie păstrat.
INFO: jitter-pulse was not present in the captured timerlat output
Măsurarea s-a terminat fără urma așteptată. Verifică dacă generatorul este activ, fixat pe CPU 2 și are prioritatea 98:
systemctl is-active latency-jitter.service
ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse'
sudo grep -E 'CPU|jitter-pulse|timerlat'
/var/log/latency-lab/*/timerlat.txt |
tail -n 30
Dacă serviciul este corect, repetă diagnosticul fără să pornești alte tracere în paralel. perf, trace-cmd sau altă sesiune rtla poate modifica infrastructura globală de tracing și invalida captura.
Oprim prioritatea real-time înainte să ștergem laboratorul
Ordinea contează: întâi oprește generatorul, apoi timerul și diagnosticul. Abia după aceea elimină fișierele.
sudo systemctl stop latency-jitter.service
sudo systemctl disable --now latency-diagnostic.timer
sudo systemctl stop latency-diagnostic.service 2>/dev/null || true
sudo rm -f
/etc/systemd/system/latency-jitter.service
/etc/systemd/system/latency-diagnostic.service
/etc/systemd/system/latency-diagnostic.timer
/etc/logrotate.d/latency-lab
sudo systemctl daemon-reload
sudo systemctl reset-failed
sudo rm -rf
/usr/local/src/latency-lab
/usr/local/libexec/latency-lab
/var/log/latency-lab
sudo userdel latnoise 2>/dev/null || true
Pachetele linux-tools nu sunt eliminate: ele aparțin depanării kernelului și pot fi folosite de alte fluxuri administrative. Verifică dispariția procesului real-time:
ps -eLo pid,tid,cls,rtprio,psr,comm | grep '[j]itter-pulse' || true
systemctl list-timers latency-diagnostic.timer --all
Outputul nu trebuie să mai conțină jitter-pulse sau timerul laboratorului.
Bifele care confirmă un diagnostic valid
- ☐ CPU 2 există și este online.
- ☐ Kernelul curent listează atât
osnoise, cât șitimerlat. - ☐ Binarul
rtlaaparține setului de unelte instalat pentru kernelul pornit. - ☐
jitter-pulserulează ca utilizatorullatnoise, în clasaFF, cu prioritatea 98. - ☐ Generatorul rămâne fixat pe CPU 2.
- ☐
osnoise.txtindică interferență produsă de un thread pe CPU 2. - ☐
timerlat.txtconține numelejitter-pulse. - ☐ Fișierul
ALERTconținesource=jitter-pulse. - ☐ Diagnosticul automat se termină cu
Result: success. - ☐ Logurile au retenție de opt rotații, iar generatorul este oprit după test.
Trei extinderi după ce laboratorul identifică sursa
Prima extindere este înlocuirea generatorului cu serviciul real, păstrând aceeași măsurare pe CPU-ul aplicației. Pragul de 500 µs trebuie schimbat numai după ce este stabilit bugetul real de latență al acelui serviciu.
A doua este corelarea capturii cu function_graph atunci când urma indică o cale kernel lungă, nu un proces concurent. Colectarea trebuie făcută într-o fereastră scurtă, deoarece tracingul suplimentar poate modifica el însuși latența.
A treia este compararea aceleiași sarcini înainte și după mutarea IRQ-urilor sau izolarea CPU-ului. Păstrează fișierele environment.txt, aceeași durată și același prag; altfel compari configurații și condiții diferite, nu efectul unei singure schimbări.
Întrebări frecvente
Pot rula osnoise și timerlat simultan?
Nu în acest proiect. Ambele configurează infrastructura globală de tracing, iar scriptul le rulează succesiv: osnoise clasifică interferența, apoi timerlat capturează evenimentul și procesul asociat.
De ce generatorul folosește prioritatea real-time 98?
Prioritatea ridicată produce controlat o întârziere observabilă pe CPU 2. Procesul ocupă CPU-ul aproximativ 2 ms, apoi doarme aproximativ 100 ms și este limitat la serverul de test.
De ce unitatea de diagnostic rulează ca root?
rtla trebuie să configureze tracerele prin tracefs. Generatorul nu are această nevoie și rulează separat ca utilizatorul fără login latnoise.
Este suficient un rezultat mare în osnoise pentru a identifica procesul?
Nu. osnoise arată categoria sursei, precum thread, IRQ sau softirq. În laborator, numele jitter-pulse este confirmat în captura produsă de timerlat.
Surse
- OSNOISE Tracer — The Linux Kernel documentation
- rtla-osnoise — The Linux Kernel documentation
- rtla-timerlat — The Linux Kernel documentation
- The realtime Linux analysis tool — The Linux Kernel documentation
- Tools for measuring real-time metrics — Ubuntu documentation
- systemd.timer — freedesktop.org manual

















































