Table of Contents

Introduzione al controllo di competitività nei sistemi operativi

Il controllo della concorrenza rappresenta una delle basi più critiche del moderno sistema operativo, consentendo ai computer di eseguire più processi e fili contemporaneamente mantenendo l'integrità dei dati e la stabilità del sistema.

Il controllo della convalutazione comprende la raccolta di meccanismi, protocolli e strategie che i sistemi operativi impiegano per coordinare l'accesso alle risorse condivise tra più entità esecutive, che possono includere posizioni di memoria, file, database, connessioni di rete e dispositivi hardware. Senza una corretta gestione della concurrenza, i sistemi sarebbero affetti da condizioni di gara in cui il risultato dipende da tempi imprevedibili, blocchi in cui i processi aspettano compromessi indefiniti, l'affidabilità e la corruzione dei dati.

L'evoluzione del controllo della concurrenza ha parallelamente all'avanzamento dell'hardware di calcolo. I primi sistemi a singolo processore hanno richiesto meccanismi di coordinamento relativamente semplici, ma le moderne architetture multi-core con decine o addirittura centinaia di unità di elaborazione richiedono approcci sofisticati per garantire che l'esecuzione parallela offra guadagni di prestazioni piuttosto che introdurre il caos.

Comprendere i principi fondamentali di controllo della concorrenza

Il controllo della concorrenza comporta un insieme completo di meccanismi che coordinano l'accesso alle risorse condivise tra processi multipli o thread che eseguono simultaneamente. L'obiettivo primario è quello di garantire che le operazioni concorrenti producano risultati corretti equivalenti ad una qualche esecuzione sequenziale di tali operazioni, una proprietà nota come serializability.

La sfida delle risorse condivise

Quando si verificano più processi o thread, si verificano diversi problemi fondamentali: quando la correttezza di un programma dipende dalla relativa tempistica degli eventi, come l'ordine in cui vengono eseguiti i thread. Considera uno scenario semplice in cui due thread tentano di incrementare una variabile di contro condivisa. Senza sincronizzazione, entrambi i thread potrebbero leggere lo stesso valore iniziale, incrementarlo in modo indipendente e riscrivere il risultato, perdendo efficacemente uno degli incrementi di produzione apparentemente semplici possono causcare errori.

Un deadlock si verifica quando due o più processi vengono bloccati indefinitamente, ciascuno in attesa di risorse detenute dagli altri. L'esempio classico prevede due processi in cui il processo A detiene la risorsa 1 e attende la risorsa 2, mentre il processo B detiene la risorsa 2 e aspetta la risorsa 1. Non può procedere, con conseguente stallo permanente che può essere risolto solo attraverso l'intervento esterno o il riavvio del sistema.

Quando più processi accedere alle strutture di dati condivise senza un corretto coordinamento, i dati possono entrare in stati inconsistenti che violano invarianti il sistema dipende. Ad esempio, in un sistema bancario, un'operazione di trasferimento che addebita un account e crediti un altro deve apparire atomico ad altri processi; altrimenti, il denaro potrebbe apparire per svanire o essere creato da nulla durante gli stati intermedi della transazione.

Sezioni critiche e inclusione reciproca

Il concetto di sezioni critiche costituisce la base di molti approcci di controllo della concurrenza. Una sezione critica è un segmento di codice che accede alle risorse condivise e non deve essere eseguita da più di un processo o filo alla volta. L'identificazione e la protezione di sezioni critiche attraverso meccanismi di esclusione reciproca assicura che solo un processo possa eseguire il codice sensibile in qualsiasi momento, impedendo l'interferenza e mantenendo la coerenza dei dati.

In primo luogo, deve garantire che nella maggior parte di un processo si esegue nella sezione critica in qualsiasi momento. In secondo luogo, non dovrebbe fare ipotesi sulle velocità relative dei processi o il numero di processori. In terzo luogo, un processo al di fuori della sua sezione critica non dovrebbe bloccare altri processi di entrare nelle loro sezioni critiche. Infine, nessun processo dovrebbe aspettare indefinitamente per entrare nella sua sezione critica, una proprietà conosciuta come bounded attesa che impedisce la fame.

Atomicity e Transaction Semantics

L'Atomicity garantisce che le operazioni siano complete o non abbiano alcun effetto, senza stati intermedi visibili. Questa proprietà all-or-nothing è fondamentale per mantenere la coerenza del sistema, in particolare negli scenari che coinvolgono più operazioni correlate che devono avere successo o non funzionare come unità. I sistemi operativi forniscono operazioni atomiche a vari livelli, dalle istruzioni atomiche supportate dall'hardware per operazioni semplici come il confronto e il lancio, ai meccanismi di transazione basati sul software per procedure complesse multi-passo.

