DEALING WITH RECURRENT TERMINATES IN ORCHESTRATED RELIABLE RECOVERY LINE ACCUMULATION ALGORITHMS FOR FAULTTOLERANT MOBILE DISTRIBUTED SYSTEMS

https://iaeme.com/Home/journal/IJEET 393 editor@iaeme.com
International Journal of Electrical Engineering and Technology (IJEET)
Volume 11, Issue 9, November 2020, pp. 393-400, Article ID: IJEET_11_09_036
Available online at https://iaeme.com/Home/issue/IJEET?Volume=11&Issue=9
ISSN Print: 0976-6545 and ISSN Online: 0976-6553
DOI: https://doi.org/10.17605/OSF.IO/VWRBG
© IAEME Publication Scopus Indexed
DEALING WITH RECURRENT TERMINATES IN
ORCHESTRATED RELIABLE RECOVERY LINE
ACCUMULATION ALGORITHMS FOR FAULT-
TOLERANT MOBILE DISTRIBUTED SYSTEMS
Asrar Ahmad Ansari
Research Scholar, CS, NIMS University Rajasthan, Jaipur, India
Surendra Pal Singh
Professor, CSE, NIMS University Rajasthan, Jaipur, India
ABSTRACT
We propose a least-interacting-routine orchestrated RRL-accumulation (Reliable
Recovery Line Accumulation) mechanism for non-deterministic mobile distributed
frameworks, where no inoperable restoration-spots are captured. We use the following
technique to minimize the filibustering of routines. During the period, when a routine
consigns its causal-interrelationship set to the originator and receives the least-
interacting-set, may receive some reckoning-communications, which may add new
members to the already computed least-interacting-set. Such reckoning-
communications are delayed at the receiver side. It should be noted that the duration
for which the reckoning-communications are delayed at the receiver’s end is negligibly
small. We also try to minimize the loss of RRL-accumulation effort when any routine
miscarries to seize its restoration-spot in synchronization with others. We propose that
in the first phase, all concerned Mobl-Nodules will seize transient restoration-spot only.
Transient restoration-spot is stored on the memory of Mobl-Nodule only. In this case,
if some routine miscarries to seize restoration-spot in the first phase, then Mobl-Nodules
need to abort their transient restoration-spots only. The effort of capturing a transient
restoration-spot is negligible as compared to the partially-committed one. We propose
a three phase mechanism as planned in previous chapter. But, in the planned
mechanism, the synchronization with the originator Mobl_Supp_St is done without
consigning explicit synchronization reckoning-communications. We want to emphasize
that in all orchestrated RRL-accumulation schemes available in literature,
synchronization among routines and originator captures place by consigning explicit
synchronization reckoning-communications. In this way, we try to significantly reduce
the synchronization overhead in orchestrated RRL-accumulation.
Key Words: Fault tolerance, dependable global state, synchronized DRL-compilation
and mobile frameworks

Dealing with Recurrent Terminates in Orchestrated Reliable Recovery Line Accumulation
Algorithms for Fault-Tolerant Mobile Distributed Systems
Cite this Article: Asrar Ahmad Ansari and Surendra Pal Singh, Dealing with Recurrent
Terminates in Orchestrated Reliable Recovery Line Accumulation Algorithms for
Fault-Tolerant Mobile Distributed Systems, International Journal of Electrical
Engineering and Technology (IJEET), 11(9), 2020, pp. 393-400.
https://iaeme.com/Home/issue/IJEET?Volume=11&Issue=9
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].

