Protocolli di coerenza della cache (esempi)
{{torna a|Memoria cache}}Vengono qui elencati esempi dei protocolli di coerenza per la memoria cache. Per semplicità tutte le transazioni di stato di Read e Write "miss" che ovviamente provengono dallo stato '''I''' (o miss di Tag), nei diagrammi non sono mostrate. Sono mostrate direttamente sul nuovo stato. Molti dei seguenti protocolli hanno solo valore storico. Al momento i principali protocolli usati sono i protocolli [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] (tipo [[#Protocollo MESI|MESI]]) e il [[#Protocollo HRT-ST-MESI|HRT-ST-MESI]] (tipo [[#Protocollo MOESI|MOESI]]) o un sottoinsieme o un'estensione di questi.

== Problema di coerenza della cache (''cache coherency'') ==

Nei sistemi come il [[Sistema multiprocessore simmetrico|multiprocessore simmetrico (SMP)]], il [[multi core]] e il [[Non-Uniform Memory Access|cc-NUMA]], dove viene usata una cache dedicata per ogni [[processore]], [[Core (informatica)|core]] o [[#Directory-based - Message-passing|nodo]], si può verificare un problema di coerenza dei dati quando uno stesso dato è memorizzato in più di una cache viene modificato in una cache. Può essere risolto in due modi:

# invalidando tutte le copie delle altre cache (broadcast-invalidate - diffusione invalidazione);
# aggiornando tutte le copie delle altre cache (write-broadcasting - diffusione scrittura).

In entrambi i casi la memoria può essere aggiornata (write through) o non aggiornata (write-back); la coerenza dai dati generalmente riguarda solo i dati (come operandi) e non le istruzioni (vedi [[Codice automodificante]]).

Gli schemi si possono classificare in base a:
* Schema Snoopy Vs Directory e Vs Shared caches;
* Protocollo Write through vs Write-back (basati sull'ownership o proprietà);
* Protocollo Update Vs Invalidation (aggiornamento Vs invalidazione);
* Intervention Vs non Intervention (intervento Vs non intervento);
* Protocollo dirty-sharing Vs non dirty-sharing (dati modificati condivisi Vs non condivisi - MOESI Vs MESI).

Tre approcci sono adottati per mantenere la coerenza dei dati:
# '''Bus watching o Snooping''': generalmente usato per i sistemi SMP o [[Sistema multiprocessore simmetrico|Sistema Multiprocessore Simmetrico]]/[[#Sistemi Multi-core|multi-core]] basati sul bus;
# '''Directory-based - Message-passing''': basati sulla directory e scambio di messaggi; possono essere usati in tutti i sistemi, ma tipicamente nei sistemi [[#Directory-based - Message-passing|cc-NUMA]] e nei sistemi [[#Sistemi Multi-core|multi-core]] estesi;
# '''Shared cache''' (cache condivisa): generalmente usata nei sistemi [[#Sistemi Multi-core|multi-core]].

== Bus watching o Snooping ==

[[File:SMP - Symmetric Multiprocessor System.svg|thumb|upright=1.8|SMP - Symmetric Multiprocessor System]]
Protocollo usato nei sistemi con bus, come ad esempio nei sistemi SMP. Sistema operante sotto un unico [[Sistema Operativo|sistema operativo]] con due o più processori omogenei e con una [[Memoria (informatica)#Memoria primaria|memoria principale]] centralizzata condivisa. 
Nei sistemi multiprocessori con cache separate che condividono una memoria comune, uno stesso dato può essere memorizzato in più di una cache. Un problema di coerenza nei dati nasce quando un dato è modificato in una sola cache. I protocolli per mantenere la coerenza fra processori multipli sono chiamati cache-coherency protocols (protocolli di coerenza delle cache). Generalmente nei sistemi SMP la coerenza si basa sull'approccio chiamato Bus watching (sorveglianza del bus) o Snoopy. In un sistema basato sullo snoopy, tutte le cache controllano le transazioni del bus per intercettare i dati e verificare se ha una copia nella propria cache. Vari protocolli di coerenza sono usati per mantenere la coerenza dei dati tra cache<ref name="Various protocols">Archibald, J. and Baer, J. 1986 - Cache coherence protocols: evaluation using a multiprocessor simulation model. ACM Trans. Comput. Syst. 4, 4 (Sep. 1986), 273-298) - http://ctho.org/toread/forclass/18-742/3/p273-archibald.pdf</ref>. Questi protocolli sono generalmente classificati solo in base agli stati della cache (da 3 a 5 e 7 o più) e le transazioni tra questi, ma questo potrebbe creare qualche confusione in quanto la definizione di un protocollo così fatta è incompleta perché mancante di importanti ed essenziali informazioni come le azioni che questi producono; queste azioni possono essere indotte dal processore o dal bus (esempio "intervention", "invalidation", "broadcasting", "updating", ecc.). Il tipo di azioni sono dipendenti dalle implementazioni adottate. Protocolli aventi gli stessi stati e le stesse regole di transazioni possono essere differenti, per es. il protocollo MESI con "shared intervention" (intervento su dati condivisi puliti (clean)) e MESI senza "intervention". Protocolli con stati differenti possono essere praticamente lo stesso protocollo, per esempio i protocolli 4-stati MESI [[#Protocollo Illinois|Illinois]] e 5-stati MERSI (IBM) / MESIF-Intel sono solo un'implementazione diversa delle stesse funzionalità. I più comuni protocolli sono il protocollo 4-stati conosciuto con l'acronimo MESI e il 5-stati MOESI. Altri protocolli usano gli stessi stati - o un sottoinsieme di questi - ma con differenti implementazioni e spesso con una differente ma equivalente terminologia. Con il termine MESI o MOESI, o un sottoinsieme di questi, generalmente si fa riferimento a una classe di protocolli piuttosto che a uno specifico protocollo.

=== Stati della cache ===
* <span style=color:blue>'''M'''</span>=Modified (modificato) o <span style=color:blue>'''D'''</span>=Dirty (sporco/alterato) o <span style=color:blue>'''DE'''</span>=Dirty-Exclusive (sporco esclusivo) o <span style=color:blue>'''EM'''</span>=Exclusive Modified (esclusivo modificato)
** modificato o sporco, cioè modificato solo in una cache - write-back in caso di rimpiazzo (replacement); il dato è memorizzato in una sola cache, ma il dato in memoria non è aggiornato (invalido);
* <span style=color:blue>'''O'''</span>=Owner (proprietario/responsabile) o <span style=color:blue>'''SD'''</span>=Shared Dirty (sporco condiviso) o <span style=color:blue>'''M'''</span>=Shared Modified (sporco modificato) o <span style=color:blue>'''T'''</span>=Tagged (etichettato/contrassegnato)
** modificato, potenzialmente condiviso, proprietario - write-back in caso di rimpiazzo; il dato può essere memorizzato in più di una cache, ma il dato in memoria non è aggiornato (invalido). Solamente una cache è "owner" (proprietario), le altre cache sono marcate "shared" (condivise). In caso di una richiesta di lettura sul bus, il dato viene fornito dall'owner anziché dalla memoria.
* <span style=color:blue>'''E'''=</span>''Exclusive'' o <span style=color:blue>'''R'''=</span>''Reserved'' o <span style=color:blue>'''VE'''</span>=''Valid-Exclusive'' o <span style=color:blue>'''EC'''</span>=''Exclusive Clean'' <span style=color:blue>o '''Me'''</span>=''Exclusive''
** esclusivo o riservato o valido esclusivo o esclusivo pulito; il dato è memorizzato solo in una cache e ''clean'' (pulito, cioè valido) in memoria.
* <span style=color:blue>'''S'''</span>=''Shared'' (condiviso) o <span style=color:blue>'''V'''</span>=''Valid'' (valido) o <span style=color:blue>'''SC'''</span>=''Shared Clean'' (condiviso pulito)
** Dato potenzialmente condiviso con altre cache. Il dato può essere clean o dirty. Il termine "clean" in SC è fuorviante perché può essere anche dirty (vedi [[#Protocollo Dragon (Xerox)|Protocollo Dragon]])
* <span style=color:blue>'''I'''</span>=''Invalid''
** Linea di cache invalida. Se la linea di cache non è presente (tag non corrispondente) è equivalente a linea invalida, perciò dato invalido significa dato presente ma invalido oppure non presente in cache

;Stati speciali
* <span style=color:blue>'''F'''</span>=''Forward'' (in avanti) o <span style=color:blue>'''R'''</span>=''Recent'' (recente)
** stati addizionali del protocollo [[#Protocollo MESI|MESI]]. L'ultimo dato letto. È uno speciale stato "Valido" che è l'owner per ''dati condivisi non modificati'', usato in alcuni protocolli estesi di MESI (MERSI o R-MESI IBM<ref name="MERSI" /><ref>{{Cita pubblicazione|nome=Ravi Kumar|cognome=Arimilli|data=30 novembre 1999|titolo=Cache-coherency protocol with recently read state for data and instructions|numero=US5996049 A|accesso=28 febbraio 2017|url=https://www.google.com/patents/US5996049|nome2=John Steven|cognome2=Dodson|nome3=John Michael|cognome3=Kaiser}}</ref>, MESIF - Intel<ref name="Intel QuickPath">An Introduction to the Intel® QuickPath Interconnect - http://www.intel.ie/content/dam/doc/white-paper/quick-path-interconnect-introduction-paper.pdf</ref><ref>{{Cita pubblicazione|nome=Herbert H. J.|cognome=Hum|data=26 luglio 2005|titolo=Forward state for use in cache coherency in a multiprocessor system|numero=US6922756 B2|accesso=28 febbraio 2017|url=https://www.google.com/patents/US6922756|nome2=James R.|cognome2=Goodman}}</ref>). Lo stato R/F è usato per permettere l' "Intervention" quando il dato è "Valido" ma condiviso con le altre cache. Questa cache è responsabile per l'intervention (shared intervention). Su una richiesta di lettura del bus, il dato viene fornito da questa cache invece che dalla memoria. MERSI e MESIF sono lo stesso protocollo solo con una differente terminologia (F al posto di R). Qualche volta R è riferito anche come "Shared Last " - ultimo condiviso (S<sub>L</sub>)<ref name="POWER4 protocol" /><ref>BM PowerPC 476FP L2 Cache Core Databook - {{cita web |url=https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/8D5342097498C81A852575C50078D867/$file/L2CacheController_v1.5_ext_Pub.pdf |titolo=Copia archiviata |accesso=1º novembre 2016 |urlmorto=sì |urlarchivio=https://web.archive.org/web/20141218185642/https://www-01.ibm.com/chips/techlib/techlib.nsf/techdocs/8D5342097498C81A852575C50078D867/$file/L2CacheController_v1.5_ext_Pub.pdf |dataarchivio=18 dicembre 2014 }}</ref>. Lo stato R (Recent) è usato non solamente nel protocollo MERSI = R-MESI ma in diversi altri protocolli. Questo stato può essere usato in combinazione con altri stati. Per esempio [[#Protocollo RT-MESI|RT-MESI]], HR-MESI, HRT-MESI, [[#Protocollo HRT-ST-MESI|HRT-ST-MESI]]<ref name="HRT-MESI">Cache Ccoherency Protocol Including an HR State - IBM patent - https://www.google.com/patents/US6275908</ref><ref>{{Cita pubblicazione|nome=Ravi Kumar|cognome=Arimilli|data=25 dicembre 2001|titolo=Cache coherency protocol with tagged state for modified values|numero=US6334172 B1|accesso=28 febbraio 2017|url=https://www.google.com/patents/US6334172|nome2=John Steven|cognome2=Dodson|nome3=Jerry Don|cognome3=Lewis}}</ref>. Tutti i protocolli che usano questo stato saranno riferiti come R-MESI type.
* <span style=color:blue>'''H'''</span>=''Hover'' - '''H-MESI''' (stato addizionale del protocollo MESI)<ref>{{Cita pubblicazione|nome=Ravi Kumar|cognome=Arimilli|data=Aug 14, 2001|titolo=Cache coherency protocol including an HR state|numero=US6275908 B1|accesso=28 febbraio 2017|url=https://www.google.com/patents/US6275908|nome2=John Steven|cognome2=Dodson|nome3=Jerry Don|cognome3=Lewis}}</ref>
** Lo stato Hover (H) (sospeso) permette a una cache di mantenere un indirizzo nella directory anche se il corrispondente valore della linea di cache è una copia invalida. Se il valore corrispondente appare sul bus (Tag dell'indirizzo coincidente) dovuto a una "Read" o "Write" valida, il dato della linea di cache è aggiornato con una copia valida e il suo stato è cambiato in S. Questo stato può essere usato in combinazione con altri stati, per es. HR-MESI, HT-MESI, HRT-MESI, [[#Protocollo HRT-ST-MESI|HRT-ST-MESI]]<ref name="HRT-MESI" /><ref name="R-MESI">Cache-coherency protocol with recently read state for data and instructions - IBM patent - https://www.google.com/patents/US5996049</ref><ref name="RT-MESI">Cache Coherency Protocol with Tagged State for Modified Values - IBM patent - https://www.google.com/patents/US6334172</ref>

=== Operazioni di coerenza Snoopy ===

Si distinguono tre operazioni: transazioni di bus, caratteristiche dei dati e operazioni di cache:
* '''Transazioni di bus''': le principali operazioni sono:
** [[#Write Through (scrittura passante)|Write Through]]: la linea di cache è aggiornata sia in cache che in MM o solo in MM (write no-allocate); semplice da implementare, alta occupazione di banda. Va bene per scritture singole.
** [[#Write-Back (or Copy Back) (riscrittura, scrittura indietro o copia indietro)|Write-Back]]: il dato è scritto solo in cache. Il dato è scritto indietro in MM (Write-Back) solo quando sarà rimpiazzato (replacement) o quando richiesto dalle altre cache (vedi [[#Write Policy|Write Policy]]); soluzione intermedia: Write Through per la prima scrittura, Write-Back per le successive (protocolli [[#Protocollo Write-Once (or Write-First)|Write-once]] e [[#Protocollo Bull HN ISI|Protocollo Bull HN ISI]]<ref name="Bull HN ISI" />)
** [[#Write Allocate (scrittura con allocazione)|Write Allocate]]: in caso di miss il dato è letto dall'"owner" o dalla MM, poi il dato è scritto in cache (aggiornato - scrittura parziale) (vedi [[#Write Policy|Write Policy]])
** [[#Write no-Allocate (o no-Write allocate - non allocazione)|Write no-Allocate]]: in caso di miss il dato è scritto in MM senza coinvolgere la cache, oppure, come nel protocollo [[#Protocollo Bull HN ISI|Protocollo Bull HN ISI]], è scritto nell '"owner" , cioè nella '''D''' o '''SD''' cache (owner updating - aggiornamento dell'Owner), se è presente, altrimenti in MM; Write-no-Allocate normalmente è associato al Write Through.
** Cache Intervention (o brevemente "intervention " - intervento)
*** Shared Intervention: shared-clean intervention (intervento su dati non modificati); in caso Read Miss (mancanza di lettura) il dato viene fornito dall' "owner" - '''E''' o '''R'''/'''F''' o anche '''S''' invece che dalla MM (vedi protocolli [[#Protocollo Illinois|Illinois]], [[#Protocollo MERSI (IBM) / MESIF (Intel)|IBM R-MESI type and Intel MESIF]]):
*** Dirty Intervention (intervento su dati modificati): in caso di Read Miss il dato è fornito dagli "owner" '''M''' (D) o '''O''' (SD) o '''E''' (R) (Non per '''E''' (R) nella proposta originale del protocollo MOESI<ref name="MOESI Sweazey" /> e in alcune altre implementazioni tipo-MOESI) invece che dalla MM (es. protocollo MOESI, RT-MESI, …)
*** L'"Intervento" è una soluzione migliore rispetto al "non-Intervento" perché le transazioni cache-to-cache (da cache a cache) sono molto più veloci rispetto all'accesso alla MM, e in più si riduce il traffico di memoria (aumento di banda). MESI esteso [[#Protocollo Illinois|Illinois]] e [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] sono perciò molto più efficienti rispetto al protocollo MOESI (vedi [[##MESI vs MOESI|MESI vs MOESI]])
** '''Invalidation''': in caso di Write Hit con stato '''S''' (V) o '''O''' (SD) (shared) una transazione di bus è inviata per invalidare tutte le copie delle altre cache (Write-invalidate)
** '''Write-broadcast (Write-update)''': (scrittura distribuita), in caso di "Write Hit" con stato S (V) o O (SD) (shared) una scrittura di aggiornamento è inviata a tutte le altre cache per aggiornare le loro copie (es. Intel Nehalem<ref name="Nehalem2" />, [[#Protocollo Dragon (Xerox)|Dragon]] protocol (Xerox), [[#Protocollo Firefly (DEC)|Firefly]] (DEC). L'operazione di aggiornamento delle altre cache è a volte chiamata anche Snarfing (arraffare, impadronirsi). Le cache monitorizzano (snoopy) il bus e se si ha hit la cache si impadronisce del dato che transita sul bus e aggiorna la propria cache. Anche l'aggiornamento dello stato H in ([[#H-MESI|H-MESI]]) può essere definito come snarfing. Nel primo caso avviene solo in un'operazione scrittura distribuita, nel secondo caso sia in lettura che scrittura.
** '''Intervention-broadcasting''': (Intervento con aggiornamento distribuito): in caso di una transazione di intervento, una cache con stato '''H''' ([[#H-MESI|H-MESI]]) aggiorna la sua copia invalida con il valore inviato sul bus e il suo stato è cambiato in '''S'''<ref name="R-MESI" />
** '''Write Invalidate vs broadcast: w'''rite Invalidate è migliore in caso di scritture multiple, tipicamente scritture parziali, fatte da un processore prima che la linea di cache sia letta da un altro processore.  Write-broadcast (aggiornamento) è migliore quando si ha un produttore singolo a molti consumatori del dato, ma è peggiore quando una cache è aggiornata con un dato che non sarà più successivamente utilizzato (inutile aumento di traffico sul bus e aumento delle [[#Interferenze tra Snoopy e Attività del Processore|interferenze di cache]]). L'invalidazione è la soluzione comune.
* '''Caratteristiche dei dati''': ci sono tre caratteristiche dei dati di cache:
** '''Validità''': Qualsiasi linea di cache non invalida, cioè stati MOES / D-SD-R-V
** '''Esclusività''': il dato è valido solo su una cache (dato non condiviso) in stato '''M''' (D) o '''E''' (R), con la MM non aggiornata (dirty) in caso di '''M''' (D) e aggiornata (clean) in caso di '''E''' (R);
** '''Ownership - Proprietà'''<ref>Non deve essere confusa la definizione più restrittiva di "owner" data nel protocollo in MOESI con questa più generale definizione</ref>: la cache che è responsabile di fornire il dato richiesto in sostituzione della MM (Intervento). - Dipendente dal protocollo, la cache che deve fare l'intervento può essere '''S'''-'''E'''-'''M''' in MESI [[#Protocollo Illinois|Illinois]], o '''R'''/'''F'''-'''E'''-'''M''' in [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] o '''M''' (D) o '''O''' (SD) o anche '''E''' (R) (dipendente dall'implementazione) nel tipo MOESI, (es. [[AMD64]],<ref name="MOESI Sweazey" />, [[#Protocollo Bull HN ISI|Bull HN ISI]]<ref name="Bull HN ISI" /> - vedi operazione di "Read Miss" sotto).
* '''Operazioni di cache''': le operazioni delle cache sono:
** '''Read Hit:''' il dato è letto dalla cache. Lo stato rimane inalterato; poiché questa è un'operazione ovvia, in seguito non sarà più considerata, anche nei diagrammi di transazione di stato
** '''Read Miss''': la richiesta di lettura dato è inviata sul bus; ci sono diverse situazioni:
*** '''Dato memorizzato solamente in MM''': il dato è letto dalla MM; la cache è settata '''E''' (R) o '''S''' (V); '''E''' (R) se una speciale linea di bus ('''''Shared line''''') è usata per indicare "''nessun dato condiviso ''" (no data sharing). Usato in tutti i protocolli aventi lo stato '''E''' (R) eccetto per i protocolli [[#Protocollo Write-Once (or Write-First)|Write-once]] e [[#Protocollo Bull HN ISI|Bull HN ISI]] (vedi "Write Hit" sotto).
*** '''Dato memorizzato in MM e in una o più cache in stato S''' (V)''' oppure in R/F nel protocollo [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]]''': Ci sono tre situazioni:
**** Protocollo [[#Protocollo Illinois|Illinois]] - una rete di priorità è usata per assegnare in modo arbitrario e temporaneo la "ownership" (proprietà) a una copia '''S'''. Il dato è fornito dalla cache selezionata. La cache richiedente è settata '''S''' ('''shared intervention''' - intervento tra dati condivisi con MM clean);
**** Protocollo [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] con una cache in stato '''R'''/'''F''' - '''shared owner''' ("owner" delle cache condivise); il dato è fornito dalla cache '''R'''/'''F'''. La cache che fornisce il dato è cambiata in '''S''' e la cache richiedente è settata '''R'''/'''F''' (in read miss la "ownership" è sempre presa dalla cache richiedente) - '''shared intervention''';
**** In tutti gli altri casi il dato è fornito dalla MM e la cache richiedente è settata '''S''' (V).
*** '''Dato memorizzato in MM e in una sola cache in stato E '''(R): il dato è fornito dalla cache '''E''' (R) o dalla MM, in funzione del protocollo; fornito da '''E''' (R) in MESI esteso (es. [[#Protocollo Illinois|Illinois]], Pentium (R) II<ref name="MESI" />), [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] e in alcune implementazioni di MOESI (es. [[AMD64]]); la cache richiedente è settata '''S''' (V), o '''R'''/'''F''' nel protocollo [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI type / MESIF]] e la cache '''E''' (R) è cambiata in '''S''' (V) o in '''I''' nel protocollo MEI. In tutti gli altri casi il dato è fornito dalla MM

::* '''Dato modificato in una o più cache con MM non aggiornata''':
:::* '''Protocollo tipo MOESI - Dato memorizzato in M''' (D)''' o in O '''(SD)''' e le altre cache nello stato S '''(V): il dato è inviato alla cache richiedente dall' "owner" '''M''' (D) o '''O''' (SD). La cache richiedente è settata '''S''' (V) mentre '''M''' (D) è cambiato in '''O''' (SD); la MM rimane non è aggiornata.
:::* '''Protocollo tipo MESI o MEI - Dato memorizzato in M '''(D)''' e le altre cache nello stato S '''(V); ci sono due soluzioni:
:::# il dato è inviato dalla cache '''M''' (D) alla cache richiedente e contemporaneamente in MM (per es. [[#Protocollo Illinois|Illinois]])
:::# l'operazione è fatta in due passi: la transazione richiedente è temporaneamente sospesa. Si ha il "Copy Back" del dato '''M''' (D) in MM, poi la transazione in attesa prosegue leggendo il dato dalla MM (es. protocolli [[#Protocollo MESI|MESI]] e MSI [[#Protocollo Synapse|Synapse]])
:::: Tutte le cache sono settate '''S''' (V)
** '''Write Hit''': il dato è scritto in cache; ci sono diverse situazioni:
*** '''Cache in stato S '''(V)''' o R/F o O '''(SD) (cache condivise)
**** '''Write invalidate'''
***** Copy back: il dato è scritto in cache e una transazione di invalida è inviata sul bus per invalidare le altre cache; la cache è settata '''M''' (D)
***** Write Through ([[#Protocollo Write-Once (or Write-First)|Write-once]], [[#Protocollo Bull HN ISI|Bull HN ISI]]): il dato è scritto in cache e in MM invalidando tutte le altre cache. La cache è settata '''R''' (E)
**** '''Write broadcasting''' (es. [[#Protocollo Firefly (DEC)|Firefly]], [[#Protocollo Dragon (Xerox)|Dragon]]); il dato è scritto in cache e una transazione di "broadcasting" è inviata sul bus per aggiornare tutte le altre cache aventi una copia; la cache è settata '''M''' (D) se la linea "shared line" non è attiva, altrimenti è settata '''O''' (SD). Tutte le altre cache sono settate '''S''' (V)
*** '''Cache con stato E'''(R) o '''M'''(D) (esclusività): la scrittura può essere fatta localmente senza nessun'altra azione. Lo stato è settato (o rimane) '''M''' (D)
** '''Write Miss'''
*** '''Write Allocate'''
**** Operazione di Read with Intent to Modified operation ([[#Write Allocate (scrittura con allocazione)|RWITM]]): Come per un'operazione di Read più un comando di invalida, successivamente la cache è scritta (aggiornata); la cache richiedente è settata '''M''' (D) e tutte le altre cache sono invalidate
**** Write broadcasting (es. [[#Protocollo Firefly (DEC)|Firefly]], [[#Protocollo Dragon (Xerox)|Dragon]]): come per una Read Miss; se la "shared line" non è attiva il dato è scritto in cache e settato '''M''' (D), altrimenti come per una Write Hit - Write broadcasting
*** '''Write-no-Allocate''': il dato è inviato alla MM, oppure come nel protocollo [[#Protocollo Bull HN ISI|Bull HN ISI]], solamente alle cache '''D''' (M) o '''SD''' (O) se presenti, bypassando la cache.

== Vari protocolli di coerenza ==

{| class="wikitable"
! !! Protocolli
|-
| SI || Write Through
|-
| MSI || [[#Protocollo Synapse|Synapse]]<ref name="Various protocols" />
|-
| MEI || IBM [[PowerPC 7xx|PowerPC 750]]<ref name="PowerPC">MPC750UM/D 12/2001 Rev. 1 MPC750 RISC Microprocessor Family User's Manual - http://www.freescale.com/files/32bit/doc/ref_manual/MPC750UM.pdf</ref>, MPC7400<ref name="R-MESI" />
|-
| MES || [[#Protocollo Firefly (DEC)|Firefly]]<ref name="Various 
protocols" />
|-
| [[#Protocollo MESI|MESI]] || Pentium II<ref name="MESI">Pentium Pro and Pentium II System Architecture pg. 160 - Di T. Shanley - http://books.google.it/books?id=MLJClvCYh34C&pg=PA160&lpg=PA160&dq=Pentium+protocol+cache&source=bl&ots=gaOu-EvaTy&sig=QQEM1krp-H_0KUhi5Ti2bmxU2kU&hl=it&sa=X&ei=Zt6KT7icG8TE4gShzaDwCQ&ved=0CDcQ6AEwAg#v=onepage&q=Pentium%20protocol%20cache&f=false</ref>, PowerPC, Intel Harpertown (Xeon 5400)
|-
| MOSI || [[#Protocollo Berkeley (DEC)|Berkeley]]<ref name="Various protocols" />
|-
| [[#Protocollo MOESI|MOESI]] || [[AMD64]]<ref name="AMD64">AMD64 Technology - AMD64 Architecture Programmer's Manual Volume 2: System Programming - http://developer.amd.com/wordpress/media/2012/10/24593_APM_v21.pdf {{Webarchive|url=https://web.archive.org/web/20160303230732/http://developer.amd.com/wordpress/media/2012/10/24593_APM_v21.pdf |data=3 marzo 2016 }}</ref>, [[Opteron|AMD Opteron]][[AMD Opteron]]<ref name="AMD Opteron">AMD Opteron Shared Memory MP Systems - http://www.cse.wustl.edu/~roger/569M.s09/28_AMD_Hammer_MP_HC_v8.pdf</ref>, MOESI<ref name="MOESI Sweazey">Sweazey, P., and Smith, A. J. A class of compatible cache consistency protocols and their support by the IEEE Futurebus. In ''Proceedings of the 13th International Symposium on Computer Architecture''. IEEE. New York, 1986, pp. 414-423.) - http://pdf.aminer.org/000/419/524/a_class_of_compatible_cache_consistency_protocols_and_their_support.pdf</ref>, T-MESI IBM<ref name="RT-MESI" />
|}

{| class="wikitable"
! Terminologia usata !!
|-
| [[#Protocollo Illinois|Illinois]] || D-VE-S-I (= MESI esteso)<ref name="Various protocols" /><ref>Mark S. Papamarcos and Janak H. Patel. In ISCA '84: Proceedings of the 11th annual international symposium on Computer architecture, pages 348{354, New York, NY, USA, 1984. ACM - https://web.archive.org/web/20150521112759/http://www.researchgate.net/profile/Janak_Patel4/publication/220771512_A_Low-Overhead_Coherence_Solution_for_Multiprocessors_with_Private_Cache_Memories/links/00463519b8d139e451000000.pdf</ref>
|-
| [[#Protocollo Write-Once (or Write-First)|Write-once o Write-first]] || D-R-V-I (= MESI) &nbsp;<ref name="Various protocols" /><ref name="Goodman">Using cache memory to reduce processor-memory traffic". Proceedings of the 10th annual international symposium on Computer architecture - ISCA '83. International Symposium on Computer Architecture: Stockholm, Sweden, June 13–17, 1983.pp. 127-128 - http://courses.cs.vt.edu/cs5204/fall11-kafura/Papers/TransactionalMemory/Goodman-SnoopyProtocol.pdf</ref><ref name="Write Once">Advanced Computer Architecture, 2E pg. 301 - Di Hwang - http://books.google.it/books?id=m4VFXr6qjroC&pg=PA301&lpg=PR10&focus=viewport&dq=Multiprocessors+and+Multicomputers+7.2+Cache+Coherence+and+Synchronization&hl=it</ref>
|-
| [[#Protocollo Berkeley|Berkeley]] || D-SD-V-I (= MOSI) &nbsp;<ref name="Various protocols" />
|-
| [[#Protocollo Synapse|Synapse]] || D-V-I (= MSI) &nbsp; &nbsp;<ref name="Various protocols" />
|-
| [[#Protocollo Firefly (DEC)|Firefly]] || D-VE-S (= MES) DEC<ref name="Various protocols" />
|-
| [[#Protocollo Dragon (Xerox)|Dragon]] || D-SD (SM?)-SC-VE &nbsp; (= MOES) Xerox<ref name="Various protocols" />
|-
| [[#Protocollo Bull HN ISI|Bull HN ISI]] || D-SD-R-V-I (= MOESI)<ref name="Bull HN ISI">Cache memory and related consistency protocol, Inventor Ferruccio Zulian, Bull HN ISI - https://www.google.com/patents/EP0396940B1?cl=en</ref>
|-
| [[#Protocollo MERSI (IBM) / MESIF (Intel)|Protocollo MERSI (IBM) / MESIF (Intel)]]  ||
R=Recent - IBM [[PowerPC G4]], MPC7400<ref name="MERSI">MPC7400 RISC Microprocessor User's Manual - http://pccomponents.com/datasheets/MOT-MPC7400.PDF</ref><ref name="R-MESI" /><br>
F=Forward - Intel<ref name="Intel QuickPath" /> , Intel Nehalem<ref name="Shanghai - Nehalem-EP" /><ref name="Nehalem2">Cache Organization and Memory Management of the Intel Nehalem Computer Architecture - Trent Rolf - {{cita web |url=http://rolfed.com/nehalem/nehalemPaper.pdf |titolo=Copia archiviata |accesso=26 settembre 2014 |urlmorto=sì |urlarchivio=https://web.archive.org/web/20140830111714/http://rolfed.com/nehalem/nehalemPaper.pdf |dataarchivio=30 agosto 2014 }}</ref><ref name="Nehalem">{{Cita pubblicazione|url=http://www.realworldtech.com/common-system-interface/5/ |titolo=The Common System Interface: Intel’s Future Interconnect |autore=David Kanter |data=28 agosto 2007 |p=5 |rivista=Real World Tech |accesso=12 agosto 2012}}</ref>
|-
| [[#Protocollo RT-ST-MESI|RT-MESI]] || T=Tagged - IBM<ref name="RT-MESI" />
|-
| [[#Protocollo RT-ST-MESI|HRT-ST-MESI]] || H=Hover, R=Recent,T=Tagged, ST=Shared-Tagged - IBM<ref name="HRT-MESI" /><ref name="RT-MESI" />
|-
| Protocollo [[#Protocollo POWER4 IBM|POWER4 IBM]] || Mu-Me-M-T-S-S<sub>L</sub>-I &nbsp;(L2 sette stati)<ref name="POWER4 protocol" />

* <span style=color:blue>'''Mu'''</span>=Unsolicited Modified - non Sollecitato Modificato Esclusivo - (<span style=color:blue>'''M'''</span>)<ref>Stato speciale - Richiesta per una prenotazione di lettura e scrittura di un "doubleword" (implementazioni a 64-bit)</ref>

* <span style=color:blue>'''M'''</span>=Modified Exclusive - Modificato Esclusivo (<span style=color:blue>'''D'''</span>)
* <span style=color:blue>'''T'''</span>=Tagged - Modificato Owner non Esclusivo (<span style=color:blue>'''O'''</span>)
* <span style=color:blue>'''Me'''</span>=Valido Esclusivo - (<span style=color:blue>'''E'''</span>)
* <span style=color:blue>'''S'''</span>=Shared
* <span style=color:blue>'''S<sub>L</sub>'''</span>=Shared Last - sourced local" - (<span style=color:blue>'''Shared Owner Locale'''</span>)
* <span style=color:blue>'''I'''</span>=Invalido - (<span style=color:blue>'''I'''</span>)

|}

----

=== Protocollo MESI ===
[[File:MESI_State_Transaction_Diagram.svg|destra|miniatura|MESI Protocol - State Transaction Diagram]]

&nbsp; Stati MESI = D-R-V-I
: - Uso della linea "shared line" per determinare copie condivise (shared) sulle altre cache

* '''Operazioni del Processor'''

::* Read Miss
::: Ci sono due implementazioni alternative: MESI standard (senza intervento) e MESI esteso (con intervento)
::: 1. MESI "no Intervention" (senza intervento) (es. PowerPC 604<ref name="autogenerato1">Optimizing the MESI Cache Coherence Protocol for Multithreaded Applications on Small Symmetric Multiprocessor Systems - {{cita web|url=http://tibrewala.net/papers/MESI98/|titolo=Copia archiviata|accesso=9 ottobre 2016|urlarchivio=https://web.archive.org/web/20161022140749/http://tibrewala.net/papers/mesi98/|dataarchivio=22 ottobre 2016|urlmorto=sì}}</ref>)
:::: - Se si ha una copia '''M''' in una cache, la transazione viene fermata e rimane in attesa sino a quando la cache '''M''' aggiornerà la MM, poi la transazione continuerà leggendo il dato dalla MM. Lo stato di tutte e due le cache è settato '''S'''
:::: - altrimenti il dato è letto dalla MM. Se la linea "shared line" è "on" la cache è settata '''S''' altrimenti '''E'''
::: 2. MESI "Intervention" da '''M''' e da '''E''' (es. Pentium (R) II<ref name="MESI">Pentium Pro and Pentium II System Architecture pg. 160 - Di T. Shanley - http://books.google.it/books?id=MLJClvCYh34C&pg=PA160&lpg=PA160&dq=Pentium+protocol+cache&source=bl&ots=gaOu-EvaTy&sig=QQEM1krp-H_0KUhi5Ti2bmxU2kU&hl=it&sa=X&ei=Zt6KT7icG8TE4gShzaDwCQ&ved=0CDcQ6AEwAg#v=onepage&q=Pentium%20protocol%20cache&f=false</ref>)
:::: - Se si ha una copia '''M''' o '''E''' in una cache (esclusività), il dato è fornito alla cache richiedente da '''M''' o da '''E''' (intervento). Se è inviato da '''M''' il dato è contemporaneamente scritto anche in MM (copy back). Tutte le cache sono settate '''S'''
:::: - altrimenti il dato è letto dalla MM. Se la linea "shared line" è "on" la cache è settata '''S''' altrimenti '''E'''
::* Write Hit
::: - Se la cache è '''M''' o '''E''' (esclusività), la scrittura può essere fatta localmente senza nessun'altra azione
::: - altrimenti il dato è scritto in cache e una transazione di invalida è inviata sul bus per invalidare tutte le altre cache
::: - La cache è settata '''M'''
::* Write Miss
::: - Un'operazione [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]] è inviata sul bus. L'operazione è fatta in due step: "Read Miss" con un comando di "invalida" per invalidare tutte le altre cache, poi come in una "Write Hit" con cache in stato '''M''' (vedi [[Memoria cache#Operazioni di coerenza Snoopy|Operazioni di Cache-Write Miss]]).

* '''Transazioni di Bus '''

::* Bus Read
::: - se '''M''' e "no Intervento" il dato è inviato alla MM (Copy Back)
::: - se '''M''' e "Intervento" il dato è inviato alla cache richiedente e alla MM (Copy Back)
::: - se '''E''' (*) e "Intervento" il dato è inviato alla cache richiedente
::: - Lo stato è cambiato (o rimane) in '''S'''
::* Bus Write - ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Come in caso di "Bus Read"
::: - La cache è settata "Invalida" ('''I''')
::* Transazione di Bus di Invalida
::: - La cache è settata "Invalida" ('''I''')

* '''Operazioni'''

:: - ''Write Allocate''
:: - ''Intervento'': da M - E (*)
:: - ''Write Invalidate''
:: - ''Copy-Back'': Rimpiazzo di M
:: (*) - MESI esteso

----
[[File:MOESI_State_Transaction_Diagram.svg|destra|miniatura|MOESI Protocol - State Transaction Diagram]]

=== Protocollo MOESI ===
&nbsp; Stati MEOSI = D-R-SD-V-I = T-MESI IBM<ref name="RT-MESI" />

: - Uso della linea "shared line" per determinare copie condivise (shared) sulle altre cache

* '''Operazioni del Processor'''

::* Read Miss
::: - Se c'è una copia in un'altra cache in stato '''M''' o '''O''' o '''E''' (*), il dato è fornito da questa cache (Intervention). La cache richiedente è settata '''S''' , '''M''' è cambiato in '''O''' e '''E''' in '''S'''
::: - altrimenti il dato è letto dalla MM
::: - Se la "shared line" è "on" la cache richiedente è settata '''S''' altrimenti '''E'''
::* Write Hit
::: - Se la cache è '''M''' o '''E''' (esclusività), la scrittura può essere fatta localmente senza nessun'altra azione
::: - altrimenti '''O''' o '''S''' (sharing) una transazione di invalida è inviata sul bus per invalidare le altre cache.
::: - Lo stato è cambiato (o rimane) in '''M'''
::* Write Miss
::: - Un'operazione di [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]] è inviata sul bus
::: - Il dato è fornito dall' "owner" o dalla MM come nella Read Miss, poi il dato è scritto in cache (aggiornato = scrittura parziale)
::: - La cache è settata '''M''' e le altre cache sono settate '''I'''

* '''Transazioni di Bus '''

::* Bus Read
::: - Se la cache è '''M''' o '''O''' o '''E''' (*) il dato è inviato alla cache (intervention). Se la cache è '''E''' lo stato è cambiato in '''S''', altrimenti è settato (o rimane) '''O'''
::: - altrimenti lo stato è cambiato in '''S'''
::* Bus Write - ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Se la cache è '''M''' o '''O''' o '''E''' (*) il dato è inviato alla cache (intervention)
::: - La cache è settata "Invalida" ('''I''')
::* Transazione di Bus di Invalida
::: - La cache è settata "Invalida" ('''I''')

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da M-O-E (*)
: - ''Write Invalidate''
: - ''Copy-Back'': Rimpiazzo di M-O
: - (*) dipendente dal tipo di implementazione per '''E'''

----
[[File:Illinois_State_Transaction_Diagram.svg|destra|miniatura|Illinois State Transaction Diagram]]

=== Protocollo Illinois ===
&nbsp; Stati MESI = D-R-V-I<ref name="Various protocols">Archibald, J. and Baer, J. 1986 - Cache coherence protocols: evaluation using a multiprocessor simulation model. ACM Trans. Comput. Syst. 4, 4 (Sep. 1986), 273-298) - http://ctho.org/toread/forclass/18-742/3/p273-archibald.pdf</ref>

: - Caratteristiche:
:: - È un'estensione del protocollo MESI
:: - Uso di una rete di priorità per il '''shared intervention''' (intervento su dati condivisi)
:: - Differenze da MESI: intervento oltre che da '''E''' e '''M''' anche da '''S''' (vedi [[Memoria cache#Operazioni di coerenza Snoopy|Operazioni di Cache-Read Miss - punto 1]])

* '''Operazioni'''

:: - ''Write Allocate''
:: - ''Intervention'': da M-E-S
:: - ''Write Invalidate''
:: - ''Copy-Back'': Rimpiazzo di M

----
[[File:Write-Once_State_Transaction_Diagram.svg|destra|miniatura|Write-Once Protocol - State Transaction Diagram]]

=== Protocollo Write-Once (or Write-First) ===
&nbsp; States D-R-V-I (MESI)<ref name="Various protocols" /><ref name="Goodman">Using cache memory to reduce processor-memory traffic". Proceedings of the 10th annual international symposium on Computer architecture - ISCA '83. International Symposium on Computer Architecture: Stockholm, Sweden, June 13–17, 1983.pp. 127-128 - http://courses.cs.vt.edu/cs5204/fall11-kafura/Papers/TransactionalMemory/Goodman-SnoopyProtocol.pdf</ref><ref name="Write Once">Advanced Computer Architecture, 2E pg. 301 - Di Hwang - http://books.google.it/books?id=m4VFXr6qjroC&pg=PA301&lpg=PR10&focus=viewport&dq=Multiprocessors+and+Multicomputers+7.2+Cache+Coherence+and+Synchronization&hl=it</ref>

: - Caratteristiche:
:: - Non uso della "shared line" (protocollo per bus standard o bus non modificabile)
:: - Write Through sulla prima Write Hit in stato '''V''', poi Copy Back

* '''Operazioni del Processor'''

::* Read Miss
::: - Se c'è una copia '''D''' in un'altra cache, il dato è fornito da questa cache (intervention) e contemporaneamente è anche scritto in MM (Copy-Back) .
::: - altrimenti il dato è letto dalla MM
::: - tutte le cache sono settate '''V'''
::* Wiite Hit
::: - Se la cache è '''D''' o '''R''' (esclusività), la scrittura è fatta localmente senza nessun'altra azione e lo stato è settato (o rimane) '''D'''
::: - altrimenti '''V''' (prima Write Hit) il dato è scritto in cache e in MM (Write Through) invalidando tutte le altre cache (Write-Invalidate). La cache è settata '''R'''
::* Wiite Miss
::: - Come per la Read Miss con un comando di "invalida" ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]]) più una Write Hit in stato '''D''' (updating). La cache è settata '''D''' e tutte le altre cache "Invalide" ('''I''')
::: - Nota - La Write Through è fatta solamente in "Write Miss". È da notare che in questo caso una transazione di bus è comunque necessaria per invalidare le altre cache e perciò si può approfittare di questo fatto per aggiornare anche la MM. In "Write Miss" invece non è necessaria nessuna transazione in più per cui una Write Through diventerebbe un'inutile operazione nel caso in cui la cache fosse nuovamente aggiornata.

* '''Transazioni di Bus '''

::* Bus Read
::: - Se la cache è '''D''' il dato è inviato da questa cache alla cache richiedente (intervention) e anche alla MM (copy-back). La cache è settata '''V'''
::: - altrimenti lo stato è cambiato (o rimane) in '''V'''
::* Bus Write - ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Se la cache è '''D''' il dato è inviato alla cache richiedente (intervention)
::: - La cache è settata "Invalida" ('''I''')
::* Transazione di Bus di Invalida
::: - La cache è settata "Invalida" ('''I''')

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da D
: - ''Write Through'': prima Write Hit in stato V
: - ''Write Invalidate''
: - ''Copy-Back'': Rimpiazzo di D

----
[[File:Bull_HN_ISI_State_Transaction_Diagram.svg|destra|miniatura|Bull HN ISI Protocol - State Transaction Diagram]]

=== Protocollo Bull HN ISI ===
&nbsp; Stati D-SD-R-V-I (MOESI)
&nbsp; Protocollo brevettato (F. Zulian)<ref name="Bull HN ISI">Cache memory and related consistency protocol, Inventor Ferruccio Zulian, Bull HN ISI - https://www.google.com/patents/EP0396940B1?cl=en</ref>

: - Caratteristiche:
:: - MOESI - estensione del protocollo [[#Protocollo Write-Once (or Write-First)|Write-once]]
:: - Write-no-allocate su miss con aggiornamento di '''D''' o '''SD'''
:: - Non uso di [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]]
:: - Non uso della "shared line"

* '''Operazioni del Processor'''

::* Read Miss
::: - Come per MOESI con "shared line" "on" ed intervento solo dall' "owner" '''D''' o '''SD''' e non da '''R'''
::* Wiite Hit
::: - Se la cache è '''D''' o '''R''', come per MOESI, la scrittura è fatta localmente senza nessun'altra azione. La cache è settata (o rimane) '''D'''
::: - Se '''SD''' o '''V''' (prima scrittura), come per Write-Once, il dato è scritto in cache e in MM (Write Through) invalidando tutte le altre cache (Write-Invalidate). La cache è settata '''R'''
::* Write Miss
::: - Il dato è inviato sul bus bypassando la cache (Write-no-allocate)
::: - Se c'è una copia "owner" '''D''' o '''SD''', l' "owner" è aggiornato (vedi [[Memoria cache#Operazioni di coerenza Snoopy|Write-no-Allocate]]) mentre le altre cache sono invalidate. L' "owner" è settato (o rimane) '''D'''. La MM rimane "dirty" (non aggiornata)
::: - altrimenti il dato è inviato alla MM invalidando le altre cache (Write-Invalidate)

* '''Transazioni di Bus '''

::* Bus Read
::: - Come per MOESI con intervento solo dall' "owner" '''D''' o '''SD'''
::* Bus Write (Write Update / Write Invalidate)
::: - Se la cache è '''D''' o '''SD''', la cache è aggiornata, altrimenti è settata "Invalida" ('''I''')

* '''Operazioni'''

: - ''Write-no-allocate'': su miss
: - ''Write update'': su miss
: - ''Write Through'': per la prima scrittura, poi copy back
: - ''Write Update / Write Invalidate''
: - ''Intervention'': da SD-D
: - ''Copy-Back'': rimpiazzo di D o di SD con invalida
:: Oss. - Questo è l'unico protocollo che ha transazioni O-E (SD-R) ed è anche l'unico che fa uso della Write-no-allocate su miss.

----
[[File:Synapse_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|Synapse Protocol - State Transaction Diagram]]

=== Protocollo Synapse ===
&nbsp; Stati D-V-I (MSI)<ref name="Various protocols" />

: - Caratteristiche:
:: - La caratteristica di questo protocollo è di avere, per ciascuna linea di cache, un tag singolo-bit in MM, indicando una linea di cache è in stato '''D'''.
:::: - Questo bit previene una possibile [[Race condition]] (condizione di corsa) se la cache '''D''' non risponde sufficientemente veloce per inibire la MM dal rispondere immediatamente prima di essere stata aggiornata.
:: - Il dato proviene sempre dalla MM
:: - Non uso della "shared line"

* '''Operazioni del Processor'''

::* Read Miss
::: - Se c'è una copia '''D''' in un'altra cache, la transazione di lettura è rifiutata. La copia '''D''' è scritta indietro in MM e cambia il suo stato in '''V''', poi la cache richiedente rimanda una nuova transazione di lettura e il dato è letto dalla MM.
::: - altrimenti il dato è letto dalla MM.
::: - La cache è settata '''V'''
::* Write Hit
::: - Se la cache è '''D''', la scrittura può essere fatta localmente senza nessun'altra azione.
::: - altrimenti '''V''', come in caso di Read Miss, includendo anche un trasferimento di dati dalla memoria con in più un comando di invalida ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]]). Questo è fatto solo per invalidare le altre copie '''V''' perché questo protocollo non supporta una transazione di invalida.
::: - La cache è settata '''D'''. Tutte le altre cache sono settate "Invalide" ('''I''')
::* Write Miss ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Come per la Read Miss, ma con un comando di invalida. La linea di cache è letta dalla MM, poi la cache è scritta (aggiornata). La cache è settata '''D'''. Tutte le altre cache sono settate "Invalide" ('''I''').

* '''Transazioni di Bus '''

::* Bus Read
::: - Se la cache è '''D''' il dato è inviato indietro alla MM (Copy Back). La cache è settata '''V'''
::: - altrimenti lo stato rimane in '''V'''
::* Bus Write ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Se la cache è '''D''' il dato è inviato indietro alla MM (Copy Back)
::: - La cache ('''D''' o '''V''') è settata "Invalida" ('''I''')

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': nessun intervento
: - ''Write Invalidate'': [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]]
: - ''No transazione di invalida''
: - ''Copy-Back'': rimpiazzo di D

----
[[File:Berkeley_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|Berkeley Protocol - State Transaction Diagram]]

=== Protocollo Berkeley ===
&nbsp; Stati D-SD-V-I (MOSI)<ref name="Various protocols" />

: - Caratteristiche:
: - Come per MOESI senza lo stato '''E'''
: - Non uso della "shared line"

* '''Operazioni del Processor'''

::* Read Miss
::: - Ii dato è fornito dall' "owner", e cioè da '''D''' o da '''SD''' altrimenti dalla MM. '''D''' è cambiato in '''SD'''
::: - La cache è settata '''V'''
::* Wiite Hit
::: - Se la cache è '''D''' (esclusività), la scrittura è fatta localmente senza nessun'altra azione
::: - altrimenti ('''SD''' o '''V'''), una transazione di invalida è inviata sul bus per invalidare le altre cache.
::: - La cache è settata (o rimane) '''D'''
::* Write Miss
::: - Un'operazione di [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]] è inviata sul bus
::: - Come per la Read Miss, il dato è fornito dall' "owner", e cioè da '''D''' o '''SD''' o dalla MM, poi la cache è aggiornata
::: - La cache è settata '''D'''. Tutte le altre cache sono settate '''I'''

* '''Transazioni di Bus '''

::* Bus Read
::: - Se la cache è '''D''' o '''SD''' il dato è inviato alla cache richiedente (intervento). La cache è settata (o rimane) in '''SD'''
::: - altrimenti la cache rimane in '''V'''
::* Bus Write ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Se la cache è '''D''' o '''SD''' il dato è inviato sul bus (Intervento)
::: - La cache è settata "Invalida" ('''I''')
::* Transazione di Bus di Invalida
::: - La cache è settata "Invalida" ('''I''')

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da D-SD
: - ''Write Invalidate''
: - ''Copy-Back'': rimpiazzo di D e SD

----
[[File:Firefly_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|Firefly Protocol - State Transaction Diagram]]

=== Protocollo Firefly (DEC) ===
&nbsp; Stati D-VE-S (MES)<ref name="Various protocols" />

: - Caratteristiche:
:: - Non uso di stato "Invalido"
:: - Write-broadcasting +Write Through
:: - Uso della "shared line"
:: - Write-broadcasting evita la necessità dello stato "Invalido"
:: - Simultaneo intervento da tutte le cache (shared e dirty Intervention - su dati non modificati che modificati)
:: - Questo protocollo richiede un bus sincrono

* '''Operazioni del Processor'''

::* Read Miss
::: - Ogni cache è l' "owner", cioè tutte le altre cache con una copia inviano simultaneamente il dato sul bus (intervento simultaneo - la temporizzazione del bus è fissa cosicché le cache rispondono nello stesso ciclo), altrimenti il dato è fornito dalla MM.
::: - Se c'è una cache '''D''', il dato è inviato simultaneamente anche in MM (Copy Back)
::: - Se c'è una copia nelle altre cache la "Shared line" è settata "on"
::: - Se la "Shared line" è "off" tutte le altre cache sono settate '''S''' altrimenti la cache richiedente è settata '''VE'''.
::* Write Hit
::: - Se la cache è '''D''' o '''VE''' (esclusività), la scrittura è fatta localmente senza nessun'altra azione e la cache è settata '''D'''
::: - altrimenti '''S''', una Write-broadcasting è inviata sul bus per aggiornare tutte le altre cache e la MM (Write Through)
:::: - Se c'è una copia in un'altra cache, la "Shared line" è settata "on". Se la "Shared line" is "off" la cache è settata '''VE''' altrimenti tutte le cache sono settate '''S'''
::* White Miss
::: - L'operazione è fatta in due step. Read Miss seguita da una Write Hit.
::: - Se il dato proviene da una cache (Shared Line "on") una Write-broadcasting è inviata sul bus per aggiornate tutte le altre cache e la MM (Write Through). Tutte le cache sono settate '''S'''
::: - altrimenti la cache è settata '''D'''

* '''Transazioni di Bus '''

::* Bus Read
::: - Se hit ('''D''' o '''VE''' o '''S''') il dato è inviato sul bus (intervento) e in caso di '''D''' il dato è scritto anche in MM. La cache è settata '''S'''
::* Bus Write
:::: - Se hit ('''D''' o '''VE''' o '''S''') il dato è inviato sul bus (Intervento).
::: - Tutte le cache sono settate '''S'''
::* Write Broadcasting
::: - La cache è aggiornata con il nuovo dato. Lo stato rimane '''S'''

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da D-VE-S (da tutte le cache "valide")
: - ''Write-broadcasting - Write through''
: - ''Copy-Back'': rimpiazzo di D e su qualsiasi transazione con una cache D

----
[[File:Dragon_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|Dragon Protocol - State Transaction Diagram]]

=== Protocollo Dragon (Xerox) ===
&nbsp; Stati D-SD-VE-SC (MOES)<ref name="Various protocols" />
Nota - lo stato '''SC''', nonostante il termine "clean", può essere "clean" o "dirty" come lo stato '''S''' degli altri protocolli. '''SC''' e '''S''' sono equivalenti.

: - Caratteristiche:
:: - Non uso di stato "Invalido"
:: - Write-broadcasting (non Write Through)
:: - Uso della "shared line"
:: - Write-broadcasting evita la necessità dello stato "Invalido"

* '''Operazioni del Processor'''

::* Read Miss
::: - Ii dato è fornito dall' "owner", vale a dire da '''D''' o da '''SD''' altrimenti dalla MM. '''D''' è cambiato in '''SD'''
::: - Se la "shared line" è "on" la cache è settata '''SC''' altrimenti '''VE'''
::* Wiite Hit
::: - Se la cache è '''D''' o '''VE''' (esclusività), la scrittura è fatta localmente senza nessun'altra azione. La cache è settata (o rimane) '''D'''
:::: - altrimenti '''SD''' o '''SC''' (sharing) il dato è scritto in cache e una Write-broadcasting è inviata sul bus per aggiornare tutte le altre cache - La MM non è aggiornata (non Write through)
:::: - Se c'è una copia in un'altra cache, la "Shared line" è settata "on"
:::: - Se la "Shared Line" è "on" la cache è settata '''SD''', altrimenti '''D'''. Tutte le altre eventuali copie sono settate '''SC'''
::* Wiite Miss
::: - Come per la Read Miss, il dato è inviato dall' "owner", '''D''' o '''SD''' o MM, poi la cache viene aggiornata.
::: - Se c'è una copia in un'altra cache, la "Shared line" è settata "on"
::: - Se la "Shared Line" è "on" il dato aggiornato è distribuito alle altre cache e lo stato è settato '''SD'''. Tutte le altre cache sono settate '''SC'''
::: - altrimenti la cache è settata '''D'''

* '''Transazioni di Bus '''

::* Bus Read
::: - SE la cache è '''D''' o '''SD''' il dato è inviato alla cache richiedente (intervention). La cache è settata (o rimane) '''SD'''
::: - altrimenti la cache rimane '''SC'''
::* Bus Write
::: - Se la cache è '''D''' o '''SD''' il dato è inviato sul bus (Intervention)
::: - La cache è settata '''SC'''
::* Write Broadcasting
::: - La cache è aggiornata con il nuovo dato. La cache rimane '''SC'''

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da D-SD (ma non da VE)
: - ''Write-broadcasting''
: - ''Copy-Back'': rimpiazzo di D-SD

----
[[File:MERSI-MESIF_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|MERSI - MESIF Protocol - State Transaction Diagram]]

=== Protocollo MERSI (IBM) / MESIF (Intel) ===
&nbsp; Stati MERSI o R-MESI &nbsp; Stati MESIF
&nbsp; Protocolli brevettati - IBM (1997)<ref name="R-MESI" /> - Intel (2002)<ref name="MESIF2">Forward state for use in cache coherency in a multiprocessor system - Intel -https://www.google.com/patents/US6922756</ref>

: - MERSI e MESIF sono lo stesso identico protocollo (solamente lo stato del nome è differente, '''F''' invece di '''R''')
: - Caratteristiche:
:: - Le stesse funzionalità del protocollo [[#Protocollo Illinois|Illinois]]
:: - Un nuovo stato '''R''' (Recent) / '''F''' (Forward) è l' "''owner'' " per i dati shared-clean" (condivisi).
:: - La "shared ownership" (l'owner delle cache condivise "clean" - non modificate) non è assegnata da una rete di priorità come con [[#Protocollo Illinois|Illinois]], ma è sempre assegnata all'ultima cache con Read Miss, settando il suo stato '''R'''/'''F'''
:: - La "shared ownership" è temporaneamente persa nel caso di rimpiazzo della linea '''R'''/'''F'''. La "ownership" è riassegnata alla prima successiva Read Miss con cache "shared" non modificate
:: - Uso della "shared line"

* '''Operazioni'''

: - ''Write Allocate''
: - ''Intervention'': da M-E-R/F
: - ''Write Invalidate''
: - ''Copy-Back'': rimpiazzo di M

----

=== MESI vs MOESI ===
MESI e MOESI sono i protocolli più popolari
È comune opinione che MOESI sia un'estensione del [[protocollo MESI]] e perciò più sofisticato e più performante. Questo è vero solamente se confrontato con MESI standard, cioè con MESI senza intervento tra cache condivise "clean" (dato non modificato rispetto alla MM). MESI con intervento tra cache condivise "clean", come <u>'''''MESI [[#Protocollo Illinois|Illinois]] o gli equivalenti protocolli 5-stati [[#Protocollo MERSI (IBM) / MESIF (Intel)|MERSI / MESIF]], sono molto più performanti del protocollo MOESI'''''</u>.
In MOESI, le operazioni cache-cache sono fatte solamente su dati modificati. Invece nei protocolli tipo MESI [[#Protocollo Illinois|Illinois]] e [[#Protocollo MERSI (IBM) / MESIF (Intel)|MERSI / MESIF]], le operazioni <u>cache-cache sono sempre fatte" sia su dati "clean" che su dati modificati</u>. Nel caso di dati modificati, l'intervento è fatto dall' "owner" M, ma <u>l'ownership non è persa</u> perché essa migra in un'altra cache (la R/F in [[#Protocollo MERSI (IBM) / MESIF (Intel)|MERSI / MESIF]] o in una cache selezionata come nell caso di [[#Protocollo Illinois|Illinois]]. L'unica differenza è che la MM deve essere aggiornata. In ogni caso anche in MOESI questa transazione dovrà più tardi comunque essere fatta in caso di rimpiazzo dell' "owner", se nessun'altra modifica avviene nel frattempo. Tuttavia questo è un limite minore rispetto a una transazione di memoria dovuta ad un non intervento, come nel caso di dati non modificati (clean) per il protocollo MOESI. (vedi per es. "Performance evaluation between MOESI (Shanghai) and MESIF Nehalem-EP"<ref name="Shanghai - Nehalem-EP">Comparing Cache Architectures and Coherency Protocols on x86-64 Multicore SMP Systems - https://people.freebsd.org/~lstewart/articles/cache-performance-x86-2009.pdf</ref>)
I sistemi più avanzati usano solamente il protocollo [[#Protocollo MERSI (IBM) / MESIF (Intel)|MERSI / MESIF]]|R-MESI type / MESIF (IBM / Intel) o i più completi [[#Protocollo RT-MESI|RT-MESI]], [[#Protocollo HRT-ST-MESI|HRT-ST-MESI]] e [[#Protocollo MERSI (IBM) / MESIF (Intel)|MERSI / MESIF]] che sono l'unione evoluta dei protocolli MESI e MOESI.
Nota: Trasferimenti cache-cache sono soluzioni efficienti per sistemi multiprocessor/multicore connessi direttamente tra loro, ma meno nei sistemi con [[Memoria cache#Cache Remota|Cache remota]] come nei [[Memoria cache#Coerenza delle Cache in cc-NUMA|sistemi NUMA]] dove è preferibile MESI standard. Esempio nel Protocollo [[#Protocollo POWER4 IBM|POWER4 IBM]] lo "shared intervention" è fatto solo "localmente" e non tra moduli remoti.
----
[[File:RT-MESI_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|RT-MESI Protocol - State Transaction Diagram]]

=== Protocollo RT-MESI ===
&nbsp; States RT-MESI
&nbsp; protocollo brevettato IBM<ref name="HRT-MESI" /><ref name="RT-MESI" />

: - Caratteristiche:
:: - Unione di MESI e MOESI
:: - Shared Intervention + Dirty Intervention (sia tra cache "clean" che tra cache con dati modificati)
:: - Stesse funzionalità del protocollo [[#Protocollo MERSI (IBM) / MESIF (Intel)|R-MESI]] con un nuovo stato '''T''' = Tagged, equivalente allo stato '''O'''
:: - Migrazione del "Dirty-Owner"
: - L' "owner" (sia Shared che Dirty) è sempre l'ultima cache richiedente (il nuovo "owner" ([[Memoria cache#Replacement Policy (Politica di Rimpiazzo - deallocazione della linea di cache)|LRU]]) ha meno probabilità di essere deallocato a breve rispetto a quello più vecchio)
: - Gli "owner" sono '''T''', '''M''', '''E''', '''R''' (tutti eccetto '''S''')
: - Uso della "shared line"

* '''Operazioni del Processor'''

::* Read Miss
::: - Se c'è una copia '''M''' o '''T''' (dirty-ownership) in un'altra cache, il dato è fornito da questa cache (dirty-intervention). La cache richiedente è settata '''T''' e i precedenti '''M''' o '''T''' sono cambiati in '''S'''
::: - Se c'è una copia '''E''' o '''R''' (shared-ownership) in un'altra cache, il dato è fornito da questa cache (shared-intervention). La cache richiedente è settata '''R''' e i precedenti '''E''' o '''R''' sono cambiati in '''S'''
::: - altrimenti il dato è letto dalla MM e la cache è settata '''R'''.
::* Write Hit
::: - Se la cache è '''M''' o '''E''' (esclusività), la scrittura è fatta localmente senza nessun'altra azione
::: - altrimenti '''T''' o '''R''' o '''S''' (sharing) una transazione di "Invalida" è inviata sul bus per invalidare tutte le altre cache.
::: - La cache è settata (o rimane) '''M''' e tutte le altre cache sono settate '''I'''
::* Write Miss
::: - Un'operazione di [[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]] è inviata sul bus
::: - Il dato è fornito dall' "owner" o dalla MM come nella Read Miss, poi il dato è scritto (aggiornato) in cache
::: - La cache è settata '''M''' e tutte le altre cache sono settate '''I'''

* '''Transazioni di Bus '''

::* Bus Read
::: - Se la cache è '''T''' o '''M''' o '''R''' o '''E''' il dato è inviato alla cache richiedente (intervention).
::: - La cache è settata (o rimane) '''S'''
::* Bus Write - ([[Memoria cache#Write Allocate (scrittura con allocazione)|RWITM]])
::: - Se la cache è '''T''' o '''M''' o '''R''' o '''E''' il dato è inviato alla cache richiedente (intervention)
::: - La cache è settata "Invalida" ('''I''')
::* Transazione di Bus di Invalida
::: - La cache è settata "Invalida" ('''I''')

* '''Operations'''

: - ''Write Allocate''
: - ''Intervention'': da T-M-R-E
: - ''Write Invalidate''
: - ''Copy-Back'': rimpiazzo di T-M

----

=== Protocollo RT-ST-MESI ===
È un miglioramento del protocollo [[#Protocollo RT-MESI|RT-MESI]]<ref name="RT-MESI" /> ed è un subset del protocollo [[#Protocollo HRT-ST-MESI|HRT-ST-MESI]]<ref name="HRT-MESI" />

: '''S<sub>T</sub>''' = Shared-Tagged
: - L'uso dello stato "Shared-Tagged" permette di mantenere l' "intervention" dopo una deallocazione di una linea di cache "Tagged"
:: - Nel caso di rimpiazzo di '''T''' (deallocazione della linea di cache), il dato deve essere scritto indietro in MM e così perdere la "ownershisp". Per evitare ciò può essere usato un nuovo stato '''S<sub>T</sub>'''. In caso di Read Miss il precedente '''T''' è settato '''S<sub>T</sub>''' invece di '''S'''. '''S<sub>T</sub>''' sarà il candidato per rimpiazzare la ownership in caso di deallocazione di '''T'''. La transazione di "Copy Back" di '''T''' è bloccata da '''S<sub>T</sub>''' (la memoria non è aggiornata) che cambia il suo stato in '''T'''. Nel caso di una nuova Read MIss da un'altra cache, quest'ultima è settata '''T''', il precedente '''T''' è cambiato in '''S<sub>T</sub>''' e precedente '''S<sub>T</sub>''' è cambiato in '''S'''.

Un miglioramento aggiuntivo può essere ottenuto usando più di uno stato '''S<sub>T</sub>''', '''S<sub>T1</sub>''', '''S<sub>T2</sub>''' ,… '''S<sub>Tn</sub>'''.

: - In Read Miss, '''T''' è cambiato in '''S<sub>T1</sub>''' e gli indici degli altri '''S<sub>Ti</sub>''' sono incrementati di "1"
: - In caso di deallocazione di '''T''', '''S<sub>T1</sub>''' blocca la transazione di "Copy Back" e cambia il suo stato in '''T''' e tutti gli indici degli '''S<sub>Ti</sub>''' sono decrementati di "1".
: - In caso di una deallocazione, per esempio di '''S<sub>Tk</sub>''', la catena sarà interrotta e tutti gli '''S<sub>Ti</sub>''' con indice maggiore di "k" saranno automaticamente persi in termini di '''S<sub>T</sub>''', e saranno considerati ''de facto'' solamente come stati '''S''', anche se essi manterranno lo stato '''S<sub>T</sub>'''. Tutto ciò perché solo '''S<sub>T1</sub>''' interviene per bloccare e sostituirsi a '''T'''. Per es. se si ha una situazione tipo '''T''', '''S<sub>T1</sub>''', '''S<sub>T3</sub>''', '''S<sub>T4</sub>''' con '''S<sub>T2</sub>''' rimpiazzato, se '''T''' sarà rimpiazzato la nuova situazione sarà '''T''', '''S<sub>T2</sub>''', '''S<sub>T3</sub>''' senza nessun '''S<sub>T1</sub>'''.

----
[[File:HRT-ST-MESI_Protocol_-_State_Transaction_Diagram.svg|destra|miniatura|HRT-ST-MESI Protocol - State Transaction Diagram]]

=== Protocollo HRT-ST-MESI ===
Protocollo IBM brevettato HRT-ST-MESI completo<ref name="HRT-MESI" /><ref name="RT-MESI" />
- Stato '''I''' = Tag invalido (*) - Dati Invalidi
- Stato '''H''' = Tag Valido - Dati Invalidi
- Lo stato '''I''' è settato all'inizializzazione e il suo stato cambia solo dopo una Read o Write miss del processor. Poi non tornerà più in questo stato.
- '''H''' ha le stesse funzionalità dello stato '''I''' ma con in più la capacità di catturare le transazioni del bus aventi lo stesso Tag della directory e aggiornare la cache dati.
- Dopo la prima utilizzazione '''I''' viene rimpiazzato da '''H''' nelle sue funzioni

: - Le principali funzioni sono:
:: - Write Back
:: - Intervento sia su dati dirty che shared-clean - da '''T'''-'''M'''-'''R'''-'''E'''
:: - Stati di riserva del Tagged (Shared-Tagged)
:: - Auto aggiornamento dello stato invalido '''H''' (Hover)

(*) - Nota: Il Tag per definizione è sempre valido, ma sino al primo aggiornamento della linea di cache è considerato invalido per non aggiornare la cache anche quando questa linea non è ancora stata richiesta e usata.
----

=== Protocollo POWER4 IBM ===
&nbsp; Stati M-T-Me-S-I -Mu-S<sub>L</sub> = RT-MESI+Mu<ref name="POWER4 protocol">"POWER4 System Microarchitecture", http://www.cc.gatech.edu/~bader/COURSES/UNM/ece637-Fall2003/papers/TDF02.pdf {{Webarchive|url=https://web.archive.org/web/20131107140531/http://www.cc.gatech.edu/~bader/COURSES/UNM/ece637-Fall2003/papers/TDF02.pdf |data=7 novembre 2013 }}</ref>

: - Uso della "shared line"
: - Usato in [[Memoria cache#Sistemi Multi-core|Sistemi multi-core/moduli]] - multi-cache L2<ref name="POWER4 protocol" />
: - Questo protocollo è equivalente al protocollo [[#Protocollo RT-MESI|RT-MESI]] per sistemi con cache L2 multiple su [[Memoria cache#Sistemi Multi-core|sistemi multi moduli]].
:* <span style=color:blue class="" data-ve-attributes="{"style":"color"}">'''S<sub>L</sub>'''</span> - "Shared Last" equivalente a '''R''' nel [[#Protocollo RT-MESI|RT-MESI]] protocollo
:* <span style=color:blue class="" data-ve-attributes="{"style":"color"}">'''Me'''</span> - "Valid Exclusive" = '''E''' (valido esclusivo)
:* <span style=color:blue class="" data-ve-attributes="{"style":"color"}">'''Mu'''</span> - unsolicited modified state - stato modificato esclusivo non sollecitato
:: - stato speciale - richiesta di prenotazione scrittura e lettura "doubleword" (per l'implementazione a 64-bit)
: - "Shared intervention" da '''S<sub>L</sub>''' è fatto solo tra cache L2 dello stesso modulo
: - "Dirty intervention" da '''T''' è fatto solo tra cache L2 dello stesso modulo

* '''Operations'''

: - ''Write Allocate''
: - ''Intervention'': da M-T-VE-S<sub>L</sub> = M-O-E-S<sub>L</sub>
: - ''Write Invalidate''
: - ''Copy-Back'': rimpiazzo di M-T
: - Nota: T e S<sub>L</sub> - Intervento solo locale al modulo

== Considerazione generale sui protocolli ==
Sotto certe condizioni il più efficiente e completo protocollo risulta essere il protocollo '''[[#HRT-ST-MESI protocol|HRT-ST-MESI]]'''
:- Write Back
: - Intervento sia su dati dirty che shared-clean - da '''T'''-'''M'''-'''R'''-'''E'''
: - Stati di riserva del Tagged (Shared-Tagged)
: - Auto aggiornamento dello stato invalido '''H''' (Hover)
== Note ==

<references />

[[Categoria:Memorie informatiche]]
{{portale|informatica}}