La semantica delle transazioni estende l'atomica per contenere molteplici operazioni che dovrebbero essere trattate come un'unica unità logica. Le transazioni devono soddisfare le proprietà ACID: Atomicity (tutte le operazioni complete o non esecutive), Consistency (il sistema si sposta da uno stato all'altro valido), Isolation (le transazioni concorrenti non interferiscono tra loro), e Durability (le transazioni complete persistono anche di fronte a guasti).

Tecniche e Meccanismo per il Controllo della Concorrenza

I moderni sistemi operativi impiegano una serie di tecniche diverse per gestire operazioni concorrenziali, ognuna con caratteristiche distinte, implicazioni di performance e casi di utilizzo appropriati. La comprensione di questi meccanismi consente ai progettisti di sistema di selezionare gli strumenti giusti per specifiche sfide di concorrenza e ottimizzare le prestazioni del sistema mantenendo la correttezza.

Blocchi e Motual Exclusion Primitivi

Un blocco è un oggetto di sincronizzazione che può essere in uno dei due stati: bloccato o sbloccato. Quando un processo o un thread acquisisce una serratura, ottiene l'accesso esclusivo alla risorsa associata. Altri processi che tentano di acquisire la stessa serratura devono aspettare fino a quando il supporto corrente lo rilascia. Questo modello semplice fornisce garanzie di esclusione reciproca ed è relativamente facile da ragionare e implementare correttamente.

Esistono diversi tipi di serrature per affrontare diversi modelli di concurrenza. I manubri causano processi di attesa per verificare continuamente se la serratura è diventata disponibile, consumando cicli di CPU ma evitando la sovraccarico del contesto di commutazione. Questo approccio funziona bene per brevi sezioni critiche in cui il tempo di attesa previsto è inferiore al costo di mettere un thread a dormire e svegliarlo.

Il lettore si blocca ottimizzando per scenari in cui i dati condivisi vengono letti frequentemente ma modificati in modo non frequente, ma questi blocchi consentono a più lettori di accedere simultaneamente alla risorsa, poiché la lettura non modifica i dati e le letture multiple contemporaneamente non possono interferire tra loro. Tuttavia, gli scrittori richiedono un accesso esclusivo, bloccando sia gli altri scrittori che i lettori.

Le serrature ricorsive, note anche come serrature reentrant, permettono allo stesso thread di acquisire la serratura più volte senza bloccarsi. La serratura mantiene un conteggio di quante volte è stata acquisita e richiede un numero uguale di release prima di essere disponibile ad altri thread. Questa funzione semplifica la programmazione in scenari in cui un thread potrebbe chiamare più funzioni che ogni necessità di acquisire la stessa serratura, evitando la complessità di tracciare se la serratura è già tenuta.

Semafori e Contare Meccanismi

Semaphores fornisce un meccanismo di sincronizzazione più flessibile di semplici serrature mantenendo un contatore interi che rappresenta il numero di risorse disponibili. I processi possono eseguire due operazioni atomiche su un semaforo: aspettare (chiamato anche P o down), che decrementa il contatore e blocca se il risultato sarebbe negativo, e il segnale (chiamato anche V o up), che aumenta il contatore e potenzialmente sveglia un processo di attesa.

I semafori binari, con valori limitati a 0 e 1, funzionano allo stesso modo per serrature e possono implementare l'esclusione reciproca. Tuttavia, il conteggio di semafori con valori più grandi consente modelli di coordinamento più sofisticati. Ad esempio, un semaforo inizializzato a N può controllare l'accesso a un pool di risorse identiche, come connessioni di database o slot buffer.

In questo scenario classico, i thread dei produttori generano elementi di dati e li collocano in un buffer limitato, mentre i thread dei consumatori rimuoveranno e elaborano gli elementi dal buffer. Due semaphore coordinano questa attività: uno tracciamento vuoto slot (inizialmente pari a dimensioni del buffer) e un altro tracciamento riempito slot (inizialmente zero).

Monitor e sincronizzazione ad alta velocità

I monitor forniscono un costrutto di sincronizzazione di alto livello che incapsula i dati condivisi con le procedure che lo operano, assicurando che solo un processo possa eseguire all'interno del monitor in qualsiasi momento. Questo incapsulamento semplifica la programmazione contemporaneamente rendendo implicita la sincronizzazione piuttosto che richiedere l'acquisizione e il rilascio di blocco espliciti. Il monitor acquisisce automaticamente una serratura quando un processo chiama una delle sue procedure e lo rilascia quando la procedura di rilascio di errori di programmazione si dimentica, riducendo il rischio.

Quando un processo scopre che non può procedere perché alcune condizioni non sono soddisfatte (ad esempio, un buffer è vuoto), può aspettare su una variabile di condizione, rilasciando il blocco del monitor e bloccando fino a quando un altro processo non segnala la condizione. Questo meccanismo evita frenetico-aspettando e consente un coordinamento efficiente di schemi di sincronizzazione complessi in cui la semplice esclusione reciproca è insufficiente.

Molti linguaggi di programmazione moderni incorporano i costrutti simili a monitor direttamente nella loro sintassi. I metodi sincronizzati di Java e i blocchi implementano la semantica del monitor, acquisiscono automaticamente e rilasciano le serrature associate agli oggetti. Il modulo di filettatura di Python fornisce oggetti Lock and Condition che permettono schemi simili. Queste caratteristiche di livello di lingua rendono la programmazione concorrente più accessibile e meno sicuro, trattando i dettagli di sincronizzazione a basso livello automaticamente.

Sistemi di memoria transazionali

La memoria transazionale rappresenta un cambiamento di paradigma nel controllo della convalutazione, ispirandosi al processo di transazione del database per semplificare la programmazione concorrenziale. Invece di acquisire esplicitamente blocchi, i programmatori contrassegnano blocchi di codice come transazioni atomiche. Il sistema traccia automaticamente gli accessi alla memoria all'interno della transazione e assicura che l'intera transazione sembra eseguire atomicamente rispetto ad altre transazioni, sia commettendo tutti i cambiamenti o aborti e rotolamento se vengono rilevati.

Quando inizia una transazione, il processore monitora i set di lettura e scrittura delle posizioni di memoria accessibili. Se un altro processore modifica una posizione nel set di lettura o accede a una posizione nel set di scrittura, viene rilevato un conflitto e una transazione deve interrompere e riprovare.

La memoria transazionale software (STM) fornisce simili semantiche senza richiedere il supporto hardware, utilizzando le librerie di compilatore e runtime per monitorare gli accessi alla memoria e gestire i conflitti. Mentre STM in genere incorre in una maggiore sovraccarico rispetto a HTM, offre una maggiore flessibilità nelle dimensioni delle transazioni e può implementare politiche di risoluzione dei conflitti più sofisticate.

L'appello della memoria transazionale è nella sua componibilità e semplicità. I programmatori possono scrivere codice che appare sequenziale all'interno delle transazioni, e il sistema gestisce automaticamente tutta la sincronizzazione. Le transazioni possono essere composte liberamente, ovvero la registrazione di una funzione transazionale dall'interno di un'altra transazione semplicemente estende la transazione esterna.

Algoritmi senza serrature e senza attesa

Gli algoritmi senza serrature e senza attesa forniscono il controllo della concurrenza senza usare i primitivi di bloccaggio tradizionali, invece basandosi sulle operazioni hardware atomiche come il confronto-e-swap (CAS) per coordinare l'accesso ai dati condivisi.

Gli algoritmi senza serrature garantiscono che almeno un thread faccia progressi in un numero limitato di passaggi, anche se altri filetti sono ritardati o sospesi. Questa proprietà assicura che il sistema nel suo complesso continui a fare progressi, anche se i singoli thread potrebbero essere ripetutamente pre-sentati e costretti a riprovare le loro operazioni.

Gli algoritmi senza attesa forniscono garanzie ancora più forti, assicurando che ogni thread completa il suo funzionamento in un numero limitato di passaggi indipendentemente dal comportamento di altri thread. Questa proprietà elimina la possibilità di fame e fornisce prestazioni prevedibili peggiori, rendendo gli algoritmi senza attesa attraenti per i sistemi in tempo reale. Tuttavia, gli algoritmi senza attesa sono tipicamente più complessi da progettare e possono avere una maggiore sovraccarica costante rispetto alle alternative senza blocco o basate su blocco.

Il funzionamento del confronto-e-swap costituisce la base della maggior parte degli algoritmi senza blocco e senza attesa. CAS confronta atomicamente una posizione di memoria a un valore atteso e, se corrispondono, aggiorna la posizione a un nuovo valore, restituisce il successo o il fallimento. Utilizzando CAS, gli algoritmi possono implementare il controllo di convalutazione ottimista dove i thread effettuano operazioni speculativamente e utilizzano CAS per commettere modifiche solo se non si verificano conflitti.

Read-Copy-Update (RCU) Meccanismo

Read-Copy-Update (RCU) è un meccanismo di sincronizzazione specializzato ottimizzato per i carichi di lavoro in lettura-pesanti dove legge scriva molto più in alto numero. RCU consente ai lettori di accedere alle strutture di dati condivise senza acquisire serrature o eseguire operazioni atomiche, ottenendo un overhead estremamente basso per le operazioni di lettura.

La chiave intuizione dietro RCU è che i lettori possono tollerare di vedere dati leggermente stanti in molti scenari, purché i dati che osservano siano internimente coerenti. Quando uno scrittore ha bisogno di modificare una struttura di dati condivisa, crea una nuova versione con i cambiamenti desiderati e aggiorna atomicamente un puntatore per riferire la nuova versione.

RCU è diventato sempre più importante nei kernel del sistema operativo, in particolare Linux, dove consente un accesso di lettura altamente scalabile alle strutture dei dati del kernel. Il kernel Linux utilizza RCU estesamente per la gestione di tabelle di routing di rete, metadati del file system e liste di processo, tra le altre applicazioni. La capacità di eseguire le letture senza sovraccarico di sincronizzazione rende RCU ideale per i percorsi caldi nel kernel dove anche il costo delle operazioni atomiche sarebbe proibitivo.

Prevenzione e rilevamento di Deadlock

I Deadlock rappresentano uno dei problemi più impegnativi nei sistemi concomitanti, che si verificano quando i processi vengono bloccati indefinitamente, in attesa di risorse detenute da altri in una dipendenza circolare. I sistemi operativi devono impiegare strategie per evitare che i deadlocks si verifichino, rilevarli quando si verificano, o recuperare da loro con grazia.

Condizioni necessarie per Deadlock

In primo luogo, l'esclusione reciproca richiede che le risorse non possano essere condivise e devono essere tenute esclusivamente da un processo alla volta. In secondo luogo, tenere e aspettare significa che i processi che detengono risorse possono richiedere risorse aggiuntive senza rilasciare quelle che già detengono. In terzo luogo, nessuna preensione indica che le risorse non possono essere prese in modo forzato dai processi; devono essere rilasciate volontariamente.

La comprensione di queste condizioni fornisce una panoramica delle strategie di prevenzione dei blocchi morti. Assicurando che almeno una di queste quattro condizioni non possa contenere, il sistema può garantire che i blocchi non si verifichino mai. Tuttavia, impedendo che ogni condizione venga con compromessi in termini di utilizzo delle risorse, complessità del sistema e convenienza di programmazione, richiedendo un'attenta considerazione dei requisiti specifici e vincoli del sistema in fase di progettazione.

Strategie di prevenzione di Deadlock

Per eliminare la presa e l'attesa, i sistemi possono richiedere processi per richiedere tutte le risorse necessarie atomicamente all'inizio dell'esecuzione. Questo approccio garantisce che un processo o acquisisca tutte le risorse e provenga o non acquisisce né attende, impedendo l'allocazione parziale delle risorse che porta a deadlock.

Permettendo di interrompere la prelazione, la condizione di non prelazione, consentendo al sistema di recuperare forzatamente le risorse dai processi. Quando un processo richiede una risorsa non disponibile, il sistema può prelevare risorse da altri processi di attesa e allocarle al richiedente. Questo approccio funziona bene per le risorse il cui stato può essere facilmente salvato e ripristinato, come i registri della CPU o le pagine di memoria, ma è problematico per le risorse come le stampanti o le serrature del database in cui la preenzione potrebbe essere eseguita.

Se tutti i processi seguono questo protocollo, le dipendenze circolari non possono formarsi perché un processo che tiene una risorsa più alta non richiede mai una minore quantità di risorse che potrebbe essere tenuta da un processo in attesa delle sue risorse. Questo approccio è pratico e ampiamente utilizzato, anche se richiede un'attenta progettazione dell'ordine delle risorse e può essere restrittivo per le applicazioni con complessi modelli di accesso alle risorse.

Rilevamento e recupero di Deadlock

Piuttosto che prevenire i deadlock, alcuni sistemi permettono loro di verificarsi ma periodicamente controllare la loro presenza e prendere azione correttiva quando rilevato.

Una volta rilevato un deadlock, il sistema deve recuperare rompendo l'attesa circolare. L'approccio più drastico è quello di terminare uno o più processi coinvolti nel deadlock, liberando le proprie risorse per altri processi. Il sistema potrebbe terminare il processo con la minor quantità di lavoro completato, la priorità più bassa, o quella che tiene le risorse più necessarie da altri. La risoluzione del processo è efficace ma spreco, come tutto il lavoro eseguito dal processo terminato è perso.

La prelazione delle risorse offre un meccanismo di recupero meno drastico, prendendo forza le risorse dai processi e allegandole ad altri. Il processo preento deve essere ripiegato in uno stato sicuro prima di aver acquisito la risorsa predetta, richiedendo meccanismi di controllo per salvare lo stato di processo periodicamente. Il sistema deve anche proteggere contro la fame, assicurando che lo stesso processo non sia più selezionato per la prelazione.

Tecniche di evitamento di Deadlock

L'elusione di Deadlock rappresenta un terreno centrale tra prevenzione e rilevamento, utilizzando informazioni sulle future richieste di risorse per prendere decisioni di allocazione che mantengono il sistema in uno stato sicuro. Uno stato è sicuro se esiste una sequenza in cui tutti i processi possono completare, anche nel peggiore dei casi in cui ogni processo richiede immediatamente la massima risorsa. L'algoritmo del banchiere è l'esempio classico di elusione di deadlock, simulando l'assegnazione delle risorse per determinare se concedere una richiesta lascerebbe il sistema in uno stato sicuro.

Quando un processo richiede risorse, l'algoritmo garantisce provvisoriamente la richiesta e verifica se lo stato risultante è sicuro tentando di trovare una sequenza in cui tutti i processi possono completare. Se tale sequenza esiste, la richiesta è concessa; altrimenti, il processo deve aspettare fino a quando la richiesta non sarà sicura. Questo approccio garantisce la libertà di blocco ma richiede una conoscenza anticipata delle esigenze delle risorse e può essere conservatore, negando le richieste che potrebbero essere di piombo morto.

Importanza del controllo di competitività nelle prestazioni del sistema

Il rapporto tra controllo della concurrenza e prestazioni è complesso, coinvolgendo i trade-off tra parallelismo, sincronizzazione overhead e garanzie di correttezza. Capire questi trade-off consente ai progettisti di sistema di ottimizzare le prestazioni mantenendo l'affidabilità e la coerenza che gli utenti si aspettano.

Massimizzazione dell'utilizzo della CPU e del throughput

Un controllo di concurrency corretto consente di eseguire più processi in parallelo, massimizzando l'utilizzo della CPU attraverso processori multi-core. Quando un blocco di processo in attesa di I/O o altre risorse, altri processi possono continuare ad eseguire, assicurando che i core della CPU rimangano produttivi piuttosto che seduti inattivo.

Il grado di parallelismo raggiungibile dipende in modo critico dalla granularità della sincronizzazione. L'incollaggio grossolano, dove una singola serratura protegge grandi strutture di dati o interi sottosistemi, è semplice da implementare e la ragione circa ma limita il parallelismo costringendo i processi ad aspettare anche quando si accede a diverse parti della risorsa protetta.

Quando più processi competono frequentemente per le stesse serrature, spendono tempo significativo in attesa piuttosto che eseguire il lavoro utile. Alta contention può effettivamente rendere un programma parallelo più lento di una versione sequenziale a causa della sovraccarico di sincronizzazione e traffico di coerenza cache. Ridurre la contention attraverso tecniche come algoritmi senza blocco, lettura-aggiornamento, o riprogettare molte strutture di dati per ridurre al minimo la buona scalabilità.

Ridurre la resistenza e migliorare la responsabilità

I meccanismi di controllo della concorrenza influiscono significativamente sulla latenza e sulla reattività del sistema, in particolare per le applicazioni interattive in cui gli utenti si aspettano un feedback immediato.Il controllo della concurrenza ben progettato consente alle attività ad alta priorità di procedere rapidamente senza essere bloccati da operazioni di sfondo a bassa priorità.

La scelta dei primitivi di sincronizzazione colpisce le caratteristiche di latenza. Spinlocks minimizza la latenza per brevi sezioni critiche evitando l'interruttore di contesto in testa, ma i cicli di CPU rifiuti e può aumentare la latenza se la serratura è tenuta più lunga del previsto. Bloccaggio serrature ridurre i rifiuti della CPU ma incur contesto switch overhead che può aggiungere millisecondi di latenza.

Considerazioni di scalabilità

La scalabilità ideale vedrebbe aumentare le prestazioni in linea con il numero di core della CPU, ma la sincronizzazione sovraccarica e la contention tipicamente limitano la scalabilità nella pratica. La legge di Amdahl quantifica questa limitazione, mostrando che la velocità massima raggiungibile attraverso la parallelizzazione è limitata dalla frazione del programma che deve eseguire sequenzialità, compreso il tempo trascorso in sezioni critiche protette da serrature.

La realizzazione di una buona scalabilità richiede la minimizzazione dei punti di serializzazione dove tutti i processi devono coordinarsi. Tecniche come le strutture di dati per-CPU, dove ogni processore mantiene la propria copia dei dati frequentemente accessibili, eliminando la contention evitando la condivisione del tutto. Quando è necessario il coordinamento globale, i primitivi di sincronizzazione scalabile come le serrature atomiche MCS o le serrature gerarchiche riducono la contention organizzando processi di attesa in code o alberi piuttosto che avere tutti i processi competere per una singola variabile.

Le architetture non uniformi di accesso alla memoria (NUMA) introducono ulteriori sfide di scalabilità, poiché la latenza di accesso alla memoria dipende da quali processori e nodi di memoria sono coinvolti. I meccanismi di controllo della concorrenza devono essere NUMA-aware, preferendo allocare le strutture di dati in memoria locale ai processori che li accederanno più frequentemente.

Efficienza energetica e gestione della potenza

Il controllo della concorrenza influisce sull'efficienza energetica, una considerazione sempre più importante nel moderno calcolo da dispositivi mobili a data center. Spinlocks spreco energetico mantenendo attivo i core della CPU durante l'attesa, mentre i blocchi consentono ai core di entrare in stati di bassa potenza durante i periodi di inattività. La scelta del meccanismo di sincronizzazione dovrebbe considerare il consumo energetico accanto alle prestazioni, in particolare nei dispositivi alimentati a batteria, dove l'efficienza energetica influisce direttamente sulla durata della batteria.

Il controllo efficace della concurrenza consente una migliore gestione dell'energia, consentendo al sistema di consolidare il lavoro su un numero minore di core e di abbassare i core inutilizzati. Quando i processi possono eseguire in parallelo senza sovraccarico di sincronizzazione eccessiva, il sistema può completare i lavori in modo rapido e inserire gli stati a bassa potenza prima.

Controllo della frequenza in diversi componenti del sistema operativo

Il controllo della concorrenza si concentra su ogni livello di sistemi operativi moderni, dai primitivi del kernel a basso livello ai servizi di sistema di alto livello. I diversi componenti affrontano sfide di concurrenza uniche e impiegano tecniche specializzate ottimizzate per le loro specifiche esigenze. Capire come il controllo della convaluta è applicato in tutto il sistema operativo fornisce una panoramica delle considerazioni pratiche e dei trade-off coinvolti nella costruzione di sistemi robusti e ad alte prestazioni.

Gestione dei processi e dei filetti

Il programmatore di processo e thread deve coordinare l'accesso alle strutture di dati di pianificazione, mentre prende decisioni rapide su quali processi eseguire. Le strutture di dati di pianificazione tracciano code pronte, stati di processo, priorità e affinità della CPU, tutte accessibili e modificate da più processori contemporaneamente.

Quando viene creato un thread, il sistema deve assegnare e inizializzare lo storage thread-local, aggiornare i conteggi di filettatura su scala di processo e aggiungere il nuovo thread alle strutture di dati di programmazione, il tutto assicurando che altri thread nello stesso processo vedano lo stato coerente.

Gestione della memoria Subsystem

La gestione della memoria comporta un ampio controllo della concurrency per coordinare l'allocazione della pagina, la mappatura della memoria virtuale e la sostituzione della pagina tra più processi e processori. L'allocatore della pagina deve sincronizzare l'accesso alle liste di pagina libere e alle strutture di dati del sistema di amico pur mantenendo buone prestazioni sotto alti tassi di allocazione.

Le operazioni di memoria virtuale come la mappatura e le pagine di sbavatura richiedono il coordinamento degli aggiornamenti alle tabelle di pagina con l'invalidità di TLB (Translation Lookaside Buffer) in tutti i processori. Quando viene modificata una voce della tabella di pagina, il sistema deve garantire che tutti i processori arrossino le voci TLB prima che possano accedere agli indirizzi virtuali interessati con le vecchie traduzioni.

L'algoritmo di sostituzione della pagina deve coordinarsi con la gestione dei guasti della pagina per selezionare le pagine delle vittime per evitare che la memoria sia scarsa. I processori multipli possono contemporaneamente verificare errori di pagina e devono assegnare le pagine, richiedendo la sincronizzazione per garantire che la stessa pagina non sia selezionata come una vittima più volte e che le informazioni di riferimento della pagina utilizzate dall'algoritmo di sostituzione rimangano coerenti.

Concorrenza del sistema di file

I sistemi di file affrontano complesse sfide di concurrency nella gestione delle strutture di metadati come inodi, voci di directory e bitmap di spazio libero, garantendo la coerenza del crash e fornendo buone prestazioni per le operazioni di file contemporaneamente.

I sistemi di file moderni impiegano sofisticate gerarchie di bloccaggio per consentire operazioni concorrenziali. Le serrature separate proteggono singoli inodi, voci di directory e blocchi di dati, permettendo operazioni su diversi file di procedere in parallelo. Le serrature di gamma consentono di leggere o scrivere diverse porzioni dello stesso file contemporaneamente, migliorando le prestazioni per i file di grandi dimensioni accessibili da processi multipli.

I file system di ricerca e di log-strutturati utilizzano i log di sola accettazione per serializzare gli aggiornamenti, semplificando il controllo della convaluta evitando gli aggiornamenti in-place alle strutture di dati condivise. I processi multipli possono preparare i loro aggiornamenti in modo indipendente e poi applicarli al log in modo serializzato, con i processi di sfondo che in seguito applicano gli aggiornamenti registrati alle principali strutture del file system.

Driver per il sottosistema I/O e i dispositivi

Il sottosistema I/O coordina l'accesso ai dispositivi hardware tra più processi, mentre gestiscono operazioni asincroni e interrompo. I driver del dispositivo devono sincronizzarsi tra il codice di contesto di processo che avvia le operazioni I/O e interrompe i manutentori che elaborano le notifiche di completamento, tipicamente utilizzando spinlock che disabilitano gli interruttori per prevenire i blocchi di blocco tra interruttori e contesti di processo.

I processi multipli possono presentare le richieste I/O contemporaneamente, richiedendo aggiornamenti atomici alle strutture dei dati di coda. L'elaborazione di completamento deve coordinarsi con la presentazione della richiesta per garantire che le richieste completate siano correttamente abbinate ai loro iniziatori e che le risorse siano liberate correttamente. Le code senza blocco sono sempre più utilizzate per la gestione delle richieste I/O per ridurre la sovraccaricazione dei dispositivi di storage NSD.

Convalutazione della rete

Gli stack di protocollo di rete devono gestire l'elaborazione dei pacchetti concomitanti in più interfacce di rete e core della CPU, mantenendo le macchine di stato del protocollo e le tabelle di connessione. Le moderne tecniche di rete utilizzano le tecniche come la scalatura del lato ricevente (RSS) per distribuire i pacchetti in entrata in più core della CPU basati su reti di flusso, consentendo l'elaborazione parallela di flussi di rete diversi senza sincronizzazione.

I buffer di socket e lo stato di connessione richiedono un'attenta sincronizzazione tra i filetti di applicazione che eseguono operazioni di invio e ricevono e i filetti del kernel elaborano pacchetti in arrivo e gestiscono timer di protocollo. Le serrature per-socket proteggono lo stato di connessione, mentre le tecniche prive di blocco gestiscono code di pacchetti per minimizzare la sovraccarico di sincronizzazione nel percorso veloce.

Sfide e direzioni future

La crescente prevalenza di processori di molti core, architetture di calcolo eterogenee e sistemi distribuiti richiede nuovi approcci per gestire le operazioni concorrenziali. Capire tendenze emergenti e direzioni di ricerca aiuta a preparare per la prossima generazione di progettazione del sistema operativo.

Sistemi eterogenei e di molti costi

La tendenza verso i processori con decine o centinaia di core sfida approcci tradizionali di controllo della concurrenza che sono stati progettati per sistemi con una manciata di processori. I meccanismi di sincronizzazione che funzionano bene con 2-8 core possono non scalare a 64 o 128 core a causa di una maggiore contesa e coerenza della cache sovraccarica.

I sistemi eterogenei che combinano core CPU generali con acceleratori specializzati come GPU, FPGAs e processori AI presentano nuove sfide di concurrency. Questi acceleratori hanno spesso i propri spazi di memoria e modelli di esecuzione, richiedendo meccanismi di coordinamento che abbracciano diversi tipi di processori e sistemi di memoria.

Memoria persistente e nuove tecnologie di storage

Tecnologie di memoria persistenti come Intel Optane sfocano la linea tra memoria e storage, fornendo memoria non volatile e persistente con latenute che si avvicinano a DRAM. Queste tecnologie sfidano le ipotesi tradizionali sulla separazione tra stato volatile e persistente, richiedendo nuovi meccanismi di controllo della concurrenza che garantiscono sia la consistenza che il recupero di crash.

Le caratteristiche di performance della memoria persistente richiedono un'attenta attenzione alla sincronizzazione in testa. Gli approcci tradizionali che assumono operazioni di storage sono lenti e rari possono introdurre overhead inaccettabile quando applicato alla memoria persistente con le latencies di accesso su scala nanoseconda.

Verifica formale e correttezza

La complessità dei sistemi concomitanti li rende notoriamente difficili da testare e debug, poiché le condizioni di gara e altri bug di convalutazione possono manifestarsi solo in condizioni di tempistiche specifiche che sono difficili da riprodurre.

Diversi componenti del sistema operativo sono stati formalmente verificati, dimostrando che le prove di correttezza rigorose sono fattibili anche per sistemi concomitanti complessi. Il microkernel seL4 fornisce una implementazione completamente verificata con prove matematiche di correttezza funzionale, compresi i suoi meccanismi di controllo della concurrenza.

Controllo di competitività e apprendimento della macchina

Le tecniche di apprendimento delle macchine offrono approcci promettenti per il controllo della convalutazione adattativo che regola le strategie di sincronizzazione basate sulle caratteristiche del carico di lavoro osservato. Piuttosto che usare politiche fisse, i sistemi potrebbero imparare la granularità di blocco ottimale, la durata del giro, o le decisioni di pianificazione basate sul comportamento di runtime.

I modelli predittivi potrebbero anticipare la contention e regolare proattivamente i meccanismi di sincronizzazione per evitare strozzature. Ad esempio, un sistema potrebbe prevedere quando la contention di serratura è probabile che aumenti e cambi da fine-grained a chiusura grezzo-grained, o viceversa, per ottimizzare il modello di accesso previsto.

Sicurezza e competitività

I meccanismi di controllo della concorrenza possono introdurre vulnerabilità di sicurezza se non accuratamente progettate. Le condizioni di gara possono essere sfruttate dagli aggressori per aggirare i controlli di sicurezza o corrotte strutture di dati critici.

Gli attacchi laterali sfruttano le variazioni di temporizzazione dei meccanismi di sincronizzazione per divulgare informazioni sulle operazioni concorrenti. Ad esempio, un aggressore potrebbe dedurre informazioni sulle chiavi crittografiche osservando i modelli di conteggiamento di blocco o il comportamento della cache durante le operazioni di crittografia concomitante.

Migliori Pratiche per l'attuazione del controllo di concorrenza

L'implementazione di un efficace controllo della convalutazione richiede un'attenta progettazione, un'attenta analisi e un'aderenza alle migliori pratiche stabilite. Mentre le tecniche specifiche variano a seconda del sistema e del carico di lavoro, alcuni principi si applicano in larga misura in diversi contesti.

Principi di progettazione

Inizia con il più semplice meccanismo di sincronizzazione che soddisfa i requisiti, aggiungendo complessità solo quando necessario. L'incollaggio a grana grossolana è più facile da ragionare su e meno inclini a bug che gli approcci finiti, rendendolo un buon punto di partenza.Profilo il sistema per identificare i colli di bottiglia effettivi prima di ottimizzare la sincronizzazione, come l'ottimizzazione prematura spesso introduce complessità senza corrispondenti prestazioni vantaggi.

Minimizza la portata e la durata delle sezioni critiche per ridurre la contesa e migliorare il parallelismo. Spostare le operazioni che non richiedono la sincronizzazione al di fuori delle sezioni critiche, e evitare di eseguire operazioni costose come I/O o l'allocazione della memoria durante la tenuta di serrature.

Stabilire e documentare le convenzioni di ordinazione per prevenire i deadlocks. Quando devono essere acquisiti più serrature, sempre acquisiscono in un ordine coerente su tutti i percorsi di codice. Utilizzare le gerarchie di blocco dove le serrature di livello superiore sono sempre acquisite prima di serrature di livello inferiore, e non tentare mai di acquisire una serratura di livello superiore mentre si tiene una inferiore livello.

Test e debug di sistemi concomitanti

I test di stringa con alti livelli di concurrency possono esporre le condizioni di gara e i blocchi di blocco che potrebbero non apparire sotto carichi leggeri. Strumenti come i sanitizer di filo rilevano le corse strumentali mediante l'accesso alla memoria e il monitoraggio delle operazioni di sincronizzazione, segnalando quando più fili si trovano nella stessa posizione della memoria senza una corretta sincronizzazione.

Questi strumenti utilizzano tecniche come la programmazione controllata o il controllo del modello per eseguire lo stesso caso di prova con diversi programmi di thread, aumentando la probabilità di attivare bug dipendente dai tempi. Mentre l'esplorazione esaustiva è generalmente inaffidabile per grandi sistemi, l'esplorazione mirata delle sezioni critiche e le operazioni di sincronizzazione possono trovare molti bug di carenza tradizionali.

Registrazione e monitoraggio aiutano a diagnosticare problemi di concurrency nei sistemi di produzione. Registrazione di eventi di acquisizione e rilascio di blocco, insieme a timestamp e identificatori di filetto, consente analisi post-mortem di deadlock e problemi di prestazioni.

Ottimizzazione delle prestazioni

Strumenti come perf su Linux possono misurare la contention di blocco, manca di cache e altre metriche di performance relative alla sincronizzazione.

Le strutture di dati Per-CPU evitano la sincronizzazione del tutto dando a ciascun processore la propria copia di dati frequentemente accessibili.Leggere-copia-aggiornamento consente letture senza blocco per le strutture di dati che vengono lette frequentemente ma aggiornate raramente.Gli algoritmi senza serratura che utilizzano operazioni atomiche possono fornire una migliore scalabilità rispetto agli approcci basati su blocco per determinati modelli di accesso, anche se sono più complessi da implementare correttamente.

Blocchi adattativi che girano brevemente prima di bloccare bene quando le sezioni critiche sono brevi, ma i cicli di CPU di scarto quando le serrature sono tenute per periodi più lunghi. La durata ottimale di rotazione dipende da fattori come il tempo di attesa di bloccaggio, il numero di thread concorrenti, e il costo di commutazione di contesto.

Esempi reali e studi di casi

Esaminando come i sistemi operativi reali implementano il controllo della convalutazione fornisce preziose informazioni sulle decisioni pratiche di progettazione e i trade-off. Diversi sistemi hanno sviluppato approcci diversi basati sulle loro filosofie di progettazione, sui carichi di lavoro di destinazione e sui contesti storici.

Concorrenza del kernel di Linux

Il kernel Linux impiega un sofisticato mix di meccanismi di controllo della concurrency ottimizzati per la scalabilità su grandi sistemi multi-core. Il kernel utilizza spinlocks per proteggere le sezioni critiche brevi, con varianti di spinlock separate per diversi contesti come i maneggiatori di interruttori e il codice di processo.

Le variabili per-CPU di Linux eliminano la sincronizzazione per i contatori e le statistiche di accesso frequente mantenendo copie separate per ogni processore. Il kernel aggrega questi valori per-CPU quando sono necessari totali globali, scambiando opinioni globali leggermente stanti per una sovraccarica sincronizzazione drasticamente ridotta. Questo approccio ha dimostrato altamente efficace per la scalabilità, permettendo a Linux di utilizzare efficacemente i sistemi con centinaia di core CPU.

Il programmatore completamente equo (CFS) in Linux utilizza code di corsa per-CPU con bilanciamento del carico per minimizzare la sovraccarico di sincronizzazione mentre distribuendo il lavoro uniformemente attraverso i processori. Ogni CPU pianifica principalmente i processi dalla propria coda di corsa, acquisendo solo le serrature sulle code di esecuzione di altre CPU quando rubano il lavoro durante i periodi di inattività.

Sincronizzazione del kernel di Windows

Windows utilizza un ricco insieme di primitivi di sincronizzazione tra cui mutexe, semafori, eventi e sezioni critiche, ciascuna ottimizzata per diversi casi di utilizzo. Il kernel fornisce sia spinlock per brevi sezioni critiche e oggetti di dispacciatore che si integrano con il programmatore per più lunghe attese.

Il sottosistema Windows I/O utilizza ampiamente I/O asincrono, consentendo alle applicazioni di avviare le operazioni e continuare a eseguire durante la completa I/O. Questo approccio riduce la necessità di più thread per raggiungere la convalutazione, in quanto un singolo thread può gestire più operazioni I/O eccezionali. Le porte di completamento forniscono un meccanismo efficiente per gestire i completamento I/O su più thread, consentendo applicazioni server scalabili.

macOS e XNU Kernel

Il kernel XNU macOS e iOS combina elementi di Mach e BSD, utilizzando un approccio ibrido al controllo della concurrency. Il kernel impiega un mix di mutexe, spinlock e serrature di lettura, con un'attenta attenzione a bloccare l'ordine per prevenire i deadlock. Il framework I/O Kit utilizza code di lavoro per serializzare le operazioni sui driver del dispositivo, semplificando lo sviluppo del driver riducendo la necessità di sincronizzazione esplicita del driver.

Grand Central Dispatch (GCD) fornisce un framework di alta convalutazione per applicazioni, astrattando la gestione del thread e la sincronizzazione dietro un modello di programmazione basato su task. Le applicazioni inviano blocchi di codice per inviare code, e il sistema gestisce automaticamente i pool di thread e il bilanciamento del carico. Questo approccio semplifica la programmazione concomitante per gli sviluppatori di applicazioni, consentendo al sistema di ottimizzare l'utilizzo del thread e ridurre la sincronizzazione in testa.

Conclusioni

Il controllo della concorrenza è un pilastro fondamentale del moderno sistema operativo, che consente ai sistemi di sfruttare la potenza dei processori multi-core mantenendo la correttezza e l'affidabilità. Da serrature di base e semafori a sofisticati algoritmi di memoria transazionale e di blocco, il ricco kit di strumenti di controllo della convalutazione fornisce ai progettisti di sistema opzioni per soddisfare esigenze e carichi di lavoro diversi. La scelta di tecniche appropriate richiede un'attenta considerazione dei compromessi tra prestazioni, la complessità.

Mentre i sistemi di calcolo continuano ad evolversi verso un maggior parallelismo, un'eterogeneità e una scala, il controllo della convalutazione rimarrà un'area critica di ricerca e sviluppo. Le tecnologie emergenti come la memoria persistente, i processori di molti-core e gli acceleratori specializzati richiedono nuovi approcci che vanno oltre i meccanismi di sincronizzazione tradizionali. L'integrazione di verifica formale, apprendimento automatico e tecniche adattative promette di rendere i sistemi concorrenti più robusti ed efficienti, anche se le sfide significative rimangono nella gestione di approcci avanzati.

Per gli sviluppatori di sistemi e gli architetti, il controllo della convalutazione è essenziale per la costruzione di sistemi affidabili e ad alte prestazioni. La comprensione dei principi fondamentali, dei meccanismi disponibili e delle considerazioni pratiche consente di prendere decisioni di progettazione informate che bilanciano i requisiti concorrenti.

Il viaggio dalla semplice esclusione reciproca alla sofisticata memoria transazionale e agli algoritmi senza blocco riflette l'evoluzione continua dei sistemi di calcolo e la persistente sfida di coordinare le attività concorrenziali in modo efficiente e corretto.