A snapshot object simulates the behavior of an array of single-writer/multi-reader shared registers that can be read atomically. Delporte-Gallet et al. proposed two fault-tolerant algorithms for snapshot objects in asynchronous crash-prone message-passing systems. Their first algorithm is non-blocking; it allows snapshot operations to terminate once all write operations have ceased. It uses O(n) messages of O(nν) bits, where n is the number of nodes and ν is the number of bits it takes to represent the object. Their second algorithm allows snapshot operations to always terminate independently of write operations. It incurs
Nearby in the stack
O(n2)
messages. The fault model of Delporte-Gallet et al. considers node crashes. We aim at the design of even more robust snapshot objects via the lenses of self-stabilization---a very strong notion of fault-tolerance. In addition to Delporte-Gallet et al.'s fault model, our self-stabilizing algorithm can recover after the occurrence of transient faults; these faults represent arbitrary violations of the assumptions according to which the system was designed to operate. We propose self-stabilizing variations of Delporte-Gallet et al.'s non-blocking algorithm and always-terminating algorithm. Our algorithms have similar communication costs to the ones by Delporte-Gallet et al. and
O(1)
recovery time from transient faults. The main differences are that our proposal considers repeated gossiping of
O(ν)
bit messages and deals with bounded space. We also consider an input parameter,
δ
, for which we claim an ability to balance the costs of snapshot operations. We validate our correctness proof, evaluate the performance of Delporte-Gallet et al.'s algorithms and our proposed variations and investigate the properties of
δ
via PlanetLab experiments, where significant latency and communication costs reduction are observed.