Asrar Ahmad Ansari and Surendra Pal Singh
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.
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
We propose a three phase mechanism as planned in previous chapter. But, in the planned
mechanism, the synchronization with the originator Mobl_Supp_St is done without consigning
explicit synchronization reckoning-communications. The originator Mobl_Supp_St (say
Mobl_Supp_Stin) collects the causal-interrelationship vectors of all routines, computes the
least-interacting-set and consigns the transient restoration-spot request to all Mobl_Supp_Sts
along with the least-interacting-set. Suppose, Mobl_Supp_Sti gets the transient restoration-spot
request in the first phase from Mobl_Supp_Stin. It sets its timer (timer_transient) and consigns
the transient restoration-spot request to all concerned resident Mobl-Nodules. timer_transient
is the maximum allowable time for all concerned routines to seize their transient restoration-
spots . On receiving the transient restoration-spot request, a Mobl-Nodule captures its transient
restoration-spot and consigns the response to Mobl_Supp_Sti. Before the expiry of the
timer_transient, if Mobl_Supp_Sti gets the negative response from some Mobl-Nodule to its
transient restoration-spot request, then Mobl_Supp_Sti consigns the negative response to
Mobl_Supp_Stin and Mobl_Supp_Stin issues abort reckoning-communication to all
Mobl_Supp_Sts. Otherwise, on expiry of timer_transient, if Mobl_Supp_Sti does not get the
positive response to transient restoration-spot request from all concerned resident Mobl-
Nodules, it informs letdown reckoning-communication to Mobl_Supp_Stin and
Mobl_Supp_Stin issues abort. Alternatively, on expiry of timer_transient Mobl_Supp_Sti issues

partially-committed restoration-spot request to the concerned Mobl-Nodules in its cubicle and
sets timer_tent_rm. On expiry of timer_transient, if Mobl_Supp_Sti does not get abort massage
from Mobl_Supp_Stin, it is presumed that all concerned routines have captured their transient
restoration-spots ; and the mechanism should enter the second phase in which all concerned
routines convert their transient restoration-spots into the partially-committed ones. Similarly,
timer_tent_rm is the maximum allowable time for all concerned routines to convert their
transient restoration-spots into partially-committed ones. If some routine miscarries to seize its
partially-committed restoration-spot, then Mobl_Supp_Sti informs Mobl_Supp_Stin and
Mobl_Supp_Stin issues abort. Otherwise, after the timeout of timer_tent_rm, Mobl_Supp_Sti
commits the restoration-spots of the routines of the least-interacting-sets which are resident to
its cubicle. On expiry of timer_tent_rm, if Mobl_Supp_Sti does not get abort massage from
Mobl_Supp_Stin, it is presumed that all concerned routines have captured their partially-
committed restoration-spots ; and the mechanism should enter the third phase in which all
concerned routines convert their partially-committed restoration-spots into the enduring ones.
In this way, three-phase orchestrated RRL-accumulation mechanism commits without
consigning or receiving any synchronization reckoning-communications. Only in the case of a
letdown a Mobl_Supp_St issues the letdown reckoning-communication to Mobl_Supp_Stin
and Mobl_Supp_Stin issues the commit. The planned mechanism may seize longer time to
commit. But in doing so, we are saving synchronization reckoning-communications to
significant extent and no extra filibustering of routines captures place due to longer commit
time.
3. PROPOSED ALGORITHM
The originator Mobl_Supp_St consigns a request to all Mobl_Supp_Sts to consign the ci_vectr
vectors of the routines in their cubicles. All ci_vectr vectors are at Mobl_Supp_Sts and thus no
initial RRL-accumulation reckoning-communications or responses travels wireless channels.
On receiving the ci_vectr [] request, a Mobl_Supp_St records the identity of the originator
routine (say Mobl_Supp_St_ida) and originator Mobl_Supp_St, consigns back the ci_vectr []
of the routines in its cubicle, and sets g_chkpt. If the originator Mobl_Supp_St receives a
request for ci_vectr [] from some other Mobl_Supp_St (say Mobl_Supp_St_idb) and
Mobl_Supp_St_ida is lower tha Mobl_Supp_St_idb,the, current commencement with
Mobl_Supp_St_ida is discarded and the new one having Mobl_Supp_St_idb is continued.
Similarly, if a Mobl_Supp_St receives ci_vectr requests from two Mobl_Supp_Sts, then it
discards the request of the originator Mobl_Supp_St with lower Mobl_Supp_St_id. Otherwise,
on receiving ci_vectr vectors of all routines, the originator Mobl_Supp_St computes least_vectr
[], consigns transient restoration-spot request along with the least_vectr [] to all
Mobl_Supp_Sts. In this way, if two routines concurrently initiate RRL-accumulation, then one
is ignored. When an routineconsigns its ci_vectr [] to the originator Mobl_Supp_St, it comes
into its filibustering state. An routine comes out of the filibustering state only after capturing
its transient restoration-spot if it is a member of the least-interacting-set; otherwise, it comes
out of filibustering state after getting the transient restoration-spot request. It should be noted
that the filibustering time of an routineis bare least.
On receiving the transient restoration-spot request along with the least_vectr [], a
Mobl_Supp_St, say Mobl_Supp_Stj, captures the following actions. It sets the timer
timer_transient; consigns the transient restoration-spot request to Pi only if Pi belongs to the
least_vectr [] and Pi is running in its cubicle. On receiving the restoration-spot request, Pi
captures its transient restoration-spot and informs Mobl_Supp_Stj. On receiving positive
response from Pi, Mobl_Supp_Stj updates o-rmsni, resets filibusteringi, and consigns the
buffered reckoning-communications to Pi, if any. Alternatively, If Pi is not in the least_vectr []

