A cosa serve IRQbalance in Linux e come si inserisce nell'ottimizzazione avanzata?

Ultimo aggiornamento: 17/12/2025
Autore: Isaac
  • irqbalance distribuisce gli interrupt hardware tra i core per evitare colli di bottiglia nei sistemi SMP, risultando particolarmente utile nei server ad alto traffico.
  • Le prestazioni effettive dipendono dalla combinazione di irqbalance con NAPI, code di rete, buffer TCP di dimensioni adeguate, qdisc moderno e algoritmi di controllo della congestione come BBR.
  • Le impostazioni NIC avanzate (buffer ad anello, RSS/RPS, offload) e l'assegnazione manuale dell'affinità IRQ consentono un'ulteriore regolazione precisa della distribuzione del carico tra le CPU.
  • L'ottimizzazione complessiva di Linux Ciò viene completato con modifiche alla memoria, allo swap, alla zram, ai file system temporanei e ai parametri del desktop e ad applicazioni come Firefox.

Configurazione di IRQbalance in Linux

Quando si inizia a smanettare con le prestazioni di un sistema GNU/Linux, prima o poi emerge un protagonista ricorrente: irqbalance e la distribuzione degli interrupt hardware tra le CPU . Se ne parla nei forum, nella documentazione delle distribuzioni e nei tutorial su come "ottimizzare" il sistema per renderlo più veloce... ma raramente viene spiegato chiaramente cosa faccia effettivamente, in quali scenari sia utile e in quali non si noti nulla.

Inoltre, tutto questo bilanciamento degli IRQ si intreccia con altri concetti avanzati: NAPI, code di ricezione del kernel, buffer delle schede di rete, algoritmi di controllo della congestione TCP, RSS/RPS, BBR, impostazioni sysctl, demoni delle prestazioni come preload, swap compresso da zram, ottimizzazione GTK, file temporanei in RAM e così via. È molto facile perdersi tra parametri, comandi e file di configurazione senza una chiara comprensione di cosa faccia ciascuno di essi.

Che cos'è IRQbalance e a cosa serve realmente in Linux?

irqbalance è un demone in spazio utente che distribuisce gli interrupt hardware (IRQ) tra i core della CPU nei sistemi SMP (multiprocessore o multicore). Il suo scopo non è magico: mira semplicemente a impedire che l'intero carico di lavoro dei dispositivi di servizio (rete, dischi, USB , ecc.) ricada su un singolo core.

Quando un dispositivo genera un IRQ, il kernel esegue un gestore di interrupt. Se molti di questi interrupt sono concentrati su una singola CPU, quest'ultima può sovraccaricarsi mentre le altre rimangono inattive. irqbalance analizza il volume di interrupt per dispositivo e assegna ciascun IRQ a un core appropriato per distribuire il carico , cercando al contempo di minimizzare le perdite di cache e rispettare le affinità logiche (ad esempio, mantenendo correlati gli IRQ provenienti dalla stessa interfaccia di rete).

Nei sistemi con una singola CPU o con core che condividono completamente la cache L2 , irqbalance rileva automaticamente di non avere nulla di utile da fare e si arresta. Non si tratta di un bug; semplicemente non c'è margine di miglioramento. Tuttavia, nei server con più CPU fisiche o molti core, soprattutto in presenza di traffico di rete intenso o elevato I/O, questo comportamento può influire sulla latenza e sulla stabilità.

Il demone può essere eseguito in background (modalità di servizio) o in base alle necessità con l'opzione – colpo singolo. Anche consente di escludere IRQ specifici per opzione --banirq e impedirgli di utilizzare determinati core con la maschera della CPU definita nella variabile di ambiente IRQBALANCE_BANNED_CPUSTutto questo è normalmente controllato dal tuo file di configurazione, che in molte distribuzioni si trova in /etc/default/irqbalance o /etc/irqbalance.env.

Bilanciamento IRQ: kernel vs irqbalance e quando è evidente

