Models and Clocks

1
Models and Clocks
2
Characteristics of a Distributed System

• Absence of a shared clock
• Absence of shared memory
• Absence of failure detection

3
Model of a Distributed System

• Asynchronous
• Message Passing

4
A Simple Distributed Program

• Each process is defined as a set of states

5
Model of a Distributed Computation

• Interleaving model
• A global sequence of events
• eg.
• P1 sends what is my checking balance to P2
• P1 sends what is my savings balance to P2
• P2 receives what is my checking balance from P1
• P1 sets total to 0
• P2 receives what is my savings balance from P1
• P2 sends checking balance 40 to P1
• P1 receives checking balance 40 from P2 . . .

6
Model of a Distributed Computation

• Happened before model
• Happened before relation
• If e occurred before f in the same process, then
• e --gt f
• If e is the send event of a message and f is the
  receive event of the same message, then e --gt f
• If there exists an event g such that e --gt g and
  g --gt f, then e --gt f

7
A run in the happened-before model
8
Logical Clocks

• A logical clock C is a map from the set of events
  E to N (the set of natural numbers) with the
  following constraint

9
Lamport's logical clock algorithm
public class LamportClock int c public
LamportClock() c 1 public
int getValue() return c
public void tick() // on internal actions
c c 1 public void sendAction()
// include c in message c c
1 public void receiveAction(int src,
int sentValue) c Util.max(c,
sentValue) 1
10
Vector Clocks

• Map from the set of states to vectors of natural
  numbers with the constraint
• For all s, t s--gt t iff s.v lt t.v ......
  where s.v is the vector assigned to the state s.
• Given vectors x,y x lt y
• All elements of x are less than or equal to the
  corresponding elements of y
• At least one element of x is strictly less than
  the corresponding element of y

11
A Vector clock algorithm
public class VectorClock public int v
int myId int N public VectorClock(int
numProc, int id) myId id N
numProc v new intnumProc
for (int i 0 i lt N i) vi 0
vmyId 1 public void tick()
vmyId public void sendAction()
//include the vector in the message
vmyId public void
receiveAction(int sentValue) for (int
i 0 i lt N i) vi
Util.max(vi, sentValuei)
vmyId
12
An execution of the vector clock algorithm
13
Direct-Dependency Clocks

• Weaker version of the vector clock
• Maintain a vector clock locally
• Process sends only its local component of the
  clock
• Directly precedes relation only one message in
  the happened-before diagram of the computation
• Direct-dependency clocks satisfy

14
A Direct-dependency clock algorithm
public class DirectClock public int
clock int myId public DirectClock(int
numProc, int id) myId id
clock new intnumProc for (int i 0
i lt numProc i) clocki 0
clockmyId 1 public int
getValue(int i) return clocki
public void tick() clockmyId
public void sendAction() //
sentValue clockmyId tick()
public void receiveAction(int sender, int
sentValue) clocksender
Util.max(clocksender, sentValue)
clockmyId Util.max(clockmyId, sentValue)
1
15
Matrix Clocks

• N x N matrix
• Gives processes additional knowledge

16
The matrix clock algorithm
public class MatrixClock int M int
myId int N public MatrixClock(int
numProc, int id) myId id N
numProc M new intNN for
(int i 0 i lt N i) for (int j
0 j lt N j) Mij 0
MmyIdmyId 1 public void tick()
MmyIdmyId public void
sendAction() //include the matrix in
the message MmyIdmyId
public void receiveAction(int W, int srcId)
// component-wise maximum of matrices
for (int i 0 i lt N i) if
(i ! myId) for (int j 0 j lt
N j) Mij
Util.max(Mij, Wij)