Logical time

1. Capture just the “happens before” relationship between events
   • 舍弃时间的微小粒度
   • 大致对应于因果关系

为什么要逻辑时钟

之前假设的时钟都是与实际时间相关的，但是，在许多应用中，只要所有的机器时间同步即可，不一定需要和实际时间完全一致。比如：make程序时，一个节点编译生成input.o，一个节点是编辑源文件input.c，两个节点判断input.o是否过时（如果input.c的时间在input.o后面，说明需要重新编译），达成一致，可以跟踪各自的事件（如生成了一个新版本的input.c）。这类算法就叫逻辑时钟

Logical time and logical clocks (Lamport 1978)

Events at three processes

1. 可以使用事件排序而不是同步时钟
   • 如果两个事件发生在同一进程中 pi (i = 1, 2, … N)，而且它们发生在pi 所观察的顺序，则就能称这“-> i” (“happened before” i)
   • 当m个消息在两个进程之间发送时，发送（m）发生在接收（m）。消息不可能就在发送之前就被接收，也不能在发送的同时被接收，这是因为消息需要一定时间才能到达接收端
   • "先发生"关系是传递性的
2. 关系之前发生的是因果顺序的关系
3. 并非所有事件都与"->"相关
4. 考虑a和e（不同的流程，并没有链接的消息来关联他们）
   • 它们与"->"不相关; 他们被认为是并发的
   • 被写作 a||e
5. 逻辑时钟是一个单调递增的软件计数器
   • 它不需要涉及物理时钟。
6. 每个进程pi都有一个逻辑时钟，可以用来将逻辑时间戳应用于事件
   • 规则1：在进程pi的每个事件之前，Li都加1
   • 规则2 :
     • （a）当进程pi发送消息m时，它捎带t = Li
     • （b）当pj接收到（m，t）时，它设置Lj：= max（Lj，t），并在时间戳事件接收之前应用规则1
7. 每个p1，p2，p3的逻辑时钟都被初始化为零，
8. 时钟值是在事件之后的那些时钟值。
9. 对于m1,2是捎带的，c取最大值（0,2）+1 = 3

Lamport’s algorithm

1. 每个进程i 我都保留一个当地时钟 ，Li
2. 三个规则：
   • 在每个事件发生之前，进程i 增加Li
   • 要在进程i发送消息m，应用规则1，然后在消息中包含当前本地时间：i。，send（m，Li）
   • 为了在过程j接收消息（m，t），设置Lj = max（Lj，t），然后在时间标记接收事件之前应用规则1
3. 事件e的全球时间L（e）就是当地时间

e ->e’ implies L(e)<L(e’)
The converse is not true, that is L(e)<L(e') does not imply e ->e’
e.g. L(b) > L(e) but b || e

Total-order Lamport clocks

1. 许多系统需要事件的总体排序，而不是部分排序
2. 使用Lamport的算法，但使用进程ID打破关系
   L(e) = M * Li(e) + i
   M = maximum number of processes
   i = process ID

Vector Clocks（向量时钟）

1. 矢量时钟克服了Lamport逻辑时钟的缺点
   • L(e) < L(e’) does not imply e happened before e’
2. 目标
   • 想使顺序匹配因果关系
   • V（e）<V（e'）当且仅当e→e'
3. 方法
   • 向量V（e）[c1，c2 ...，cn]标记每个事件
     - ci =＃在进程i中的因果关系在e之前

Vector Clock Algorithm

1. 初始化 all vectors [0,0,…,0]
2. 对于进程i的事件，增加自己的ci
3. 用本地向量发送标签消息
   4.当进程j收到带有向量[d1，d2，...，dn]的消息时：
   • 将本地每个本地条目k设置为max（ck，dk）
   • cj的增量值

Vector Clocks

1. At p1
   • a occurs at (1,0,0); b occurs at (2,0,0)
   • （piggyback）捎带（2,0,0）在m1上
2. At p2 on receipt of m1 use max ((0,0,0), (2,0,0)) = (2, 0, 0) and add 1 to own element = (2,1,0)
3. 注意e→e'意味着V（e）<V（e'）。 反过来也是如此
4. 你能看到一对平行的事件吗？
   • c || e（并行），因为既不V（c）<= V（e）和也不V（e）<= V（c）

Vi[j]的含义：i节点上所了解到J节点的时钟值

总结归纳

1. 时钟同步
   • 依靠时间戳网络消息
   • 估计消息传输的延迟
   • 可以同步到UTC或本地源
   • 时钟从未完全同步
   • 通常不足以用于分布式系统
   • 可能需要完全有序的事件
   • 可能需要非常高的精度
2. 逻辑时钟
   • 编码因果关系
   • Lamport时钟只提供单向编码
   • 矢量时钟提供确切的因果关系信息

一个例子

1. 四个地点：投手丘，一垒，本垒，三垒
2. Ten events:
   e1：投手抛球回家
   e2：球到达家中
   e3：击球手击中投手
   e4：击球手跑到一垒
   e5：跑步者跑回家
   e6：球到达投手
   e7：投手投球到一垒
   e8：跑步者到家
   e9：球到达第一垒
   e10：击球手到达一垒
3. 投手知道e1发生在e6之前，发生在e7之前
4. 本垒板裁判知道e2在e3之前，这是在e8之前，e8之前，...

5. e8和e9之间的关系还不清楚

   
   
   image.png

时钟同步的方法

1. 从一个基地发送消息到家里？
   • 或者到一个中央计时器
   • 这个消息需要多久才能到达？
2. 在游戏之前同步时钟？
   • 时钟漂移
     • 百万分之一= 11秒内> 1秒
   • 在游戏中不断同步？
     • GPS, pulsars, etc

Lamport时钟

L(e1) = 1 (pitcher throws ball to home)
L(e2) = 2 (ball arrives at home)
L(e3) = 3 (batter hits ball to pitcher)
L(e4) = 4 (batter runs to first base)
L(e5) = 1 (runner runs to home)
L(e6) = 4 (ball arrives at pitcher)
L(e7) = 5 (pitcher throws ball to first base)
L(e8) = 5 (runner arrives at home)
L(e9) = 6 (ball arrives at first base)
L(e10) = 7 (batter arrives at first base)

向量时钟

image.png

Vector: [p,f,h,t]

我：
例如：e4->e10:e4现在是[1,0,3,0]，e10所处在的进程是第一垒，当前进程的时钟值是e9[3,1,2,0]，比较向量中每项取最新的版本号，即[3,1,3,0]，最终当前进程所处在的项+1 =>e10[3,2,3,0]

参考

一致性算法之四: 时间戳和向量图
[图片上传中...(image.png-29d27a-1517278430738-0)]