Abstract
An atomic snapshot object is an object that can be concurrently accessed by asynchronous processes prone to crash. It is made of m components (base atomic registers) and is defined by two operations: an update operation that allows a process to atomically assign a new value to a component and a snapshot operation that atomically reads and returns the values of all the components. To cope with the net effect of concurrency, asynchrony and failures, the algorithm implementing the update operation has to help concurrent snapshot operations so that they always terminate.
This paper is on partial snapshot objects. Such an object provides a snapshot operation that can take any subset of the components as input parameter, and atomically reads and returns the values of this subset of components. The paper has two contributions. The first is the introduction of two properties for partial snapshot object algorithms, called help-locality and freshness. Help-locality requires that an update operation helps only the concurrent partial snapshot operations that read the component it writes. When an update of a component r helps a partial snapshot, freshness requires that the update provides the partial snapshot with a value of the component r that is at least as recent as the value it writes into that component. (No snapshot algorithm proposed so far satisfies these properties.) The second contribution consists of an update and a partial snapshot algorithms that are wait-free, linearizable and satisfy the previous efficiency properties. Interestingly, the principle that underlies the proposed algorithms is different from the one used so far, namely, it is based on the “write first, and help later” strategy. An improvement of the previous algorithms is also presented. Based on LL/SC atomic registers (instead of read/write registers) this improvement decreases the number of base registers from O(n 2) to O(n). This shows an interesting tradeoff relating the synchronization power of the base operations and the number of base atomic registers when using the “write first, and help later” strategy.
This is a preview of subscription content, log in via an institution to check access.
Access this chapter
Tax calculation will be finalised at checkout
Purchases are for personal use only
Preview
Unable to display preview. Download preview PDF.
References
Afek, Y., Attiya, H., Dolev, D., Gafni, E., Merritt, M., Shavit, N.: Atomic Snapshots of Shared Memory. Journal of the ACM 40(4), 873–890 (1993)
Afek, Y., Stupp, G., Touitou, D.: Long-lived Adaptive Collect with Applications. In: Proc. 40th IEEE Symposium on Foundations of Computer Science Computing (FOCS 1999), pp. 262–272. IEEE Computer Society Press, Los Alamitos (1999)
Aguilera, M.K.: A Pleasant Stroll Through the Land of Infintely Many Creatures. ACM Sigact News, Distributed Computing Column 35(2), 36–59 (2004)
Anderson, J.: Composite Registers. In: Proc. 9th ACM Symp. on Principles of Distributed Computing (PODC 1990), pp. 15–29 (1990)
Anderson, J.: Multi-writer Composite Registers. Distributed Computing 7(4), 175–195 (1994)
Attiya, H.: Needed: Foundations for Transactional Memory. ACM SIGACT News 39(1), 59–61 (2008)
Attiya, H., Fouren, A.: Algorithms Adapting to Contention Point. Journal of the ACM 50(4), 444–468 (2003)
Attiya, H., Fouren, A., Gafni, E.: An Adaptive Collect Algorithm with Applications. Distributed Computing 15, 87–96 (2002)
Attiya, H., Guerraoui, R., Ruppert, E.: Partial Snapshot Objects. In: Proc. 20th ACM Symposium on Parallel Architectures and Algorithms (SPAA 2008), pp. 336–343. ACM Press, New York (2008)
Attiya, H., Rachman, O.: Atomic Snapshot in O(nlogn) Operations. SIAM J. of Comp. 27(2), 319–340 (1998)
Attiya, H., Welch, J.: Distributed Computing: Fundamentals, Simulations and Advanced Topics, 2nd edn., p. 414. Wiley Interscience, Hoboken (2004)
Chandy, K.M., Lamport, L.: Distributed Snapshots: Determining Global States of Distributed Systems. ACM Transactions on Computer Systems 3(1), 63–75 (1985)
Ellen, F.: How hard is it to take a snapshot? In: Vojtáš, P., Bieliková, M., Charron-Bost, B., Sýkora, O. (eds.) SOFSEM 2005. LNCS, vol. 3381, pp. 28–37. Springer, Heidelberg (2005)
Felber, P., Fetzer, C., Guerraoui, R., Harris, T.: Transactions Are Back–But Are They the Same? ACM SIGACT News 39(1), 47–58 (2008)
Guerraoui, R., Kapałka, M.: On the Correctness of Transactional Memory. In: Proc. 13th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming (PPoPP 2008), pp. 175–184. ACM Press, New York (2008)
Guerraoui, R., Raynal, M.: From unreliable objects to reliable objects: The case of atomic registers and consensus. In: Malyshkin, V.E. (ed.) PaCT 2007. LNCS, vol. 4671, pp. 47–61. Springer, Heidelberg (2007)
Herlihy, M.P.: Wait-Free Synchronization. ACM Trans. on Progr. Lang. and Systems 13(1), 124–149 (1991)
Herlihy, M.P., Shavit, N.: The Art of Mutiprocessor Programming, 508 pages. Morgan Kaufmann Pub., San Francisco (2008)
Herlihy, M.P., Luchangco, V.: Distributed Computing and the Multicore Revolution. ACM SIGACT News 39(1), 62–72 (2008)
Herlihy, M.P., Wing, J.M.: Linearizability: a Correctness Condition for Concurrent Objects. ACM Transactions on Programming Languages and Systems 12(3), 463–492 (1990)
Imbs, D., Raynal, M.: A lock-based STM protocol that satisfies opacity and progressiveness. In: Baker, T.P., Bui, A., Tixeuil, S. (eds.) OPODIS 2008. LNCS, vol. 5401, pp. 226–245. Springer, Heidelberg (2008)
Imbs, D., Raynal, M.: Help when needed, but no more: Efficient Read/Write Partial Snapshot. Tech Report # 1907, 24 pages; IRISA, Université de Rennes, France (2008)
Inoue, I., Chen, W., Masuzawa, T., Tokura, N.: Linear Time Snapshots Using Multi-writer Multi-reader Registers. In: Tel, G., Vitányi, P.M.B. (eds.) WDAG 1994. LNCS, vol. 857, pp. 130–140. Springer, Heidelberg (1994)
Israeli, A., Rappoport, L.: Disjoint-Access-Parallel Implementations of Strong Shared Memory Primitives. In: Proc. 13th ACM Symposium on Principles of Distributed Computing (PODC 1994), pp. 151–160 (1994)
Jayanti, P.: An Optimal Multiwriter Snapshot Algorithm. In: Proc. 37th ACM Symposium on Theory of Computing (STOCS 2005), pp. 723–732. ACM Press, New York (2005)
Lynch, N.A.: Distributed Algorithms, 872 pages. Morgan Kaufmann Pub., San Francisco (1996)
Moir, M.: Practical Implementation of Non-Blocking Synchronization Primitives. In: Proc. 16th ACM Symposium on Principles of Distributed Computing (PODC 1997), pp. 219–228. ACM Press, New York (1997)
Shavit, N., Touitou, D.: Software Transactional Memory. Distributed Computing 10(2), 99–116 (1997)
Taubenfeld, G.: Synchronization Algorithms and Concurrent Programming, 423 pages. Pearson Prentice-Hall, London (2006)
Author information
Authors and Affiliations
Editor information
Editors and Affiliations
Rights and permissions
Copyright information
© 2009 Springer-Verlag Berlin Heidelberg
About this paper
Cite this paper
Imbs, D., Raynal, M. (2009). Help When Needed, But No More: Efficient Read/Write Partial Snapshot. In: Keidar, I. (eds) Distributed Computing. DISC 2009. Lecture Notes in Computer Science, vol 5805. Springer, Berlin, Heidelberg. https://doi.org/10.1007/978-3-642-04355-0_16
Download citation
DOI: https://doi.org/10.1007/978-3-642-04355-0_16
Publisher Name: Springer, Berlin, Heidelberg
Print ISBN: 978-3-642-04354-3
Online ISBN: 978-3-642-04355-0
eBook Packages: Computer ScienceComputer Science (R0)