Results 1  10
of
15
Optimal resilient sorting and searching in the presence of memory faults
 IN PROC. 33RD INTERNATIONAL COLLOQUIUM ON AUTOMATA, LANGUAGES AND PROGRAMMING, VOLUME 4051 OF LECTURE NOTES IN COMPUTER SCIENCE
, 2006
"... We investigate the problem of reliable computation in the presence of faults that may arbitrarily corrupt memory locations. In this framework, we consider the problems of sorting and searching in optimal time while tolerating the largest possible number of memory faults. In particular, we design an ..."
Abstract

Cited by 17 (5 self)
 Add to MetaCart
We investigate the problem of reliable computation in the presence of faults that may arbitrarily corrupt memory locations. In this framework, we consider the problems of sorting and searching in optimal time while tolerating the largest possible number of memory faults. In particular, we design an O(n log n) time sorting algorithm that can optimally tolerate up to O ( √ n log n) memory faults. In the special case of integer sorting, we present an algorithm with linear expected running time that can tolerate O ( √ n) faults. We also present a randomized searching algorithm that can optimally tolerate up to O(log n) memory faults in O(log n) expected time, and an almost optimal deterministic searching algorithm that can tolerate O((log n) 1−ǫ) faults, for any small positive constant ǫ, in O(log n) worstcase time. All these results improve over previous bounds.
Priority queues resilient to memory faults
 IN: PROC. 10TH INTERNATIONAL WORKSHOP ON ALGORITHMS AND DATA STRUCTURES
, 2007
"... In the faultymemory RAM model, the content of memory cells can get corrupted at any time during the execution of an algorithm, and a constant number of uncorruptible registers are available. A resilient data structure in this model works correctly on the set of uncorrupted values. In this paper w ..."
Abstract

Cited by 13 (5 self)
 Add to MetaCart