Linux possiede già un proprio meccanismo interno per decidere quale CPU gestisce ciascun IRQ, senza bisogno di irqbalance. Il kernel può impostare le affinità degli interrupt e distribuirle utilizzando semplici euristiche , e su molti computer desktop questo è più che sufficiente: l'utente medio non noterà alcuna differenza abilitando o disabilitando irqbalance.

Ecco perché è relativamente comune che qualcuno provi irqbalance sulla propria distribuzione desktop e dica: "Non noto alcun miglioramento, ma nemmeno nulla di negativo ". È perfettamente normale. Su un portatile con un processore quad-core e una singola scheda di rete senza un carico di I/O elevato, lo scheduler di Linux e i meccanismi interni del kernel (NAPI, code di rete, ecc.) mantengono già un bilanciamento ragionevole.

Ha senso, invece, sui server multi-core con traffico intenso : database di grandi dimensioni , proxy inversi, server web ad alto traffico, storage di backup , macchine virtuali con carico elevato , ecc. In queste situazioni, avere molti interrupt di rete o di disco bloccati su un singolo core può diventare un collo di bottiglia. Distribuirli efficacemente riduce le code, i tempi di servizio e i picchi di latenza.

Alcuni utenti preferiscono usare irqbalance invece di irqbalance parametrizzare il kernel con opzioni come acpi_irq_balance In GRUB. Questo parametro influenza il modo in cui ACPI e il kernel allocano gli IRQ, ma non offre la stessa flessibilità dinamica di irqbalance, che rivaluta l'allocazione in base al carico effettivo. Si tratta di approcci diversi: il primo è più statico e di basso livello; il secondo, più adattivo.

Negli ambienti a bassissima latenza (ad esempio, alcune piattaforme di trading o reti con DPDK), accade il contrario: irqbalance è solitamente disabilitato e gli interrupt vengono assegnati manualmente a core specifici , insieme a mappature accurate tra code NIC e CPU. In questi scenari, si ricerca il controllo assoluto e si sacrifica una certa automazione.

  Come formattare una scheda SD con Ubuntu

Interruzioni, NAPI e code di rete: come si inserisce IRQbalance

Per comprendere meglio il ruolo di irqbalance, dobbiamo scendere a un altro livello e vedere come Linux li gestisce. interruzioni di rete e ricezione dei pacchettiIl sottosistema di rete del kernel combina diversi componenti chiave: NAPI, code di ricezione (buffer DMA), parametri di net.core.*, algoritmi di gestione delle code (qdisc) e ridimensionamento laterale (RSS/RPS).

NAPI (New API) è il meccanismo con cui il kernel riduce le tempeste di interruzioni in caso di traffico elevato. Invece di generare un IRQ per ogni pacchetto, la scheda di rete genera un'interruzione che indica "lavoro in sospeso" e il kernel interroga la coda di ricezione finché non è vuota o finché non si esaurisce un budget di tempo/pacchetti. Questo riduce il jitter e migliora le prestazioni, sebbene possa anche introdurre alcune variazioni di latenza.

La coda in cui i pacchetti atterrano prima di essere elaborati dallo stack di rete è comunemente chiamata coda di ricezione del kernel o buffer DMA . La sua capacità è limitata da parametri quali:

  • net.core.netdev_max_backlog: numero massimo di pacchetti nella coda di ricezione del software quando il kernel non riesce a elaborarli alla velocità con cui arrivano.
  • net.core.netdev_budget_usecs: “budget” di tempo in microsecondi che NAPI ha a disposizione per svuotare le code in ogni ciclo.
  • net.core.dev_weight: numero di pacchetti elaborati per interfaccia in ogni round entro quel budget.

Si netdev_max_backlog è molto basso e la NIC invia più pacchetti di quanti il ​​kernel possa gestire, inizieremo a vedere "pacchetti scartati" in /proc/net/softnet_statUn tipico punto di partenza per la messa a punto su server ad alto traffico è nell'intervallo di Pacchetti 4000, configurato in /etc/sysctl.conf con qualcosa del tipo:

net.core.netdev_max_backlog = 4000

