## Designing Checkers for Programs that Run in Parallel (1994)

Venue: | Algorithmica |

Citations: | 13 - 2 self |

### BibTeX

@ARTICLE{Rubinfeld94designingcheckers,

author = {Ronitt Rubinfeld},

title = {Designing Checkers for Programs that Run in Parallel},

journal = {Algorithmica},

year = {1994},

volume = {15},

pages = {30--1}

}

### Years of Citing Articles

### OpenURL

### Abstract

Program correctness for parallel programs is an even more problematic issue than for serial programs. We extend the theory of program result checking to parallel programs, and find general techniques for designing such result checkers that work for many basic problems in parallel computation. These result checkers are simple to program and are more efficient than the actual computation of the result. For example, sorting, multiplication, parity, the all pairs shortest path problem and majority all have constant depth result checkers, and the result checkers for all but the last problem use a linear number of processors. We show that there are P-complete problems (evaluating straight-line programs, linear programming) that have very fast, even constant depth, result checkers. 1 Introduction Verifying a program to see if it is correct is a problem that every programmer has encountered. Even the seemingly simplest of programs can be full of hidden bugs, and in the age of massive software...

### Citations

1807 | Computational Geometry: An Introduction - Preparata, Shamos - 1985 |

1338 |
Introduction to Parallel Algorithms and Architectures: Arrays
- Leighton
- 1992
(Show Context)
Citation Context ...problems are the first deterministic sequential result checkers for those problems. All of the examples in this paper are written for the arbitrary and priority CRCW PRAM models (cf. pages 698-700 of =-=[16]-=- for definitions of models). The difference in the complexity of solving a problem in parallel with a polynomial number of processors, as compared to the depth complexity of result checking a problem ... |

375 | A simple parallel algorithm for the maximal independent set problem - Luby - 1986 |

350 | Self-testing/correcting with applications to numerical problems - BLUM, LUBY, et al. - 1990 |

287 | Parallel Algorithms for Shared-Memory Machines - Karp, Ramachandran - 1990 |

220 | A fast and simple randomized parallel algorithm for the maximal independent set problem - Alon, Babai, et al. - 1986 |

187 |
On finding lowest common ancestors: Simplification and parallelization
- Schieber, Vishkin
- 1988
(Show Context)
Citation Context ...etermined in O(log n) expected time and O( m+n log n ) processors using the techniques of [13]. Finding lowest common ancestors for all edges can be done in O(log n) time using O(n= log n) processors =-=[26]-=-. In the problem of constructing a breadth first search tree, the input is an undirected graph G and some node r in G. The output is a rooted (directed) tree T which can be obtained by performing a br... |

120 | Parity, circuits, and the polynomial time hier- archy," 22nd FOCS - Furst, Saxe, et al. - 1981 |

108 |
Constant depth reducibility
- Chandra, Stockmeyer, et al.
- 1984
(Show Context)
Citation Context ...s the number of processors required to do addition in constant depth. The best algorithm for multiplication takes O(log n= log log n) time and O(n 1+ffl ) (ffl ? 0) operations, by combining [27] with =-=[10]-=-. The total time is O(D(n)) with O(n \Theta A(n) + n \Theta N(n)) total processors. Because of the following known results, all the checkers presented in this section are quantifiably different. When ... |

96 |
Schnelle Multiplikation grosser Zahlen
- Schönhage, Strassen
- 1971
(Show Context)
Citation Context ...ere A(n) is the number of processors required to do addition in constant depth. The best algorithm for multiplication takes O(log n= log log n) time and O(n 1+ffl ) (ffl ? 0) operations, by combining =-=[27]-=- with [10]. The total time is O(D(n)) with O(n \Theta A(n) + n \Theta N(n)) total processors. Because of the following known results, all the checkers presented in this section are quantifiably differ... |

46 |
An Optimal Randomized Parallel Algorithm for Finding Connected Components in a Graph
- Gazit
- 1991
(Show Context)
Citation Context ...s (v; u) are backedges; i.e. that either v is an ancestor of u or u is an ancestor of v. Connectivity can be determined in O(log n) expected time and O( m+n log n ) processors using the techniques of =-=[13]-=-. Finding lowest common ancestors for all edges can be done in O(log n) time using O(n= log n) processors [26]. In the problem of constructing a breadth first search tree, the input is an undirected g... |

46 |
Constructing a perfect matching is in random NC
- Karp, Upfal, et al.
- 1986
(Show Context)
Citation Context ...ted by an adjacency matrix. Output: k = the size of a maximum matching, and the edges in a maximum matching in G No deterministic NC algorithm is known for this problem, but it is known to be in RNC (=-=[21]-=-, [24]). Result Checking Algorithm: The result checker first checks in parallel that no vertex is matched more than once and that the maximum matching is of size k. Then the algorithm in [19] is used ... |

45 | Unbounded fan-in circuits and associative functions - Chandra, Fortune, et al. |

44 |
U.: Converting High Probability into Nearly-Constant Time—with Applications to Parallel Hashing
- Matias, Vishkin
- 1991
(Show Context)
Citation Context ...etermine which equivalence class the input is in, it can verify that the answer of P on the input is correct. In the result checking algorithm, several random permutations of the input bits are made; =-=[23]-=- provides a way of doing this in O(log n) depth with linear processors (and O(log n log log n) depth with an optimal number of processors). They also show how to do it in O(1) depth and O(n log n) pro... |

42 |
Optimal bounds for decision problems
- Beame, Hastad
- 1989
(Show Context)
Citation Context ... Matching is not known to be in NC (though it is in RNC), and it has a deterministic NC result checker. Multiplication, parity and majority all have lower bounds of\Omega\Gamma/18 n= log log n) depth =-=[6]-=- when computed with a polynomial number of processors, yet all have (completely different) constant depth result checkers. 2 The Parallel Program Result Checking Model In this section, we describe the... |