In the faultymemory RAM model, the content of memory cells can get corrupted at any time during the execution of an algorithm, and a constant number of uncorruptible registers are available. A resilient data structure in this model works correctly on the set of uncorrupted values. In this paper we introduce a resilient priority queue. The deletemin operation of a resilient priority queue returns either the minimum uncorrupted element or some corrupted element. Our resilient priority queue uses O(n) space to store n elements. Both insert and deletemin operations are performed in O(log n + δ) time amortized, where δ is the maximum amount of corruptions tolerated. Our priority queue matches the performance of classical optimal priority queues in the RAM model when the number of corruptions tolerated is O(log n). We prove matching worst case lower bounds for resilient priority queues storing only structural information in the uncorruptible registers between operations.
Optimal resilient dynamic dictionaries
 IN PROCEEDINGS OF 15TH EUROPEAN SYMPOSIUM ON ALGORITHMS (ESA
, 2007
"... We investigate the problem of computing in the presence of faults that may arbitrarily (i.e., adversarially) corrupt memory locations. In the faulty memory model, any memory cell can get corrupted at any time, and corrupted cells cannot be distinguished from uncorrupted ones. An upper bound δ on the ..."
Abstract

Cited by 12 (8 self)
 Add to MetaCart
(Show Context)
We investigate the problem of computing in the presence of faults that may arbitrarily (i.e., adversarially) corrupt memory locations. In the faulty memory model, any memory cell can get corrupted at any time, and corrupted cells cannot be distinguished from uncorrupted ones. An upper bound δ on the number of corruptions and O(1) reliable memory cells are provided. In this model, we focus on the design of resilient dictionaries, i.e., dictionaries which are able to operate correctly (at least) on the set of uncorrupted keys. We first present a simple resilient dynamic search tree, based on random sampling, with O(log n+δ) expected amortized cost per operation, and O(n) space complexity. We then propose an optimal deterministic static dictionary supporting searches in Θ(log n+δ) time in the worst case, and we show how to use it in a dynamic setting in order to support updates in O(log n + δ) amortized time. Our dynamic dictionary also supports range queries in O(log n+δ+t) worst case time, where t is the size of the output. Finally, we show that every resilient search tree (with some reasonable properties) must take Ω(log n + δ) worstcase time per search.
Checking and spotchecking the correctness of priority queues
 In Proceedings of 34th International Colloquium on Automata, Languages and Programming, volume 4596 of Lecture notes in Computer Science
, 2007
"... Abstract. We revisit the problem of memory checking considered by Blum et al. [3]. In this model, a checker monitors the behavior of a data structure residing in unreliable memory given an arbitrary sequence of user defined operations. The checker is permitted a small amount of separate reliable mem ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
(Show Context)
Abstract. We revisit the problem of memory checking considered by Blum et al. [3]. In this model, a checker monitors the behavior of a data structure residing in unreliable memory given an arbitrary sequence of user defined operations. The checker is permitted a small amount of separate reliable memory and must fail a data structure if it is not behaving as specified and pass it otherwise. How much additional reliable memory is required by the checker? First, we present a checker for an implementation of a priority queue. The checker uses O ( √ n log n) space where n is the number of operations performed. We then present a spotchecker using only O(ɛ −1 log δ −1 log n) space, that, with probability at least 1−δ, will fail the priority queue if it is ɛfar (defined appropriately) from operating like a priority queue and pass the priority queue if it operates correctly. Finally, we then prove a range of lower bounds that complement our checkers. 1
Resilient dictionaries
 ACM Transactions on Algorithms
"... We address the problem of designing data structures in the presence of faults that may arbitrarily corrupt memory locations. More precisely, we assume that an adaptive adversary can arbitrarily overwrite the content of up to δ memory locations, that corrupted locations cannot be detected, and that o ..."
Abstract

Cited by 7 (3 self)
 Add to MetaCart
We address the problem of designing data structures in the presence of faults that may arbitrarily corrupt memory locations. More precisely, we assume that an adaptive adversary can arbitrarily overwrite the content of up to δ memory locations, that corrupted locations cannot be detected, and that only O(1) memory locations are safe. In this framework, we call a data structure resilient if it is able to operate correctly (at least) on the set of uncorrupted values. We present a resilient dictionary, implementing search, insert and delete operations. Our dictionary has O(log n + δ) expected amortized time per operation, and O(n) space complexity, where n denotes the current number of keys in the dictionary. We also describe a deterministic resilient dictionary, with the same amortized cost per operation over a sequence of at least δ ǫ operations, where ǫ> 0 is an arbitrary constant. Finally, we show that any resilient comparisonbased dictionary must take Ω(log n+δ) expected time per search. Our results are achieved by means of simple, new techniques, which might be of independent interest for the design of other resilient algorithms. 1
Counting in the Presence of Memory Faults
"... Abstract. The faulty memory RAM presented by Finocchi and Italiano [1] is a variant of the RAM model where the content of any memory cell can get corrupted at any time, and corrupted cells cannot be distinguished from uncorrupted cells. An upper bound, δ, on the number of corruptions and O(1) reliab ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
Abstract. The faulty memory RAM presented by Finocchi and Italiano [1] is a variant of the RAM model where the content of any memory cell can get corrupted at any time, and corrupted cells cannot be distinguished from uncorrupted cells. An upper bound, δ, on the number of corruptions and O(1) reliable memory cells are provided. In this paper we investigate the fundamental problem of counting in faulty memory. Keeping many reliable counters in the faulty memory is easily done by replicating the value of each counter Θ(δ) times and paying Θ(δ) time every time a counter is queried or incremented. In this paper we decrease the expensive increment cost to o(δ) and present upper and lower bound tradeoffs decreasing the increment time at the cost of the accuracy of the counters. 1
EFFICIENT AND ERRORCORRECTING DATA STRUCTURES FOR MEMBERSHIP AND POLYNOMIAL EVALUATION
 SUBMITTED TO THE SYMPOSIUM ON THEORETICAL ASPECTS OF COMPUTER SCIENCE
"... We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “ ..."
Abstract

Cited by 5 (1 self)
 Add to MetaCart
(Show Context)
We construct efficient data structures that are resilient against a constant fraction of adversarial noise. Our model requires that the decoder answers most queries correctly with high probability and for the remaining queries, the decoder with high probability either answers correctly or declares “don’t know.” Furthermore, if there is no noise on the data structure, it answers all queries correctly with high probability. Our model is the common generalization of an errorcorrecting data structure model proposed recently by de Wolf, and the notion of “relaxed locally decodable codes” developed in the PCP literature. We measure the efficiency of a data structure in terms of its length (the number of bits in its representation), and queryanswering time, measured by the number of bitprobes to the (possibly corrupted) representation. We obtain results for the following two data structure problems: • (Membership) Store a subset S of size at most s from a universe of size n such that membership queries can be answered efficiently, i.e., decide if a given element from the universe is in S. We construct an errorcorrecting data structure for this problem with length nearly linear in s log n that answers membership queries with O(1) bitprobes. This nearly matches the asymptotically optimal parameters for the noiseless case: length O(s log n) and one bitprobe, due to
ErrorCorrecting Data Structures
, 2008
"... We study data structures in the presence of adversarial noise. We want to encode a given object in a succinct data structure that enables us to efficiently answer specific queries about the object, even if the data structure has been corrupted by a constant fraction of errors. This model is the comm ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
We study data structures in the presence of adversarial noise. We want to encode a given object in a succinct data structure that enables us to efficiently answer specific queries about the object, even if the data structure has been corrupted by a constant fraction of errors. This model is the common generalization of (static) data structures and locally decodable errorcorrecting codes. The main issue is the tradeoff between the space used by the data structure and the time (number of probes) needed to answer a query about the encoded object. We prove a number of upper and lower bounds on various natural errorcorrecting data structure problems. In particular, we show that the optimal length of errorcorrecting data structures for the Membership problem (where we want to store subsets of size s from a universe of size n) is closely related to the optimal length of locally decodable codes for sbit strings. 1
Lossless FaultTolerant Data Structures with Additive Overhead
"... Abstract. We develop the first dynamic data structures that tolerate δ memory faults, lose no data, and incur only an Õ(δ) additive overhead in overall space and time per operation. We obtain such data structures for arrays, linked lists, binary search trees, interval trees, predecessor search, and ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
Abstract. We develop the first dynamic data structures that tolerate δ memory faults, lose no data, and incur only an Õ(δ) additive overhead in overall space and time per operation. We obtain such data structures for arrays, linked lists, binary search trees, interval trees, predecessor search, and suffix trees. Like previous data structures, δ must be known in advance, but we show how to restore pristine state in linear time, in parallel with queries, making δ just a bound on the rate of memory faults. Our data structures require Θ(δ) words of safe memory during an operation, which may not be theoretically necessary but seems a practical assumption. 1