scispace - formally typeset
Search or ask a question

Showing papers by "Robert E. Tarjan published in 2012"


Patent
20 Dec 2012
TL;DR: In this paper, the authors describe software self-checking mechanisms for improving software tamper resistance and/or reliability, which can be implemented such that they are relatively stealthy and robust, and compatible with copy-specific static watermarking and other tamper-resistance techniques.
Abstract: Software self-checking mechanisms are described for improving software tamper resistance and/or reliability. Redundant tests are performed to detect modifications to a program while it is running. Modifications are recorded or reported. Embodiments of the software self-checking mechanisms can be implemented such that they are relatively stealthy and robust, and so that it they are compatible with copy-specific static watermarking and other tamper-resistance techniques.

151 citations


Journal ArticleDOI
TL;DR: In this article, the authors present two online algorithms for maintaining a topological order of a directed n-vertex acyclic graph as arcs are added, and detecting a cycle when one is created.
Abstract: We present two online algorithms for maintaining a topological order of a directed n-vertex acyclic graph as arcs are added, and detecting a cycle when one is created. Our first algorithm handles m arc additions in O(m3/2) time. For sparse graphs (m/n = O(1)), this bound improves the best previous bound by a logarithmic factor, and is tight to within a constant factor among algorithms satisfying a natural locality property. Our second algorithm handles an arbitrary sequence of arc additions in O(n5/2) time. For sufficiently dense graphs, this bound improves the best previous bound by a polynomial factor. Our bound may be far from tight: we show that the algorithm can take Ω(n22√2 lgn) time by relating its performance to a generalization of the k-levels problem of combinatorial geometry. A completely different algorithm running in Θ(n2 log n) time was given recently by Bender, Fineman, and Gilbert. We extend both of our algorithms to the maintenance of strong components, without affecting the asymptotic time bounds.

88 citations


Book ChapterDOI
16 Oct 2012
TL;DR: The CBTree is presented, a new counting-based self-adjusting binary search tree that moves more frequently accessed nodes closer to the root that improves performance compared to existing concurrent search trees on non-uniform access sequences derived from real workloads.
Abstract: We present the CBTree, a new counting-based self-adjusting binary search tree that, like splay trees, moves more frequently accessed nodes closer to the root. After m operations on n items, c of which access some item v, an operation on v traverses a path of length $\mathcal{O}(\log\dfrac{m}{c})$ while performing few if any rotations. In contrast to the traditional self-adjusting splay tree in which each accessed item is moved to the root through a sequence of tree rotations, the CBTree performs rotations infrequently (an amortized subconstant o(1) per operation if m≫n), mostly at the bottom of the tree. As a result, the CBTree scales with the amount of concurrency. We adapt the CBTree to a multicore setting and show experimentally that it improves performance compared to existing concurrent search trees on non-uniform access sequences derived from real workloads.

64 citations


Proceedings ArticleDOI
19 May 2012
TL;DR: This work presents the first pointer-based heap implementation with time bounds matching those of Fibonacci heaps in the worst case, and uses the pigeonhole principle in place of the redundant counter mechanism.
Abstract: We present the first pointer-based heap implementation with time bounds matching those of Fibonacci heaps in the worst case. We support make-heap, insert, find-min, meld and decrease-key in worst-case O(1) time, and delete and delete-min in worst-case O(lg n) time, where n is the size of the heap. The data structure uses linear space. A previous, very complicated, solution achieving the same time bounds in the RAM model made essential use of arrays and extensive use of redundant counter schemes to maintain balance. Our solution uses neither. Our key simplification is to discard the structure of the smaller heap when doing a meld. We use the pigeonhole principle in place of the redundant counter mechanism.

51 citations


Proceedings ArticleDOI
20 Oct 2012
TL;DR: New machinery is introduced to find a perfect matching in time O(m√s log(sC)) via weight scaling via weight scaled for bipartite graphs in which the edge weights are integers bounded in magnitude by C >; 1.
Abstract: Call a bipartite graph G = (X, Y, E) "balanced" when |X| = |Y|. Given a balanced bipartite graph G with edge costs, the "assignment problem" asks for a perfect matching in G of minimum total cost. The Hungarian Method can solve assignment problems in time O(mn + n^2 log n), where n := |X| = |Y| and m := |E|. If the edge weights are integers bounded in magnitude by C > 1, then algorithms using "weight scaling", such as that of Gabow and Tarjan, can lower the time to O(m sqrt(n) log(nC)). There are important applications in which G is "unbalanced", with |X| not equal |Y|, and we require a min-cost matching of size r := min(|X|, |Y|) or, more generally, of some specified size s than or equal to r. The Hungarian Method extends easily to find such a matching in time O(ms + s2 log r), but weightscaling algorithms do not extend so easily. We introduce new machinery to find such a matching in time O(mps log(sC)) via weight scaling. Our results provide some insight into the design space of efficient weight-scaling matching algorithms.

28 citations


