We present an efficient algorithm which can check the answers given by the fundamental abstract data types priority queues and mergeable priority queues. This is the first linear-time checker for mergeable priority queues. These abstract data types are widely used in routing, scheduling, simulation, computational geometry and many other algorithmic domains. We have implemented our answer checker and have performed experiments comparing the speed of our checker to recently benchmarked priority queue and mergeable priority queue implementations, and our checker is substantially faster than the best of these implementations. 1 Introduction This paper concerns the fundamental abstract data types of priority queues (PQs) and mergeable priority queues (MPQs). These abstract data types have been recognized as centrally important from the early days of computer-algorithm design. They appear in seminal algorithm texts such as Knuth's [10] and Aho, Hopcroft and Ullman's [1]. Data structure impl...

In this paper we describe a general technique for checking the integrity of data structures which can be corrupted by memory faults. Our approach is based on a recursive checksum technique. Basic methods of using checksums have been previously seen to be useful for detecting faults at the bit or word level; among our results will be their extension to the node level. The major contributions of our paper are threefold. First, we show how the recursive checksum procedure can be applied to tree data structures that are dynamically changing, whereas the previous work concentrated on trees that were static in their structure. This results in a asymptotic improvement in running time for applications where it is natural to model the underlying data as a tree. Second, we present a C ++ implementation of this scheme. Significantly, it is seen that our software can be used with existing applications which manipulate trees with only minor modification of the application programs. Finally, we ha...

this paper, we consider the problem of detecting errors in the answers given in response to data structure queries. For many programs a substantial fraction of the intricate error-prone code resides in the routines associated with data structure access. In addition, a significant fraction of total program running time is spent executing the code of these routines. Data structures are often used to implement abstract data types (ADTs) and in recent years a number of different ADTs have been shown to be efficiently checkable. Checkers which are also referred to as error monitors in this paper have been developed for priority queues, the union/find data type, and most recently mergeable priority queues and have been shown to require only O(n) time to check a sequence of n operations [5, 21, 23]. These checkers detect any errors in query answers and since each of these checkers is based on an ADT

For many years, there has been tremendous interest in methods to make computation more reliable. In this thesis, we explore various techniques that can be implemented in software to help insure the correctness of the output of a program. The basic tool we use is a generalization of the notion of a program checker called a certifier. A certifier is given intermediate computations from a program computing an answer in an effort to simplify the checking process. The certifier is constructed in such a way that even if the intermediate computations it is given are incorrect, the certifier will never accept an incorrect output. We have constructed certifiers and program checkers for several common abstract data types including mergeable priority queues and splittable priority queues. We have also constructed a certifier for an abstract data type that allows approximate nearest neighbor queries to be performed efficiently. We have implemented and experimentally evaluated some of these algorithms. In the parallel domain, we have developed both general and problem specific techniques for certifying parallel computation. Lastly, we have formally proven correct a certifier for sorting, and have analyzed the advantages of using certifiers in conjunction with formal program verification techniques. This work forms a thesis presented by Jonathan D. Bright to the faculty of the Department of Computer Science, at the Johns Hopkins University, in partial fulfillment of the requirements for the degree of Doctor of Philosophy, under the supervision of Professor Gregory F. Sullivan. iii Acknowledgements I would like to thank my advisor, Gregory Sullivan, for giving me an excellent research topic for my thesis, and for vastly improving my writing skills during my stay at Hopkins. Also, ...

Run-time certificates can be used to efficiently check the correctness of computational results with relatively small time and software redundancy. However, certificates heretofore have had to be customized to specific algorithms. In this paper we provide both theoretical and experimental results regarding the use of certificates for wide classes of algorithms based on common data-structure operations. Using an answer-validation monitoring approach, cer-tificates can be created for a variety of algorithms. Specifically, this paper discusses answer-validation monitoring of disjoint-set-union and priority-queue operations. The correctness of the answer validation approach is rigor-ously demonstrated. Experimental results are presented for four well-known algorithms using priority queues: shortest path, heapsort, Huffman tree, and skyline. It will be seen that the certificate utilized for each algorithm is generic in the sense that it is applicable to any algorithm using a priority queue. The experimental results com-pare the certificate approach using answer-validation monitoring to a two-version programming approach. It is seen that the certificate-based approach has significantly lower overhead. Furthermore, the advantage of using the certificate approach becomes greater as the size of the algorithm input increases, making the approach particu-larly attractive for low-overhead enhancement of the dependability of operations associated with computationally intensive applications.