International Journal of Electrical Engineering and Technology (IJEET)

Volume 12, Issue 11, November 2021, pp. 131-141, Article ID: IJEET_12_11_012
Available online at https://iaeme.com/Home/issue/IJEET?Volume=12&Issue=11
ISSN Print: 0976-6545 and ISSN Online: 0976-6553
DOI: https://doi.org/10.17605/OSF.IO/BPM3U

© IAEME Publication Scopus Indexed

DEALING WITH FREQUENT TERMINATES IN

SYNCHRONIZED DEPENDENCY RECOVERY
LINE COMPILATION ALGORITHM FOR
MOBILE DISTRIBUTED SYSTEMS
Suresh Kumar1, Rajeev Yadav2
1
Research Scholar, Sunrise University Alwar, India
2
Professor, CSE, Sunrise University Alwar, India

ABSTRACT
While dealing with mobile distributed frameworks, we come across some issues like:
mobility, low bandwidth of wireless channels and lack of stable storage on mobile
nodes, disconnections, limited battery power and high failure rate of mobile nodes. In
this paper, we design a minimum operation methodology for Mobile Distributed
frameworks, where no useless retrieval-marks are taken and an effort has been made to
optimize the filibustering of operations. In order to keep the filibustering time minimum,
we collect the dependency vectors and compute the exact minimum set in the beginning
of the methodology. In synchronized Dependable Recovery Line Compilation (DRL-
compilation), if a single operation fails to take its retrieval-mark; all the DRL-
compilation effort goes waste, because, each operation has to terminate its partially-
committed retrieval-mark. In order to take its partially-committed retrieval-mark, an
Mob_Node (Mobile Host) needs to transfer large retrieval-mark data to its local
Mob_Supp_Stn over wireless channels. The DRL-compilation effort may be exceedingly
high due to frequent terminates especially in mobile frameworks. We try to minimize the
loss of DRL-compilation effort when any operation fails to take its retrieval-mark in
coordination with others
Key words: Fault tolerance, dependable global state, synchronized DRL-compilation
and mobile frameworks.
Cite this Article: Suresh Kumar and Rajeev Yadav, Dealing with Frequent Terminates
in Synchronized Dependency Recovery Line Compilation Algorithm for Mobile
Distributed Systems, International Journal of Electrical Engineering and Technology
(IJEET). 12(11), 2021, pp. 131-141.
https://iaeme.com/Home/issue/IJEET?Volume=12&Issue=11

https://iaeme.com/Home/journal/IJEET 131 editor@iaeme.com

 Dealing with Frequent Terminates in Synchronized Dependency Recovery Line Compilation
Algorithm for Mobile Distributed Systems

1. INTRODUCTION
A distributed framework is one that runs on a collection of machines that do not have shared
memory, yet looks to its users like a single computer. The term Distributed Systems is used to
describe a framework with the following characteristics: i) it consists of several computers that
do not share memory or a clock, ii) the computers communicate with each other by exchanging
reckoning-communications over a communication network, iii) each computer has its own
memory and runs its own operating framework. A distributed framework consists of a finite set
of operations and a finite set of channels.
In the mobile distributed framework, some of the operations are running on mobile hosts
(Mob_Nodes). A Mob_Node communicates with other nodes of the framework via a special
node called mobile support station (Mob_Supp_Stn) [1]. A cell is a geographical area around
an Mob_Supp_Stn in which it can support an Mob_Node. A Mob_Node can change its
geographical position freely from one cell to another or even to an area covered by no cell. An
Mob_Supp_Stn can have both wired and wireless links and acts as an interface between the
static network and a part of the mobile network. Static network connects all Mob_Supp_Stns.
A static node that has no support to Mob_Node can be considered as an Mob_Supp_Stn with
no Mob_Node.
Checkpoint is defined as a designated place in a program at which normal operation is
interrupted specifically to preserve the status information necessary to allow resumption of
handling at a later time. DRL-compilation is the operation of saving the status information. By
periodically invoking the DRL-compilation operation, one can save the status of a program at
regular intervals. If there is a failure one may restart computation from the last retrieval-marks
thereby avoiding repeating computation from the beginning. The operation of resuming
computation by rolling back to a saved state is called rollback recovery. The retrieval-mark-
restart is one of the well-known methods to realize reliable distributed frameworks. Each
operation takes a retrieval-mark where the local state information is stored in the stable storage.
Rolling back an operation and again resuming its execution from a prior state involves overhead
and delays the overall completion of the operation, it is needed to make an operation rollback
to a most recent possible state. So it is at the desire of the user for taking many retrieval-marks
over the whole life of the execution of the operation [6, 27].
In a distributed framework, since the operations in the framework do not share memory, a
global state of the framework is defined as a set of local states, one from each operation. The
state of channels corresponding to a global state is the set of reckoning-communications sent
but not yet received. A global state is said to be “dependable” if it contains no orphan reckoning-
communication; i.e., a reckoning-communication whose receive event is recorded, but its
forward event is lost. To recover from a failure, the framework restarts its execution from a
previous dependable global state saved on the stable storage during fault-free execution. This
saves all the computation done up to the last retrieval-marked state and only the computation
done thereafter needs to be redone. In distributed frameworks, DRL-compilation can be
independent, synchronized [6, 11, 13] or quasi-synchronous [2]. Message Logging is also used
for fault tolerance in distributed frameworks [22, 28].
In synchronized or synchronous DRL-compilation, operations take retrieval-marks in such
a manner that the resulting global state is dependable. Mostly it follows two-phase commit
structure [6, 11, 23]. In the first phase, operations take partially-committed retrieval-marks and
in the second phase, these are made enduring. The main advantage is that only one enduring
retrieval-mark and at most one partially-committed retrieval-mark is required to be stored. In
the case of a fault, operations rollback to last retrieval-marked state.