Posted Content
TL;DR: A correctness certificate for a dominator tree is defined, how to use it to easily verify the correctness of the tree is shown, and how to augment fast dominator-finding algorithms so that they produce a correctness certificate.
Abstract: How does one verify that the output of a complicated program is correct? One can formally prove that the program is correct, but this may be beyond the power of existing methods. Alternatively one can check that the output produced for a particular input satisfies the desired input-output relation, by running a checker on the input-output pair. Then one only needs to prove the correctness of the checker. But for some problems even such a checker may be too complicated to formally verify. There is a third alternative: augment the original program to produce not only an output but also a correctness certificate, with the property that a very simple program (whose correctness is easy to prove) can use the certificate to verify that the input-output pair satisfies the desired input-output relation. We consider the following important instance of this general question: How does one verify that the dominator tree of a flow graph is correct? Existing fast algorithms for finding dominators are complicated, and even verifying the correctness of a dominator tree in the absence of additional information seems complicated. We define a correctness certificate for a dominator tree, show how to use it to easily verify the correctness of the tree, and show how to augment fast dominator-finding algorithms so that they produce a correctness certificate. We also relate the dominator certificate problem to the problem of finding independent spanning trees in a flow graph, and we develop algorithms to find such trees. All our algorithms run in linear time. Previous algorithms apply just to the special case of only trivial dominators, and they take at least quadratic time.

18 citations


Book ChapterDOI
09 Jul 2012
TL;DR: The notion of a directed bipolar order is introduced, generalizing a previous notion of Plein and Cheriyan and Reif, and how to construct such an order from information computed by several known algorithms for finding dominators is shown.
Abstract: We consider problems related to dominators and independent spanning trees in flowgraphs and provide linear-time algorithms for their solutions. We introduce the notion of a directed bipolar order, generalizing a previous notion of Plein and Cheriyan and Reif. We show how to construct such an order from information computed by several known algorithms for finding dominators. We show how to concurrently verify the correctness of a dominator tree D and a directed bipolar order O very simply, and how to construct from D and O two spanning trees whose paths are disjoint except for common dominators. Finally, we describe alternative ways to verify dominators without using a directed bipolar order.

18 citations


Journal ArticleDOI
TL;DR: A linear-size dynamic data structure that answers queries in worst-case $O(\log n)$ time and supports both insertions and deletions of intervals in amortized $O('log n') time is proposed.
Abstract: Let $S$ be a set of $n$ intervals in $\mathbb{R}$, and let $(\mathbf{S}, +)$ be any commutative semigroup. We assign a weight $\omega(s) \in \mathbf{S}$ to each interval in $S$. For a point $x \in \mathbb{R}$, let $S(x) \subseteq S$ be the set of intervals that contain $x$. Given a point $q \in \mathbb{R}$, the stabbing-semigroup query asks for computing $\sum_{s \in S(q)} \omega(s)$. We propose a linear-size dynamic data structure, under the pointer-machine model, that answers queries in worst-case $O(\log n)$ time and supports both insertions and deletions of intervals in amortized $O(\log n)$ time. It is the first data structure that attains the optimal $O(\log n)$ bound for all three operations. Furthermore, our structure can easily be adapted to external memory, where we obtain a linear-size structure that answers queries and supports updates in $O(\log_B n)$ I/Os, where $B$ is the disk block size. For the restricted case of a nested family of intervals (either every pair of intervals is disjoint or one contains the other), we present a simpler solution based on dynamic trees.

16 citations


Patent
28 Sep 2012
TL;DR: In this paper, a system and method for generating shape graphs for a routing table is described. The method includes splitting a binary trie representing the routing table of a router into a number of layers.
Abstract: A system and method for generating shape graphs for a routing table are described herein. The method includes splitting a binary trie representing a routing table of a router into a number of layers, wherein each layer includes a number of nodes. The method also includes, for each layer, determining a number of groups of isomorphic nodes and merging the isomorphic nodes within each group to generate a shape graph.

5 citations


28 Nov 2012
TL;DR:  Sidestep: Co-Designed Shiftable Memory & Software T.D. Kelly, H. Pickett, and H. Williams HP Laboratories HPL-2012-235.
Abstract:  Sidestep: Co-Designed Shiftable Memory & Software T. Kelly, H. Kuno, M.D. Pickett, H. Boehm, A. Davis, W. Golab, G. Graefe, S. Harizopoulos, P. Joisha, A. Karp, N. Muralimanohar, F. Perner, G. Medeiros-Ribeiro, G. Seroussi, A. Simitsis, R. Tarjan, R.S. Williams HP Laboratories HPL-2012-235

4 citations


Patent
26 Apr 2012
TL;DR: In this article, the authors propose a method for cost entity matching based on the number of first cost values and the second cost values assigned to each edge connecting one of the first entities to the second entity.
Abstract: A method for cost entity matching can include constructing a first graph including a number of first entities and a number of second entities, and assigning a number of first cost values to each of a number of first edges connecting one of the number of first entities to one of the number of second entities in the first graph; adding a second graph to the first graph, wherein the second graph includes the number of first entities and the number of second entities, and assigning a second cost value to each of a number of second edges connecting one of the number of first entities in the first graph to the corresponding first entity in the second graph; and, matching each one of the number of second entities to one of the number of first entities based on the number of first cost values and the second cost values.