Russell Quong - Academia.edu (original) (raw)

Papers by Russell Quong

Register allocation by coloring an interference graph is a common technique. We introduce the wei... more Register allocation by coloring an interference graph is a common technique. We introduce the weighted interference graph (WIG) which improves upon previous approaches in the following ways: (i) the cost of a coloring accurately models the cost of the register assignment, (ii) arbitrary register spills are handled naturally, as the coloring implicitly determines when and what registers to spill, and (iii) the allocation granularity is freely scalable from an instruction level to a per variable level. In particular, at any granularity, a WIG models the degree of interference between two vertices, which improves upon the traditional interference graph. The weights in a WIG incorporate usage counts to reflect the relative cost for spilling a quantity. We model the savings from keeping a variable in a register via negative edge weights. Our method is ideal when near-optimal register allocation is desired and spill code is unavoidable, such as for large frequently-executed basic blocks, ...

For NP-complete problems, it may not be possible to find an optimal solution in polynomial time. ... more For NP-complete problems, it may not be possible to find an optimal solution in polynomial time. However, efficient approximation algorithms for many NP-complete problems do exist. A good approach is to find tighter upper and lower bounds on the optimal solutions. As the gap between these two bounds approaches zero, optimality is reached. For minimization problems, any feasible solution serves as an upper bound. In general, researchers attempt to find heuristic algorithms to narrow the gap by decreasing the upper bound. Another approach is to narrow the gap by increasing the lower bound. To determine a good lower bound on a problem requires careful examination of the problem's characteristics. In this paper, we present an efficient algorithm for calculating a lower bound on the number of bins needed in a bin-packing problem. It is obvious that the sum of the sizes of all objects is a lower bound. In addition to this, we consider objects that cannot share their bins with other objects. We consider a subproblem class which contains only objects whose sizes are greater than $, where L is the size of a bin, given the harmonic partition. An O(n1ogn) algorithm finds a lower bound for the subproblem, which in turn is a lower bound for the original problem. Notably, our approach also leads to a polynomial time algorithm for finding optimal solutions of some special cases of bin-packing. Simulation data show that our lower bound provides an estimate of the optimal number of bins required which is equal to or better than the sum. The approximate error rate is normally less than 1% if our bound is used. The improvement can be as high as 79% when compared to the sum.

Register allocation by coloring an interference graph is a common technique. We introduce the wei... more Register allocation by coloring an interference graph is a common technique. We introduce the weighted interference graph (WIG) which improves upon previous approaches in the following ways: (i) the cost of a coloring accurately models the cost of the register assignment, (ii) arbitrary register spills are handled naturally, as the coloring implicitly determines when and what registers to spill, and (iii) the allocation granularity is freely scalable from an instruction level t o a per variable level. In particular, at any granularity, a WIG models the degree of interference between two vertices, which improves upon the traditional interference graph. The weights in a WIG incorporate usage counts t o reflect the relative cost for spilling a quantity. We model the savings from keeping a variable in a register via negative edge weights. Our method is ideal when near-optimal register allocation is desired and spill code is unavoidable, such as for large frequently-executed basic blocks, as might be produced by inlining and loop unrolling. We show that a WIG gives better allocations than a traditional interference graph when it matters most, namely when there are not enough registers.

Although existing LR(1) or U(1) parser generators suffice for many language recognition problems,... more Although existing LR(1) or U(1) parser generators suffice for many language recognition problems, writing a straightforward grammar to translate a complicated language, such as C++ or even C, remains a non-trivial task. We have often found that adding translation actions to the grammar is harder than writing the grammar itself. Part of the problem is that many languages are context-sensitive. Simple, natural descriptions of these languages escape current language tool technology because they were not designed to handle semantic information. In this paper, we introduce predicated LR (k) and LL (k) parsers as a solution. Predicates provide a general, practical means to utilize semantic tests in parsers. Used in conjunction with k >1 lookahead sets, a predicated parser simplifies the task of writing real translators. Our approach differs from previous work in that (i) we allow multiple predicates to be placed arbitrarily within a production, (ii) we describe the construction of pred...

Proceedings of 21 International Symposium on Computer Architecture, 1994

To evaluate the performance of a memory system, computer architects must determine the miss rate ... more To evaluate the performance of a memory system, computer architects must determine the miss rate m of a cache C when running program P. Typically, the measured miss rate depends on the specific address mapping M of P set arbitrarily by the compiler and linker. In this paper, we remove the effect of the address-mapping on the miss rate by

Theoretical Computer Science, 1992