https://iaeme.com/Home/journal/IJEET 132 editor@iaeme.com

 Suresh Kumar and Rajeev Yadav

The synchronized DRL-compilation protocols can be classified into two types: filibustering
and non-filibustering . In filibustering methodologies, some filibustering of operations takes
place during DRL-compilation [4, 11, 24, 25, 29] In non-filibustering methodologies, no
filibustering of operations is required for DRL-compilation [5, 12, 15, 21]. The synchronized
DRL-compilation methodologies can also be classified into following two categories:
minimum-operation and all operation methodologies. In all-operation synchronized DRL-
compilation methodologies, every operation is required to take its retrieval-mark in a
commencement [6], [8]. In minimum-operation methodologies, minimum interacting
operations are required to take their retrieval-marks in a commencement [11].
In minimum-operation synchronized DRL-compilation methodologies, an operation Pi
takes its retrieval-mark only if it a member of the minimum set (a subset of interacting
operation). A operation Pi is in the minimum set only if the retrieval-mark originator operation
is transitively dependent upon it. Pj is directly dependent upon Pk only if there exists m such
that Pj accepts m from Pk in the current DRL-compilation interval [CI] and Pk has not taken its
enduring retrieval-mark after forwarding m. The ith CI of an operation denotes all the
computation performed between its ith and (i+1)th retrieval-mark, including the ith retrieval-mark
but not the (i+1)th retrieval-mark.
In minimum-operation DRL-compilation protocols, some useless retrieval-marks are taken
or filibustering of operations takes place. In this paper, we propose a minimum-operation
synchronized DRL-compilation methodology for non-deterministic mobile distributed
frameworks, where no useless retrieval-marks are taken. An effort has been made to minimize
the filibustering of operations and the loss of DRL-compilation effort when any operation fails
to take its retrieval-mark in coordination with others.

2. BASIC IDEA
The proposed scheme is based on keeping track of direct dependencies of operations. Similar
to [4], originator operation collects the direct dependency vectors of all operations, computes
minimum set, and forwards the retrieval-mark request along with the minimum set to all
operations. In this way, filibustering time has been significantly reduced as compared to [11].
During the period, when an operation forwards its dependency set to the originator and
accepts the minimum set, may receive some reckoning-communications, which may add new
members to the already computed minimum set [25]. In order to keep the computed minimum
set intact, we have classified the reckoning-communications, received during the filibustering
period, into two types: (i) reckoning-communications that alter the dependency set of the
receiver operation (ii) reckoning-communications that do not alter the dependency set of the
receiver operation. The reckoning-communications in point (i) need to be delayed at the
receiver side [25]. The reckoning-communications in point (ii) can be operationed normally.
All operations can perform their normal computations and forward reckoning-communications
during their filibustering period. When an operation buffers a reckoning-communication of
former type, it does not operation any reckoning-communication till it accepts the minimum set
so as to keep the proper sequence of reckoning-communications received. When an operation
gets the minimum set, it takes the retrieval-mark, if it is in the minimum set. After this, it accepts
the buffered reckoning-communications, if any. The proposed minimum-operation filibustering
methodology forces zero useless retrieval-marks at the cost of very small filibustering.
In minimum-operation synchronous DRL-compilation, the originator operation asks all
communicating operations to take partially-committed retrieval-marks. In this scheme, if a
single operation fails to take its retrieval-mark; all the DRL-compilation effort goes waste,
because, each operation has to terminate its partially-committed retrieval-mark. In order to take
the partially-committed retrieval-mark, an Mob_Node needs to transfer large retrieval-mark

