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

Software self-defense systems and methods

Abstract: Systems and methods are disclosed for protecting a computer program from unauthorized analysis and modification. Obfuscation transformations can be applied to the computer program's local structure, control graph, and/or data structure to render the program more difficult to understand and/or modify. Tamper-resistance mechanisms can be incorporated into the computer program to detect attempts to tamper with the program's operation. Once an attempt to tamper with the computer program is detected, the computer program reports it to an external agent, ceases normal operation, and/or reverses any modifications made by the attempted tampering. The computer program can also be watermarked to facilitate identification of its owner. The obfuscation, tamper-resistance, and watermarking transformations can be applied to the computer program's source code, object code, or executable image.

Self-adjusting top trees

Abstract: The dynamic trees problem is that of maintaining a forest that changes over time through edge insertions and deletions. We can associate data with vertices or edges, and manipulate this data individually or in bulk, with operations that deal with whole paths or trees. Efficient solutions to this problem have numerous applications, particularly in algorithms for network flows and dynamic graphs in general. Several data structures capable of logarithmic-time dynamic tree operations have been proposed. The first was Sleator and Tarjan's ST-tree [16, 17], which represents a partition of the tree into paths. Although reasonably fast in practice, adapting ST-trees to different applications is nontrivial. Topology trees [9], top trees [3], and RC-trees [1] are based on tree contractions: they progressively combine vertices or edges to obtain a hierarchical representation of the tree. This approach is more flexible in theory, but all known implementations assume the trees have bounded degree; arbitrary trees are supported only after ternarization. We show how these two approaches can be combined (with very little overhead) to produce a data structure that is as generic as any other, very easy to adapt, and as practical as ST-trees.

Dominator tree verification and vertex-disjoint paths

Abstract: We present a linear-time algorithm that given a flowgraph G = (V,A,r) and a tree T, checks whether T is the dominator tree of G. Also we prove that there exist two spanning trees of G, T1 and T2, such that for any vertex v the paths from r to v in T1 and T2 intersect only at the vertices that dominate v. The proof is constructive and our algorithm can build the two spanning trees in linear time. Simpler versions of our two algorithms run in O(mα(m, n))-time, where n is the number of vertices and m is the number of arcs in G. The existence of such two spanning trees implies that we can order the calculations of the iterative algorithm for finding dominators, proposed by Allen and Cocke [2], so that it builds the dominator tree in a single iteration.

Value-maximizing deadline scheduling and its application to animation rendering

Abstract: We describe a new class of utility-maximization scheduling problem with precedence constraints, the disconnected staged scheduling problem (DSSP). DSSP is a nonpreemptive multiprocessor deadline scheduling problem that arises in several commercially-important applications, including animation rendering, protein analysis, and seismic signal processing. DSSP differs from most previously-studied deadline scheduling problems because the graph of precedence constraints among tasks within jobs is disconnected, with one component per job. Another difference is that in practice we often lack accurate estimates of task execution times, and so purely offline solutions are not possible. However we do know the set of jobs and their precedence constraints up front and therefore some offline planning is possible.Our solution decomposes DSSP into an offline job selection phase followed by an online task dispatching phase. We model the former as a knapsack problem and explore several solutions to it, describe a new dispatching algorithm for the latter, and compare both with existing methods. Our theoretical results show that while DSSP is NP-hard and inapproximable in general, our two-phase scheduling method guarantees a good performance bound for many special cases. Our empirical results include an evaluation of scheduling algorithms on a real animation-rendering workload; we present a characterization of this workload in a companion paper. The workload records eight weeks of activity on a 1,000-CPU cluster used to render portions of the full-length animated feature film Shrek 2 in 2004. We show that our improved scheduling algorithms can substantially increase the aggregate value of completed jobs compared to existing practices. Our new task dispatching algorithm LCPF performs well by several metrics, including job completion times as well as the aggregate value of completed jobs.

Calculating numbers of servers for tiers of a multi-tiered system

Abstract: Fractional, non-integer numbers of servers are calculated for respective tiers of a multi-tiered system using a server allocation algorithm. The fractional, non-integer numbers of servers are rounded up to integer numbers to compute allocated numbers of servers for respective tiers.

Linear-time algorithms for dominators and related problems

