Snapshot Algorithms Research Articles

Async-Fork: Mitigating Query Latency Spikes Incurred by the Fork-based Snapshot Mechanism from the OS Level

In-memory key-value stores (IMKVSes) serve many online applications. They generally adopt the fork-based snapshot mechanism to support data backup. However, this method can result in query latency spikes because the engine is out-of-service for queries during the snapshot. In contrast to existing research optimizing snapshot algorithms, we address the problem from the operating system (OS) level, while keeping the data persistent mechanism in IMKVSes unchanged. Specifically, we first study the impact of the fork operation on query latency. Based on findings in the study, we propose Async-fork, which performs the fork operation asynchronously to reduce the out-of-service time of the engine. Async-fork is implemented in the Linux kernel and deployed into the online Redis database in public clouds. Our experiment results show that Async-fork can significantly reduce the tail latency of queries during the snapshot.

Visibility reasoning for concurrent snapshot algorithms

Visibility relations have been proposed by Henzinger et al. as an abstraction for proving linearizability of concurrent algorithms that obtains modular and reusable proofs. This is in contrast to the customary approach based on exhibiting the algorithm's linearization points. In this paper we apply visibility relations to develop modular proofs for three elegant concurrent snapshot algorithms of Jayanti. The proofs are divided by signatures into components of increasing level of abstraction; the components at higher abstraction levels are shared, i.e., they apply to all three algorithms simultaneously. Importantly, the interface properties mathematically capture Jayanti's original intuitions that have previously been given only informally.

A Fault-Tolerant Distributed Framework for Asynchronous Iterative Computations

Asynchronous iterative computations (AIC) are common in machine learning and data mining systems. However, the lack of synchronization barriers in asynchronous processing brings challenges for continuous processing while workers might fail. There is no global synchronization point that all workers can roll back to. In this article, we propose a fault-tolerant framework for asynchronous iterative computations (FAIC). Our framework takes a virtual snapshot of the AIC system without halting the computation of any worker. We prove that the virtual snapshot capture by FAIC can recover the AIC system correctly. We evaluate our FAIC framework on two existing AIC systems, Maiter and NOMAD. Our experiment result shows that the checkpoint overhead of FAIC is more than 50 percent shorter than the synchronous checkpoint method. FAIC is around 10 percent faster than other asynchronous snapshot algorithms, such as the Chandy-Lamport algorithm. Our experiments on a large cluster demonstrate that FAIC scales with the number of workers.

A Comparative Study of Consistent Snapshot Algorithms for Main-Memory Database Systems

In-memory databases (IMDBs) are gaining increasing popularity in big data applications, where clients commit updates intensively. Specifically, it is necessary for IMDBs to have efficient snapshot performance to support certain special applications (e.g., consistent checkpoint, HTAP). Formally, the in-memory consistent snapshot problem refers to taking an in-memory consistent time-in-point snapshot with the constraints that 1) clients can read the latest data items and 2) any data item in the snapshot should not be overwritten. Various snapshot algorithms have been proposed in academia to trade off throughput and latency, but industrial IMDBs such as Redis adhere to the simple fork algorithm. To understand this phenomenon, we conduct comprehensive performance evaluations on mainstream snapshot algorithms. Surprisingly, we observe that the simple fork algorithm indeed outperforms the state-of-the-arts in update-intensive workload scenarios. On this basis, we identify the drawbacks of existing research and propose two lightweight improvements. Extensive evaluations on synthetic data and Redis show that our lightweight improvements yield better performance than fork, the current industrial standard, and the representative snapshot algorithms from academia. Finally, we have opensourced the implementation of all the above snapshot algorithms so that practitioners are able to benchmark the performance of each algorithm and select proper methods for different application scenarios.

A cooperative partial snapshot algorithm for checkpoint‐rollback recovery of large‐scale and dynamic distributed systems and experimental evaluations

SummaryA distributed system consisting of a huge number of computational entities is prone to faults because faults in a few nodes cause the entire system to fail. Consequently, fault tolerance of distributed systems is a critical issue. Checkpoint‐rollback recovery is a universal and representative technique for fault tolerance; it periodically records the entire system state (configuration) to non‐volatile storage, and the system restores itself using the recorded configuration when the system fails. To record a configuration of a distributed system, a specific algorithm known as a snapshot algorithm is required. However, many snapshot algorithms require coordination among all nodes in the system; thus, frequent executions of snapshot algorithms require unacceptable communication cost, especially if the systems are large. As a sophisticated snapshot algorithm, a partial snapshot algorithm has been introduced that takes a partial snapshot (instead of a global snapshot). However, if two or more partial snapshot algorithms are concurrently executed, and their snapshot domains overlap, they should coordinate, so that the partial snapshots (taken by the algorithms) are consistent. In this paper, we propose a new efficient partial snapshot algorithm with the aim of reducing communication for the coordination. In a simulation, we show that the proposed algorithm drastically outperforms the existing partial snapshot algorithm, in terms of message and time complexity.