https://iaeme.com/Home/journal/IJEET 133 editor@iaeme.com

 Dealing with Frequent Terminates in Synchronized Dependency Recovery Line Compilation
Algorithm for Mobile Distributed Systems

data to its local Mob_Supp_Stn over wireless channels. Due to frequent terminates, total DRL-
compilation effort may be exceedingly high, which may be undesirable in mobile frameworks
due to scarce resources. Frequent terminates may happen in mobile frameworks due to
exhausted battery, abrupt disconnection, or bad wireless connectivity. Therefore, we propose
that in the first phase, all concerned Mob_Nodes will take transient retrieval-mark only.
Mutable retrieval-mark is stored on the memory of Mob_Node only. In this case, if some
operation fails to take retrieval-mark in the first phase, then Mob_Nodes need to terminate their
transient retrieval-marks only. The effort of taking a transient retrieval-mark is negligible as
compared to the partially-committed one. When the originator comes to know that all relevant
operations have taken their transient retrieval-marks, it asks all relevant operations to come into
the second phase, in which, an operation converts its transient retrieval-mark into partially-
committed one. In this way, by increasing small synchronization reckoning-communication
overhead, we try to reduce the total DRL-compilation effort.
Our framework model is similar to [5, 24, 25]. There are n spatially separated sequential
operations P0, P1,.., Pn-1, running on Mob_Nodes or Mob_Supp_Stns, constituting a mobile
distributed computing framework. Each Mob_Node/Mob_Supp_Stn has one operation running
on it. The operations do not share memory or clock. Message passing is the only way for
operations to communicate with each other. Each operation progresses at its own speed and
reckoning-communications are exchanged through reliable channels, whose transmission
delays are finite but arbitrary. A Mob_Node forwards and accepts application reckoning-
communications that do not contain any additional information; it is only responsible for DRL-
compilation its local state appropriately and transferring it to the local Mob_Supp_Stn.

3. THE PROPOSED DRL-COMPILATION ALGORITHM

3.1. The Minimum-Operation Coordinated DRL-Compilation Scheme
The originator Mob_Supp_Stn forwards a request to all Mob_Supp_Stns to forward the cdd-set
vectors of the operations in their cells. All cdd-set vectors are at Mob_Supp_Stns and thus no
initial DRL-compilation reckoning-communications or responses travels wireless channels. On
receiving the cdd-set [] request, an Mob_Supp_Stn records the identity of the originator
operation (say mss_ida) and originator Mob_Supp_Stn, forwards back the cdd-set [] of the
operations in its cell, and sets g_chkpt. If the originator Mob_Supp_Stn accepts a request for
cdd-set [] from some other Mob_Supp_Stn (say mss_idb) and mss_ida is lower than mss_idb,the,
current commencement with mss_ida is discarded and the new one having mss_idb is continued.
Similarly, if an Mob_Supp_Stn accepts cdd-set requests from two Mob_Supp_Stns, then it
discards the request of the originator Mob_Supp_Stn with lower mss_id. Otherwise, on
receiving cdd-set vectors of all operations, the originator Mob_Supp_Stn computes min_vectr
[], forwards transient retrieval-mark request along with the min_vectr [] to all Mob_Supp_Stns.
When an operation forwards its cdd-set [] to the originator Mob_Supp_Stn, it comes into its
filibustering state. A operation comes out of the filibustering state only after taking its transient
retrieval-mark if it is a member of the minimum set; otherwise, it comes out of filibustering
state after getting the transient retrieval-mark request.
On receiving the transient retrieval-mark request along with the min_vectr [], an
Mob_Supp_Stn, say Mob_Supp_Stnj, takes the following actions. It forwards the transient
retrieval-mark request to Pi only if Pi belongs to the min_vectr [] and Pi is running in its cell. On
receiving the retrieval-mark request, Pi takes its transient retrieval-mark and informs
Mob_Supp_Stnj. On receiving positive response from Pi, Mob_Supp_Stnj updates p-c_s_ni,
resets filibustering i, and forwards the buffered reckoning-communications to Pi, if any.
Alternatively, If Pi is not in the min_vectr [] and Pi is in the cell of Mob_Supp_Stnj,