Dopo averlo modificato, viene applicato con sysctl -p o un sysctl -w puntuale. In questo modo, la coda assorbe meglio i picchi di arrivo senza perdere pacchetti, a patto che il resto del percorso di elaborazione regga.

In questo circuito, irqbalance decide quale CPU gestisce gli interrupt (IRQ) associati all'interfaccia di rete. Se concentriamo tutti gli interrupt della scheda di rete su un singolo core, quest'ultimo eseguirà da solo le routine NAPI e svuoterà la coda . Se invece distribuiamo gli interrupt in modo efficace e utilizziamo meccanismi come RSS o RPS, più CPU possono collaborare per elaborare i pacchetti, riducendo le code e la perdita di pacchetti.

Ottimizzare le code, i buffer e la finestra TCP per il traffico intenso

Quando un server gestisce grandi quantità di dati (ad esempio, backup, traffico FTP, file di grandi dimensioni o replica di database), la semplice attivazione di irqbalance non è sufficiente. È necessario armonizzare diversi livelli: code del kernel, buffer dell'interfaccia di rete, dimensioni della finestra TCP e parametri di congestione , in modo che tutto funzioni nella stessa direzione.

Il primo blocco di regolazione si trova nel buffer di ricezione dei pacchetti e nella finestra TCP . Linux espone parametri quali:

  • net.ipv4.tcp_rmem: tripletta (minimo, predefinito, massimo) di memoria di ricezione TCP per socket.
  • net.ipv4.tcp_wmem: equivalente per la spedizione.
  • net.core.rmem_max y net.core.wmem_max: buffer massimo che un'applicazione può richiedere.

