Come fa le operazioni di Go Runtime Handle Channel internamente

I canali in Go sono attualmente implementati come la struttura dei dati `hchan`, che incapsula lo stato del canale incluso il suo buffer, le code di mittenti e ricevitori in attesa, primitivi di sincronizzazione e meta informazioni come se il canale è chiuso. Quando viene creato un canale, un'istanza di `hchan` viene assegnata sul heap e il valore che rappresenta i punti del canale di questa struttura, consentendo a più goroutine di fare riferimento e utilizzarlo contemporaneamente.

Al centro, un canale è composto da:

- Un buffer circolare per i canali tamponati, rappresentato da una fetta e indici `Sendx` e` recvx` che traccia dove inviare e ricevere elementi, rispettivamente. La dimensione del buffer è fissata sulla creazione del canale e funge da coda che memorizza elementi inviati ma non ancora ricevuti.
- Due code di attesa FIFO (elenchi collegati) per la gestione di goroutine bloccate durante l'invio (`Sendq`) e la ricezione (` recvq`). Queste code archiviano le strutture `Sudog`, che rappresentano la goroutine bloccata e i dati correlati per le operazioni del canale come il valore da inviare o un puntatore a dove ricevere un valore.
- Un blocco Mutex per proteggere l'accesso concorrente alle strutture interne del canale, garantendo che le operazioni di invio e ricezione mantengano coerenza e non corrompano lo stato del canale sotto accesso simultaneo.

Canale Invia operazione