https://iaeme.com/Home/journal/IJEET 134 editor@iaeme.com

 Suresh Kumar and Rajeev Yadav

Mob_Supp_Stnj resets filibustering i and forwards the buffered reckoning-communication to Pi,

if any. For a disconnected Mob_Node, that is a member of min_vectr [], the Mob_Supp_Stn
that has its disconnected retrieval-mark, converts its disconnected retrieval-mark into the
required one.
During filibustering period, Pi operations m, received from Pj, if following conditions are
met: (i) (!buferi) i.e. Pi has not buffered any reckoning-communication (ii) (m.psn <=c_s_n[j])
i.e. Pj has not taken its retrieval-mark before forwarding m (iii) (cdd-seti[j]=1) Pi is already
dependent upon Pj in the current CI or Pj has taken some enduring retrieval-mark after
forwarding m.
Otherwise, the local Mob_Supp_Stn of Pi buffers m for the filibustering period of Pi and
sets bufferi.
When an Mob_Supp_Stn learns that all of its operations in minimum set have taken their
transient retrieval-marks or at least one of its operation has failed to retrieval-mark, it forwards
the response reckoning-communication to the originator Mob_Supp_Stn. In this case, if some
operation fails to take transient retrieval-mark in the first phase, then Mob_Nodes need to
terminate their transient retrieval-marks only. The effort of taking a transient retrieval-mark is
negligible as compared to the partially-committed one. When the originator comes to know that
all relevant operations have taken their transient retrieval-marks, it asks all relevant operations
to come into the second phase, in which, an operation converts its transient retrieval-mark into
partially-committed one.
Finally, originator Mob_Supp_Stn forwards commit or terminate to all operations. On
receiving terminate, an operation discards its partially-committed retrieval-mark, if any, and
undoes the updating of data structures. On receiving commit, operations, in the min_vectr [],
convert their partially-committed retrieval-marks into enduring ones. On receiving commit or
terminate, all operations update their cdd-set vectors and other data structures.

3.2. An Example
We explain the proposed minimum-operation DRL-compilation methodology with the help of
an example. In Figure 1, at time t1, P4 initiates DRL-compilation operation and forwards request
to all operations for their dependency vectors. At time t2, P4 accepts the dependency vectors
from all operations (not shown in the Figure 1) and computes the minimum set (min_vectr[])
which is {P3, P4, P5}. P4 forwards min_vectr[]to all operations and takes its own transient
retrieval-mark. A operation takes its transient retrieval-mark if it is a member of min_vectr[].
When P3 and P5 get the min_vectr[], they find themselves in the min_vectr[]; therefore, they
take their transient retrieval-marks. When P0, P1 and P2 get the min_vectr [], they find that they
do not belong to min_vectr [], therefore, they do not take their transient retrieval-marks.
A operation comes into the filibustering state immediately after forwarding the cdd-set[].
A operation comes out of the filibustering state only after taking its transient retrieval-mark if
it is a member of the minimum set; otherwise, it comes out of filibustering state after getting
the transient retrieval-mark request. P4 accepts m4 during its filibustering period. As cdd-
set4[5]=1 due to m3, and receive of m4 will not alter cdd-set4[]; therefore P4 operations m4. P1
accepts m5 from P2 during its filibustering period; cdd-set1[2]=0 and the receive of m5 can alter
cdd-set1[]; therefore, P1 buffers m5. Similarly, P3 buffers m6. P3 operations m6 only after taking
its transient retrieval-mark. P1 operation m5 after getting the min_vectr [].P2 operations m7
because at this movement it not in the filibustering state. Similarly, P3 operations m8. At time
t3, P4 accepts responses to transient check point requests from all relevant operations (not shown
in the Figure 1) and issues partially-committed retrieval-mark request to all operations. An
operation in the minimum set converts its transient retrieval-mark into partially-committed one.

https://iaeme.com/Home/journal/IJEET 135 editor@iaeme.com

 Dealing with Frequent Terminates in Synchronized Dependency Recovery Line Compilation
