Jard–Jourdan’s adaptive technique

The Fowler–Zwaenepoel direct-dependency technique does not allow the transitive dependencies to be captured in real time during the execution of processes. In addition, a process must observe an event (i.e., update and record its dependency vector) after receiving a message but before sending out any message. Otherwise, during the reconstruction of a vector timestamp from the direct-dependency vectors, all the causal dependencies will not be captured. If events occur very frequently, this technique will require recording the history of a large number of events.

In the Jard–Jourdan’s technique [8], events can be adaptively observed while maintaining the capability of retrieving all the causal dependencies of an observed event. (Observing an event means recording of the information about its dependencies.) This method uses the idea that when an observed eventerecords its dependencies, then events that follow can determine their transitive dependencies, that is, the set of events that they indirectly depend on, by making use of the information recorded about e. The reason is that when an event eis observed, the information about the send and receive of messages maintained by a process is recorded in that event and the information maintained by the process is then reset and updated. So, when the process

propagates information after e, it propagates only history of activities that took place aftere. The next observed event either in the same process or in a different one, would then have to look at the information recorded for e to know about the activities that happened before e. This method still does not allow determining all the causal dependencies in real time, but avoids the problem of recording a large amount of history which is realized when using the direct dependency technique.

To implement the technique of recording the information in an observed event and resetting the information managed by a process, Jard–Jourdan defined apseudo-directrelationon the events of a distributed computation as follows:

If eventse_iande_jhappen at processp_iandp_j, respectively, thene_je_iiff there exists a path of message transfers that starts aftere_j on the processp_j and ends beforee_i on the processe_isuch that there is no observed event on the path. The relation is termed pseudo-direct because event e_i may depend upon many unobserved events on the path, sayue₁,ue₂, ,ue_n, etc., which are in turn dependent on each other. If e_i happens after ue_n, then e_i is still considered to be directly dependent uponue₁,ue₂, ,ue_n, since these events are unobserved, which is a falsely assumed to have direct dependency. If another event e_k happens aftere_i, then the transitive dependencies ofe_k on ue₁,ue₂, ,ue_n can be determined by using the information recorded ate_i ande_ican do the same withe_j.

The technique is implemented using the following mechanism: the partial vector clockp_vt_iat processp_iis a list of tuples of the form (j,v) indicating that the current state of p_i is pseudo-dependent on the event on process p_j whose sequence number is v. Initially, at a processp_i:p_vt_i={(i, 0)}.

Letp_vt_i= i₁ v₁ i v i_n v_ndenote the current partial vec-tor clock at processp_i. Lete_vt_ibe a variable that holds the timestamp of the observed event.

(i) Whenever an event is observed at processp_i, the contents of the partial vector clockp_vt_iare transferred toe_vt_iandp_vt_iis reset and updated as follows:

e_vt_i= i₁ v₁ i v i_n v_n p_vt_i= i v+1

(ii) When processp_j sends a message top_i, it piggybacks the current value ofp_vt_j in the message.

(iii) When p_i receives a message piggybacked with timestamp p_vt, p_i updates p_vt_i such that it is the union of the following (let p_vt={(i_m1 v_m1), ,(i_mk v_mk)} andp_vt_i= i₁ v₁ i_l v_l):

• all (i_mx v_mx) such that (i_mx ) does not appear inv_pt_i;

• all (i_x v_x) such that (i_x ) does not appear inv_pt;

• all (i_x,max(v_x v_mx)) for all (v_x ) that appear inv_ptandv_pt_i.

67 3.6 Jard–Jourdan’s adaptive technique

In Figure3.6,eX_pt_ndenotes the timestamp of the Xth observed event at processp_n. For instance, the event 1 observed atp₄is timestampede1_pt₄= 40 51; this timestamp means that the pseudo-direct predecessors of this event are located at processp₄ andp₅, and are respectively the event 0 observed atp₄and event 1 observed atp₅.v_pt_n denotes a list of timestamps collected by a processp_n for the unobserved events and is reset and updated after an event is observed atp_n. For instance, let us considerv_pt₃. Process p₃first collects the timestamp of event zero 30into v_pt₃ and when the observed event 1 occurs, it transfers its content toe1_pt₃, resets its list and updates its value to 31 which is the timestamp of the observed event.

When it receives a message from processp₂, it includes those elements that are not already present in its list, namely,10and20tov_pt₃. Again, when event 2 is observed, it resets its list to 32and transfers its content toe2_pt₃ which holds 10 20 31. It can be seen that event 2 at processp₃ is directly dependent upon event 0 on processp₂ and event 1 on processp₃. But, it is pseudo-directly dependent upon event 0 at processp₁. It also depends on event 0 at processp₃ but this dependency information is obtained by examininge1_pt₃recorded by the observed event. Thus, transitive dependencies of event 2 at process p₃ can be computed by examining the observed events in e2_pt₃. If this is done recursively, then all the causal

dependencies of an observed event can be retrieved. It is also pertinent to observe here that these transitive dependencies cannot be determined online but from a log of the events.

This method can help ensure that the list piggybacked on a message is of optimal size. It is also possible to limit the size of the list by introducing a dummy observed event. If the size of the list is to be limited tok, then when timestamps of kevents have been collected in the list, a dummy observed event can be introduced to receive the contents of the list. This allows a lot of flexibility in managing the size of messages.