Un modo pratico per adattare questi valori a un collegamento Gigabit a bassa latenza è calcolare il prodotto larghezza di banda-ritardo (BDP) e applicare un fattore di scala (grazie all'opzione di scalatura della finestra TCP , abilitata di default nella maggior parte dei kernel moderni). In pratica, molti amministratori finiscono per ottenere valori massimi di diversi megabyte, ad esempio:

net.ipv4.tcp_rmem = 4096 16384 10880000
net.ipv4.tcp_wmem = 4096 16384 10880000

Quel valore massimo di ~10,8 MB deriva da calcoli specifici per collegamenti a 1 Gbps con un RTT molto basso (~0,00017 s). Maggiore è la velocità di trasmissione o la latenza, maggiore deve essere il buffer per sfruttare la larghezza di banda senza essere limitati dalla finestra del buffer.

È importante correlare questo valore massimo alla dimensione della coda di ricezione dei pacchetti. Se netdev_max_backlog = 4000 e ogni pacchetto effettivo è di circa 1480 byte, tale coda rappresenta approssimativamente 5,9 MB. Il buffer della finestra TCP deve essere più grande della capacità della coda , altrimenti perderemo pacchetti perché il buffer si saturerà prima della coda.

Per monitorare le perdite , è possibile utilizzare comandi come i seguenti:

  • cat /sys/class/net/eth0/statistics/rx_dropped: pacchetti persi nella NIC.
  • watch -n 1 -t -d cat /proc/net/softnet_stat: colonne elaborate, eliminate, tempi ridotti, ecc. per CPU.
  • watch -n 1 -t -d "netstat -s | grep err": errori dello stack di rete.

Se netstat segnala errori ma /proc/net/softnet_stat no , è molto probabile che le perdite si verifichino al di fuori del nostro host (lungo il percorso, attraverso un firewall intermedio, ecc.). Una certa perdita sarà sempre presente a causa degli algoritmi di controllo della congestione, ma dovrebbe rimanere gestibile e correlata ai picchi di traffico.

  Come configurare un server NAS domestico con OpenMediaVault

Gestione delle code (qdisc), QoS e controllo della congestione TCP

Sebbene le code interne del kernel siano fondamentali, altrettanto importante è la disciplina di accodamento (qdisc) associata alle interfacce di rete . Questa determina come i pacchetti vengono ordinati, raggruppati e scartati in uscita e può fare la differenza nel mitigare fenomeni come il bufferbloat.

Linux offre diversi qdisc pertinenti :

  • pfifo_fast: vecchia disciplina predefinita, un FIFO con tre fasce di priorità.
  • fq_codice: combinazione di coda equa con CoDel per combattere il bufferbloat, altamente consigliata per router e uso generale.
  • fq: semplice coda equa, molto utile sui server ad alto carico.
  • torta (sch_cake): il più avanzato oggi, ma richiede la compilazione o la presenza del modulo nel kernel.

Il qdisc predefinito si presenta così:

sysctl net.core.default_qdisc

E può essere sostituito a caldo con:

sysctl -w net.core.default_qdisc=fq_codel

Per garantire che un'interfaccia specifica utilizzi una disciplina particolare, si ricorre a tc:

sudo tc qdisc replace dev eth0 root fq_codel

In relazione a ciò, anche l' algoritmo di controllo della congestione TCP fa la differenza negli ambienti WAN o in quelli con traffico elevato. Il kernel ne offre diversi (cubic, reno, ecc.) e le versioni più recenti includono BBR, sviluppato da Google , che in genere migliora la velocità di trasmissione sostenuta senza aumentare significativamente la latenza. Si attiva con:

sudo sysctl -w net.ipv4.tcp_congestion_control=bbr

L'elenco degli algoritmi disponibili può essere ispezionato visualizzando i moduli tcp_* en /lib/modules/<versión>/kernel/net/ipv4/. Combina BBR con un qdisc adatto (fq/fq_code) e una buona configurazione del buffer Ciò si traduce in flussi di dati molto più stabili.

Impostazioni NIC avanzate: buffer ad anello, RSS, RPS e offload

Anche la scheda di rete stessa dispone di una propria serie di code e buffer: i buffer ad anello di ricezione (RX) e trasmissione (TX) . La loro dimensione massima dipende dall'hardware ed è visualizzata come segue:

ethtool -g ethX

I campi “Massimi preimpostati” indicano di quanto possono essere aumentati i valori. Se la scheda lo consente, RX e TX possono essere aumentati a valori come 4096, 8192 o 16384 con:

ethtool -G ethX rx 4096 tx 4096

Se viene visualizzato un errore come "Impossibile impostare i parametri dell'anello del dispositivo: argomento non valido", quel valore supera le capacità della scheda di rete e sarà necessario provare con divisori più piccoli.

Per evitare che una singola CPU gestisca tutto il carico di lavoro in ricezione , molte schede di rete moderne implementano il Receive Side Scaling (RSS) , creando più code hardware associate a core diversi. In Linux, questa distribuzione è rappresentata da:

gatto /proc/interruzioni | grep

Sulle schede sprovviste di RSS, è possibile "emulare" qualcosa di simile con RPS (Receive Packet Steering) , assegnando le CPU alle code software dell'interfaccia:

echo f > /sys/class/net/enp4s0f0/queues/rx-0/rps_cpus

Il valore è una maschera esadecimale. Ad esempio, f In binario (1111), indica l'utilizzo dei primi quattro kernel. Il kernel deve essere compilato con CONFIG_RPS perché funzioni.

Puoi anche giocare con scaricamenti e segmentazione del checksum per scaricare il lavoro dalla CPU al processore NIC. ethtool -k Le funzionalità attivate sono visibili e possono essere attivate cose come le seguenti:

ethtool -K ethX rx acceso (verifica del checksum alla reception)
ethtool -K ethX tso on (Scarico della segmentazione TCP)

Affinché questi cambiamenti siano duraturi, sono solitamente inseriti negli script di rete (/etc/network/interfaces in Debian/Ubuntu, /etc/sysconfig/network-scripts/ifcfg-ethX in Red Hat) o nelle regole udev.

Regola manualmente l'affinità IRQ e vivi con IRQbalance

Nei kernel più vecchi o nei casi in cui vogliamo un controllo preciso, è possibile Assegna manualmente la CPU che gestisce uno specifico IRQ.Tutte le informazioni sono in /proc/irq y /proc/interruptsUn flusso tipico sarebbe:

  • Visualizza interruzioni: cat / proc / interrupts e individuare la linea dell'interfaccia di rete (ad esempio, IRQ 25 per enp0s8).
  • Controlla l'affinità attuale: gatto /proc/irq/25/smp_affinity (maschera esadecimale: 02 = CPU1, 01 = CPU0, 04 = CPU2, ecc.).
  • Cambialo: echo 1 > /proc/irq/25/smp_affinity per spostarlo su CPU0.

In questo modo è possibile, ad esempio, alleggerire il carico di una CPU satura spostando un IRQ su un core meno occupato. Se hai installato e abilitato irqbalance, è importante indicargli di non intervenire su quello specifico interrupt aggiungendo un'opzione come:

OPZIONI="--banirq=25"

en /etc/default/irqbalanceoppure utilizzando l'opzione --banirq=25 Quando il demone inizia. Così Lo si esclude dalla logica di distribuzione automatica. e rispetti il ​​tuo compito manuale.

Quindi questo cambia come echo 1 > /proc/irq/25/smp_affinity sopravvivere ai riavviiDi solito vengono aggiunti al classico /etc/rc.local (se abilitato) o a unità systemd specifiche.

Altre impostazioni di prestazioni correlate: swap, zram, file temporanei, preload

Tutto questo lavoro di miglioramento della risposta della rete e della distribuzione degli IRQ è solitamente accompagnato da altre ottimizzazioni di sistema che, pur non essendo direttamente collegate all'equilibrio degli IRQ, completano il quadro delle prestazioni.

Nell'ambito della memoria, molti amministratori riducono la uso aggressivo dello swap modificando /etc/sysctl.conf con parametri quali:

  • vm.swappiness: quanto il kernel preferisce usare lo swap (0-100, predefinito 60). Valori bassi (1-10) danno priorità alla RAM.
  • vm.vfs_cache_pressionePressione sulla cache inode e dentry. Ridurla aiuta a mantenere i metadati nella RAM.
  • vm.dirty_writeback_centisecs y vm.dirty_expire_centisecs: frequenza e scadenza della scrittura di pagine sporche su disco.
  • vm.dirty_ratio y vm.dirty_ background_ratio: percentuale di memoria che può essere riempita con dati sporchi prima delle scritture forzate.
  La fotocamera non funziona in Windows 10. Cause e soluzioni

Con valori appropriati (ad esempio vm.swappiness=1 , vm.vfs_cache_pressure=50 , ecc.) è possibile fare in modo che il sistema utilizzi più RAM prima di iniziare il paging , il che è auspicabile nei server con molta memoria.

Un'altra misura classica è spostare le directory temporanee nella RAM montandoli come tmpfs en /etc/fstab:

tmpfs /tmp tmpfs noatime,nodiratime,nodev,nosuid,mode=1777,defaults 0 0
tmpfs /var/tmp tmpfs noatime,nodiratime,nodev,nosuid,mode=1777,defaults 0 0

Ciò consente di eseguire accessi temporanei (compilazioni, file di lavoro delle applicazioni, ecc.) alla velocità della RAM , riducendo l'usura dei dischi SSD.

È anche comune in ambienti con poche risorse attivare zram-swapUn dispositivo di swap compresso nella RAM. Viene installato da un repository (ad esempio, utilizzando Git tramite clonazione). zram-swap eseguendo il suo install.sh) e crea un dispositivo a blocchi compresso in cui il sistema effettua lo scambio prima di ricorrere, se disponibile, allo scambio del disco. Si ottiene una memoria effettiva a discapito di una CPU leggermente maggiore.che compensa molti carichi.