Algorithm for Mobile Distributed Systems

Finally, at time t4, P4 accepts responses to partially-committed retrieval-mark requests from all
relevant operations (not shown in the Figure 1) and issues the commit request.

Figure 1 An Example of the proposed Protocol

3.3. Handling Node Mobility and Disconnections

A Mob_Node may be disconnected from the network for an arbitrary period of time. The DRL-
compilation methodology may generate a request for such Mob_Node to take a retrieval-mark.
Delaying a response may significantly increase the completion time of the DRL-compilation
methodology. We propose the following solution to deal with disconnections that may lead to
infinite wait state.
When an Mob_Node, say Mob_Nodei, disconnects from an Mob_Supp_Stn, say
Mob_Supp_Stnk, Mob_Nodei takes its own retrieval-mark, say disconnect_ckpti, and transfers it
to Mob_Supp_Stnk. Mob_Supp_Stnk stores all the relevant data structures and disconnect_ckpti
of Mob_Nodei on stable storage. During disconnection period, Mob_Supp_Stnk acts on behalf
of Mob_Nodei as follows. In minimum-operation DRL-compilation, if Mob_Nodei is in the
minset[], disconnect_ckpti is considered as Mob_Nodei’s retrieval-mark for the current
commencement . In all-operation DRL-compilation, if Mob_Nodei’s disconnect_ckpti is already
converted into enduring one, then the committed retrieval-mark is considered as the retrieval-
mark for the current commencement; otherwise, disconnect_ckpti is considered. On global
retrieval-mark commit, Mob_Supp_Stnk also updates Mob_Nodei’s data structures, e.g., ddv[],
cci etc. On the receipt of reckoning-communications for Mob_Nodei, Mob_Supp_Stnk does not
update Mob_Nodei’s ddv[] but maintains two reckoning-communication queues, say old_m_q
and new_m_q, to store the reckoning-communications as described below.

https://iaeme.com/Home/journal/IJEET 136 editor@iaeme.com

 Suresh Kumar and Rajeev Yadav

On the receipt of a reckoning-communication m for Mob_Nodei at Mob_Supp_Stnk from

