Efficient parallel algorithms can be made robust
Proceedings of the eighth annual ACM Symposium on Principles of distributed computing
ACM Transactions on Programming Languages and Systems (TOPLAS)
Combining tentative and definite executions for very fast dependable parallel computing
STOC '91 Proceedings of the twenty-third annual ACM symposium on Theory of computing
Parallel algorithms with processor failures and delays
Journal of Algorithms
Algorithms for the Certified Write-All Problem
SIAM Journal on Computing
Fault-Tolerant Parallel Computation
Fault-Tolerant Parallel Computation
Waitfree distributed memory management by Create, and Read Until Deletion (CRUD)
Waitfree distributed memory management by Create, and Read Until Deletion (CRUD)
Towards practical deteministic write-all algorithms
Proceedings of the thirteenth annual ACM symposium on Parallel algorithms and architectures
The Complexity of Synchronous Iterative Do-All with Crashes
DISC '01 Proceedings of the 15th International Conference on Distributed Computing
distributed cooperation and adversity: complexity trade-offs
PCK50 Proceedings of the Paris C. Kanellakis memorial workshop on Principles of computing & knowledge: Paris C. Kanellakis memorial workshop on the occasion of his 50th birthday
Split-ordered lists: lock-free extensible hash tables
Proceedings of the twenty-second annual symposium on Principles of distributed computing
A work-optimal deterministic algorithm for the asynchronous certified write-all problem
Proceedings of the twenty-second annual symposium on Principles of distributed computing
Deterministic computations on a PRAM with static processor and memory faults
Fundamenta Informaticae
Hundreds of impossibility results for distributed computing
Distributed Computing - Papers in celebration of the 20th anniversary of PODC
Writing-all deterministically and optimally using a non-trivial number of asynchronous processors
Proceedings of the sixteenth annual ACM symposium on Parallelism in algorithms and architectures
The complexity of synchronous iterative Do-All with crashes
Distributed Computing
A tight analysis and near-optimal instances of the algorithm of Anderson and Woll
Theoretical Computer Science
Lock-free dynamic hash tables with open addressing
Distributed Computing - Special issue: PODC 02
Split-ordered lists: Lock-free extensible hash tables
Journal of the ACM (JACM)
The Do-All problem with Byzantine processor failures
Theoretical Computer Science - Foundations of software science and computation structures
Lock-free parallel and concurrent garbage collection by mark&sweep
Science of Computer Programming
Writing-all deterministically and optimally using a nontrivial number of asynchronous processors
ACM Transactions on Algorithms (TALG)
At-most-once semantics in asynchronous shared memory
Proceedings of the twenty-first annual symposium on Parallelism in algorithms and architectures
At-most-once semantics in asynchronous shared memory
DISC'09 Proceedings of the 23rd international conference on Distributed computing
Simple concurrent garbage collection almost without synchronization
Formal Methods in System Design
Asynchronous perfectly secure communication over one-time pads
ICALP'05 Proceedings of the 32nd international conference on Automata, Languages and Programming
Solving the at-most-once problem with nearly optimal effectiveness
ICDCN'12 Proceedings of the 13th international conference on Distributed Computing and Networking
Deterministic Computations on a PRAM with Static Processor and Memory Faults
Fundamenta Informaticae
The strong at-most-once problem
DISC'12 Proceedings of the 26th international conference on Distributed Computing
Hi-index | 0.00 |
The problem of using P processes to write a given value to all positions of a shared array of size N is called the Write-All problem. We present and analyze an asynchronous algorithm with work complexity O(NċPlog(x+1)/x)), where x N1/log(P) (assuming N = xk and P = 2k). Our algorithm is a generalization of the naive two-processor algorithm where the two processes each start at one side of the array and walk towards each other until they collide.