and Pi is in the cubicle of Mobl_Supp_Stj, Mobl_Supp_Stj resets filibusteringi and consigns the
buffered reckoning-communication to Pi, if any. For a disengaged Mobl-Nodule, that is a
member of least_vectr [], the Mobl_Supp_St that has its disengaged restoration-spot, converts
its disengaged restoration-spot into the required one.
During filibustering period, Pi routines m, received from Pj, if following conditions are met:
(i) (!buferi) i.e. Pi has not buffered any reckoning-communication (ii) (m.psn <=rmsn[j]) i.e. Pj
has not captured its restoration-spot before consigning m (iii) (ci_vectri[j]=1) Pi is already
dependent upon Pj in the current CI or Pj has captured some enduring restoration-spot after
consigning m. Otherwise, the resident Mobl_Supp_St of Pi buffers m for the filibustering period
of Pi and sets bufferi.
On expiry of timer_transient, if Mobl_Supp_Stj does not get the positive response to
transient restoration-spot request from all concerned resident Mobl-Nodules, it informs letdown
reckoning-communication to Mobl_Supp_Stin and Mobl_Supp_Stin issues abort. Alternatively,
on expiry of timer_transient Mobl_Supp_Stj issues partially-committed restoration-spot request
to the concerned Mobl-Nodules in its cubicle and sets timer_tent_rm.
If some routine miscarries to seize its partially-committed restoration-spot, then
Mobl_Supp_Stj informs Mobl_Supp_Stin and Mobl_Supp_Stin issues abort. Otherwise, after the
timeout of timer_tent_rm, Mobl_Supp_Stj commits the restoration-spots of the routines of the
least-interacting-sets which are resident to its cubicle. On expiry of timer_tent_rm, if
Mobl_Supp_Sti does not get abort massage from Mobl_Supp_Stin, it is presumed that all
concerned routines have captured their partially-committed restoration-spots successfully; and
the mechanism should enter the third phase in which all concerned routines convert their
partially-committed restoration-spots into the enduring ones.
4. AN EXAMPLE OF THE PROPOSED SCHEME
We explain the planned least-interacting-routine RRL-accumulation mechanism with the help
of an example. In Figure 1, at time t0, P5 initiates RRL-accumulation routine and consigns
request to all routines for their causal-interrelationship vectors. At time t1, P5 receives the
causal-interrelationship vectors from all routines and computes the least-interacting-set
(least_vectr[]) which is {P4, P5, P6}. The working out of the least-interacting-set on the basis
of causal-interrelationship vectors of all routines can be found in [14, 16]. P5 consigns least-
interacting-set (least_vectr[]) to all routines and captures its own transient restoration-spot C51.
On receiving least_vectr[], an routine captures its transient restoration-spot if it is a member of
least_vectr[]. When P4 and P6 get the least_vectr[], they find themselves to be the members of
the least_vectr[]; therefore, they seize their transient restoration-spots , C41 and C61,
respectively. When P1, P2 and P3 get the least_vectr [], they find that they do not belong to
least_vectr [], therefore, they do not seize their transient restoration-spots. It should be noted
that these routines have not sent any reckoning-communication to any routine of the least-
interacting-set. In other words, P5 is not transitively dependent upon them. Therefore, for the
sake of consistency, it is not necessary for them to seize their restoration-spots in the current
commencement.
An routine comes into the filibustering state immediately after consigning the ci_vectr[].
An routine comes out of the filibustering state only after capturing its transient restoration-spot
if it is a member of the least-interacting-set; otherwise, it comes out of filibustering state after
getting the transient restoration-spot request. We want to say that the filibustering time of an
routine in this mechanism is negligibly small. Moreover, an routineis allowed to perform its
normal working out, consign reckoning-communications and partially receive them during the
filibustering period. For example, P5 receives m4 during its filibustering period. As
ci_vectr5[6]=1 due to m2, and receive of m4 will not alter ci_vectr5[]; therefore P5 routines m4.