Quong, R.W., Fast average-case pattern matching by multiplexing sparse tables, Theoretical Comput... more Quong, R.W., Fast average-case pattern matching by multiplexing sparse tables, Theoretical Computer Science 92 (1992) 1655179. Pattern matching consists of finding occurrences of a pattern in some data. One general approach is to sample the data collecting evidence about possible matches. By sampling appropriately, we force matches to be sparse and can encode a table of size m as a series of smaller tables with total size O((In r#/ln In m). This method yields practical algorithms with fast average-case running times for a wide variety of pattern matching and pattern recognition problems. We apply our technique of multiplexing sparse tables to the k-mismatches string searching problem which asks for all occurrences of a pattern string P=p,, pl, _. ,p,_ 1, in a text string

... If you must use LaTeX 2.09 instead of LaTeX2 e. ltoh relies on unique matching braces to deli... more ... If you must use LaTeX 2.09 instead of LaTeX2 e. ltoh relies on unique matching braces to delimit arguments to the latex macros. ... Type, macro name, HTML start, HTML end, input, output. comm, \abc, XYZ, not-used, \abc, XZY. b/e, \begin{abc}, XYZ, ijk, \begin{abc}...\end{abc}, XZY ...

IEEE Transactions on Software Engineering, 2000

To profile the changes made to programs during development and maintenance, the authors have inst... more To profile the changes made to programs during development and maintenance, the authors have instrumented the `make' utility that is used to compile and link programs. With minor modifications, they have used `make' to find out how much time programmers spend waiting for compiling and linking, how many modules are compiled each time a program is linked, and the change

ACM Sigarch Computer Architecture News, 1994

Studies the sample complexity of a continuous binary search problem with probabilistic noise pres... more Studies the sample complexity of a continuous binary search problem with probabilistic noise present in the information. The authors derive a general lower bound on the complexity and propose an algorithm that can solve the problem with arbitrary accuracy and confidence. The authors also give the sufficient condition on the number of samples for the success of the algorithm

Operations research letters, 1995

In this paper, we present an O (n log n) algorithm to compute a tight lower bound for the one-dim... more In this paper, we present an O (n log n) algorithm to compute a tight lower bound for the one-dimensional bin packing problem. We have simulated the algorithm on randomly generated bin packing problems with item sizes drawn uniformly from (a, b), where 0⩽ a< b⩽ B and B ...

Icpp, 1990

... Nichols, markni@&amp;gt;ecn . purdue . edu Howard Jay Siegel, hj@ecn . purdue . ... (... more ... Nichols, markni@&amp;gt;ecn . purdue . edu Howard Jay Siegel, hj@ecn . purdue . ... (e) In a partitionable SIMD machine, the PEGs of a submachine are broadcast all of the code they execute. All PEs within a submachine are implicitly synchron-i zed after every instruction. ...

Acm Transactions on Programming Languages and Systems, 1991

Linking is traditionally a batch process that resolves cross-references between object modules an... more Linking is traditionally a batch process that resolves cross-references between object modules and run-time libraries to produce a stand-alone executable image. Because most program changes only involve a small part of the program, we have implemented an incremental linker, named Inclink, that processes only the changed modules. Inclink generates a new executable in time proportional to the size of change;

Sigplan, 1994

Language translation is a harder and more important problem than language recognition. In particu... more Language translation is a harder and more important problem than language recognition. In particular, programmers implement translators not recognizers. Yet too often, translation is equated with the simpler task of syntactic parsing. This misconception coupled with computing limitations of past computers has led to the almost exclusive use of L/~(1) and LL(1) in parser generators. We claim that use of k > 1 lookahead can and should be available in practice, as it simplifies the translator development. We give several examples justifying our arguments.

Register allocation by coloring an interference graph is a common technique. We introduce the wei... more Register allocation by coloring an interference graph is a common technique. We introduce the weighted interference graph (WIG) which improves upon previous approaches in the following ways: (i) the cost of a coloring accurately models the cost of the register assignment, (ii) arbitrary register spills are handled naturally, as the coloring implicitly determines when and what registers to spill, and (iii) the allocation granularity is freely scalable from an instruction level t o a per variable level. In particular, at any granularity, a WIG models the degree of interference between two vertices, which improves upon the traditional interference graph. The weights in a WIG incorporate usage counts t o reflect the relative cost for spilling a quantity. We model the savings from keeping a variable in a register via negative edge weights. Our method is ideal when near-optimal register allocation is desired and spill code is unavoidable, such as for large frequently-executed basic blocks, as might be produced by inlining and loop unrolling. We show that a WIG gives better allocations than a traditional interference graph when it matters most, namely when there are not enough registers.