Efficient Hybrid Data Dissemination for Edge-Assisted Automated Driving

Automatic driving services have large volume, location-aware, and time-changing contents, which are suitable to be cached by the edge. However, the traffic on the edge will be extremely high especially in the area with high vehicle density, if the vehicles directly access the contents from the edge as they demand. A hybrid data dissemination model with both vehicle-to-vehicle (V2V) and vehicle-to-infrastructure (V2I) disseminations has been proposed to reduce the traffic on the edge, in which the edge (infrastructure) selectively injects data to the vehicles and leverages the vehicle network to disseminate the data. In this article, we study the hybrid data dissemination problem, i.e., to optimally determine when and which vehicle the data are injected into, and whether the vehicle acquires the demanded data directly from the edge or from nearby neighbors, with the aim of minimizing the traffic cost on the edge and meeting the deadlines of acquiring the data. Existing approach prioritizes the selection of V2I disseminations at first and then explores the V2V disseminations which have no conflict with the V2I disseminations. This approach cannot fully take advantage of V2V to reduce the traffic cost on the edge. We propose a new data dissemination algorithm, named the offline algorithm for hybrid data dissemination (OFDD), which seeks the most beneficial V2V broadcasts with priority, and then choose feasible V2I disseminations. Based on OFDD, we develop both the snapshot and prediction-based online algorithms. We follow with extensive simulations to validate the proposed algorithms. The results show that our algorithms significantly outperform the state-of-the-art approaches in terms of data acquisition rate and traffic cost.

Fast estimation of optical properties of pear using a single snapshot technique combined with a least-squares support vector regression model based on spatial frequency domain imaging.

Spatial frequency domain imaging has great potential in agricultural produce quality control due to its advantage of wide-field mapping of absorption (μa) and reduced scattering (μs') parameters. However, it is not widely adopted in real applications due to the large time cost during image acquisition and inversion calculation processes. In this study, a single snapshot technique was used to obtain ac and dc components (Rd_ac, Rd_dc) of diffuse reflectance of turbid media (phantoms and pears). The validation results for the snapshot method indicate that at the spatial frequency of 1000/3 m-1, it achieved the optimal demodulation, by comparison with the results obtained by the commonly used time-domain amplitude demodulation method. Diffusion approximation, artificial neural network, least-squares support vector machine regression (LSSVR), and LSSVR combined with a genetic algorithm (LSSVR+GA) were then used to predict μa and μs' from the obtained Rd_ac, Rd_dc at the fx of 1000/3 m-1. Validation results indicated that the LSSVR method took the least time to calculate μa and μs' with high performance. The proposed imaging system and algorithm were implemented for the inspection of a pear bruise. Results indicated that the bruise, which is not obviously distinguishable in original gray maps, can show obvious contrast in calculated μa and μs' maps, especially in μa maps. Further, the contrast becomes more obvious with the passage of time. In summary, this study developed a low-cost spatial frequency imaging system and matching software that could realize fast detection of optical properties for a pear with the proposed snapshot and LSSVR algorithms.

A More Faithful Formal Definition of the Desired Property for Distributed Snapshot Algorithms to Model Check the Property

The first distributed snapshot algorithm was invented by Chandy and Lamport: Chandy-Lamport distributed snapshot algorithm (CLDSA). Distributed snapshot algorithms are crucial components to make distributed systems fault tolerant. Such algorithms are extremely important because many modern key software systems are in the form of distributed systems and should be fault tolerant. There are at least two desired properties such algorithms should satisfy: 1) the distributed snapshot reachability property (called the DSR property) and 2) the ability to run concurrently with, but not alter, an underlying distributed system (UDS). This paper identifies subtle errors in a paper on formalization of the DSR property and shows how to correct them. We give a more faithful formal definition of the DSR property; the definition involves two state machines - one state machine M_UDS that formalizes a UDS and the other M_CLDSA that formalizes the UDS on which CLDSA is superimposed (UDS-CLDSA) - and can be used to more precise model checking of the DSR property for CLDSA. We also prove a theorem on equivalence of our new definition and an existing one that only involves M_CLDSA to guarantee the validity of the existing model checking approach. Moreover, we prove the second property, namely that CLDSA does not alter the behaviors of UDS.