P2 receives m15 from P3 during its filibustering period; ci_vectr2 [3]=0 and the receive of m15
can alter ci_vectr2[]; therefore, P2 buffers m15. Similarly, P4 buffers m16. P4 routines m16 only
after capturing its transient restoration-spot C41. P2 routines m15 after getting the least_vectr [].
P4 routines m7 because at this moment it not in the filibustering state. Similarly, P4 routines m8.
On getting the transient restoration-spot request, an routine, say P6, sets the timer
timer_transient. If P6 miscarries to seize its transient restoration-spot , it informs P5 and P5 will
issue abort. Similarly, if any other routine miscarries to seize its transient restoration-spot, it
will inform P5 and P5 will inform P6. In this way, if any routine miscarries to seize its
restoration-spot in synchronization with others in the first phase, then all routines need to abort
their transient restoration-spots only and not the partially-committed restoration-spots as in
other mechanisms [14, 15, 16]. In this way, we are able to significantly reduce the loss of RRL-
accumulation effort in case of a letdown during RRL-accumulation. Alternatively, on timeout
of timer_transient and no abort reckoning-communication from P5, it is presumed that all
concerned routines have captured their transient restoration-spots successfully and the
mechanism should enter into the second phase. Therefore, P6 converts its transient restoration-
spot into partially-committed one and sets the timer timer_tent_rm . If P6 miscarries to convert
its transient restoration-spot into partially-committed one, it informs P5 and P5 will issue abort.
Similarly, if any other routine miscarries to seize its transient restoration-spot, it will inform P5
and P5 will inform P6. Otherwise, on timeout of timer_tent_rm, P6 converts its partially-
committed restoration-spot into enduring one. On timeout of timer_tent_rm and no abort
reckoning-communication from P5, it is presumed that all concerned routines have captured
their partially-committed restoration-spots successfully and the mechanism should enter into
the second phase. In this way, we commit the restoration-spots without much synchronization.
Figure 1 An Example of the proposed Protocol

