1. Algorithm

The algorithm follows some simple rules:

1. A process increments its counter before each event in that process;
2. When a process sends a message, it includes its counter value with the message;
3. On receiving a message, the counter of the recipient is updated, if necessary, to the greater of its current counter and the timestamp in the received message. The counter is then incremented by 1 before the message is considered received.^[1]

In pseudocode, the algorithm for sending is:

# event is known time = time + 1; # event happens send(message, time); 

The algorithm for receiving a message is:

(message, time_stamp) = receive(); time = max(time_stamp, time) + 1; 

2. Considerations

For every two different events [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math] occurring in the same process, and [math]\displaystyle{ C(x) }[/math] being the timestamp for a certain event [math]\displaystyle{ x }[/math], it is necessary that [math]\displaystyle{ C(a) }[/math] never equals [math]\displaystyle{ C(b) }[/math].

Therefore it is necessary that:

• The logical clock be set so that there is a minimum of one clock "tick" (increment of the counter) between events [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math];
• In a multi-process or multi-threaded environment, it might be necessary to attach the process ID (PID) or any other unique ID to the timestamp so that it is possible to differentiate between events [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math] which may occur simultaneously in different processes.

3. Causal Ordering

For any two events, [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math], if there’s any way that [math]\displaystyle{ a }[/math] could have influenced [math]\displaystyle{ b }[/math], then the Lamport timestamp of [math]\displaystyle{ a }[/math] will be less than the Lamport timestamp of [math]\displaystyle{ b }[/math]. It’s also possible to have two events where we can’t say which came first; when that happens, it means that they couldn’t have affected each other. If [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math] can’t have any effect on each other, then it doesn’t matter which one came first.

4. Implications

A Lamport clock may be used to create a partial causal ordering of events between processes. Given a logical clock following these rules, the following relation is true: if [math]\displaystyle{ a \rightarrow b }[/math] then [math]\displaystyle{ C(a) \lt C(b) }[/math], where [math]\displaystyle{ \rightarrow\, }[/math] means happened-before.

This relation only goes one way, and is called the clock consistency condition: if one event comes before another, then that event's logical clock comes before the other's. The strong clock consistency condition, which is two way (if [math]\displaystyle{ C(a) \lt C(b) }[/math] then [math]\displaystyle{ a \rightarrow b }[/math]), can be obtained by other techniques such as vector clocks. Using only a simple Lamport clock, only a partial causal ordering can be inferred from the clock.

However, via the contrapositive, it's true that [math]\displaystyle{ C(a) \nless C(b) }[/math] implies [math]\displaystyle{ a \nrightarrow b }[/math]. So, for example, if [math]\displaystyle{ C(a) \geq C(b) }[/math] then [math]\displaystyle{ a }[/math] cannot have happened-before [math]\displaystyle{ b }[/math].

Another way of putting this is that [math]\displaystyle{ C(a) \lt C(b) }[/math] means that [math]\displaystyle{ a }[/math] may have happened-before [math]\displaystyle{ b }[/math], or be incomparable with [math]\displaystyle{ b }[/math] in the happened-before ordering, but [math]\displaystyle{ a }[/math] did not happen after [math]\displaystyle{ b }[/math].

Nevertheless, Lamport timestamps can be used to create a total ordering of events in a distributed system by using some arbitrary mechanism to break ties (e.g., the ID of the process). The caveat is that this ordering is artifactual and cannot be depended on to imply a causal relationship.

5. Lamport's Logical Clock in Distributed Systems

In a distributed system, it is not possible in practice to synchronize time across entities (typically thought of as processes) within the system; hence, the entities can use the concept of a logical clock based on the events through which they communicate.

If two entities do not exchange any messages, then they probably do not need to share a common clock; events occurring on those entities are termed as concurrent events.

Among the processes on the same local machine we can order the events based on the local clock of the system.

When two entities communicate by message passing, then the send event is said to happen-before the receive event, and the logical order can be established among the events.

A distributed system is said to have partial order if we can have a partial order relationship among the events in the system. If 'totality', i.e., causal relationship among all events in the system, can be established, then the system is said to have total order.

A single entity cannot have two events occur simultaneously. If the system has total order we can determine the order among all events in the system. If the system has partial order between processes, which is the type of order Lamport's logical clock provides, then we can only tell the ordering between entities that interact. Lamport addressed ordering two events with the same timestamp (or counter): "To break ties, we use any arbitrary total ordering [math]\displaystyle{ \lt }[/math] of the processes."^[1] Thus two timestamps or counters may be the same within a distributed system, but in applying the logical clocks algorithm events that occur will always maintain at least a strict partial ordering.

Lamport clocks lead to a situation where all events in a distributed system are totally ordered. That is, if [math]\displaystyle{ a \rightarrow b }[/math], then we can say [math]\displaystyle{ a }[/math] actually happened before [math]\displaystyle{ b }[/math].

Note that with Lamport’s clocks, nothing can be said about the actual time of [math]\displaystyle{ a }[/math] and [math]\displaystyle{ b }[/math]. If the logical clock says [math]\displaystyle{ a \rightarrow b }[/math], that does not mean in reality that [math]\displaystyle{ a }[/math] actually happened before [math]\displaystyle{ b }[/math] in terms of real time.

Lamport clocks show non-causality, but do not capture all causality. Knowing [math]\displaystyle{ a \rightarrow c }[/math] and [math]\displaystyle{ b \rightarrow c }[/math] shows [math]\displaystyle{ c }[/math] did not cause [math]\displaystyle{ a }[/math] or [math]\displaystyle{ b }[/math] but we cannot say which initiated [math]\displaystyle{ c }[/math].

This kind of information can be important when trying to replay events in a distributed system (such as when trying to recover after a crash). If one node goes down, and we know the causal relationships between messages, then we can replay those messages and respect the causal relationship to get that node back up to the state it needs to be in.^[2]

The content is sourced from: https://handwiki.org/wiki/Lamport_timestamps