Poly-logarithmic adaptive algorithms require revealing primitives

This paper studies the step complexity of adaptive algorithms, depending on the revealing properties of the primitives used, namely, how many processes are revealed when concurrently applying the primitive (in specific situations).When only 0- or 1-revealing primitives are used, e.g., reads, writes, test&set, compare&swap and LL/SC, then for any collect algorithm there is an execution in which k processes collectively perform Ω(k2) steps, provided k∈O(loglogn). This implies that any adaptive collect algorithm has an Ω(k) amortized (and hence, worst-case) step complexity in an execution with total contention k∈O(loglogn). The lower bound applies for snapshot and renaming, both one-shot and long-lived. While there are snapshot algorithms whose step complexity is polylogarithmic in n using only reads and writes, there is no adaptive algorithm whose step complexity is polylogarithmic in the contention, even when compare&swap and LL/SC are used.Primitives like fetch&inc are more revealing, and using them admits snapshot algorithms with O(logk) step complexity, where k is the total or the point contention. These algorithms combine a renaming algorithm with a mechanism for propagating values so they can be quickly collected.The main implication of these results is that the step complexity of adaptive algorithms depends on the revealing power of the primitives used. Even conditional primitives that allow to solve consensus for any number of processes, like compare&swap and LL/SC, do not improve the step complexity of adaptive algorithms.

A study of mutable checkpointing and related algorithms

Mutable Checkpointing algorithms (MC), [7] , [8] , [9] , stand for snapshot algorithms that take checkpoints of processes with causally induced dependencies to the initiating process, only. They classify as coordinated snapshot algorithms with communication induced checkpointing. To specify and verify such algorithms formally, we introduce a formal framework in which their operational semantics can easily be expressed. Within this framework correctness of the algorithms follows from an invariant which explains how snapshots are incrementally built up. For MC and the related blocking queue algorithms of [26] , [27] some adaptations are required as they take a partial snapshot, only. However, both can be proven in the given framework and in this way we equip them with a direct, constructive consistency proof.

On fault detection and exclusion in snapshot and recursive positioning algorithms for maritime applications

Introduction Resilient provision of Position, Navigation and Timing (PNT) data can be considered as a key element of the e-Navigation strategy developed by the International Maritime Organization (IMO). An indication of reliability has been identified as a high level user need with respect to PNT data to be supplied by electronic navigation means. The paper concentrates on the Fault Detection and Exclusion (FDE) component of the Integrity Monitoring (IM) for navigation systems based both on pure GNSS (Global Navigation Satellite Systems) as well as on hybrid GNSS/inertial measurements. Here a PNT-data processing Unit will be responsible for both the integration of data provided by all available on-board sensors as well as for the IM functionality. The IM mechanism can be seen as an instantaneous decision criterion for using or not using the system and, therefore, constitutes a key component within a process of provision of reliable navigational data in future navigation systems. Methods The performance of the FDE functionality is demonstrated for a pure GNSS-based snapshot weighted iterative least-square (WLS) solution, a GNSS-based Extended Kalman Filter (EKF) as well as for a classical error-state tightly-coupled EKF for the hybrid GNSS/inertial system. Pure GNSS approaches are evaluated by combining true measurement data collected in port operation scenario with artificially induced measurement faults, while for the hybrid navigation system the measurement data in an open sea scenario with native GNSS measurement faults have been employed. Results First, the performance of the proposed FDE schemes in terms of the horizontal error is evaluated for both weighted and unweighted approaches in GNSS-based snapshot and KF-based schemes. Here, mainly due to availability of the process model, the KF approaches have demonstrated smaller sensitivity to the injected GNSS faults, while the methods with CNo weighting schemes have resulted in reduced spread of the obtained position solutions. The statistical evaluation of the proposed FDE schemes have been performed for pure GNSS schemes by considering the fault detection rate as a function of the amplitude for the randomly injected GNSS faults. Although the KF-based approaches have clearly outperformed the memoryless schemes, lower detection rates for weighted schemes could be clearly seen due to inability of the FDE to detect faults of fixed amplitude for satellites with lower CNo values. Moreover, the evaluation of the FDE schemes in terms of maximum horizontal position error have indicated bounded response of the FDE schemes when compared to that of non-FDE methods. Finally, the superiority of the FDE-enabled tightly-coupled GNSS/inertial EKF over the non-FDE solution have been demonstrated using a scenario with native GNSS faults. Conclusions The work had successfully demonstrated an applicability of the developed FDE schemes in snapshot and RBE-based algorithms for maritime applications using both non-inertial GNSS-based positioning and a hybrid IMU/GNSS EKF-based approach. The proposed methods form a solid foundation for construction of a more reliable and robust PNT-Unit, where state-of-the-art hybrid navigation algorithms are augmented with integrity monitoring functionality to ensure the system performance in the presence of GNSS faults. The FDE mechanism provides consistent improvements in terms of the horizontal accuracy both in LS and KF-based methods. Although only port operation case and one example of a true GNSS fault in open sea was considered, the presented results are believed to be general enough and the scheme could be adopted for other applications in future.