Infine, i daemon come preload analizzano quali applicazioni vengono eseguite più frequentemente e precaricano i relativi binari e librerie nella RAM, velocizzandone l'avvio a scapito del consumo di memoria. Questo ha senso sui computer desktop con molta RAM; sui server con risorse molto limitate, di solito viene omesso.

GTK, GRUB, Firefox e altre modifiche alla “qualità della vita”

Oltre alle pure prestazioni del server, molti tutorial includono lunghe sezioni sull'ottimizzazione dell'esperienza desktop : tempi di risposta dei menu GTK, font, temi scuri, audio, comportamento del mouse, ecc. Sebbene questi elementi non influiscano direttamente sul bilanciamento degli IRQ o sul traffico di rete, contribuiscono a rendere il sistema più reattivo.

In GTK2, GTK3 e GTK4 è possibile effettuare delle regolazioni. decine di parametri in file come ~/.gtkrc-2.0, ~/.config/gtk-3.0/settings.ini o ~/.config/gtk-4.0/settings.iniAnimazioni, tempi di doppio clic, dimensioni del cursore, design della barra del titolo, utilizzo di temi scuri, comportamento dei suggerimenti, antialiasing dei caratteri, ecc. Questi file vengono modificati manualmente (con nano) o aggiungendo linee tramite echo >> da terminale.

