Models and Clocks

Document Sample

```					Models and Clocks
Characteristics of a Distributed
System

 Absence of a shared clock
 Absence of shared memory

 Absence of failure detection
Model of a Distributed System

 Asynchronous
 Message Passing
A Simple Distributed Program

   Each process is defined as a set of
states
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 . . .
Model of a Distributed
Computation
   Happened before model
• Happened before relation
• If e occurred before f in the same process, then
e --> f
• If e is the send event of a message and f is the
receive event of the same message, then e --> f
• If there exists an event g such that e --> g and g -->
f, then e --> f
A run in the happened-before
model
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:
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;
}
}
Vector Clocks

   Map from the set of states to vectors of
natural numbers with the constraint:
• For all s, t: s--> t
iff s.v < t.v ...... where s.v is
the vector assigned to the state s.
   Given vectors x,y : x < 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
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 int[numProc];
for (int i = 0; i < N; i++) v[i] = 0;
v[myId] = 1;
}
public void tick() {
v[myId]++;
}
public void sendAction() {
//include the vector in the message
v[myId]++;
}
for (int i = 0; i < N; i++)
v[i] = Util.max(v[i], sentValue[i]);
v[myId]++;
}   }
An execution of the vector clock
algorithm
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
A Direct-dependency clock algorithm
public class DirectClock {
public int[] clock;
int myId;
public DirectClock(int numProc, int id) {
myId = id;
clock = new int[numProc];
for (int i = 0; i < numProc; i++) clock[i] = 0;
clock[myId] = 1;
}
public int getValue(int i) {
return clock[i];
}
public void tick() {
clock[myId]++;
}
public void sendAction() {
// sentValue = clock[myId];
tick();
}
public void receiveAction(int sender, int sentValue) {
clock[sender] = Util.max(clock[sender], sentValue);
clock[myId] = Util.max(clock[myId], sentValue) + 1;
}
}
Matrix Clocks
   N x N matrix
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 int[N][N];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
M[i][j] = 0;
M[myId][myId] = 1;
}
public void tick() {
M[myId][myId]++;
}
public void sendAction() {
//include the matrix in the message
M[myId][myId]++;
}
public void receiveAction(int[][] W, int srcId) {
// component-wise maximum of matrices
for (int i = 0; i < N; i++)
if (i != myId) {
for (int j = 0; j < N; j++)
M[i][j] = Util.max(M[i][j], W[i][j]);
}
}     }

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 2 posted: 8/31/2012 language: English pages: 16
How are you planning on using Docstoc?