VAE/MPM/GA Technique for DoA Estimation Using Optimized Antenna Arrays

Many algorithms have been proposed to estimate the direction of arrival for the targets, but through using a large number of snapshots. In real time applications such as automotive radar, this is unacceptable as it causes delay and heavy processing. Instead, if only a small number of snapshots or, optimally, a single snapshot is available for DoA estimation, it will be fast and efficient. Single snapshot algorithms have a drawback as they require a large number of antenna elements, which considered a limiting factor. In this paper, a single snapshot DoA estimation technique is introduced by using optimized antenna arrays. The proposed algorithm is based on utilization of virtual array extension, matrix pencil method, and the genetic algorithm. The use of virtual array extension greatly improves the MPM performance. Furthermore, it exhibits a high DoA estimation accuracy by using a reduced number of antenna elements. The genetic algorithm is employed to determine the minimum number of antenna elements, which are required to estimate the DoAs with minimal root mean square error.

Limited-Use Atomic Snapshots with Polylogarithmic Step Complexity

This article presents a novel implementation of a snapshot object for n processes, with O (log 2 b log n ) step complexity for update operations and O (log b ) step complexity for scan operations, where b is the number of updates. The algorithm uses only reads and writes. For polynomially many updates, this is an exponential improvement on previous snapshot algorithms, which have linear step complexity. It overcomes the existing Ω( n ) lower bound on step complexity by having the step complexity depend on the number of updates. The key to this implementation is the construction of a new object consisting of a pair of max registers that supports a scan operation.

Rilpivirine versus efavirenz with emtricitabine/tenofovir disoproxil fumarate in treatment-naïve HIV-1-infected patients with HIV-1 RNA ≤100,000 copies/mL: week 96 pooled ECHO/THRIVE subanalysis.

The once daily, single-tablet regimen (STR) combining rilpivirine (RPV), emtricitabine (FTC), and tenofovir disoproxil fumarate (TDF) provides a simplified treatment option for antiretroviral therapy (ART)-naïve patients with baseline HIV-1 RNA (BLVL) of ≤100,000 copies/mL. The aim of this analysis is to compare long-term efficacy, safety, and tolerability of RPV+FTC/TDF vs. efavirenz (EFV)+FTC/TDF as individual components in subjects with BLVL ≤100,000 copies/mL. Week 96 efficacy and safety data from subjects with BLVL ≤100,000 copies/mL, who received daily RPV 25 mg or EFV 600 mg with FTC/TDF in the phase 3, randomized, double-blind, double-dummy, active-controlled, registrational trials ECHO and THRIVE, were analyzed. Virologic response was evaluated by intent-to-treat, time to loss of virological response (ITT-TLOVR), and Snapshot algorithms. Through Week 96, RPV+FTC/TDF demonstrated non-inferior efficacy to EFV+FTC/TDF (84% vs. 81%, respectively; ITT-TLOVR) in 543 subjects with BLVL ≤100,000 copies/mL, and overall rates of virologic failure (VF) were 5.9% vs. 2.4%, respectively. Resistance development was lower in Year 2 than Year 1. Subjects in both arms with suboptimal adherence (≤95%) had lower virologic responses (63% vs. 62%, respectively). Treatment with RPV+FTC/TDF was associated with significantly fewer treatment-related adverse events (AEs), grade 2-4 AEs, neurological and psychiatric AEs (including dizziness and abnormal dreams/nightmares), and rash. Additionally, grade 2-4 treatment-emergent laboratory abnormalities and grade 1-3 lipid abnormalities were significantly less common with RPV+FTC/TDF than EFV+FTC/TDF. RPV+FTC/TDF demonstrated non-inferior efficacy to EFV+FTC/TDF in ART-naïve subjects with BLVL ≤100,000 copies/mL and was associated with a higher rate of VF but a more favorable safety and tolerability profile through Week 96.

