In un sistema distribuito su larga scala privo di un'autorità centrale, stabilire l'ordine cronologico degli eventi è uno dei problemi più complessi dell'informatica teorica. Affidarsi agli orologi fisici locali dei computer tramite il protocollo Network Time Protocol (NTP) si rivela sistematicamente fallimentare: oscillazioni dei cristalli di quarzo, latenze di rete asimmetriche e correzioni dei secondi intercalari introducono derive temporali (clock skew) che possono compromettere l'integrità dei dati.
"Nei sistemi distribuiti, il tempo non è un valore scalare assoluto indicato da una lancetta, ma una relazione causale parziale tra eventi: un evento A può causare B, oppure A e B possono accadere in modo del tutto concorrente."
1. Il Limite degli Orologi Logici di Lamport
Nel fondamentale articolo del 1978 "Time, Clocks, and the Ordering of Events in a Distributed System", Leslie Lamport introdusse la relazione di "happened-before" ($\prec$):
- Se $a$ e $b$ sono eventi dello stesso processo e $a$ accade prima di $b$, allora $a \prec b$.
- Se $a$ è l'invio di un messaggio da parte di un processo e $b$ è la ricezione di quel messaggio da parte di un altro processo, allora $a \prec b$.
- Se $a \prec b$ e $b \prec c$, allora $a \prec c$ (proprietà transitiva).
Tuttavia, l'orologio scalare di Lamport soffre di un grave limite teorico: dato un timestamp logico $L(a) < L(b)$, non è possibile dedurre che $a \prec b$; gli eventi potrebbero essere concorrenti ($a \parallel b$) ma ricevere timestamp numerici diversi per pura casualità dell'incremento locale.
2. Gli Orologi Vettoriali (Mattern & Fidge, 1988)
Per superare questo limite e consentire l'isomorfismo tra ordine causale e timestamp, Friedemann Mattern e Colin Fidge hanno introdotto gli Orologi Vettoriali (Vector Clocks). In un cluster con $N$ nodi attivi, ogni nodo $i$ mantiene un vettore di $N$ interi:
V_i = [v_1, v_2, ..., v_N]
Le Tre Regole Fondamentali di Aggiornamento
- Inizializzazione: Al momento dell'avvio della rete, ogni nodo imposta tutte le coordinate del proprio vettore a zero: $V_i[k] = 0 \quad \forall k \in \{1, ..., N\}$.
- Evento Locale: Prima di eseguire una transazione, emettere un token o aggiornare la memoria a grafo, il nodo incrementa la propria coordinata:
V_i[i] = V_i[i] + 1 - Messaggio e Fusione Causale: Quando il nodo $i$ invia un messaggio mesh al nodo $j$, allega una copia del proprio vettore $V_i$. Il nodo ricevente $j$ aggiorna il proprio orologio calcolando il massimo elemento per elemento (estremo superiore o sup):
V_j[k] = max(V_j[k], V_msg[k]) ∀ k
e incrementa successivamente il proprio indice locale:V_j[j] = V_j[j] + 1.
3. La Condizione di Precedenza Causale Rigorosa
Grazie alla struttura vettoriale, possiamo confrontare due eventi $a$ e $b$ con vettori $V(a)$ e $V(b)$ in modo matematicamente certo:
V(a) <= V(b) <==> (∀ k, V(a)[k] <= V(b)[k])
V(a) < V(b) <==> (V(a) <= V(b) AND ∃ k tale che V(a)[k] < V(b)[k])
Teorema Fondamentale:
a ≺ b <===> V(a) < V(b)
a || b <===> NOT(V(a) < V(b)) AND NOT(V(b) < V(a))
Se non sussiste né $V(a) < V(b)$ né $V(b) < V(a)$, gli eventi sono concorrenti ($a \parallel b$). In questo caso il sistema sa con certezza che le due operazioni sono avvenute in rami paralleli della rete senza influenzarsi a vicenda.
4. Implementazione Reale nel Cluster 00MESH
Nel cluster HyperSpace, composto dal Mac M5 (Hub Control Plane), dalla workstation HP OMEN 16 (GPU RTX Code Engine) e dall'ASUS V16 (MoE Deep Inference), ogni transizione di stato della memoria e ogni prompt di dialogo con Anna viene coordinato attraverso il modulo VectorClock:
# Implementazione Python AST-Validated del Vector Clock in HyperSpace
from typing import Dict, List, Tuple
class SovereignVectorClock:
def __init__(self, node_id: str, cluster_nodes: List[str]):
self.node_id = node_id
self.clock: Dict[str, int] = {n: 0 for n in cluster_nodes}
def tick(self) -> Dict[str, int]:
"""Avanza il contatore logico del nodo corrente."""
self.clock[self.node_id] += 1
return dict(self.clock)
def merge_message(self, received_clock: Dict[str, int]) -> Dict[str, int]:
"""Fonde causalmente l'orologio del payload mesh calcolando il sup."""
for nid, val in received_clock.items():
self.clock[nid] = max(self.clock.get(nid, 0), val)
self.clock[self.node_id] += 1
return dict(self.clock)
def compare_causality(self, other: Dict[str, int]) -> str:
"""Restituisce: 'PRECEDES' (a ≺ b), 'SUCCEEDS' (b ≺ a), o 'CONCURRENT' (a || b)."""
all_keys = set(self.clock.keys()).union(other.keys())
is_less_or_equal = all(self.clock.get(k, 0) <= other.get(k, 0) for k in all_keys)
is_strictly_less = any(self.clock.get(k, 0) < other.get(k, 0) for k in all_keys)
is_greater_or_equal = all(self.clock.get(k, 0) >= other.get(k, 0) for k in all_keys)
is_strictly_greater = any(self.clock.get(k, 0) > other.get(k, 0) for k in all_keys)
if is_less_or_equal and is_strictly_less:
return "PRECEDES"
if is_greater_or_equal and is_strictly_greater:
return "SUCCEEDS"
return "CONCURRENT"
5. Risoluzione dei Conflitti senza Deadlock né Server Centrali
Quando due nodi operano in modo concorrente su note della memoria a grafo (ad esempio se il Mac Hub riassume un log mentre l'OMEN convalida una patch di codice), 00MESH adotta una struttura a Conflict-Free Replicated Data Types (CRDT):
- Le operazioni concorrenti non bloccano l'esecuzione con lock distribuiti complessi e fragili (come il two-phase commit).
- I rami concorrenti vengono archiviati come nodi biforcati nel grafo di memoria.
- Il ciclo notturno di consolidamento (Nightly Consolidation) applica una funzione di merge deterministica, unificando le evidenze senza perdita di informazioni.
Conclusioni
L'adozione degli orologi vettoriali rappresenta l'architrave su cui poggia l'intera sovranità computazionale di 00MESH. Essa garantisce che centinaia di nodi eterogenei possano dialogare, inferire modelli linguistici e scambiarsi token senza dover mai interrogare un server di sincronizzazione centralizzato.