Anche le versioni vengono solitamente modificate. "globale" di questi parametri in /etc/gtk-2.0/gtkrc, /etc/gtk-3.0/settings.ini y /etc/gtk-4.0/settings.ini, in modo che riguardino tutti gli utenti, rispettando sempre che in quei casi bisogna essere root (tramite su - o sudo).

El tempo di attesa del direttore Boot GRUB Si accorcia modificandolo. /etc/default/grub e modificando GRUB_TIMEOUT (ad esempio, da 10 a 3 secondi) e aggiungendo parametri al kernel come noresume o acpi_irq_balance en GRUB_CMDLINE_LINUX_DEFAULT. Quindi viene eseguito update-grub (Debian/Ubuntu) o grub-mkconfig -o /boot/grub/grub.cfg (Archivi e derivati).

Nel caso del browser, ci sono file come user.js per firefox Queste impostazioni consentono di applicare gruppi di preferenze volte ad accelerare la navigazione: numero di connessioni, comportamento della cache, compressione, WebSocket, ecc. La procedura usuale è quella di reimpostare il profilo, aprire la directory del profilo da "Informazioni sulla risoluzione dei problemi", chiudere Firefox e incollare quanto segue: user.js nella cartella del profilo e riaprire il browser.

Sebbene tutto ciò sia correlato all'argomento irqbalance, illustra un concetto importante: l'ottimizzazione di Linux è un processo olistico . Non si tratta solo di un demone o di un parametro magico, ma di mettere a punto CPU, memoria, disco, rete, ambiente desktop e applicazioni fino a quando non corrispondono all'utilizzo effettivo della macchina.

Considerando il quadro generale – allocazione degli IRQ con irqbalance o configurazione manuale, NAPI e code ottimizzate, buffer TCP di dimensioni adeguate, qdisc moderni come fq_codel o fq, controllo della congestione BBR, buffer ad anello espansi, RSS/RPS abilitati, swap e zram controllati, RAM temporanea e un ambiente desktop finemente ottimizzato – diventa chiaro che irqbalance è solo un tassello di un puzzle piuttosto grande . Il suo ruolo è vitale sui server multicore con traffico elevato, irrilevante su molti desktop e controproducente su sistemi con latenza estremamente bassa dove è preferibile impostare manualmente l'affinità. Comprendere questo contesto è fondamentale per decidere se lasciarlo operare, limitarne l'uso o disabilitarlo completamente.

virtualizzazione con KVM e Virt-Manager
Articolo correlato:
Virtualizzazione con KVM e Virt-Manager: tutto quello che devi sapere
Isaac

Isaac

Scrittore appassionato del mondo dei byte e della tecnologia in generale. Adoro condividere le mie conoscenze attraverso la scrittura, ed è quello che farò in questo blog, mostrarti tutte le cose più interessanti su gadget, software, hardware, tendenze tecnologiche e altro ancora. Il mio obiettivo è aiutarti a navigare nel mondo digitale in modo semplice e divertente.