Abstract: This dissertation deals with several topics related to the problem of finding dominators in flowgraphs. The concept of dominators has applications in various fields, including program optimization, circuit testing and theoretical biology. We are interested both in asymptotically fast algorithms and in algorithms that are practical. We begin with an experimental study of various algorithms that compute dominators efficiently in practice. We describe two practical algorithms that have been proposed in the related literature: an iterative algorithm initially presented by Allen and Cocke and later refined by Cooper, Harvey and Kennedy, and the well-known algorithm of Lengauer and Tarjan. We discuss how to achieve efficient implementations, and furthermore, introduce a new practical algorithm. We present a thorough empirical analysis using real as well as artificial data. Then we present a linear-time algorithm for dominators implementable on the pointer machine model of computation. Previously, Alstrup, Harel, Lauridsen and Thorup gave a complicated linear-time algorithm for the random-access model. Buchsbaum, Kaplan, Rogers and Westbrook presented a simpler dominators algorithm, implementable on a pointer machine and claimed linear running time. However, as we show, one of their techniques cannot be applied to the dominators problem and, consequently, their algorithm does not run in linear time. Nonetheless, based on this algorithm, we show how to achieve linear running time on a pointer machine. Next we address the question of how to verify dominators. We derive a linear-time verification algorithm, which is much simpler than the known algorithms that compute dominators in linear time. Still, this algorithm is non-trivial and we believe it provides some new intuition and ideas towards a simpler dominators algorithm. Finally we study the relation of dominators to spanning trees. Our central result is a linear-time algorithm that constructs two spanning trees of any input flowgraph G, such that corresponding paths in the two trees satisfy a vertex-disjointness property we call ancestor-dominance . This result is related to the concepts of independent spanning trees and directed st-numberings, previously studied by various authors, and implies linear-time algorithms for these constructions.

Allocating resources in a system having multiple tiers

Abstract: To perform resource allocation in a system having plural tiers, one of plural resource allocation algorithms is selected in response to determining, based on one or more conditions, which of the plural resource allocation algorithms to select. The selected resource allocation algorithm is used to allocate resources for the plural tiers of the system.

Allocation of resources for tiers of a multi-tiered system based on selecting items from respective sets

Abstract: Plural sets of items corresponding to plural tiers of a multi-tiered system are defined, where the items represent amounts of resources to allocate to the tiers. Items from respective sets are selected based on a response time constraint and a target cost. Information is provided pertaining to allocation of amounts of resources to the respective tiers based on the selected items.

Server allocation algorithms for tiered systems

Abstract: Many web-based systems have a tiered application architecture, in which a request needs to transverse all the tiers before finishing its processing. One of the most important QoS metrics for these applications is the expected response time for the user. Since the expected response time in any tier depends upon the number of servers allocated to this tier, and a request’s total response time is the sum of the response times at all the tiers, many different configurations (number of servers allocated to each tier) can satisfy the expected response time requirement. Naturally, one would like to find the configuration to minimize the total system cost while satisfying the total response time requirement. This is modeled as a non-linear optimization problem using an open-queuing network model of response time, which we call the server allocation problem for tiered systems (SAPTS). In this paper we study the computational complexity of SAPTS and design efficient algorithms to solve it. For a variable number of tiers, we show that the decision problem of SAPTS is NP-complete. Then we design a simple two-approximation algorithm and a fully polynomial time approximation scheme (FPTAS). If the number of tiers is a constant, we show that SAPTS is polynomial-time solvable. Furthermore, we design a fast polynomial-time exact algorithm to solve for the important two-tier case. Most of our results extend to the general case where each tier has an arbitrary response time function.

Problems in data structures and algorithms

Abstract: ion Old/New Theory/Process

Deadline scheduling for animation rendering

Abstract: We describe a new class of scheduling problem with precedence constraints, the disconnected staged scheduling problem (dssp). dssp is a nonpreemptive multiprocessor deadline scheduling problem; we seek to maximize the aggregate value of jobs that complete by a specified deadline. It arises in many commercially-important domains including bioinformatics and seismic signal processing. Our interest in dssp began with the practical problem of scheduling computer animation rendering jobs. Each job represents a brief film clip and consists of several stages that must be processed in order (e.g., physical simulation, model baking, frame rendering, and clip assembly). Each stage in turn consists of computational tasks that may be run in parallel; all tasks in a stage must finish before any task in the next stage can start. A job completes if and only if all of its tasks complete. Precedence constraints exist among tasks within a job, but not among tasks in different jobs. Jobs run overnight and yield value only if they complete before the artists who submitted them return the following morning. Demand frequently exceeds available CPU capacity, making it impossible to complete all submitted jobs by the deadline. The set of jobs is known in advance but their computational demands (e.g., the run times of tasks) are not precisely known. Existing scheduling practices rely on priority schedulers, which are not well suited to dssp because ordinal priorities cannot adequately express the value of jobs. Furthermore priority schedulers make job selection decisions as byproducts of task sequencing decisions. Our approach is to assign to jobs completion rewards whose sums and ratios are meaningful, and to perform job selection and task sequencing separately. We present both theoretical analysis and empirical evaluation of our dssp solution. Our empirical results are based on an eight-week trace of 2,388 jobs collected in a 1,000-CPU production system that rendered part of film Shrek 2 in 2004. We show that our two-phase method improves aggregate reward and achieves near-optimal performance under