5. CONCLUSION
We have designed a least-interacting-routine synchronous RRL-accumulation mechanism for
mobile distributed framework. We try to minimize the filibustering of routines during RRL-
accumulation. The filibustering time of an routine is bare least. During filibustering period,
routines can do their normal working outs, consign reckoning-communications and can routine
selective reckoning-communications. The number of routines that seize restoration-spots is
minimized to avoid awakening of Mobl-Nodules in doze mode of routine and thrashing of
Mobl-Nodules with RRL-accumulation activity. It also saves limited battery life of Mobl-
Nodules and low bandwidth of wireless channels. We try to reduce the loss of RRL-
accumulation effort when any routine miscarries to seize its restoration-spot in synchronization
with others. We also try to minimize the synchronization reckoning-communications during
RRL-accumulation. In the planned scheme, no synchronization reckoning-communications are
sent in order to enter the second or third phase of the mechanism.
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 1994), 1994, 73-80.
[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, 1997, 68-77.
[3] G. Cao and M. Singhal, “On coordinated checkpointing in Distributed Systems”, IEEE
Transactions on Parallel and Distributed Systems, 9 (12), 1998, 1213-1225.
[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, 1998, 37-44.
[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), 2001, 157-
172.
[6] K.M. Chandy and L. Lamport, “Distributed Snapshots: Determining Global State of Distributed
Systems,” ACM Transaction on Computing Systems, 3(1), 1985, 63-75.
[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), 2002, 375-408.
[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, 1992,
39-47.
[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, 1998, 208-217.
[10] H. Higaki and M. Takizawa, “Checkpoint-recovery Protocol for Reliable Mobile Systems”,
Transactions of Information processing Japan, 40(1), 1999, 236-244.
[11] R. Koo and S. Toueg, “Checkpointing and Roll-Back Recovery for Distributed Systems”, IEEE
Transactions on Software Engineering, 13(1), 1987, 23-31.
[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, 1993, 955-960.
[14] L. Kumar, M. Misra, R.C. Joshi, “Checkpointing in Distributed Computing Systems”, In
Concurrency in Dependable Computing, 2002, 273-92.
[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, 2003,
686 – 88.
[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), 2007, 298-314.
[17] L. Lamport, “Time, clocks and ordering of events in a distributed system”, Communications of
the ACM, 21(7), 1978, 558-565.
[18] N. Neves and W.K. Fuchs, “Adaptive Recovery for Mobile Environments”, Communications
of the ACM, 40(1), 1997, 68-74.
[19] W. Ni, S. Vrbsky and S. Ray, “Pitfalls in Distributed Nonblocking Checkpointing”, Journal of
Interconnection Networks, 1(5), 2004, 47-78.
[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, 1996, 16-25.
[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), 1996,
1035-1048.
[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), 1999, 315-
324.
[23] L.M. Silva and J.G. Silva, “Global checkpointing for distributed programs”, In Proceedings of
the 11th
symposium on Reliable Distributed Systems, 1992, 155-62.
[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,vol 19, no. 4, pp 1015-1038, 2008.
[25] Parveen Kumar, “A Low-Cost Hybrid Coordinated Checkpointing Protocol for mobile
distributed systems”, Mobile Information Systems. pp 13-32, vol. 4, no. 1, 2007.
[26] W. Ni, S. Vrbsky and S. Ray, “Pitfalls in Distributed Nonblocking Checkpointing”, Journal of
Interconnection Networks, 1(5), 2004, 47-78.
[27] Praveen Choudhary, Parveen Kumar,”Minimum-Process Global-Snapshot Accumulation
Etiquette for Mobile Distributed Systems”, International Journal of Advanced Research in
Engineering and Technology” vol. 11, Issue 8, Aug 20, pp.937-948.
[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” vol. 9, Issue 8, Aug 2021, pp.1069-1072.

DEALING WITH RECURRENT TERMINATES IN ORCHESTRATED RELIABLE RECOVERY LINE ACCUMULATION ALGORITHMS FOR FAULTTOLERANT MOBILE DISTRIBUTED SYSTEMS

More Related Content

Similar to DEALING WITH RECURRENT TERMINATES IN ORCHESTRATED RELIABLE RECOVERY LINE ACCUMULATION ALGORITHMS FOR FAULTTOLERANT MOBILE DISTRIBUTED SYSTEMS (20)

More from IAEME Publication (20)

Recently uploaded (20)

DEALING WITH RECURRENT TERMINATES IN ORCHESTRATED RELIABLE RECOVERY LINE ACCUMULATION ALGORITHMS FOR FAULTTOLERANT MOBILE DISTRIBUTED SYSTEMS