Revisiting snapshot algorithms by refinement-based techniques

The snapshot problem addresses a collection of important algorithmic issues related to distributed computations, which are used for debugging or recovering distributed programs. Among existing solutions, Chandy and Lamport have proposed a simple distributed algorithm. In this paper, we explore the correct-byconstruction process to formalize the snapshot algorithms in distributed system. The formalization process is based on a modeling language Event B, which supports a refinement-based incremental development using RODIN platform. These refinement-based techniques help to derive correct distributed algorithms. Moreover, we demonstrate how other distributed algorithms can be revisited. A consequence is to provide a fully mechanized proof of the resulting distributed algorithms.

Message efficient global snapshot recording using a self stabilizing spanning tree in a MANET

Distributed snapshots are a significant paradigm for distributed systems. These are applied for constructing checkpoint protocols, apart from investigating, testing, or proving properties in distributed executions such as deadlocks and termination. Though a number of snapshot algorithms exist for traditional distributed systems, they cannot be directly applied to mobile ad hoc networks due to the constraints of topology and hostile conditions in which the MANETs operate. The paper presents an algorithm for recording the global state of a clustered and multi-hop mobile ad hoc network. The proposed algorithm imposes a self stabilizing spanning tree upon the network topology to reduce the message overhead in the system due to the algorithm and to deal with the dynamic nature of MANETs. Moreover, the protocol handles concurrent snapshot initiation and does not require FIFO channels. The message complexity of snapshot recording is O(n-1) where n is the number of clusters in the system

Detecting Locally Distributed Predicates

In this article, we formalize locally distributed predicates , a concept previously introduced to address specific challenges associated with modular robotics and distributed debugging. A locally distributed predicate (LDP) is a novel construction for representing and detecting distributed properties in sparse-topology systems. Our previous work on LDPs presented empirical validation; here we show a formal model for two variants of the LDP algorithm, LDP-Basic and LDP-Snapshot, and establish performance bounds for these variants. We prove that LDP-Basic can detect strong stable predicates, that LDP-Snapshot can detect all stable predicates, and discuss their applicability to various distributed programming domains and to spatial computing in general. LDP detection in bounded-degree networks is shown to be scale-free, making the approach particularly attractive for specific topologies, even though LDPs are less efficient than snapshot algorithms in general distributed systems.

Distributed snapshots for ad hoc network systems

Snapshot algorithms are fundamental algorithms in recording consistent global states of a distributed system. They find a large class of important applications such as monitoring and debugging of distributed systems and detection of stable properties (e.g. deadlock, termination and loss of tokens). Unfortunately, most existing snapshot algorithms were designed for static network systems and cellular systems only. They cannot be applied directly in recent emerging ad hoc network systems, which usually have no fixed infrastructure and may experience dynamic topology changes in the mid of execution. This paper presents a snapshot algorithm that can work in an ad hoc network system. Compared to the traditional snapshot algorithms, the proposed algorithm can guarantee both the causal consistency and the topological consistency. Simple methods are also discussed to reduce logged system states and exchanged message timestamps when applying the algorithm.

A comparison of the FDA TLOVR and FDA Snapshot algorithms based on studies evaluating once‐daily vs. twice daily lopinavir/ritonavir (LPV/r) regimens

7‐11 November 2010, Tenth International Congress on Drug Therapy in HIV Infection, Glasgow, UK

Fast and Message-Efficient Global Snapshot Algorithms for Large-Scale Distributed Systems

Large-scale distributed systems such as supercomputers and peer-to-peer systems typically have a fully connected logical topology over a large number of processors. Existing snapshot algorithms in such systems have high response time and/or require a large number of messages, typically O(n2), where n is the number of processes. In this paper, we present a suite of two algorithms: simple_tree, and hypercube, that are both fast and require a small number of messages. This makes the algorithms highly scalable. Simple_tree requires O(n) messages and has O(log n) response time. Hypercube requires O(n log n) messages and has O(log n) response time, in addition to having the property that the roles of all the processes are symmetrical. Process symmetry implies greater potential for balanced workload and congestion-freedom. All the algorithms assume non-FIFO channels.