Reducible Flow Graphs Research Articles

Finding a minimum feedback arc set in reducible flow graphs

We present a polynomial-time algorithm for finding a minimum weight feedback arc set (FAS) in arc-weighted reducible flow graphs and for finding a minimum weight feedback vertex set (FVS) in vertex-weighted reducible flow graphs. The algorithm has time complexity O(mn 2 log( n 2 m )) , where n is the number of vertices and m is the number of arcs in the reducible flow graph. For unweighted reducible flow graphs, the algorithm for FAS has time complexity O( min(mn 5 3 , m 2)) . We also show that any algorithm that solves the FAS problem or the vertex-weighted FVS problem on reducible flow graphs has time complexity at least that of finding a minimum cut in a flow network, for which the best algorithm currently known has time complexity Θ(mn log( n 2 m )) for networks with arbitrary capacities, and Θ( min(mn 2 3 , m 3 2 )) for networks with unit capacities. Our results establish several connections between the FAS problem on reducible flow graphs and the minimum cut-maximum flow problem on flow networks.

Implementation of an optimizing compiler for VHDL

We present techniques used to implement an optimizing compiler for the VHSIC hardware description language (VHDL). We present details about the LR parser used to parse the input program. An efficient intermediate representation, called a process graph, is constructed as a result of the parsing. This representation is chosen to facilitate the ease of data flow analyses and optimizations. The process graph is a reducible flow graph because of the restricted subset of VHDL that we work with. The various data flow analyses and optimization techniques that have been implemented are described. This optimizing compiler is being used as a front end for a tool that performs behavioral synthesis.

