Atomic Snapshots from Small Registers

Authors Leqi Zhu, Faith Ellen

Thumbnail PDF


  • Filesize: 469 kB
  • 16 pages

Document Identifiers

Author Details

Leqi Zhu
Faith Ellen

Cite AsGet BibTex

Leqi Zhu and Faith Ellen. Atomic Snapshots from Small Registers. In 19th International Conference on Principles of Distributed Systems (OPODIS 2015). Leibniz International Proceedings in Informatics (LIPIcs), Volume 46, pp. 17:1-17:16, Schloss Dagstuhl – Leibniz-Zentrum für Informatik (2016)


Existing n-process implementations of atomic snapshots from registers use large registers. We consider the problem of implementing an m-component snapshot from small, Theta(log(n))-bit registers. A natural solution is to consider simulating the large registers. Doing so straightforwardly can significantly increase the step complexity. We introduce the notion of an interruptible read and show how it can reduce the step complexity of simulating the large registers in the snapshot of Afek et al. In particular, we show how to modify a recent large register simulation to support interruptible reads. Using this modified simulation, the step complexity of UPDATE and SCAN changes from Theta(n*m) to Theta(n*m+m*w), instead of Theta(n*m*w), if each component of the snapshot consists of Theta(w*log(n)) bits. We also show how to modify a limited-use snapshot to use small registers when the number of UPDATE operations is in n^{O(1)}. In this case, we change the step complexity of UPDATE from Theta((log(n))^3) to O(w + (log(n))^2*log(m)) and the step complexity of SCAN from Theta(log(n)) to O(m*w + log(n)).
  • atomic snapshot
  • limited-use snapshot
  • small registers
  • simulation


  • Access Statistics
  • Total Accesses (updated on a weekly basis)
    PDF Downloads


  1. Yehuda Afek, Hagit Attiya, Danny Dolev, Eli Gafni, Michael Merritt, and Nir Shavit. Atomic snapshots of shared memory. Journal of the ACM, 40(4):873-890, 1993. Google Scholar
  2. Zahra Aghazadeh, Wojciech Golab, and Philipp Woelfel. Making objects writable. In Proceedings of the Thirty-Third ACM Symposium on Principles of Distributed Computing (PODC), pages 385-395, 2014. Google Scholar
  3. James Aspnes, Hagit Attiya, and Keren Censor-Hillel. Polylogarithmic concurrent data structures from monotone circuits. Journal of the ACM, 59(1):2:1-2:24, 2012. Google Scholar
  4. James Aspnes, Hagit Attiya, Keren Censor-Hillel, and Faith Ellen. Limited-use atomic snapshots with polylogarithmic step complexity. Journal of the ACM, 62(1):3:1-3:22, 2015. Google Scholar
  5. Hagit Attiya, Rachid Guerraoui, and Eric Ruppert. Partial snapshot objects. In Proceedings of the Twentieth Annual ACM Symposium on Parallelism in Algorithms and Architectures (SPAA), pages 336-343, 2008. Google Scholar
  6. Hagit Attiya, Maurice Herlihy, and Ophir Rachman. Atomic snapshots using lattice agreement. Distributed Computing, 8(3):121-132, 1995. Google Scholar
  7. Hagit Attiya and Ophir Rachman. Atomic snapshots in O(n log n) operations. In Proceedings of the Twelfth Annual ACM Symposium on Principles of Distributed Computing (PODC), pages 29-40, 1993. Google Scholar
  8. Maurice P. Herlihy and Jeannette M. Wing. Linearizability: A correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems, 12(3):463-492, 1990. Google Scholar
  9. Michiko Inoue, Toshimitsu Masuzawa, Wei Chen, and Nobuki Tokura. Linear-time snapshot using multi-writer multi-reader registers. In Proceedings of the Eighth International Workshop on Distributed Algorithms (WDAG), pages 130-140, 1994. Google Scholar
  10. Gary L. Peterson. Concurrent reading while writing. ACM Transactions on Programming Languages and Systems, 5(1):46-55, 1983. Google Scholar