any other operation:
if((m.cci= = ccii  (m.cci= =ncii)  (matd[j, m.cci]= =1))
add (m, new_m_q); // keep the reckoning-communication in new_m_q
else
add( m, old_m_q);
On all-operation retrieval-mark commit:
Merge new_m_q to old_m_q;
Free(new_m_q);
When Mob_Nodei, enters in the cell of Mob_Supp_Stnj, it is connected to the
Mob_Supp_Stnj if g_chkptj is reset. Otherwise, it waits for g_chkptj to be reset. Before
connection, Mob_Supp_Stnj collects Mob_Nodei’s ddv[], cci, new_m_q, old_m_q from
Mob_Supp_Stnk; and Mob_Supp_Stnk discards Mob_Nodei’s support information and
disconnect_ckpti. Mob_Supp_Stnj forwards the reckoning-communications in old_m_q to
Mob_Nodei without updating the ddv[], but reckoning-communications in new_m_q, update
ddv[] of Mob_Nodei.

3.4. Handling Failures during DRL-compilation

Since Mob_Nodes are prone to failure, an Mob_Node may fail during DRL-compilation
operation. Sudden or abrupt disconnection of an Mob_Node is also termed as a fault. Suppose,
Pi is waiting for a reckoning-communication from Pj and Pj has failed, then Pi times out and
detects the failure of Pj. If the failed operation is not required to retrieval-mark in the current
commencement or the failed operation has already taken its partially-committed retrieval-mark,
the DRL-compilation operation can be completed uninterruptedly. If the failed operation is not
the originator, one way to deal with the failure is to discard the whole DRL-compilation
operation similar to the approach in [11, 21]. The failed operation will not be able to respond
to the originator’s requests and originator will detect the failure by timeout and will terminate
the current DRL-compilation operation. If the originator fails after forwarding commit or
terminates reckoning-communication, it has nothing to do for the current commencement.
Suppose, the originator fails before forwarding commit or terminate reckoning-communication.
Some operation, waiting for the retrieval-mark/commit request, will timeout and will detect the
failure of the originator. It will forward terminate request to all operations discarding the current
DRL-compilation operation.
The above approach seems to be inefficient, because, the whole DRL-compilation operation
is discarded even when only one participating operation fails. Kim and Park [13] proposed that
an operation commits its partially-committed retrieval-marks if none of the operations, on
which it transitively depends, fails; and the dependable recovery line is advanced for those
operations that committed their retrieval-marks. The originator and other operations, which
transitively depend on the failed operation, have to terminate their partially-committed
retrieval-marks. Thus, in case of a node failure during DRL-compilation, total terminate of the
DRL-compilation is avoided.

3.5. Multiple Concurrent Initiations

We point out the following problems in allowing concurrent commencement s in minimum-
operation DRL-compilation protocols, particularly in case of mobile distributed frameworks:
(i) If Pi and Pj concurrently initiate DRL-compilation operation and Pj belongs to the minimum
set of Pi, then Pj’s commencement will be redundant. Some operations, in Pj’s minimum set,

https://iaeme.com/Home/journal/IJEET 137 editor@iaeme.com

 Dealing with Frequent Terminates in Synchronized Dependency Recovery Line Compilation
Algorithm for Mobile Distributed Systems

will unnecessarily take multiple redundant retrieval-marks. This will waste the scarce resources
of the mobile distributed framework.
(ii) In case of concurrent commencement s, multiple triggers need to be piggybacked on normal
reckoning-communications [26]. Trigger contains the originator operation identification and its
c_s_n. This leads to considerable increase in piggybacked information.
Concurrent commencement s may exhaust the limited battery life and congest the wireless
channels. Therefore, the concurrent executions of the proposed protocol are not considered.

3.6. Correctness Proof

The correctness proof for the proposed minimum-operation DRL-compilation methodology is
as under:
Let GCi ={C1,x, C2,y,............,Cn,z} be some dependable global state created by our
methodology, where Ci,x is the xth retrieval-mark of Pi.

Theorem I: The global state created by the ith iteration of the DRL-compilation protocol is
dependable.
Proof: Let us consider that the framework is in dependable state when an operation initiates
DRL-compilation. The recorded global state will be independable only if there exists a
reckoning-communication m between two operations Pi and Pj such that Pi forwards m after
taking the retrieval-mark Ci,x, Pj accepts m before taking the retrieval-mark Cj,y, and both Ci,x
and Cj,y are the members of the new global state. We prove the result by contradiction that no
such reckoning-communication exists. We consider all four possibilities as follows:
Case I: Pi belongs to minimum set and Pj does not:
As Pi is in minimum set, Ci,x is the retrieval-mark taken by Pi during the current commencement
and Cj,y is the retrieval-mark taken by Pj during some previous commencement i.e. Cj,y →Ci,x .
Therefore rec(m) →Cj,y and Ci,x →forward (m) implies rec(m) → Cj,y →Ci,x →forward (m)
implies rec(m) →forward (m) which is not possible. ‘→’ is the Lamport’s happened before
relation [17].
Case II: Both Pi and Pj are in minimum set:
Both Ci,x and Cj,y are the retrieval-marks taken during current commencement . There are
following possibilities:
(a) Pi forwards m after taking the partially-committed/transient retrieval-mark and Pj accepts m
before receiving request for dependency:
Any operation can take the retrieval-mark only after originator accepts the dependencies
from all operations. Therefore a reckoning-communication sent from an operation after taking
the retrieval-mark cannot be received by other operation before getting the dependency request.
(b)Pi forwards m after taking the transient retrieval-mark and Pj accepts m after getting the
dependency request but before taking the retrieval-mark:
In this case, following condition will be true at the time of receiving m: (filibustering j) &&
(m.p_c_s_n >c_s_n[j]) ). Therefore, m will be buffered at Pj, and it will be operationed only
after Pj takes the transient retrieval-mark.
(c) Pi forwards m after commit and Pj accepts m before taking partially-committed retrieval-
mark:
As Pj is in the minimum set, originator can issue a commit only after Pj takes partially-
committed retrieval-mark and informs originator. Therefore the event rec(m) at Pj cannot take
place before Pj takes the retrieval-mark.

https://iaeme.com/Home/journal/IJEET 138 editor@iaeme.com

 Suresh Kumar and Rajeev Yadav

Case III: Pi is not in minimum set but Pj is in minimum set:

