praca_magisterska/pytania/odpowiedzi/23-zegary-logiczne-wektory.md

# Pytanie 23: Zegary logiczne i wektory stempli czasowych

## Pytanie
**"Przedstawić koncepcję i przeznaczenie zegarów logicznych i wektorów stempli czasowych."**

Przedmiot: ERSMS (Elementy Rozproszonych Systemów i Middleware'u Sieciowego)

---

## 📚 Odpowiedź główna

### 1. Problem czasu w systemach rozproszonych

```
┌─────────────────────────────────────────────────────────────────┐
│ Brak globalnego zegara:                                         │
│                                                                 │
│ Node A:  ──●────────●────────●──→ czas lokalny A               │
│            e1      e2       e3                                  │
│                    │↘                                           │
│                    │  ↘ msg                                     │
│                    │    ↘                                       │
│ Node B:  ────●─────────────●───→ czas lokalny B                │
│              e4           e5                                    │
│                                                                 │
│ Pytanie: Czy e2 było przed e5, czy po?                         │
│ Zegary fizyczne: drift, synchronizacja niedokładna             │
└─────────────────────────────────────────────────────────────────┘
```

**Problem:** Nie możemy polegać na zegarach fizycznych - drift, opóźnienia sieciowe, brak atomowej synchronizacji.

---

### 2. Relacja "happened-before" (Lamport)

#### Definicja (→)

Zdarzenie **a** happened-before **b** (a → b) jeśli:
1. **a** i **b** są w tym samym procesie i **a** występuje przed **b**
2. **a** to wysłanie wiadomości, **b** to jej odbiór
3. Przechodniość: a → c ∧ c → b ⟹ a → b

```
P1:  ─●─────●─────────●───→
      a     b         d
            │↘
            │  ↘ m1
            │    ↘
P2:  ───────────●─────●───→
                c     e

a → b (ten sam proces)
b → c (wysłanie → odbiór)
a → c (przechodniość)
c → e (ten sam proces)
```

#### Zdarzenia współbieżne

Jeśli ¬(a → b) ∧ ¬(b → a), to **a || b** (współbieżne).

---

### 3. Zegar Lamporta (Scalar Clock)

#### Algorytm

```
Każdy proces P_i ma licznik C_i:

1. Przed każdym zdarzeniem lokalnym:
   C_i := C_i + 1

2. Wysyłając wiadomość m:
   C_i := C_i + 1
   Dołącz timestamp(m) = C_i

3. Odbierając wiadomość m z timestamp t:
   C_i := max(C_i, t) + 1
```

#### Przykład

```
P1: C=0  ──●(1)────●(2)─────────●(5)──→
           a       b             d
                   │↘
                   │  ↘ m(2)
                   │    ↘
P2: C=0  ────●(1)───────●(3)────●(4)──→
             x           c       e

Zdarzenia: a=1, b=2, x=1, c=3, e=4, d=5
```

#### Właściwości

| Właściwość | Zegar Lamporta |
|------------|----------------|
| a → b ⟹ C(a) < C(b) | ✅ TAK |
| C(a) < C(b) ⟹ a → b | ❌ NIE |

**Ograniczenie:** C(a) < C(b) nie oznacza, że a → b (mogą być współbieżne).

---

### 4. Zegary wektorowe (Vector Clocks)

#### Algorytm

```
Każdy z N procesów ma wektor V[1..N]:

1. Przed każdym zdarzeniem lokalnym:
   V_i[i] := V_i[i] + 1

2. Wysyłając wiadomość m:
   V_i[i] := V_i[i] + 1
   Dołącz timestamp(m) = V_i

3. Odbierając wiadomość m z timestamp T:
   V_i[j] := max(V_i[j], T[j]) dla każdego j
   V_i[i] := V_i[i] + 1
```

#### Przykład

```
P1: [0,0,0] ──●[1,0,0]────●[2,0,0]─────────●[3,2,0]──→
              a            b                 d
                           │↘
                           │  ↘ m[2,0,0]
                           │    ↘
P2: [0,0,0] ────●[0,1,0]─────────●[2,2,0]────●[2,3,0]──→
                x                 c            e
```

#### Porównanie wektorów

```
V ≤ W  ⟺  ∀i: V[i] ≤ W[i]
V < W  ⟺  V ≤ W ∧ V ≠ W
V || W ⟺  ¬(V ≤ W) ∧ ¬(W ≤ V)

Przykład:
[2,3,1] < [2,4,1]  (happened-before)
[2,3,1] || [1,4,2] (współbieżne)
```

#### Właściwości

| Właściwość | Zegar wektorowy |
|------------|-----------------|
| a → b ⟺ V(a) < V(b) | ✅ TAK |
| Wykrycie współbieżności | ✅ TAK |

**Zegary wektorowe charakteryzują dokładnie relację happened-before!**

---

### 5. Porównanie

| Cecha | Lamport | Vector Clock |
|-------|---------|--------------|
| **Rozmiar** | O(1) | O(N) |
| **a → b ⟹ C(a) < C(b)** | ✅ | ✅ |
| **C(a) < C(b) ⟹ a → b** | ❌ | ✅ |
| **Wykrycie współbieżności** | ❌ | ✅ |
| **Zastosowanie** | Uporządkowanie | Wykrywanie konfliktów |

---

### 6. Zastosowania

| Zastosowanie | Typ zegara | Cel |
|--------------|------------|-----|
| **Mutual exclusion** | Lamport | Uporządkowanie żądań |
| **Causal broadcast** | Vector | Dostarczanie w kolejności przyczynowej |
| **Conflict detection** | Vector | Wykrycie współbieżnych zapisów |
| **Distributed debugging** | Vector | Odtworzenie kolejności zdarzeń |
| **Version vectors (Dynamo)** | Vector | Wykrycie konfliktów w replikacji |

#### Przykład: Dynamo/Riak

```
Put(key, value) z vector clock:

Client → Server A: put("x", "v1", [A:1])
Client → Server B: put("x", "v2", [B:1])

Konflikt wykryty: [A:1] || [B:1]
Oba wartości przechowane, klient rozwiązuje
```

---

### 7. Warianty i rozszerzenia

| Wariant | Opis |
|---------|------|
| **Interval Tree Clocks** | Dynamiczna liczba procesów |
| **Bloom Clocks** | Probabilistyczne, kompaktowe |
| **Hybrid Logical Clocks** | Lamport + czas fizyczny |
| **Matrix Clocks** | Wiedza o wiedzy innych |

---

## 🧠 Mnemoniki

### "Lamport = Licznik skalarny":
Jedna liczba, nie wykrywa współbieżności

### "Vector = Każdy wie o każdym":
V[i] = ile zdarzeń widział proces i

### "< oznacza →, || oznacza współbieżność":
Porównanie wektorów = relacja przyczynowa

---

## ❓ Pytania dodatkowe

### Q1: "Dlaczego nie używać NTP zamiast zegarów logicznych?"
**Odpowiedź:** NTP ma błąd ~ms (LAN) do ~100ms (WAN). Dla zdarzeń szybszych niż błąd synchronizacji, kolejność fizyczna jest nieznana. Zegary logiczne dają gwarancje przyczynowe bez względu na drift.

### Q2: "Co to jest causal consistency?"
**Odpowiedź:** Model spójności gdzie zapisy przyczynowo zależne są widziane w tej samej kolejności przez wszystkich. Wymaga vector clocks. Słabszy niż sequential consistency, silniejszy niż eventual.

### Q3: "Problem skalowalności vector clocks?"
**Odpowiedź:** O(N) rozmiar dla N procesów. Rozwiązania: przycinanie (Dynamo), Interval Tree Clocks (dynamiczne ID), Bloom clocks (probabilistyczne).

---

## 🎯 Kluczowe punkty

1. **Problem:** Brak globalnego zegara w systemach rozproszonych
2. **Lamport:** Skalarny, a → b ⟹ C(a) < C(b), nie odwrotnie
3. **Vector:** a → b ⟺ V(a) < V(b), wykrywa współbieżność
4. **Zastosowania:** Replikacja, debugging, causal broadcast

---

## 📖 Źródła

1. Lamport - "Time, Clocks, and the Ordering of Events" (1978)
2. Fidge, Mattern - "Vector Clocks" (1988)
3. DeCandia et al. - "Dynamo" (Amazon, 2007)