Data flow analysis for `intractable' system software

We describe, and give experience with, a new method of intraprocedural data flow analysis on reducible flow-graphs[9]. The method is advantageous in imbedded applications where the added value of improved performance justifies substantial optimization effort, but extremely powerful data flow analysis is required due to the code profile. The method is unusual in that (1) various kinds of forward data flow analysis are done simultaneously, so that benefit is derived from informative interactions (e.g. between constant propagation[7] and alias analysis[8]) and (2) we abandon insistence on reaching a least fixed point, allowing us to handle extremely broad classes of information (e.g., inequality of array indices, which implies non-aliasing in array references). We argue that the gain from using a very rich framework more than offsets the loss due to non-minimal fixed points, and justify this with a 'thought experiment' and practical results.

Feedback vertex sets and cyclically reducible graphs

The problem of finding a minimum cardinality feedback vertex set of a directed graph is considered. Of the classic NP-complete problems, this is one of the least understood. Although Karp showed the general problem to be NP-complete, a linear algorithm for its solution on reducible flow graphs was given by Shamir. The class of reducible flow graphs is the only nontrivial class of graphs for which a polynomial-time algorithm to solve this problem is known. The main result of this paper is to present a new class of graphs—the cyclically reducible graphs —for which minimum feedback vertex sets can be found in polynomial time. This class is not restricted to flow graphs, and most small graphs (10 or fewer nodes) fall into this class. The identification of this class is particularly important since there do not exist approximation algorithms for this problem having a provably good worst case performance. Along with the class and a simple polynomial-time algorithm for finding minimum feedback vertex sets of graphs in the class, several related results are presented. It is shown that there is no “forbidden subgraph” characterization of the class and that there is no particular inclusion relationship between this class and the reducible flow graphs. In addition, it is shown that a class of (general) graphs, which are related to the reducible flow graphs, are contained in the cyclically reducible class.

A region analysis algorithm for the live variables problem

An algorithm to solve the “live variables” problem on reducible flow graphs is presented. It is based on the concept of a region of a flow graph. The algorithm is compared for time complexity with the well-known round-robin version of the iterative algorithm on “self-replicating” families of reducible flow graphs. The results of comparison are inconclusive in that the region analysis algorithm requires fewer bit-vector operations on some graphs and more on others.

A Comparison of the Worst-Case Complexities of Two Algorithms for the Reaching Definitions Problem

An algorithm to solve the “reaching definitions” problem on reducible flow graphs is presented. It is based on the concept of a region of a flow graph, and has the worst-case time bound of O(n2) bit-vector operations. The algorithm is compared for time complexity with the well-known round-robin version of the iterative algorithm. The comparison shows that for every flow graph of n>2 nodes the region analysis algorithm for the “reaching definitions” problem requires in the worst case fewer bit-vector operations than the round-robin version of the iterative algorithm for the same problem.

Pathlistings applied to data flow analysis

In this paper the pathlisting mechanism is developed as a new tool useful in performing efficient data flow analysis of programs for a wide variety of problems. An algorithm using this tool for forward flow, code improvement problems is presented. It is shown that for all practical purposes this algorithm is linear in the size of the input which is, generally speaking, a reducible flow graph modeling the given program. Pathlistings generalize the nodelisting approach, introduced by Kennedy, for solving data flow problems. The efficiency of the pathlisting algorithm is due to the reuse of intermediate values and due to the fact that the cycles of a reducible flow graph can be ordered. Other advantages of the approach are also discussed.

Fast Algorithms for Solving Path Problems

Let G = (V,E) be a directed graph with a distinguished source vertex s. The single-source path expression problem is to find, for each vertex v, a regular expression P(s,v) which represents the set of all paths in G from s to v. A solution to this problem can be used to solve shortest path problems, solve sparse systems of linear equations, and carry out global flow analysis. We describe a method to compute path expressions by dividing G into components, computing path expressions on the components by Gaussian elimination, and combining the solutions. This method requires O(m $\alpha$(m,n)) time on a reducible flow graph, where n is the number of vertices in G, m is the number of edges in G, and $\alpha$ is a functional inverse of Ackermann''s function. The method makes use of an algorithm for evaluating functions defined on paths in trees. A simplified version of the algorithm, which runs in O(m log n) time on reducible flow graphs, is quite easy to implement and efficient in practice.

A comparison of some algorithms for live variable analysis

A complete algorithm for computing acceptable assignments for the live variable problem in global program optimization is given which is a modification of an earlier algorithm due to Graham and Wegman. The complexity of the algorithm has been analysed on some self-replicating families of reducible flow graphs. It has been observed that there exists class of graphs for which algorithms of 0(nlog n) require more bit vector operations than algorithms of 0(n 2). A characterization of the flow graphs for which the procedure of Graham and Wegman is applicable for backward data flow propagation problems is also presented

Finding the depth of a flow graph

The depth of a flow graph is the maximum number of back edges in an acyclic path, where a back edge is defined by some depth-first spanning tree for the flow graph. In the case of a reducible graph, the depth is independent of the depth-first spanning tree chosen. We show that the computation of the depth of a reducible flow graph requires polynomial time. Our algorithm is O(ne) on a flow graph of n nodes and e edges. Since e ≤2 n for normal flow graphs, our algorithm is really O ( n 2 ). While even an O ( n 2 ) algorithm is not likely to be acceptable, it is suggestive of the possibility of a more efficient algorithm. Finally, we show that the general problem of computing the depth of an arbitrary flow graph is NP -complete.

Node listings for reducible flow graphs

K. Kennedy recently conjectured that for every n node reducible flow graph, there is a sequence of nodes (with repetitions) of length O(n log n ) such that all acyclic paths are subsequences thereof. Such a sequence would, if it could be found easily, enable one to do various kinds of global data flow analyses quickly. We show that for all reducible flow graphs such a sequence does exist, even if the number of edges is much larger than n . If the number of edges is O(n) , the node listing can be found in O(n log n ) time.

Lower bounds on the lengths of node sequences in directed graphs

A strong node sequence for a directed graph G=(N,A) is a sequence of nodes containing every cycle-free path of G as a subsequence. A weak node sequence for G is a sequence of nodes containing every basic path in G as a subsequence, where a basic path n1, n2, …, nk is a path from n1 to nk such that no proper subsequence is a path from n1 to nk. (Every strong node sequence for G is a weak node sequence for G.) Kennedy has developed a global program data flow analysis method using node sequences. Kwiatowski and Kleitman have shown that any strong node sequence for the complete graph on n nodes must have length at least n2−O(n7/4+α), for arbitrary positive ε. Every graph on n nodes has a strong sequence of length n2–2n+4, so this bound is tight to within O(n7/4+α). However, the complete graph on n nodes has a weak node sequence of length n nodes (all with in-degree and out-degree bounded by two) such that any weak node sequence for G has length at least 1/2 log2 n−O(n log log n). Aho and Ullman have shown that every reducible flow graph has a strong node sequence of length O(n log2 n); thus our bound is tight to within a constant factor for reducible graphs. We also show that for infinitely many n, there is a (non-reducible) flow graph H with n nodes (all with in-degree and out-degree bounded by two), such that any weak node sequence for H has length at least cn2, where c is a positive constant. This bound, too, is tight to within a constant factor.

On Finding Lowest Common Ancestors in Trees

Trees in an n-node forest are merged according to instructions in a given sequence, while other instructions in the sequence ask for the lowest common ancestor of pairs of nodes. We show that any sequence of $O(n)$ such instructions can be processed “on-line” in $O(n\log n)$ steps on a random access computer.If we can accept our answer “off-line”, that is, no answers need to be produced until the entire sequence of instructions has been seen, then we may perform the task in $O(n\alpha (n))$ steps, where $\alpha (n)$ is the very slowly growing inverse Ackermann function defined in [14].A third algorithm solves a problem of intermediate complexity. We require the answers on-line, but we assume that all tree merging instructions precede the information requests. This algorithm requires $O(n \log \log n)$ time.We apply the first on-line algorithm to a problem in code optimization, that of computing immediate dominators in a reducible flow graph. We show how this computation can be performed in $O(n\log n)$ steps.

A Comparison of Two Algorithms for Global Data Flow Analysis

The problem of determining the points in a program at which variables are “live” (will be used again) is introduced and discussed. Two solutions, one which uses a simple iterative algorithm and one which uses an algorithm based on “Cocke–Allen interval” analysis, are presented and analyzed. These algorithms are compared on “self replicating“ families of reducible program flow graphs. The results are inconclusive in that the interval method requires fewer bit-vector steps on some graphs and more on others. If n is the number of nodes in a program flow graph and the number of edges is linearly proportional to n, then both algorithms require $O(n^2 )$ steps in the worst case.

A Simple Algorithm for Global Data Flow Analysis Problems

A simple, iterative bit propagation algorithm for solving global data flow analysis problems such as “available expressions” and “live variables” is presented and shown to be quite comparable in speed to the corresponding interval analysis algorithm. This comparison is facilitated by a result relating two parameters of a reducible flow graph (rfg). Namely, if G is an rfg, d is the largest number of back edges found in any cycle-free path in G, and k is the length of the interval derived sequence of G, then $k \geqq d$. (Intuitively, k is the maximum nesting depth of loops in a computer program, while d is a measure of the maximum loop-interconnectedness.) The node ordering employed by the simple algorithm is the reverse of the order in which a node is last visited while growing any depth-first spanning tree of the flow graph. In addition, a dominator algorithm for an rfg is presented which takes O(edges) bit vector steps.

Characterizations of Reducible Flow Graphs

It is established that if G is a reducible flow graph, then edge ( n, m ) is backward (a back latch) if and only if either n = m or m dominates n in G . Thus, the backward edges of a reducible flow graph are unique. Further characterizations of reducibility are presented. In particular, the following are equivalent: (a) G = ( N, E, n 0 ) is reducible. (b) The “dag” of G is unique. (A dag of a flow graph G is a maximal acyclic flow graph which is a subgraph of G .) (c) E can be partitioned into two sets E 1 and E 2 such that E 1 forms a dag D of G and each ( n, m ) in E 2 has n = m or m dominates n in G . (d) Same as (c), except each ( n, m ) in E 2 has n = m or m dominates n in D . (e) Same as (c), except E 2 is the back edge set of a depth-first spanning tree for G . (f) Every cycle of G has a node which dominates the other nodes of the cycle. Finally, it is shown that there is a “natural” single-entry loop associated with each backward edge of a reducible flow graph.

Fast algorithms for the elimination of common subexpressions

We give two algorithms for computing the set of available expressions at entrance to the nodes of a flow graph. The first takes O(mn) isteps on a program flow graph (one in which no node has more than two successors), where n is the number of nodes and m the number of expressions which are ever computed. A modified version of this algorithm requires O(n 2) steps of an extended type, where bit vector operations are regarded as one step. We present another algorithm which works only for reducible flow graphs. It requires O(n log n) extended steps.

A physical interpretation of the multiple-node removal algorithm of a flow graph

A simple physical interpretation of the multiple-node removal algorithm for both Coates' flow graph and Mason's signal-flow graph is presented. It is shown that the transmittances associated with the branches of a reduced flow graph can be interpreted as the graph transmissions of certain subgraphs.