Checkpoint Cj,y belongs to the current commencement and Ci,x is from some previous
commencement . The reckoning-communication m can be received by Pj:
• before receiving request for dependency
• after receiving request for dependency but before taking the retrieval-mark Cj,y
If m is received during above (i), Pi will be included in the minimum set. If m is received
during (ii) above, Pj will operation m, before taking the transient retrieval-mark. Otherwise, if
any of the following conditions is true:
• cdd-setj[i]=1. In this case Pi will also be included in the minimum set.
• (m.p_c_s_n >c_s_n[i]). This is possible only if Pi has taken some enduring retrieval-
mark after forwarding m. In that case, m is not an orphan reckoning-communication.
Case IV: Both Pi and Pj are not in minimum set:
Neither Pi nor Pj will take a new retrieval-mark, therefore, no such m is possible unless and until
it already exists.
All nodes will complete above steps in finite time unless a node is faulty. If a node in the
minimum set becomes faulty during DRL-compilation, the whole of the DRL-compilation
operation is terminated. Hence, it can be inferred that the methodology terminates in finite time.

4. CONCLUSION
We have proposed a minimum operation synchronized DRL-compilation methodology for
mobile distributed framework, where no useless retrieval-marks are taken and an effort is made
to minimize the filibustering of operations. We are able to reduce the filibustering time to bare
minimum by computing the exact minimum set in the beginning. Furthermore, the filibustering
of operations is reduced by allowing the operations to perform their normal computations and
forward reckoning-communications during their filibustering period. The number of operations
that take retrieval-marks is minimized to avoid awakening of Mob_Nodes in doze mode of
operation and thrashing of Mob_Nodes with DRL-compilation activity. It also saves limited
battery life of Mob_Nodes and low bandwidth of wireless channels. We try to reduce the loss
of DRL-compilation effort when any operation fails to take its retrieval-mark in coordination
with others.

REFERENCES
[1] A. Acharya and B. R. Badrinath, “Checkpointing Distributed Applications on Mobile
Computers”, In Proceedings of the 3rd International Conference on Parallel and Distributed
Information Systems (PDIS), pp. 73-80, 1994.

[2] R. Baldoni, J-M Hélary, A. Mostefaoui and M. Raynal, “A Communication-Induced

Checkpointing Protocol that Ensures Rollback-Dependency Tractability, In Proceedings of the
International Symposium on Fault-Tolerant-Computing Systems, pp. 68-77, 1997.

[3] G. Cao and M. Singhal, “On coordinated checkpointing in Distributed Systems”, IEEE
Transactions on Parallel and Distributed Systems, 9 (12), pp. 1213-1225, 1998.

[4] G. Cao and M. Singhal, “On the Impossibility of Min-process Non-blocking Checkpointing and
an Efficient Checkpointing Algorithm for Mobile Computing Systems,” In Proceedings of
International Conference on Parallel Processing, pp. 37-44, 1998.

https://iaeme.com/Home/journal/IJEET 139 editor@iaeme.com

 Dealing with Frequent Terminates in Synchronized Dependency Recovery Line Compilation
Algorithm for Mobile Distributed Systems

[5] G. Cao and M. Singhal, “Mutable Checkpoints: A New Checkpointing Approach for Mobile
Computing systems”, IEEE Transaction On Parallel and Distributed Systems, 12(2), pp. 157-
172, 2001.

[6] K.M. Chandy and L. Lamport, “Distributed Snapshots: Determining Global State of Distributed
Systems,” ACM Transaction on Computing Systems, 3(1), pp. 63-75, 1985.

[7] E. N. Elnozahy, L. Alvisi, Y. M. Wang and D. B. Johnson, “A Survey of Rollback-Recovery

Protocols in Message-Passing Systems,” ACM Computing Surveys, 34(3), pp. 375-408, 2002.

[8] E.N. Elnozahy, D.B. Johnson and W. Zwaenepoel, “The Performance of Consistent
Checkpointing”, In Proceedings of the 11th Symposium on Reliable Distributed Systems, pp. 39-
47,1992.

[9] J.M. Hélary, A. Mostefaoui and M. Raynal, “Communication-Induced Determination of

Consistent Snapshots”, In Proceedings of the 28th International Symposium on Fault-Tolerant
Computing, pp. 208-217, 1998.

[10] H. Higaki and M. Takizawa, “Checkpoint-recovery Protocol for Reliable Mobile Systems”,
Transactions of Information processing Japan, 40(1), pp. 236-244, 1999.

[11] R. Koo and S. Toueg, “Checkpointing and Roll-Back Recovery for Distributed Systems”, IEEE
Transactions on Software Engineering, 13(1), pp. 23-31, 1987.