Quando una goroutine tenta di inviare un valore a un canale (`CH E Operation

L'operazione di ricezione (lexity:

1. Acquisizione di blocco: il mutex del canale è bloccato.

2. Controlla i mittenti in attesa: se c'è un mittente in attesa in `Sendq`:
- Il ricevitore prende il valore direttamente da "Sudog" del mittente.
- Il mittente è dequeed e marcato eseguibile.
- Entrambe le goroutine procedono immediatamente senza buffering.

3. Controlla il buffer per i canali bufferizzati: se nessun mittente è in attesa:
- Il canale controlla se il suo buffer contiene elementi.
- In tal caso, un elemento viene copiato dalla posizione del tampone `buf [recvx]`.
- L'indice `recvx` viene incrementato e` qCount` viene decrementato.
- Il blocco viene rilasciato e il ricevitore continua senza bloccare.

4. Blocco del ricevitore: se il buffer è vuoto e nessun mittente sta aspettando:
- La goroutine del ricevitore è rappresentata come un `Sudog`.
- È tenuto in `recvq`.
- Il ricevitore è parcheggiato dallo Scheduler fino a quando un'operazione di invio non si sblocca.

5. CHIUSH CANNEL Riceve: se il canale è chiuso e il buffer è vuoto:
- riceve restituire il valore zero del tipo di elemento.
- I ricevitori non bloccano e possono rilevare lo stato chiuso per il secondo booleano restituito dall'operazione di ricezione.

6. Equità e ordine: i ricevitori in attesa sono dequeati FIFO per mantenere l'equità e la programmazione rispetta i vincoli di ordinazione ma non garantisce un ordine di temporizzazione rigoroso a causa del comportamento dello scheduler.

Integrazione di parcheggio e programmazione

I canali sono strettamente integrati con lo scheduler di goroutine di GO, che gestisce il ciclo di vita da goroutine utilizzando tre entità:

- G (Goroutine): thread leggero a livello di utente.
- M (macchina): thread del sistema operativo che esegue goroutine.
- P (processore): detiene una coda locale di goroutine e risorse eseguite per eseguire il codice GO.

Quando un'operazione di canale blocca (inviare o ricevere), la goroutine:

- è contrassegnato come in attesa.
- viene rimosso dalla coda di corsa locale del possesso di `p`.
- è collegato tramite una struttura `Sudog` nella rispettiva coda del canale (` Sendq` o `recvq`).
- Lo Scheduler raccoglie quindi un'altra goroutine eseguibile per correre su quel `p`.

Quando l'operazione bloccata diventa pronta per il completamento (ad esempio, si verifica una controparte invio o ricezione):

- La goroutine in attesa è dequeata dalla coda del canale.
- contrassegnato.
- Punito su una coda di corsa locale o globale per la pianificazione.
- La goroutine alla fine riprenderà l'esecuzione.

Questo design evita di aspettare e garantisce un efficiente commutazione di contesto con un sovraccarico minimo rispetto al blocco tradizionale del filo del sistema operativo.

operazione chiusura del canale

La chiusura di un canale imposta una bandiera `chiusa 'in` hchan` protetto dallo stesso mutex. La chiusura di un canale provoca quanto segue:

- Tutti i mittenti bloccati si fanno prendere dal panico se si tenta di inviare.
- Tutti i ricevitori bloccati non sono bloccati in ordine FIFO per ricevere valori bufferiti rimanenti e quindi valori zero.
- Riceve ulteriormente i valori di reso zero immediatamente senza bloccare.
- Invio immediatamente su un canale chiuso.
- L'operazione ravvicinata è anche sincronizzata con le operazioni del canale attraverso Mutex per evitare le condizioni di gara.

Strutture di dati interni

- Hchan: struggista centrale:
- `buf` (puntatore per array buffer)
- `dataqsiz` (dimensione del buffer)
- `QCOUNT` (Conte di elementi attualmente bufferiti)
- `sendx`,` recvx` (indici buffer)
- `Sendq`,` recvq` (attesa code per mittenti e ricevitori bloccati)
- Flag `chiuso
- Mutex incorporato (per proteggere lo stato e coordinare più operazioni simultanee).

- Sudog: struttura di runtime interna che rappresenta una goroutine in attesa di un'operazione di canale. Contiene:
- Un puntatore alla goroutine.
- Puntatori ai dati inviati o ricevuti.
- Collegamenti al prossimo `Sudog` nella coda di attesa.

- WaitQ: elenco collegato di Sudogs che rappresentano i camerieri SEND (`Sendq`) o ricevono camerieri (` recvq`). Garantire l'equità FIFO.

Seleziona istruzione e canali

L'istruzione `Select` di GO introduce complessità perché le operazioni di canali multiple competono contemporaneamente. Il runtime gestisce più code di attesa per ogni caso di selezione e la selezione da più canali offline prevede:

- Provare operazioni non bloccanti su ogni caso.
- Se nessuno procede, accenire la goroutine su tutte le code pertinenti.
- Quando un'operazione può procedere, altri camerieri vengono rimossi e la goroutine sblocca.

Questo meccanismo di attesa selettivo è profondamente integrato con lo scheduler di runtime per mantenere l'equità e l'efficienza.

Considerazioni su prestazioni e concorrenza

Il design del canale si impegna per l'equilibrio tra sicurezza e prestazioni:

- Mutex Blocking: garantisce coerenza ma può diventare un collo di bottiglia con una contesa molto elevata. Il runtime mantiene brevemente il blocco per aggiornare atomicamente lo stato.
- Direct Handoff: evita il sovraccarico del buffer quando possibile, consentendo una comunicazione più rapida tra le goroutine.
- Parcheggio e impossibile: riduce al minimo le spese generali di commutazione del contesto rispetto ai thread del sistema operativo.
- Equità: applicato tramite code FIFO per prevenire la fame.
- Cache e località: le goroutine non accardate possono riprendere a processori diversi (`P`s), portando probabilmente alle mancate mancate cache.
- Problema di branco tuonante: chiudere un canale o trasmettere può svegliare molte goroutine contemporaneamente, che devono essere gestite con giudizio dallo scheduler.

I canali rappresentano un'elegante primitiva di concorrenza che accoppia un tampone ad anello protetto con blocco con meccanismi di pianificazione delle goroutine, fornendo sicurezza, ordinamento ed efficienza nei programmi GO.