41 |
Faster Optimal Parallel Prefix Sums and List Ranking
- Cole, Vishkin
- 1989
(Show Context)
Citation Context ... checkers presented in this section are quantifiably different. When the input consists of integers, the best known algorithm for prefix sums uses O(n= log n) processors and O(log n= log log n) depth =-=[11]-=-. Any algorithm using only a polynomial number of processors for prefix sums, sum, parity and integer multiplication provably requires \Omega\Gammaequ n= log log n) depth [6] Straight-line programming... |

35 | A new parallel algorithm for the maximal independent set problem - Spencer, Golberg - 1989 |

33 |
private communication
- GROSS, MÉZARD
(Show Context)
Citation Context ...hm result checks planar convex hull in a way that is is more efficient with processors. Result Checking Algorithm: This result checker is a parallel implementation of the sequential result checker of =-=[15]-=-. The result checker must verify that the polygon described in the output is simple and convex. This is done by assigning a processor to each vertex of the hull in order to verify that a left turn is ... |

27 |
A random NC algorithm for depth first search
- Aggarwal, Anderson
- 1988
(Show Context)
Citation Context ...d tree T which can be obtained by peforming a depth first search on G, starting from r. No "efficient" parallel algorithm for this problem is known. It was shown to be in RNC by Aggarwal and=-= Anderson [2]-=-. The checker first confirms that T is a tree, by checking that T is connected and has n \Gamma 1 edges. Then, the checker confirms that all non-tree edges (v; u) are backedges; i.e. that either v is ... |

25 |
Program correctness checking : : : and the design of programs that check their work
- BLUM, KANNAN
- 1989
(Show Context)
Citation Context ...ssive software projects, this problem is becoming increasingly important. The complexity of programming parallel computers is even greater. A general theory of result checking algorithms was given in =-=[7]-=-. This approach recognizes that proving programs correct is very difficult to do, and with this in mind, aims at the easier task of checking that a program is correct on any given input. This easier p... |

21 | The complexity of parallel search - Karp, Upfal, et al. - 1988 |

11 |
A Las Vegas RNC algorithm for maximum matching
- Karloff
- 1986
(Show Context)
Citation Context ... in RNC ([21], [24]). Result Checking Algorithm: The result checker first checks in parallel that no vertex is matched more than once and that the maximum matching is of size k. Then the algorithm in =-=[19]-=- is used to find a proof that there is no matching of sizesk. This proof will be an odd set cover of size k. Karloff's algorithm calls a matching oracle on other problem instances. The result checker ... |

10 |
Program Result Checking with Applications
- Kannan
- 1990
(Show Context)
Citation Context ...complete, so no fast parallel algorithm is known for it. However, it can be result checked in logarithmic time with only two calls to the program using an obvious parallelization of the techniques in =-=[18]-=-. Another example is the following: Maximum Matching Input: Graph G = (V; E), where E is represented by an adjacency matrix. Output: k = the size of a maximum matching, and the edges in a maximum matc... |

7 |
Optimal Parallel Algorithms for Transitive Closure and
- Tamassia, Vitter
- 1989
(Show Context)
Citation Context ...t must be outside of the convex hull). One must then just test that the point is really in the tetrahedron defined by (p; a; b; c). Determining (a; b; c) is simply a planar point location problem. In =-=[29]-=- it shown how to create the planar point location data structure in O(log n) time with n= log n processors that supports point location queries in O(log n) time. Running Time: The checking and total t... |

4 |
Efficient checkers for number-theoretic computations
- Adleman, Huang, et al.
- 1995
(Show Context)
Citation Context ... programs, linear programming) that have very fast, even constant depth, parallel result checkers. Integer GCD is not known to be in RNC, yet a logarithmic depth parallel result checker exists for it =-=[1]-=-. Maximum Matching is not known to be in NC (though it is in RNC), and it has a deterministic NC result checker. Multiplication, parity and majority all have lower bounds of\Omega\Gamma/18 n= log log ... |

4 |
An NC Parallel 3D Convex Hull Algorithm
- Amato, Preparata
- 1993
(Show Context)
Citation Context ...ices of the polyhedron. Model of Computation: CRCW PRAM in which arithmetic operations on real numbers can be performed in one step. The best known parallel algorithm from 3D convex hull mentioned in =-=[5]-=- requires O(log n) time with O(n 1+ff ) processors. The following result checking algorithm uses constant checking time, but uses many processors. 11 Result Checking Algorithm: For each face on the co... |

2 |
Matching is as Easy as Matrix Inversion", Combinatorica 7
- Mulmuley, Vazirani, et al.
- 1987
(Show Context)
Citation Context ... an adjacency matrix. Output: k = the size of a maximum matching, and the edges in a maximum matching in G No deterministic NC algorithm is known for this problem, but it is known to be in RNC ([21], =-=[24]-=-). Result Checking Algorithm: The result checker first checks in parallel that no vertex is matched more than once and that the maximum matching is of size k. Then the algorithm in [19] is used to fin... |

1 |
Parallel Computational Geometry", Algorithmica 3
- Aggarwal, Chazelle, et al.
- 1988
(Show Context)
Citation Context ...se order around the hull. Model of Computation: CRCW PRAM in which arithmetic operations (+; \Gamma; \Delta; =) on real numbers can be performed in one step. 10 The best algorithm for this problem in =-=[3]-=- runs in O(log n) depth and uses O(n) processors. The following algorithm result checks planar convex hull using constant checking time, but uses many processors: Result Checking Algorithm: For each e... |