1. Lamport's Scalar clocks and Singhal-Kshemkalyani’s VC Algorithms
Implementation of
Lamport's Scalar clocks and Singhal-Kshemkalyani’s VC Algorithms
Kent State University
Computer Science Department
Saleh Alnaeli
Advanced Operating System. Spring 2010

2. Goals Implementing both of the algorithms
study their behavior under some different arguments
Processes Number
Messages Number
Involved processes Number in the computation
Note: This presentation assumes that you have a back ground about Logical Clocks and some of its related algorithms (Scalar, Vector, S-K).

3. Lamport's Scalar clocks
was proposed by Lamport 1978
to totally order events in distributed system
each process Pi has a logical clock Ci (represented as integer value)
consistency condition
consistency: if ab, then C(a)  C(b)
if event a happens before event b, then the clock value (timestamp) of a should be less than the clock value of b
strong consistency: consistency and
if C(a)C(b) then ab
scalar clocks are not strongly consistent:
if ab, then C(a) < C(b) but
C(a) < C(b), then not necessarily ab

4. Implementation of Scalar Clocks
Rule1: before executing event update Ci so, Ci := Ci + d (d>0)
Rule2: attach timestamp of the send event to the transmitted message when received, timestamp of receive event is computed as follows: Ci := max(Ci , Cmsg) and then execute R1
It is implemented in C++ and was verified in different ways:
Checking its consistency using a function compares the new value of previous one locally and with the sender in receive event
Results were compared with vector clock application

5. Generating the computations
Computations were entered from input text file
Generated manually and using a computation generator developed in C++ randomly (random sender and receiver)
Each event is constructed according the following scheme:
EventType,SenderID,ReceiverID such that:
EventType is 1 for internal event, 2 for send event and 3 for receive event.
Example:3,7,8 means an event to receive a SMS was sent by Pcocess 7 to 8 // Also
order of the events can be changed in the InputFile just make sure the receive event is preceeded by send event
SMS not found or lost for receive without send event.
Sending to process it self is an internal event. Example 2,5,5

6. Singhal-Kshemkalyani’s Algorithm for vector clock S-K
Considered as an efficient implementation of vector clocks.
instead of sending the whole vector only need to send elements that changed. And same update rules are used for the recipient process.
maintain two vectors :
LS[1..n] – “last sent”
LU[1..n]
needs to send with the message only the elements that meet the condition: {(x,vti[x])| LSi[j] < LUi[x]}
The sent vector contains the processes’ Id’s and Clock values of changed processes.

7. S-K Implementation Computations were entered from input text file
It is implemented in C++ and was verified in different ways:
Results were compared with others generated by a combined Scalar and vector clock application.
Known examples and random computations were used.
Computations were entered from input text file
Computations were generated using a computation generator developed in C++.

8. Events construction scheme
similar to scalar events format with extra field:
EventType,SenderID,ReceiverID,EventId such that:
EventType is 1 for internal event, 2 for send event and 3 for receive event.
EventId is number of the event when the message has been sent
Example:3,7,8,4 means an event to receive a SMS was sent by Process 7 to 8 and the event was the fourth send event
order of the events can be changed in the InputFile just make sure the receive event is preceeded by send event
SMS not found or lost for receive without send event.
Sending to process it self is an internal event. Example 2,5,5,4

9. Performance Evaluation
Lamport’s Scalar Clock algorithm:
There were not enough area to study (trivial)
S-K algorithms
Performance metrics evaluated include
Stamps Memory size used in units (1 unit=32 bytes)
Conditions of varying
Processes Number, messages Number, and number of the involved processes in the computation.
It’s expected that SK in the worst case will perform as VC

10. S-K: Simulation Parameters
Default Values
Processes numbers
// constant 50
Simulation Cycles 15
Messages Number
Involved processes in computation
100%-50% // 100%-20% (10-50 of 50)
Events sequence 1
All Send to all and all receive (50 lost)
Event sequence 2
Randomly send and direct receive
Expectations: In the worst case of S-K will be Vector clock’s work.

11. # processes vs. #messages
events by sequence1 with 2500 messages and 50 lost
figure1 shows that S-K out performance regular VC even with changing the No of processes and involved processes as well
Not Sufficient and not satisfied

12. #Messages vs. #involved processes
Events were generated randomly with sequence 2 (randomly picking sender and receiver)
After sending, message is directly received to got more updates in locals V.
Constant # of processes 50
Changing # of involved processes (10-50)

13. Figure2 shows surprising results

14. Table1 and table2 S-K and VC respectively
Messages Number
 table1
500
1000
1500
2000
2500 10
5318
10804
15264
21152
27020 20
12412
25966
39054
54974
66504 30
17026
40906
64556
85070
110548 40
22698
56564
88224
119018
152488 50
24202
65326
105732
153888
189428
# involved processes
Used memory in units
Table2 
500
1000
1500
2000
2500 10
25000
50000
75000
100000
125000 20 30 40 50

15. Verifying S-K efficiency equation
S-K original paper states that their technique can be beneficial if n<N.b/(log2N+b)
Such that: n=avr of entries in Ti, b=bits in a sequence number, log2N=bits needed to code N process ids.
It doesn’t work with my simulation !!!
I have calculated n value in (2500,40 and ,30 ) and I compared it with their equation but did not work!!!
Mine is :
When of involved processes gets close to 70% and #of messages gets close to 20N, then S-K becomes inefficient.

16. Conclusion
The sequence of the events plays big role in determining the efficiency of S-K
Number of the involved processes in the computation can affect S-K performance
For low # of messages, S-K seems fine.
When # of involved processes is about 70% and #of messages close to 20N then S-K becomes a weak.
Efficiency equation is not applicable in my experiment .

17. Difficulties
The most difficult issue was generating a computation that can be used for adequate results.
It’s Difficult to predict the order of receiving the messages which make it difficult to generate a computation close to reality.

18. References Original S-K paper Logical clock, Adv OS course slides.
Prof. Mikhail Nesterenko (Acknowledge)
S-k implementation-Manas Hardas. KSU. (Acknowledge)