Efficient synchronization of multiprocessors with shared memory
ACM Transactions on Programming Languages and Systems (TOPLAS)
Linearizability: a correctness condition for concurrent objects
ACM Transactions on Programming Languages and Systems (TOPLAS)
ACM Transactions on Programming Languages and Systems (TOPLAS)
Fault-tolerant wait-free shared objects
Journal of the ACM (JACM)
Distributed Algorithms
Building secure file systems out of byzantine storage
Proceedings of the twenty-first annual symposium on Principles of distributed computing
Obstruction-Free Synchronization: Double-Ended Queues as an Example
ICDCS '03 Proceedings of the 23rd International Conference on Distributed Computing Systems
Distributed Computing
Secure untrusted data repository (SUNDR)
OSDI'04 Proceedings of the 6th conference on Symposium on Opearting Systems Design & Implementation - Volume 6
Abortable and query-abortable objects and their efficient implementation
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Efficient fork-linearizable access to untrusted shared memory
Proceedings of the twenty-sixth annual ACM symposium on Principles of distributed computing
Proceedings of the twentieth annual symposium on Parallelism in algorithms and architectures
Timeliness-based wait-freedom: a gracefully degrading progress condition
Proceedings of the twenty-seventh ACM symposium on Principles of distributed computing
On the Time-Complexity of Robust and Amnesic Storage
OPODIS '08 Proceedings of the 12th International Conference on Principles of Distributed Systems
Integrity Protection for Revision Control
ACNS '09 Proceedings of the 7th International Conference on Applied Cryptography and Network Security
Abortable Fork-Linearizable Storage
OPODIS '09 Proceedings of the 13th International Conference on Principles of Distributed Systems
Venus: verification for untrusted cloud storage
Proceedings of the 2010 ACM workshop on Cloud computing security workshop
SPORC: group collaboration using untrusted cloud resources
OSDI'10 Proceedings of the 9th USENIX conference on Operating systems design and implementation
Dynamic atomic storage without consensus
Journal of the ACM (JACM)
Integrity and consistency for untrusted services
SOFSEM'11 Proceedings of the 37th international conference on Current trends in theory and practice of computer science
Beyond one-third faulty replicas in byzantine fault tolerant systems
NSDI'07 Proceedings of the 4th USENIX conference on Networked systems design & implementation
SIAM Journal on Computing
How hard is it to take a snapshot?
SOFSEM'05 Proceedings of the 31st international conference on Theory and Practice of Computer Science
SP 800-145. The NIST Definition of Cloud Computing
SP 800-145. The NIST Definition of Cloud Computing
Hi-index | 0.00 |
Users increasingly execute services online at remote providers, but they may have security concerns and not always trust the providers. Fork-consistent emulations offer one way to protect the clients of a remote service, which is usually correct but may suffer from Byzantine faults. They feature linearizability as long as the service behaves correctly, and gracefully degrade to fork-consistent semantics in case the service becomes faulty. This guarantees data integrity and service consistency to the clients. All currently known fork-consistent emulations require the execution of non-trivial computation steps by the service. From a theoretical viewpoint, such a service constitutes a read-modify-write object, representing the strongest object in Herlihy's wait-free hierarchy [1]. A read-modify-write object is much more powerful than a shared memory made of so-called registers, which lie in the weakest class of all shared objects in this hierarchy. In practical terms, it is important to reduce the complexity and cost of a remote service implementation as computation resources are typically more expensive than storage resources. In this paper, we address the fundamental structure of a fork-consistent emulation and ask the question: Can one provide a fork-consistent emulation in which the service does not execute computation steps, but can be realized only by a shared memory? Surprisingly, the answer is yes. Specifically, we provide two such algorithms that can be built only from registers: A fork-linearizable construction of a universal type, in which operations are allowed to abort under concurrency, and a weakly fork-linearizable emulation of a shared memory that ensures wait-freedom when the registers are correct.