[12] P. Kumar, L. Kumar, R. K. Chauhan and V. K. Gupta, “A Non-Intrusive Minimum Process

Synchronous Checkpointing Protocol for Mobile Distributed Systems”, In Proceedings of IEEE
ICPWC-2005, 2005.

[13] J.L. Kim and T. Park, “An efficient Protocol for checkpointing Recovery in Distributed
Systems”, IEEE Transactions on Parallel and Distributed Systems, pp. 955-960, 1993.

[14] L. Kumar, M. Misra, R.C. Joshi, “Checkpointing in Distributed Computing Systems”, In

Concurrency in Dependable Computing, pp. 273-92, 2002.

[15] L. Kumar, M. Misra, R.C. Joshi, “Low overhead optimal checkpointing for mobile distributed
systems”, In Proceedings of 19th IEEE International Conference on Data Engineering, pp. 686
– 88, 2003.

[16] L. Kumar and P.Kumar, “A Synchronous Checkpointing Protocol for Mobile Distributed
Systems: Probabilistic Approach”, International Journal of Information and Computer
Security, 1(3), pp. 298-314, 2007.

[17] L. Lamport, “Time, clocks and ordering of events in a distributed system”, Communications of
the ACM, 21(7), pp. 558-565, 1978.

[18] N. Neves and W.K. Fuchs, “Adaptive Recovery for Mobile Environments”, Communications
of the ACM, 40(1), pp. 68-74, 1997.

[19] W. Ni, S. Vrbsky and S. Ray, “Pitfalls in Distributed Nonblocking Checkpointing”, Journal of
Interconnection Networks, 1(5), pp. 47-78, 2004.

[20] D.K. Pradhan, P.P. Krishana and N.H. Vaidya, “Recovery in Mobile Wireless Environment:
Design and Trade-off Analysis”, In Proceedings of 26th International Symposium on Fault-
Tolerant Computing, pp. 16-25, 1996.

https://iaeme.com/Home/journal/IJEET 140 editor@iaeme.com

 Suresh Kumar and Rajeev Yadav

[21] R. Prakash and M. Singhal, “Low-Cost Checkpointing and Failure Recovery in Mobile
Computing Systems”, IEEE Transaction On Parallel and Distributed Systems, 7(10), pp. 1035-
1048, 1996.

[22] K.F. Ssu, B. Yao, W.K. Fuchs and N.F. Neves, “Adaptive Checkpointing with Storage
Management for Mobile Environments”, IEEE Transactions on Reliability, 48(4), pp. 315-324,
1999.

[23] L.M. Silva and J.G. Silva, “Global checkpointing for distributed programs”, In Proceedings of
the 11th symposium on Reliable Distributed Systems, pp. 155-62, 1992.

[24] Sunil Kumar, R K Chauhan, Parveen Kumar, “A Minimum-process Coordinated

Checkpointing Protocol for Mobile Computing Systems”, International Journal of Foundations
of Computer science, 19(4), pp 1015-1038, 2008.

[25] Parveen Kumar, “A Low-Cost Hybrid Coordinated Checkpointing Protocol for mobile
distributed systems”, Mobile Information Systems, 4(1), pp 13-32, 2007.

[26] W. Ni, S. Vrbsky and S. Ray, “Pitfalls in Distributed Nonblocking Checkpointing”, Journal of
Interconnection Networks, 1(5), pp. 47-78, 2004.

[27] Praveen Choudhary, Parveen Kumar, “Minimum-Process Global-Snapshot Accumulation

Etiquette for Mobile Distributed Systems”, International Journal of Advanced Research in
Engineering and Technology”, 11(8), pp. 937-948, August 2020.

[28] Praveen Choudhary, Parveen Kumar, ”Low-Overhead Minimum-Method Global-Snapshot

Compilation Protocol for Deterministic Mobile Computing Systems”, International Journal of
Emerging Trends in Engineering Research”, 9(8), pp.1069-1072, August 2021.

[29] Deepak Chandra Uprety, Parveen Kumar, Arun Kumar Chouhary, ”Transient Snapshot based
Minimum-process Synchronized Checkpointing Etiquette for Mobile Distributed Systems”,
International Journal of Emerging Trends in Engineering Research”, 10(4), August 2021.

https://iaeme.com/Home/journal/IJEET 141 editor@iaeme.com