%
% converted from refer format by refer-to-bibtex 0.9.2 -- 13:00, 10 Feb 108
% r2b -n -reverse-author
%

}

@TechReport{Sha91,
  author =       "Edwin Hsing-Mean Sha and Kenneth Steiglitz",
  title =        "Reliable Reconfigurable Structures for Array
                 Architectures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-315-91",
  pages =        "24",
  month =        apr,
  year =         "1991",
  abstract =     "This paper describes some explicit constructions for
                 reconfigurable array architectures. Given a working
                 architecture (application graph), we add redundant
                 hardware to increase reliability. The degree of
                 reconfigurability, D R, of a redundant graph is a
                 measure of the cost of reconfiguration after failures.
                 When ${D^R}$ is independent of the size of the
                 application graph, we say the graph is finitely
                 reconfigurable, F R. We present a class of simple
                 layered graphs with a logarithmic number of redundant
                 edges, which can maintain both finite reconfigurability
                 and a fixed level of reliability for a wide class of
                 application graphs. By sacrificing finite
                 reconfigurability, we show that by using expanders we
                 can construct highly reliable structures with the
                 asymptotically optimal number of edges for
                 one-dimensional and tree-like array architectures.",
}


@TechReport{Lovasz91,
  author =       "Laszlo Lovasz and Neal Young",
  title =        "Lecture Notes on Evasiveness of Graph Properties",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-317-91",
  pages =        "49",
  month =        apr,
  year =         "1991",
  abstract =     "These notes cover the first eight lectures of the
                 class Many Models of Complexity taught by L\'aszl\'o
                 Lov\'asz at Princeton University in the Fall of 1990.
                 The first eight lectures were on evasiveness of graph
                 properties and related topics; subsequent lectures were
                 on communication complexity and Kolmogorov complexity
                 and are covered in other sets of notes.\par The
                 fundamental question considered in these notes is,
                 given a function, how many bits of the input an
                 algorithm must check in the worst case before it knows
                 the value of the function. The algorithms considered
                 are deterministic, randomized, and non-deterministic.
                 The functions considered are primarily graph properties
                 --- predicates on edge sets of graphs invariant under
                 relabeling of the edges.",
}


@TechReport{Chazelle91,
  author =       "Bernard Chazelle and Joel Friedman",
  title =        "Point Location Among Hyperplanes and Unidirectional
                 Ray-Shooting",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-333-91",
  pages =        "9",
  month =        jun,
  year =         "1991",
  abstract =     "We present an algorithm for locating a query point $q$
                 in an arrangement of $n$ hyperplanes in $d$-space. The
                 size of the data structure is $O(n sup d$) and the time
                 to answer any query is $O($log $n)$. Unlike previous
                 data structures, our solution will also report, in
                 addition to the face of the arrangement that contains
                 $q$, the first hyperplane that is hit (if any) by
                 shooting the point $q$ in some fixed direction.
                 Actually, if this ray-shooting capability is all that
                 is needed, or if one only desires to know a single
                 vertex of the face enclosing $q$, then the storage can
                 be reduced to $O(n sup d^/($log $n) sup {left ceiling
                 ^d/2^ right ceiling - epsilon}^)$, for any fixed
                 $epsilon ^ > ^ 0$.",
}


@TechReport{Chazelle91a,
  author =       "Bernard Chazelle",
  title =        "An Optimal Convex Hull Algorithm for Points Sets in
                 Any Fixed Dimension",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-336-91",
  pages =        "36",
  month =        jun,
  year =         "1991",
  abstract =     "We present a deterministic algorithm for computing the
                 convex hull of $n$ points in $E sup d$ in optimal $O(n
                 sup {left floor ^d/2^ right floor})$ time, for $d^<^3$.
                 This result settles an open question of long standing:
                 optimal solutions were previously known only in two and
                 three dimensions or alternatively by allowing
                 randomization. The algorithm involves a fairly
                 elaborate dynamic search process, whose fine points are
                 clarified by using an analogy with statistical
                 thermodynamics: this allows us to uncover some
                 unexpected phenomena relating to the convergence of the
                 algorithm. By duality, the algorithm can be used to
                 construct the full lattice structure of the feasible
                 set of $n$ linear constraints in optimal $O(n$ log
                 $n^+^n sup {left floor ^d/2^ right floor})$ time, for
                 any fixed $d$. As an immediate corollary, we obtain an
                 algorithm for computing the Voronoi diagram of $n$
                 points in $d$-space in optimal $O(n$ log $n^+^ n sup
                 {left ceiling ^d/2^ right ceiling})$ time, which is
                 also a new result.",
}


@TechReport{Ahuja91,
  author =       "Clifford Stein Ravindra K. Ahuja and James B. Orlin
                 and Robert E. Tarjan",
  title =        "Improved Algorithms for Bipartite Network Flow",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-338-91",
  pages =        "42",
  month =        may,
  year =         "1991",
  abstract =     "In this paper, we study network flow algorithms for
                 bipartite networks. A network $G^=^(V,E)$ is called
                 $bipartite$ if its vertex set $V$ can be partitioned
                 into two subsets $V sub 1$ and $V sub 2$ such that all
                 edges have one endpoint in $V sub 1$ and the other in
                 $V sub 2$. Let $n^=^|V^|,^n sub 1^=^|{V sub 1}|,^n sub
                 2^=^|{V sub 2}|,^m^=^|E^|$ and assume without loss of
                 generality that $n sub 1^ <= ^ n sub 2$. We call a
                 bipartite network $unbalanced$ if $n sub 1$ $<<$ $n sub
                 2$ and $balanced$ otherwise. (This notion is
                 necessarily imprecise.) We show that several maximum
                 flow algorithms can be substantially sped up when
                 applied to unbalanced networks. The basic idea in these
                 improvements is a $two-edge^push^rule$ that allows us
                 to {"}charge{"} most computation to vertices in $V sub
                 1$, and hence develop algorithms whose running times
                 depend on $n sub 1$ rather than $n$. For example, we
                 show that the two-edge push version of Goldberg and
                 Tarjan's FIFO preflow push algorithm runs in $O(n sub
                 1^m + n size 6 {3 over 1})$ time and that the analogous
                 version of Ahuja and Orlin's excess scaling algorithm
                 runs in $O(n sub 1^m + n size 6 {2 over 1}$ log $U)$
                 time, where $U$ is the largest edge capacity. We also
                 extend our ideas to dynamic tree implementations,
                 parametric maximum flows, and minimum-cost flows.",
}


@TechReport{Rosenberg91,
  author =       "Burton Rosenberg",
  title =        "Lower Bounds in Geometric Searching",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-343-91",
  pages =        "42",
  month =        oct,
  year =         "1991",
  abstract =     "We study algorithms for geometric range searching,
                 particularly for the problems of reporting and counting
                 points inside of axis-parallel rectangles and simplices
                 in Euclidean $d$-space. Lower bounds are discussed as
                 well as the models of computation in which the lower
                 bounds hold. The relevance of these models to practical
                 computing is considered. We then present two new lower
                 bounds for geometric range searching. Related to the
                 problem of computing partial sums off-line, we show
                 that given an array $A$ with $n$ entries in an additive
                 semi-group, and $m$ intervals of the form $I sub
                 k^=^[i,j],$ where $0^<^i^<^j^<=^n,$ then the
                 computation of $A[i]^+ cdot cdot cdot +^[j]$ for all $I
                 sub k$ will require $OMEGA (n^+^m alpha (m,n))$
                 semigroup additions. Here $ alpha $ is the functional
                 inverse of Ackermann's function. Related to the problem
                 of simplex range reporting we prove that given a
                 collection $P$ of $n$ points in $d$-space, any data
                 structure which can be modeled on a pointer machine and
                 which can report the $r$ points inside of an arbitrary
                 $d$-simplex in time $O(n sup delta ^ +^r)$ will require
                 storage $OMEGA size 7 (n sup {d(1 - delta ) -
                 epsilon})$, for any fixed $epsilon > ^0$. Both of these
                 lower bounds are tight within small functional
                 factors.",
}


@TechReport{Ramsey92,
  author =       "Norman Ramsey",
  title =        "Literate Programming Tools Need Not Be Complex",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-351-91",
  pages =        "42",
  month =        oct # " 1991, revised " # sep,
  year =         "1992",
  abstract =     "When it was introduced, literate programming meant
                 WEB. Desire to use This thesis presents research done
                 by the author on competitive analysis of on-line
                 problems.\par An on-line problem is a problem that is
                 given and solved one piece at a time. An on-line
                 strategy for solving such a problem must give the
                 solution to each piece knowing only the current piece
                 and preceding pieces, in ignorance of the pieces to be
                 given in the future.\par We consider on-line strategies
                 that are competitive (guaranteeing solutions whose
                 costs are within a constant factor of optimal) for
                 several combinatorial optimization problems: paging,
                 weighted caching, the k-server problem, and weighted
                 matching.\par We introduce variations on the standard
                 model of competitive analysis for paging: allowing
                 randomization, allowing resource-bounded lookahead, and
                 loose competitiveness, in which performance over a
                 range of fast memory sizes is considered and
                 noncompetitiveness is allowed provided the fault rate
                 is insignificant. Each variation leads to substantially
                 better competitive ratios.\par We present a general
                 technique for competitive analysis of linear
                 optimization problems: competitive analyses are
                 obtained by using linear programming duality to obtain
                 bounds on the optimal cost. The technique is implicit
                 in previous work on paging, weighted caching, and
                 weighted matching. We generalize the implicit previous
                 use of the technique, obtaining the greedy dual
                 algorithm for weighted caching. The strategy
                 generalizes the least-recently-used and
                 first-in-first-out algorithms for paging and the
                 balance algorithm for weighted caching. The analysis
                 strengthens a previous analysis of the balance
                 algorithm for weighted caching.\par We explore the
                 linear programming dual of the k-server problem,
                 showing that the k-server problem is a special case of
                 on-line minimum-weight matching, revealing close
                 relationships between on-line weighted caching and
                 assignment algorithms, and showing how duality can
                 yield potential function analyses. WEB with languages
                 other than Pascal led to the implementation of many
                 versions. WEB is complex, and the difficulty of using
                 WEB creates an artificial barrier to experimentation
                 with literate programming. noweb provides much of the
                 functionality of WEB, with a fraction of the
                 complexity. noweb is independent of the target
                 programming language, and its formatter-dependent part
                 is less than 40~lines. noweb is extensible, because it
                 uses two representations of programs: one easily
                 manipulated by authors and one easily manipulated by
                 tools. This paper explains how to use the {\tt noweb}
                 tools and gives examples of their use. It sketches the
                 implementation of the tools and describes how new tools
                 are added to the set. Because {\tt WEB} and {\tt noweb}
                 overlap, but each does some things that the other
                 cannot, this paper enumerates the differences.",
}


@TechReport{Schaffer92,
  author =       "Russel W. Schaffer",
  title =        "Analysis of Heapsort",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-370-92",
  pages =        "85",
  month =        jun,
  year =         "1992",
  abstract =     "Heapsort is a classical sorting algorithm due to
                 Williams. Given an array to sort, Heapsort first
                 transforms the keys of the array into a heap. The heap
                 is then sorted by repeatedly swapping the root of the
                 heap with the last key in the bottom row, and then
                 sifting this new root down to an appropriate position
                 to restore heap order. In Williams's original Heapsort,
                 the new root is sifted down by repeatedly comparing its
                 two children, and swapping it with its larger child if
                 a comparison shows the child to be larger than the key
                 being sifted. Floyd proposed an important variant of
                 Williams's Heapsort which unconditionally performs the
                 swap with the larger child. This thesis analyzes the
                 asymptotic number of executions of each instruction for
                 both versions of Heapsort in the average, best, and
                 worst cases. In the average case, when sorting a
                 uniformly generated random heap on $N$ distinct keys,
                 Williams's Heapsort performs $\sim 2N\lg N$ key
                 comparisons while Floyd's variant performs $\sim N\lg
                 N$ key comparisons (lg is the logarithm base two).
                 Another quantity of interest is the number of times
                 keys are swapped with their right children. Both
                 Williams's and Floyd's versions of Heapsort expect to
                 perform $\sim {1\over 2}N\lg N$ such swaps. Sedgewick,
                 and independently Fleischer and Wegener, have presented
                 arguments to demonstrate that the number of key
                 comparisons required by Williams's Heapsort in the best
                 case and Floyd's Heapsort in the worst case are $\sim
                 N\lg N$ and $\sim {3\over 2}N\lg N$ respectively. These
                 arguments are extended and applied in a different form
                 to demonstrate that in the worst case, Williams's and
                 Floyd's Heapsorts perform $\sim {3\over 4}N\lg N$ swaps
                 of keys with their right children, while in the best
                 case at most $\sim {1\over 4}N\lg N$ such swaps are
                 performed. For both versions of Heapsort, it is shown
                 that these best and worst case numbers can be found in
                 heaps that also require the best and worst case numbers
                 of key comparisons.",
}


@TechReport{Rogers92,
  author =       "Anne Rogers and Kai Li",
  title =        "Software Support for Speculative Loads",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-372-92",
  pages =        "14",
  month =        may,
  year =         "1992",
  abstract =     "This paper describes a very simple mechanism and
                 related compiler support for software--controlled {\it
                 speculative loads.\/} The compiler issues speculative
                 load instructions based on anticipated data references
                 and the ability of the memory system to hide memory
                 latency in high--performance processors. The
                 architectural support for such a mechanism is simple
                 and minimal, yet handles faults gracefully. We have
                 simulated the speculative load mechanism based on a
                 MIPS processor and a detailed memory system. The
                 results of scientific kernel loops indicate that the
                 speculative load techniques are effective approaches to
                 hiding memory latency.",
}


@TechReport{Barber92,
  author =       "C. Bradford Barber",
  title =        "Computational Geometry with Imprecise Data and
                 Arithmetic",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-377-92",
  pages =        "184",
  month =        oct,
  year =         "1992",
  abstract =     "This thesis presents an algorithm for computing the
                 3-d convex hull of imprecise points using floating
                 point arithmetic. The algorithm produces a set of
                 ''thick'' facets that contain all exact convex hulls of
                 the data. It is based on Quickhull and Beneath--beyond.
                 Parameters for the algorithm include the precision of
                 the data and the maximum angle between adjacent facets.
                 This allows the user to simplify the output and may
                 reduce the exponential growth in output size as
                 dimension increases. It is the first 3-d convex hull
                 algorithm to work with fixed precision arithmetic. We
                 derive a bound for the maximum width of a facet when
                 certain restrictions are satisfied. The algorithm
                 produces a data structure called a {\it locally convex
                 box complex.} Similar to a simplicial complex, a {\it
                 box complex} is a graded DAG of sets called {\it
                 boxes}. Each node of the DAG is a {\it face} of the box
                 complex. A face represents a vertex, edge, facet, or
                 other feature. its box bounds the possible locations of
                 the face. A box complex is {\it locally convex} when
                 hyperplanes define the boxes for facets, and the
                 hyperplanes for adjacent facets meet in a convex angle.
                 The thesis also presents an algorithm for point
                 includion in box complexes and polyhedra. It identifies
                 a subset of the vertices. The subset has odd parity of
                 the point is inside and even parity if it is outside.
                 It is the first point--in--polyhedron algorithm to work
                 in general dimension on arbitrary inputs with fixed
                 precision arithmetic. It is the first
                 point--in--polyhedron algorithm to work when the only
                 geometric information is bounding boxes.",
}


@TechReport{Massacre92,
  author =       "The New Jersey Line-Segment-Saw Massacre",
  title =        "Ayellet Tal, Bernard Chazelle, David Dobkin",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Companion to Video",
  number =       "TR-379-92",
  pages =        "134",
  month =        oct,
  year =         "1992",
  abstract =     "This videotape shows a line segment intersection
                 algorithm in action and illustrates its most important
                 features. The algorithm, due to Chazelle and
                 Edelsbrunner \cite{CE}, has an optimal running time of
                 $O(n log n + k)$, where n is the number of line
                 segments and k is the number of pairwise
                 intersections.\par As in the classical Bentley-Ottmann
                 method \cite{BO}, the algorithm operates in a sweepline
                 fashion by scanning the segments from left to right,
                 and maintaining the vertical visibility map of the
                 region swept along the way. Two important differences
                 are that (i) the schedule includes only the endpoints
                 of the segments and not the intersection points, and
                 (ii) the cross section along the sweepline is
                 maintained in a lazy fashion, meaning that the nodes of
                 the tree representing the cross section might
                 correspond to segments stranded behind past the
                 sweepline. Also, the loop invariant for the sweepline
                 is not simply that the portion of the map left of it
                 should be maintained but also that the map associated
                 with all the segments intersecting the sweepline be
                 available as well. Segments are cut up into smaller
                 pieces in preprocessing, so as to enforce a
                 normalization condition related to the schedule of
                 insertions.\par Production Notes: The animation comes
                 from a system currently being developed at Princeton by
                 Ayellet Tal and David Dobkin. This system is intended
                 to ease the interface between geometric code and the
                 graphics device. It is built on top of Cheyenne, a
                 device independent graphics library developed by David
                 Dobkin and Eleftheros Koutsofios. The program runs on
                 Sun and Silicon Graphics IRIS workstation. Recording
                 was done at the Interactive Computer Graphics Lab at
                 Princeton and editing was done with the assistance of
                 the Princeton Department of Media Services. J.L.
                 Bentley and T.A. Ottmann. Algorithms for reporting and
                 counting geometric intersections. {\em IEEE
                 Transactions on Computers, C-28(9):643-647,} 1979. B.
                 Chazelle and H. Edelsbrunner. An optimal algorithm for
                 intersecting line segments in the plane. {\em Journal
                 of the ACM, 39(1):1-54,} 1992. (Video, July 1992)\par
                 TR-380-92 Run--Time Fault Tolerance For Array
                 Architectures Hsing--Mean Sha (Thesis) As array
                 architectures become larger, surviving hardware
                 failures becomes a critical issue. To achieve fault
                 tolerance and increase reliability, redundancy is added
                 to the system. In this way the original working
                 architectur e can be reconfigured after a failure is
                 detected by replacing components. Since in certain
                 run--time applications reconfiguration should be
                 accomplished as quickly as possible, the efficiency of
                 reconfiguration of a fault--tolerant structure becomes
                 a major concern. This dissertation investigates the
                 relationships among reliability, reconfigurability and
                 the hardware costs of fault--tolerant structures for
                 different classes of array architectures. A
                 mathematical framework is presented, and new measures,
                 {\it local} and {\it finite reconfigurability,} are
                 defined. For run--time fault tolerance, local and
                 finite reconfigurability are desirable properties. It
                 is proved that local reconfigurability and a fixed
                 level of reliability cannot be achieved simultaneously
                 unless a dynamic graph is of dimension at least one
                 greater than the application graph. After this negative
                 result, some highly reliable and easily reconfigurable
                 structures are constructed based on simple layered
                 graphs. An on--line distributed reconfiguration
                 algorithm is presented for finding new bipartite
                 matchings for these constructions. For run--time error
                 detection in array processors, a methodology based on
                 data--dependency graphs is described. It combines the
                 projection method of deriving systolic arrays from
                 dependency graphs with the idea of input--triggered
                 testing. The method is called {\it ITRED,} for {\it
                 Input--driven Time--Redundancy Error Detection.} Tests
                 are triggered by inserting special symbols in the
                 input, and so the approach gives the user flexibility
                 in trading off throughput for error coverage. The
                 method requires no extra {\it PE's} and little extra
                 hardware. To illustrate this approach, an
                 error--detectable systolic array is designed in CMOS
                 for ALL--SUBSTRING COMPARISONS, a problem which arises
                 in applications such as information retrieval, and DNA
                 pattern matching.",
}


@TechReport{with92,
  author =       "A {\em deque with heap order} is a linear list of
                 elements with",
  title =        "Data Structural Bootstrapping, Linear Path
                 Compression, and Catenable Heap Ordered Double Ended
                 Queues",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-381-92",
  pages =        "12",
  month =        jul,
  year =         "1992",
  abstract =     "real-valued keys which allows insertions and deletions
                 of elements at both ends of the list. It also allows
                 the {\em findmin} (equivalently {\em findmax})
                 operation, which returns the element of least
                 (greatest) key, but it does not allow a general {\em
                 deletemin} ({\em deletemax}) operation. Such a data
                 structure is also called a {\em mindeque} ({\em
                 maxdeque}). Whereas implementing mindeques in constant
                 time per operation is a solved problem, catenating
                 mindeques in sublogarithmic time has until now remained
                 open. This paper provides an efficient implementation
                 of catenable mindeques, yielding constant amortized
                 time per operation. The important algorithmic technique
                 employed is an idea which is best described as {\em
                 data structural bootstrapping}: We abstract mindeques
                 so that their elements represent other mindeques,
                 effecting catenation while preserving heap order. The
                 efficiency of the resulting data structure depends upon
                 the complexity of a special case of path compression
                 which we prove requires linear time. Adam L. Buchsbaum,
                 Rajamani Sundar, Robert E. Tarjan",
}


@TechReport{Chao92,
  author =       "Liang-Fang Chao and Andrea S. LaPaugh",
  title =        "Finding All Minimal Shapes in a Routing Channel",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-384-92",
  pages =        "47",
  month =        aug,
  year =         "1992",
  abstract =     "We present an algorithm to find a set of all optimal
                 solutions for a channel replacement problem. A channel
                 consists of two rows of horizontal line segments
                 (representing components). Each line segment contains
                 some terminals with fixed positions. Sets of terminals,
                 called {\it nets,\/} are to be connected. The relative
                 ordering of line segments in each row is fixed. The
                 line segments can be shifted left or right, which will
                 affect the width needed for routing and the length of
                 the channel. We want to find the tradeoff between
                 channel length and routing width. Since the channel
                 routing problem is NP--complete, we use a lower bound
                 on routing width, called density. The {\it density\/}
                 of a placement is the maximum number of nets crossing
                 each vertical cut. We can increase the total length to
                 minimize the channel density, or minimize the total
                 length by increasing the channel density. The pair
                 (density, total length) is called the {\it shape\/} of
                 a placement. A shape is minimal if a decrease in
                 density would cause an increase in total length, and
                 vice versa. Our algorithm computes all the minimal
                 shapes in $O(N^{4})$ time, where $N$ is the number of
                 nets. This is the first known polynomial algorithm for
                 this problem.",
}


@TechReport{Leighton92,
  author =       "Ramesh Sitaraman Tom Leighton and Bruce Maggs",
  title =        "On the Fault Tolerance of Some Popular Bounded-Degree
                 Networks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-385-92",
  pages =        "42",
  month =        sep,
  year =         "1992",
  abstract =     "In this paper, we analyze the ability of several
                 bounded-degree networks that are commonly used for
                 parallel computation to tolerate faults. Among other
                 things, we show that an $N$-node butterfly containing
                 $N^{1-\epsilon}$ worst-case faults (for any constant
                 $\epsilon > 0$) can emulate a fault-free butterfly of
                 the same size with only constant slowdown. Similar
                 results are proved for the shuffle-exchange graph.
                 Hence, these networks become the first connected
                 bounded-degree networks known to be able to sustain
                 more than a constant number of worst-case faults
                 without suffering more than a constant-factor slowdown
                 in performance. We also show that an $N$-node butterfly
                 whose nodes fail with some constant probability $p$ can
                 emulate a fault-free version of itself with a slowdown
                 of $2^{O(\log^* N)}$, which is a very slowly increasing
                 function of $N$. The proofs of these results combine
                 the technique of redundant computation with new
                 algorithms for (packet) routing around faults in
                 hypercubic networks. Techniques for reconfiguring
                 hypercubic networks around faults that do not rely on
                 redundant computation are also presented. These
                 techniques are less tolerant of faults but are more
                 widely applicable since they can be used with other
                 networks such as binary trees and meshes of trees.",
}


@TechReport{Fraser92,
  author =       "Todd A. Proebsting Christopher W. Fraser and David R.
                 Hanson",
  title =        "Engineering Efficient Code Generators Using Tree
                 Matching and Dynamic Programming",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-386-92",
  pages =        "12",
  month =        aug,
  year =         "1992",
  abstract =     "Many code generator generators use tree pattern
                 matching and dynamic programming. This note describes a
                 simple program that generates matchers that are fast,
                 compact, and easy to understand. It is simpler than
                 common alternatives: 200--700 lines of Icon versus 3000
                 lines of C for Twig and 5000 for {\tt burg}. Its
                 matchers run up to 25 times faster than Twig's. They
                 are necessarily slower than {\tt burg}'s BURS
                 (bottom-up rewrite system) matchers but they are more
                 flexible and still practical.",
}


@TechReport{Buchsbaum92,
  author =       "Adam L. Buchsbaum and Martin C. Carlisle",
  title =        "Determining Single Connectivity in Directed Graphs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-390-92",
  pages =        "7",
  month =        sep,
  year =         "1992",
  abstract =     "In this paper, we consider the problem of determining
                 whether or not a directed graph contains a pair of
                 vertices connected by two distinct simple paths; if it
                 does not, we say it is {\em singly connected}. A
                 straightforward implementation using $n$ depth first
                 searches requires $O(nm)$ time on an $n$-vertex,
                 $m$-arc digraph; we obtain an $O(n^2)$ time algorithm
                 by using contraction wherever possible.",
}


@TechReport{Ting93,
  author =       "Hing-Fung Ting",
  title =        "Computational Complexity for Selection Problems with
                 Parity-Like Tests",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-392-92",
  pages =        "52",
  month =        jan,
  year =         "1993",
  abstract =     "The computational complexity of sorting type problems
                 using pairwise comparisons has been studied
                 extensively. For example, let $W_k ( n )$ denote the
                 number of pairwise comparisons needed to find the $k$
                 largests among $n$ distinct real numbers. It is known
                 that $W_1 ( n ) = n - 1$, $W_2 ( n ) = n - 2 + \lceil
                 \log n \rceil$ and, for fixed $k$, $W_k ( n ) = n + ( k
                 - 1 ) \lceil \log n \rceil + O ( 1 )$. In this thesis,
                 we study the computational complexity for selection
                 problems when some more powerful type of queries,
                 namely, the queries ``$\xprod:0$'' are allowed. We call
                 queries of the type ``$\xprod:0$'' partiy-like tests.
                 In some problems, using parity-like tests can
                 significantly reduced the number of queries needed to
                 be asked to find an answer. For example, $\theta ( n
                 \log n )$ queries are necessary to determine whether
                 $n$ real numbers are distinct if the queries are
                 restricted to pairwise comparisons. On the other hand,
                 one query ``$\prod_{i \not= j} (x_i - x_j ) > 0 ?$'' is
                 sufficient to solve the problem. In the thesis, we
                 study the problem of selecting the $k$ largests of $n$
                 distinct real numbers. We show that when queries are
                 restricted to parity-like tests, $n-k+\lceil
                 \log((n(n-1)...(n-k+2))\rceil$ queries are necessary to
                 solve the problem. In other words, the parity-like
                 tests are not much more powerful than the simple
                 pairwise comparisons in this problem. We also study the
                 problem of finding the maximum of $n$ numbers using
                 small number of queries. The result on selecting the
                 $k$ largests implies $n-1$ parity-like tests are
                 necessary to find the maximum of $n$ numbers. However,
                 we show that for any fixed $\varepsilon>0$, there is a
                 decision tree algorithm which finds the maximum of $n$
                 numbers with error probability $<\varepsilon$ and uses
                 at most $O((\log n)^2)$ parity-like tests. On the other
                 hand, we show that if the queries are restricted to
                 pairwise comparisons, ``Is $x_i$ is the median of
                 ${\textbraceleft}x_i,x_j,x_t{\textbraceright}$?'', ``Is
                 the rank of $x_i$ among $x_1,...,x_n$ even?'', ``Is the
                 rank of $x_i$ equal to $k$?'' or any other type of
                 queries which depend on a small number of arguments,
                 $\Omega(n)$ queries are necessary even if we only want
                 the decision tree to be correct on a small fraction of
                 the inputs. The last result is for the problem of
                 determining the rank of $x_i$ among $x_1,x_2,...,x_n$
                 when the rank is already known to be smaller than some
                 constant $k$. We show that $\min(n-\frac{n}{k}+\log k,
                 k^2\log n)$ parity-like tests are sufficient to solve
                 the problem. On the other hand, $n-1$ is the lower
                 bound for the problem if only pairwise comparisons are
                 allowed.",
}


@TechReport{Chazelle92,
  author =       "Bernard Chazelle and Jiri Matousek",
  title =        "On Linear-time Deterministic Algorithms for
                 Optimization Problems in Fixed Dimension",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-393-92",
  pages =        "16",
  month =        oct,
  year =         "1992",
  abstract =     "We show that with recently developed derandomization
                 techniques, one can convert Clarkson's randomized
                 algorithm for linear programming in fixed dimension
                 into a linear-time deterministic one. The constant of
                 proportionality is $d^{O(d)}$, which is better than for
                 previously known such algorithms. We show that the
                 algorithm works in a fairly general abstract setting,
                 which allows us to solve various other problems (such
                 as finding the maximum volume ellipsoid inscribed into
                 the intersection of $n$ halfspaces) in linear time.",
}


@TechReport{Greenstreet93,
  author =       "Mark R. Greenstreet",
  title =        "{STARI}: {A} Technique for High--Bandwidth
                 Communication",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-394-92",
  pages =        "165",
  month =        jan,
  year =         "1993",
  abstract =     "This dissertation presents a novel technique for
                 high--bandwidth communication called STARI, {\em
                 Self--Timed At Receiver's Input}. STARI is a hybrid of
                 synchronous and self--timed design techniques. STARI is
                 provably correct, well suited for CMOS implementation,
                 and offers a practical, cost effective approach to
                 interprocessor communication in a multiprocessor. To
                 demonstrate STARI, a CMOS chip has been implemented and
                 is described here. STARI is motivated by limitations of
                 purely synchronous or purely self--timed hardware. This
                 dissertation begins with an asymptotic analysis of the
                 performance of self--timed pipelines. It is shown that
                 self--timed pipelines can achieve linear speedup under
                 an assumption of uniform interconnect delays. However,
                 practical designs have non--uniform interconnect
                 because of the hierarchy of packaging. In these
                 designs, the performance is limited by the latency of
                 the slowest interconnect. To exploit the
                 high--bandwidth offered by STARI in a multiprocessor,
                 each processor node must have a memory system that
                 offers high--bandwidth data transfers to the STARI
                 interface and low latency access to the local CPU.
                 Dual--port memories allow both of these goals to be
                 met. Consistency problems that arise when using
                 dual--port memories are identified and two software
                 solutions are presented and analyzed.",
}


@TechReport{Shao92,
  author =       "Zhong Shao and Andrew W. Appel",
  title =        "Smartest Recompilation",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-395-92",
  pages =        "32",
  month =        oct,
  year =         "1992",
  abstract =     "To separately compile a program module in traditional
                 statically--typed languages, one has to manually write
                 down an import interface which explicitly specifies all
                 the external symbols referenced in the module. Whenever
                 the definitions of these external symbols are changed,
                 the module has to be recompiled. In this paper, we
                 present an algorithm which can automatically infer the
                 ``minimum'' import interface for any module in
                 languages based on the Damas--Milner type discipline
                 (e.g., ML). By ``minimum'', we mean that the interface
                 specifies a set of assumptions (for external symbols)
                 that are just enough to make the module type--check and
                 compile. By compiling each module using its ``minimum''
                 import interface, we get a separate compilation method
                 that can achieve the following optimal property: {\em A
                 compilation unit never needs to be recompiled unless
                 its own implementation changes.}",
}


@TechReport{Blaze93,
  author =       "Matthew A. Blaze",
  title =        "Caching in Large-Scale Distributed File Systems",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-397-92",
  pages =        "89",
  month =        jan,
  year =         "1993",
  abstract =     "This thesis examines the problem of cache organization
                 for very large-scale distributed file systems (DFSs).
                 Conventional DFSs, based on the client--server model,
                 suffer from bottlenecks when the total client load
                 exceeds the server's capacity. Previous work has
                 suggested that hierarchical client organizations can
                 ameliorate the problem somewhat, but at the expense of
                 a substantial increase in client latency. An analysis
                 of existing DFS workloads reveals that there is
                 considerable regularity in client file access patterns
                 and that widely shared files lend themselves especially
                 well to caching techniques. In particular, a large
                 proportion of ``cache miss'' traffic is for files that
                 are already copied in another client's cache. If
                 clients can share these cached files, the server's load
                 can be reduced by a potentially large margin, making
                 larger-scale systems possible. We introduce the notion
                 of {\em dynamic hierarchical caching}, in which
                 adaptive client hierarchies are constructed on a file -
                 by - file basis. Trace - driven simulation and workload
                 - driven runs of a prototype file system suggest that
                 dynamic hierarchies can reduce server load
                 substantially without the client performance penalties
                 associated with more static schemes.",
}


@TechReport{Golan92,
  author =       "Michael Golan and David R. Hanson",
  title =        "{DUEL} -- {A} Very High-Level Debugging Language",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-399-92",
  pages =        "16",
  month =        nov,
  year =         "1992",
  abstract =     "Most source-level debuggers accept expressions in the
                 source language, e.g., C, and can print source-language
                 values. This approach is usually justified on grounds
                 that programmers need to know only one language. But
                 the evaluation of source-language expressions or even
                 statements is poorly suited for making non-trivial
                 queries about the program state, e.g., ``which elements
                 of array \verb|x[100]| are positive?'' {\rm Duel}
                 departs from the conventional wisdom: It is a very
                 high-level language designed specifically for
                 source-level debugging of C programs. {\rm Duel}
                 expressions are a superset of C's and include
                 ``generators,'' which are expressions that can produce
                 zero or more values and are inspired by Icon, APL, and
                 LISP. For example, \verb|x[..100] >? 0| displays the
                 positive elements of {\tt x} and their indices. {\rm
                 Duel} is implemented on top of {\tt gdb} and adds one
                 new command to evaluate {\rm Duel} expressions and
                 display their results. This paper describes {\rm
                 Duel}'s semantics and syntax, gives examples of its
                 use, and outlines its implementation. {\rm Duel} is
                 freely available and could be interfaced to other
                 debuggers.",
}


@TechReport{Support93,
  author =       "Memory Support",
  title =        "An Evaluation of Multiprocessor Cache Coherence Based
                 on Virtual",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-401-92",
  pages =        "190",
  month =        jan,
  year =         "1993",
  abstract =     "Karin Petersen and Kai Li This paper presents an
                 evaluation of the impact of several architectural
                 parameters on the performance of Virtual Memory (VM)
                 based cache coherence schemes for shared-memory
                 multiprocessors. The VM-based c ache coherence schemes
                 use the traditional VM translation hardware on each
                 processor to detect memory access attempts that might
                 leave caches incoherent, and maintain coherence through
                 VM-level system software. The implementation of this
                 class of coherence schemes is flexible and economical:
                 It allows differe nt consistency models, requires no
                 special hardware for multiprocessor cache coherence,
                 and supports arbitrary interconnection networks.\par We
                 used trace-driven simulations to evaluate the effect of
                 different architectural parameters on the performance
                 of the VM-based schemes. These parameters include VM
                 page sizes, write-back and write-through caches, memory
                 access latencies, bus and crossbar interconnections,
                 and different cache sizes. Our results show that for
                 appropriate parameters VM-based cache coherence is an
                 economical and practical approach for building
                 shared-memory multiprocessors. (15 pages, December
                 1992)\par TR 402-92 Fully Dynamic Graph Algorithms and
                 Their Data Structures Monika Rauch (Thesis) We present
                 four fully dynamic algorithms, i.e., algorithms that
                 are able to answer queries about properties of a graph
                 or a set during a sequence of modifications of the
                 graph or set. Additionally, we give lower bounds for
                 fully dynamic graph algorithms. The first three
                 algorithms maintain properties of graphs during
                 insertions and deletions of edges and vertices. %These
                 algorithms are called fully dynamic graph algorithms.
                 Let $n$ denote the number of vertices in a graph and
                 $m$ the number of edges. We give the first sublinear
                 time algorithm for maintaining biconnectivity in
                 graphs. A query can be answered in constant time. The
                 amortized time of an insertion or deletion is
                 $O(m^{2/3})$. A slight variation of the algorithm gives
                 an amortized running time of $O(\sqrt {n} \log n)$ per
                 insertion or deletion in a plane graph. The worst-case
                 running time per query is $O(\log ^2 n)$ in a plane
                 graph. The second data structure maintains two-edge
                 connectivity in plane graphs in a fully dynamic
                 environment. It achieves a worst case running time of
                 $O(\log ^2 n)$ per insertion or deletion and $O(\log
                 n)$ per query. Finally, we give an algorithm for
                 deciding whether adding an edge to a plane graph
                 maintains the planarity of its embedding. If the edge
                 can be added, the algorithm returns a face into which
                 the edge can be embedded without destroying the
                 planarity of the embedding. Any query and any insertion
                 or deletion of an edge takes $O(\log ^2 n)$ time. All
                 of the algorithms use $O(n)$ space and isolated
                 vertices may be inserted in constant time. In addition,
                 we give a lower bound in the cell probe model of
                 $\Omega (\log n / \log \log n)$ per operation for
                 fully-dynamic planarity testing and for fully-dynamic
                 $k$-edge connectivity and $k$-vertex connectivity in
                 plane graphs for constant $k$. The fourth algorithm
                 maintains predecessors in integer sets during
                 insertions and deletions of elements. The integers are
                 chosen from the universe ${\textbraceleft}0, 1, \dots
                 ,u-1{\textbraceright}$. There is an upper bound of $O(
                 \log \log u)$ for this problem and a lower bound of
                 $\Omega (\log \log u)$ per query operation (even for
                 randomized algorithms) in the cell probe model. If the
                 set of numbers is uniformly distributed over the
                 universe, we give an algorithm with worst case query
                 time $O(1)$ and amortized expected time $O(1)$ for any
                 insertion or deletion. (121 pages, January 1993)\par TR
                 403-92 A Retargetable Debugger Norman Ramsey (Thesis)
                 Debuggers are specific to the machines, operating
                 systems, and languages that they support. Much of a
                 debugger has to be re-implemented for each new machine,
                 so debuggers that work with a variety of machines and
                 operating systems can get unwieldy. Improvements to
                 debuggers may be lost unless they are re-implemented as
                 users move to new machines. If retargeting debuggers
                 were easier, other improvements would be more valuable.
                 This thesis describes the design and implementation of
                 {\tt ldb}, a prototype retargetable debugger. Dealing
                 with symbol-table formats is one of the most
                 machine-dependent aspects of debuggers. {\tt ldb}
                 eliminates this machine dependence by using one format
                 on all machines. The format is a language---a dialect
                 of PostScript, which is extensible and can represent
                 procedures. {\tt ldb} reduces retargeting effort
                 associated with variations in run-time support by
                 controlling its target process using a debug nub, which
                 is a small piece of object code linked with the target
                 program. Much of a debugger's job is to undo what the
                 compiler has done or to do what the compiler could do,
                 but at run time. For example, to print the value of a
                 variable, the debugger must undo the compiler's mapping
                 of source-level data to the machine level. To evaluate
                 an expression, the debugger must check that it is
                 syntactically and semantically correct and translate it
                 into an executable form. {\tt ldb} makes the compiler
                 do as much of this work as possible. The compiler emits
                 PostScript that {\tt ldb} uses to print values. A
                 variant of the compiler runs at debug time and compiles
                 expressions into other PostScript, which {\tt ldb} uses
                 to evaluate the expressions. Debugging tasks like
                 planting breakpoints and walking the call stack have no
                 analogs in a compiler. {\tt ldb} reduces retargeting
                 effort for these tasks by using layers of abstraction
                 to minimize machine-dependent code, which is confined
                 to the innermost layers. These techniques produce a
                 debugger with little machine-dependent code. {\tt
                 ldb}'s total code size is about 15,000~lines of
                 Modula-3 and~C, but it needs no more than 550~lines of
                 machine-dependent code for any of its 4~targets.",
}


@TechReport{Chazelle93,
  author =       "Bernard Chazelle",
  title =        "Quasi-Orthogonality via Finite-Differencing: An
                 Elementary Approach to Geometric Discrepancy",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-407-93",
  pages =        "13",
  month =        feb,
  year =         "1993",
  abstract =     "It is possible to place $n$ points in $d$-space so
                 that, given any two-coloring of the points, there
                 exists a halfspace within which one color dominates the
                 other by as much as $c n^{1/2- 1/2d} $, for some
                 constant $c>0$. This result was proven in a slightly
                 weaker form by Beck and the bound was later tightened
                 by Alexander. It was shown to be quasi-optimal by
                 Matou\v{s}ek, Welzl, and Wernisch. The lower bound
                 proofs are highly technical and do not provide much
                 intuitive insight into the ``large-discrepancy''
                 phenomenon. We develop a proof technique which allows
                 us to rederive the same lower bound in a much simpler
                 fashion. We give a probabilistic interpretation of the
                 result and we discuss the connection of our method to
                 Beck's Fourier transform approach. We also provide a
                 quasi-optimal lower bound on the discrepancy of
                 fixed-size rotated boxes, which significantly improves
                 the previous bound.",
}


@TechReport{Aupperle93,
  author =       "Larry Aupperle and Pat Hanrahan",
  title =        "A Hierarchical Illumination Algorithm for Surfaces
                 with Glossy Reflection",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-410-93",
  pages =        "28",
  month =        jan,
  year =         "1993",
  abstract =     "We develop a radiance formulation for discrete three
                 point transport, and a new measure and description of
                 reflectance: {\em area reflectance}. This formulation
                 and associated reflectance allow an estimate of\par We
                 have implemented and analyzed this algorithm over
                 surfaces exhibiting glossy specular and diffuse
                 reflection. Theoretical growth in light transport
                 interactions is shown to be $O(n \log n)$ for
                 sufficient refinement, where $n$ is the number of
                 elements at the finest level of subdivision within the
                 environment --- in trials, this growth has been nearly
                 linear. Naive implementation of three point transport
                 would require $O(n^3)$ element-triple interactions.",
}


@TechReport{Dobkin93,
  author =       "David Dobkin and Ayellet Tal",
  title =        "Building and Using Polyhedral Hierarchies",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-411-93",
  pages =        "28",
  year =         "February 1993, video",
  abstract =     "This animation shows the techniques used to build a
                 hierarchy of polyhedra as a preprocessing step for
                 intersection detection algorithms. We show here how the
                 hierarchy is created from a polyhedron and animate an
                 algorithm for detecting the intersection between a
                 polyhedron and a plane.\par The hierarchical data
                 structure gives a concise representation for polyhedra
                 that is useful in various searching tasks. Given a
                 polyhedron, $P$, we build a hierarchy $P_0 = P, P_1 ,
                 ... ,P_k$ such that $P_k$ is a tetrahedron. Each
                 $P_{i+1}$ is the convex hull of a subset of the
                 vertices of its parent $P_i$. $P_{i+1}$ is formed by
                 removing in turn each vertex in $V(P_{i+1}) - V(P_i)$.
                 The cone of faces attached to the vertex is also
                 removed. This leaves a hole in the polyhedron. This
                 hole is retriangulated in convex fashion. By removing
                 an independent set of vertices, we assure that the
                 apexes of removed cones are not connected. As a result
                 we can reattach one or many cones and retain a convex
                 object. We only remove vertices of degree less than 12.
                 As a result, the hierarchy has logarithmic depth.
                 Computing the hierarchy requires linear time and it can
                 be stored in linear space. The initial segment of the
                 video shows the creation of a 6 level hierarchy from a
                 convex polyhedron built on 30 vertices. Colors are used
                 to code the levels .\par The hierarchy has been
                 constructed as a search tool. We demonstrate its use in
                 searching during the final segments of the video. We
                 begin with the task of determining if a polyhedron
                 intersects a plane. This is done by determining if the
                 polyhedron at each level of the hierarchy intersects
                 the plane and finding the closest vertex if there is no
                 intersection. At the initial level, this computation
                 can be done in constant time by enumeration. The
                 hierarchy was constructed to simplify growth between
                 levels. In particular, we need only consider growth
                 affecting two edges adjacent to the closest vertex.
                 This amounts to a maximum of 4 cones reattached at each
                 level. Since the cones are formed from vertices of
                 bounded degree, this growth can be done in constant
                 time, also. As a result, a preprocessed polyhedron's
                 intersection with a plane can be detected in $O(log ~
                 n)$ time. We trace the hierarchical growth by
                 highlighting the closest vertex and extremal edges. We
                 also display the separating plane. Watching the cones
                 return to the polyhedron we are able to see the
                 algorithm determine if a near vertex is closest or new
                 edges are extremal.\par This video was prepared in the
                 computer science department at Princeton University.
                 Animation software was attached to code for computing
                 the hierarchy and detecting intersections. The programs
                 were written in C to run under UNIX on a Silicon
                 Graphics Iris. Recording was done at the Interactive
                 Computer Graphics Lab at Princeton and editing was done
                 with the assistance of the Princeton Department of
                 Media Services.\par We thank Copper Giloth for helping
                 with various artistic aspects of the animation. Kirk
                 Alexander and Mike Mills led us through many difficult
                 tasks in helping us produce the final video.",
}


@TechReport{Dimension93,
  author =       "d Dimension",
  title =        "On Linear-time Deterministic Algorithms for
                 Optimization Problems in Fixe",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-413-93",
  pages =        "16",
  month =        mar,
  year =         "1993",
  abstract =     "Bernard Chazelle and Jiri Matousek We show that with
                 recently developed derandomization techniques, one can
                 convert Clarkson's randomized algorithm for linear
                 programming in fixed dimension into a linear-time
                 deterministic one. The constant of proportionality is
                 $d^{O(d)}$, which is better than for previously known
                 such algorithms. We show that the algorithm works in a
                 fairly general abstract setting, which allows us to
                 solve various other problems, e.g., computing the
                 minimum-volume ellipsoid enclosing a set of $n$ points,
                 finding the maximum volume ellipsoid in the
                 intersection of $n$ halfspaces.",
}


@TechReport{Sitaraman93,
  author =       "Ramesh Kumar Sitaraman",
  title =        "Communication and Fault Tolerance in Parallel
                 Computers",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-414-93",
  pages =        "116",
  month =        jun,
  year =         "1993",
  abstract =     "This thesis explores two fundamental issues in the
                 design of large-scale parallel computers: {\it
                 communication \/} and {\it fault tolerance\/}.\par In
                 Chapter 1, we introduce and provide motivation for the
                 problems that we study in this thesis.\par Chapter 2
                 examines several simple algorithms for routing packets
                 on butterfly networks with bounded queues. Among other
                 things, we show that for any greedy queuing protocol, a
                 routing problem in which each of the $N$ inputs sends a
                 packet to a randomly chosen output requires $O(\log N)$
                 steps, with high probability, provided that the queue
                 size is a sufficiently large, but fixed, constant.\par
                 In Chapter 3, we analyze the fault-tolerance properties
                 of several bounded-degree hypercubic networks that are
                 commonly used for parallel computation. Among other
                 things, we show that an $N$-node butterfly containing
                 $N^{1-\epsilon}$ worst-case faults (for any constant
                 $\epsilon > 0$) can emulate a fault-free butterfly of
                 the same size with only constant slowdown. Similar
                 results are proved for the shuffle-exchange graph.
                 Hence, these networks become the first connected
                 bounded-degree networks known to be able to sustain
                 more than a constant number of worst-case faults
                 without suffering more than a constant-factor slowdown
                 in performance.\par In Chapter 4, we study the ability
                 of array-based networks to tolerate faults. Among other
                 things, we show that an $N \times N$ two-dimensional
                 array can sustain $N^{1-\epsilon}$ worst-case faults,
                 for some fixed $\epsilon < 1$, and still emulate a
                 fully-functioning $N \times N$ array with only constant
                 slowdown.\par In Chapter 5, we study a concurrent error
                 detection scheme called Algorithm Based Fault Tolerance
                 (ABFT). Unlike the schemes developed in Chapters 3 and
                 4 to tolerate permanent faults, the scheme studied in
                 this chapter is primarily aimed at tolerating transient
                 faults in a parallel computer. The main contribution of
                 this chapter is to propose a simple and novel algorithm
                 called RANDGEN to generate data-check relationships. By
                 simply varying its parameters, RANDGEN can produce
                 data-check relationships with a wide spectrum of
                 properties, many of which have been considered
                 important in recent ABFT designs.",
}


@TechReport{Allender93,
  author =       "Eric Allender and Jia Jiao",
  title =        "Depth Reduction for Noncommutative Arithmetic Circuits
                 (Extended Abstract)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-417-93",
  pages =        "8",
  month =        mar,
  year =         "1993",
  abstract =     "We show that for every family of arithmetic circuits
                 of polynomial size and degree over the algebra
                 ($\Sigma^*,$ max, concat), there is an equivalent
                 family of arithmetic circuits of depth $\log^2 n$. (The
                 depth can be reduced to $\log n$ if unbounded fan-in is
                 allowed.) This is the first depth-reduction result for
                 arithmetic circuits over a noncommutative semiring, and
                 it complements the lower bounds of [nisan] and
                 [kosaraju] showing that depth reduction cannot be done
                 in the general noncommutative setting. The (max,concat)
                 semiring is of interest, because it characterizes
                 certain classes of optimization problems. In
                 particular, our results show that OptSAC$^1$ is
                 contained in AC$^1$.\par We also prove other results
                 relating Boolean and arithmetic circuit complexity. We
                 show that AC$^1$ has no more power than arithmetic
                 circuits of polynomial size and degree $n^{O(\log \log
                 n)}$ (improving the trivial bound of $n^{O(\log n)}$).
                 Connections are drawn between TC$^1$ and arithmetic
                 circuits of polynomial size and degree.",
}


@TechReport{Allender93a,
  author =       "Jose Balc\'{a}zar Eric Allender and Neil Immerman",
  title =        "A First--Order Isomorphism Theorem",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-418-93",
  pages =        "15",
  month =        mar,
  year =         "1993",
  abstract =     "We show that for most complexity classes of interest,
                 all sets complete under first-order projections are
                 isomorphic under first-order isomorphisms. That is, a
                 very restricted version of the Berman-Hartmanis
                 Conjecture holds.",
}


@TechReport{Buchsbaum93,
  author =       "Adam L. Buchsbaum and Robert E. Tarjan",
  title =        "Confluently Persistent Deques via Data-Structural
                 Bootstrapping",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-420-93",
  pages =        "22",
  month =        mar,
  year =         "1993",
  abstract =     "We introduce {\em data-structural bootstrapping}, a
                 technique to design data structures recursively, and
                 use it to design confluently persistent deques. Our
                 data structure requires $O(\log^* k)$ worst-case time
                 and space per deletion, where $k$ is the total number
                 of deque operations, and constant worst-case time and
                 space for other operations. Further, the data structure
                 allows a purely functional implementation, with no side
                 effects. This improves a previous result of Driscoll,
                 Sleator, and Tarjan.",
}


@TechReport{Buchsbaum93a,
  author =       "Adam Buchsbaum and Rajamani Sundar and Robert E.
                 Tarjan",
  title =        "Lazy Structure Sharing for Query Optimization",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-422-93",
  pages =        "12",
  month =        apr,
  year =         "1993",
  abstract =     "We study {\em lazy structure sharing} as a tool for
                 optimizing equivalence testing on complex data types.
                 We investigate a number of strategies for a restricted
                 case of the problem and provide upper and lower bounds
                 on their performance (how quickly they effect ideal
                 configurations of our data structure). In most cases,
                 the bounds provide nontrivial improvements over the
                 na{\"\i}ve linear-time equivalence-testing strategy
                 that employs no optimization.",
}


@TechReport{Buchsbaum93b,
  author =       "Adam L. Buchsbaum",
  title =        "Data-Structural Bootstrapping and Catenable Deques",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-423-93",
  pages =        "90",
  month =        jun,
  year =         "1993",
  abstract =     "The {\em list} is a fundamental data structure. It
                 stores a linearly ordered collection of elements and
                 allows access only to the front and rear elements of
                 the list. {\em Catenation} can be applied to lists,
                 unifying the rear of one list with the front of
                 another. Absent other requirements, the basic list
                 operations, including catenation, have straightforward
                 implementations. If the list has certain secondary
                 properties, however, the operations, particularly
                 catenation, become more difficult.\par {\em
                 Non-destructive lists}, for example, support
                 side-effect-free list operations and are fundamental in
                 high-level programming languages such as LISP, ML, and
                 Scheme. Actual implementations of non-destructive lists
                 usually apply simple copying methods directly to the
                 lists or to trees representing the lists. These copying
                 methods have high space and time overhead, however.
                 {\em Persistent data structures} allow operations on
                 old versions, and therefore techniques for designing
                 persistent data structures might be useful in devising
                 non-destructive lists. Current persistence techniques,
                 however, can be applied to only one version of a data
                 structure at a time and therefore do not accommodate
                 list catenation. {\em Heap-ordered lists}, which
                 provide access to minimum elements, also have efficient
                 implementations that do not allow catenation. These two
                 data structures are related: in both cases, the
                 addition of a secondary property complicates list
                 catenation. In this thesis, we develop a technique
                 called {\em data-structural bootstrapping} to address
                 these problems.\par Bootstrapping uses two basic ideas.
                 First, we {\em abstract} a data structure by
                 representing it in terms of its own secondary property.
                 Inserting the abstracted data structure as an element
                 into the same type of non-catenable data structure on a
                 higher level effects catenation. Second, we
                 homogeneously {\em decompose} a data structure into a
                 group of smaller data structures. This produces an
                 efficient, recursive implementation.\par
                 Data-structural bootstrapping yields efficient
                 implementations of both non-de\-struc\-tive lists
                 ($O(\log^*n)$ worst-case time and space per operation
                 on a list of $n$ elements) and catenable heap-ordered
                 lists ($O(1)$ amortized time per operation). The latter
                 have applications in pagination, network sensitivity
                 analysis, and VLSI river routing. Catenable
                 heap-ordered lists derive their efficiency from a
                 special case of path compression that we prove takes
                 only linear time.",
}


@TechReport{Allender93b,
  author =       "Eric Allender and Vivek Gore",
  title =        "A Uniform Circuit Lower Bound for the Permanent",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-426-93",
  pages =        "38",
  month =        jun,
  year =         "1993",
  abstract =     "We show that uniform families of ACC circuits of
                 subexponential size cannot compute the permanent
                 function. This also implies similar lower bounds for
                 certain sets in PP. This is one of the very few
                 examples of a lower bound in circuit complexity whose
                 proof hinges on the uniformity condition; it is still
                 unknown if there is any set in Ntime ($2^{n^{O(1)}}$)
                 that does not have nonuniform ACC circuits.",
}


@TechReport{Cox93,
  author =       "Michael Cox and Patrick Hanrahan",
  title =        "Evenly Distributed Depth is the Worst for Distributed
                 Snooping",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-427-93",
  pages =        "4",
  month =        jun,
  year =         "1993",
  abstract =     "In the purely object-parallel approach to
                 multiprocessor rendering, each processor is assigned
                 responsibility to render a subset of the graphics
                 database. When rendering is complete, pixels from the
                 processors must be merged and globally z-buffered. On
                 an arbitrary multiprocessor interconnection network,
                 the straightforward algorithm for pixel merging
                 requires $\bar{d} A$ total network bandwidth per frame,
                 where $\bar{d}$ is the depth complexity of the scene
                 and $A$ is the area of the screen or window. In another
                 paper we have presented a {\em distributed snooping
                 algorithm} for pixel merging that requires
                 $\log(\bar{d}) A$ expected network bandwidth per frame.
                 In that paper, to simplify the analysis we required the
                 assumption that depth is ``evenly'' distributed over
                 the screen, and we claimed that this assumption
                 represented a worst-case for expected traffic. In the
                 current paper we prove this claim.",
}


@TechReport{Dixon93,
  author =       "Brandon Dixon",
  title =        "Minimum Spanning Tree Verification, Fast Priority
                 Queues, and Massively Parallel Factoring",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-428-93",
  pages =        "104",
  month =        oct,
  year =         "1993",
  abstract =     "We present algorithms for problems from three
                 different areas of research on parallel computation.
                 The first problem that we consider is verifying minimum
                 spanning trees. Given a weighted, undirected graph $G$
                 and a spanning tree $T$ of $G$, our algorithms
                 determine whether $T$ is a minimum spanning tree. We
                 present the first linear time algorithm for this
                 problem, that is, if $G$ has $n$ vertices and $m$
                 edges, our algorithm runs in $O(m + n)$ time given a
                 unit cost random access machine (RAM) with $O(\log n)$
                 word size. Along with the spanning tree verification
                 problem, we consider the spanning tree sensitivity
                 analysis problem. This problem is to determine the
                 maximum possible change for each individual edge cost
                 that does not destroy the minimality of the given
                 spanning tree. We give two algorithms for this problem:
                 the first runs in $O(m+n)$ expected time and the second
                 runs in optimal deterministic time, but the exact time
                 bound is not known.\par We additionally present optimal
                 parallel algorithms for the minimum spanning tree
                 verification and sensitivity analysis problems. The
                 parallel algorithms share top level ideas with the
                 above sequential algorithms, but their implementations
                 require different techniques. The parallel verification
                 algorithm runs in $O(\log n)$ time using
                 $\Theta((m+n)/\log n)$ processors in the concurrent
                 read, exclusive write (CREW) PRAM model. The parallel
                 sensitivity analysis algorithms are the parallel
                 equivalents of the sequential sensitivity analysis
                 algorithms; we give an algorithm that runs in $O(\log
                 n)$ expected time using $\Theta((m+n)/\log n)$ CREW
                 processors and a deterministic algorithm that run is
                 optimal but unknown time using $\Theta((m+n)/\log n)$
                 processors as well.\par The second problem that we
                 consider is that of allowing concurrent operations on a
                 priority queue over some bounded universe. Given a
                 bounded universe, say $[0 \ldots N]$, we give
                 algorithms for performing insertions, deletions and
                 find minimum operations on a set of elements from the
                 universe. Each operation completes in $O(\log \log N)$
                 time. Our algorithms are unique because the operations
                 can be pipelined in such a way that a new operation can
                 always begin on the set in a constant amount of time.
                 This allows concurrent operations on the set and gives
                 a way to increase the throughput of the data structure
                 without increasing the latency of any single operation.
                 We give an application of this data structure to the
                 longest increasing subsequence problem, giving an
                 optimal linear time algorithm using $\Theta(\log \log
                 N)$ processors.\par The last problem we consider is
                 that of factoring integers. Our contribution to this
                 widely studied problem is to give efficient factoring
                 algorithms for massively parallel single instruction,
                 multiple data (SIMD) machines. The algorithms presented
                 here have been implemented on a 16K processor MasPar
                 SIMD machine. We present both special purpose factoring
                 algorithms (where the running time depends strongly on
                 the size of the smallest factor) and general purpose
                 methods (where the running time depends solely on the
                 size of the integer to be factored). Additionally we
                 present fast algorithms for the multiplication of large
                 integers modulo a fixed integer, a problem useful for
                 many applications in the area of computational number
                 theory and cryptography.",
}


@TechReport{Chao93,
  author =       "Liang-Fang Chao",
  title =        "Scheduling and Behavioral Transformations for Parallel
                 Systems",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-430-93",
  pages =        "182",
  month =        oct,
  year =         "1993",
  abstract =     "In a parallel system, either a VLSI architecture in
                 hardware or a parallel program in software, the quality
                 of the final design depends on the ability of a
                 synthesis system to exploit the parallelism hidden in
                 the input description of applications. Since iterative
                 or recursive algorithms are usually the most
                 time-critical parts of an application, the parallelism
                 embedded in the repetitive pattern of an iterative
                 algorithm needs to be explored. This thesis studies
                 techniques and algorithms to expose the parallelism in
                 an iterative algorithm so that the designer can find an
                 implementation achieving a desired execution rate. In
                 particular, the objective is to find an efficient
                 schedule to be executed iteratively.\par A form of {\it
                 data-flow graphs} is used to model the iterative part
                 of an application, e.g. a digital signal filter or the
                 while/for loop of a program. Nodes in the graph
                 represent operations to be performed and edges
                 represent both intra-iteration and inter-iteration
                 precedence relations. A schedule of the operations is
                 executed repeatedly with certain execution rate. Two
                 transformation techniques, {\it retiming} (pipelining)
                 and {\it unfolding} (unwinding), are combined to
                 transform a data-flow graph into another data-flow
                 graph while preserving the intended behavior of the
                 application. After the interaction of retiming and
                 unfolding is analyzed, it is shown that the order of
                 retiming and unfolding is immaterial. Algorithms are
                 designed to find a transformation such that tThis new
                 technique turns out to be very useful, and can be
                 generalized to other problems.\par For example, the
                 problem of {\it software pipelining} in parallel
                 compilers is modeled as a special case of our
                 technique. Efficient polynomial-time algorithms are
                 derived for the scheduling on different parallel models
                 and implementation styles. For uniform nested loops,
                 multi-dimensional retiming and unfolding are defined
                 and studied for nested loop scheduling.\par Based on
                 the theoretical results, a novel technique, {\it
                 rotation}, is designed for loop pipelining under
                 resource constraints. Rotation technique repeatedly
                 transforms a schedule To a more compact schedule. The
                 rotation scheduling gives very good performance from
                 the experiments on many benchmarks.",
}


@TechReport{Petersen93,
  author =       "Karin Petersen",
  title =        "Operating System Support for Modern Memory
                 Hierarchies",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-431-93",
  pages =        "26",
  month =        aug,
  year =         "1993",
  abstract =     "The demands of large applications and the rapid
                 development of microprocessor and high-density memory
                 technology over the last years have motivated the
                 design of new memory hierarchies for uniprocessors and
                 parallel architectures. This dissertation presents the
                 study of three such memory hierarchy alternatives:
                 large memory extensions for uniprocessors, cache
                 coherence schemes for multiprocessors based on virtual
                 memory support, and memory servers for
                 multicomputers.\par Large memory extensions for
                 uniprocessors provide extensive amounts of physical
                 memory to support the efficient execution of
                 applications that use very large data structures. My
                 work studies architectures with large amounts of memory
                 on a secondary memory bus. On such computers, the
                 processor can either access the additional memory
                 directly or can use it as a cache between primary
                 memory and disks. Analytical and empirical results show
                 that many applications can benefit significantly from
                 using an extended memory system, and that the direct
                 approach outperforms the caching approach in most
                 cases.\par In the second part of this dissertation, I
                 study a new class of software cache coherence schemes
                 for multiprocessors. Currently, most multiprocessors
                 are based on bus interconnections. However, bus-based
                 multiprocessors have limited memory bandwidth. Other
                 approaches, such as directory-based schemes and
                 compiler-based software schemes, require hardware
                 support and are complex. The software cache coherence
                 schemes I propose are based on virtual memory (VM)
                 support and can be implemented on very simple
                 multiprocessors, built with distributed memories and
                 arbitrary interconnects. Trace-driven simulation
                 results show that VM-based cache coherence is an
                 economical and practical approach to build simple
                 shared-memory multiprocessors.\par The third component
                 of this dissertation presents a virtual memory
                 management technique for multicomputers called {\em
                 memory servers}. Multicomputers can provide very high
                 levels of computing power and storage capacity at
                 relatively low cost. However, it is difficult to
                 exploit the available peak performance and capacity of
                 existing multicomputers. The memory server model
                 extends the memory hierarchy of multicomputers by
                 introducing a remote memory server layer, which can be
                 viewed as a distributed cache for disk backing stores.
                 Results from a prototype implementation show that the
                 memory server mechanism is an effective way to use
                 multicomputer memory resources. (October 1993, 160
                 pages)\par Static Scheduling for Synthesis of DSP
                 Algorithms on Various Models Liang-Fang Chao and Edwin
                 Hsing-Mean Sha Given a behavioral description of a DSP
                 algorithm represented by a data-flow graph, we show how
                 to obtain a rate-optimal static schedule with the
                 minimum unfolding factor under two models, integral
                 grid model and fractional grid model, and two kinds of
                 implementations for each model, pipelined
                 implementation and non-pipelined implementation. We
                 present a simple and unified approach to deal with the
                 four possible combinations. A unified polynomial-time
                 scheduling algorithm is presented, which works on the
                 original data-flow graphs without really unfolding. The
                 values of the minimum rate-optimal unfolding factors
                 and the general properties for all the four
                 combinations are proved.",
}


@TechReport{Ar93,
  author =       "Sigal Ar and Jin-Yi Cai",
  title =        "Uncheatable Benchmarks Using Numerical Instability",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-433-93",
  pages =        "18",
  month =        sep,
  year =         "1993",
  abstract =     "We present the first practical {\em reliable\/}
                 benchmark. This benchmark is ``uncheatable'', in the
                 sense that one can not substantiate a claim to have
                 obtained the results of its computation without
                 actually doing so. In addition to having the ability to
                 check the computation results for correctness, they are
                 known to require at least some (specified) computation
                 time to be computed.\par Initial work in trying to
                 provide for reliability in benchmark is presented in
                 \cite{CLSY}. They rely on cryptographic assumptions for
                 the reliability feature in the benchmarks they
                 propose.\par Our benchmarks are based on numerical
                 instability of some matrix computations, and are
                 therefore very similar to benchmarks actually in use,
                 with the added benefit of reliability.",
}


@TechReport{Aupperle93a,
  author =       "Larry Aupperle",
  title =        "Hierarchical Algorithms for Illumination",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-434-93",
  pages =        "137",
  month =        nov,
  year =         "1993",
  abstract =     "This dissertation is a discussion and development of
                 hierarchical algorithms for illumination. These
                 algorithms operate through recursive, adaptive
                 refinement of the environment into hierarchical meshes
                 --- rather than computing light transport only between
                 elements at the finest level of refinement, the
                 algorithms allow computation of transport between
                 higher level subpatches, as controlled by user
                 specified error bounds. As discussed in this
                 dissertation, employment of hierarchical methods yields
                 significant savings in computation.\par The initial
                 work in hierarchical methods was that of Hanrahan and
                 Salzman for the computation of radiosity over
                 unoccluded environments. In this dissertation, we
                 discuss extension of the algorithm to occluded
                 environments, incorporating visibility heuristics and
                 acceleration via radiosity weighting. Given an
                 environment consisting of $k$ polygonal patches and $n$
                 elements at the finest level of refinement, the
                 algorithm requires at most $O(n + k^2)$ transport
                 interactions; traditional methods require $O(n^2)$.\par
                 Application of hierarchical transport to nondiffuse
                 reflection is developed through the derivation of a
                 radiance formulation for discrete three point
                 transport, incorporating a new measure and description
                 of reflectance: {\em area reflectance}. This
                 formulation and associated reflectance allow an
                 estimate of error in the computation of radiance across
                 triples of surface elements, and lead directly to a
                 hierarchical refinement algorithm for global
                 illumination.\par We have implemented and analyzed this
                 algorithm over surfaces exhibiting glossy and diffuse
                 reflection. Theoretical growth in transport computation
                 is shown to be $O(n + k^3)$ --- this growth is
                 exhibited in experimental trials. Naive application of
                 three point transport would require computation over
                 $O(n^3)$ element triples.\par Global illumination
                 within nondiffuse environments is ideally suited for
                 computation under importance and radiance driven
                 refinement: a transport interaction is of significance
                 only if it lies within paths of directional reflection
                 of both radiance originating at a light source, and
                 importance originating at the eye. We have thus derived
                 the adjoint to the radiance transport formulation, and
                 present preliminary results of application of this
                 adjoint in the form of an importance driven version of
                 our implementation. These results show significant
                 reduction in computation, and indicate that importance
                 and radiance driven hierarchical techniques possess
                 great potential for efficient evaluation of global
                 illumination over general reflection.",
}


@TechReport{Ar93a,
  author =       "Sigal H. Ar",
  title =        "Trustworthy Computations (Thesis)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-435-93",
  pages =        "94",
  month =        nov,
  year =         "1993",
  abstract =     "The reliability of computations has always been an
                 issue, even before these days when computers and
                 computing machinery run our lives.\par The task of
                 ensuring that computations are trustworthy needs to be
                 approached from many angles. The theoretical approach
                 provides evaluation of the reliability of a given
                 computation. Once finding flaws, this approach may
                 provide schemes and (hopefully) proofs of their
                 effectiveness. However, correctness, reliability and
                 trustworthiness need to be the property of computations
                 performed in reality, and not be provided just in
                 theory.\par In this work, we address several aspects of
                 this problem.\par In the first part, we address
                 theoretical aspects of reliability. We study one of the
                 central problems in the areas of algebraic
                 computations, coding theory, program checking and
                 others. This is the problem of obtaining explicit (or
                 implicit, but correct) representation for a function
                 given by an unreliable black box oracle. Solutions to
                 such problems may be thought of as ``smart''
                 interpolation algorithms.\par In the second part, we
                 study the checking of approximate numerical
                 computations over subsets of the reals. We indicate why
                 approximate checking is much more challenging than
                 exact checking of similar computational tasks, and
                 present a variety of checkers for linear algebra
                 computations. We do not leave checking in the realm of
                 theory. We provide an implementation, a package of
                 checkers for linear algebra computations manipulating
                 matrices.\par Last, we consider the issue of trust in
                 the people executing computations, by addressing the
                 correctness of benchmark computation results and their
                 time reports.We consider the task of designing
                 benchmarks that are uncheatable in the following sense.
                 First, the customer has a way to check the accuracy of
                 the output of the computations of a benchmark run by
                 the vendor; second, when asked to run the benchmark the
                 vendor has to perform some {\em specific\/}
                 computation, in order to get the correct results. We
                 suggest a benchmark and give the theoretical
                 justification for its being uncheatable, in addition to
                 providing an implementation demonstrating its
                 usefulness and reliability.",
}


@TechReport{Golan94,
  author =       "Michael Golan",
  title =        "A Very High Level Debugging Language",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-438-93",
  pages =        "107",
  month =        jan,
  year =         "1994",
  abstract =     "Programmers spend a significant part of their time
                 debugging, yet most of them simply add print statements
                 and avoid debugging tools. Although the user interface
                 of debuggers has improved significantly in the past
                 decade, their basic debugging methodologies have
                 changed little.\par This thesis examines single-process
                 sequential debuggers and attempts to elucidate their
                 weaknesses. Target-state exploration and conditional
                 program execution are essential idioms that cannot be
                 practiced effectively with existing debuggers. State
                 exploration seeks answers to queries such as detecting
                 a linked list containing a negative element and finding
                 where that element was added.\par Previous work has
                 focussed on the use of source-language interpreters and
                 graphical interactive exploration as solutions to the
                 state-exploration problem, but these cannot effectively
                 search for a negative element in a linked list, specify
                 a search for it, etc. This thesis describes {\it
                 Duel,\/} a very high-level language designed
                 specifically for state exploration in a debugger. {\it
                 Duel\/} allows complex state queries to be expressed
                 succinctly and it produces meaningful output. The
                 traditional C operators are extended to process
                 sequences of values, and special operators manipulate
                 these sequences in novel ways. Over a hundred
                 programmers have used {\it Duel\/} and their experience
                 substantiates the importance of state exploration and
                 of the inadequacies in previous approaches.\par
                 Conditional execution that detects state changes in
                 complex data structures is at the crux of advanced
                 debugging, and it is useful to specify such conditions
                 in {\it Duel.\/} Such use of {\it Duel\/} raises
                 important semantic and implementation problems. These
                 problems, possible solutions, and {\it
                 Duel\/}extensions are discussed.",
}


@TechReport{Matheson93,
  author =       "Lesley R. Matheson and Robert E. Tarjan",
  title =        "A Critical Analysis of Multigrid Methods on Massively
                 Parallel Computers",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-440-93",
  pages =        "5",
  year =         "July 1993, 20 Pages",
  abstract =     "The hierarchical nature of multigrid algorithms leaves
                 domain parallel strategies with a deficiency of
                 parallelism as the computation moves to coarser and
                 coarser grids. To introduce more parallelism several
                 strategies have been designed to project the original
                 problem space into non-interfering subspaces, allowing
                 all grids to relax concurrently. Our objective is to
                 understand the potential efficiency of standard and
                 concurrent multigrid algorithms on existing and
                 proposed massively parallel machines. We study model
                 problems on simple domains discretized with finite
                 difference techniques on block structured meshes in two
                 and three dimensions with up to 10^{6} and 10^{9}
                 points, respectively. Performance of the standard
                 domain parallel V and F cycle schemes is compared to
                 several proposed concurrent algorithms. The multigrid
                 strategies are studied in several models of parallel
                 computation, designed to reflect both the
                 characteristics of existing machines and those of the
                 proposed next generation of multicomputers. These
                 models include a SIMD fine-grain model which contains a
                 large number (10^{4} - 10^{6}) of small (bit-serial)
                 processors as well as a SPMD medium-grain model with a
                 more modest number (256-16,384) of powerful (single
                 chip) processors interconnected through a single stage
                 or multistage communication network. Our analysis
                 suggests that obtaining acceptable levels of
                 performance requires optimization techniques which
                 address the salient characteristics of each
                 architectural class of massively parallel computers.
                 With the appropriate optimization techniques, a
                 comparison indicates that the F-cycle is potentially
                 more efficient than the V-cycle despite the relative
                 increase in coarse grid activity. In addition, the
                 analysis suggests that subspace parallelism is too
                 expensive to be practical, except under a very limited
                 set of conditions, on either class of massively
                 parallel computers.",
}


@TechReport{Dobkin94,
  author =       "David P. Dobkin and Dimitrios Gunopulos",
  title =        "Computing the Rectangle Discrepancy",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-443-94",
  pages =        "25",
  month =        jan # " 24",
  year =         "1994",
  abstract =     "Computing the discrepancy is an interesting
                 theoretical problem with practical applications in
                 computer graphics. We extend previous work on
                 discrepancy to a more useful model. We give an $O(n^2
                 \log n )$ algorithm for computing the unanchored
                 rectangle discrepancy of planar point sets. In
                 addition, we give extensions to other interesting
                 discrepancy problems.",
}


@TechReport{Dikaiakos94,
  author =       "Marios D. Dikaiakos",
  title =        "{FAST}: {A} Functional Algorithm Simulation Testbed",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-444-94",
  pages =        "130",
  month =        jun,
  year =         "1994",
  abstract =     "Substantial progress in Parallel Scientific
                 Computation will emerge from improvements in the
                 effectiveness of current parallel machines, the
                 development of new scientific algorithms, and the
                 employment of more powerful multiprocessors.
                 Successfully addressing these issues in a
                 cost-effective way requires extensive experimentation.
                 Nevertheless, the large computational complexity of
                 scientific applications and the high cost of
                 multiprocessor systems, make the quantitative and
                 qualitative analyses of parallel workloads a difficult
                 and costly endeavor.\par In this thesis, I address some
                 of the issues involved in the modeling and evaluation
                 of parallel scientific computations. More specifically,
                 I introduce Functional Algorithm Simulation, that is,
                 simulation without performing the bulk of numerical
                 calculations involved in the applications studied.
                 Functional Algorithm Simulation is applicable in the
                 evaluation of algorithms simulating complex systems,
                 for which the core-set of time-consuming calculations
                 and data-exchanges can be determined from input
                 information, before the actual computations take place.
                 To assess the principles of Functional Algorithm
                 Simulation I built the {\em Functional Algorithm
                 Simulation Testbed (FAST)\/}, a software prototype
                 system for approximately simulating the parallel
                 execution of such algorithms on uniprocessor
                 workstations. FAST has been used to evaluate parallel
                 executions of three interesting and important
                 scientific algorithms: SIMPLE, a Computational Fluid
                 Dynamics code; the Fast Multipole Method, and a
                 modified version of the Barnes-Hut algorithm, which
                 solve the N-Body problem and have applications in
                 Computational Molecular Dynamics and Astrophysics.
                 Experimentation with FAST shows that approximate
                 simulation can give valid and useful results. FAST
                 enables us to study parallel executions of much larger
                 problem sizes and more processors than those reported
                 so far, with modest computing resources. Also, it
                 allows us to collect detailed information
                 characterizing parallel executions on various
                 message-passing architectures, analyze the effects of
                 communication overhead to parallel performance, and
                 study the scalability of parallel algorithms.",
}


@TechReport{Cao94,
  author =       "Pei Cao and Edward W. Felten and Kai Li",
  title =        "Application-Controlled File Caching Policies",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-445-94",
  pages =        "12",
  month =        feb,
  year =         "1994",
  abstract =     "We consider how to improve the performance of file
                 caching by allowing user-level control over file cache
                 replacement decisions. We use two-level cache
                 management: the kernel allocates physical pages to
                 individual applications ({\em allocation}), and each
                 application is responsible for deciding how to use its
                 physical pages ({\em replacement}). Previous work on
                 two-level memory management has focused on replacement,
                 largely ignoring allocation.\par The main contribution
                 of this paper is our solution to the allocation
                 problem. Our solution allows processes to manage their
                 own cache blocks, while at the same time maintains the
                 dynamic allocation of cache blocks among processes. Our
                 solution makes sure that good user-level policies can
                 improve the file cache hit ratios of the entire system
                 over the existing replacement approach. We evaluate our
                 scheme by trace-based simulation, demonstrating that it
                 leads to significant improvements in hit ratios for a
                 variety of applications.",
}


@TechReport{Rogers94,
  author =       "A. Rogers and M. Carlisle and J. Reppy and L.
                 Hendren",
  title =        "Supporting Dynamic Data Structures on Distributed
                 Memory Machines",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-447-94",
  pages =        "31",
  month =        feb,
  year =         "1994",
  abstract =     "Compiling for distributed memory machines has been a
                 very active research area in recent years. Much of this
                 work has concentrated on programs that use arrays as
                 their primary data structures. To date, little work has
                 been done to address the problem of supporting programs
                 that use pointer-based dynamic data structures. The
                 techniques developed for supporting SPMD execution of
                 array-based programs rely on the fact that arrays are
                 statically defined and directly addressable. Recursive
                 data structures do not have these properties, so new
                 techniques must be developed. In this paper, we
                 describe an execution model for supporting programs
                 that use pointer-based dynamic data structures. This
                 model uses a simple mechanism for migrating a thread of
                 control based on the layout of heap-allocated data and
                 introduces parallelism using a technique based on
                 futures and lazy task creation. We intend to exploit
                 this execution model using compiler analyses and
                 automatic parallelization techniques. We have
                 implemented a prototype system, which we call {\em
                 Olden}, that runs on the Intel iPSC/860 and the
                 Thinking Machines CM-5. We discuss our implementation
                 and report on experiments with five benchmarks.",
}


@TechReport{Matheson94,
  author =       "Lesley R. Matheson and Robert E. Tarjan",
  title =        "A Critical Analysis of Multigrid Methods on Massively
                 Parallel Computers",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-448-94",
  pages =        "14",
  month =        feb,
  year =         "1994",
  abstract =     "The hierarchical nature of multigrid algorithms leaves
                 domain parallel strategies with a deficiency of
                 parallelism as the computation moves to coarser and
                 coarser grids. To introduce more parallelism several
                 strategies have been designed to project the original
                 problem space into non-interfering subspaces, allowing
                 all grids to relax concurrently. Our objective is to
                 understand the potential efficiency of standard and
                 concurrent multigrid algorithms on existing and
                 proposed massively parallel machines. We study model
                 problems on simple domains discretized with finite
                 difference techniques on block structured meshes in two
                 and three dimensions with up to $10^{6}$ and $10^{9}$
                 points, respectively. Performance of the standard
                 domain parallel V and F cycle schemes is compared to
                 several proposed concurrent algorithms. The multigrid
                 strategies are studied in several models of parallel
                 computation, designed to reflect both the
                 characteristics of existing machines and those of the
                 proposed next generation of multicomputers. These
                 models include a SIMD fine-grain model which contains a
                 large number $(10^{4} - 10^{6})$ of small (bit-serial)
                 processors as well as a SPMD medium-grain model with a
                 more modest number (256-16,384) of powerful (single
                 chip) processors interconnected through a single stage
                 or multistage communication network. Our analysis
                 suggests that obtaining acceptable levels of
                 performance requires optimization techniques which
                 address the salient characteristics of each
                 architectural class of massively parallel computers.
                 With the appropriate optimization techniques, a
                 comparison indicates that the F-cycle is potentially
                 more efficient than the V-cycle despite the relative
                 increase in coarse grid activity. In addition, the
                 analysis suggests that subspace parallelism is too
                 expensive to be practical, except under a very limited
                 set of conditions, on either class of massively
                 parallel computers.",
}


@TechReport{Gershbein94,
  author =       "Reid Gershbein and Peter Schr{\"o}der and Pat
                 Hanrahan",
  title =        "Textures and Radiosity: Controlling Emission and
                 Reflection with Texture Maps",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-449-94",
  pages =        "16",
  month =        mar,
  year =         "1994",
  abstract =     "In this paper we discuss the efficient and accurate
                 incorporation of texture maps into a hierarchical
                 Galerkin radiosity algorithm. This extension of the
                 standard algorithm allows the use of textures to
                 describe complex reflectance and emittance patterns
                 over surfaces, increasing the realism and complexity of
                 radiosity images. Previous approaches to the inclusion
                 of textures have either averaged the texture to yield a
                 single color for the radiosity computations, or
                 exhaustively generated detail elements---possibly as
                 many as one per texture pixel. The former does not
                 capture important lighting effects due to textures,
                 while the latter is too expensive computationally to be
                 practical.\par To handle texture maps requires a
                 detailed analysis of the underlying operator equation.
                 In particular we decompose the radiosity equation into
                 two steps: (i) the computation of irradiance on a
                 surface from the radiosities on other surfaces, and
                 (ii) the application of the reflectance operator $\rho$
                 to compute radiosities from irradiances. We then
                 describe an algorithm that maintains hierarchical
                 representations of both radiosities and textures. The
                 numerical error involved in using these approximations
                 is quantifiable and a time/error tradeoff is possible.
                 The resulting algorithm allows texture maps to be used
                 in radiosity computations with very little overhead.",
}


@TechReport{Appel94,
  author =       "Andrew W. Appel",
  title =        "Axiomatic Bootstrapping: {A} Guide for Compiler
                 Hackers",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-451-94",
  pages =        "9",
  month =        mar,
  year =         "1994",
  abstract =     "The Standard ML of New Jersey compiler is written in
                 Standard ML. Thus, SML/NJ can compile itself. This
                 should be simple and obvious.\par There are some
                 complications. The compiler produces binary files that
                 contain both {\it executable code} and {\it static
                 environments} (mapping identifiers to structures,
                 signatures, and types). Normal binary files are
                 intended to be loaded into a running SML/NJ system,
                 where the static environment enhances the environment
                 already available in that system, and the code is
                 loaded and run.\par Some new version of the compiler
                 may make different assumptions about the format of
                 static environments, and its executing code may not be
                 compatible with the existing interactive system. Thus,
                 there can be a severe ``bootstrap'' problem: how can
                 the old version of the compiler compile and bootstrap
                 the new version?\par Here I attempt an axiomatic
                 clarification of the bootstrapping technique. This
                 should be useful to implementors of any self-applicable
                 compiler with nontrivial object-file and runtime-system
                 compatibility problems.",
}


@TechReport{Shao94,
  author =       "Zhong Shao and John H. Reppy and Andrew W. Appel",
  title =        "Unrolling Lists",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-453-94",
  pages =        "13",
  month =        mar,
  year =         "1994",
  abstract =     "Lists are ubiquitous in functional programs, thus
                 supporting lists efficiently is a major concern to
                 compiler writers for functional languages. Lists are
                 normally represented as linked {\em cons} cells, with
                 each {\em cons} cell containing a {\em car} (the data)
                 and a {\em cdr} (the link); this is inefficient in the
                 use of space, because 50\% of the storage is used for
                 links. Loops and recursions on lists are slow on modern
                 machines because of the long chains of control
                 dependences (in checking for {\em nil}) and data
                 dependences (in fetching {\em cdr} fields).\par We
                 present a data structure for ``unrolled lists,'' where
                 each cell has several data items ({\em car} fields) and
                 one link ({\em cdr}). This reduces the memory used for
                 links, and it significantly shortens the length of
                 control-dependence and data-dependence chains in
                 operations on lists.\par We further present an
                 efficient compile-time analysis that transforms
                 programs written for ``ordinary'' lists into programs
                 on unrolled lists. The use of our new representation
                 requires no change to existing programs. \par We sketch
                 the proof of soundness of our analysis---which is based
                 on refinement types---and present some preliminary
                 measurements of our technique.",
}


@TechReport{Cole94,
  author =       "Richard Cole and Philip N. Klein and Robert E.
                 Tarjan",
  title =        "A Linear-Work Parallel Algorithm for Finding Minimum
                 Spanning Trees",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-457-94",
  pages =        "14",
  month =        may,
  year =         "1994",
  abstract =     "We give the first linear-work parallel algorithm for
                 finding a minimum spanning tree. It is a randomized
                 algorithm, and requires O(2^{log^* n} log n) expected
                 time. It is a modification of the sequential
                 linear-time algorithm of Klein and Tarjan.",
}


@TechReport{Appel94a,
  author =       "Andrew W. Appel",
  title =        "Emulating Write-Allocate on a No-Write-Allocate
                 Cache",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-459-94",
  pages =        "2",
  month =        jun,
  year =         "1994",
  abstract =     "A cache write-miss policy of {\it write-allocate}
                 leads to better performance for many programs than a
                 policy of {\it no-write-allocate}.\par I show a
                 compiling technique to emulate a write-allocate policy
                 even on a no-write-allocate machine, if that machine
                 has non-blocking cache read misses (e.g. DEC Alpha
                 21064).\par The trick is to pre-fetch garbage {\it
                 before} the write, so that the cache line will be
                 allocated and the write will hit the cache.
                 Measurements show a factor-of-1.2 improvement in
                 execution time.",
}


@TechReport{Matheson94a,
  author =       "Lesley R. Matheson and Robert E. Tarjan",
  title =        "Dominating Sets in Planar Graphs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-461-94",
  pages =        "8",
  month =        jun,
  year =         "1994",
  abstract =     "Motivated by an application to unstructured multigrid
                 calculations, we consider the problem of asymptotically
                 minimizing the size of dominating sets in triangulated
                 planar graphs. Specifically, we wish to find the
                 smallest $\eps$ such that, for $n$ sufficiently large,
                 every $n$-vertex planar graph contains a dominating set
                 of size at most $\eps n$. We prove that $\frac 14 \le
                 \eps \le \frac 13$, and we conjecture that $\eps =
                 \frac 14$. For triangulated discs we obtain a tight
                 bound of $\eps = \frac 13$. The upper bound proof
                 yields a linear-time algorithm for finding an $n/3$ -
                 size dominating set.",
}


@TechReport{Computations94,
  author =       "Wavelet Algorithms for Illumination Computations",
  title =        "Peter Schr{\"o}der (Thesis)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-466-94",
  pages =        "141",
  month =        nov,
  year =         "1994",
  abstract =     "One of the core problems of computer graphics is the
                 computation of the equilibrium distribution of light in
                 a scene. This distribution is given as the solution to
                 a Fredholm integral equation of the second kind
                 involving an integral over all surfaces in the scene.
                 In the general case such solutions can only be
                 numerically approximated, and are generally costly to
                 compute, due to the geometric complexity of typical
                 computer graphics scenes. For this computation both
                 Monte Carlo and finite element techniques (or hybrid
                 approaches) are typically used.\par A simplified
                 version of the illumination problem is known as {\em
                 radiosity}, which assumes that all surfaces are diffuse
                 reflectors. For this case hierarchical techniques,
                 first introduced by Hanrahan {\em et
                 al.\/}\cite{hanr91}, have recently gained prominence.
                 The hierarchical approaches lead to an asymptotic
                 improvement when only finite precision is required. The
                 resulting algorithms have cost proportional to
                 $O(k^2+n)$ versus the usual $O(n^2)$ ($k$ is the number
                 of input surfaces, $n$ the number of finite elements
                 into which the input surfaces are meshed). Similarly a
                 hierarchical technique has been introduced for the more
                 general radiance problem (which allows glossy
                 reflectors) by Aupperle {\em et
                 al.\/}\cite{aupp93a}.\par In this dissertation we show
                 the equivalence of these hierarchical techniques to the
                 use of a Haar wavelet basis in a general Galerkin
                 framework. By so doing, we come to a deeper
                 understanding of the properties of the numerical
                 approximations used and are able to extend the
                 hierarchical techniques to higher orders. In
                 particular, we show the correspondence of the geometric
                 arguments underlying hierarchical methods to the theory
                 of Calderon-Zygmund operators and their sparse
                 realization in wavelet bases. The resulting wavelet
                 algorithms for radiosity and radiance are analyzed and
                 numerical results achieved with our implementation are
                 reported. We find that the resulting algorithms achieve
                 smaller and smoother errors at equivalent work.",
}


@TechReport{Dobkin94a,
  author =       "David P. Dobkin and Dimitrios Gunopulos and Wolfgang
                 Maass",
  title =        "Computing the Maximum Bichromatic Discrepancy, with
                 Applications to Computer Graphics and Machine
                 Learning",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-467-94",
  pages =        "38",
  month =        oct,
  year =         "1994",
  abstract =     "Computing the maximum bichromatic discrepancy is an
                 interesting theoretical problem with important
                 applications in computational learning theory,
                 computational geometry and computer graphics. In this
                 paper we give algorithms to compute the maximum
                 bichromatic discrepancy for simple geometric ranges,
                 including rectangles and halfspaces. Our main result is
                 an $O(n^2 \log n)$ algorithm that computes the maximum
                 bichromatic discrepancy of rectangles in two
                 dimensions. In addition, we present an $O(n^2 \log^2
                 n)$ algorithm that computes the maximum numerical
                 discrepancy of rectangles in two dimensions, and we
                 give extensions to other discrepancy problems.",
}


@TechReport{Ramsey94,
  author =       "Norman Ramsey and Mary F. Fernandez",
  title =        "The New Jersey Machine-Code Toolkit",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-469-94",
  pages =        "14",
  month =        oct,
  year =         "1994",
  abstract =     "The New Jersey Machine-Code Toolkit helps programmers
                 write applications that process machine code.
                 Applications that use the toolkit are written at an
                 assembly-language level of abstraction, but they
                 recognize and emit binary. Guided by a short
                 instruction-set specification, the toolkit generates
                 all the bit-manipulating code.\par The toolkit's
                 specification language uses four concepts: fields and
                 tokens describe parts of instructions, patterns
                 describe binary encodings of instructions or groups of
                 instructions, and constructors map between the
                 assembly-language and binary levels. These concepts are
                 suitable for describing both CISC and RISC machines; we
                 have written specifications for the MIPS R3000, SPARC,
                 and Intel 486 instruction sets. Complete specifications
                 for the three architectures appear in
                 [ramsey:tk-architecture]. Excerpts from those
                 specifications appear in this paper. The reference
                 manual for the toolkit [ramsey:tk-reference] gives a
                 complete description of the specification language.\par
                 We have written two applications that use the toolkit:
                 a retargetable debugger and a retargetable, optimizing
                 linker. The toolkit generates efficient code; for
                 example, the linker emits binary up to 10% faster than
                 it emits assembly language, making it 1.5--2 times
                 faster to produce an {\tt a.out} directly than by using
                 the assembler.",
}


@TechReport{Fernandez94,
  author =       "Mary F. Fernandez",
  title =        "Simple and Effective Link-Time Optimization of
                 Modula-3 Programs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-474-94",
  pages =        "17",
  month =        nov,
  year =         "1994",
  abstract =     "Object-oriented languages have features that help
                 develop modular programs and libraries of reusable
                 software. Opaque types and methods, two such features
                 in Modula-3, incur a runtime cost, because to implement
                 them, the Modula-3 compiler must generate code for
                 various runtime computations and checks. Incomplete
                 information at {\em compile\/} time necessitates these
                 computations; their runtime overhead, however, can be
                 reduced at {\em link\/} time when the entire program
                 and its type hierarchy become available.\par We
                 describe the opportunities for link-time optimization
                 of Modula-3 and present two link-time optimization
                 techniques. {\em Data-driven simplification} is a new
                 technique that uses a program's type hierarchy to
                 recover {\em completely} the cost of opaque types and
                 to reduce the runtime overhead of methods. It also
                 reveals other opportunities for optimization, such as
                 constant and type propagation and procedure inlining
                 and cloning. {\em Profile-driven} optimization uses
                 profile data to identify and transform those procedures
                 that can benefit most from optimizations made possible
                 by data-driven simplification. Moreover, our techniques
                 make it as easy to optimize procedures in libraries as
                 to optimize those in applications. it converts as many
                 as 78\% of the indirect calls executed to direct calls.
                 Profile-driven optimization reduces the total number of
                 instructions executed by up to 14\% and the number of
                 loads executed by up to 19\%.",
}


@TechReport{Shao94a,
  author =       "Zhong Shao",
  title =        "Compiling Standard {ML} for Efficient Execution on
                 Modern Machines",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-475-94",
  pages =        "169",
  month =        nov,
  year =         "1994",
  abstract =     "Many language theoreticians have taken great efforts
                 in designing higher-level programming languages that
                 are more elegant and more expressive than conventional
                 languages. However, few of these new languages have
                 been implemented very efficiently. The result is that
                 most software engineers still prefer to use
                 conventional languages, even though the new
                 higher-level languages offer a better and simpler
                 programming model. \par This dissertation concentrates
                 on improving the performance of programs written in
                 Standard ML (SML)---a statically typed functional
                 language---on today's RISC machines. SML poses tough
                 challenges to efficient implementations: very frequent
                 function calls, polymorphic types, recursive data
                 structures, higher-order functions, and first-class
                 continuations. This dissertation presents the design
                 and evaluation of several new compilation techniques
                 that meet these challenges by taking advantage of some
                 of the higher-level language features in SML. \par {\em
                 Type-directed compilation} exploits the use of
                 compile-time type information to optimize data
                 representations and function calling conventions. By
                 inserting coercions at each type instantiation and
                 abstraction site, data objects in SML can use the same
                 unboxed representations as in C, even with the presence
                 of polymorphic functions. Measurements show that a
                 simple set of type-based optimizations improves the
                 performance of the non-type-based compiler by about
                 19\% on a DECstation 5000.\par {\em Space-efficient
                 closure representations} utilizes the compile-time
                 control and data flow information to optimize closure
                 representations. By extensive closure sharing and
                 allocating as many closures in registers as possible,
                 the new {\em closure conversion} algorithm achieves
                 very good asymptotic space usage, and improves the
                 performance of the old compiler by about 14\% on a
                 DECstation 5000, {\em even without using a stack}.
                 Further empirical and analytic studies show that the
                 execution cost of stack-allocated and heap-allocated
                 activation records is similar, but heap allocation is
                 simpler to implement and allows very efficient
                 first-class continuations.\par {\em Unrolling lists}
                 takes advantage of the higher-level language
                 abstraction in SML to support more efficient
                 representations for lists. By representing each {\em
                 cons} cell using multiple {\em car} fields and one {\em
                 cdr} field, the {\em unrolled list} reduces the memory
                 used for links and significantly shortens the length of
                 control-dependence and data-dependence chains in
                 operations on lists.",
}


@TechReport{Arora94,
  author =       "Sanjeev Arora",
  title =        "Probabilistic Checking of Proofs and Hardness of
                 Approximation Problems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-476-94",
  pages =        "166",
  month =        nov,
  year =         "1994",
  abstract =     "This report is a revised form of a dissertation
                 submitted by the author at UC Berkeley in Fall 1994. It
                 establishes a surprising new characterization of NP,
                 the class of languages for which membership proofs can
                 be checked in polynomial time deterministically. The
                 class NP is exactly the set of languages for which
                 membe rship proofs can be checked by a probabilistic
                 polynomial time verifier that examines a constant
                 number of bits in the proof, and uses $O(\log n)$
                 random bits, where $n$ is the size of the input.\par
                 This characterization of NP underlies new results on
                 the hardness of approximating a host of optimization
                 problems. Among the problems proved hard to approximate
                 are classical optimization problems such as Clique,
                 Independent Set, Max-Sat, Vertex Cover, every
                 MAX-SNP-hard problem, Nearest Lattice Vector, Nearest
                 Codeword, and Shortest Lattice Vector (only the version
                 using the $\ell_{\infty}$ norm).\par The report
                 includes a survey of related results in these areas.",
}


@TechReport{Cao94a,
  author =       "Pei Cao and Edward W. Felten and Anna Karlin and Kai
                 Li",
  title =        "A Study of Integrated Prefetching and Caching
                 Strategies",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-479-94",
  pages =        "25",
  month =        dec,
  year =         "1994",
  abstract =     "Prefetching and caching are effective techniques for
                 improving the performance of file systems, but they
                 have not been studied in an integrated fashion. This
                 paper proposes four properties that optimal integrated
                 strategies for prefetching and caching must satisfy,
                 and then presents and studies two such integrated
                 strategies, called {\em aggressive} and {\em
                 conservative}. We show that the performance of the
                 conservative approach is within a factor of two of
                 optimal and that the performance of the aggressive
                 strategy is a factor significantly less than twice that
                 of the optimal case. We have evaluated these two
                 approaches by trace-driven simulation with a collection
                 of file access traces. Our results show that the two
                 integrated prefetching and caching strategies are
                 indeed close to optimal and that these strategies can
                 reduce the running time of applications by up to
                 50\%.",
}


@TechReport{Dobkin94b,
  author =       "David P. Dobkin and Dimitrios Gunopulos",
  title =        "The Maximum Discrepancy of Simple Geometric Ranges",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-480-94",
  pages =        "12",
  month =        dec,
  year =         "1994",
  abstract =     "In this paper we give algorithms that compute the
                 maximum bichromatic discrepancy for simple geometric
                 ranges and consequently solve the minimizing
                 disagreement problem of machine learning for geometric
                 hypotheses. The main result, presented in section 3 is
                 an $O(n^{\min(\alpha + 1/2, 2k-1)} \log n)$ algorithm
                 that computes the maximum bichromatic discrepancy
                 w.r.t. $k$-gons in two dimensions (where $\alpha$ is
                 the VC-dimension of the implied set system, $k$ is
                 constant). This is an application of a general approach
                 to computing the discrepancy of set systems with finite
                 VC-dimension. We also present an algorithm for the
                 special case of stripes.",
}


@TechReport{Dobkin94c,
  author =       "David P. Dobkin and Dimitrios Gunopulos",
  title =        "Concept Learning with Simple Geometric Hypotheses",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-481-94",
  pages =        "12",
  month =        dec,
  year =         "1994",
  abstract =     "We present a general approach to solving the
                 minimizing disagreement problem for geometric
                 hypotheses with finite VC-dimension. These results also
                 imply efficient agnostic-PAC learning of these
                 hypotheses classes. In particular we give an
                 $O(n^{\min(\alpha + 1/2, 2k-1)} \log n)$ algorithm that
                 solves the m.d.p. for two-dimensional convex $k$-gon
                 hypotheses (where $\alpha$ is the VC-dimension of the
                 implied set system, $k$ is constant), and an
                 $O(n^{3k-1} \log n)$ algorithm for three-dimensional
                 convex $k$-hedra hypotheses. We extend these results to
                 handle unions of $k$-gons and give an approach to
                 approximation algorithms.",
}


@TechReport{Goncalves95,
  author =       "Marcelo Jose de Rezende Goncalves",
  title =        "Cache Performance of Programs with Intensive Heap
                 Allocation and Generational Garbage Collection",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-492-95",
  pages =        "124",
  month =        may,
  year =         "1995",
  abstract =     "This dissertation presents a study of cache
                 performance of programs with intensive heap allocation
                 and generational garbage collection, such as ML
                 programs compiled by the {\em Standard ML of New
                 Jersey} compiler (SML/NJ). SML/NJ programs allocate
                 objects dynamically in the heap at a very fast rate,
                 due to the allocation of function activation records
                 (closures) in the heap.\par The memory reference
                 patterns of a set of SML/NJ programs are studied,
                 showing that nearly all writes are for sequential
                 allocation, and most reads are to recently allocated
                 objects. The cache performance of the programs is
                 studied with different cache parameters varied: cache
                 and block size, associativity, and write-miss policy.
                 The results confirm the findings of previous studies,
                 that the write-miss policy has the most significant
                 effect on the performance of these programs. Because of
                 the way these programs reference memory it is important
                 that the cache allocates a block on writes, without
                 fetching the block from memory.\par This dissertation
                 also investigates the use of software alternatives to
                 improve cache performance, that have been suggested but
                 not fully analyzed in previous studies, such as fitting
                 the allocation space in the cache. The trade-offs
                 between cache and garbage collection overhead are
                 quantitatively analyzed. The effects of other garbage
                 collection parameters on performance, such as the
                 frequency of major collections, and the algorithm to
                 traverse the graph of reachable objects are also
                 considered.\par The results of this study show that
                 heap allocation, even intensive heap allocation of
                 closures, can have good cache performance, as long as
                 the architecture uses a favorable write-miss policy. On
                 machines with an unfavorable write-miss policy there
                 are alternatives that can be applied, such as fitting
                 the allocation space in the cache.",
}


@TechReport{Cao95,
  author =       "Pei Cao and Edward W. Felten and Anna R. Karlin and
                 Kai Li",
  title =        "Implementation and Performance of Integrated
                 Application-Controlled Caching, Prefetching and Disk
                 Scheduling",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-493-95",
  pages =        "14",
  month =        jul,
  year =         "1995",
  abstract =     "Although file caching and prefetching are known
                 techniques to improve the performance of file systems,
                 little work has been done on intergrating caching and
                 prefetching. Optimal prefetching is nontrivial because
                 prefetching may require early cache block replacements.
                 Moreover, the tradeoff between the latency-hiding
                 benefits of prefetching and the increase in the number
                 of fetches required must be considered.\par This paper
                 presents the design, implementation and performance of
                 a file system that integrates application-controlled
                 caching, prefetching and disk scheduling. We use a
                 two-level cache management strategy. The kernel uses
                 the LRU-SP policy~\cite{pei:usenix94} to allocate
                 blocks to processes, and each process uses the {\it
                 controlled-aggressive} policy, an algorithm previously
                 shown in a theoretical sense to be near-optimal, for
                 managing its cache. Each process then improves its disk
                 access latency by submitting its prefetches in batches
                 and schedules the requests in each batch to optimize
                 disk access performance. Our measurements show that
                 this combination of techniques greatly improves the
                 performance of the file system. Average running time is
                 reduced by 26\% for single-process workloads, and by
                 46\% for multi-process workloads.",
}


@TechReport{Cao95a,
  author =       "Pei Cao",
  title =        "Integrated Parellel Prefetching and Caching",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-502-95",
  pages =        "22",
  year =         "December 1995, 18 Pages",
  abstract =     "Recently there have been a lot of interests in
                 prefetching on parallel disks. Prefetching is
                 considered an important technique to exploit the
                 parallelism on multiple disks for serial applications.
                 Studies have also shown that for optimal performance,
                 it is important to integrate prefetching and caching.
                 In this paper, we study integrated parallel prefetching
                 and caching strategies for multiple disks. We present
                 two algorithms, {\em regular aggressive} and {\em
                 reverse aggressive}, and give evidence that {\em
                 reverse aggressive} is close to optimal. Using
                 trace-driven simulation with a collection of file
                 access traces, we evaluated these algorithms under a
                 variety of data placement policies including striping
                 and random.\par Our results show that both algorithms
                 can achieve near linear speedup when the load is
                 distributed evenly on disks, and {\em reverse
                 aggressive} performs well even when the data placement
                 policy distributes the load unevenly [introduce load
                 unbalance?]. In particular, the results show that when
                 prefetching is done well, the striping data placement
                 strategy perform close to replicating data across all
                 of the disks. We also evaluate four online variations
                 of the algorithms and show that the online algorithms
                 perform well even with moderate advance knowledge of
                 future file accesses.",
}


@TechReport{Dobkin95,
  author =       "David P. Dobkin and Dimitrios Gunopulos",
  title =        "Concept Learning with Geometric Hypotheses",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-563-95",
  pages =        "22",
  year =         "December 1995; 8 Pages",
  abstract =     "We present a general approach to solving the
                 minimizing disagreement problem for geometric
                 hypotheses with finite VC-dimension. These results also
                 imply efficient agnostic-PAC learning of these
                 hypotheses classes. In particular we give an
                 <i>O</i>(<i>n</i><sup>min{<i>alpha</i> + &frac12; ,
                 2k-1}</sup> log <i>n</i>) algorithm that solves the
                 m.d.p. for two-dimensional convex <i>k</i>-gon
                 hypotheses (where <i>alpha</i> is the VC dimension of
                 the implied set system, <i>k</i> is constant), and an
                 <i>O</i>(<i>n</i><sup>3<i>k</i>-1</sup>log <i>n</i>)
                 algorithm for convex <i>k</i>-hedra hypotheses in three
                 dimensions. We extend these results to handle unions of
                 <i>k</i>-gons and give an approach to approximation
                 algorithms.",
}


@TechReport{Iftode96,
  author =       "Jaswinder Pal Singh Liviu Iftode and Kai Li",
  title =        "Scope Consistency: a Bridge between Release
                 Consistency and Entry Consistency",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-509-96",
  pages =        "22",
  year =         "January 1996, 11 Pages",
  abstract =     "This paper proposes a new consistency model for
                 software shared virtual memory, called {\em Scope
                 Consistency} (ScC), which offers most of the potential
                 performance advantages of the EC model but requires a
                 programming interface as simple as that of RC or LRC.
                 It does this by exploiting the implicit dynamic binding
                 between data and synchronization events variables. In
                 our simulation studies, we compared ScC with Automatic
                 Update Release Consistency (AURC), a modified LRC model
                 that takes advantage of new network interfaces. For two
                 of the four real applications we used, ScC reduced the
                 running time by about 11\%.",
}


@TechReport{Boneh96,
  author =       "Dan Boneh and Ramarathnam Venkatesan",
  title =        "Hardness of Computing the Most Significant Bits of
                 Secret Keys in Diffie-Hellman and Related Schemes",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-515-96",
  pages =        "22",
  year =         "March 1996, 13 Pages",
  abstract =     "We show that computing the most significant bits of
                 the secret key in a Diffie-Hellman key-exchange
                 protocol from the public keys of the participants is as
                 hard as computing the secret key itself. This is done
                 by studying the following {\em hidden number problem}:
                 Given an oracle $O_{\alpha,\beta}(x)$ that on input $x$
                 computes the $k$ most significant bits of $\alpha g^x +
                 \beta \bmod p $, find $\alpha, \beta \bmod p$. We
                 present many other applications of this problem
                 including: (1) MSB's in El-Gamal encryptions, Shamir
                 Message passing scheme etc. are hard to compute. (2)
                 Factoring with hints. Our results lead us to suggest a
                 new variant of Diffie-Hellman key exchange, for which
                 we prove the most significant bit is hard to compute.",
}


@TechReport{Boneh96a,
  author =       "Dan Boneh",
  title =        "Studies in Computational Number Theory with
                 Applications to Cryptography",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-523-96",
  pages =        "22",
  year =         "July 1996, 136 Pages",
  abstract =     "We study various number theoretic problems that arise
                 from cryptographic protocols. Our results are used to
                 prove the security of new and existing protocols. The
                 thesis is divided into five parts. We begin by studying
                 algebraic algorithms which are a weak model of
                 computation suitable for modeling number theoretic
                 algorithms. We prove a hardness criteria for algebraic
                 algorithms and present several number theoretic
                 consequences of this result. Next we study black box
                 fields and show how they can be used to break
                 algebraically homomorphic encryption schemes. These
                 algorithms show that over the group of points of an
                 elliptic curve the hardness of computing discrete-log
                 implies the security of the Diffie-Hellman protocol. We
                 go on to study the security of portions of the
                 Diffie-Hellman secret. We show that $\sqrt{\log p}$
                 bits of the Diffie-Hellman secret are as hard to
                 compute as the whole secret. Furthermore, in some cases
                 the individual most significant bit is sufficient.
                 These results lead us to suggest a new variant of the
                 Diffie-Hellman protocol for which the most significant
                 bit of the secret is hard to compute. The fourth part
                 generalizes the Goldreich-Levin theorem to arbitrary
                 finite groups and describes some applications to
                 learning. Finally in the last chapter we study a coding
                 theory problem which arises from the problem of
                 fingerprinting digital data.",
}


@TechReport{Karpinski96,
  author =       "Marek Karpinski and Angus Macintyre",
  title =        "Polynomial Bounds for {VC} Dimension of Sigmoidal and
                 General Pfaffian Neural Networks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-526-96",
  pages =        "22",
  year =         "October 1996, 16 Pages",
  abstract =     "We introduce a new method for proving explicit upper
                 bounds on the VC Dimension of general functional basis
                 networks, and prove as an application, for the first
                 time, that the VC Dimension of analog neural networks
                 with the sigmoidal activation function
                 $\sigma(y)=1/1+e^{-y}$ is bounded by a quadratic
                 polynomial $O((lm)^2)$ in both the number $l$ of
                 programmable parameters, and the number $m$ of nodes.
                 The proof method of this paper generalizes to much
                 wider class of Pfaffian activation functions and
                 formulas, and gives also for the first time polynomial
                 bounds on their VC Dimension. We present also some
                 other applications of our method.",
}


@TechReport{Ablayev96,
  author =       "Farid Ablayev and Marek Karpinski",
  title =        "On the Power of Randomized Branching Programs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-531-96",
  pages =        "22",
  year =         "October 1996, 9 Pages",
  abstract =     "We define the notion of a randomized branching program
                 in the natural way similar to the definition of a
                 randomized circuit. We exhibit an explicit function
                 $f_{n}$ for which we prove that:\par 1) $f_{n}$ can be
                 computed by polynomial size randomized read-once
                 ordered branching program with a small one-sided
                 error;\par 2) $f_{n}$ cannot be computed in polynomial
                 size by deterministic read-once branching programs;\par
                 3) $f_{n}$ cannot be computed in polynomial size by
                 deterministic read-$k$-times ordered branching program
                 for $k=o(n/\log n)$ (the required deterministic size is
                 $\exp\left(\Omega\left(\frac{n}{k}\right)\right)$).",
}


@TechReport{Karpinski96a,
  author =       "Marek Karpinski and Alexander Zelikovsky",
  title =        "Approximating Dense Cases of Covering Problems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-542-97",
  pages =        "22",
  year =         "December 1996, 9 Pages",
  abstract =     "We study dense cases of several covering problems. An
                 instance of the set cover problem with $m$ sets is
                 dense if there is $\epsilon>0$ such that any element
                 belongs to at least $\epsilon m$ sets. We show that the
                 dense set cover problem can be approximated with the
                 performance ratio $c\log n$ for any $c>0$ and it is
                 unlikely to be NP-hard. We construct a polynomial-time
                 approximation scheme for the dense Steiner tree problem
                 in $n$-vertex graphs, i.e. for the case when each
                 terminal is adjacent to at least $\epsilon n$ vertices.
                 We also study the vertex cover problem in
                 $\epsilon$-dense graphs. Though this problem is shown
                 to be still MAX-SNP-hard as in general graphs, we find
                 a better approximation algorithm with the performance
                 ratio $2\over{1+\epsilon}$. The {\em superdense} cases
                 of all these problems are shown to be solvable in
                 polynomial time.",
}


@TechReport{Liu97,
  author =       "Zicheng Liu",
  title =        "Efficient Animation Techniques Balancing Both User
                 Control And Physical Realism",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-549-97",
  pages =        "22",
  year =         "June 1997, 128 Pages",
  abstract =     "Specifying the motion of an animated linked figure
                 such that it achieves given tasks (e.g., throwing a
                 ball into a basket) and performing the tasks in a
                 realistic fashion (e.g., gracefully, and following
                 physical laws such as gravity) has been an elusive goal
                 for computer animators. The {\em spacetime constraints}
                 paradigm has been shown to be a valuable approach to
                 this problem, but it suffers from the computational
                 complexity growth as creatures and tasks approach those
                 one would like to animate. There are two sources which
                 contribute to the complexity problem: one is the
                 symbolic processing of the animator's constraints and
                 the objective functions derived from the physical
                 models and the second lies in the numerical
                 optimization phase. This thesis reports on work to
                 enhance the spacetime constraints techniques both
                 symbolically and numerically to significantly speed up
                 computations.\par Our first contribution is to develop
                 a new symbolic interface with a recursive evaluation
                 scheme so that the time required for gradient
                 computation which is needed by the numerical
                 optimization is reduced from exponential growth to the
                 optimal quadratic growth. Furthermore, with the new
                 symbolic method, a language developed for the symbolic
                 expressions can be easily input, thus it provides a
                 more convenient interface.\par Secondly, we develop a
                 keyframe optimization system which allows the user to
                 specify a few keyframes while letting the computer
                 determine the speed and timing, parameters which may be
                 less intuitive for the animator, by using optimization
                 methods. The novelty of this approach is that the
                 user-specified keyframes are used both to provide
                 control over the motion and to reduce the complexity of
                 the optimization problem. This method has the advantage
                 of providing much of the user control of the
                 traditional animation system while providing the
                 physical realism of the optimization based system. Due
                 to the reduced complexity of the optimization problem,
                 the computation time is nearly interactive for complex
                 figures.\par Finally we develop a hierarchical scheme
                 to solve the nonlinear variational problem arising in
                 the spacetime constraints formulation by using
                 wavelets. In this scheme, the functions through time of
                 the generalized degrees of freedom are reformulated in
                 a hierarchical wavelet representation. This provides a
                 means to automatically add detailed motion only where
                 it is required, thus minimizing the number of unknowns.
                 In addition, the optimization problem is better
                 conditioned so that the convergence is faster.",
}


@TechReport{Dubnicki98,
  author =       "Cezary Dubnicki and Angelos Bilas and Yuqun Chen and
                 Stefanos N. Damianakis and Kai Li",
  title =        "{VMMC}-2: Efficient Support for Reliable,
                 Connection-Oriented Communication",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-573-98",
  pages =        "22",
  year =         "February 1998, 22 Pages",
  abstract =     "The basic virtual memory-mapped communication (VMMC)
                 model provides protected, direct communication between
                 the sender's and receiver's virtual address spaces, but
                 it does not support high-level connection-oriented
                 communication APIs well. This paper presents VMMC-2, an
                 extension to the basic VMMC. We describe the design,
                 implementation, and evaluate the performance of three
                 mechanisms in VMMC-2: (1) a user-managed TLB mechanism
                 for address translation which enables user libraries to
                 dynamically manage the amount of pinned space and
                 requires only driver support from many operating
                 systems; (2) a transfer redirection mechanism which
                 avoids copying on the receiver's side; (3) a reliable
                 communication protocol at the data link layer which
                 avoids copying on the sender's side.\par To validate
                 our extensions we implemented stream sockets on top of
                 the VMMC-2{} running on a Myrinet network of Pentium
                 PCs. This zero-copy sockets implementation provides a
                 maximum bandwidth of over 84~Mbytes/s and a one-way
                 latency of 20~$\mu$s.",
}


@TechReport{Iftode98,
  author =       "Liviu Iftode and David L. Oppenheimer Matthias
                 Blumrich and Cezary Dubnicki",
  title =        "Shared Virtual Memory with Automatic Update Support",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-575-98",
  pages =        "22",
  year =         "February 1998, 13 Pages",
  abstract =     "Jaswinder Pal Singh and Kai Li Shared virtual memory
                 systems provide the abstraction of a shared address
                 space on top of a message-passing communication
                 architecture. The overall performance of an SVM system
                 therefore depends on both the raw performance of the
                 underlying communication mechanism and the efficiency
                 with which the SVM protocol uses that mechanism. The
                 Automatic Update Release Consistency (AURC) protocol
                 was proposed to take advantage of simple memory-mapped
                 communication and automatic update support to
                 accelerate a shared virtual memory protocol. However,
                 there has not yet been a real system on which an
                 implementation of this protocol could be evaluated.\par
                 This paper reports our evaluation of AURC on the
                 \shrimp{} multicomputer, the only hardware platform
                 that supports an automatic update mechanism. Automatic
                 update propagates local memory writes to remote memory
                 locations automatically. We compare the AURC protocol
                 with its all-software counterpart protocol, Home-based
                 Lazy Release Consistency (HLRC). We first show that
                 virtual memory-mapped communication itself helps all
                 home-based LRC protocols because these protocols can
                 easily take advantage of the zero-copy communication
                 allowed by the memory mapping mechanism. By integrating
                 AU support into the protocol as well, the AURC protocol
                 can further improve performance. For applications with
                 write-write false sharing, an AU-based multiple-writer
                 protocol can significantly outperform an all-software
                 home-based multiple-writer LRC protocol that uses
                 diffs. For applications without much write-write false
                 sharing, the two protocols perform similarly. Our
                 results also show that write-through caching and
                 automatic update traffic does not perturb the
                 computation, validating the implementation as achieving
                 its goals.",
}


@TechReport{Kilian98,
  author =       "Joe Kilian and F. Thomson Leighton and Lesley R.
                 Matheson and Talal G. Shamoon and Robert E. Tarjan and
                 Francis Zane",
  title =        "Resistance of Digital Watermarks to Collusive
                 Attacks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-585-98",
  pages =        "22",
  year =         "July 1998; 23 Pages",
  abstract =     "In many schemes for digital watermarking, an attacker
                 in possession of a small fixed number of differently
                 marked copies of a single document can easily produce
                 an unmarked copy. In contrast, we show in this paper
                 that if the watermarks have a component-wise normal
                 distribution, then $\Omega \big({\sqrt{n/\ln
                 m}}\,\/\big)$ differently marked copies are required to
                 successfully erase any mark with non-negligible
                 probability. Here $n$ is the dimensionality of the
                 watermarks, and $m$ is the number of differently marked
                 copies distributed. This result holds in a specific but
                 natural statistical model of watermarking.",
}


@TechReport{Bilas98,
  author =       "Angelos Bilas",
  title =        "Improving the Performance of Shared Virtual Memory on
                 System Area Networks",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-586-98",
  pages =        "22",
  year =         "August 1998; 22 Pages",
  abstract =     "As clusters of workstations, uniprocessor or symmetric
                 multiprocessors (SMPs), become important platforms for
                 parallel computing, there is increasing research
                 interest in supporting the attractive, shared address
                 space programming model across them in software. The
                 reason is that it may provide successful low-cost,
                 high-performance alternatives to both tightly-coupled,
                 hardware-coherent distributed shared memory machines
                 and to scalable servers. In both these cases, the
                 clusters are formed with off-the-self, high-end PCs or
                 workstations and system area networks that track
                 technologies well. Given that a shared memory
                 abstraction is an attractive programming model for this
                 architecture, there has been a lot of research in fast
                 communication on clusters connected with system area
                 networks and in protocols for supporting software
                 shared memory across them. However, the end performance
                 of applications that were written for the more proven
                 hardware-coherent shared memory is still not very good
                 on these systems.\par This dissertation is about
                 improving the performance of shared virtual memory on
                 clusters that are connected with system area networks.
                 In this architecture, three major layers of software
                 (and hardware) stand between the end user and
                 performance, each with its own functionality and
                 performance characteristics. The lowest layer is the
                 communication layer: the communication hardware and the
                 low level software libraries that provide basic
                 messaging facilities. Next is the protocol layer that
                 provides the programming model to the parallel
                 application programmer. Finally, above the programming
                 model or protocol layer runs the application itself.
                 This dissertation improves the performance of shared
                 virtual memory on clusters by studying and improving
                 each of this layers and some of their interactions.
                 (November 1998; 242 Pages)\par TR-587-98; revised
                 TR-602-99 BERT: A Scheduler for Best Effort and
                 Realtime Tasks Andy Bavier, Larry Peterson, and David
                 Mosberger We describe a new algorithm, called BERT,
                 that can be used to schedule both best effort and
                 realtime tasks on a multimedia workstation. BERT
                 exploits two innovations. First, it is based on the
                 virtual clock algorithm originally developed to
                 schedule bandwidth on packet switches. Because this
                 algorithm maintains a relationship between virtual time
                 and real time, our algorithm allows us to
                 simultaneously factor realtime deadlines into the
                 scheduling decision, and to allocate some fraction of
                 the processor to best effort tasks. Second, BERT
                 includes a mechanism that allows one task to {\it
                 steal} cycles from another. This mechanism is valuable
                 for two reasons: it allows us to distinguish among
                 tasks based on their importance, and it results in a
                 robust algorithm that is not overly sensitive to the
                 task having made a perfect reservation.",
}


@TechReport{Zhou99,
  author =       "P. Chen Y. Zhou and K. Li",
  title =        "Fast Cluster Failover Using Virtual Memory-Mapped
                 Communication",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-591-99",
  pages =        "22",
  year =         "January 1999, 10 Pages",
  abstract =     "This paper proposes a novel way to use virtual
                 memory-mapped communication (VMMC) to reduce the
                 failover time on clusters. With the VMMC model,
                 applications' virtual address space can be efficiently
                 mirrored on remote memory either automatically or via
                 explicit messages. When a machine fails, its
                 applications can restart from the most recent
                 checkpoints on the failover node with minimal memory
                 copying and disk I/O overhead. This method requires
                 little change to applications' source code. We
                 developed two fast failover protocols: {\it deliverate
                 update failover protocol\/} (DU) and {\it automatic
                 update failover protocol\/} (AU). The first can run on
                 any system that supports VMMC, whereas the other
                 requires special network interface support.\par We
                 implemented these two protocols on two different
                 clusters that supported VMMC communication. Our results
                 with three transaction-based applications show that
                 both protocols work quite well. The deliberate update
                 protocol imposes 4-21% overhead when taking checkpoints
                 every 2 seconds. If an application can tolerate 20%
                 overhead, this protocol can failover to another machine
                 within 4 milliseconds in the best case and from 0.1 to
                 3 seconds in the worst case. The failover performance
                 can be further improved by using special network
                 interface hardware. The automatic update protocol is
                 able to take checkpoints every 0.1 seconds with only
                 3-12% overhead. If 10% overhead is allowed, it can
                 failover applications from 0.01 to 0.4 seconds in the
                 worst case.",
}


@TechReport{Kaplan99,
  author =       "Haim Kaplan and Robert E. Tarjan",
  title =        "New Heap Data Structures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-597-99",
  pages =        "22",
  year =         "March 1999; 16 Pages",
  abstract =     "We describe two new heap data structures. Our first
                 structure, called the {\em thin heap\/}; is closely
                 related to Fibonacci heaps [2] and has the same
                 asymptotic performance. Specifically, {\em make-heap},
                 {\em insert}, {\em find-min}, {\em decrease-key}, and
                 {\em meld} take $O(1)$ amortized time, and {\em
                 delete-min} and {\em delete} take $O(\log n)$ amortized
                 time. The advantage of thin heaps over Fibonacci heaps
                 is that the heap-ordered trees being maintained have
                 more structure and require fewer fields per node, but
                 the operations are as simple as for Fibonacci heaps. In
                 a practical implementation, the time and space constant
                 factors of thin heaps should thus be better than those
                 of Fibonacci heaps.\par The second structure, called
                 the {\em fat heap\/}, achieves the same asymptotic
                 performance as the run-relaxed heaps described by
                 Driscoll et al. [1] and offers an alternative to it in
                 all its applications. Specifically, {\em make-heap},
                 {\em insert}, {\em find-min}, and {\em decrease-key\/}
                 take $O(1)$ worst-case time, and {\em delete}, {\em
                 delete-min}, and {\em meld\/} take $O(\log n)$
                 worst-case time. Our data structure is much simpler
                 than run-relaxed heaps.\par There exists a well-known
                 connection between binomial queue operations and
                 arithmetic operations on binary numbers.\par Our fat
                 heaps exploit this connection and achieve their
                 performance by incorporating two redundant counters.",
}

%
% converted from refer format by refer-to-bibtex 0.9.2 -- 13:00, 10 Feb 108
% r2b -eqn -reverse-author
%

}

@TechReport{Appel89,
  author =       "Andrew Appel",
  title =        "A Run Time System",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-220-89",
  pages =        "35",
  month =        may,
  year =         "1989",
  abstract =     "The runtime data structures of the Standard ML of New
                 Jersey compiler are simple yet general. As a result,
                 code generators are easy to implement, programs execute
                 quickly, garbage colllectors are easy to implement and
                 work efficiently, and a variety of runtime facilities
                 can be provided with ease.",
}


@TechReport{Tolmach90,
  author =       "Andrew P. Tolmach and Andrew W. Appel",
  title =        "Debugging Standard {ML} Without Reverse Engineering",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-253-90",
  pages =        "12",
  month =        mar,
  year =         "1990",
  abstract =     "We have built a novel and efficient replay debugger
                 for our Standard ML compiler. Debugging facilities are
                 provided by instrumenting the user's source code; this
                 approach, made feasible by ML's safety property, is
                 machine-independent and back-end independent. Replay is
                 practical because ML is normally used functionally, and
                 our compiler uses continuation-passing style; thus most
                 of the program's state can be checkpointed quickly and
                 compactly using call-with-current-continuation.
                 Together, instrumentation and replay support a simple
                 and elegant debugger featuring full variable display,
                 polymorphic type resolution, stack trace-back,
                 breakpointing, and reverse execution, even though our
                 compiler is very highly optimizing and has no run-time
                 stack.",
}


@TechReport{Fraser90,
  author =       "Christopher W. Fraser and David R. Hanson",
  title =        "A Code Generation Interface for {ANSI} {C}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-270-90",
  pages =        "37",
  month =        jun,
  year =         "1990",
  abstract =     "A Code Generation Interface for ANSI C is a
                 retargetable, production compiler for ANSI C; versions
                 for the VAX, the Motorola 68020 and MIPS have been in
                 use for over a year and a half. It is smaller and
                 faster than generally available alternatives, and its
                 local code is about as good. This report describes the
                 interface between the target-independent front end and
                 the target-dependent back ends. The interface consists
                 of shared data structures, a few functions, and a dag
                 language. While this approach couples the front and
                 back ends tightly, it results in an efficient, compact
                 compiler. The interface is illustrated by detailing a
                 complete code generator that emits naive VAS code.",
}


@TechReport{Appel90,
  author =       "Andrew W. Appel and Kai Li",
  title =        "Virtual Memory Primitives for User Programs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-276-90",
  pages =        "13",
  month =        jul,
  year =         "1990",
  abstract =     "Memory Management Units (MMUs) are traditionally used
                 by operating systems to implement disk-paged virtual
                 memory. Some operating systems allow user programs to
                 specify the protection level (inaccessbile, read-only,
                 read-write) of pages, and allow user programs to handle
                 protection violations, but these machanisms are not
                 always robust, efficient, or well-matched to the needs
                 of applications. We survey several user-level
                 algorithms that make use of page-protection techniques,
                 and analyze their common characteristics, in an attempt
                 to answer the question, {"}What virtual-memory
                 primitives should the operating system provide to user
                 processes, and how do today's operating systems provide
                 them?{"}",
}


@TechReport{Mishra91,
  author =       "B. Mishra and R. E. Tarjan",
  title =        "A Linear-Time Algorithm for Finding an Ambitus",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-301-91",
  pages =        "34",
  month =        jan,
  year =         "1991",
  abstract =     "We devise a linear-time algorithm for finding an
                 ambitus in an undirected graph. An ambitus is a cycle
                 in a graph containing two distinguished vertices such
                 that certain different groups of bridges (called \$B
                 sup P\$-, \$B sup Q\$- and \$B sup PQ\$-bridges)
                 satisfy the property that a bridge in one group does
                 not interlace with any bridge in the other groups.
                 Thus, an ambitus allows the graph to be cut into
                 pieces, where, in each piece, certain graph properties
                 may be investigated independently and recursively, and
                 then the pieces can be pasted together to yield
                 information about these graph properties in the
                 original graph. In order to achieve a good
                 time-complexity for such an algorithm employing the
                 divide-and-conquer paradigm, it is necessary to find an
                 ambitus quickly. We also show that, using ambitus,
                 linear-time algorithms can be devised for
                 abiding-path-finding and
                 nonseparating-induced-cycle-finding problems.",
}


@TechReport{Ramsey91,
  author =       "Norman Ramsey and Carla Marceau",
  title =        "Literate Programming on a Team Project",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-302-91",
  pages =        "11",
  month =        feb,
  year =         "1991",
  abstract =     "We used literate programming on a team project to
                 write a 33,000-line program for the Synthesizer
                 Generator. The program, Penelope, was written using
                 WEB, a tool designed for writing literate programs.
                 Unlike other WEB programs, many of which have been
                 written by WEB's developer or by individuals, Penelope
                 was not intended to be published. We used WEB in the
                 hope that both our team and its final product would
                 benefit from the advantages often attributed to
                 literate programming. The WEB source served as good
                 internal documentation throughout development and
                 maintenance, and it continues to document Penelope's
                 design and implementation. Our experience also
                 uncovered a number of problems with WEB.",
}


@TechReport{Fraser91,
  author =       "Christopher W. Fraser and David R. Hanson",
  title =        "A Retargetable Compiler for {ANSI} {C}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-303-91",
  pages =        "20",
  month =        feb,
  year =         "1991",
  abstract =     "Lcc is a new retargetable compiler for ANSI C.
                 Versions for the VAX, Motorola 68020, SPARC, and MIPS
                 are in production use at Princeton University and at
                 AT\&T Bell Laboratories. With a few exceptions, little
                 about lcc is unusual -- it integrates several
                 well-engineered, existing techniques -- but it is
                 smaller and faster than most other C compilers, and it
                 generates code of comparable quality. Lcc's
                 target-independent front end performs a few simple, but
                 effective, optimizations that contribute to good code;
                 examples include simulating register declarations and
                 partitioning switch statement cases into dense tables.
                 It also implements target-independent function tracing
                 and expression-level profiling.",
}


@TechReport{Squier91,
  author =       "Richard K. Squier",
  title =        "Efficient, Scalable Architectures for Lattice-Gas
                 Computations",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-304-91",
  pages =        "182",
  month =        jun,
  year =         "1991",
  abstract =     "The subject of this dissertation is finding an
                 architecture for two-dimensional cellular automata
                 computations that is verifiably correct, and the
                 fastest and cheapest possible. The motivating problems
                 for this work are large-scale scientific computations;
                 the hardware context is that of application-specific
                 processors attached to general-purpose systems. While
                 the conclusions are derived for a specific class of
                 two-dimensional cellular automata, the so-called
                 {"}lattice gasses,{"} they are applicable to a wide
                 range of similar problems. By developing and applying
                 solutions to discrete isoperimetric problems to a
                 pebbling game, upper bounds on throughput for machines
                 computing problems with data dependency graphs based on
                 the undirected graphs for the Hardy-de Pazzis-Pomeau
                 (HPP) and Frisch-Hasslacher-Pomeau (FHP) lattice-gasses
                 are shown. A particular architecture, the {"}Wide
                 Serial Architecture{"} (WSA), is shown to be within a
                 factor of approximately 6 of the bound for the HPP-like
                 computations, and within a factor of about 4.5 of the
                 bound for the FHP-like computations. Besides the
                 insight they provide into the optimal computational
                 strategy, the methods of solution of the isoperimetric
                 problems, such as the use of the Wulff Crystal, are of
                 interest in their own right. An analytic study of the
                 least-cost configuration for a multiple-pipeline WSA
                 machine is undertaken. The use of overlap-save method
                 is described, and the efficiency of the WSA
                 architecture using this method is derived. A numerical
                 search is used to find the least cost machine
                 configuration as the problem size is scaled. A slightly
                 super-linear speedup is shown over a moderate range of
                 problem sizes, and the least-cost machine parameters
                 are described. Finally, a data-embedded,
                 specification-based testing technique for FHP lattice
                 gasses is introduced. The tests consist of limit cycles
                 in the cellular automaton, and their error detection
                 coverage is shown empirically to be good. Their use in
                 software, hardware, and system debugging is described,
                 as well as their use as runtime simulation error
                 detectors. Machine design tradeoffs relating to
                 testability are discussed.",
}


@TechReport{Doyle91,
  author =       "Jon Doyle and Elisha P. Sacks",
  title =        "Markov Analysis of Qualitative Dynamics",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-305-91",
  pages =        "24",
  month =        feb,
  year =         "1991",
  abstract =     "Commonsense sometimes predicts events to be likely or
                 unlikely rather than merely possible. We extend methods
                 of qualitative reasoning to predict the relative
                 likelihoods of possible qualitative behaviors by
                 viewing the dynamics of a system as a Markov chain over
                 its transition graph. This involves adding qualitative
                 or quantitative estimates of transition probabilities
                 to each of the transitions and applying the standard
                 theory of Markov chains to distinguish persistent
                 states from transient states and to calculate
                 recurrence times, settling times, and probabilities for
                 ending up in each state. Much of the analysis depends
                 solely on qualitative estimates of transition
                 probabilities, which follow directly from theoretical
                 considerations and which lead to qualitative
                 predictions about entire classes of systems.
                 Quantitative estimates for specific systems are derived
                 empirically and lead to qualitative and quantitative
                 conclusions, most of which are insensitive to small
                 perturbations in the estimated transition
                 probabilities. The algorithms are straightforward and
                 efficient.",
}


@TechReport{Griswold91,
  author =       "Ralph E. Griswold and David R. Hanson",
  title =        "String Processing Languages",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-306-91",
  pages =        "18",
  month =        feb,
  year =         "1991",
  abstract =     "In most traditional programming languages, character
                 strings are arrays of characters, and string processing
                 is programmed with low-level array operations, such as
                 indexing. In high-level string-processing languages,
                 strings are treated at a higher conceptual level.
                 Strings are first-class values in these languages, and
                 most offer a rich set of operations that manipulate
                 strings as atomic values. Examples include
                 concatenation, substring identification,
                 transformation, and pattern matching. This report
                 surveys some of the past and present string-processing
                 and their facilities that deal with strings. Included
                 are brief descriptions of Comit, the SNOBOL languages,
                 and Icon. This report will appear in the third edition
                 of the Encyclopedia of Computer Science and
                 Engineering, to be published by Van Nostrand
                 Reinhold.",
}


@TechReport{Li91,
  author =       "Kai Li and Karin Petersen",
  title =        "Evaluation of Memory System Extensions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-307-91",
  pages =        "10",
  month =        mar,
  year =         "1991",
  abstract =     "A traditional memory system for a uniprocessor
                 consists of one or two levels of cashe, a main memory
                 and a backing store. One can extend such a memory
                 system by adding inexpensive but slower memories into
                 the memory hierarchy. This paper uses an experimental
                 approach to evaluate two methods of extending a memory
                 system: direct and caching. The direct method adds the
                 slower memory into the memory hierarchy by putting it
                 at the same level as the main memory, allowing the CPU
                 to access the slower memories directly; whereas the
                 caching method puts the slower memory between the main
                 memory and the backing store, using the main memory as
                 a cache for the slower memory. We have implemented both
                 approaches and our experiments indicate that
                 applications with very large data structures can
                 benefit significantly using an extended memory system,
                 and that the direct approach outperforms the caching
                 approach in memory-bound applications.",
}


@TechReport{Friedman90,
  author =       "Joel Friedman",
  title =        "A Note on Matrix Rigidity",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-308-91",
  pages =        "6",
  month =        jun,
  year =         "1990",
  abstract =     "In this paper we give an explicit construction of
                 \$n\^{}times\^{}n\$ matrices over finite fields which
                 are somewhat rigid, in that if we change at most \$k\$
                 entries in each row, its rank remains at least \$Cn(log
                 sub q\^{}k)/k\$, where \$q\$ is the size of the field
                 and \$C\$ is an absolute constant. Our matrices
                 satisify a somewhat stronger property, which we explain
                 and call {"}strong rigidity.{"} We introduce and
                 briefly discuss strong rigidity, because it is in a
                 sense a simpler property and may be easier to use in
                 giving explicit constructions.",
}


@TechReport{Cai91,
  author =       "Jiazhen Cai and Xiaofeng Han and Robert E. Tarjan",
  title =        "An \${O}(mlogn)\$-Time Algorithm for the Maximal
                 Planar Subgraph Problem",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-309-91",
  pages =        "25",
  month =        mar,
  year =         "1991",
  abstract =     "Based on a recursive version of Hopcroft and Tarjan's
                 planarity testing algorithm, we develop an
                 \$O(mlogn)\$-time algorithm to find a maximal planar
                 subgraph.",
}


@TechReport{Dietzfelbinger91,
  author =       "Martin Dietzfelbinger and Kurt Mehlhorn Anna Karlin",
  title =        "Dynamic Perfect Hashing: Upper and Lower Bounds",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-310-91",
  pages =        "34",
  month =        mar,
  year =         "1991",
  abstract =     "Friedhelm Meyer auf der Heide, Hans Rohnert, and
                 Robert E. Tarjan The dynamic dictionary problem is
                 considered: provide an algorithm for storing a dynamic
                 set, allowing the operations insert, delete, and
                 lookup. A dynamic perfect hashing strategy is given: a
                 \$randomized\$ algorithm for the dynamic dictionary
                 problem that takes \$O\$(1) worst-case time for lookups
                 and \$O\$(1) amortized expected time for insertions and
                 deletions; it uses space proportional to the size of
                 the set stored. Furthermore, lower bounds for the time
                 complexity of a class of \$deterministic\$ algorithms
                 for the dictionary problem are proved. This class
                 encompasses realistic hashing-based schemes that use
                 linear space. Such algorithms have amortized worst-case
                 time complexity \$OMEGA\$(log \$n\$) for a sequence of
                 \$n\$ insertions and lookups; if the worst-case lookup
                 time is restricted to \$k\$ then the lower bound
                 becomes \$OMEGA (k\^{}cdot\^{}n sup 1/k\$).",
}


@TechReport{Tarjan91,
  author =       "Robert E. Tarjan",
  title =        "Efficient Maximum Flow Algorithms",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-311-91",
  pages =        "10",
  month =        mar,
  year =         "1991",
  abstract =     "Discovering efficient algorithms to compute flows in
                 networks has been a goal of researchers in operations
                 research and computer science for over 35 years. In
                 this paper we review some recent developments in
                 algorithms for the single-commodity maximum flow
                 problem, and we comment on possible additional
                 improvements. Our criterion for efficiency is
                 theoretical worst-case running time on large sparse
                 problems, ignoring constant factors.",
}


@TechReport{Spauster91,
  author =       "Annemarie Spauster",
  title =        "Ordered and Reliable Multicast Communication",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-312-91",
  pages =        "119",
  month =        jun,
  year =         "1991",
  abstract =     "Multicasting (sending a message to a subset of sites
                 in a network) has become a popular mechanism for
                 interprocess communication in distributed systems. Many
                 applications (e.g., distributed databases) require that
                 a message be transmitted to multiple processes. One
                 indisputably desirable quality of any type of message
                 transmission is reliability. A message that is sent
                 from process A to process B should indeed arrive. Even
                 better, it should arrive within a reasonable amount of
                 time. For distributed applications, it is also often
                 desirable for multidestination messages to arrive at
                 the destination processes in a consistent order. In a
                 database application, if update requests are headed to
                 two destinations with copies of the data, delivering
                 the requests in the same order at both destinations
                 helps maintain consistency. This is just one example of
                 how consistent message delivery simplifies distributed
                 applications. In this thesis, we consider enhancing
                 multicast communication by providing ordering and
                 reliability properties. We present an algorithm, the
                 propagation graph algorithm, that guarantees a strong
                 ordering property: multiple group ordering.
                 Experimental analysis of the propagation graph
                 technique demonstrates that it is efficient compared to
                 other solutions and exhibits a clear load/delay
                 tradeoff. We also present several types of reliability
                 that multicast ordering algorithms can provide. We
                 address how to achieve these types of reliability with
                 the propagation graph algorithm. Further, we clarify
                 the issue of reliability by presenting a formal model
                 of message ordering and by presenting formal
                 definitions of reliability properties. These properties
                 are then applied to the propagation graph solution.",
}


@TechReport{Yao91,
  author =       "Andrew Chi-Chih Yao",
  title =        "Probabilistic Behavior of Shortest Paths Over
                 Unbounded Regions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-313-91",
  pages =        "18",
  month =        mar,
  year =         "1991",
  abstract =     "Let \$k\^{}$>$\^{}1\$ and \$P\$ be a probability
                 distribution over \$R sup k\$ with all its absolute
                 \$mu\$-th moments being finite for some \$mu \^{} $>$
                 \^{}k/(k\^{}-\^{}1)\$. Let \$v sub 1\$,\$v sub 2\$,
                 \$cdot cdot cdot\$ be an infinite sequence of random
                 points, each independently distributed according to
                 \$P\$. It is shown that the length of the shortest
                 traveling-salesman's tour through \$v sub 1\$,\$v sub
                 2\$,\$cdot cdot cdot\$,\$v sub n\$ is, for large \$n\$,
                 almost surely around \$alpha p n sup (k-1)/K\$ for some
                 constant \$alpha p\$. This proves a conjecture of
                 Beardwood, Halton and Hammersley (Proc. Camb. Phil.
                 Soc. 55 (1959), 299-327).",
}


@TechReport{Sacks91,
  author =       "Elisha P. Sacks and Jon Doyle",
  title =        "Prolegomena to any Future Qualitative Physics",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-314-91",
  pages =        "31",
  month =        apr,
  year =         "1991",
  abstract =     "We evaluate the success of the qualitative physics
                 enterprise in automating expert reasoning about
                 physical systems. The field has agreed, in essentials,
                 upon a modeling language for dynamical systems, a
                 representation for behavior, and an analysis method.
                 The modeling language consists of generalized ordinary
                 differential equations containing unspecified constants
                 and monotonic functions; the behavioral representation
                 decomposes the state space described by the equations
                 into discrete cells; and the analysis method traces the
                 transitory response using sign arithmetic and calculus.
                 The field has developed several reasoners based on
                 these choices over some fifteen years. We demonstrate
                 that these reasoners exhibit severe limitations in
                 comparison with experts and can analyze only a handful
                 of simple systems. We trace the limitations to
                 inappropriate assumptions about expert needs and
                 methods. Experts ordinarily seek to determine
                 asymptotic behavior rather than transient response, and
                 use extensive mathematical knowledge and numerical
                 analysis to derive this information. Standard
                 mathematics provides complete qualitative understanding
                 of many systems, including those addressed so far in
                 qualitative physics. Preliminary evidence suggests that
                 expert knowledge and reasoning methods can be automated
                 directly, without restriction to the accepted language,
                 representation and algorithm. We conclude that expert
                 knowledge and methods provide the most promising basis
                 for automating qualitative reasoning about physical
                 systems.",
}


@TechReport{Li91a,
  author =       "Jeffrey F. Naughton Kai Li and James S. Plank",
  title =        "Checkpointing Multicomputer Applications",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-316-91",
  pages =        "16",
  month =        apr,
  year =         "1991",
  abstract =     "Efficient checkpointing and resumption of
                 multicomputer applications is essential if
                 multicomputers are to support time-sharing and the
                 automatic resumption of jobs after a system failure. We
                 present a checkpointing scheme that is transparent,
                 imposes overhead only during checkpoints, requires
                 minimal message logging, and allows for quick
                 resumption of execution from a checkpointed image.
                 Since checkpointing multicomputer applications poses
                 requirements different from those posed by
                 checkpointing general distributed systems, existing
                 distributed checkpointing schemes are inadequate for
                 multicomputer checkpointing. Our checkpointing scheme
                 makes use of special properties of multicomputer
                 interconnection networks to satisfy this new set of
                 requirements.",
}


@TechReport{Clarkson91,
  author =       "Richard Cole Kenneth L. Clarkson and Robert E.
                 Tarjan",
  title =        "Randomized Parallel Algorithms for Trapezoidal
                 Diagrams",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-318-91",
  pages =        "10",
  month =        apr,
  year =         "1991",
  abstract =     "We describe randomized parallel CREW PRAM algorithms
                 for building trapezoidal diagrams of line segments in
                 the plane. For general segments, we give an algorithm
                 requiring optimal \$O(A\^{}+\^{}n\$ log \$n)\$ expected
                 work and optimal \$O\$(log \$n)\$ time, where \$A\$ is
                 the number of intersecting pairs of segments. If the
                 segments form a simple chain, we give an algorithm
                 requiring optimal \$O(n)\$ expected work and \$O(\$log
                 \$n\$ log log \$n\$ log* \$n\$) expected time, and a
                 simpler algorithm requiring \$O(n\$ log* \$n)\$
                 expected work. The serial algorithm corresponding to
                 the latter is the simplest known algorithm requiring
                 \$O(n\$ log* \$n)\$ expected operations. For a set of
                 segments forming \$K\$ chains, we give an algorithm
                 requiring \$O(A\^{}+\^{}n\$ log* \$n\^{}+\^{}K\$ log
                 \$n)\$ expected work and \$O\$(log \$n\$ log log \$n\$
                 log* \$n\$) expected time. The parallel time bounds
                 require the assumption that enough processors are
                 available, with processor allocations every log \$n\$
                 steps.",
}


@TechReport{Karlin91,
  author =       "Mark S. Manasse Anna R. Karlin and Kai Li and Susan
                 Owicki",
  title =        "Empirical Studies of Competitive Spinning for
                 Shared-Memory Multiprocessors",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-319-91",
  pages =        "21",
  month =        mar,
  year =         "1991",
  abstract =     "A common operation in multiprocessor programs is
                 acquiring a lock to protect access to shared data.
                 Typically, the requesting thread is blocked if the lock
                 it needs is held by another thread. The cost of
                 blocking one thread and activating another can be a
                 substantial part of program execution time.
                 Alternatively, the thread could spin until the lock is
                 free, or spin for a while and then block. This may
                 avoid context-switch overhead, but processor cycles may
                 be wasted in unproductive spinning. This paper studies
                 seven strategies for determining whether and how long
                 to spin before blocking. Of particular interest are
                 competitive strategies, for which the performance can
                 be shown to be no worse than some constant factor times
                 an optimal off-line strategy. The performance of five
                 competitive strategies is compared with that of always
                 blocking, always spinning, or using the optimal
                 off-line algorithm. Measurements of lock-waiting time
                 distributions for five parallel programs were used to
                 compare the cost of synchronization under all the
                 strategies. Additional measurements of elapsed time for
                 some of the programs and strategies allowed assessment
                 of the impact of synchronization strategy on overall
                 program performance. Both types of measurements
                 indicate that the standard blocking strategy performs
                 poorly compared to mixed strategies. Among the mixed
                 strategies studied, adaptive algorithms perform better
                 than non-adaptive ones.",
}


@TechReport{Systems91,
  author =       "Constraints in Distributed Database Systems",
  title =        "The Demarcation Protocol: {A} Technique for
                 Maintaining Arithmetic",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-320-91",
  pages =        "24",
  month =        apr,
  year =         "1991",
  abstract =     "Daniel Barbara and Hector Garcia-Molina Traditional
                 protocols for distributed database management have high
                 message overhead, lock or restrain access to resources
                 during protocol execution, and may become impractical
                 for some scenarios like real-time systems and very
                 large distributed databases. In this paper we present
                 the demarcation protocol; it overcomes these problems
                 through the use of explicit arithmetic consistency
                 constraints as the correctness criteria. The method
                 establishes safe limits as {"}lines drawn in the
                 sand{"} for updates and gives a way of changing these
                 limits dynamically, enforcing the constraints at all
                 times.",
}


@TechReport{Blaze91,
  author =       "Matt Blaze and Rafael Alonso",
  title =        "Long-Term Caching Strategies for Very Large
                 Distributed File Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-321-91",
  pages =        "13",
  month =        apr,
  year =         "1991",
  abstract =     "This paper examines the feasibility of using long term
                 (disk based) caches in very large distributed file
                 systems (DFSs). We begin with an analysis of file
                 access patterns in a distributed Unix workstation
                 environment, and identify properties of use to the DFS
                 designer. We then introduce long-term caching
                 strategies that maintain consistency while dramatically
                 reducing the load on file servers. We describe a number
                 of algorithms for maintaining client caches, and
                 present the results of a trace-driven simulation that
                 shows how relatively small disk-based caches can be
                 used to reduce server traffic by 60\% to 90\%. Finally,
                 we outline possible mechanisms for dynamically
                 organizing these caches into adaptive hierarchies to
                 allow arbitrary scaling of the number of clients and
                 the use of low-bandwidth communication networks. A
                 small (2 or 3 level) hierarchy, coupled with smart
                 caching techniques, has the potential to reduce traffic
                 by an order of magnitude or more over a flat scheme.",
}


@TechReport{Han91,
  author =       "Xiaofeng Han",
  title =        "An Algorithmic Approach to Extremal Graph Problems",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-322-91",
  pages =        "130",
  month =        jun,
  year =         "1991",
  abstract =     "The main purpose of this thesis is to study three
                 problems concerning extremal graphs. The first is the
                 problem of finding a minimal 2-edge connected subgraph
                 of a 2-edge connected graph, the second is the problem
                 of finding a minimal 2-connected subgraph of a
                 2-connected graph, and the third is the problem of
                 finding a maximal planar subgraph of a nonplanar graph.
                 These problems are extensions of the 2-edge
                 connectivity problem, the 2-connectivity problem, and
                 the planarity testing problem in graph theory. All
                 three problems are important in the theory of extremal
                 graphs. They also have useful applications in computer
                 network and electronic circuit design.",
}


@TechReport{Clifton91,
  author =       "Christopher W. Clifton",
  title =        "Hyperfile, {A} Database Manager for Documents",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-323-91",
  pages =        "104",
  month =        jun,
  year =         "1991",
  abstract =     "Documents, pictures, and other such non-quantitative
                 information pose interesting new problems in the
                 database world. Such data has traditionally been stored
                 in file systems, which do not provide the security,
                 integrity, or query features of database management
                 systems. We have developed HyperFile, a data server
                 that provides query facilities (as well as some other
                 database features) while maintaining the flexibility
                 and efficiency of a file system. HyperFile is based on
                 the hypertext notion of free-form objects connected by
                 links. Hypertext systems {"}query{"} their database by
                 browsing (reading objects and following links.) We
                 present a query interface that maintains much of the
                 flavor of browsing, allowing the user to specify a
                 single query rather than manually following links. This
                 eliminates the repeated user interactions of hypertext
                 browsing, and allows the hypertext model to be extended
                 to larger and less structured databases. An algorithm
                 for processing HyperFile queries is presented. We also
                 show how to extend this algorithm for distributed query
                 processing, and present experimental results from a
                 distributed HyperFile server. Another issue explored is
                 indexing. In HyperFile, searches are often demarcated
                 by pointers between items. Thus the scope of the search
                 may change dynamically, whereas traditional indexes
                 cover a statically defined region such as a relation.
                 This demands new indexing techniques. Some ideas on
                 indexing in HyperFile are presented, as well as
                 experiments in a large HyperFile database. Also
                 presented is a sample HyperFile application. This is a
                 {"}browser{"} that uses menus to guide the user in
                 constructing HyperFile queries.",
}


@TechReport{Fernandez91,
  author =       "Mary F. Fernandez and David R. Hanson",
  title =        "Garbage Collection Alternatives for Icon",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-324-91",
  pages =        "16",
  month =        may,
  year =         "1991",
  abstract =     "Copying garbage collectors are becoming the collectors
                 of choice for very high-level languages and for
                 functional and object-oriented languages. Copying
                 collectors are particularly efficient for large heaps
                 because their execution time is proportional only to
                 the amount of accessible data, and they identify and
                 compact this data in one pass. In contrast,
                 mark-and-sweep collectors execute in time proportional
                 to the heap size and require a second pass to compact
                 accessible data. The performance of existing systems
                 with old mark-and-sweep collectors might be improved by
                 replacing their collectors with copying collectors.
                 This paper explores this possibility by describing the
                 results of replacing the mark-and-sweep collector in
                 the Icon programming language with four alternative
                 collectors, three of which are copying collectors.
                 Copying collectors do indeed yield better performance,
                 but at a significant cost in space. Measurements
                 suggest that the mark-and-sweep alternative is best for
                 Icon programs that have 1-5MB heaps.",
}


@TechReport{Cai91a,
  author =       "Jin-yi Cai",
  title =        "Computations Over Infinite Groups",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-325-91",
  pages =        "11",
  month =        jun,
  year =         "1991",
  abstract =     "We propose the study of a wide variety of infinite
                 groups from a computational complexity point of view.
                 We raise some important structural questions on these
                 groups from a computational aspect. The purpose of this
                 paper is to invite the attention of both the
                 theoretical computer science community and the
                 combinatorial group theorists that a fruitful area of
                 cross fertilization may be offering itself. As a
                 specific problem, we consider randomly generated groups
                 and their isomorphism problem.",
}


@TechReport{Appel91,
  author =       "Andrew W. Appel and Zhong Shao",
  title =        "Callee-save Registers in Continuation-Passing Style",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-326-91",
  pages =        "16",
  month =        aug,
  year =         "1991",
  abstract =     "Continuation-passing style (CPS) is a good abstract
                 representation to use for compilation and optimization:
                 it has a clean semantics and is easily manipulated. We
                 examine how CPS expresses the saving and restoring of
                 registers in source-language procedure calls. As
                 CPS-conversion is usually written, the context of the
                 calling procedure is saved in a {"}continuation
                 closure{"} -- a single variable that is passed as an
                 argument to the function being called. This closure is
                 a record containing bindings of all the free variables
                 of the continuation; that is, registers that hold
                 values needed by the caller {"}after the call{"} are
                 written to memory in the closure, and fetched back
                 after the call. Consider the procedure-call mechanisms
                 used by conventional compilers. In particular,
                 registers holding values needed after the call must be
                 saved and later restored. The responsibility for saving
                 registers can lie with the caller (a {"}caller-saves{"}
                 convention) or with the called function (a
                 {"}callee-saves{"}). In practice, to optimize memory
                 traffic compilers find it useful to have some
                 caller-saves registers and some callee-saves. Clearly
                 the usual translation into CPS is a caller-saves
                 convention. We explain how to express callee-save
                 registers in Continuation-Passing Style, and give
                 measurements showing the resulting improvement in
                 execution time.",
}


@TechReport{Kirkpatrick91,
  author =       "Maria M. Klawe David G. Kirkpatrick and Robert E.
                 Tarjan",
  title =        "Polygon Triangulation in
                 \${O}({N}\^{}log\^{}log\^{}{N})\$ Time with Simple Data
                 Structures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-327-91",
  pages =        "16",
  month =        jun,
  year =         "1991",
  abstract =     "We give a new \$O(n\$ log log \$n)\$-time
                 deterministic algorithm for triangulating simple
                 \$n\$-vertex polygons, which avoids the use of
                 complicated data structures. In addition, for polygons
                 whose vertices have integer coordinates of polynomially
                 bounded size, the algorithm can be modified to run in
                 \$O(n\$ log* \$n)\$ time. The major new techniques
                 employed are the efficient location of horizontal
                 visibility edges that partition the interior of the
                 polygon into regions of approximately equal size, and a
                 linear-time algorithm for obtaining the horizontal
                 visibility partition of a subchain of a polygonal
                 chain, from the horizontal visibility partition of the
                 entire chain. The latter technique has other
                 interesting applications, including a linear-time
                 algorithm to convert a Steiner triangulation of a
                 polygon into a true triangulation.",
}


@TechReport{Salem91,
  author =       "Daniel Barbara Kenneth Salem and Richard J. Lipton",
  title =        "Probabilistic Diagnosis of Hot Spots",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-328-91",
  pages =        "28",
  month =        jun,
  year =         "1991",
  abstract =     "Commonly, a few objects in a database account for a
                 large share of all database accesses. These objects are
                 called hot spots. The ability to determine which
                 objects are hot spots opens the door to a variety of
                 performance improvements. Data reorganization,
                 migration, and replication techniques can take
                 advantage of knowledge of hot spots to improve
                 performance at low cost. In this paper we present some
                 techniques that can be used to identify those objects
                 in the database that account for more than a specified
                 percentage of database accesses. Identification is
                 accomplished by analyzing a string of database
                 references and collecting statistics. Depending on the
                 length of the reference string and the amount of space
                 available for the analysis, each technique will have a
                 non-zero probability of false diagnosis, i.e.,
                 mistaking {"}cold{"} items for hot spots and vice
                 versa. We compare the techniques analytically and show
                 the tradeoffs among time, space and the probability of
                 false diagnoses.",
}


@TechReport{Appel91a,
  author =       "Andrew W. Appel and David B. MacQueen",
  title =        "Standard {ML} of New Jersey",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-329-91",
  pages =        "13",
  month =        jun,
  year =         "1991",
  abstract =     "The Standard ML of New Jersey compiler has been under
                 development for five years now. We have developed a
                 robust and complete environment for Standard ML that
                 supports the implementation of large software systems
                 and generates efficient code. The compiler has also
                 served as a laboratory for developing novel
                 implementation techniques for a sophisticated type and
                 module system, continuation based code generation,
                 efficient pattern matching, and concurrent programming
                 features.",
}


@TechReport{Schaffer91,
  author =       "Russel Schaffer and Robert Sedgewick",
  title =        "The Analysis of Heapsort",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-330-91",
  pages =        "13",
  month =        jan,
  year =         "1991",
  abstract =     "Heapsort is a fundamental algorithm whose precise
                 performance characteristics have proven difficult to
                 analyze. It is easy to show that the number of keys
                 moved during the algorithm when sorting a random file
                 of \$N\$ distinct elements is \$N\$ lg
                 \$N\^{}+\^{}O(N)\$ in the worst case, and it has long
                 been conjectured that the average case performance is
                 the same. No specific results on the average case or
                 even the best case have been found despite the
                 algorithm's standing as a classic method that is in
                 widespread use. In this paper, we resolve these
                 questions by showing that the best case for the number
                 of moves is \$$\sim$ 1 over 2\^{}N\$ lg \$N\$ and that
                 the average number of moves is \$$\sim$ N\$ lg \$N\$.
                 This essentially completes the analysis of the
                 algorithm, though there is another quantity that
                 contributes to the leading term of the running time
                 that requires more intricate arguments, and we have
                 little specific information about the distribution
                 beyond what is implied by our asymptotic results. These
                 results were initially suggested by results of an
                 empirical study that involved generating and analyzing
                 hundreds of billions of heaps. The distribution of the
                 number of moves required by Heapsort for small \$N\$ is
                 presented in an Appendix.",
}


@TechReport{Abbott91,
  author =       "Robert Kilburn Abbott",
  title =        "Scheduling Real-Time Transactions: {A} Performance
                 Evaluation",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-331-91",
  pages =        "331",
  month =        oct,
  year =         "1991",
  abstract =     "This thesis describes a new group of algorithms for
                 scheduling real-time transactions, or transactions with
                 deadlines. The algorithms are evaluated via a detailed
                 simulation study. Our results show that under a wide
                 range of workloads, the real-time algorithms perform
                 significantly better than a conventional transaction
                 scheduling algorithm. This thesis also studies the
                 problem of scheduling disk requests with deadlines.
                 Three new algorithms are proposed and their performance
                 is evaluated via simulation. One real-time algorithm,
                 FD-SCAN, was found to perform better than all
                 algorithms tested, both real-time and conventional,
                 under a wide range of experimental conditions.",
}


@TechReport{Balasubramania91,
  author =       "K. Balasubramanian",
  title =        "An Euclidean Metric for Genetic Sequence Comparison",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-332-91",
  pages =        "103",
  month =        oct,
  year =         "1991",
  abstract =     "This thesis introduces a new representation for
                 genetic sequences in the form of geometric points or
                 vectors. It is based on the relative frequencies of the
                 various (small) fixed length substrings of \$k-tuples\$
                 of the DNA or protein sequences. This effectively
                 transforms the sequence from a variable sized string to
                 fixed size vector. We show that this transformation
                 preserves, under certain circumstances, the
                 \$edit\^{}distince\$ between sequences, a widely used
                 measure for comparing genetic sequences. This fact is
                 used to develop a linear time heuristic for sequence
                 comparison, an improvement over the quadratic time
                 dynamic programming based algorithms currently in
                 widespread use. The transformation from a variable
                 sized sequence to a fixed size vector representation
                 allows computational geometric techniques to be applied
                 to the study of genetic sequences. In particular, we
                 develop a method of comparing several sequences
                 simulatneously without having to compare each pair of
                 sequences separately. This results in a substantial
                 reduction in the complexity of the problem of multiple
                 sequence comparison and clustering. This can be applied
                 as a filter to extract interesting sets of sequences
                 from a large database for more thorough study as well
                 as an indexing method, to locate the database sequences
                 most likely to be related to a query sequence.",
}


@TechReport{Chazelle91,
  author =       "Micha Sharir and Bernard Chazelle and Leonidas Guibas
                 Herbert Edelsbrunner",
  title =        "Computing a Face in an Arrangement of Line Segments
                 and Related Problems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-334-91",
  pages =        "20",
  month =        jun,
  year =         "1991",
  abstract =     "Jack Snoeyink We present a randomized incremental
                 algorithm for computing a single face in an arrangement
                 of \$n\$ line segments in the plane that is fairly
                 simple to implement. The expected running time of the
                 algorithm is \$O(n alpha (n)\$ log \$n\$). The analysis
                 of the algorithm uses a novel approach that generalizes
                 and extends the Clarkson-Shor analysis technique. We
                 also present a few extensions of the technique,
                 obtaining efficient randomized incremental algorithms
                 for constructing the entire arrangement of a collection
                 of line segments, and for computing a single face in an
                 arrangement of Jordan arcs.",
}


@TechReport{Chazelle91a,
  author =       "Bernard Chazelle",
  title =        "Cutting Hyperplanes for Divide-and-Conquer",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-335-91",
  pages =        "14",
  month =        jun,
  year =         "1991",
  abstract =     "Given \$n\$ hyperplanes in \$E sup d\$, a
                 \$1/r)-cutting\$ is a collection of simplices which
                 together cover \$E sup d\$ and such that the interior
                 of each simplex intersects at most \$n/r\$ hyperplanes.
                 We present an algorithm for computing a
                 \$(1/r\$-cutting of (asymptotically) minimum size in
                 \$O(nr sup d-1\$) time. If, as is the case in practice,
                 the lists of cutting hyperplanes must be explicitly
                 provided, then the algorithm is optimal. Our result
                 bridges a gap in a recent algorithm of Matousek by
                 extending its performance to all values of \$r\$; the
                 previous bound was restricted to \$r\^{}$<$=\^{}n sup
                 1- delta \$, for any fixed \$ delta $>$ 0\$. To attain
                 our goal, we show that optimal cuttings can be refined
                 by composition. This is interesting in its own right,
                 because it leads to the improvement and the
                 simplification of a number of geometric algorithms,
                 e.g., point location among hyperplanes, counting
                 segment intersections, Hopcroft's line/point incidence
                 problem, linear programming in fixed dimension. One of
                 the main tools used in the cutting construction is a
                 proof that \$ epsilon \$-approximations can be used to
                 estimate how many vertices of a hyperplane arrangement
                 fall inside a given simplex. In a different
                 development, to be reported elsewhere, we have used
                 this lemma to derive an optimal deterministic algorithm
                 for computing convex hulls in higher dimensions. Thus,
                 we suspect that the lemma will have other useful
                 applications in computational geometry.",
}


@TechReport{Ristad91,
  author =       "Eric Sven Ristad",
  title =        "Human Language Comprehension is {NP}-Complete",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-337-91",
  pages =        "42",
  month =        jun,
  year =         "1991",
  abstract =     "Consider the computational problem of understanding
                 the utterances of a human language that contain
                 pronouns. In order to completely understand such
                 utterances, the language user must determine the
                 intended reference of each pronoun in a given
                 utterance. For example, in order to comprehend the
                 english sentence Jocasta loved her son, the hearer
                 might determine that the possessive pronoun \$her\$
                 refers to Jocasta, the queen of Thebes. We prove that
                 two different models of this broad computational
                 problem are NP-hard, and argue that the problem remains
                 in \$NP\$ even if our language models account for the
                 computationally complex phenomenon of syntactic
                 ellipsis. These complexity results are based directly
                 on human linguistic knowledge, and are invariant across
                 linguistic theories. No knowledge of linguistic theory
                 is needed to understand the analysis, only knowledge of
                 English.",
}


@TechReport{Sha91,
  author =       "Edwin Hsing-Mean Sha and Kenneth Steiglitz",
  title =        "Error Detection in Arrays Via Dependency Graphs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-339-91",
  pages =        "42",
  month =        aug,
  year =         "1991",
  abstract =     "This paper describes a methodology based on dependency
                 graphs for doing concurrent run-time error detection in
                 systolic arrays and wavefront processors. It combines
                 the projection method of deriving systolic arrays from
                 dependency graphs with the idea of input-triggered
                 testing. We call the method \$ITRED\$, for Input-driven
                 Time-Redundancy Error Detection. Tests are triggered by
                 inserting special symbols in the input, and so the
                 approach gives the user flexibility in trading off
                 throughput for error coverage. Correctness of timing is
                 proved at the dependency graph level. The method
                 requires no extra \$PE's\$ and little extra hardware.
                 We propose several variations of the general approach
                 and derive corresponding constraints on the modified
                 dependency graphs that guarantee correctness. One
                 variation performs run-time error correction using
                 majority voting. Examples are given, including a
                 dynamic programming algorithm, convolution, and matrix
                 multiplication.",
}


@TechReport{Friedman91,
  author =       "Joel Friedman",
  title =        "Some Geometric Aspects of Graphs and their
                 Eigenfunctions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-340-91",
  pages =        "42",
  month =        nov,
  year =         "1991",
  abstract =     "We study two mathematical notions, that of nodal
                 regions for eigenfunctions of the Laplacian, and that
                 of fiber products, in the context of graph theory. We
                 formulate analogous notions and theorems for graphs and
                 their eigenpairs. These techniques suggest new ways of
                 studying problems related to spectral theory of
                 graphs.",
}


@TechReport{Sacks91a,
  author =       "Elisha Sacks",
  title =        "A Smart Interface for Numerical Software",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-341-91",
  pages =        "42",
  month =        aug,
  year =         "1991",
  abstract =     "The paper describes a smart interface that makes
                 numerical libraries easy to use and reliable by
                 exploiting mathematical theory, symbolic algebra, and
                 descriptions of the input/output formats of numerical
                 subroutines. The interface accepts a high-level problem
                 description, selects the appropriate numerical
                 subroutine, programs the problem in subroutine format,
                 runs the program, corrects for numerical errors and
                 special conditions, and returns the output in a
                 high-level format. The current interface manages a root
                 finder, a continuation package, an ordinary
                 differential equation integrator, and a Lyapunov
                 exponent calculator. I describe these functions and
                 illustrate their use in a program that analyzes
                 ordinary differential equations.",
}


@TechReport{Sacks91b,
  author =       "Elisha Sacks",
  title =        "Automated Analysis of a Heart Model",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-342-91",
  pages =        "42",
  month =        aug,
  year =         "1991",
  abstract =     "I analyze Rigney and Goldberger's mathematical model
                 of the heart's rocking during periocardial effusion.
                 The analysis predicts the motion of the heart for heart
                 rates between 50 and 130 and for a range of initial
                 positions and velocities: the heart rocks once every
                 other beat (exhibits alternans) at heart rates between
                 104 and 117 and rocks once per beat otherwise. The
                 predictions agree with the published clinical data,
                 which shows alternans at heart rates between 100 and
                 124. They also agree with Rigney and Goldberger's
                 numerical simulation, which shows one rock per beat at
                 heart rate 75 and alternans at heart rate 105. I
                 describe a general purpose analysis program that
                 analyzed the heart model automatically.",
}


@TechReport{Tay91,
  author =       "Y. C. Tay and W. Tim Loke",
  title =        "A Theory for Deadlocks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-344-91",
  pages =        "42",
  month =        aug,
  year =         "1991",
  abstract =     "Deadlock detection is an elementary problem in
                 computer science, yet algorithms for detecting
                 deadlocks over resources in a distributed system are
                 curiously prone to errors. This anomaly calls for a
                 theory that will help us understand existing algorithms
                 and design new algorithms. Surprisingly, most papers in
                 the literature have either no difinition of what a
                 deadlock is, or a bad definition; this fact itself
                 accounts for many of the errors. The first task in
                 developing a theory is therefore to choose an
                 appropriate definition for a deadlock. Since this
                 theory is to be used for the analysis and synthesis of
                 detection algorithms, it should focus on what an
                 algorithm can observe (in this sense, it is an
                 \$operational\$ theory); accordingly, the definition
                 chosen here is in terms of locally observable facts,
                 and does not use real time. The theory begins with a
                 rigorous formulation of the interaction between
                 processes and resources, and its development is via
                 logical deduction, rather than operational arguments.
                 The results examine the effect of aborting processes on
                 deadlock detection, clarify the difference between a
                 process and a resource, and reveal the structure of
                 detection algorithms. To illustrate its application,
                 the theory is used to analyze several errors and
                 algorithms in the literature.",
}


@TechReport{Doukas91,
  author =       "Dimitris Doukas and Andrea S. LaPaugh",
  title =        "{CLOVER}: {A} User Guide",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-345-91",
  pages =        "42",
  month =        aug,
  year =         "1991",
  abstract =     "CLOVER is a timing verification system for digital
                 systems. It was designed to handle medium size
                 asynchronous systems, particularly interface systems,
                 but can be used with synchronous systems as well. A
                 wide range of basic components can be used with CLOVER,
                 including user-defined components. To use CLOVER, the
                 designer provides a description of the design in the
                 hardware description language PDL-e and a description
                 of the timing constraints that the design should
                 satisfy in CLOVER's constraint language ATCSL. CLOVER
                 derives an \$event\^{}graph\$ for the design using an
                 event-based timing simulator and checks the
                 satisfaction of each constraint within the event graph.
                 In this report we present a detailed description on the
                 use of CLOVER from the user perspective. A detailed
                 documentation of all CLOVER's features is given,
                 accompanied by simple but illustrative examples.",
}


@TechReport{Steiglitz91,
  author =       "Jeff Blum Ken Steiglitz and Jonathan Thompson This is
                 the lab manual",
  title =        "Computer Science 111",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-346-91",
  pages =        "42",
  month =        sep,
  year =         "1991",
  abstract =     "for COS 111, an introductory course in computer
                 science for liberal arts students, as it was taught for
                 the first time in the fall semester of 1991. It
                 includes a general introduction, topic outline, a set
                 of nine laboratory exercises for the NeXT, and a
                 collection of CheatSheets that provide supporting
                 material for the labs. The topics are: (1) Introduction
                 (2) Communications [news, mail, ftp, telnet], (3)
                 Graphics [PostScript, lpr, Edit, Yap, TopDraw, etc.],
                 (4) Presentation [WriteNow, troff, etc.] (5) Sound
                 [SoundEditor], (6) Programming in C, (7) Selection
                 sort, (8) More sound, using C, and (9) Information
                 processing [grep, wc, sort]. The lectures themselves
                 included an introduction to complexity theory [big-oh
                 notation, analysis of sorting, etc.] and computability
                 theory [Turing machines, the halting problem, etc.].",
}


@TechReport{Staelin91,
  author =       "Carl Hudson Staelin",
  title =        "High Performance File System Design",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-347-91",
  pages =        "42",
  month =        oct,
  year =         "1991",
  abstract =     "File systems and I/O subsystems should be \$smart\$;
                 they can analyze how they are being used and tune
                 themselves dynamically to improve their performance.
                 File systems should select caching and disk placement
                 strategies on a per-file basis, and they should use
                 system-wide disk reorganization strategies. For
                 example, systems should be able to reorganize the data
                 on disk automatically during idle periods so that
                 system performance is improved during future periods of
                 peak load. This dissertation presents the design and
                 analysis of iPcress, a prototype of a next-generation
                 file system. iPcress is a smart, high-performance,
                 reliable file system. It uses statistical information
                 collected on a per-file basis to tune itself. iPcress
                 has a framework in which various optimizations can be
                 performed by the file system automatically. It is
                 extensible; other optimization techniques can be
                 incorporated easily, so that the system may evolve. In
                 addition, iPcress can incorporate a variety of file
                 access and placement techniques and choose the best
                 combination of techniques for each file dynamically. A
                 sample smart optimization -- clustering active disk
                 data in the center of the disk -- is described; it
                 increases disk throughput by 30\%",
}


@TechReport{Algorithms91,
  author =       "Algorithms",
  title =        "Competitive Paging and Dual-Guided On-Line Weighted
                 Caching and Matching",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-348-91",
  pages =        "42",
  month =        oct,
  year =         "1991",
  abstract =     "Neal Young (Thesis)",
}


@TechReport{Campos91,
  author =       "Alvaro E. Campos and David R. Hanson",
  title =        "Distributed {EZ}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-349-91",
  pages =        "42",
  month =        sep,
  year =         "1991",
  abstract =     "EZ is a system that integrates traditional operating
                 systems and programming languages into a very
                 high-level, persistent, string processing language.
                 This paper describes the design and initial
                 implementation of a distributed memory manager that
                 distributes EZ's virtual address space transparently
                 among a network of homogeneous computers. The design
                 adapts the techniques used in recent implementations of
                 shared virtual memory for use in EZ's persistent
                 environment. Unlike most implementations of shared
                 virtual memory, control information is distributed and
                 migrates. This memory manager works in concert with a
                 distributed mark-and-sweep garbage collector, which is
                 also concurrent and real-time. This collector trades
                 time for space and minimal disruption of mutators,
                 which reduces communication costs.",
}


@TechReport{Chazelle91b,
  author =       "Bernard Chazelle and Leonidas Guibas Herbert
                 Edelsbrunner and Michelangelo Grigni",
  title =        "Ray Shooting in Polygons Using Geodesic
                 Triangulations",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-350-91",
  pages =        "42",
  month =        sep,
  year =         "1991",
  abstract =     "John Hershberger, Micha Sharir and Jack Snoeyink Let
                 \$P\$ be a simple polygon with \$n\$ vertices. We
                 present a simple decomposition scheme that partitions
                 the interior of \$P\$ into \$O(n)\$ so-called geodesic
                 triangles, so that any line segment interior to \$P\$
                 crosses at most 2 log \$n\$ of these triangles. This
                 decomposition can be used to preprocess \$P\$ in a very
                 simple manner, so that any ray-shooting query can be
                 answered in time \$O(log\^{}n)\$. The data structure
                 required \$O(n)\$ storage and \$O(n\$ log \$n)\$
                 preprocessing time. By using more sophisticated
                 techniques, we can reduce the preprocessing time to
                 \$O(n)\$. We also extend our general technique to the
                 case of ray-shooting amidst \$k\$ polygonal obstacles
                 with a total of \$n\$ edges, so that a query can be
                 answered in \$O( sqrt k\$ log \$n\$) time.",
}


@TechReport{Tolmach91,
  author =       "Andrew P. Tolmach and Andrew W. Appel",
  title =        "Debuggable Concurrency Extensions for Standard {ML}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-352-91",
  pages =        "42",
  month =        oct,
  year =         "1991",
  abstract =     "We are developing an interactive debugger with reverse
                 execution for the language Standard ML extended to
                 include concurrent threads in the style of Modula-2+.
                 Our debugging approach is based on automatic
                 instrumentation in the source language of the user's
                 source code; this makes the debugger completely
                 independent of the compiler back-end, run-time system,
                 and target hardware. The debugger operates entirely
                 inside the concurrency model and has no special
                 concurrency privileges. In this paper, we consider some
                 of the challenges of debugging a non-deterministic
                 concurrent symbolic language {"}in itself.{"} Issues
                 considered include logging non-deterministic activity,
                 obtaining more secure semantics for our concurrency
                 primitives, controlling distributed computations, and
                 defining suitable time models. We conclude by
                 suggesting an alternative simulation-based approach to
                 dealing with non-determinism.",
}


@TechReport{Blaze91a,
  author =       "Matt Blaze and Rafael Alonso",
  title =        "Dynamic Hierarchical Caching in Large-Scale
                 Distributed File Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-353-91",
  pages =        "42",
  month =        oct,
  year =         "1991",
  abstract =     "Most Distributed File Systems (DFSs) are based on a
                 flat client-server model in which each client interacts
                 directly with the file server for all file operations.
                 While this model works well for relatively small
                 systems in which the file server has adequate capacity
                 for all its clients, it does not scale to large numbers
                 of clients or systems in which the clients are
                 connected to the server through low-bandwidth links.
                 Server traffic can be reduced substantially if clients
                 keep even a modest-sized cache of previously read
                 files. Intuitively, the benefits of caching can be
                 increased by organizing clients into a hierarchy, in
                 which only a small number of machines communicate
                 directly with the file server, providing intermediate
                 caching services to machines below them in the
                 hierarchy. While this potentially reduces server
                 traffic for widely shared files, it can introduce a
                 significant delay for clients low in the hierarchy for
                 access to files with a low degree of sharing. This
                 paper describes a simple method for constructing
                 dynamic hierarchies on a file-by-file basis. The
                 results of a trace-driven simulation of a dynamic
                 hierarchical filesystem are presented, yielding a
                 reduction in server traffic of a factor of more than
                 two for shared files compared with a flat scheme and
                 without a large increase in client access time. An
                 algorithm to maintain cache consistency with low
                 overhead by detecting missed cache invalidation
                 messages is given.",
}


@TechReport{Polyzois91,
  author =       "Christos A. Polyzois and Hector Garcia-Molina",
  title =        "Processing of Read-Only Queries at a Remote Backup",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-354-91",
  pages =        "42",
  month =        nov,
  year =         "1991",
  abstract =     "Remote backup systems are often used to provide high
                 data availability. Updates are typically propagated to
                 the backup via a log, which decouples the backup from
                 the primary. We show that this decoupling can lead to
                 efficient installation of updates in batches and
                 efficient processing of read-only queries, by
                 eliminating or reducing access conflicts between
                 updates and queries. We present several methods for
                 query processing at the backup and evaluate their
                 performance analytically.",
}


@TechReport{Blaze91b,
  author =       "Matt Blaze",
  title =        "{NFS} Tracing by Passive Network Monitoring",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-355-91",
  pages =        "42",
  month =        nov,
  year =         "1991",
  abstract =     "Traces of filesystem activity have proven to be useful
                 for a wide variety of purposes, ranging from
                 quantitative analysis of system behavior to
                 trace-driven simulation of filesystem algorithms. Such
                 traces can be difficult to obtain, however, usually
                 entailing modification of the filesystems to be
                 monitored and runtime overhead for the period of the
                 trace. Largely because of these difficulties, a
                 surprisingly small number of filesystem traces have
                 been conducted, and few sample workloads are available
                 to filesystem researchers. This paper describes a
                 portable toolkit for deriving approximate traces of NFS
                 [1] activity by non-intrusively monitoring the Ethernet
                 traffic to and from the file server. The toolkit uses a
                 promiscuous Ethernet listener interface (such as the
                 Packetfilter[2]) to read and reconstruct NFS-related
                 RPC packets intended for the server. It produces traces
                 of the NFS activity as well as a plausible set of
                 corresponding client system calls. The tool is
                 currently in use at Princeton and other sites, and is
                 available via anonymous ftp.",
}


@TechReport{Han91a,
  author =       "Vijaya Ramachandran Xiafeng Han and Pierre Kelsen and
                 Robert Tarjan",
  title =        "Computing Minimal Spanning Subgraphs in Linear Time",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-356-91",
  pages =        "42",
  month =        dec,
  year =         "1991",
  abstract =     "Let \$P\$ be a property of undirected graphs. We
                 consider the following problem: given a graph \$G\$
                 that has property \$P\$, find a minimal spanning
                 subgraph of \$G\$ with property \$P\$. We describe two
                 related algorithms for this problem and prove their
                 correctness under some rather weak assumptions about
                 \$P\$. We devise a general technique for analyzing the
                 worst-case behavior of these algorithms. By applying
                 the technique to 2-edge-connectivity and
                 biconnectivity, we obtain a tight lower bound of
                 \$OMEGA (m\^{}+\^{}n\$ log \$n\$) on the worst-case
                 sequential running time of the above algorithms for
                 these properties; this resolves open questions posed
                 earlier with regard to these properties. We then give
                 refinements of the basic algorithms that yield the
                 first linear-time algorithms for finding a minimal
                 2-edge-connected spanning subgraph and a minimal
                 biconnected spanning subgraph of a graph.",
}


@TechReport{Friedman91a,
  author =       "Joel Friedman",
  title =        "On the Bit Extraction Problem",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-357-91",
  pages =        "42",
  month =        dec,
  year =         "1991",
  abstract =     "Consider a coloring of the \$n\$-dimensional Boolean
                 cube with \$c\^{}=\^{} 2 sup s\$ colors in such a way
                 that every \$k\$-dimensional subcube is equicolored,
                 i.e. each color occurs the same number of times. We
                 show that for such a coloring we necessarily have
                 \$(k\^{}-\^{}1)/n\^{}$>$= theta sub c \^{} = \^{} (c/2
                 \^{}-\^{} 1)/(c \^{}-\^{} 1)\$. This resolves the
                 {"}bit extraction{"} or {"}\$t\$-resilient functions{"}
                 problem in many cases, such as
                 \$c\^{}-\^{}1\^{}$|$\^{}n\$, proving that XOR type
                 colorings are optimal. We also study the problem of
                 finding almost equicolored colorings when \$(k\^{}-\^{}
                 1)/n\^{}$<$\^{} theta sub c\$, and of classifying all
                 optimal colorings.",
}


@TechReport{Chazelle91c,
  author =       "Bernard Chazelle and Jiri Matousek",
  title =        "Derandomizing an Output-Sensitive Convex Hull
                 Algorithm in Three Dimensions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-358-91",
  pages =        "42",
  month =        dec,
  year =         "1991",
  abstract =     "We consider the computation of the convex hull of a
                 given \$n\$-point set in three-dimensional Euclidean
                 space in an output-sensitive manner. Clarkson and Shor
                 proposed an optimal randomized algorithm for this
                 problem, with an expected running time of
                 \$O(n\^{}log\^{}h)\$, where \$h\$ denotes the number of
                 points on the surface of the convex hull. In this note
                 we point out that the algorithm can be made
                 deterministic by using recently developed techniques,
                 thus obtaining an optimal deterministic algorithm.",
}


@TechReport{Polyzois92,
  author =       "Christos A. Polyzois and Hector Garcia-Molina",
  title =        "Evaluation of Remote Backup Algorithms for Transaction
                 Processing Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-359-92",
  pages =        "26",
  month =        jan,
  year =         "1992",
  abstract =     "A remote backup is a copy of a primary database
                 maintained at a geographically separate location and is
                 used to increase data availability. Remote backup
                 systems are typically log-based and can be classified
                 into 2-safe and 1-safe, depending on whether
                 transactions commit at both sites simultaneously or
                 they first commit at the primary and are later
                 propagated to the backup. We have built an experimental
                 database system on which we evaluated the performance
                 of the epoch algorithm, a 1-safe algorithm we have
                 developed, and compared it with the 2-safe approach
                 under various conditions. We also report on the use of
                 multiple log streams to propagate information from the
                 primary to the backup.",
}


@TechReport{Multiprocessor92,
  author =       "Multiprocessor",
  title =        "An Empirical Comparison of Loop Scheduling Algorithms
                 on a Shared Memory",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-360-92",
  pages =        "26",
  month =        jan,
  year =         "1992",
  abstract =     "Matthias A. Blumrich, Carrie J. Brownhill, Kai Li, and
                 Alexandru Nicolau This paper studies several methods of
                 instruction level parallelization applied at the
                 statement level on a shared memory multiprocessor, and
                 reports the results of an empirical evaluation to
                 determine which of the methods yields the best results.
                 Using sequential code as a base case, we compared
                 doacross, list scheduling, greedy software pipelining
                 (a variant of perfect pipelining), and top down
                 scheduling. The experiments were performed on loops
                 both with and without loop carried dependencies. We
                 find that statement level parallelism does yield
                 speedups on the shared memory multiprocessor. In
                 addition, we observed an interesting superlinearity
                 effect for fully vectorized loops.",
}


@TechReport{Chazelle92,
  author =       "Bernard Chazelle and Jiri Matousek",
  title =        "Randomizing an Output-Sensitive Convex Hull Algorithm
                 in Three Dimensions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-361-92",
  pages =        "5",
  month =        feb,
  year =         "1992",
  abstract =     "We consider the computation of the convex hull of a
                 given \$n\$-point set in three-dimensional Euclidean
                 space in an output-sensitive manner. Clarkson and Shor
                 proposed an optimal randomized algorithm for this
                 problem, with an expected running time
                 \$O(n\^{}log\^{}h)\$, where \$h\$ denotes the number of
                 points on the surface of the convex hull. In this note
                 we point out that the algorithm can be made
                 deterministic by using recently developed techniques,
                 thus obtaining an optimal deterministic algorithm.",
}


@TechReport{Tay92,
  author =       "Y. C. Tay",
  title =        "A Monotonicity Theorem for Tandem Queues",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-362-92",
  pages =        "12",
  month =        feb,
  year =         "1992",
  abstract =     "Tandem queues are often used for performance modeling
                 in production lines, computer systems and communication
                 networks. Consider a series of tandem
                 first-come-first-served queues with single servers. The
                 buffers may be finite or infinite. When a finite buffer
                 is full, the upstream server may suffer from transfer
                 blocking or service blocking. A job's service
                 requirements at various servers may be correlated. A
                 transient analysis shows that, if the network is open,
                 then response time decreases if a server is speeded up,
                 or a finite buffer increases in size, or service
                 blocking is changed to transfer blocking at some
                 server; if the network is closed, then such changes
                 increase the throughput. The analytic technique is
                 elementary, and the equations can be used to simulate a
                 network.",
}


@TechReport{Appel92,
  author =       "Andrew W. Appel",
  title =        "Unrolling Recursions Saves Space",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-363-92",
  pages =        "3",
  month =        mar,
  year =         "1992",
  abstract =     "Partially unrolling a single-branch, non-tail
                 recursion reduces the number of stack frames allocated.
                 This simple transformation can speed up the program and
                 avoid stack overflow.",
}


@TechReport{Appel92a,
  author =       "Andrew W. Appel",
  title =        "A Critique of Standard {ML}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-364-92",
  pages =        "23",
  month =        feb,
  year =         "1992",
  abstract =     "Standard ML is an excellent language for many kinds of
                 programming. It is safe, efficient, suitably abstract
                 and concise. There are many aspects of the language
                 that work well. However, nothing is perfect: Standard
                 ML has a few shortcomings. In some cases there are
                 obvious solutions, and in other cases further research
                 is required.",
}


@TechReport{Effusion92,
  author =       "Alternans in Pericardial Effusion",
  title =        "Nonlinear Heart Model Predicts the Range of Heart
                 Rates for Electrical",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-365-92",
  pages =        "14",
  month =        feb,
  year =         "1992",
  abstract =     "Elisha Sacks and Lawrence Widman We analyze Rigney and
                 Goldberger's [8] two mathematical models of the heart's
                 rocking during pericardial effusion. Both models
                 examine the torques due to the outflow of blood from
                 the heart. The first assumes that the duration of
                 systole varies linearly with heart rate, whereas the
                 second assumes that it does not vary with heart rate.
                 The analysis predicts the motion of the heart for heart
                 rates between 50 and 200 and for a range of initial
                 positions and velocities. The first model predicts that
                 the heart rocks once every other beat (exhibits
                 electrical alternans) at heart rates between 88 and 119
                 and rocks once per beat otherwise, and explains the
                 appearance and disappearance of alternans
                 mathematically. The results agree within 5\% with the
                 published clinical data, which shows alternans at heart
                 rates between 90 and 124. The second model predicts the
                 same qualitative behavior, but with alternans occurring
                 solely at heart rates between 105 and 116. We describe
                 an analysis program for ordinary differential equations
                 that analyzed the models quickly and automatically.",
}


@TechReport{Segments92,
  author =       "Segments and Polygons",
  title =        "Optimal Algorithms for Computing Connected Components
                 of Bichromatic Line",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-366-92",
  pages =        "7",
  month =        mar,
  year =         "1992",
  abstract =     "David Dobkin and Jenny Zehong Zhao A set of planar
                 geometric objects can be partitioned into connected
                 components, where these are defined by the reflective
                 transitive closure of the pairwise intersection or
                 overlap relation. We consider the problem of finding
                 connected components of the union between \$m\$ blue
                 line segments and \$n\$ red line segments in the plane,
                 assuming that two line segments are disjoint if they
                 have the same color. We solve this problem in \$O(N\$
                 log \$N)\$ time and \$O(N)\$ space, where \$N = m+n\$,
                 by using a variant of thesetment tree and union-find
                 technique. It is then generalized to determine, in the
                 same time and space bounds, the connected components of
                 bichromatic simple polygons with \$N\$ sides total,
                 where polygons with the same color do not intersect or
                 overlap.",
}


@TechReport{Sacks92,
  author =       "Elisha Sacks and Leo Joskowicz",
  title =        "Mechanism Simulation with Configuration Spaces and
                 Simple Dynamics",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-367-92",
  pages =        "33",
  month =        mar,
  year =         "1992",
  abstract =     "We present a practical simulation program for rigid
                 part mechanisms, such as feeders, locks, and brakes.
                 The program performs a kinematic simulation of the
                 behavior produced by part contacts and input motions
                 along with a dynamical simulation of the behavior
                 produced by gravity, springs, and friction. It
                 describes the behavior in a compact, symbolic format
                 and with a realistic, three-dimensional animation. The
                 program is much more efficient than traditional
                 simulation. It examines roughly 1/6 as many degrees of
                 freedom because the kinematics module precomputes the
                 configurations where parts collide. It uses a simple
                 model of dynamics that captures the steady-state effect
                 of forces without the conceptual and computational cost
                 of dynamical simulation. We demonstrate that our
                 simulation algorithm captures the workings of most
                 mechanisms by surveying 2500 mechanisms from an
                 engineering encyclopedia.",
}


@TechReport{Palios92,
  author =       "Leonidas Palios",
  title =        "Decomposition Problems in Computational Geometry",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-368-92",
  pages =        "118",
  month =        apr,
  year =         "1992",
  abstract =     "Decomposition problems are of major importance in
                 computational geometry, as they allow us to express
                 complicated objects in terms of simpler ones, which are
                 in general easier to process, and often lead to more
                 efficient algorithms. In this thesis, we present two
                 decomposition algorithms on three-dimensional
                 polyhedra, one to partition the boundary of a
                 polyhedron of arbitrary genus into a small number of
                 {"}well-behaved{"} pieces, the other to partition a
                 polyhedron of zero genus into tetrahedra. The first
                 algorithm decomposes the boundary of a polyhedron of
                 \$r\$ reflex angles into at most \$10r - 2\$ connected
                 pieces, each of which lies on the boundary of its
                 convex hull. A remarkable feature of this result is
                 that the number of these convex-like pieces is
                 independent of the number of vertices. Furthermore, it
                 is linear in \$r,\$ which contrasts with a quadratic
                 worst-case lower bound on the number of convex pieces
                 needed to decompose the polyhedron itself. The number
                 of new vertices introduced in the process is \$0(n),\$
                 and the decomposition can be computed in \$0(n + r log
                 r)\$ time. The second algorithm decomposes a polyhedron
                 of zero genus (a polyhedron homeomorphic to a
                 three-dimensional ball) that has \$n\$ vertices and
                 \$r\$ reflex angles into a collection of \$0(n + r sup
                 2\^{})\$ tetrahedra. The algorithms runs in \$0((n + r
                 sup 2\^{})\$ log \$r)\$ time and requires \$0(n + r sup
                 2\^{})\$ space. Up to within a constant factor, the
                 number of tetrahedra produced is optimal in the worst
                 case. Discussion on an implementation of the second
                 algorithm in the programming language C concludes the
                 thesis. It involves the issues of how to carry out some
                 of the tasks outlined in the theoretical description,
                 how to represent the entities participating in the
                 different stages of the algorithm, and how to deal with
                 finite precision arithmetic.",
}


@TechReport{Pach92,
  author =       "J$\backslash$o{"}a{\'{ }}{"}nos Pach and Jeno
                 Torocsik",
  title =        "Layout of Rooted Trees",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-369-92",
  pages =        "7",
  month =        feb,
  year =         "1992",
  abstract =     "Let \$S\$ be a set of \$n\$ points in the plane in
                 general position. The depth of a point \$p$\in$ S\$ is
                 the minimum number of elements of \$S\$ in a closed
                 halfplane containing \$p\$. We prove that, if \$p\$ is
                 not the deepest point of \$S\$ or the depth of \$p\$ is
                 at most \$n over 3\$ \$+1\$, then any tree with \$n\$
                 vertices and with root \$r\$ can be straight-line
                 embedded on \$S\$ so that \$r\$ is mapped onto \$p.\$
                 This gives a partial answer to a problem raised by
                 Micha Perles.",
}


@TechReport{Polyzois92a,
  author =       "Christos A. Polyzois",
  title =        "Disaster Recovery for Transaction Processing Systems",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-371-92",
  pages =        "102",
  month =        jun,
  year =         "1992",
  abstract =     "A remote backup is a copy of a primary database
                 maintained at a geographically separate location and is
                 used to increase data availability. Remote backup
                 systems are usually log--based and can be classified as
                 either 2--safe or 1--safe, depending on whether
                 transactions commit at both sites simultaneously or the
                 commit first at the primary and are then propagated to
                 the backup. This thesis describes the 1--safe
                 algorithms that can exploit multiple log streans to
                 propagate information from the primary to the backup.
                 An experimental distributed database system is used to
                 evaluate the performance of these algorithms and
                 compare the 1--safe with the 2--safe approach under
                 various conditions. Techniques for processing
                 read--only queries at the backup are also presented.",
}


@TechReport{Petersen92,
  author =       "Karin Petersen and Kai Li",
  title =        "A Comparative Evaluation of Cache Coherence Schemes
                 Based on Virtual Memory Support",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-373-92",
  pages =        "13",
  month =        may,
  year =         "1992",
  abstract =     "This paper presents an evaluation of a new class of
                 software cache coherence schemes that use virtual
                 memory (VM) support to maintain multiprocessor cache
                 coherence. Traditional VM translation hardware in each
                 processor detects memory access attempts that would
                 violate cache coherence and system software is used to
                 enforce coherence. The implementation of this class of
                 coherence schemes is extremely economical: it requires
                 neither special multiprocessor hardware nor compiler
                 support, and easily incorporates different consistency
                 models. We have evaluated four consistency models for
                 the VM-based approach: sequential consistency,
                 single-writer release consistency, release consistency,
                 and lazy release consistency. Our trace-driven
                 simulation results show that the VM-based cache
                 coherence schemes are practical for small-scale
                 multiprocessors and that the performance of lazy
                 release consistency for multi-threaded parallel
                 programs is close to the snoopy-cache
                 invalidation-based coherence approach.",
}


@TechReport{Rogers92,
  author =       "Laurie J. Hendren Anne Rogers and John H. Reppy",
  title =        "Supporting {SPMD} Execution for Dynamic Data
                 Structures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-374-92",
  pages =        "23",
  month =        jun,
  year =         "1992",
  abstract =     "In this paper, we address the problem of supporting
                 SPMD execution of programs that use
                 recursively--defined dynamic data structures on
                 distributed memory machines. The techniques developed
                 for supporting SPMD execution of array--based programs
                 rely on the fact that arrays are statically defined and
                 directly addressable. As a result, these techniques do
                 not apply to recursive data structures, which are
                 neither statically defined nor directly addressable. We
                 propose a three--pronged approach. First, we describe a
                 simple mechanism for migrating a thread of control
                 based on the layout of heap--allocated data. Second, we
                 explain how to introduce parallelism into the model
                 using a technique based on futures and lazy task
                 creation [MKH91]. Third, we present the compiler
                 analyses and parallelization techniques that are
                 required to exploit the proposed mechanism.",
}


@TechReport{Tal92,
  author =       "Ayellet Tal and Rafael Alonso",
  title =        "Integration of Mommit Protocols in Heterogeneous
                 Databases",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-375-92",
  pages =        "32",
  month =        jun,
  year =         "1992",
  abstract =     "In this paper we explore the problem of atomic
                 commitment among a collection of heterogeneous
                 distributed databases. We distinguish between two
                 cases. In the first, the individual databases which
                 participate in the system do not externalize their
                 commit protocols. Several ways to handle this case have
                 been proposed in the literature. We discuss and
                 classify the various solutions. The second case, where
                 the individual databases do externalize their commit
                 protocols, has not been discussed in detail in the
                 past. We will focus on this case, and propose new
                 heterogeneous commit protocols for two subproblems:
                 joining databases that have different 2-phase commit
                 protocols (e.g., centralized and linear); and uniting
                 databases using a 3-phase commit protocol with others
                 employing a 2-phase commit protocol.",
}


@TechReport{Tolmach92,
  author =       "Andrew Tolmach and J. Gregory Morrisett",
  title =        "A Portable Multiprocessor Interface for Standard {ML}
                 of New Jersey",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-376-92",
  pages =        "31",
  month =        jun,
  year =         "1992",
  abstract =     "We have designed a portable interface between
                 shared--memory multiprocessors and Standard ML of New
                 Jersey. The interface is based on the conventional
                 kernel thread model and provides facilities that can be
                 used to implement user--level thread packages. The
                 interface supports experimentation with different
                 thread scheduling policies and synchronization
                 constructs. It has been ported to three different
                 multiprocessors and used to construct a general
                 purpose, user--level thread package. In this paper, we
                 discuss the interface and its implementation and
                 performance, with emphasis on the Silicon Graphics
                 4D/380S multiprocessor.",
}


@TechReport{Tolmach92a,
  author =       "Andrew Peter Tolmach",
  title =        "Debugging Standard {ML}",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-378-92",
  pages =        "219",
  month =        oct,
  year =         "1992",
  abstract =     "Traditional ''source--level'' debuggers for compiled
                 languages actually operate at machine level, which
                 makes them complex, difficult to port, and intolerant
                 of compiler optimization. For type--safe languages,
                 however, debugging support can be provided without
                 reference to the underlying machine, by adding
                 instrumentation to program source code before
                 compilation. Because the instrumented code is (almost)
                 ordinary source, it can be processed by the ordinary
                 compiler. The debugger is thus independent from the
                 underlying hardware and runtime systems, and from the
                 optimization strategies used by the compiler. This
                 dissertation describes the design and implementation of
                 instrumentation--based debuggers for the Standard ML of
                 New Jersey compiler. Three systems are described: a
                 simple debugger with ordinary variable display and
                 breakpoint facilities, a debugger supporting --- and
                 taking advantage of --- reverse execution, and a
                 debugger for ML Threads, a concurrent extension of ML
                 running on multiprocessors. A formal operational
                 semantics for a subset of ML is used to define
                 debugging operations precisely, and to provide a basis
                 for determining the concrete types of polymorphic
                 variables at runtime. Debugger performance measurements
                 are presented for a range of real programs.",
}


@TechReport{Cox92,
  author =       "Michael Cox and Patrick Hanrahan",
  title =        "Depth Complexity in Object-Parallel Graphics
                 Architectures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-382-92",
  pages =        "53",
  month =        sep,
  year =         "1992",
  abstract =     "We consider a multiprocessor graphics architecture
                 object--parallel if graphics primitives are assigned to
                 processors without regard to screen location, and if
                 each processor completely renders the primitives it is
                 assigned. Such an approach leads to the following
                 problem: \ the images rendered by all processors must
                 be merged, or composited, before they can be displayed.
                 At worst, the number of pixels that must be merged is a
                 frame per processor. Perhaps there is a more
                 parsimonious approach to pixel merging in
                 object--parallel architectures than merging a full
                 frame from each processor. In this paper, we analyze
                 the number of pixels that must be merged in
                 object--parallel architectures. Our analysis is from
                 the perspective that the number of pixels to be merged
                 is a function of the depth complexity of the graphics
                 scene to be rendered, and a function of the depth
                 complexity of each processor's subset of the scene to
                 be rendered. We derive a model of depth complexity of
                 graphics scenes rendered on object--parallel
                 architectures. The model is based strictly on the
                 graphics primitive size distribution, and on number of
                 processors. We validate the model with trace data from
                 a number of graphics applications, and with
                 trace--driven simulations of rendering on
                 object--parallel architectures. The results of our
                 analysis suggest some directions in design of
                 object--parallel architectures, and suggest that our
                 model can be used in future analysis of design
                 trade--offs in these architectures.",
}


@TechReport{Dobkin92,
  author =       "David P. Dobkin",
  title =        "Computational Geometry and Computer Graphics",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-383-92",
  pages =        "22",
  month =        aug,
  year =         "1992",
  abstract =     "Computer graphics is a defining application for
                 computational geometry. The interaction between these
                 fields is explored through two scenarios. Spatial
                 subdivisions studied from the viewpoint of
                 computational geometry are shown to have found
                 application in computer graphics. Hidden surface
                 removal problems of computer graphics have led to
                 sweepline and area subdivision algorithms in
                 computational geometry. The paper ends with two
                 promising research areas with practical applications:
                 precise computation and polyhedral decomposition.",
}


@TechReport{Friedman92,
  author =       "Joel Friedman",
  title =        "Probabilistic Spaces of Boolean Functions of a Given
                 Complexity: Generalities and Random \$k\$-{SAT}
                 Coefficients",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-387-92",
  pages =        "27",
  month =        jul,
  year =         "1992",
  abstract =     "In this paper we develop an approach to studying
                 probabilistic spaces of boolean functions, namely
                 recovering exact formulas for the event probabilities
                 in terms of the moments. While this involves analyzing
                 a large number of moments, there are situations in
                 which this seems feasible to do; for the \$m\$-fold AND
                 of a probability space of functions, there is a formula
                 involving coefficients with a geometric intepretation
                 (and which is otherwise quite simple). We investigate
                 the coefficients involved in the \$k\$-SAT problem,
                 where we give a formula for the \$1\$-SAT coefficients
                 and are able to understand a few of the \$2\$-SAT
                 coefficients.",
}


@TechReport{Ristad92,
  author =       "Eric Sven Ristad",
  title =        "Complexity of the Simplified Segmental Phonology",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-388-92",
  pages =        "19",
  month =        aug,
  year =         "1992",
  abstract =     "This article presents detailed complexity analysis of
                 the encoding and decoding problems for the segmental
                 phonology. The segmental model is a generative theory
                 of phonological dependencies. As such, it poses two
                 computational problems. The first computational problem
                 is the problem of actually encoding the dependencies of
                 a given phonology into a given representation of
                 phonological knowledge (the encoding problem). The
                 second computational problem is the problem of deciding
                 whether a given phonological representation encodes the
                 dependencies of a given phonology (the decoding
                 problem).\par We begin by proving that the encoding and
                 decoding problems are both undecidable in the segmental
                 model. Next, we motivate a simplified segmental model,
                 that more accurately models the phonological
                 dependencies actually proposed in the phonological
                 literature. The simplified segmental model is a more
                 restricted and more natural reformalization of the
                 segmental model. To conclude, we prove that the
                 encoding and decoding problems are NP-complete in this
                 simplified segmental model.",
}


@TechReport{Buchsbaum92,
  author =       "Adam L. Buchsbaum and Milena Mihail",
  title =        "Monte Carlo and Markov Chain Techniques for Network
                 Reliability and Sampling",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-391-92",
  pages =        "18",
  month =        sep,
  year =         "1992",
  abstract =     "We outline a heuristic to approximate various
                 reliability related parameters of communications
                 networks under link failures. Our scheme is based on
                 Monte Carlo and Markov chain simulation techniques. We
                 shall present the ideas of these Monte Carlo and Markov
                 chain techniques in terms of a specific reliability
                 measure. However, the general method could be
                 applicable to other reliability measures and, in fact,
                 to other combinatorial problems. We present initial
                 experimental results which suggest that our approach is
                 efficient in the computational complexity sense
                 (running time polynomial in the size of the input);
                 furthermore, our results suggest practical
                 applicability for medium size networks and single-edge
                 parameters. As an example, we present the results of
                 our experiments on a network that was posed for
                 analysis by Applied Research at Bellcore: We estimated
                 all single-edge parameters on a single DEC-5000 in less
                 than 4 hours. The software that supported our
                 experiments involves approximately 3000 lines of C-code
                 and is easy to adapt to other applications.",
}


@TechReport{Chao92,
  author =       "Liang-Fang Chao and Edwin Hsing-Mean Sha",
  title =        "Scheduling Data-Flow Graphs via Retiming and
                 Unfolding",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-396-92",
  pages =        "30",
  month =        oct,
  year =         "1992",
  abstract =     "Loop scheduling is an important problem in parallel
                 processing. Retiming technique reorganizes an iteration
                 by introducing a prologue section. Unfolding technique
                 schedules several iterations together. We invent a new
                 technique by combining these two to obtain a static
                 schedule with a reduced average computation time per
                 iteration. Many fundamental properties of loop
                 scheduling are derived through this combination. We
                 first prove that the order of retiming and unfolding is
                 irrelevant for scheduling a data-flow graph (DFG).
                 $>$From this nice property, we present a
                 polynomial-time algorithm on the original DFG, before
                 unfolding, to find the minimum-rate static schedule for
                 a given unfolding factor. For the case of a unit-time
                 DFG, the minimum rate-optimal unfolding factor is
                 derived, and efficient checking and retiming algorithms
                 are presented. The problem of software pipelining is
                 modeled as a unit-time DFG, and an efficient algorithm
                 for finding the rate-optimal schedule is presented.",
}


@TechReport{Sha92,
  author =       "Edwin Hsing-Mean Sha and Kenneth Steiglitz",
  title =        "Maintaining Bipartite Matchings in the Presence of
                 Failures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-398-92",
  pages =        "16",
  month =        oct,
  year =         "1992",
  abstract =     "We present an on-line distributed reconfiguration
                 algorithm for finding a new maximum matching
                 incrementally after some nodes have failed. Our
                 algorithm is deadlock free, and with \$k\$ failures
                 maintains at least \$M - k\$ matching pairs during the
                 reconfiguration process, where \$M\$ is the size of the
                 original maximum matching. The algorithm tolerates
                 failures that occur during reconfiguration. The
                 worst-case reconfiguration time is \$O(k
                 $\backslash$min($|$A$|$, $|$B$|$))\$ after \$k\$
                 failures, where \$A\$ and \$B\$ are the node sets, but
                 simulations show that the average-case reconfiguration
                 time is much better. The algorithm is also simple
                 enough to be implemented in hardware.",
}


@TechReport{Support92,
  author =       "Support",
  title =        "Cache Coherence for Shared Memory Multiprocessors
                 Based on Virtual Memory",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-400-92",
  pages =        "18",
  month =        dec,
  year =         "1992",
  abstract =     "Karin Petersen and Kai Li (pages, December 1992) This
                 paper presents a software cache coherence scheme that
                 uses virtual memory (VM) support to maintain cache
                 coherency for shared memory multiprocessors and
                 requires no special hardware to do so. Traditional VM
                 translation hardware in each processor is used to
                 detect memory access attempts that would violate cache
                 coherence and system software is used to enforce
                 coherence. The implementation of this class of
                 coherence schemes is extremely economical: it requires
                 neither special multiprocessor hardware nor compiler
                 support, and easily incorporates different consistency
                 models.\par We evaluated two consistency models for the
                 VM-based approach: sequential consistency and lazy
                 release consistency. The VM-based schemes are compared
                 with a bus based snoopy caching architecture, and our
                 trace-driven simulation results show that the VM-based
                 cache coherence schemes are practical for small-scale,
                 shared memory multiprocessors.",
}


@TechReport{Schroeder93,
  author =       "Peter Schroeder and Pat Hanrahan",
  title =        "A Closed Form Expression for the Form Factor between
                 Two Polygons",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-404-93",
  pages =        "13",
  month =        jan,
  year =         "1993",
  abstract =     "Form factors are used in computer graphics and
                 radiative heat transfer to describe the fraction of
                 diffusely refledted light or radiation leaving one
                 surface and arriving at another. They are a fundamental
                 geometric property used for computation. Many special
                 configurations admit closed form solutions. However,
                 the important case of the form factor between two
                 polygons in three space has had no known closed form
                 solution. We give a closed form solution for the case
                 of general (planar, convex, or concave, possibly
                 containing holes) polygons. The solution is
                 non-elementary since it involves dilogarithms.",
}


@TechReport{Davies93,
  author =       "Rebecca Davies",
  title =        "Bibliography of Technical Reports 1985-91",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-405-93",
  pages =        "73",
  month =        jan,
  year =         "1993",
  abstract =     "Abstracts of all technical reports published by the
                 Department of Computer Science between 1985 and 1991.",
}


@TechReport{Plank93,
  author =       "James Steven Plank",
  title =        "Efficient Checkpointing on {MIMD} Architectures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-406-93",
  pages =        "137",
  month =        jun,
  year =         "1993",
  abstract =     "Presented here are efficient algorithms for
                 checkpointing on MIMD architectures. These algorithms
                 have been implemented on two representative machines: a
                 shared-memory multiprocessor, and a message-passing
                 multicomputer. The algorithms and implementations are
                 evaluated according to three speed metrics: checkpoint
                 time, overhead, and latency. Checkpointing is important
                 as a general means of software fault-tolerance. It is
                 also the backbone of certain program control utilities,
                 such as job-swapping, process migration, and playback
                 debugging. We employ several techniques to minimize the
                 invasiveness of the checkpointer on the target program.
                 Such techniques are main memory checkpointing,
                 copy-on-write, buffering, compression, and the
                 elimination of bottlenecks and extra control messages.
                 The major result of this dissertation is that we can
                 implement efficient checkpointing on MIMD
                 architectures, thereby enhancing the usability of such
                 machines.",
}


@TechReport{Gortler93,
  author =       "Steven Gortler and Michael F. Cohen and Philipp
                 Slusallek",
  title =        "Radiosity and Relaxation Methods: Progressive
                 Refinement is Southwell Relaxation",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-408-93",
  pages =        "24",
  month =        feb,
  year =         "1993",
  abstract =     "The radiosity method for realistic image synthesis has
                 been described in the computer graphics literature
                 since 1984. This paper discusses the various algorithms
                 which have been developed for solving the radiosity
                 problem and places them in the context of the
                 literature on solving systems of linear equations. The
                 progressive radiosity method developed in 1988 is shown
                 to be equivalent to a numerical technique known as
                 Southwell iteration. A proof of convergence for this
                 method when used for the radiosity problem is presented
                 in the appendix. A new overshooting (similar to over
                 relaxation) method is developed as a means of
                 accelerating the convergence of the iterative radiosity
                 methods.",
}


@TechReport{Hanrahan93,
  author =       "Pat Hanrahan and Wolfgang Krueger",
  title =        "Reflection from Layered Surfaces due to Subsurface
                 Scattering",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-409-93",
  pages =        "32",
  month =        jan,
  year =         "1993",
  abstract =     "The reflection of light from most materials consists
                 of two major terms: the specular and the diffuse.
                 Specular reflection may be modeled from first
                 principles by considering a rough surface consisting of
                 perfect reflectors, or micro-facets. Diffuse reflection
                 is generally considered to result from subsurface
                 scattering; that is, light enters a surface layer, is
                 scattered multiple times, and then exits in a random
                 direction in the process inheriting the color of the
                 surface. Accounting for diffuse reflection by Lambert's
                 cosine law, as is universally done in computer
                 graphics, is not a physical theory based on first
                 principles.\par This paper presents a model for
                 subsurface scattering in layered surfaces in terms of
                 one-dimensional linear transport theory. The solutions
                 to this equation account for diffuse reflection from
                 first principles. This model is particularly
                 appropriate for common layered materials appearing in
                 nature, such as biological tissues (e.g. skin, leaves,
                 etc.) or inorganic materials (e.g. snow, sand, paint,
                 varnished or dusty surfaces). As an application of the
                 model, we simulate the appearance of a face and a
                 cluster of leaves, from experimental data describing
                 their layer properties.",
}


@TechReport{Appel93,
  author =       "Andrew W. Appel and Marcelo J. R. Goncalves",
  title =        "Hash-Consing Garbage Collection",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-412-93",
  pages =        "18",
  month =        feb,
  year =         "1993",
  abstract =     "We describe an implementation of hash-consing for the
                 Standard ML of New Jersey compiler. Hash-consing can
                 eliminate replication among heap-allocated data, which
                 may allow the use of fast equality checking and may
                 also improve the locality of reference of a program.
                 The cost of a hash table lookup for each record
                 allocated may, however, offset any gains from the
                 elimination of replication.\par Our hash-consing scheme
                 is integrated with a generational garbage collector.
                 Only records that survive a garbage collection are
                 ``hash-consed,'' thus avoiding the cost of a table
                 lookup for short-lived records. We discuss some issues
                 related with the implementation of this scheme and
                 present a performance evaluation.",
}


@TechReport{Edahiro93,
  author =       "Masato Edahiro",
  title =        "Delay Minimization for Zero-Skew Routing",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-415-93",
  pages =        "26",
  month =        mar,
  year =         "1993",
  abstract =     "Delay minimization methods are proposed for zero-skew
                 routings. A delay-time estimation formula is derived,
                 which can be used as an objective function to be
                 minimized in zero-skew routing algorithms. Moreover,
                 the optimum wire width is formulated. Experimental
                 results show that our methods with a clustering-based
                 algorithm achieve 50\% reduction of the delay time on
                 benchmark data with 3000 pins.",
}


@TechReport{Edahiro93a,
  author =       "Masato Edahiro",
  title =        "A Clustering-Based Optimization Algorithm in Zero-Skew
                 Routings",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-416-93",
  pages =        "18",
  month =        mar,
  year =         "1993",
  abstract =     "A zero-skew routing algorithm with clustering and
                 improvement methods is proposed. This algorithm
                 generates a zero-skew routing in O(n log n) time for n
                 pins, and it is proven that the order of the total wire
                 length is best possible. Our algorithm achieves 20\%
                 reduction of the total wire length and 15\%-50\%
                 improvement of the delay time on benchmark data
                 compared with the best known algorithm.",
}


@TechReport{Campos93,
  author =       "Alvaro E. Campos",
  title =        "Distributed, Garbage-Collected, Persistent, Virtual
                 Address Spaces",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-419-93",
  pages =        "116",
  month =        jun,
  year =         "1993",
  abstract =     "Most integrated programming environments were designed
                 for uniprocessor systems, and they require substantial
                 processing power and storage capacity. Despite the
                 advantages they offer --- flexibility, rapid response
                 --- their appetites have limited their use. The recent
                 increases in work-station and network computing power
                 provide an opportunity to overcome these
                 limitations.\par This dissertation describes the design
                 of a distributed, language-based, integrated
                 environment and its implementation on current hardware.
                 A distributed system allows users, who can access the
                 system from different locations, to share values and
                 computing power. Shared virtual-memory techniques are
                 used to distribute the address space of $\backslash$EZ,
                 a persistent, very high-level, string-processing
                 programming and command language. Unlike other
                 persistent systems, persistence pervades
                 $\backslash$EZ\ and applies to both data and active
                 objects. Distributed $\backslash$EZ\ runs on a loosely
                 coupled multiprocessor, implemented as several
                 work-stations connected by a network.\par A distributed
                 virtual-memory manager provides a shared-memory
                 programming paradigm even though there is no shared
                 physical memory accessible by all work-stations. The
                 virtual address space is distributed over the secondary
                 storage devices of the individual processors. Managers
                 cache pages into the physical memory of the
                 work-stations that access them and maintain coherence
                 among the multiple copies of a page. They use
                 replication to permit multiple readers, but permit only
                 one writer.\par A distributed, mark-and-sweep garbage
                 collector, which works in concert with the memory
                 manager, reclaims inaccessible objects in the
                 distributed system. This collector is concurrent and
                 real-time. The memory manager collaborates with the
                 collector to avoid direct mutator assistance.\par The
                 results show that it is feasible to build an effective
                 distributed system by using shared virtual memory to
                 distribute the persistent address space. Performance
                 remains a problem, due mainly to the high cost of
                 network communication. The implementation of
                 $\backslash$EZ's data structures conflicts with the
                 techniques used to maintain cache coherence and cause
                 too much interprocessor communication. The distributed,
                 mark-and-sweep garbage collector works well, however,
                 and it is especially effective when the system activity
                 is distributed among several processors.",
}


@TechReport{Sacks93,
  author =       "Elisha Sacks and Leo Joskowicz",
  title =        "Comprehensive Kinematic Analysis of Higher Pairs with
                 Two Degrees of Freedom",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-421-93",
  pages =        "18",
  month =        apr,
  year =         "1993",
  abstract =     "We present a comprehensive kinematic analysis program
                 for higher pairs with two degrees of freedom, such as
                 gears, cams, ratchets, and escapements. The program,
                 called HIPAIR, derives the contact constraints and
                 contact transitions of a pair by computing its
                 configuration space. It generates the contact curves of
                 the interacting features, finds their intersection
                 points, and partitions the resulting space. It derives
                 displacement, velocity, and acceleration plots by
                 simulating driving motions in configuration space.
                 HIPAIR handles intermittent, simultaneous, and
                 degenerate contacts between planar and 2.5D parts. This
                 class contains 90$\backslash$\% of 2.5D pairs and
                 80$\backslash$\% of all higher pairs according to our
                 survey of 2500 mechanisms from an engineering
                 encyclopedia. HIPAIR analyzes pairs of average shape
                 complexity in under five seconds on a workstation. It
                 facilitates the design and analysis of multipart
                 mechanisms that contain higher pairs. It helps
                 designers detect part interference, establish part
                 clearances, identify functional surfaces, and find
                 jamming and lock-up configurations.",
}


@TechReport{Joskowicz93,
  author =       "Leo Joskowicz and Elisha Sacks",
  title =        "A Catalog of Higher Pairs and Their Configuration
                 Spaces",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-424-93",
  pages =        "25",
  month =        jun,
  year =         "1993",
  abstract =     "We illustrate the HIPAIR kinematic analysis program
                 for higher pairs on twenty examples from Artobolevsky's
                 encyclopedia of mechanisms. For each example, we show
                 the pair, present its configuration space, explain its
                 structure and behavior, and list its reference number
                 in the encyclopedia. All the figures ar e direct
                 program output. HIPAIR is the first comprehensive
                 kinematic analysis program for higher pairs. It covers
                 pairs of 2.5D parts with two degrees of freedom,
                 including ones with intermittent, simultaneous, and
                 degenerate contacts. This class contains
                 90$\backslash$\% of 2.5D pairs and 80$\backslash$\% of
                 all higher pairs according to our survey of 2500
                 mechanisms. It analyzes pairs of average shape
                 complexity in five seconds and pairs with several
                 thousand features in one minute. HIPAIR facilitates the
                 design and analysis of multipart mechanisms that
                 contain higher pairs. It helps designers detect part
                 interference, establish part clearances, identify
                 functional surfaces, and find jamming and lock-up
                 configurations.",
}


@TechReport{Allender93,
  author =       "Eric Allender and Mitsunori Ogiwara",
  title =        "Relationships among {PL}, $\backslash$\#{L}, and the
                 Determinant",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-425-93",
  pages =        "20",
  month =        jun,
  year =         "1993",
  abstract =     "Recent results by Toda, Vinay, Damm, and Valiant have
                 shown that the complexity of the determinant is
                 characterized by the complexity of counting the number
                 of accepting computations of a nondeterministic
                 logspace-bounded machine. (This class of functions is
                 known as $\backslash$\#L.) Using that characterization,
                 we give a very simple proof of a theorem of Jung,
                 showing that probabilistic logspace-bounded (PL)
                 machines lose none of their computational power if they
                 are restricted to run in polynomial time.\par We also
                 present new results comparing and contrasting the
                 classes of functions reducible to PL, $\backslash$\#L,
                 and the determinant, using various notions of
                 reducibility.",
}


@TechReport{Dikaiakos93,
  author =       "Marios D. Dikaiakos and Anne Rogers and Kenneth
                 Steiglitz",
  title =        "Functional Algorithm Simulation: Implementation and
                 Experiments",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-429-93",
  pages =        "38",
  month =        jun,
  year =         "1993",
  abstract =     "In this paper we describe a new way to predict the
                 computation and communication characteristics of
                 parallel algorithms for a class of scientific problems.
                 The approach uses Functional Algorithm Simulation -
                 simulation without actually performing the numerical
                 computations. We implemented a prototype system called
                 FAST, and used it to study two important algorithms:
                 (1) SIMPLE, a popular computational fluid dynamics
                 kernel; and (2) the Fast Multipole Method (FMM) for
                 solving the N-body problem. Data obtained for SIMPLE
                 validated the accuracy of the approach, and also
                 allowed us to analyze SIMPLE's scalability. The results
                 for the FMM provided a wealth of data on communication
                 patterns and available parallelism during different
                 algorithmic phases, and provided upper bounds on
                 available speedup for a wide range of problem sizes.
                 The approach also allowed us to predict the performance
                 of the FMM on message-passing multiprocessors with a
                 variety of topologies, including cliques, hypercubes,
                 rings, and multirings, over a wider range of problem
                 sizes and numbers of processors than would be feasible
                 by direct simulation.",
}


@TechReport{Chao93,
  author =       "Liang-Fang Chao and Edwin Hsing-Mean Sha",
  title =        "Static Scheduling for Synthesis of {DSP} Algorithms on
                 Various Models",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-432-93",
  pages =        "26",
  month =        aug,
  year =         "1993",
  abstract =     "Given a behavioral description of a DSP algorithm
                 represented by a data-flow graph, we show how to obtain
                 a rate-optimal static schedule with the minimum
                 unfolding factor under two models, integral grid model
                 and fractional grid model, and two kinds of
                 implementations for each model, pipelined
                 implementation and non-pipelined implementation. We
                 present a simple and unified approach to deal with the
                 four possible combinations. A unified polynomial-time
                 scheduling algorithm is presented, which works on the
                 original data-flow graphs without really unfolding. The
                 values of the minimum rate-optimal unfolding factors
                 and the general properties for all the four
                 combinations are proved.",
}


@TechReport{Klein93,
  author =       "Philip N. Klein and Robert E. Tarjan",
  title =        "A Randomized Linear-Time Algorithm for Finding Minimum
                 Spanning Trees",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-436-93",
  pages =        "9",
  month =        oct,
  year =         "1993",
  abstract =     "We present a randomized linear-time algorithm for
                 finding a minimum spanning tree in a connected graph
                 with edge weights. The algorithm is a modification of
                 one proposed by Karger and uses random sampling in
                 combination with a recently discovered linear-time
                 algorithm for verifying a minimum spanning tree. Our
                 computational model is a unit-cost random-access
                 machine with the restriction that the only operations
                 allowed on edge weights are binary comparisons.",
}


@TechReport{Blumrich93,
  author =       "Matthias A. Blumrich and Edward W. Felten Kai Li and
                 Cezary Dubnick Richard Alpert",
  title =        "Virtual Memory Mapped Network Interface for the
                 {SHRIMP} Multicomputer",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-437-93",
  pages =        "12",
  month =        nov,
  year =         "1993",
  abstract =     "and Jonathan Sandberg The network interfaces of
                 existing multicomputers require a significant amount of
                 software overhead at the operating system and user
                 levels to provide protection and to implement message
                 passing protocols. This paper describes the design of a
                 low-latency, high-bandwidth, virtual memory-mapped
                 network interface for the SHRIMP multicomputer project
                 at Princeton University. Without sacrificing
                 protection, the network interface achieves low latency
                 by using virtual memory mapping and write-latency
                 hiding techniques, and obtains high bandwidth by
                 providing a user-level block data transfer mechanism.
                 We have implemented several message passing primitives
                 in an experimental environment, demonstrating that our
                 approach can reduce the message passing overhead to a
                 few user-level instructions.",
}


@TechReport{Iftode93,
  author =       "Liviu Iftode and Kai Li",
  title =        "Process Capturing",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-439-93",
  pages =        "5",
  month =        nov,
  year =         "1993",
  abstract =     "A challenge in mobile computing is to provide
                 continuous interactions between users and their running
                 applications. An interesting model is to allow a user's
                 computing environment to migrate between a stationary
                 computer and a mobile computer while applications are
                 running. To achieve this goal, it is necessary to
                 extend existing operating systems at several levels.
                 This paper focuses on the process management level and
                 proposes a simple mechanism called process capturing.
                 We have implemented a experimental shell and showed
                 that process capturing is a simple and effective
                 mechanism to support computing environment migration.",
}


@TechReport{Danskin94,
  author =       "John Danskin and Pat Hanrahan",
  title =        "Compression Performance of the Xremote Protocol",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-441-94",
  pages =        "10",
  month =        jan # " 5",
  year =         "1994",
  abstract =     "The Xremote protocol is a compressed transformation of
                 the X Window System protocol, designed to efficiently
                 implement X connections across relatively slow serial
                 lines. Using an Xremote simulator and 11 traces of X
                 sessions, we found that Xremote's overall compression
                 ratio is 2.4:1. This figure varies widely depending on
                 the trace. A study of compression ratio as a function
                 of message type shows text based messages commonly
                 achieving 3:1 compression, while geometric messages
                 usually achieve only 1.6:1 compression. By examining
                 bandwidth requirements and compression performance as a
                 function of time, we see that Xremote performs
                 adequately for some applications which are text based
                 or which use small geometric datasets, except at
                 application startup where more bandwidth is required.
                 Further work is required to adequately support the
                 initialization stage of X applications and medium to
                 large geometric databases.",
}


@TechReport{Danskin94a,
  author =       "John Danskin and Pat Hanrahan",
  title =        "Profiling the {X} Protocol",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-442-94",
  pages =        "19",
  month =        jan # " 5",
  year =         "1994",
  abstract =     "This paper describes a system for tracing the X Window
                 System Protocol. We have analyzed these traces by
                 breaking the protocol down into discrete instructions
                 or messages, and analyzing the frequency and network
                 resource requirements of these messages. This analysis
                 has resulted in preliminary results in 4 areas: the
                 relative importance of X messages, how X usage changes
                 during different application stages, differing
                 application idioms for accomplishing similar tasks, and
                 the size distributions of X messages and groups of X
                 messages. Some of these results have architectural
                 implications for network protocols and
                 implementations.",
}


@TechReport{Dikaiakos94,
  author =       "Marios D. Dikaiakos and Anne Rogers and Ken
                 Steiglitz",
  title =        "A Comparison Study of Heuristics for Mapping Parallel
                 Algorithms to Message-Passing Multiprocessors",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-446-94",
  pages =        "18",
  month =        feb,
  year =         "1994",
  abstract =     "This paper presents a comparison study of popular
                 clustering and mapping heuristics which are used to map
                 task-flow graphs to message-passing multiprocessors. To
                 this end, we use task-graphs which are representative
                 of important scientific algorithms running on data-sets
                 of practical interest. The annotation which assigns
                 weights to nodes and edges of the task-graphs is
                 realistic. It reflects current trends in processor,
                 communication channel, and message-passing interface
                 technology and takes into consideration hardware
                 characteristics of state-of-the-art multiprocessors.
                 Our experiments show that applying realistic models for
                 task-graph annotation affects the effectiveness and
                 functionality of clustering and mapping techniques.
                 Therefore, new heuristics are necessary that will take
                 into account more practical models of communication
                 costs. We present modifications to existing clustering
                 and mapping algorithms which improve their efficiency
                 and running-time for the practical models adopted.",
}


@TechReport{Appel94,
  author =       "Andrew W. Appel and Zhong Shao",
  title =        "An Empirical and Analytic Study of Stack vs. Heap Cost
                 for Languages with Closures",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-450-94",
  pages =        "12",
  month =        mar,
  year =         "1994",
  abstract =     "It has been proposed that allocating procedure
                 activation records on a garbage collected heap is more
                 efficient than stack allocation. However, previous
                 comparisons of heap vs. stack allocation have been
                 over-simplistic, neglecting (for example) frame
                 pointers, or the better locality of reference of
                 stacks.\par We present a comprehensive analysis of all
                 the components of creation, access, and disposal of
                 heap-allocated and stack-allocated activation records.
                 Among our results are:\par Although stack frames are
                 known to have a better cache read-miss rate than heap
                 frames, our simple analytical model (backed up by
                 simulation results) shows that the difference is too
                 trivial to matter.\par * The cache write-miss rate of
                 heap frames is very high; we show that a variety of
                 miss-handling strategies (exemplified by specific
                 modern machines) can give good performance, but not all
                 can.\par * The write-miss policy of the primary cache
                 is much more important than the write-miss policy of
                 the secondary cache.\par * Stacks restrict the
                 flexibility of closure representations (for
                 higher-order functions) in important (and costly) ways.
                 \par * The extra load placed on the garbage collector
                 by heap-allocated frames is very small.\par * The
                 demands of modern programming languages make stacks
                 quite complicated to implement efficiently and
                 correctly.\par Overall, the execution cost of
                 stack-allocated and heap-allocated frames is very
                 similar; but heap frames are simpler to implement and
                 allow very efficient first-class continuations
                 (call/cc).",
}


@TechReport{ML94,
  author =       "Separate Compilation for Standard ML",
  title =        "Andrew {W}. Appel and David {B}. MacQueen",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-452-94",
  pages =        "11",
  month =        mar,
  year =         "1994",
  abstract =     "Languages that support abstraction and modular
                 structure, such as Standard ML, Modula, Ada, and (more
                 or less) C++, may have deeply nested dependency
                 hierarchies among source files. In ML the problem is
                 particularly severe because ML's powerful parameterized
                 module (functor) facility entails dependencies among
                 implementation modules, not just among interfaces.\par
                 To efficiently compile individual modules in such
                 languages, it is useful (in ML, necessary) to infer,
                 digest, and cache the static environment resulting from
                 the compilation of each module.\par Our system provides
                 a simple model of compilation and linkage that supports
                 incremental recompilation (a restricted form of
                 separate compilation) with type-safe linkage. This
                 model is made available to user programs in the form of
                 a set of internal compiler modules, a feature that we
                 call the ``visible compiler.'' The chief client of this
                 interface is the IRM incremental recompilation manager
                 from CMU.",
}


@TechReport{Shao94,
  author =       "Zhong Shao and Andrew W. Appel",
  title =        "Space-Efficient Closure Representations",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-454-94",
  pages =        "14",
  month =        mar,
  year =         "1994",
  abstract =     "Many modern compilers implement function calls (or
                 returns) in two steps: first, a closure environment is
                 properly installed to provide access for free variables
                 in the target program fragment; second, the control is
                 transferred to the target by a ``jump with arguments
                 (or results).'' Closure conversion, which decides where
                 and how to represent closures at runtime, is a crucial
                 step in compilation of functional languages. We have a
                 new algorithm that exploits the use of compile-time
                 control and data flow information to optimize closure
                 representations. By extensive closure sharing and
                 allocating as many closures in registers as possible,
                 our new closure conversion algorithm reduces heap
                 allocation by 36\% and memory fetches for local/global
                 variables by 43\%; and improves the already-efficient
                 code generated by the Standard ML of New Jersey
                 compiler by about 17\% on a DECstation 5000. Moreover,
                 unlike most other approaches, our new closure
                 allocation scheme satisfies the strong ``safe for space
                 complexity'' rule, thus achieving good asymptotic space
                 usage.",
}


@TechReport{Damianakis94,
  author =       "Stefanos Damianakis and Kai Li and Anne Rogers",
  title =        "An Analysis of a Combined Hardware-software Mechanism
                 for Speculative Loads",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-455-94",
  pages =        "22",
  month =        apr,
  year =         "1994",
  abstract =     "This paper describes a simple hardware mechanism and
                 related compiler support for software-controlled
                 speculative loads. The compiler issues speculative load
                 instructions based on anticipated data references and
                 the ability of the memory system to hide memory latency
                 in high-performance processors. The architectural
                 support for such a mechanism is simple and minimal, yet
                 handles faults gracefully. We have simulated three
                 speculative load mechanisms based on a MIPS processor
                 and a detailed memory system. The results of scientific
                 kernel loops indicate that speculative load techniques
                 can hide memory latency effectively.",
}


@TechReport{Gortler94,
  author =       "Steven J. Gortler and Michael F. Cohen",
  title =        "Variational Modeling with Wavelets",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-456-94",
  pages =        "11",
  month =        apr,
  year =         "1994",
  abstract =     "In many geometric modeling paradigms the user sculpts
                 a curve or surface by dragging around some type of
                 control points (eg. Bezier or B-spline). A more
                 intuitive modeling interface allows the user to
                 directly manipulate curves and surfaces. This
                 manipulation defines some set of constraints that the
                 curve or surface must satisfy (such as interpolation
                 and tangent constraints). Direct manipulation, however,
                 usually leads to an underconstrained problem since
                 there are, in general, many possible surfaces meeting
                 some set of constraints. Finding the ``best'' solution
                 requires solving a variational problem. Unfortunately,
                 this can be costly to compute. In particular, iterative
                 descent methods converge slowly when a finite element
                 basis such as B-splines is used.\par This paper
                 discusses how geometric variational modeling problems
                 can be solved more efficiently by using a wavelet
                 basis. Because the wavelet basis is hierarchical, the
                 iterative methods converge rapidly. And because the
                 wavelet coefficients indicate the degree of detail in
                 the solution, they can be used to determine the number
                 of basis functions needed to express the variational
                 minimum, thus avoiding unnecessary computation. An
                 implementation is discussed and experimental results
                 are reported.",
}


@TechReport{Tomasic94,
  author =       "Anthony Slavko Tomasic",
  title =        "Distributed Queries and Incremental Updates in
                 Information Retrieval Systems",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-458-94",
  pages =        "157",
  month =        jun,
  year =         "1994",
  abstract =     "The proliferation of the world's ``information
                 highways'' has renewed interest in efficient document
                 indexing techniques. This thesis explores the
                 architecture of information retrieval systems for
                 querying and indexing documents. Distributed queries
                 are studied with analytical and trace-driven
                 simulations. We focus on physical index design,
                 inverted index caching, and database scaling in a
                 distributed system. All three issues influence response
                 time and throughput. Incremental updates of inverted
                 lists are studied using a new dual-structure index data
                 structure. This index structure separates long and
                 short inverted lists dynamically and optimizes the
                 retrieval, update, and storage of each type of list. To
                 study the behavior of the index, engineering trade-offs
                 are described that favor either update time or query
                 performance. We explore these trade-offs quantitatively
                 by using actual data and hardware and simulation to
                 determine the best algorithm under a variety of
                 criteria. Finally, implementation of our incremental
                 update algorithms is compared to an existing
                 information retrieval system.",
}


@TechReport{Appel94a,
  author =       "Andrew W. Appel",
  title =        "Loop Headers in Lambda-Calculus or {CPS}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-460-94",
  pages =        "8",
  month =        jun,
  year =         "1994",
  abstract =     "As is well known, the introduction of a ``loop
                 header'' block facilitates the hoisting of
                 loop-invariant code from a loop. But in a
                 \$$\backslash$lambda\$-calculus intermediate
                 representation, which has a notion of scope, this
                 transformation is particularly useful.\par Loop headers
                 with scope also solve an old problem with in-line
                 expansion of recursive functions or loops: if done
                 naively, only the first iteration is inlined. A loop
                 header can encapsulate the loop or recursion for better
                 in-line expansion.\par This optimization improves
                 performance by about 5$\backslash$\% in Standard ML of
                 New Jersey.",
}


@TechReport{Cao94,
  author =       "Pei Cao and Edward W. Felten and Kai Li",
  title =        "Implementation and Performance of
                 Application-Controlled File Caching",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-462-94",
  pages =        "11",
  month =        jun,
  year =         "1994",
  abstract =     "Traditional file systems do not allow applications to
                 control file caching replacement decisions. We have
                 implemented two-level replacement, a scheme that allows
                 applications to control their own cache replacement,
                 while letting the kernel control the allocation of
                 cache space among processes. We let applications choose
                 from a menu of common policies that are implemented in
                 the kernel. This is effective and requires low
                 overhead.\par We demonstrate that for applications with
                 large data sets, the combination of good
                 application-chosen replacement policies, and our kernel
                 allocation policy LRU-SP, can improve performance
                 significantly. We also show that LRU-SP is crucial to
                 the performance improvement for multiple concurrent
                 applications: LRU-SP fairly distributes cache blocks
                 and offers protection against foolish applications.",
}


@TechReport{Chandra94,
  author =       "Satish Chandra and James R. Larus and Anne Rogers",
  title =        "Where is Time Spent in Message-Passing and
                 Shared-Memory Programs?",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-463-94",
  pages =        "13",
  month =        jul,
  year =         "1994",
  abstract =     "Message passing and shared memory are two techniques
                 parallel programs use for coordination and
                 communication. This paper studies the strengths and
                 weaknesses of these two mechanisms by comparing
                 equivalent, well-written message-passing and
                 shared-memory programs running on similar hardware. To
                 ensure that our measurements are comparable, we
                 produced two carefully tuned versions of each program
                 and measured them on closely-related simulators of a
                 message-passing and a shared-memory machine, both of
                 which are based on same underlying hardware
                 assumptions.\par We examined the behavior and
                 performance of each program carefully. Although the
                 cost of computation in each pair of programs was
                 similar, synchronization and communication differed
                 greatly. We found that message-passing's advantage over
                 shared-memory is not clear-cut. Three of the four
                 shared-memory programs ran at roughly the same speed as
                 their message-passing equivalent, even though their
                 communication patterns were different.",
}


@TechReport{Falsafi94,
  author =       "Babak Falsafi and Ioannis Schoinas Alvin R. Lebeck and
                 Steven K. Reinhardt",
  title =        "Application-Specific Protocols for User-Level Shared
                 Memory",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-464-94",
  pages =        "10",
  month =        aug,
  year =         "1994",
  abstract =     "Mark D. Hill, James R. Larus, Anne Rogers, and David
                 A. Wood Recent distributed shared memory (DSM) systems
                 and proposed shared-memory machines have implemented
                 some or all of their cache coherence protocols in
                 software. One way to exploit the flexibility of this
                 software is to tailor a coherence protocol to match an
                 application's communication patterns and memory
                 semantics. This paper presents evidence that this
                 approach can lead to large performance improvements. It
                 shows that application-specific protocols substantially
                 improved the performance of three application
                 programs--appbt, em3d, and barnes--over carefully tuned
                 transparent shared memory implementations. The
                 speed-ups were obtained on Blizzard, a fine-grained DSM
                 system running on a 32-node Thinking Machines CM-5.",
}


@TechReport{Danskin94b,
  author =       "John M. Danskin",
  title =        "Compressing the {X} Graphics Protocol",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-465-94",
  pages =        "130",
  month =        nov,
  year =         "1994",
  abstract =     "This dissertation is about compressing networked
                 graphics for transmission across low bandwidth networks
                 like phone lines and wireless networks. It concentrates
                 on the X Window System Version 11 (X) because X is the
                 most widely available networked window system today.
                 The dissertation is divided into three main
                 sections:\par The first section describes a system for
                 tracing the X protocol, the traces gathered, and an
                 analysis of the results. The traces were analyzed by
                 breaking the protocol down into discrete instructions
                 or messages, and analyzing the frequency and network
                 resource requirements of these messages. This analysis
                 has resulted in preliminary results in 4 areas: the
                 relative importance of X messages, how X usage changes
                 during different application stages, differing
                 application idioms for accomplishing similar tasks, and
                 the size distributions of X messages and groups of X
                 messages. Some of these results have architectural
                 implications for network protocols and
                 implementations.\par The second section examines the
                 performance of the Xremote protocol, which was designed
                 as part of a product by Network Communications Devices
                 Inc. (NCD). The Xremote protocol is a compressed
                 transformation of the X Window System protocol,
                 designed to efficiently implement X connections across
                 relatively slow serial lines. Using an Xremote
                 simulator and 11 traces of X sessions, I found that
                 Xremote's overall compression ratio is 2.4:1.\par Text
                 based applications commonly see about 2.5:1
                 compression, geometric applications achieve about 1.7:1
                 compression and image based document previewers achieve
                 about 2.5:1.\par The third section introduces a new
                 technique for compressing structured data. Embodied in
                 the Higher Bandwidth X (HBX) protocol, this technique
                 results in 7.5:1 compression across the trace suite,
                 for about 3 times the performance of Xremote. HBX works
                 by parsing X messages into individual fields and
                 applying statistical modeling and arithmetic coding to
                 individual fields of X messages. HBX typically achieves
                 5:1 compression on geometric data, between 10:1 and
                 20:1 compression on image based document previewing,
                 and over 5:1 compression on text based
                 applications.\par It seems likely that the techniques
                 used in HBX will prove applicable to compressing
                 network headers, object code, RPC traffic and other
                 structured data.",
}


@TechReport{Boneh94,
  author =       "Dan Boneh and James Shaw",
  title =        "Collusion-Secure Fingerprinting for Digital Data",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-468-94",
  pages =        "31",
  month =        oct,
  year =         "1994",
  abstract =     "This paper discusses methods for assigning codewords
                 for the purpose of fingerprinting digital data (e.g.,
                 software, documents, and images). Fingerprinting
                 consists of uniquely marking and registering each copy
                 of the data. This marking allows a distributor to
                 detect any unauthorized copy and trace it back to the
                 user. This threat of detection will deter users from
                 releasing unauthorized copies.\par A problem arises
                 when users collude: For digital data, two different
                 fingerprinted objects can be compared and the
                 differences between them detected. Hence, a set of
                 users can collude to detect the location of the
                 fingerprint. They can then alter the fingerprint to
                 mask their identities. We present a general
                 fingerprinting solution which is secure in the context
                 of collusion. In addition, we discuss methods for
                 distributing fingerprinted data.",
}


@TechReport{Ramsey94,
  author =       "Norman Ramsey and Mary Fernandez",
  title =        "New Jersey Machine-Code Toolkit Architecture
                 Specifications",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-470-94",
  pages =        "57",
  month =        oct,
  year =         "1994",
  abstract =     "The New Jersey Machine-Code Toolkit helps programmers
                 write applications that process machine
                 code---assemblers, disassemblers, code generators,
                 tracers, profilers, and debuggers. The toolkit lets
                 programmers encode and decode machine instructions
                 symbolically. It transforms symbolic manipulations into
                 bit manipulations, guided by a specification that
                 defines mappings between symbolic and binary
                 representations of instructions. This document presents
                 our annotated specifications for the MIPS R3000, SPARC,
                 and Intel 486 instruction sets. For an overview of the
                 toolkit, read [ramsey:jersey] first. The reference
                 manual for the toolkit [ramsey:tk-reference] gives a
                 complete description of the specification language used
                 here.",
}


@TechReport{Ramsey94a,
  author =       "Norman Ramsey and Mary Fernandez",
  title =        "New Jersey Machine-Code Toolkit Reference Manual
                 Version 0.1",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-471-94",
  pages =        "57",
  month =        oct,
  year =         "1994",
  abstract =     "This document contains the reference manual for
                 version 0.1 of the New Jersey Machine-Code toolkit. It
                 is not intended to explain what is going on; for an
                 overview of the toolkit, see [ramsey:jersey]. For
                 extended examples describing real machines, see
                 [ramsey:tk-architecture]. This document goes into the
                 nooks and crannies of the toolkit and describes what
                 lurks there. This is the place to find out the whole
                 truth about the toolkit's specification language, as
                 well as get a description of its myriad command-line
                 options.",
}


@TechReport{Yianilos94,
  author =       "Peter N. Yianilos and Eric Sven Ristad",
  title =        "Probability Value Library",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-472-94",
  pages =        "40",
  month =        oct,
  year =         "1994",
  abstract =     "Hidden Markov models (HMMs) and other time series
                 models assign probabilities to long sequences of
                 events. Avoiding underflow is arguably the central
                 difficulty in calculating the probability of such
                 sequences. This technical report presents an elegant
                 and efficient C library for representing and
                 manipulating probability values without underflow. Use
                 of the library results in simpler code whose execution
                 time compares favorably with traditional numerical
                 methods. Thus, the library provides a strong foundation
                 on which to build large scale stochastic modeling
                 systems. Our abstraction suggests a natural extension
                 of the IEEE floating point standard, to better support
                 statistical computation.",
}


@TechReport{Gortler95,
  author =       "Steven J. Gortler",
  title =        "Wavelet Methods for Computer Graphics",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-273-94",
  pages =        "183",
  month =        jan,
  year =         "1995",
  abstract =     "This thesis discusses how a wavelet basis can be used
                 in the context of two computer graphics applications,
                 realistic rendering and geometric modeling, to produced
                 more efficient and flexible algorithms.\par The goal of
                 realistic rendering is to simulate the interreflection
                 of light in some geometric environment in order to
                 produce realistic images. Radiosity is a commonly used
                 solution method for this problem. Recently Hanrahan et
                 al. have introduced a hierarchical method that can
                 solve radiosity problems in \$O(n)\$ time instead of
                 \$O(n\^{}2)\$. This thesis explores how the
                 hierarchical radiosity algorithm can be formally
                 understood from the context of wavelet theory. When the
                 radiosity problem is expressed with respect to a
                 wavelet basis, the resulting linear system is sparse,
                 with only \$O(n)\$ significant terms. By casting the
                 hierarchical method in this framework, a variety of
                 wavelet basis functions can be used, resulting in more
                 efficient radiosity methods.\par This thesis also
                 discusses how wavelets can be used in the context of
                 geometric modeling. Geometric modeling is the study of
                 how geometric shapes can be represented and manipulated
                 by a designer. This thesis explores the use of wavelets
                 to represent parametric curves and surfaces within the
                 context of geometric modeling interfaces.\par One
                 intuitive modeling interface commonly used in geometric
                 modeling allows the user to directly manipulate curves
                 and surfaces. This manipulation defines some set of
                 constraints that the curve or surface must satisfy
                 (such as interpolation and tangent constraints). Direct
                 manipulation, however, usually leads to an
                 underconstrained problem since there are, in general,
                 many possible surfaces meeting some set of constraints.
                 Therefore an optimization problem must be solved.\par
                 This thesis discusses how geometric modeling
                 optimization problems can be solved more efficiently by
                 using a wavelet basis. Because the wavelet basis is
                 hierarchical, iterative optimization methods converge
                 rapidly. And because the wavelet coefficients indicate
                 the degree of detail in the solution, they can be used
                 to determine the number of basis functions needed to
                 express the variational minimum, thus avoiding
                 unnecessary computation. An implementation is discussed
                 and experimental results are reported.",
}


@TechReport{Appel94b,
  author =       "Andrew W. Appel and Trevor Jim",
  title =        "Making Lambda Calculus Smaller, Faster",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-477-94",
  pages =        "9",
  month =        nov,
  year =         "1994",
  abstract =     "Some optimizations are speculative: they improve
                 execution speed most but not all of the time, or they
                 trade off faster execution for an increase in code
                 size. Other optimizations, such as dead-variable
                 elimination and algebraic simplification, are
                 guaranteed to both reduce code size and speed
                 execution. It makes sense to group all of these
                 ``contracting'' optimizations together in a single
                 phase of a compiler. This paper describes an efficient
                 implementation of these optimizations for a language
                 based on the lambda calculus, where a particularly
                 interesting optimization of this sort is inlining for
                 those functions called only once. And we prove that our
                 contracting rewrites are confluent.",
}


@TechReport{Squier94,
  author =       "Richard K. Squier and Ken Steiglitz",
  title =        "Programmable Parallel Arithmetic in Cellular Automata
                 Using a Particle Model",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-478-94",
  pages =        "14",
  month =        dec,
  year =         "1994",
  abstract =     "In this paper we show how to embed practical
                 computation in one-dimensional cellular automata using
                 a model of computation based on collisions of moving
                 particles. The cellular automata have small
                 neighborhoods, and state spaces which are binary
                 occupancy vectors. They can be fabricated in VLSI, and
                 perhaps also in bulk media which support appropriate
                 particle propagation and collisions. The model uses
                 injected particles to represent both data and
                 processors. Consequently, realizations are highly
                 programmable, and do not have application-specific
                 topology, in contrast with systolic arrays. We describe
                 several practical calculations which can be carried out
                 in a highly parallel way in a single cellular
                 automaton, including addition, subtraction,
                 multiplication, arbitrarily nested combinations of
                 these operations, and finite- impulse-response digital
                 filtering of a signal arriving in a continuous stream.
                 These are all accomplished in time linear in the number
                 of input bits, and with fixed-point arithmetic of
                 arbitrary precision, independent of the hardware.",
}


@TechReport{Goncalves94,
  author =       "Marcelo J. R. Goncalves and Andrew W. Appel",
  title =        "Cache Performance of Fast-Allocating Programs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-482-94",
  pages =        "12",
  month =        dec,
  year =         "1994",
  abstract =     "We study the cache performance of a set of ML
                 programs, compiled by the Standard ML of New Jersey
                 compiler. We find that more than half of the reads are
                 for objects that have just been allocated. We also
                 consider the effects of varying software (garbage
                 collection frequency) and hardware (cache) parameters.
                 Confirming results of related experiments, we found
                 that ML programs can have good cache performance when
                 there is no penalty for allocation. Even on caches that
                 have an allocation penalty, we found that ML programs
                 can have lower miss ratios than the C and Fortran
                 SPEC92 benchmarks.\par Topics: 4 benchmarks,
                 performance analysis; 21 hardware design, measurements;
                 17 garbage collection, storage allocation; 46 runtime
                 systems.",
}


@TechReport{Carlisle95,
  author =       "Martin C. Carlisle and Anne Rogers",
  title =        "Software Caching and Computation Migration in Olden",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-483-95",
  pages =        "15",
  month =        jan,
  year =         "1995",
  abstract =     "The goal of the Olden project is to build a system
                 that provides parallelism for general purpose C
                 programs with minimal programmer annotations. We focus
                 on programs using dynamic structures such as trees,
                 lists, and DAGs. We demonstrate that providing both
                 software caching and computation migration can improve
                 the performance of these programs, and provide a
                 compile-time heuristic that selects between them for
                 each pointer dereference. We have implemented a
                 prototype system on the Thinking Machines CM-5. We
                 describe our implementation and report on experiments
                 with ten benchmarks.",
}


@TechReport{Machine95,
  author =       "Particle Machine",
  title =        "General Parallel Computation without {CPU}s: {VLSI}
                 Realization of a",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-484-95",
  pages =        "18",
  month =        feb,
  year =         "1995",
  abstract =     "Richard K. Squier, Ken Steiglitz, Mariusz H.
                 Jakubowski We describe an approach to parallel
                 computation using particle propagation and collisions
                 in a one-dimensional cellular automaton using a
                 particle model -- a Particle Machine (PM). Such a
                 machine has the parallelism, structural regularity, and
                 local connectivity of systolic arrays, but is general
                 and programmable. It contains no explicit multipliers,
                 adders, or other fixed arithmetic operations; these are
                 implemented using fine-grain interactions of logical
                 particles which are injected into the medium of the
                 cellular automaton, and which represent both data and
                 processors. We sketch a VLSI implementation of a PM,
                 and estimate its speed and size. We next discuss the
                 problem of determining whether a rule set for a PM is
                 free of conflicts. In general, the question is
                 undecidable, but enough side information is usually
                 available in practice to answer the question in
                 polynomial time. We then show how to implement division
                 in time linear in the number of significant bits of the
                 result, using an algorithm of Leighton. This
                 complements similar previous results for fixed-point
                 addition/subtraction and multiplication. The precision
                 of the arithmetic is arbitrary, being determined by the
                 particle groups used as input.",
}


@TechReport{Gershbein95,
  author =       "Reid Gershbein",
  title =        "An Adaptive Gauss Method for Computing Irradiance
                 Coefficients of Galerkin Radiosity Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-485-95",
  pages =        "10",
  month =        feb,
  year =         "1995",
  abstract =     "Computing energy transfer between objects is the most
                 expensive operation in radiosity systems. This energy
                 transfer operation, known as the irradiance operator,
                 is an integral that, in general, must be calculated
                 numerically. We wish to increase the speed of this
                 computation without severely compromising fidelity and
                 perform a study of numerical integration techniques,
                 \$Quadrature\$ \$Methods\$. The results of our study
                 show the strengths of \$Gauss\$ \$Quadrature\$
                 \$Rules\$ and give us insights into greatly reducing
                 the cost of the irradiance operator while maintaining
                 accuracy. An adaptive method for choosing Gauss
                 quadrature rules is presented, and our performance
                 analysis of the new adaptive algorithm shows that it
                 can be up to 10 times faster than previous methods.",
}


@TechReport{Ristad95,
  author =       "Eric Sven Ristad and Robert G. Thomas",
  title =        "Nonmonotonic Multicontext Models",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-486-95",
  pages =        "25",
  month =        feb,
  year =         "1995",
  abstract =     "We introduce three new techniques for statistical
                 language models: multicontextual modeling, nonmonotonic
                 contexts, and the divergence heuristic. Together these
                 techniques result in language models that have few
                 states, even fewer parameters, and low message
                 entropies. For example, our techniques achieve a
                 message entropy of 1.97 bits/char on the Brown corpus
                 using only 94352 parameters. By modestly increasing the
                 number of model parameters in a principled manner, our
                 techniques are able to further reduce the message
                 entropy of the Brown Corpus to 1.92 bits/char. In
                 contrast, the character quadgram model requires more
                 than 236 times as many parameters in order to achieve a
                 message entropy of only 2.59 bits/char. Given the
                 logarithmic nature of codelengths, a savings of 0.62
                 bits/char is quite significant.",
}


@TechReport{Shao95,
  author =       "Zhong Shao and Andrew W. Appel",
  title =        "A Type-Based Compiler for Standard {ML}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-487-95",
  pages =        "14",
  month =        mar,
  year =         "1995",
  abstract =     "Compile-time type information should be valuable in
                 efficient compilation of statically typed functional
                 languages such as Standard ML. But how should
                 type-directed compilation work in real compilers, and
                 how much performance gain will type-based optimizations
                 yield? In order to support more efficient data
                 representations and gain more experience about
                 type-directed compilation, we have implemented a new
                 type-based middle end and back end for the Standard ML
                 of New Jersey compiler. We describe the basic design of
                 the new compiler, identify a number of practical
                 issues, and then compare the performance of our new
                 compiler with the old non-type-based compiler. Our
                 measurement shows that a combination of several simple
                 type-based optimizations reduces heap allocation by
                 36$\backslash$\%; and improves the already-efficient
                 code generated by the old non-type-based compiler by
                 about 19$\backslash$\% on a DECstation 5000.",
}


@TechReport{Mukherjee95,
  author =       "Shubhendu S. Mukherjee and Shamik D. Sharma and Mark
                 D. Hill and James R. Larus and Anne Rogers and Joel
                 Saltz",
  title =        "Efficient Support for Irregular Applications on
                 Distributed--Memory Machines",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-488-95",
  pages =        "12",
  month =        apr,
  year =         "1995",
  abstract =     "Irregular computation problems underlie many important
                 scientific applications. Although these problems are
                 computationally expensive, and so would seem
                 appropriate for parallel machines, their irregular and
                 unpredictable run-time behavior makes this type of
                 parallel program difficult to write and adversely
                 affects run-time performance.\par This paper explores
                 three issues---partitioning, mutual exclusion, and data
                 transfer---crucial to the efficient execution of
                 irregular problems on distributed-memory machines.
                 Unlike previous work, we studied the same programs
                 running in three alternative systems on the same
                 hardware base (a Thinking Machines CM-5): the CHAOS
                 irregular application library, Transparent Shared
                 Memory (TSM), and eXtensible Shared Memory (XSM). CHAOS
                 and XSM performed equivalently for all three
                 applications. Both systems were somewhat
                 (13$\backslash$\%) to significantly faster
                 (991$\backslash$\%) than TSM.",
}


@TechReport{Boneh95,
  author =       "Christopher Dunworth Dan Boneh and Richard J. Lipton",
  title =        "Breaking {DES} Using a Molecular Computer",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-489-95",
  pages =        "20",
  month =        may,
  year =         "1995",
  abstract =     "Recently Adleman has shown that a small traveling
                 salesman problem can be solved by molecular operations.
                 In this paper we show how the same principles can be
                 applied to breaking the Data Encryption Standard (DES).
                 Our method is based on an encoding technique presented
                 in Lipton. We describe in detail a library of
                 operations which are useful when working with a
                 molecular computer. We estimate that given one
                 arbitrary (plain-text, cipher-text) pair, one can
                 recover the DES key in about 4 months of work.
                 Furthermore, if one is given cipher-text, but the plain
                 text is only known to be one of several candidates then
                 it is still possible to recover the key in about 4
                 months of work. Finally, under chosen cipher-text
                 attack it is possible to recover the DES key in one day
                 using some preprocessing.",
}


@TechReport{Fernandez95,
  author =       "Mary Fernandez",
  title =        "The Implementation of mlcc and mld: {A}
                 Machine-Independent Compiler and {A} Retargetable,
                 Optimizing Linker",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-490-95",
  pages =        "500",
  month =        may,
  year =         "1995",
  abstract =     "This document includes the implementation of mlcc, a
                 machine-independent compiler, and mld, a retargetable,
                 optimizing linker. mld is designed to reduce the
                 runtime costs of encapsulation features in
                 object-oriented languages by delaying optimization
                 until link time. The motivation for link-time
                 optimization, a description of mld's optimization
                 techniques, and the results of applying mld's
                 techniques to Modula--3 programs are described in a
                 technical paper and thesis. The document contains
                 interleaved sections of documentation and the program's
                 source code. The source and documentation are extracted
                 and written into files for compilation or for
                 formatting using the noweb literate programming
                 system.",
}


@TechReport{Boneh95a,
  author =       "Dan Boneh and Richard J. Lipton",
  title =        "Making {DNA} Computers Error Resistant",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-491-95",
  pages =        "500",
  year =         "1995",
  abstract =     "Recently Lipton showed that the formula satisfaction
                 problem can be solved using a DNA based computer. The
                 algorithm ignored the effects of errors that occur
                 during biological experiments. In this paper we show
                 that Lipton's algorithm can be made resistant to
                 errors. In addition, we present a new circuit
                 satisfaction algorithm which can be made error
                 resistant using the same techniques. (May 1995, 9
                 pages)",
}


@TechReport{Appel95,
  author =       "Andrew W. Appel",
  title =        "How to Edit a Journal by {E}-mail",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-494-95",
  pages =        "12",
  month =        jul,
  year =         "1995",
  abstract =     "The editor of a refereed scientific journal must
                 somehow get unpaid referees and unpaid associate
                 editors to provide prompt evaluations of technical
                 papers. The use of electronic mail, with a well
                 organized management system---and the software and
                 staff to support it---make this possible, without
                 unduly burdening either the editor, associate editors,
                 or referees.",
}


@TechReport{Ristad95a,
  author =       "Eric Sven Ristad",
  title =        "A Natural Law of Succession",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-495-95",
  pages =        "22",
  month =        jul,
  year =         "1995",
  abstract =     "Consider the following problem. You are given an
                 alphabet of \$k\$ distinct symbols and are told that
                 the i-th symbol occurred exactly n\_i times in the
                 past. On the basis of this information alone, you must
                 now estimate the conditional probability that the next
                 symbol will be i. In this report, we present a new
                 solution to this fundamental problem in statistics and
                 inductive reasoning. Our solution overcomes all
                 practical difficulties encountered by standard
                 approaches without requiring any special prior
                 knowledge.",
}


@TechReport{Components95,
  author =       "Scheduling In Distributed Soft Real-Time Systems With
                 Autonomous Components",
  title =        "Benjamin Chi-Ming Kao (Thesis)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-496-95",
  pages =        "22",
  year =         "July 1995, 156 Pages",
  abstract =     "Traditional real-time systems are usually used by very
                 specific, mission-critical applications, such as a
                 nuclear reactor monitor. For these applications task
                 deadlines must not be missed. However, with the
                 advances of computer and communication technology, and
                 as computers become a commonplace utility, more
                 applications are requiring a casual use of real-time
                 technology. Task deadlines in these applications are
                 soft in the sense that missing a deadline occasionally
                 is, although undesirable, not a disaster. Example soft
                 real-time applications include 800-number translation,
                 cellular telecommunication, financial databases,
                 patient-monitoring systems and so on. In these
                 applications, deadlines are used as a tool to express
                 performance goals. For example, a buy-sell action
                 triggered by a stock-price update in a financial
                 database system should be implemented within a
                 specified period of time due to the volatility of the
                 market. To conserve resources, soft real-time systems
                 are usually not designed to guarantee every single
                 deadline. Instead, the performance of a system is
                 generally measured as the percentage of deadlines it
                 meets. Deadline driven heuristic scheduling thus plays
                 a major role in the design of soft real-time
                 systems.\par This thesis studies the scheduling aspect
                 of distributed soft real-time systems. In particular,
                 it addresses the following cost-performance tradeoff.
                 When designing a distributed real-time system, one
                 approach is to build it from scratch, coding each
                 component with algorithms and features that match the
                 applications' needs. However, the development and
                 maintenance cost of such a system would be high, and
                 the development cycle could be long. Alternatively, one
                 can build the system by piecing together well-tested,
                 easy-to-maintain standard components, such as a
                 commercial database server, a token ring network, etc.
                 The disadvantage of this approach is that global
                 real-time scheduling is not possible because it demands
                 cooperation and coordination among the individual local
                 schedulers. In this thesis, we discuss different
                 scheduling techniques in a distributed soft real-time
                 system that is constructed out of a variety of existing
                 conventional non-real-time and real-time components,
                 and show how these techniques improve the real-time
                 performance of such a system without requiring the
                 components to sacrifice autonomy. These techniques
                 include subtask deadline assignment, server
                 prioritization, and real-time emulation.",
}


@TechReport{Ristad95b,
  author =       "Eric Sven Ristad",
  title =        "Effect of speed on handwriting shape: a descriptive
                 generalization.",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-497-95",
  pages =        "22",
  year =         "August 1995, 11 Pages",
  abstract =     "In this report, we characterize the natural
                 simplifying transformations of a handwritten curve. We
                 argue that the number and type of singularities in a
                 geometric curve determine the amount of time required
                 for the human handwriting system to produce that curve
                 to a given level of accuracy. Therefore, the behavior
                 of the human handwriting system under increasing time
                 pressure may be characterized by a set of stochastic
                 transformations that replace costly curve segments with
                 less costly segments, or remove segments entirely.",
}


@TechReport{George95,
  author =       "Lal George and Andrew W. Appel",
  title =        "Iterated Register Coalescing",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-498-95",
  pages =        "22",
  year =         "August 1995, 27 Pages",
  abstract =     "An important function of any register allocator is to
                 target registers so as to eliminate copy instructions.
                 Graph-coloring register allocation is an elegant
                 approach to this problem. If the source and destination
                 of a move instruction do not interfere, then their
                 nodes can be coalesced in the interference graph.
                 Chaitin's coalescing heuristic could make a graph
                 uncolorable (i.e., introduce spills); Briggs et al.
                 demonstrated a conservative coalescing heuristic that
                 preserves colorability. But Briggs's algorithm is too
                 conservative, and leaves too many move instructions in
                 our programs. We show how to interleave coloring
                 reductions with Briggs's coalescing heuristic, leading
                 to an algorithm that is safe but much more
                 aggressive.",
}


@TechReport{Boneh95b,
  author =       "Richard Lipton Dan Boneh and Christopher Dunworth and
                 Jiri Sgall",
  title =        "On The Computational Power of {DNA}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-499-95",
  pages =        "22",
  year =         "October 1995, 14 Pages",
  abstract =     "We show how DNA based computers can be used to solve
                 the satisfiability problem for boolean circuits.
                 Furthermore, we show how DNA computers can solve
                 optimization problems directly without first solving
                 several decision problems. Our methods also enable
                 random sampling of satisfying assignments. Finally we
                 suggest a procedure for evaluating functions in the
                 polynomial hierarchy.",
}


@TechReport{Hanson95,
  author =       "David R. Hanson and Mukund Raghavachari",
  title =        "A Machine-Independent Debugger",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-500-95",
  pages =        "22",
  year =         "November 1995, 24 Pages",
  abstract =     "cdb is a simple, source-level debugger for ANSI C
                 programs compiled by lcc, a retargetable C compiler.
                 cdb is completely independent of its target
                 architecture. This independence is achieved by
                 embedding a small amount of itself -- a `nub' -- in the
                 program to be debugged and by having the compiler emit
                 machine-independent symbol-table data and related code.
                 This paper describes the design of a nub interface for
                 debugging, the target-independent implementation of
                 this interface for cdb, and the implementation of cdb
                 itself. When compared to platform-specific debuggers,
                 cdb's implementation is minuscule: the nub, debugger,
                 and associated communications routines take about 1500
                 lines of C, and fewer than 600 lines were added to
                 lcc's front end to emit symbol tables and breakpoint
                 hooks. All this code is machine independent.",
}


@TechReport{Dean95,
  author =       "Drew Dean and Dan S. Wallach",
  title =        "Security Flaws in the HotJava Web Browser",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-501-95",
  pages =        "22",
  year =         "November 1995, 8 Pages",
  abstract =     "The growth of the Internet and the World Wide Web has
                 led to demand for Web extensions, such as the ability
                 to run server-supplied code on a Web client. We examine
                 the HotJava Web browser and the Java language in which
                 it is implemented. We demonstrate several attacks that
                 compromise HotJava's security. Some of these attacks
                 are made possible through browser code that fails to
                 enforce access permissions, but can be easily fixed.
                 Others point to underlying tension between the openness
                 desired by Web application writers and the security
                 desired by their users. We discuss the interaction of
                 application requirements and security needs and suggest
                 how they can both be accommodated. For more information
                 please see http://www.cs.princeton.edu/\~{}ddean/java",
}


@TechReport{Tarjan95,
  author =       "Robert E. Tarjan",
  title =        "Dynamic Trees as Search Trees via Euler Tours, Applied
                 to the Network Simplex Algorithm",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-503-95",
  pages =        "22",
  year =         "December 1995, 10 Pages",
  abstract =     "The dynamic tree is an abstract data type that allows
                 the maintenance of a collection of trees subject to
                 joining by adding edges (linking) and splitting by
                 deleting edges (cutting), while at the same time
                 allowing reporting of certain combinations of vertex or
                 edge values. For many applications of dynamic trees,
                 values must be combined along paths. For other
                 applications, values must be combined over entire
                 trees. For the latter situation, we show that an idea
                 used originally in parallel graph algorithms, to
                 represent trees by Euler tours, leads to a simple
                 implementation with a time of O(log n) per tree
                 operation, where n is the number of tree vertices. We
                 apply this representation to the implementation of two
                 versions of the network simplex algorithm, resulting in
                 a time of O(log n) per pivot, where n is the number of
                 vertices in the problem network.",
}


@TechReport{Arora95,
  author =       "Sanjeev Arora and Carsten Lund",
  title =        "Hardness of Approximations",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-504-95",
  pages =        "22",
  year =         "December 1995, 54 Pages",
  abstract =     "Many recent results show that computing approximate
                 solutions to many NP-hard optimization problems is
                 itself NP-hard. This chapter is a self-contained survey
                 of such inapproximability results. It also presents an
                 easy-to-understand framework for proving new
                 inapproxibility results.\par (to appear as a chapter in
                 the book {"}Approximation Algorithms for NP-hard
                 problems,{"} editor Dorit Hochbaum)",
}


@TechReport{Appel95a,
  author =       "Andrew W. Appel",
  title =        "Intensional Equality ;=) for Continuations",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-557-95",
  pages =        "22",
  year =         "September 1995; 3 Pages",
  abstract =     "I propose a novel language feature, $<$i$>$intensional
                 continuation equality$<$/i$>$, useful in languages with
                 or without first-class continuations, and show how it
                 enables $<$i$>$truly remarkable gains in
                 efficiency$<$/i$>$ of ordinary user programs.\par
                 Continuations, expressing ``what the program will do
                 from now on,'' are a much-used tool of semantics, and
                 sometimes show up as a user-accessible programming
                 feature. But most use of continuations is $<$i$>$
                 parametric$<$/i$>$, in the sense that functions behave
                 the same way independent of their continuation. I will
                 show that nonparametric use of continuations allows
                 very substantial, almost incredible gains in program
                 speed. Furthermore, this technique is compatible with
                 almost any style of programming language; imperative,
                 functional, even object-oriented.",
}


@TechReport{Tal95,
  author =       "Ayellet Tal and David Dobkin",
  title =        "Visualization of Geometric Algorithms",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-559-95",
  pages =        "22",
  year =         "February 1995; 16 Pages",
  abstract =     "This paper investigates the visualization of geometric
                 algorithms. We discuss how limiting the domain makes it
                 possible to create a system that enables others to use
                 it easily. Knowledge about the domain can be very
                 helpful in building a system which automates large
                 parts of the user's task. A system can be designed to
                 isolate the user from any concern about how graphics is
                 done. The application need only specify ``what''
                 happens and need not be concerned with ``how'' to make
                 it happen on the screen. We develop a conceptual model
                 and a framework for experimenting with it. We also
                 present a system, GASP, which implements this model.
                 GASP allows quick generation of three-dimensional
                 geometric algorithm visualizations, even for highly
                 complex algorithms. It also provides a visual debugging
                 facility for geometric computing. We show the utility
                 of GASP by presenting a variety of examples.",
}


@TechReport{Dobkin95,
  author =       "Wolfgang Maass David P. Dobkin and Dimitrios
                 Gunopulos",
  title =        "Computing the Maximum Bichromatic Discrepancy with
                 Applications to Computer Graphics and Machine
                 Learning",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-562-95",
  pages =        "22",
  year =         "December 1995; 37 Pages",
  abstract =     "Computing the maximum bichromatic discrepancy is an
                 interesting theoretical problem with important
                 applications in computational learning theory,
                 computational geometry and computer graphics. In this
                 paper we give algorithms to compute the maximum
                 bichromatic discrepancy for simple geometric ranges,
                 including rectangles and halfspaces. In addition, we
                 give extensions to other discrepancy problems.",
}


@TechReport{Chazelle95,
  author =       "Bernard Chazelle and David P. Dobkin and Nadia
                 Shouraboura and Ayellet Tal",
  title =        "Strategies for Polyhedral Surface Decomposition: An
                 Experimental Study",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-564-95",
  pages =        "22",
  year =         "1995",
  abstract =     "(December 1995; 17 Pages)",
}


@TechReport{Barber95,
  author =       "C. Bradford Barber and David P. Dobkin and Hannu
                 Huhdanpaa",
  title =        "The Quickhull Algorithm for Convex Hulls",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-565-95",
  pages =        "22",
  year =         "January 1995; 15 Pages",
  abstract =     "The convex hull of a set of points is the smallest
                 convex set that contains the points. This paper
                 presents a practical convex hull algorithm that
                 combines the two-dimensional Quickhull Algorithm with
                 the general dimension Beneath-Beyond Algorithm. It is
                 similar to the randomized, incremental algorithms for
                 convex hull and Delaunay triangulation. We provide
                 empirical evidence that the algorithm runs faster when
                 the input contains nonextreme points, and that it uses
                 less memory.\par Computational geometry algorithms have
                 traditionally assumed that input sets are well behaved.
                 When an algorithm is implemented with floating point
                 arithmetic, this assumption can lead to serious errors.
                 We briefly describe a solution to this problem when
                 computing the convex hull in two, three, or four
                 dimensions. The output is a set of ``thick'' facets
                 that contain all possible exact convex hulls of the
                 input. A variation is effective in five or more
                 dimensions.",
}


@TechReport{Blumrich95,
  author =       "Matthias A. Blumrich and Cezary Dubnicki and Edward W.
                 Felten and Kai Li",
  title =        "Protected, User-level {DMA} for the {SHRIMP} Network
                 Interface",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-572-95",
  pages =        "22",
  year =         "December 1995; 12 Pages",
  abstract =     "Traditional DMA requires the operating system to
                 perform many tasks to initiate a transfer, with
                 overhead on the order of hundreds or thousands of CPU
                 instructions. This paper describes a mechanism, called
                 User-level Direct Memory Access (UDMA), for initiating
                 DMA transfers of input/output data, with full
                 protection, at a cost of only two user-level memory
                 references. The UDMA mechanism uses existing virtual
                 memory translation hardware to perform permission
                 checking and address translation without kernel
                 involvement. The implementation of the UDMA mechanism
                 is simple, requiring a small extension to the
                 traditional DMA controller and minimal operating system
                 kernel support. The mechanism can be used with a wide
                 variety of I/O devices including a network interfaces,
                 data storage devices such as disks and tape drives, and
                 memory-mapped devices such as graphics frame-buffers.
                 As an illustration, we describe how we used UDMA in
                 building a network interface hardware for the SHRIMP
                 multicomputer.",
}


@TechReport{Raghavachari96,
  author =       "Mukund Raghavachari and Anne Rogers",
  title =        "A Study of the Effects of Ordering, Partitioning and
                 Factorization Algorithms on Distributed Sparse Cholesky
                 Factorization",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-505-96",
  pages =        "22",
  month =        "17 Pages, " # jan,
  year =         "1996",
  abstract =     "In this paper, we perform a comprehensive evaluation
                 of ordering, partitioning, and factorization algorithms
                 under a unified framework. Previous research in
                 distributed, sparse Cholesky factorization has
                 considered each of the stages in the factorization
                 process --- ordering, partitioning and numerical
                 factorization --- in isolation. However, due to the
                 strong dependencies between the stages, it is difficult
                 to derive conclusions from such an approach.\par
                 Specifically, in our experiments, we use input files
                 representative of practical problems to study the
                 benefits and shortcomings of ordering algorithms ---
                 multiple minimum degree and spectral nested dissection,
                 column-based partitioning algorithms --- wrapped
                 mapping and proportional mapping, and block-based
                 partitioning. We use, as the base for our experiments,
                 three factorization algorithms: Fanin, Fanout and Block
                 Fanout. In addition, we extend the research of
                 Rothbergq by performing an in-depth analysis of the
                 advantages of panel-based partitionings versus
                 column-based partitionings on message-passing machines.
                 All experiments were run on a Thinking Machines CM-5.",
}


@TechReport{Raghavachari96a,
  author =       "Mukund Raghavachari and Anne Rogers",
  title =        "Understanding Language Support for Irregular
                 Parallelism",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-506-96",
  pages =        "22",
  month =        "16 Page, " # jan,
  year =         "1996",
  abstract =     "While software support for array-based, data-parallel
                 algorithms has been studied extensively, less attention
                 has been devoted to irregular parallel applications.
                 The majority of these applications are unstructured,
                 that is, they possess asynchronous components that do
                 not fit the data-parallel model. Examples of
                 unstructured applications include sparse matrix and
                 n-body problems. Previous research, such as Parti and
                 CHAOS, has concentrated on extending the array-based
                 data-parallel model to handle structured irregular
                 algorithms. For unstructured irregular applications,
                 however, the appropriate language abstractions,
                 compiler technology, and runtime techniques have yet to
                 be discovered.\par In this paper, we analyze, under a
                 systematic framework, implementations of a
                 representative set of algorithms--- Blocked Sparse
                 Cholesky, Barnes-Hut, and EMD3 --- on Tempest/Blizzard,
                 a platform that supports both shared memory and message
                 passing. Using our framework and corroborating
                 experiments, we isolate a set of abstractions that
                 allows easy and efficient expression of our benchmarks.
                 The philosophy behind this set is to provide, for each
                 component of a parallel language, mechanisms that
                 support user control, along with good default behavior.
                 Our contributions are the following: a framework for
                 the evaluation of abstractions, a set of
                 recommendations for language support for irregular
                 applications, and an analysis of the ability of current
                 languages to support them.",
}


@TechReport{Alpert96,
  author =       "Richard Alpert and Cezary Dubnicki and Edward W.
                 Felten and Kai Li",
  title =        "Design and Implementation of {NX} Message Passing
                 Using {SHRIMP} Virtual Memory Mapped Communication",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-507-96",
  pages =        "22",
  year =         "January 1996, 11 Pages",
  abstract =     "This paper describes the design, implementation and
                 performance of the NX message-passing interface on the
                 SHRIMP multicomputer. Our implementation exploits
                 SHRIMP's virtual memory-mapped communication facility.
                 Unlike traditional methods, our implementation performs
                 buffer management at user level without using a special
                 message-passing processor, and requires no CPU
                 intervention upon message arrival in the common cases.
                 For a four-byte message, our implementation achieves a
                 user-to-user latency of 12 microseconds which is about
                 factor of four smaller than that on the Intel Paragon.
                 For large messages, our implementation quickly
                 approaches the bandwidth limit imposed by the SHRIMP
                 hardware.",
}


@TechReport{Fang96,
  author =       "Wenjia Fang and Edward W. Felten and Margaret
                 Martonosi",
  title =        "Contention and Queueing in an Experimental
                 Multicomputer: Analytical and Simulation-based
                 Results",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-508-96",
  pages =        "22",
  year =         "January 1996, 21 Pages",
  abstract =     "We use two methods, analytic modeling and event-driven
                 simulation, to evaluate the performance of
                 communication in the SHRIMP multicomputer under a
                 variety of workloads. This work has two purposes: to
                 learn about the behavior of the SHRIMP machine, and to
                 explore the tradeoffs between analytic modeling and
                 simulation as performance prediction techniques.\par We
                 find that the system's performance depends mostly on
                 the behavior of the endpoints; most of the message
                 latency is spent arbitrating for the sender's and
                 receiver's memory buses, and doing DMA transfers of
                 data to and from memory. The raw speed of the network
                 is relatively unimportant. Performance is mainly
                 determined by details of DMA speed, network
                 connectivity, and policies for arbitrating for buses
                 and network links.\par Even for very simple synthetic
                 benchmark programs, the analytic model and the
                 simulator differ by roughly 10\% in their performance
                 predictions. Although we believe the simulator to be
                 more accurate than the model, each method has
                 difficulty accurately representing some feature of the
                 real system. Finally, we observe that each of the two
                 tools was valuable in helping to improve the accuracy
                 of the other.",
}


@TechReport{Felten96,
  author =       "Edward W. Felten and Richard D. Alpert and Angelos
                 Bilas and Matthias A. Blumrich and Douglas W. Clark and
                 Stefanos Damianakis and Cezary Dubnicki and Liviu
                 Iftode and Kai Li",
  title =        "Early Experience with Message-Passing on the {SHRIMP}
                 Multicomputer",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-510-96",
  pages =        "22",
  year =         "January 1996, 15 Pages",
  abstract =     "The SHRIMP multicomputer provides virtual
                 memory-mapped communication (VMMC), which supports
                 protected, user-level message passing, allows user
                 programs to perform their own buffer management, and
                 separates data transfers from control transfers so that
                 a data transfer can be done without the intervention of
                 the receiving node CPU. An important question is
                 whether such a mechanism can indeed deliver all of the
                 available hardware performance to applications which
                 use conventional message-passing libraries.\par This
                 paper reports our early experience with message-passing
                 on a small, working SHRIMP multicomputer. We have
                 implemented several user-level communication libraries
                 on top of the VMMC mechanism, including the NX
                 message-passing interface, Sun RPC, stream sockets, and
                 specialized RPC. The first three are fully compatible
                 with existing systems. Our experience shows that the
                 VMMC mechanism supports these message-passing
                 interfaces well. When zero-copy protocols are allowed
                 by the semantics of the interface, it can effectively
                 deliver to applications almost all of the raw
                 hardware's communication performance.",
}


@TechReport{Kaplan96,
  author =       "Haim Kaplan and Robert E. Tarjan",
  title =        "Purely Functional Representations of Catenable Sorted
                 Lists",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-511-96",
  pages =        "22",
  year =         "February 1996, 16 Pages",
  abstract =     "The power of purely functional programming in the
                 construction of data structures has received much
                 attention, not only because functional languages have
                 many desirable properties, but because structures built
                 purely functionally are automatically fully persistent:
                 any and all versions of a structure can coexist
                 indefinitely. Recent results illustrate the surprising
                 power of pure functionality. One such result was the
                 development of a representation of double-ended queues
                 with catenation that supports all operations, including
                 catenation, in worst-case constant time [21].\par This
                 paper is a continuation of our study of pure
                 functionality, especially as it relates to persistence.
                 For one purposes, a purely functional data structure is
                 one built only with the LISP functions car, cons, cdr.
                 We explore purely functional representations of sorted
                 lists, implemented as finger search trees. We describe
                 three implementations. The most efficient of these
                 achieves logarithmic access, insertion, and deletion
                 time, and double-logarithmic catenation time. It uses
                 one level of structural bootstrapping to obtain its
                 efficiency.\par The bounds for find,insert, and delete
                 are the same as the best known bounds for an ephemeral
                 implementation of these operations using finger search
                 trees. The representations we present are the first
                 that address the issues of persistence and pure
                 functionality, and the first for which fast
                 implementations of catenation and split are presented.
                 They are simple to implement and could be efficient in
                 practice, especially for applications that require
                 worst-case time bounds or persistence.",
}


@TechReport{Bilas96,
  author =       "Angelos Bilas and Edward W. Felten",
  title =        "Fast {RPC} on the {SHRIMP} Virtual Memory Mapped
                 Network Interface",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-512-96",
  pages =        "22",
  year =         "March 1996, 19 Pages",
  abstract =     "The emergence of new network interface technology is
                 enabling new approaches to the development of
                 communications software. This paper evaluates the
                 SHRIMP virtual memory mapped network interface by using
                 it to build two fast implementations of remote
                 procedure call (RPC). \par Our first implementation,
                 called vRPC, is fully compatible with the SunRPC
                 standard. We change the RPC runtime library; the
                 operating system kernel is unchanged, and only a
                 minimal change was needed in the stub generator to
                 create a new protocol identifier. Despite these
                 restrictions, our vRPC implementation is several times
                 faster than existing SunRPC implementations. A
                 round-trip null RPC with no arguments and results under
                 vRPC takes about 33 microseconds.\par Our second
                 implementation, called ShrimpRPC, is not compatible
                 with SunRPC but offers much better performance.
                 ShrimpRPC specializes the stub generator and runtime
                 library to take full advantage of SHRIMP's features.
                 The result is a round-trip null RPC latency of 9.5
                 microseconds, which is about one microsecond above the
                 hardware minimum.",
}


@TechReport{protected96,
  author =       "user-level data SHRIMP multicomputer. SHRIMP supports
                 protected",
  title =        "This paper describes an implementation of stream
                 sockets for the",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-513-96",
  pages =        "22",
  year =         "February 1996, 10 Pages",
  abstract =     "transfer, allows user-level code to perform its own
                 buffer management, and separates data transfers from
                 control transfers so that data transfers can be done
                 without the interrupting the receiving node's CPU. Our
                 sockets implementation exploits all of these features
                 to provide high performance. End-to-end latency for 8
                 byte transfers is 11 microseconds, which is
                 considerably lower than all previous implementations of
                 the sockets interface. For large transfers, we obtained
                 a bandwidth of 13.5 MBytes/sec, which is close to the
                 hardware limit when the receiver must perform a copy.
                 Further experiments with the public-domain benchmarks
                 ttcp and netperf confirms the excellent performance of
                 our implementation.",
}


@TechReport{Iftode96,
  author =       "Jaswinder Pal Singh Liviu Iftode and Kai Li",
  title =        "Irregular Applications under Software Shared Memory",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-514-96",
  pages =        "22",
  year =         "February 1996, 15 Pages",
  abstract =     "Shared Virtual Memory (SVM) provides an inexpensive
                 way to support the popular shared address space
                 programming model on networks of workstations or
                 personal computers. Despite recent advances in SVM
                 systems, their performance for all but coarse-grained
                 or regular applications is not well understood. Nor is
                 there an understanding of whether and how fine-grained,
                 irregular programs should be written differently for
                 SVM, with its large granularities of communication and
                 coherence, than for the more familiar hardware coherent
                 at cache line granularity. In this paper we try to
                 understand the performance and programming issues for
                 emerging, irregular applications on SVM systems. We
                 examine performance on both an aggressive all-software
                 system as well as one with a little hardware support in
                 the network interface. We also present approaches to
                 improve the performance of irregular applications at
                 both the programming and the system level. As a result
                 of our experiences, we identify a set of guidelines and
                 techniques that pertain specifically to programming SVM
                 systems, beyond the guidelines commonly used for
                 programming hardware-coherent systems as well. We also
                 present a further relaxation of the memory consistency
                 model, called scope consistency, which is particularly
                 effective for such applications.",
}


@TechReport{Bilas96a,
  author =       "Jason Fritts Angelos Bilas and Jaswinder Pal Singh",
  title =        "Real-Time Parallel {MPEG}-2 Decoding in Software",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-516-96",
  pages =        "22",
  year =         "March 1996, 14 Pages",
  abstract =     "The growing demand for high quality compressed video
                 has led to an increasing need for real-time MPEG-2
                 decoding. With the widespread availability of
                 multiprocessors, a parallel software implementation
                 provides an effective solution to the decoding
                 problem.\par We present a parallel decoder for the
                 MPEG-2 standard, implemented on both centralized and
                 distributed shared memory machines. The goal of this
                 work is to provide an all-software solution for
                 real-time, high-quality video decoding and to
                 investigate the important properties of this
                 application as they pertain to multiprocessors
                 systems.\par Both coarse and fine grained
                 implementations are considered for parallelizing the
                 decoder. The coarse-grained approach exploits
                 parallelism at the group of pictures level, while the
                 fine-grained approach parallelizes within frames, at
                 the slice level. A comparative evaluation of these
                 methods is made, with results presented in terms of
                 speedup, memory requirements, load balance,
                 synchronization time, and temporal and spatial
                 locality.",
}


@TechReport{Bilas96b,
  author =       "David Martin Angelos Bilas and Liviu Iftode and
                 Jaswinder Pal Singh",
  title =        "Shared Virtual Memory Across {SMP} Nodes Using
                 Automatic Update: Protocols and Performance",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-517-96",
  pages =        "22",
  year =         "March 1996, 18 Pages",
  abstract =     "As the workstation market moves form single processor
                 to small-scale shared memory multiprocessors, it is
                 very attractive to construct larger-scale
                 multiprocessors by connecting widely available
                 symmetric multiprocessors (SMPs) in a less tightly
                 coupled way. Using a shared virtual memory (SVM) layer
                 for this purpose preserves the shared memory
                 programming abstraction across nodes. We explore the
                 feasibility and performance implications of one such
                 approach by extending the AURC (Automatic Update
                 Release Consistency) protocol, used in the SHRIMP
                 multicomputer, to connect hardware-coherent SMPs rather
                 than uniprocessors. We describe the extended AURC
                 protocol, and compare its performance with both the
                 AURC uniprocessor node case as well as with an
                 all-software Lazy Release Consistency (LRC) protocol
                 extended for SMPs. We present results based on detailed
                 simulations of two protocols (AURC and LRC) and two
                 architectural configurations of a system with 16
                 processors; one with one processor per node (16 nodes)
                 and one with four processors per node (4 nodes).\par We
                 find that, unless the bandwidth of the network
                 interface is increased, the network interface becomes
                 the bottleneck in a clustered architecture especially
                 for AURC. While a LRC protocol can benefit from the
                 reduction in per processor communication in a clustered
                 architecture, the write-through traffic in AURC
                 increases significantly the communication demands per
                 network interface. This causes more traffic contention
                 and either prevents the performance of AURC from
                 improving under SMP or hurts it severely for
                 applications with significant communication
                 requirements. Thus, while AURC performs better than
                 LRC, for applications with high communication needs,
                 the reverse may be true in clustered architectures.
                 Among possible solutions, two are investigated in the
                 paper: protocol changes and bandwidth increases.
                 Further work is clearly needed on the systems and
                 application sides to evaluate whether AURC can be
                 extended for multiprocessor node systems.",
}


@TechReport{Iftode96a,
  author =       "Liviu Iftode and Cezary Dubnicki and Edward W. Felten
                 and Kai Li",
  title =        "Improving Release-Consistent Shared Virtual Memory
                 using Automatic Update",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-518-96",
  pages =        "22",
  year =         "March 1996, 12 Pages",
  abstract =     "Shared virtual memory is a software technique to
                 provide shared memory on a network of computers without
                 special hardware support. Although several relaxed
                 consistency models and implementations are quite
                 effective, there is still a considerable performance
                 gap between the ``software-only'' approach and the
                 hardware approach that uses directory-based caches.\par
                 Automatic update is a simple communication mechanism,
                 implemented in the SHRIMP multicomputer, that forwards
                 local writes to remote memory transparently. In this
                 paper we propose a new lazy release consistency based
                 protocol, called Automatic Update Release Consistency
                 (AURC), that uses automatic update to propagate and
                 merge shared memory modifications. We compare the
                 performance of this protocol against a software-only
                 LRC implementation on several Splash-2 applications and
                 show that the AURC approach can substantially improve
                 the performance of LRC. For 16 processors, the average
                 speedup has increased from 5.9 under LRC, to 8.3 under
                 AURC.",
}


@TechReport{Iftode96b,
  author =       "Jaswinder Pal Singh Liviu Iftode and Kai Li",
  title =        "Understanding Application Performance on Shared
                 Virtual Memory Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-519-96",
  pages =        "22",
  year =         "March 1996, 12 Pages",
  abstract =     "Many researchers have proposed interesting protocols
                 for shared virtual memory (SVM) systems, and
                 demonstrated performance improvements on parallel
                 programs. However, there is still no clear
                 understanding of the performance potential of SVM
                 systems for different classes of applications. This
                 paper begins to fill this gap, by studying the
                 performance of a range of applications in detail and
                 understanding it in light of application
                 characteristics.\par We first develop a brief
                 classification of the inherent data sharing patterns in
                 the applications, and how they interact with system
                 granularities to yield the communication patterns
                 relevant to SVM systems. We then use detailed
                 simulation to compare the performance of two SVM
                 approaches---Lazy Released Consistency (LRC) and
                 Automatic Update Release Consistency (AURC)---with each
                 other and with an all-hardware CC-NUMA approach. We
                 examine how performance is affected by problem size,
                 machine size, key system parameters, and the use of
                 less optimized program implementations. We find that
                 SVM can indeed perform quite well for systems of at
                 least up to 32 processors for several nontrivial
                 applications. However, performance is much more
                 variable across applications than on CC-NUMA systems,
                 and the problem sizes needed to obtain good parallel
                 performance are substantially larger. The
                 hardware-assisted AURC system tends to perform
                 significantly better than the all-software LRC under
                 our system assumptions, particularly when realistic
                 cache hierarchies are used.",
}


@TechReport{Boneh96,
  author =       "Dan Boneh and Richard J. Lipton",
  title =        "A Revocable Backup System",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-520-96",
  pages =        "22",
  year =         "March 1996, 9 Pages",
  abstract =     "We present a system which enables a user to remove a
                 file from both the file system and all the backup tapes
                 on which the file is stored. The ability to remove
                 files from all backup tapes is desirable in many cases.
                 Our system erases information from the backup tape
                 without actually writing on the tape. This is achieved
                 by applying cryptography in a new way: a block cipher
                 is used to enable the system to ``forget'' information
                 rather than protect it. Our system is easy to install
                 and is transparent to the end user. Further, it
                 introduces no slowdown in system performance and little
                 slowdown in the backup procedure.",
}


@TechReport{Chazelle96,
  author =       "Bernard Chazelle",
  title =        "Application Challenges to Computational Geometry: {CG}
                 Impact Task Force Report",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-521-96",
  pages =        "22",
  year =         "April 1996, 57 Pages",
  abstract =     "With rapid advances in computer hardware and
                 visualization systems, geometric computing is creeping
                 into virtually every corner of science and engineering,
                 from design and manufacturing to astrophysics to
                 molecular biology to fluid dynamics. This report
                 assesses the opportunities and challenges this presents
                 for the field of computational geometry in the years
                 ahead. Can CG meet the algorithmic needs of
                 practitioners? Should it look to applied areas for new
                 sources of problems? Can CG live up to its potential
                 and become a key player in the vast and diverse world
                 of geometric computing? These are some of the questions
                 addressed in this document. It was prepared by a group
                 of computer scientists, engineers, and mathematicians
                 with extensive experience in geometric computing. This
                 report is intended as a wake-up call rather than an
                 agenda setter. It is hoped it will engage a
                 community-wide discussion on the future of
                 computational geometry.",
}


@TechReport{Cao96,
  author =       "Pei Cao",
  title =        "Application-Controlled File Caching and Prefetching",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-522-96",
  pages =        "22",
  year =         "May 1996, 153 Pages",
  abstract =     "As disk performance continues to lag behind
                 microprocessors and memory systems, the file system is
                 increasingly becoming the bottleneck for many
                 applications. This dissertation demonstrates that with
                 appropriate mechanisms and policies,
                 application-controlled file caching and prefetching can
                 significantly improve the file I/O performance of
                 applications in both single and multiple process
                 cases.\par In traditional file systems, the kernel
                 controls file cache replacement and prefetching using
                 fixed policies, with no input from user processes. For
                 many applications, this has resulted in poor
                 utilization of the file cache and little overlapping
                 between I/O and computation. The challenges are to
                 design a scheme that allows applications to control the
                 management of their file cache, and to design
                 algorithms for the kernel to coordinate the use of
                 shared resources so that the performance of the whole
                 system is guaranteed to improve.\par This dissertation
                 proposes two-level file cache management: the kernel
                 allocates physical pages to individual applications,
                 and each application is responsible for deciding how to
                 use its physical pages. The dissertation addresses
                 three issues: a global allocation policy that allows
                 applications to control their own cache replacement
                 while maintaining fair allocation of cache blocks among
                 processes, integrated algorithms for caching and
                 prefetching, and a low-overhead mechanism to implement
                 the interactions between user processes and the
                 kernel.\par A prototype file system, ACFS, is
                 implemented to experiment with application-controlled
                 file caching and prefetching on a suite of I/O
                 intensive applications. Experiments show that
                 application-controlled file caching and prefetching
                 combined with disk scheduling significantly improves
                 the file I/O performance for applications: individual
                 applications' running times are reduced by 3\% to 49\%
                 (average 26\%), and multi-process workloads' running
                 times are reduced by 5\% to 76\% (average 32\%). Each
                 technique provides substantial performance benefits:
                 application-controlled file caching reduces the number
                 of disk I/Os, carefully integrated caching and
                 prefetching increase the overlap between CPU
                 computation and disk accesses, and disk scheduling
                 combined with prefetching reduces the average disk
                 access latency. The combination of all three techniques
                 provides the best performance.",
}


@TechReport{Shillner96,
  author =       "Robert A. Shillner and Edward W. Felten",
  title =        "Simplifying Distributed File Systems Using a Shared
                 Logical Disk",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-524-96",
  pages =        "22",
  year =         "October 1996, 11 Pages",
  abstract =     "We present a new approach to building non-centralized
                 (``serverless'') distributed file systems, using the
                 shared logical disk, which provides the abstraction of
                 a fault-tolerant, entry-consistent, shared array of
                 persistent data blocks. By separating the storage
                 management level from higher-level file system
                 functions like metadata management, we significantly
                 reduce the overall complexity of the file system's
                 implementation.\par We describe the implementation of a
                 file system and an underlying shared logical disk,
                 designed to run on workstation clusters and on the
                 SHRIMP multicomputer. The file system level is very
                 similar to a conventional uniprocessor file system,
                 relying on the underlying shared logical disk to handle
                 all communication, caching, and coherence operations.
                 The shared logical disk provides some simple hooks to
                 allow the file system to express its fault-tolerance
                 requirements. We believe the resulting design is much
                 simpler than other non-centralized distributed file
                 systems.",
}


@TechReport{Damianakis96,
  author =       "Edward W. Felten Stefanos N. Damianakis and Yuqun
                 Chen",
  title =        "Reducing Waiting Costs in User-Level Communication",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-525-96",
  pages =        "22",
  year =         "September 1996, 11 Pages",
  abstract =     "This paper describes a mechanism for reducing the cost
                 of waiting for messages in architectures that allow
                 user-level communication libraries. We reduce waiting
                 costs in two ways: by reducing the cost of servicing
                 interrupts, and by carefully controlling when the
                 system uses interrupts and when it uses polling. We
                 have implemented our mechanism on the SHRIMP
                 multicomputer and integrated it with our user-level
                 sockets library. Experiments show that a hybrid
                 spin-then-block strategy offers good performance in a
                 wide variety of situations, and that speeding up the
                 interrupt path significantly improves performance.",
}


@TechReport{Grigoriev96,
  author =       "Friedhelm Meyer auf der Heide Dima Grigoriev and Marek
                 Karpinski and Roman Smolensky",
  title =        "A Lower Bound for Randomized Algebraic Decision
                 Trees",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-527-96",
  pages =        "22",
  year =         "October 1996, 14 Pages",
  abstract =     "We extend the lower bounds on the depth of algebraic
                 decision trees to the case of randomized algebraic
                 decision trees (with two-sided error) for languages
                 being finite unions of hyperplanes and the
                 intersections of halfspaces, solving a long standing
                 open problem. As an application, among other things, we
                 derive, for the first time, an
                 \$$\backslash$Omega(n\^{}2)\$ randomized lower bound
                 for the Knapsack Problem which was previously only
                 known for deterministic algebraic decision trees. It is
                 worth noting that for the languages being finite unions
                 of hyperplanes our proof method yields also a new
                 elementary technique for deterministic algebraic
                 decision trees without making use of Milnor's bound on
                 Betti number of algebraic varieties.",
}


@TechReport{Watson96,
  author =       "Arthur Henry Watson",
  title =        "Structured Testing: Analysis and Extensions",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-528-96",
  pages =        "22",
  year =         "November 1996, 171 Pages",
  abstract =     "Structured testing, also known as basis path testing,
                 is a methodology for software module testing based on
                 the cyclomatic complexity measure of McCabe. In this
                 dissertation, we analyze the theoretical properties of
                 structured testing, describe the implementation of a
                 system to support structured testing, empirically
                 evaluate the error detection performance of structured
                 testing, and extend the structured testing approach to
                 cover integration testing.\par We exhibit a class of
                 programs with unbounded complexity for which the
                 structured testing approach is both necessary and
                 sufficient to ensure correctness, and place structured
                 testing in a hierarchy with other structural testing
                 criteria. We also discuss Weyuker's axioms for testing
                 criteria, and show that a variant of structured testing
                 in which only executable paths are considered satisfies
                 those axioms.\par We describe an automated system to
                 support structured testing for the C language. We
                 present a technique for assessing and improving a test
                 suite with respect to basis path coverage, based on
                 source code instrumentation and execution trace
                 analysis.\par We present an empirical study comparing
                 the error detection effectiveness of structured
                 testing, all-uses data flow coverage, and branch
                 coverage. Structured testing outperformed branch
                 coverage, was comparable to all-uses, and was more
                 robust with respect to test set minimization than
                 either branch coverage or all-uses.\par We extend
                 structured testing to support software integration
                 testing. We present a mathematical model for
                 integration testing, and derive an integration test
                 sufficiency criterion from that model. We motivate the
                 criterion from a practical perspective, and demonstrate
                 its relationship to structured module testing. We
                 extend our automated system to assess test suites with
                 respect to our integration test criterion, and suggest
                 extensions of the core method to support incremental
                 integration and object-oriented programming.",
}


@TechReport{Zhou96,
  author =       "Liviu Iftode Yuanyuan Zhou and Kai Li",
  title =        "Performance Evaluation of Two Home-Based Lazy Release
                 Consistency Protocols for Shared Virtual Memory
                 Systems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-529-96",
  pages =        "22",
  year =         "September 1996, 14 Pages",
  abstract =     "This paper investigates the performance of shared
                 virtual memory protocols on large-scale multicomputers.
                 Using experiments on a 64-node Paragon, we show that
                 the traditional Lazy Release Consistency (LRC) protocol
                 does not scale well, because of the large number of
                 messages it requires, the large amount of memory it
                 consumes for protocol overhead data, and because of the
                 difficulty of garbage collecting that data.\par To
                 achieve more scalable performance, we introduce and
                 evaluate two new protocols. The first, Home-based LRC
                 (HLRC), is based on the Automatic Update Release
                 Consistency (AURC) protocol. Like AURC, HLRC maintains
                 a home for each page to which all updates are
                 propagated and from which all copies are derived.
                 Unlike AURC, HLRC requires no specialized hardware
                 support. We find that the use of homes provides
                 substantial improvements in performance and scalability
                 over LRC.\par Our second protocol, called Overlapped
                 Home-based LRC (OHLRC), takes advantage of the
                 communication processor found on each node of the
                 Paragon to offload some of the protocol overhead of
                 HLRC from the critical path followed by the compute
                 processor. We find that OHLRC provides modest
                 improvements over HLRC. We also apply overlapping to
                 the base LRC protocol, with similar results.\par Our
                 experiments were done using five of the Splash-2
                 benchmarks. We report overall execution times, as well
                 as detailed breakdowns of elapsed time, message
                 traffic, and memory use for each of the protocols.",
}


@TechReport{Goldberg96,
  author =       "Andrew V. Goldberg and Robert E. Tarjan",
  title =        "Expected Performance of Dijkstra's Shortest Path
                 Algorithm",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-530-96",
  pages =        "22",
  year =         "October 1996, 7 Pages",
  abstract =     "We show that the expected number of decrease-key
                 operations in Dijkstra's shortest path algorithm is O(n
                 log (1+m/n)) for an n-vertex, m-arc graph. The bound
                 holds for any graph structure; the only assumption we
                 make is that for every vertex, the lengths of its
                 incoming arcs are drawn independently from the same
                 distribution. The same bound holds with high
                 probability. This result explains the small number of
                 decrease-key operations observed in practice and helps
                 to explain why Dijkstra codes based on binary heaps
                 perform better than ones based on Fibonacci heaps.",
}


@TechReport{Ristad96,
  author =       "Eric Sven Ristad and Peter N. Yianilos",
  title =        "Learning String Edit Distance",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-532-96",
  pages =        "22",
  year =         "October 1996, 32 Pages",
  abstract =     "In many applications, it is necessary to determine the
                 similarity of two strings. A widely-used notion of
                 string similarity is the edit distance: the minimum
                 number of insertions, deletions, and substitutions
                 required to transform one string into the other. In
                 this report, we provide a stochastic model for string
                 edit distance. Our stochastic model allows us to learn
                 the optimal string edit distance function from a corpus
                 of examples. We illustrate the utility of our approach
                 by applying it to the difficult problem of learning the
                 pronunciation of words in conversational speech. In
                 this application, we learn a string edit distance
                 function with one third the error rate of the untrained
                 Levenshtein distance.",
}


@TechReport{Ristad96a,
  author =       "Eric Sven Ristad and Peter N. Yianilos",
  title =        "Finite Growth Models",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-533-96",
  pages =        "22",
  year =         "December 1996, 39 Pages",
  abstract =     "Finite growth models (FGM) are nonnegative functionals
                 that arise from parametrically-weighted directed
                 acyclic graphs and a tuple observation that affects
                 these weights. The weight of a source-sink path is the
                 product of the weights along it. The functional's value
                 is the sum of the weights of all such paths. The
                 mathematical foundations of hidden Markov modeling
                 (HMM) and expectation maximization (EM) are generalized
                 to address the problem of functional maximization given
                 an observation. Probability models such as HMMs and
                 stochastic context free grammars are examples that
                 satisfy a particular constraint: that of summing or
                 integrating to one. The FGM framework, algorithms, and
                 data structures describe these and other similar
                 stochastic models while providing a unified and natural
                 way for computer scientists to learn and reason about
                 them and their many variations.\par Restricted to
                 probabilistic form, FGMs correspond to stochastic
                 automata that allow observations to be processed in
                 many orderings and groupings -- not just one-by-one in
                 sequential order. As a result the parameters of a
                 highly general form of stochastic transducer can be
                 learned from examples, and the particular case of
                 string edit distance is developed.\par In the FGM
                 framework one may direct learning by criteria beyond
                 simple maximum-likelihood. The MAP (maximum a
                 posteriori estimate) and MDL (minimum description
                 length) are discussed along with the application of
                 FGMs to causal-context probability models and
                 unnormalized noncausal models.",
}


@TechReport{Shillner96a,
  author =       "Robert A. Shillner and Edward W. Felten",
  title =        "Mobile Network Objects",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-534-96",
  pages =        "22",
  year =         "October 1996, 13 Pages",
  abstract =     "A network object is an object which may have its
                 methods invoked across a network. We describe
                 extensions to DEC SRC's Modula-3 network objects
                 system; these extensions support migration of network
                 objects between address spaces. Unlike other mobile
                 object systems, we use an existing programming language
                 rather than inventing a new language with object
                 mobility primitives, and we require no changes to the
                 compiler, standard runtime library, or operating
                 system. This paper details the design, implementation
                 and performance of our mobile objects system and two
                 sample applications which use the system.",
}


@TechReport{Zhou96a,
  author =       "Mark D. Hill Yuanyuan Zhou and Ioannis Schoinas Liviu
                 Iftode and Brian R. Toonen Kai Li and Jaswinder Pal
                 Singh and David A. Wood",
  title =        "Relaxed Consistency and Coherence Granularity in {DSM}
                 Systems: {A} Performance Evaluation",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-535-96",
  pages =        "22",
  year =         "December 1996, 10 Pages",
  abstract =     "During the past few years, two main approaches have
                 been taken to improve the performance of software
                 shared memory implementations: relaxing consistency
                 models and providing fine-grained access control. Their
                 performance tradeoffs, however, are not well
                 understood. This paper compares the performance of
                 three consistency models across four coherence
                 granularity sizes on a 16-node cluster of workstations.
                 The main result is that no single combination of
                 protocol, granularity, and mechanism to handle message
                 arrival performs best for all applications. The
                 experiments with five classes of applications show that
                 the combination of the sequential consistency (SC)
                 protocol, a polling mechanism, and very fine (64-byte)
                 coherence granularity works quite well for most
                 applications. As the coherence granularity increases,
                 single-writer lazy release consistency (SW-LRC) and
                 home-based lazy release consistency (HLRC) perform
                 better than the SC protocol for applications with false
                 sharing and coarse-grain synchronization. However, the
                 absolute performance with a coarse coherence
                 granularity depends upon whether the application causes
                 significant internal fragmentation. The HLRC protocol
                 works better than SW-LRC, when the size of coherence
                 granularity increases to a typical page size (4,096
                 bytes). The polling mechanism is very crucial for the
                 SC protocol and not crucial for SW-LRC and HLRC
                 protocols for certain applications.",
}


@TechReport{Ristad96b,
  author =       "Eric Sven Ristad and Robert G. Thomas",
  title =        "Nonuniform Markov Models",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-536-96",
  pages =        "22",
  year =         "November 1996, 17 Pages",
  abstract =     "A statistical language model assigns probability to
                 strings of arbitrary length. Unfortunately, it is not
                 possible to gather reliable statistics on strings of
                 arbitrary length from a finite corpus. Therefore, a
                 statistical language model must decide that each symbol
                 in a string depends on at most a small, finite number
                 of other symbols in the string. In this report we
                 propose a new way to model conditional independence in
                 Markov models. The central feature of our nonuniform
                 Markov model is that it makes predictions of varying
                 lengths using contexts of varying lengths. Experiments
                 on the Wall Street Journal reveal that the nonuniform
                 model performs slightly better than the classic
                 interpolated Markov model.",
}


@TechReport{Blume96,
  author =       "Matthias Blume and Andrew W. Appel",
  title =        "Lambda-Splitting: {A} Higher-Order Approach to
                 Cross-Module Optimizations",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-537-96",
  pages =        "22",
  year =         "November 1996, 12 Pages",
  abstract =     "We describe an algorithm for automatic inline
                 expansion across module boundaries that works in the
                 presence of higher-order functions and free variables;
                 it rearranges bindings and scopes as necessary to move
                 nonexpansive code from one module to another. We
                 describe - and implement - the algorithm as
                 transformations on lambda-calculus. Our inliner
                 interacts well with separate compilation and is
                 efficient, robust, and practical enough for everyday
                 use in the SML/NJ compiler. Inlining improves
                 performance by 4--8\% on existing code, and makes it
                 possible to use much more data abstraction by
                 consistently eliminating penalties for modularity.",
}


@TechReport{Grigoriev96a,
  author =       "Dima Grigoriev and Marek Karpinski",
  title =        "Randomized Omega (n\^{}2) Lower Bound for Knapsack",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-538-96",
  pages =        "22",
  year =         "November 1996, 24 Pages",
  abstract =     "We prove Omega (n\^{}2) complexity lower bound for the
                 general model of randomized computation trees solving
                 the Knapsack Problem , and more generally Restricted
                 Integer Programming. This is the first nontrivial lower
                 bound proven for this model of computation. The method
                 of the proof depends crucially on the new technique for
                 proving lower bounds on the border complexity of a
                 polynomial which could be of independent interest.",
}


@TechReport{Karpinski96,
  author =       "Lawrence L. Larmore Marek Karpinski and Wojciech
                 Rytter",
  title =        "Correctness of Constructing Optimal Alphabetic Trees
                 Revisited",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-539-96",
  pages =        "22",
  year =         "December 1996, 16 Pages",
  abstract =     "Several new observations which lead to new correctness
                 proofs of two known algorithms (Hu-Tucker and
                 Garsia-Wachs) for construction of optimal alphabetic
                 trees are presented. A generalized version of the
                 Garsia-Wachs algorithm is given. Proof of this
                 generalized version works in a structured and
                 illustrative way and clarifies the usually
                 poorly-understood behavior of both the Hu-Tucker and
                 Garsia-Wachs algorithms. The generalized version
                 permits any non-negative weights, as opposed to
                 strictly positive weights required in the original
                 Garsia-Wachs algorithm. New local structural properties
                 of optimal alphabetic trees are given. The concept of
                 well-shaped segment (a part of an optimal tree) is
                 introduced. It is shown that some parts of the optimal
                 tree are known in advance to be well-shaped, and this
                 implies correctness of the algorithms rather easily.
                 The crucial part of the correctness proof of the
                 Garsia-Wachs algorithm, namely the structural theorem,
                 is identified. The correctness proof of the Hu-Tucker
                 algorithm consists of showing a very simple mutual
                 simulation between this algorithm and the Garsia-Wachs
                 algorithm. For this proof, it is essential to use the
                 generalized version of Garsia-Wachs algorithm, in which
                 an arbitrary locally minimal pair is processed, not
                 necessarily the rightmost minimal pair. Such a
                 generalized version is also needed for parallel
                 implementations. Another result presented in this paper
                 is the clarification of the problem of resolving ties
                 (equalities between weights of items) in the Hu-Tucker
                 algorithm. This is related to the proof, by simulation,
                 of correctness of the Hu-Tucker algorithm. It is shown
                 that the condition that there are no ties may generally
                 be assumed without harm and that, essentially, the
                 Hu-Tucker algorithm avoids ties automatically.",
}


@TechReport{Felten97,
  author =       "Drew Dean Edward W. Felten and Dirk Balfanz and Dan S.
                 Wallach",
  title =        "Web Spoofing: An Internet Con Game",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-540-96",
  pages =        "22",
  year =         "April 1997, 9 Pages",
  abstract =     "This paper describes an Internet security attack that
                 could endanger the privacy of World Wide Web users and
                 the integrity of their data. The attack can be carried
                 out on today's systems, endangering users of the most
                 common Web browsers, including Netscape Navigator and
                 Microsoft Internet Explorer. Web spoofing allows an
                 attacker to create a {"}shadow copy{"} of the entire
                 World Wide Web. Accesses to the shadow Web are funneled
                 through the attacker's machine, allowing the attacker
                 to monitor all of the victim's activities including any
                 passwords or account numbers the victim enters. The
                 attacker can also cause false or misleading data to be
                 sent to Web servers in the victim's name, or to the
                 victim in the name of any Web server. In short, the
                 attacker observes and controls everything the victim
                 does on the Web. We have implemented a demonstration
                 version of this attack.",
}


@TechReport{Ristad96c,
  author =       "Eric S. Ristad and Peter N. Yianilos",
  title =        "On the Strange a Posteriori degeneracy of Normal
                 Mixtures, and Related Reparameterization Theorems",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-541-96",
  pages =        "22",
  year =         "December 1996, 16 Pages",
  abstract =     "This short paper illuminates certain fundamental
                 aspects of the nature of normal (Gaussian) mixtures.
                 Thinking of each mixture component as a class, we focus
                 on the corresponding a posteriori class probability
                 functions. It is shown that the relationship between
                 these functions and the mixture's parameters, is highly
                 degenerate -- and that the precise nature of this
                 degeneracy leads to somewhat unusual and
                 counter-intuitive behavior. Even complete knowledge of
                 a mixture's a posteriori class behavior, reveals
                 essentially nothing of its absolute nature, i.e. mean
                 locations and covariance norms. Consequently a mixture
                 whose means are located in a small ball anywhere in
                 space, can project arbitrary class structure everywhere
                 in space.\par The well-known expectation maximization
                 (EM) algorithm for Maximum Likelihood (ML) optimization
                 may be thought of as a reparameterization of the
                 problem in which the search takes place over the space
                 of sample point weights. Motivated by EM we
                 characterize the expressive power of similar
                 reparameterizations, where the objective is instead to
                 maximize the a posteriori likelihood of a labeled
                 training set. This is relevant to, and a generalization
                 of a common heuristic in machine learning in which one
                 increases the weight of a mistake in order to improve
                 classification accuracy. We prove that EM-style
                 reparameterization is not capable of expressing
                 arbitrary a posteriori behavior, and is therefore
                 incapable of expressing some solutions. However a
                 slightly different reparameterization is presented
                 which is almost always fully expressive -- a fact
                 proven by exploiting the degeneracy described above.",
}


@TechReport{Appel96,
  author =       "Andrew W. Appel",
  title =        "Security and Document Compatability for Electronic
                 Refereeing",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-558-96",
  pages =        "22",
  year =         "October 1996; 4 Pages",
  abstract =     "I have recently described [1] a management system,
                 with accompanying software, for use by journal editors
                 in organizing the refereeing of scientific manuscripts
                 prior to publication. For me this system has been very
                 successful, cutting the time from submission to final
                 acceptance of manuscripts from two or three years
                 (under the previous editor) to just a few months. This
                 is fast by the standards of computer science, where
                 referees are meticulous but a bit slow, and almost
                 every paper requires revision and re-refereeing before
                 acceptance.",
}


@TechReport{Dobkin96,
  author =       "Don P. Mitchell David P. Dobkin and David Eppstein",
  title =        "Computing the Discrepancy with Applicaitons to
                 Supersampling Patterns",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-561-96",
  pages =        "22",
  year =         "September 1996; 20 Pages",
  abstract =     "Patterns used for supersampling in graphics have been
                 analyzed from statistical and signal-processing
                 viewpoints. We present an analysis based on a type of
                 isotropic discrepancy--how good patterns are at
                 estimating the area in a region of defined type. We
                 present algorithms for computing discrepancy relative
                 to regions that are defined by rectangles, halfplanes,
                 and higher-dimensional figures. Experimental evidence
                 shows that popular supersampling patterns have
                 discrepancies with better asymptotic behavior than
                 random sampling, which is not inconsistent with
                 theoretical bounds on discrepancy.",
}


@TechReport{Blumrich96,
  author =       "Matthias Augustin Blumrich",
  title =        "Network Interface for Protected, User-Level
                 Communication (Thesis)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-568-96",
  pages =        "22",
  year =         "June 1996; 155 Pages",
  abstract =     "Scalable parallel architectures are converging on the
                 general framework of a distributed memory parallel
                 processor (DMPP), consisting of a group of
                 interconnected compute nodes, each typically consisting
                 of a CPU, some memory, and a network interface. DMPP
                 architectures range from tightly-coupled multicomputers
                 to loosely-coupled networks of personal computers
                 (PCs), and support a number of parallel programming
                 paradigms including shared-memory and message-passing.
                 Networks of PCs are very attractive DMPPs because of
                 the high performance and low cost of the PC nodes.\par
                 Custom-built multicomputers have one principal
                 advantage over networks of PCs: they are faster. The
                 major reason for this advantage is a gap in
                 communication performance between multicomputer
                 interconnects and local area networks. Recent
                 networking trends have seen a migration of technology
                 from multicomputers to networks of PCs, shrinking this
                 communication performance gap considerably. However,
                 software overhead---largely attributable to local area
                 network interfaces---continues to maintain the
                 performance gap.\par This dissertation describes how
                 network interfaces can bridge the gap by providing
                 appropriate support for protected, user-level
                 communication with extremely low software overhead.
                 Such network interfaces can be used to build scalable,
                 high-performance, really inexpensive multiprocessors
                 out of low-cost, commodity components.\par This
                 assertion is demonstrated via a working implementation
                 of a prototype SHRIMP network of PCs. The prototype
                 achieves data transfer latency competitive with custom
                 multicomputers, and efficient use of bandwidth down to
                 small message sizes. In addition, SHRIMP supports
                 general multiprogramming, extending its benefits from
                 uniprocessors to multiprocessors.\par The key to SHRIMP
                 performance is virtual memory-mapped communication,
                 which strips away overhead from time-critical data
                 transfer operations without sacrificing all the
                 services that systems have come to depend on. Equipped
                 with virtual memory-mapped communication, networks of
                 PCs could very well become commodity scalable
                 systems.",
}


@TechReport{Philbin96,
  author =       "James Philbin and Jan Edler and Otto J. Anshus and
                 Craig C. Douglas and Kai Li",
  title =        "Thread Scheduling for Cache Locality",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-569-96",
  pages =        "22",
  year =         "December 1996; 12 Pages",
  abstract =     "This paper describes a method to improve the cache
                 locality of sequential programs by scheduling
                 fine-grained threads. The algorithm relies upon hints
                 provided at the time of thread creation to determine a
                 thread execution order likely to reduce cache misses.
                 This technique may be particularly valuable when
                 compiler-directed tiling is not feasible. Experiments
                 with several application programs, on two systems with
                 different cache structures, show that our thread
                 scheduling method can improve program performance by
                 reducing second-level cache misses.",
}


@TechReport{Dubnicki96,
  author =       "Cezary Dubnicki and Liviu Iftode and Edward W. Felten
                 and Kai Li",
  title =        "Software Support for Virtual Memory-Mapped
                 Communication",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-571-96",
  pages =        "22",
  year =         "April 1996; 10 Pages",
  abstract =     "Virtual memory-mapped communication (VMMC) is a
                 communication model providing direct data transfer
                 between the sender's and receiver's virtual address
                 spaces. This model eliminates operating system
                 involvement in communication, provides full protection,
                 supports user-level buffer management and zero-copy
                 protocols, and minimizes software communication
                 overhead. This paper describes system software support
                 for the model including its API, operating system
                 support, and software architecture, for two network
                 interfaces designed in the SHRIMP project. Our
                 implementations and experiments show that the VMMC
                 model can indeed expose the availabel hardware
                 performance to user programs. On two Pentium PCs with
                 our prototype network interface hardware over a
                 network, we have achieved user-to-user latency of 4.8
                 mu sec and sustained bandwidth of 23 MB/s, which is
                 close to the peak hardware bandwidth. Software
                 communication overhead is only a few user-level
                 instructions.",
}


@TechReport{Chen97,
  author =       "James S. Plank Yuqun Chen and Kai Li",
  title =        "{CLIP}: {A} Checkpointing Tool for Message-Passing
                 Parallel Programs",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-543-97",
  pages =        "22",
  year =         "May 1997, 10 Pages",
  abstract =     "Checkpointing is a useful technique for rollback
                 recovery of parallel applications. While extensive
                 research has been performed on checkpointing in
                 parallel environments, there are few checkpointers
                 available to application users on commercial parallel
                 computers. This paper presents one such checkpointer:
                 CLIP. CLIP is a user-level library that provides
                 semi-transparent checkpointing for parallel programs on
                 the Intel Paragon multicomputer. It is publicly
                 available to Paragon users at no cost.\par
                 Conceptually, checkpointing a multicomputer is
                 straightforward. However, when creating an actual tool
                 for checkpointing a complex machine like the Paragon,
                 many more issues arise that require careful design
                 decisions to be made. Sometimes ease-of-use must be
                 sacrificed for efficiency and/or correctness. This
                 paper details what these decisions are, and how they
                 were made in CLIP.\par We also present performance data
                 when checkpointing several long-running Paragon
                 applications with CLIP. The bottom line is that a
                 convenient, general-purpose checkpointing tool like
                 CLIP can provide fault-tolerance on a massively
                 parallel multicomputer like the Paragon with very good
                 performance.",
}


@TechReport{Ristad97,
  author =       "Eric Sven Ristad and Robert G. Thomas",
  title =        "Hierarchical Non-Emitting Markov Models",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-544-97",
  pages =        "22",
  year =         "1997",
  abstract =     "We describe a simple variant of the interpolated
                 Markov model with non-emitting state transitions and
                 prove that it is strictly more powerful than any Markov
                 model. More importantly, the non-emitting model
                 outperforms the classic interpolated model on the
                 natural language texts under a wide range of
                 experimental conditions, with only a modest increase in
                 computational requirements. The non-emitting model is
                 also much less prone to overfitting.",
}


@TechReport{Shillner97,
  author =       "Robert A. Shillner",
  title =        "An Introduction to Client-Server Programming with
                 Sockets",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-545-97",
  pages =        "22",
  year =         "March 1997, 9 Pages",
  abstract =     "This report gives an introduction to writing
                 client-server applications using sockets. It includes a
                 step-by-step explanation of a working sockets
                 application. Full source code is included.",
}


@TechReport{Wallach97,
  author =       "Drew Dean Dan S. Wallach and Dirk Balfanz and Edward
                 W. Felten",
  title =        "Extensible Security Architectures for Java",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-546-97",
  pages =        "22",
  year =         "April 1997, 16 Pages",
  abstract =     "Mobile code technologies such as Java, JavaScript, and
                 ActiveX generally limit all programs to a single
                 security policy. However, software-based protection can
                 allow for more flexible security models, with
                 potentially significant performance improvements over
                 traditional hardware-based solutions. We describe and
                 analyze three implementation strategies for interposing
                 flexible security policies in software-based security
                 systems. Implementations exist for all three
                 strategies: several vendors have adapted capabilities
                 to Java, Netscape Communicator extended Java's stack
                 introspection, and we built a type-hiding system as an
                 add-on to Microsoft Internet Explorer.",
}


@TechReport{Yianilos97,
  author =       "Peter N. Yianilos",
  title =        "Topics in Computational Hidden State Modeling",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-547-97",
  pages =        "22",
  year =         "May 1997, 131 Pages",
  abstract =     "Motivated by the goal of establishing stochastic and
                 information theoretic foundations for the study of
                 intelligence and synthesis of intelligent machines,
                 this thesis probes several topics relating to hidden
                 state stochastic models.\par Finite Growth Models (FGM)
                 are introduced. These are nonnegative functionals that
                 arise from parametrically-weighted directed acyclic
                 graphs and a tuple observation that affects these
                 weights. Using FGMs the parameters of a highly general
                 form of stochastic transducer can be learned from
                 examples, and the particular case of stochastic string
                 edit distance is developed. Experiments are described
                 that illustrate the application of learned string edit
                 distance to the problem of recognizing a spoken word
                 given a phonetic transcription of the acoustic signal.
                 With FGMs one may direct learning by criteria beyond
                 simple maximum-likelihood. The MAP (maximum a
                 posteriori estimate) and MDL (minimum description
                 length) are discussed along with the application to
                 causal-context probability models and unnormalized
                 noncausal models. The FGM framework, algorithms, and
                 data structures describe hidden Markov models,
                 stochastic context free grammars, and many other
                 conventional similar models while providing a unified
                 and natural way for computer scientists to learn and
                 reason about them and their many variations. A software
                 system and scripting language is proposed to serve as
                 an assembly language or sorts for many higher level
                 model types.\par This thesis also illuminates certain
                 fundamental aspects of the nature of normal (Gaussian)
                 mixtures and the reparameterization of related
                 optimization problems. The use of conditional normal
                 mixtures is proposed as a tool for image modeling, and
                 issues relating to the estimation of their parameters
                 are discussed.",
}


@TechReport{Samanta97,
  author =       "Liviu Iftode Rudrajit Samanta and Jaswinder Pal
                 Singh",
  title =        "Home-based {SVM} Protocols for {SMP} Clusters: Design,
                 Implementation and Performance",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-548-97",
  pages =        "22",
  year =         "May 1997, 7 Pages",
  abstract =     "Shared virtual memory has been used as a
                 cost-effective means of providing the attractive
                 shared-memory model to programmers. In the past, most
                 SVM implementations have been focussed on clusters of
                 uniprocessor systems. Due to the increasing popularity
                 and declining costs of small scale shared memory
                 multiprocessor systems (SMPs), they have become
                 attractive candidates for replacing the uniprocessor
                 nodes when building a shared virtual memory layer. At
                 present, there is no definite answer on what is the
                 best approach to implementing an SVM layer for a
                 cluster of SMPs, whether such a protocol is necessarily
                 different from one designed for uniprocessor nodes, and
                 what accepts of this difference actually results in
                 increases in performance.\par To answer these questions
                 and explore the design space of SVM on SMPs, we have
                 implemented a home-based lazy release consistency
                 (HLRC) protocol on a cluster of 4-way Intel PentiumPro
                 SMPs interconnected with Myrinet. This paper presents
                 numerous protocol design options we were faced with and
                 their implications. We are able to achieve very
                 promising performance on some applications investigated
                 so far. We have investigated (quantitatively) the
                 tradeoffs in our system to validate some of the choices
                 we have made. The tradeoff investigation is ongoing,
                 and we will complete it for the final paper.",
}


@TechReport{Bilas97,
  author =       "Liviu Iftode Angelos Bilas and Jaswinder Pal Singh",
  title =        "Comparison of Shared Virtual Memory across
                 Uniprocessor and {SMP} Nodes",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-550-97",
  pages =        "22",
  year =         "July 1997, 11 Pages",
  abstract =     "As the workstation market moves form single processor
                 to small-scale shared memory multiprocessors, it is
                 very attractive to construct larger-scale
                 multiprocessors by connecting symmetric multiprocessors
                 (SMPs) with efficient commodity network interfaces such
                 as Myrinet Using a shared virtual memory (SVM) layer
                 for this purpose preserves the shared memory
                 programming abstraction across nodes. We explore the
                 feasibility and performance implications of one such
                 approach by comparing the performance of two SVM
                 protocols on systems with uniprocessor and SMP nodes.
                 AURC (Automatic Update Release Consistency) is a
                 protocol developed for the SHRIMP multicomputer that
                 takes advantage of the available Automatic Update
                 hardware support. HLRC (Home-Based Lazy Release
                 Consistency) is an all-software version of AURC. These
                 protocols were demonstrated to achieve good performance
                 and to outperform earlier all-software systems on
                 configurations with uniprocessor nodes.\par In this
                 paper we use an architectural simulator and ten
                 applications to investigate the potential of using SMP
                 nodes. Through detailed simulations we find that using
                 SMPs improves performance for most of the applications,
                 because of more sharing, effective prefetching and
                 lower synchronization costs. The protocols, however,
                 exhibit different behavior for some applications. HLRC
                 is in general more robust and predictable, whereas AURC
                 exhibits more problems with contention due to the
                 increased traffic.",
}


@TechReport{Blume97,
  author =       "Matthias Blume",
  title =        "Hierarchical Modularity and Intermodule Optimization",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-551-97",
  pages =        "22",
  year =         "November 1997, 213 Pages",
  abstract =     "Separate compilation is an important tool for coping
                 with design complexity in large software projects. When
                 done right it can also be used to create software
                 libraries, thus promoting code reuse. But separate
                 compilation comes in various flavors and has many
                 facets: namespace management, linking, optimization,
                 dependencies.\par Many programming languages identify
                 modular units with units of compilation, while only a
                 few extend this to permit hierarchies of language-level
                 modules within individual compilation units. When the
                 number of compilation units is large, then it becomes
                 increasingly important that the mechanism of separate
                 compilation itself can be used to control
                 namespaces.\par The group model implemented in SML/NJ's
                 compilation manager CM provides the necessary
                 facilities to avoid unwanted interferences between
                 unrelated parts of large programs. Compilation units
                 are arranged into groups, and explicit export
                 interfaces can be used to control namespaces. When
                 there are many groups, they can be organized into
                 super-groups, and so on, thus forming a hierarchical
                 modular structure. CM provides automatic dependency
                 analysis, but automatic dependency analysis is NP-hard
                 for general SML code. We show two simple restrictions
                 that avoid intractability.\par To remove the penalties
                 for efficiency usually incurred by modularization and
                 separate compilation, I designed an algorithm for
                 automatic inline expansion across compilation unit
                 boundaries that works in the presence of higher-order
                 functions and free variables; it rearranges bindings
                 and scopes as necessary to move non-expansive code from
                 one module to another. I describe---and implement---the
                 algorithm as transformations on
                 \$$\backslash$lambda\$-calculus. The inliner is
                 efficient, robust, and practical enough for everyday
                 use in the SML/NJ compiler. It preserves separate
                 compilation and has been integrated with CM.\par I
                 briefly investigate macro systems as an alternative
                 approach---driven by programmer directives---to achieve
                 cross-module inlining and discuss a variety of problems
                 that arise. I show a solution to the problem of
                 integrating macro systems with ML-style modules that
                 use long identifiers and show an implementation
                 technique for reliable name resolution during linking.
                 But I also discover that other problems continue to
                 impede large-scale programming.",
}


@TechReport{Iftode97,
  author =       "Liviu Iftode and Jaswinder Pal Singh",
  title =        "Shared Virtual Memory: Progress and Challenges",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-552-97",
  pages =        "22",
  year =         "October 1997, 10 Pages",
  abstract =     "When the idea of implementing a shared address space
                 in software at page granularity across a network of
                 computers---i.e. the shared virtual memory or SVM
                 approach---was first introduced, few would have
                 predicted that a decade would not be enough to exhaust
                 its research potential or even understand its
                 performance capabilities. Software shared memory became
                 a very active research area, with many groups designing
                 new protocols, consistency models and systems. These
                 groups inspired and motivated one another, building on
                 one another's ideas to push performance higher.\par
                 This paper places the multi-track flow of ideas and
                 results so far in a framework, with the goal of
                 identifying the lessons learned so far and the major
                 remaining challenges.",
}


@TechReport{Raghavachari97,
  author =       "Mukund Raghavachari",
  title =        "Language and Compiler Mechanisms for Parallel
                 Programming with Customizable Protocols",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-553-97",
  pages =        "22",
  year =         "November 1997, 177 Pages",
  abstract =     "Customizing the protocols used to manage accesses to
                 different data structures within an application can
                 improve the performance of software shared-memory
                 programs substantially. Existing systems for using
                 customizable protocols, however, are hard to use
                 because they force programmers to rely on low-level
                 mechanisms for manipulating these protocols. Since
                 several shared-memory systems implement protocols in
                 software and can support customizable protocols, the
                 development of intuitive abstractions for the use of
                 application-specific protocols is important.\par This
                 dissertation is an in-depth study of the issues
                 involved with providing language support for
                 customizable protocols. We describe the design and
                 implementation of a new language for parallel
                 programming, Ace, that integrates support for
                 customizable protocols with minimal extensions to C.
                 Ace applications are developed using a shared-memory
                 model with a default sequentially consistent protocol.
                 Performance can then be optimized, with minor
                 modifications to the application, by experimenting with
                 different protocol libraries. \par The design of Ace
                 was driven by a detailed examination of the use of
                 customizable protocols. We delineate the issues that
                 must be considered when programming with customizable
                 protocols and present novel abstractions that allow for
                 the easy use of customizable protocols. We describe the
                 design and implementation of a runtime system and
                 compiler for Ace and discuss compiler optimizations
                 that improve the performance of such software
                 shared-memory systems. We study the communication
                 patterns of a set of benchmark applications, and
                 consider the use of customizable protocols to optimize
                 their performance. We evaluate the performance of our
                 system using experimentation on a Thinking Machine CM-5
                 and a Cray T3E. We also present measurements that
                 demonstrate that Ace has good performance compared to a
                 modern software distributed shared-memory system.",
}


@TechReport{Wang97,
  author =       "Daniel C. Wang and Andrew W. Appel and Jeff L. Korn
                 and Christopher S. Serra",
  title =        "The Zephyr Abstract Syntax Description Language",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-554-97",
  pages =        "22",
  year =         "October 1997; 15 Pages",
  abstract =     "The Zephyr Abstract Syntax Description Language (ASDL)
                 describes the abstract syntax of compiler intermediate
                 representations (IRs) and other tree-like data
                 structures. Just as the lexical and syntactic
                 structures of programming languages are described with
                 regular expressions and context free grammars, ASDL
                 provides a concise notation for describing the abstract
                 syntax of programming languages. Tools can convert ASDL
                 descriptions into the appropriate data-structure
                 definitions and functions to convert the
                 data-structures to or from a standard flattened
                 representation. This makes it easier to build compiler
                 components that interoperate.\par Although ASDL lacks
                 subtyping and inheritance, it is able to describe the
                 Stanford University Intermediate Format (SUIF) compiler
                 IR, originally implemented in C++. We have built a tool
                 that converts ASDL into C, C++, Java, and ML
                 data-structure definitions and conversion functions. We
                 have also built a graphical browser-editor of ASDL data
                 structures. ASDL shares features found in many network
                 interface description languages (IDLs), algebraic data
                 types, and languages such as ASN.1 and SGML. Compared
                 to other alternatives ASDL is simple and powerful. This
                 document describes ASDL in detail and presents an
                 initial evaluation of ASDL.",
}


@TechReport{Blume97a,
  author =       "Matthias Blume and Andrew W. Appel",
  title =        "Hierarchical Modularity: Compilation management for
                 Standard {ML}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-555-97",
  pages =        "22",
  year =         "July 1997; 13 Pages",
  abstract =     "Many programming languages identify modular units with
                 compilation units, while only few extend this to permit
                 hierarchies of language-level modules within individual
                 compilation units. But when the number of such
                 compilation units is large, then it becomes
                 increasingly important that they themselves can be
                 grouped together and that explicit export interfaces
                 can be used to control namespaces. We explain how the
                 group model implemented in SML/NJ's compilation manager
                 CM provides the necessary facilities to avoid unwanted
                 interferences between unrelated parts of large
                 programs. We also discuss the problem of automatic
                 dependency analysis as well as its complexity and show
                 ways of avoiding intractability.",
}


@TechReport{Appel97,
  author =       "Andrew W. Appel and Trevor Jim",
  title =        "Shrinking Lambda Expressions in Linear Time",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-556-97",
  pages =        "22",
  year =         "February 1997; 29 Pages",
  abstract =     "Functional-language compilers often perform
                 optimizations based on beta and delta reduction. To
                 avoid speculative optimizations that can blow up the
                 code size, we might wish to use only $<$i$>$
                 shrinking$<$/i$>$ reduction rules guaranteed to make
                 the program smaller: these include dead-variable
                 elimination, constant folding, and a restricted beta
                 rule that inlines only functions that are called just
                 once.\par The restricted beta rule leads to a shrinking
                 rewrite system that has not previously been studied. We
                 show some efficient normalization algorithms that are
                 immediately useful in optimizing compilers; and we give
                 a confluence proof for our system, showing that the
                 choice of normalization algorithm does not affect final
                 code quality.",
}


@TechReport{Balfanz97,
  author =       "Dirk Balfanz and Li Gong",
  title =        "Experience with Secure Multi-Processing in Java",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-560-97",
  pages =        "22",
  year =         "September 1997, 12 Pages",
  abstract =     "As Java is the preferred platform for the deployment
                 of network computers, it is appealing to run multiple
                 applications on a single Java desktop. We experimented
                 with using the Java platform as a multi-processing,
                 multi-user environment. Although the Java Virtual
                 Machine (JVM) is not inherently a single-application
                 design, we have found that the implementation of the
                 Java Development Kit (JDK) often implicitly assumes
                 that the Java Virtual Machine runs exactly one
                 application at any one time.\par In this paper, we
                 report the limitations we encountered and propose
                 improvements to several aspects of the Java
                 architecture, including its security features. We have
                 implemented all the proposed changes in a prototype
                 based on the in-house beta version of JDK 1.2. Our
                 prototype uses a Bourne shell-like command line tool to
                 launch multiple applications (such as Appletviewer)
                 within one JVM.",
}


@TechReport{Dean97,
  author =       "Drew Dean and Edward W. Felten and Dan S. Wallach and
                 Dirk Balfanz",
  title =        "Java Security: Web Browsers and Beyond",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-566-97",
  pages =        "22",
  year =         "February 1997; 20 Pages",
  abstract =     "The introduction of Java applets has taken the World
                 Wide Web by storm. Java allows web creators to
                 embellish their content with arbitrary programs which
                 execute in the web browser, whether for simple
                 animations or complex front-ends to other services. We
                 examined the Java language and the Sun HotJava,
                 Netscape Navigator, and Microsoft Internet Explorer
                 browsers which support it, and found a significant
                 number of flaws which compromise their security. These
                 flaws arise for several reasons, including
                 implementation errors, unintended interactions between
                 browser features, differences between the Java language
                 and bytecode semantics, and weaknesses in the design of
                 the language and the bytecode format. On a deeper
                 level, these flaws arise because of weaknesses in the
                 design methodology used in creating Java and the
                 browsers. In addition to the flaws, we discuss the
                 underlying tension between the openness desired by web
                 application writers and the security needs of their
                 users, and we suggest how both might be accommodated.",
}


@TechReport{Balfanz97a,
  author =       "Dirk Balfanz and Edward W. Felten",
  title =        "A Java Filter",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-567-97",
  pages =        "22",
  year =         "December 1997; 7 Pages",
  abstract =     "Rogue Java applets are currently a major concern for
                 big companies and private users alike. While the best
                 protection against them is to turn off Java support in
                 the WWW browser, this ``solution'' is unsatisfying: it
                 deprives users of many of the advantages of the Java
                 platform. Other mechanisms such as firewalls and code
                 signing have been proposed to ``enhance'' security. In
                 this paper we argue that these mechanisms cannot
                 deliver the security they promise. As an alternative,
                 we describe a simple yet effective way to prevent
                 untrusted applets from entering the user's computer. At
                 the same time, we allow trusted applets to execute in
                 whatever sandbox the browser provides for them. Our
                 technique works by modifying Java class loaders and can
                 be extended to provide fine-grained access control for
                 Java applets.",
}


@TechReport{Dubnicki97,
  author =       "Kai Li Cezary Dubnicki and Angelos Bilas and James
                 Philbin",
  title =        "Design and Implementation of Virtual Memory-Mapped
                 Communication on Myrinet",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-570-97",
  pages =        "22",
  year =         "February 1997; 9 Pages",
  abstract =     "This paper describes the design and implementation of
                 the virtual memory-mapped communication model (VMMC) on
                 a Myrinet network of PCI-based PCs. VMMC has been
                 designed designed and implemented for the SHRIMP
                 multicomputer where it delivers user-to-user latency
                 and bandwidth close to the limits imposed by the
                 underlying hardware. The goal of this work is to
                 provide an implementation of VMMC on a commercially
                 available hardware platform; to determine whether the
                 benefits of VMMC can be realized on the new hardware;
                 and to investigate network interface design tradeoffs
                 by comparing SHRIMP with Myrinet and its respective
                 VMMC implementation.\par Our Myrinet implementation of
                 VMMC achieves 9.8 microseconds one-way latency and
                 provides 108.4 MBytes per second user-to-user
                 bandwidth. Compared to SHRIMP, the Myrinet
                 implementation of VMMC incurs relatively higher
                 overhead and demands more network interface resources
                 (LANai processor, on-board SRAM) but requires less
                 operating system support.",
}


@TechReport{Finkelstein98,
  author =       "Adam Finkelstein and Marisa Range",
  title =        "Image Mosaics",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-574-98",
  pages =        "22",
  year =         "March 1998; 10 Pages",
  abstract =     "We describe a process for creating an image mosaic --
                 a collection of small images arranged in such a way
                 that when they are seen together from a distance they
                 suggest a larger image. To visually suggest the larger
                 form, the small images are arranged to match a large
                 picture as much as possible, and then their colors are
                 adjusted to better suggest the overall form.
                 Arrangement of the small images may be either manual or
                 automatic. Adjustment of the colors in the small image
                 to further suggest the larger picture is fully
                 automatic and employs a new color correction scheme
                 that generalizes traditional halftoning.",
}


@TechReport{Singh97,
  author =       "Dongming Jiang Jaswinder Pal Singh and Angelos Bilas
                 and Yuanyuan Zhou",
  title =        "Limits to the Performance of Software Shared Memory:
                 {A} Layered Approach",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-576-98",
  pages =        "22",
  year =         "November 1997; 14 Pages",
  abstract =     "Much research has been done in fast communication on
                 clusters and in protocols for supporting software
                 shared memory across them. However, the end performance
                 of applications that were written for the more proven
                 hardware-coherent shared memory is still not very good
                 on these systems. Three major layers of software (and
                 hardware) stand between the end user and parallel
                 performance, each with its own functionality and
                 performance characteristics. They include the
                 communication layer, the software protocol layer that
                 supports the programming model, and the application.
                 These layers provide a useful framework to identify the
                 key remaining limitations and bottlenecks in software
                 shared memory systems across clusters, as well as the
                 key areas where efforts might yield major performance
                 improvements. This paper performs such an integrated
                 study, using this framework of layers, for two types of
                 software shared memory systems: page-based shared
                 virtual memory (SVM) and fine-grained software systems.
                 \par For the two system layers (communication and
                 protocol), the focus of this study is on the
                 performance costs of basic operations in the layers
                 rather than on their functionalities (which bears
                 further research). This is possible because their
                 functionalities are now fairly mature. The less mature
                 applications layer is treated through application
                 restructuring. We examine the layers individually and
                 in combination, understanding their implications for
                 the two types of protocols and exposing the synergies
                 among layers. \par Our highest level conclusions are as
                 follows. (i) For currently achievable system parameters
                 the fine-grained and SVM approaches are competitive in
                 performance, at least at the scale we examine. (ii) For
                 the fine-grained approach, the most important layer to
                 improve is the communication layer. (iii) For SVM, all
                 three layers are important, and no one or even two of
                 them will do it all alone. (iv) There is substantial
                 synergy among layers, and the dependence on all three
                 rather than a single layer is in some ways a promising
                 sign, especially when that single layer is difficult to
                 improve.",
}


@TechReport{Skadron98,
  author =       "Kevin Skadron and Pritpal S. Ahuja and Margaret
                 Martonosi and Douglas W. Clark",
  title =        "Improving Prediction for Procedure Returns with
                 Return-Address-Stack Repair Mechanisms",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-577-98",
  pages =        "22",
  year =         "March 1998; 13 Pages",
  abstract =     "This paper evaluates several mechanisms for repairing
                 the return-address stack after branch mispredictions.
                 The return-address stack is a small but important
                 structure for achieving better control-flow prediction
                 accuracy and therefore better performance. But
                 wrong-path execution after mispredictions frequently
                 corrupts the return-address stack, making repair
                 mechanisms necessary. If the processor implements
                 multipath execution -- simultaneously executing both
                 sides of a branch -- the contention among different
                 paths makes the problem more severe.\par For
                 conventional, single-path processors, this paper
                 proposes saving both the top-of-stack pointer and the
                 top-of-stack contents for later restoration in case of
                 a misprediction. This simple technique achieves nearly
                 100\% hit rates and improves performance by up to 8.7\%
                 compared to a stack with no repair mechanism. For
                 multipath processors, providing each path with its own
                 return-address stack completely eliminates contention,
                 improving perforance by over 25\%.",
}


@TechReport{Skadron98a,
  author =       "Kevin Skadron and Pritpal S. Ahuja and Margaret
                 Martonosi and Douglas W. Clark",
  title =        "Branch Prediction, Instruction-Window Size, and Cache
                 Size: Performance Tradeoffs and Sampling Techniques",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-578-98",
  pages =        "22",
  year =         "April 1998; 38 Pages",
  abstract =     "Design parameters interact in complex ways in modern
                 processors, especially because out-of-order issue and
                 decoupling buffers sometimes allow latencies to be
                 overlapped. Tradeoffs among instruction-window size,
                 branch-prediction accuracy, and instruction- and
                 data-cache size can change as these parameters move
                 through different domains. For example, modeling
                 unrealistic caches can under- or over-state the
                 benefits of better prediction or a larger instruction
                 window. Avoiding such pitfalls requires understanding
                 how all these parameters interact.\par Because such
                 methodological mistakes are common, this paper provides
                 a comprehensive set of SimpleScalar simulation results
                 from SPECint95 programs, showing the interactions among
                 these major structures. In addition to presenting this
                 database of simulation results, major mechanisms
                 driving the observed tradeoffs are described. The paper
                 also considers appropriate simulation techniques when
                 sampling full-length runs with the SPEC reference
                 inputs.\par In particular, the results show that branch
                 mispredictions limit the benefits of larger instruction
                 windows, that better branch prediction and better
                 instruction cache behavior have synergistic effects,
                 and that larger instruction windows and larger data
                 caches trade off and have overlapping effects. In
                 addition, simulations of only 50 million instruction in
                 length can yield representative results if these short
                 windows are carefully selected.",
}


@TechReport{Bilas98,
  author =       "Angelos Bilas and Cheng Liao and Jaswinder Pal Singh",
  title =        "Network Interface Support for Shared Virtual Memory on
                 Clusters",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-579-98",
  pages =        "22",
  year =         "March 1998; 11 Pages",
  abstract =     "Clusters of symmetric multiprocessors (SMPs) are
                 important platforms for high performance computing. A
                 lot of research has been done in building network
                 interconnects and communication layers that deliver
                 low-latency and high-bandwidth communication to the
                 user. With the success of hardware cache-coherent
                 distributed shared memory (DSM), a lot of effort has
                 also been made to support the coherent shared address
                 space programming model in software on clusters.
                 However, performance is still far from that achieved on
                 hardware DSM systems.\par In this work we investigate
                 the use of mechanisms in the software communication
                 layer and the underlying network interface to
                 substantially enhance the performance of shared virtual
                 memory (SVM) on clusters of SMPs. We use a real
                 implementation with a programmable network interface as
                 our prototype, but our extensions are general-purpose
                 and can be provided by network interfaces that do not
                 employ a programmable processor.\par We examine how the
                 protocol layer can take advantage of each mechanism in
                 the communication layer and be restructured
                 accordingly. The final protocol (SVM-NI) eliminates the
                 need for interrupts and asynchronous protocol handling.
                 For each mechanism, we evaluate the impact on the end
                 performance of ten applications with widely varying
                 characteristics. We demonstrate that substantial
                 improvements in performance can indeed be achieved, and
                 find that different applications need different
                 mechanisms among the ones we use. Application
                 performance improves up to 50$\backslash$\% for
                 applications that end up with reasonably good speedups;
                 individual components of execution time targeted by
                 each mechanism are reduced by even higher percentages.
                 Finally, we use a firmware performance monitor,
                 integrated with the communication layer, to understand
                 the drawbacks of the system, to identify interesting
                 tradeoffs in the protocol layer for future exploration,
                 and to identify the remaining bottlenecks in SVM
                 performance that should be addressed next.",
}


@TechReport{Chen98,
  author =       "Yuqun Chen and Angelos Bilas and Stefanos Damianakis
                 and Cezary Dubnicki and Kai Li",
  title =        "{UTLB}: {A} Mechanism for Address Translation On
                 Network Interfaces",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-580-98",
  pages =        "22",
  year =         "June 1998; 12 Pages",
  abstract =     "An important aspect of a high-speed network system is
                 the ability to transfer data directly between the
                 network interface and the application buffers. Such a
                 direct data path requires the network interface to
                 ``know'' the virtual-to-physical address translation of
                 a user buffer, i.e., the physical memory location of
                 the buffer. This paper presents an efficient address
                 translation architecture, User-managed TLB (UTLB),
                 which eliminates system calls and device interrupts
                 from the common path of communication. With the UTLB
                 architecture, the network interface can translate a
                 virtual page address in 0.5 microseconds in the best
                 case. The average overhead of an address translation is
                 less than 2 microseconds under the heavy load of
                 multi-programming on a 4-way SMP. The paper describes
                 the design of the UTLB and its implementation as part
                 of a custom communication layer. Results from
                 micro-measurements and trace-driven analysis are given
                 to evaluate the effectiveness of the UTLB
                 architecture.",
}


@TechReport{Bilas98a,
  author =       "Angelos Bilas and Cezary Dubnicki and Stefanos
                 Damianakis and Yuqun Chen and Kai Li",
  title =        "Firmware Support for Reliable Communication and
                 Dynamic System Configuration in System Area Networks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-581-98",
  pages =        "22",
  year =         "June 1998; 9 Pages",
  abstract =     "Research efforts to provide fast multicomputer
                 interconnection networks for clusters of workstations
                 (SANs) at low cost has lead to the design of network
                 interfaces that support minimal standard functionality
                 in the network interface and use powerful basic blocks
                 that allow communication system designers to implement
                 the functionality needed by different paradigms and
                 systems using these basic blocks. These network
                 interfaces usually encompass a general purpose
                 processor, use simple switches to route packets to
                 their destination, and allow for arbitrary network
                 topologies. These characteristics result in the absence
                 of reliability in the network interface hardware and
                 the need to support routing for arbitrary, dynamic
                 topologies in the communication system.\par There are
                 many ways to deal with these problems. However, if
                 performance is not to be compromised, these problems
                 are highly non-trivial and many issues need to be
                 considered. Data copies need to be avoided, algorithms
                 and protocols need to be simple and memory requirements
                 must be low, since the network interface has
                 limitations in both network processor speed and
                 memory.\par In this work we address these two issues by
                 presenting the extensions we did to our communication
                 system, called Virtual Memory Mapped Communication
                 (VMMC), to support reliable communication in the
                 network interface and dynamic system configuration. We
                 propose and implement reliable communication in the
                 firmware that runs on the network interface processor
                 with minimal cost; less than 2.5 microseconds for
                 latency and less than 10\% for all different types of
                 bandwidth Moreover, we propose a new scheme for
                 dynamically determining the network topology. This
                 mechanism relies on the retransmission mechanism that
                 is used to provide reliable communication. Since the
                 support for dynamic system configuration is not on the
                 common path, there is no effect on system performance
                 when no changes in the system topology occur.",
}


@TechReport{Damianakis98,
  author =       "Stefanos N. Damianakis",
  title =        "Efficient Connection-Oriented Communication on
                 High-Performance Networks",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-582-98",
  pages =        "22",
  year =         "June 1998; 111 Pages",
  abstract =     "Network protocols have traditionally been implemented
                 in the kernel in order to provide protected
                 communication between processes. As gigabit network
                 fabrics become available, the kernel protocol stack
                 becomes a communication performance bottleneck,
                 affecting both latency and bandwidth. This dissertation
                 investigates how to use protected, user-level
                 communication mechanisms to support efficient,
                 connection-oriented communication.\par Most user-level
                 communication subsystems are designed for custom
                 communication models. To support fast user-level
                 communication, new network interfaces place incoming
                 data directly in user memory, at an address specified
                 by the sender. This capability enables the construction
                 of efficient communication subsystems since the network
                 interface can deliver messages without any software
                 intervention. Such communication subsystems do not
                 support connection-oriented communication well for two
                 reasons. First, direct data transfer does not provide
                 message detection as required by the
                 connection-oriented model, and second, sender-based
                 communication does not provide the anonymity of
                 receivers required by the connection-oriented
                 model.\par This dissertation studies how to support
                 efficient, user-level, connection-oriented
                 communication on high-performance networks. First, the
                 issue of message arrival detection for user-level
                 communication models is addressed. The traditional
                 approach uses interrupts to indicate the arrival of new
                 messages, which defeats the benefit of user-level
                 communication since a protection crossing is needed
                 with every message. To minimize the interrupt overhead,
                 a competitive mechanism that combines polling and
                 interrupts to efficiently detect the arrival of new
                 messages at user-level is proposed. Second, the
                 mismatch between connection-oriented APIs and
                 sender-based communication models is addressed. The
                 traditional approach requires receivers to copy
                 messages to their ultimate destinations, which are
                 unknown by senders. To enable zero-copy,
                 connection-oriented protocols, a mechanism that allows
                 the receiver to dynamically change the destination of a
                 message in a sender-based model is proposed.\par These
                 ideas were integrated into a user-level communication
                 model and evaluated using a stream sockets
                 implementation on two different multiprocessor
                 platforms. The results from experiments with benchmarks
                 and applications show that these techniques provide
                 significant performance improvements for user-level,
                 connection-oriented communication.",
}


@TechReport{Iftode98,
  author =       "Liviu Iftode",
  title =        "Home-based Shared Virtual Memory",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-583-98",
  pages =        "22",
  year =         "June 1998; 147 Pages",
  abstract =     "In this dissertation, I investigate how to improve the
                 performance of shared virtual memory (SVM) by examining
                 consistency models, protocols, hardware support and
                 applications. The main conclusion of this research is
                 that the performance of shared virtual memory can be
                 significantly improved when performance-enhancing
                 techniques from all these areas are combined.\par This
                 dissertation proposes home-based lazy release
                 consistency as a simple, effective, and scalable way to
                 build shared virtual memory systems. In home-based
                 protocols each shared page has a home to which all
                 writes are propagated and from which all copies are
                 derived. Two home-based protocols are described,
                 implemented and evaluated on two hardware and software
                 platforms: Automatic Update Release Consistency (AURC),
                 which requires hardware support for fine-grained remote
                 writes (automatic updates), and Home-based Lazy Release
                 Consistency (HLRC), which is implemented exclusively in
                 software.\par The dissertation investigates the impact
                 of memory-mapped network technology, in particular that
                 of automatic update support, on home-based protocol
                 design and performance. The performance evaluation of
                 HLRC and AURC prototypes implemented on SHRIMP, the
                 PC-based multicomputer built at Princeton, indicates
                 that memory-mapped communication can significantly
                 improve the efficiency of home-based protocols, and
                 that the automatic update support is an effective SVM
                 accelerator.\par The dissertation proposes a new memory
                 consistency model called Scope Consistency (ScC). ScC
                 offers most of the potential performance advantages of
                 entry consistency without requiring explicit
                 association between data and synchronization. A
                 simulation-based comparative evaluation of ScC and AURC
                 protocols shows that ScC reduces false sharing for
                 irregular applications with lock-based
                 synchronization.\par Finally, this dissertation
                 proposes a classification of parallel applications
                 which can serve as a framework for understanding the
                 performance of shared virtual memory protocols. This
                 classification derives from an analysis of the sharing
                 patterns induced by the interaction between the sharing
                 patterns inherent in the algorithm, and the coherence
                 granularity imposed by the protocol implementation. The
                 dissertation also includes an extensive
                 simulation-based performance evaluation of the
                 traditional LRC and AURC protocols on the Splash-2
                 application suite which uses the proposed
                 classification framework for performance
                 understanding.",
}


@TechReport{Kaplan98,
  author =       "Haim Kaplan and Robert E. Tarjan",
  title =        "Strictly Functional, Real-Time Deques with
                 Catenation",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-584-98",
  pages =        "22",
  year =         "June 1998; 37 Pages",
  abstract =     "We describe an efficient purely functional
                 implementation of deques with catenation. In addition
                 to being an intriguing problem in its own right,
                 functional implementation of catenable deques is the
                 tool required to add certain sophisticated programming
                 constructs to functional programming languages. Our
                 solution has a worst-case running time of {\it O}(1)
                 for each push, pop, inject, eject and catenation. The
                 best previously known solution has an {\it
                 O}(log$<$sup$>$*{\it k}$<$/sup$>$) time bound for the
                 {\it k}$<$sup$>$th$<$/sup$>$ deque operation. Our
                 solution is not only faster but simpler. A key idea
                 used in our result is an algorithmic technique related
                 to the redundant digital representations and to avoid
                 carry propagation in binary counting.",
}


@TechReport{Spatscheck98,
  author =       "Oliver Spatscheck and Larry Peterson",
  title =        "Defending Against Denial of Service Attacks in Scout",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-588-98",
  pages =        "22",
  year =         "August 1998; 25 Pages",
  abstract =     "We describe a two-dimensional architecture for
                 defending against denial of service attacks. In one
                 dimension, the architecture accounts for all resources
                 consumed by each I/O path in the system; this
                 accounting mechanism is implemented as an extension to
                 the path object in the Scout operating system. In the
                 second dimension, the various modules that define each
                 path can be configured in separate protection domains;
                 we implement hardware enforced protection domains,
                 although other implementations are possible. The
                 resulting system---which we call Escort---is the first
                 example of a system that simultaneously does end-to-end
                 resource accounting (thereby protecting against denial
                 of service attacks) and supports multiple protection
                 domains (thereby allowing untrusted modules to be
                 isolated from each other). The paper describes the
                 Escort architecture and its implementation in Scout,
                 and reports a collection of experiments that measure
                 the costs and benefits of using Escort to protect a web
                 server from denial of service attacks.",
}


@TechReport{Analysis98,
  author =       "Analysis",
  title =        "Speculative Updates of Local and Global Branch
                 History: {A} Quantitative",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-589-98",
  pages =        "22",
  year =         "December 1998; 33 Pages",
  abstract =     "Kevin Skadron, Margaret Martonosi, and Douglas W.
                 Clark In today's wide-issue processors, even small
                 branch-misprediction rates introduce substantial
                 performance penalties. Worse yet, inadequate branch
                 prediction creates a bottleneck at the fetch stage,
                 restricting other opportunities for improving
                 performance. The choice of how to predict
                 conditional-branch outcomes is the primary lever on
                 prediction accuracy. But the choice of
                 $<$i$>$when$<$$\backslash$i$>$ to update the predictor
                 with branch outcomes is a second powerful lever, and
                 the subject of this paper. In history-based predictors
                 like $<$i$>$gshare$<$/i$>$, many mispredictions result
                 from commit-time update of the history: typical
                 pipelined processors predict branches in the fetch
                 stage, but update the predictor in the commit stage,
                 making the predictor's state temporarily out-of-date.
                 As pipelines grow longer---in particular, when branches
                 can spend many cycles in the instruction window waiting
                 to issue---this problem becomes worse. Prior work on
                 this subject has discussed the need for speculative
                 update in a global-history-based predictor; this paper
                 evaluates speculative history update for both
                 global-history and local-history predictors of various
                 configurations, using cycle-level simulation to show
                 the effects of prediction accuracy and update time on
                 overall performance. The results show the importance of
                 speculative history update, but also that speculative
                 update requires suitable fixup mechanisms for repairing
                 state that has been corrupted by mispredictions. A
                 number of such mechanisms are discussed.",
}


@TechReport{Zhou99,
  author =       "Y. Zhou and L. Wang and D. Clark and K. Li",
  title =        "Thread Scheduling for Out-of-Core Applications with
                 Memory Server on Multicomputers",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-590-99",
  pages =        "22",
  year =         "January 1999, 11 Pages",
  abstract =     "Out-of-core applications perform poorly in paged
                 virtual memory (VM) systems because demand paging
                 involves slow disk I/O accesses. Much research has been
                 done on reducing the I/O overhead in such applications
                 by either reducing the number of I/Os or lowering the
                 cost of each I/O operation.\par In this paper, we
                 investigate a method combines fine-grained threading
                 with a memory server model to improve the performance
                 of out-of-core applications on multicomputers. The
                 memory server model decreases the average cost of I/O
                 operations by paging to remote memory, while the
                 fine-grained thread scheduling reduces the number of
                 I/O accesses by improving the data locality of
                 applications. We have evaluated this method on an Intel
                 Paragon with 7 applications. Our results show that the
                 memory server system performs better than the VM disk
                 paging by a factor of 5 for sequential applications and
                 a factor of 1.5 to 2.2 for parallel applications. The
                 fine-grained threading alone improves the VM disk
                 paging performance by a factor of 10 and 1.2 and 3
                 respectively for sequential and parallel applications.
                 Overall, the combination of these two techniques
                 outperforms the VM disk paging by more than a factor of
                 12 for sequential applications and a factor of 3 to 6
                 for parallel applications.",
}


@TechReport{Zhou99a,
  author =       "Y. Zhou and K. Li",
  title =        "Dynamic Join and Departure in Shared Object
                 Middlewares",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-592-99",
  pages =        "22",
  year =         "January 1999, 11 Pages",
  abstract =     "Collaborative applications are increasingly being
                 deployed to support interactions among widely
                 distributed users. Replication of state that enables
                 interaction among distributed users can be used to
                 provide acceptable response time in the presence of
                 high communication latencies. Recent research has
                 suggested using shared objects as the middleware for
                 developing collaborative applications to minimize
                 communication traffic. One of the key issues in using
                 shared objects middleware to support collaborative
                 applications is to allow nodes to dynamically join and
                 departure. This paper presents four methods to manage
                 distributed object directories in the presence of
                 dynamic join and departure operations in shared objects
                 middleware: full redistribution, master, indexed
                 hashing and on-demand indexed hashing. We have compared
                 these four schemes with four criteria: even
                 distribution, memory overhead, number of messages and
                 algorithm complexity. Among these four schemes, the two
                 indexed hashing schemes on average are better than the
                 other two schemes.",
}


@TechReport{Praun99,
  author =       "Emil Praun and Hugues Hoppe and Adam Finkelstein",
  title =        "Robust Mesh Watermarking",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-593-99",
  pages =        "22",
  year =         "January 1999; 21 Pages",
  abstract =     "Watermarking provides a mechanism for copyright
                 protection of digital media by embedding information
                 identifying the owner in the data. The bulk of the
                 research on digital watermarks has focused on media
                 such as images, video, audio, and text.\par Robust
                 watermarks must be able to survive a variety of
                 {"}attacks{"}, including resizing, cropping, and
                 filtering. For resilience to such attacks, recent
                 watermarking schemes employ a {"}spread-spectrum{"}
                 approach - they transform the document to the frequency
                 domain (e.g. using DCT) and perturb the coefficients of
                 the perceptually most significant basis functions. In
                 this paper we extend this spread-spectrum approach for
                 the robust watermarking of arbitrary triangle
                 meshes.\par Generalization of the spread spectrum
                 techniques to surfaces presents two major challenges.
                 First, arbitrary surfaces lack a natural
                 parametrization for frequency-based decomposition. Our
                 solution is to construct a set of scalar basis function
                 over the mesh vertices using a multiresolution analysis
                 of the mesh. The watermark is embedded in the mesh by
                 perturbing vertices along the direction of the surface
                 normal, weighted by the basis functions. The second
                 challenge is that attacks such as simplification may
                 modify the connectivity of the mesh. We use an
                 optimization technique to resample an attacked mesh
                 using the original mesh connectivity. Results
                 demonstrate that our watermarks are resistant to common
                 mesh processing operations such as translation,
                 rotation, scaling, cropping, smoothing, simplification,
                 and resampling, as well as malicious attacks such as
                 the insertion of noise, modification of low-order bits,
                 or even insertion of other watermarks.",
}


@TechReport{Skadron99,
  author =       "K. Skadron and M. Martonosi and D. W. Clark",
  title =        "Alloying Global and Local Branch History: Taxonomy,
                 Performance, and Analysis",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-594-99",
  pages =        "22",
  year =         "January 1999; 22 Pages",
  abstract =     "The need for accurate conditional-branch prediction is
                 well known; mispredictions waste large numbers of
                 cycles and also waste power on mis-speculated
                 computation. A number of studies have explored ways to
                 improve the prediction accuracy of two-level
                 predictors, but have considered exclusively global or
                 local history. Because most programs benefit from
                 having both global and local history available, other
                 work has proposed hybrid predictors that combine a
                 global-history with a local-history component.\par
                 Building on prior work that categorizes the types of
                 branch mispredictions, this paper presents a taxonomy
                 of mispredictions. Using the taxonomy, the paper shows
                 why a two-level predictor that $<$i$>$ alloys$<$/i$>$
                 local and global history in the same predictor index
                 provides superior performance. By making both types of
                 history available all the time, an alloyed scheme
                 obtains accuracies competitive with hybrid schemes,
                 even though organized like conventional two-level
                 predictors. Alloying has the advantage that it
                 eliminates the need to make a choice between
                 components, since the history types are merged. For
                 large predictors used in high-performance processors,
                 an alloyed organization provides competitive
                 performance that suffers less variation from program to
                 program than alternatives. For the smaller predictors
                 needed in space- and power-constrained environments,
                 alloying outperforms alternative organizations.",
}


@TechReport{Skadron99a,
  author =       "Douglas W. Clark Kevin Skadron and Margaret
                 Martonosi",
  title =        "Selecting a Single, Representative Sample for Accurate
                 Simulation of {SPEC}int Benchmarks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-595-99",
  pages =        "22",
  year =         "August 1999; 25 Pages",
  abstract =     "Detailed micro-architecture studies often require
                 time-consuming, cycle-accurate simulation.
                 Unfortunately, many benchmarks of interest, like the
                 SPEC benchmarks, run for tens of billions of
                 instructions and are prohibitive to simulate to
                 completion. Instead, researchers typically must confine
                 themselves to simulating samples of the program's
                 overall execution. This report presents detailed
                 interval-trace data about the SPECint programs'
                 branch-prediction and cache behavior. The report then
                 argues that accurate simulation results can be obtained
                 using a single, short simulation window of just 50
                 million instructions. They key to obtaining accurate
                 results is to choose this simulation window carefully,
                 and in particular to avoid unrepresentative behavior at
                 the beginning of programs' execution.",
}


@TechReport{Karlin99,
  author =       "Margaret Martonosi Scott C. Karlin and Douglas W.
                 Clark",
  title =        "SurfBoard - {A} Hardware Performance Monitor for
                 {SHRIMP}",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-596-99",
  pages =        "22",
  year =         "March 1999; 65 Pages",
  abstract =     "Growing complexity in many current computers makes
                 performance evaluation and characterization both
                 increasingly difficult and increasingly important. For
                 parallel systems, performance characterizations can be
                 especially difficult to obtain, since the hardware is
                 more complex, and the simulation time can be
                 prohibitive.\par This technical report describes the
                 design, implementation, and case studies of a
                 performance monitoring system for the SHRIMP
                 multicomputer. This system is based on a hardware
                 performance monitor which combines several features
                 including multi-dimensional histogram generation, trace
                 generation, and sophisticated triggering and interrupt
                 capabilities.\par Demonstrated in the case studies is
                 the direct measurement of an implicit form of
                 interprocessor communication implemented on the SHRIMP
                 multicomputer.",
}


@TechReport{Fang99,
  author =       "Wenjia Fang and Larry Peterson",
  title =        "Inter-{AS} Traffic Patterns and Their Implications",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-598-99",
  pages =        "22",
  year =         "March 1999; 20 Pages",
  abstract =     "This paper reports on a study of traffic patterns
                 among Autonomous Systems (ASes), based on traces taken
                 at various points in the Internet. The traces display a
                 highly non-uniform distribution of traffic on flows
                 between pairs of hosts, networks, and ASes. Aggregation
                 along coarser granularities, such as net works or ASes,
                 accentuates this non-uniform distribution. In one
                 typical trace, for example, the top 9\% of flows
                 between ASes accounts for 86.7\% of the pack ets and
                 90.7\% of the bytes transmitted. A highly non-uniform
                 traffic pattern sug gests that routers need to maintain
                 only limited QoS flow state. The paper discusses the
                 implications of this phenomenon on different proposed
                 QoS mechanisms.",
}


@TechReport{Fang99a,
  author =       "Wenjia Fang",
  title =        "Building An Accounting Infrastructure for the
                 Internet",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-599-99",
  pages =        "22",
  year =         "March 1999; 5 Pages",
  abstract =     "This paper explores the issues involved in providing
                 of an accounting infrastructure for the Internet. It
                 first argues that accounting, absent in the current
                 Internet architecture, is crucial to the success of the
                 Internet in the future. Then it focuses mainly on the
                 design issues involved in such provision. Finally, it
                 provides a possible scheme in implementing such an
                 accounting infrastructure.",
}


@TechReport{Clark99,
  author =       "David D. Clark and Wenjia Fang",
  title =        "Explicit Allocation of Best Effort Packet Delivery
                 Service",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-600-99",
  pages =        "22",
  year =         "March 1999; 30 Pages",
  abstract =     "This paper presents the {"}Allocated Capacity{"}
                 framework for providing different levels of best-effort
                 service in times of network congestion. The
                 {"}Allocated Capacity{"} framework - extensions to the
                 Internet protocols and algorithms - can allocate
                 bandwidth to different users in a controlled and
                 predictable way during network congestion. The
                 framework sup ports two complimentary ways of
                 controlling the bandwidth allocation: sender-based and
                 receiver-based. In today's heterogeneous and commercial
                 Internet, the framework can serve as a basis for
                 charging for usage, an more efficiently utilizing the
                 network resources.",
}


@TechReport{Fang99b,
  author =       "Wenjia Fang",
  title =        "The {"}Expected Capacity{"} Famework: Simulation
                 Results",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-601-99",
  pages =        "22",
  year =         "March 1999; 75 Pages",
  abstract =     "The current Internet uses the {"}best-effort{"}
                 service model, where the network tries to deliver
                 packets at best it can. The {"}best-effort{"} model
                 cannot meet the more sophisticated demand of emerging
                 applications, and mechanisms for creating different
                 levels of services are needed. The {"}Expected
                 Capacity{"} framework provides schemes for allocating
                 different band width to different users without
                 explicit setup or reservations. This report describes
                 the mechanisms proposed in this frame work, and
                 presents comprehensive simulation results for different
                 scenarios.",
}


@TechReport{Bavier99,
  author =       "Andy Bavier and Larry Peterson and David Mosberger",
  title =        "{BERT}: {A} Scheduler for Best Effort and Realtime
                 Tasks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-602-99",
  pages =        "22",
  year =         "March 1999; 12 Pages",
  abstract =     "We describe a new scheduler, called BERT, that runs
                 both best effort and realtime tasks on a multimedia
                 workstation. BERT exploits two innovations. First, it
                 extends the proportional share scheduling algorithm to
                 allow one task to dynamically steal cycles from
                 another. This mechanism allows BERT to address a main
                 drawback of scheduling MPEG video decoding using
                 proportional share: the difficulty of making the right
                 reservation. Second, BERT combines the stealing
                 mechanism with task importance to maintain QoS
                 guarantees in overload. In BERT, important realtime
                 tasks can steal to make deadlines and important best
                 effort tasks can be made immune from stealing. The
                 result is a graceful degradation of performance under
                 heavy load. We have implemented BERT in the Scout
                 operating system and we present our experiences using
                 it to schedule multimedia workloads.",
}


@TechReport{Bauer99,
  author =       "Lujo Bauer and Andrew Appel and Edward W. Felten",
  title =        "Mechanisms for Secure Modular Programming in Java",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-603-99",
  pages =        "22",
  year =         "July 1999; 13 Pages",
  abstract =     "We present a new module system for Java that improves
                 upon many of the deficiencies of the Java package
                 system and gives the programmer more control over
                 dynamic linking. Our module system provides explicit
                 interfaces, multiple views of modules based on
                 hierarchical nesting, and more flexible name-space
                 management than the Java package system. Relationships
                 between modules are explicitly specified in module
                 description files. We provide more control over dynamic
                 linking by allowing import statements in module
                 description files to require that imported modules be
                 annotated with certain properties, which we implement
                 by digital signatures. Our module system is compatible
                 enough with standard Java that we have implemented it
                 as a source-to-source and bytecode-to-bytecode
                 transformation wrapped around a standard Java
                 compiler.",
}


@TechReport{Skadron99b,
  author =       "Kevin Skadron",
  title =        "Characterizing and Removing Branch Mispredictions",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-604-99",
  pages =        "22",
  year =         "June 1999; 229 Pages",
  abstract =     "Control-flow mispredictions are a profound impediment
                 to processor performance, because each misprediction
                 introduces a pipeline bubble of many cycles' duration.
                 For example, the minimum bubble in the recently
                 released Alpha 21264 is at least seven cycles, and
                 often as much as twenty cycles. With such long
                 penalties, even small misprediction rates harm
                 performance substantially.\par Although a huge number
                 of techniques have been proposed to combat this
                 problem, most have focused on only one type of
                 misprediction: conflicts in the predictor's state
                 tables.\par This thesis describes a taxonomy of
                 misprediction types and presents data showing that
                 several other types of mispredictions are just as
                 important as conflicts. Techniques to attack three of
                 these misprediction types are then described. Alloying
                 makes both local and global history available in a
                 single branch predictor structure, providing robust
                 performance compared against both conventional
                 two-level predictors and against hybrid predictors.
                 Speculative update with fixup ensures that the
                 predictor's state remains up-to-date, while protecting
                 the state against corruption from mispredicted
                 branches. Finally, multipath execution simultaneously
                 executes both sides of a branch, eliminating
                 mispredictions for those branches that are otherwise
                 difficult to predict.\par This work also explores
                 tradeoffs among branch prediction, instruction window
                 size, data cache size, and instruction cache size, and
                 shows that branch prediction is the most powerful lever
                 on processor performance. \par This thesis makes one
                 further contribution, demonstrating that long
                 benchmarks can be simulated efficiently by simulating
                 only a small but carefully chosen 50 million
                 instruction segment of the program's overall execution.
                 This technique avoids unrepresentative initial phases
                 of a program and sets the simulation window to capture
                 behavior that is representative in terms of the
                 program's branch prediction accuracy, cache behavior,
                 and overall execution speed.",
}


@TechReport{Fang99c,
  author =       "Wenjia Fang and Larry Peterson",
  title =        "{TCP} mechanisms for Diff-Serv Architecture",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-605-99",
  pages =        "22",
  year =         "September 1999; 12 Pages",
  abstract =     "Our early work has shown that by using a combination
                 of mechanisms in a Diff-Serv domain: tagging algorithms
                 in boundary routers and a RIO algorithm in interior
                 routers, we could create differentiations in throughput
                 among different TCP connections during periods of
                 network congestion. However, the effectiveness of such
                 schemes is limited by the impreciseness and biases in
                 the window-based congestion control algorithm of TCP.
                 More precisely, TCP's window open-up algorithm has an
                 intrinsic bias against long \$rtt\$ connections, and
                 TCP's window close down mechanism adapts to the
                 perceived network congestion optimal point only, which
                 is not sufficient to meet the underlying premise of
                 Diff-Serv architecture.\par In this paper, we propose a
                 few mechanisms to TCP's congestion control algorithm,
                 specifically tailored to the Diff-Serv architecture.
                 While preserving TCP's ``linear increase and
                 multiplicative decrease'' principle, these mechanisms
                 make TCP more robust and precise in adjusting its
                 sending rate to network congestion as well as to a
                 pre-defined service profile. Simulations are used to
                 qualitatively demonstrate the results. In addition, we
                 discuss deployment issues.\par The changes require only
                 modifications to a TCP sender, and a TCP with these
                 changes is inter-operable with any existing TCP
                 implementations. The proposed mechanisms are
                 sufficiently general to be applicable to any
                 window-based congestion control algorithms.",
}


@TechReport{Skadron99c,
  author =       "Douglas W. Clark Kevin Skadron and Margaret
                 Martonosi",
  title =        "Alloyed Global and Local Branch History: {A} Robust
                 Solution to Wrong-History Mispredictions",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-606-99",
  pages =        "22",
  year =         "October 1999; 26 Pages",
  abstract =     "The need for accurate conditional-branch prediction is
                 well known: mispredictions waste large numbers of
                 cycles, inhibit out-of-order execution, and waste power
                 on mis-speculated computation. Prior work on
                 branch-predictor organization has focused mainly on how
                 to reduce conflicts in the branch-predictor structures,
                 while relatively little work has explored other causes
                 of mispredictions. Some prior work has identified other
                 categories of mispredictions, but this paper organizes
                 these categories into a broad taxonomy of misprediction
                 types. Using the taxonomy, this paper goes on to show
                 that other categories---especially wrong-history
                 mispredictions---are often more important than
                 conflicts. This is true even if just a very simple
                 conflict-reduction technique is used.\par Wrong-history
                 mispredictions arise because current two-level,
                 history-based predictors provide only global or only
                 local history. Their contribution to the overall
                 misprediction rate is substantial because most programs
                 have some branches that require global history and also
                 some that require local history. If only one or the
                 other type of history is available, many branches are
                 therefore penalized. For SPECint95 programs using a
                 global-history predictor, wrong-history mispredictions
                 account for 35--50\% of the total misprediction rate.
                 By comparison, conflicts only account for 15-20\%.
                 Hybrid predictors are one proposed solution; they use
                 both a global-history and a local-history component.
                 Unfortunately, hybrid predictors only work well with
                 large hardware budgets, because they must subdivide the
                 available area into subcomponents.\par Based on these
                 observations, this paper proposes alloying local and
                 global history together in a two-level branch predictor
                 structure. This is a simple but superior technique for
                 making global and local history simultaneously
                 available and eliminating wrong-history mispredictions.
                 Unlike hybrid prediction, alloying gives robust
                 performance for branch-predictor hardware budgets
                 ranging from very large to very small. Alloying also
                 consistently outperforms other two-level organizations.
                 In fact, a small alloyed predictor often performs as
                 well as a much larger global-history predictor.",
}


@TechReport{Appel99,
  author =       "Andrew W. Appel and Amy P. Felty",
  title =        "Lightweight Lemmas in Lambda Prolog (Extended
                 Version)",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-607-99",
  pages =        "22",
  year =         "October 1999; 26 Pages",
  abstract =     "Lambda Prolog is known to be well-suited for
                 expressing and implementing logics and inference
                 systems. We show that lemmas and definitions in such
                 logics can be implemented with a great economy of
                 expression. We encode a polymorphic higher-order logic
                 using the ML-style polymorphism of Lambda Prolog. The
                 terms of the metalanguage (Lambda Prolog) can be used
                 to express the statement of a lemma, and metalanguage
                 type-checking can directly type-check the lemma. But to
                 allow polymorphic lemmas requires either more general
                 polymorphism at the meta-level or a less concise
                 encoding of the object logic. We discuss both the Terzo
                 and Teyjus implementations of Lambda Prolog as well as
                 related systems such as Elf.\par A shorter version of
                 this paper is to appear in 16th International
                 Conference on Logic Programming, November 1999.",
}


@TechReport{Korn99,
  author =       "Jeffrey Korn",
  title =        "Abstraction and Visualization in Graphical Debuggers",
  institution =  "Department of Computer Science, Princeton University",
  type =         "Thesis",
  number =       "TR-608-99",
  pages =        "22",
  year =         "November 1999; 138 Pages",
  abstract =     "As computer systems become increasingly pervasive, the
                 size and complexity of software grows. An inevitable
                 consequence of such growth is the presence of software
                 errors, for which half of development time is spent
                 correcting. Debuggers facilitate tracking and
                 correcting errors by increasing the visibility of a
                 program. This thesis examines how debuggers can be
                 constructed that enhance visibility of software by
                 presenting programs at a higher level of abstraction.
                 In particular, we describe the construction of three
                 systems. The first system, Deet, addresses problems
                 that arise in the implementation of graphical
                 debuggers. It focuses on aspects of portability,
                 language-independence and complexity. Deet works with a
                 variety of operating systems, languages and
                 architectures by separating machine-dependent pieces of
                 the debugger into a minimal component called a nub. The
                 second system, Chava, provides visualization of object
                 code and can display relationships such as class
                 inheritance diagrams, call graphs, and module
                 dependencies. Chava also supports comparison between
                 two versions of a program, and is useful for reverse
                 engineering applications. The third system, TraVis,
                 provides visualization of program data in the debugger.
                 TraVis draws data structures using a technique called
                 traversal-based visualization, in which the user
                 defines how in-core objects are turned into on-screen
                 entities as they are traversed by the debugger. The
                 mappings make it possible to display data at a higher
                 semantic level without modification of source code.",
}


@TechReport{Wang99,
  author =       "Daniel C. Wang and Andrew W. Appel",
  title =        "Safe Garbage Collection = Regions + Intensional Type
                 Analysis",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-609-99",
  pages =        "22",
  year =         "October 1999; 11 Pages",
  abstract =     "We present a technique to implement type-safe garbage
                 collectors by combining existing type systems used for
                 compiling type-safe languages. We adapt the type
                 systems used in region inference and intensional type
                 analysis to construct a safe stop-and-copy garbage
                 collector for higher-order polymorphic languages.
                 Rather than using region inference as the primary
                 method of storage management, we show how it can be
                 used to implement a garbage collector which is provably
                 safe. We also introduce a new region calculus with
                 non-nested object life-times which is significantly
                 simpler than previous calculi. Our approach also
                 formalizes more of the interface between garbage
                 collectors and code generators. The efficiency of our
                 safe collectors are algorithmically competitive with
                 unsafe collectors.",
}


@TechReport{Ji99,
  author =       "Minwen Ji and Edward W. Felten",
  title =        "Design and Implementation of an Island-Based File
                 System",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-610-99",
  pages =        "22",
  year =         "October 1999; 27 Pages",
  abstract =     "We have built a distributed file system called
                 Archipelagic File System (APFS). APFS is distinct from
                 other file systems in its approach to failure isolation
                 and low-cost consistency maintenance. The building
                 blocks of APFS are smaller self-contained file servers
                 called islands. The main idea underlying APFS design is
                 the one-island principle: almost every atomic operation
                 should require the participation of exactly one island
                 or server. The one-island principle improves partial
                 reliability and availability because each island is
                 self-contained and therefore can function independently
                 of others' failures. The one-island principle allows an
                 archipelagic file system to scale well with the number
                 of islands and workloads because cross-island
                 communication and synchronization are minimized.
                 Reconfiguration (addition or removal of islands, or
                 dynamic load balancing) is efficient because it only
                 requires a minimal amount of data to be migrated
                 between islands. Existing file system structures cannot
                 satisfy the one-island principle. We built a new system
                 structure in which data is partitioned to servers at
                 directory granularity by hashing the pathnames of
                 directories.\par Experiments on the contents of five
                 existing file systems in use show that the hashing
                 algorithm in APFS can evenly distribute workload to
                 islands. Statistics and scalability measurements show
                 that on average 99.8\% of operations satisfy the
                 one-island principle and that performance of these
                 one-island operations scales efficiently with the
                 number of islands and workloads. A trace-driven study
                 of online reconfiguration for a web server running on
                 APFS shows that data migration during reconfiguration
                 is made transparent to the web server and imposes a
                 performance penalty of only 4.5\%.",
}


@TechReport{Bavier99a,
  author =       "Andy Bavier and Larry Peterson",
  title =        "The Role of Virtual Time in Real-time Scheduling",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-611-99",
  pages =        "22",
  year =         "December 1999; 12 Pages",
  abstract =     "The BERT scheduler is designed to schedule a mix of
                 best effort and real-time processes. BERT is based on
                 manipulating how tasks run in the fair queueing fluid
                 model and tracking the changes using virtual time. This
                 paper makes two contributions. First, it builds on
                 results in real-time scheduling to show two properties
                 of BERT: (1) important real-time tasks are schedulable
                 with regard to their finish times in the fluid model
                 and (2) unimportant tasks have bounded workahead. BERT
                 relies on these two properties when making scheduling
                 decisions. Second, it draws attention to the thread
                 that connects the fluid model and the BERT
                 implementation: $<$i$>$virtual time$<$/i$>$. Virtual
                 time is multifaceted and powerful abstraction and we
                 use our results for BERT to argue that it can form the
                 basis for designing, implementing, and analyzing new
                 real-time scheduling algorithms.",
}


@TechReport{Wang99a,
  author =       "Randolph Wang and Thomas E. Anderson and Yuqun Chen
                 and Arvind Krishnamurthy and Kai Li and Xiang Yu",
  title =        "Mimd{RAID}: Low Latency Secondary Storage",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-612-99",
  pages =        "22",
  year =         "September 1999; 16 Pages",
  abstract =     "Disk arrays can provide scalable bandwidth with
                 increasing number of disks, but they do not address
                 latency. In this paper, we study how to improve
                 secondary storage read latency by systematically
                 increasing the ratio between disk heads and usable
                 capacity. The most direct technique is to build
                 ``faster{"} disks by altering disk geometry. In
                 addition, as an alternative to building such disks, we
                 also describe how we can emulate these faster disks
                 using multiple conventional disks. We show that all
                 these techniques are governed by a common principle
                 that the overhead-independent part of the latency
                 improves by a factor of the square root of the amount
                 of extra resources. We evaluate some of these latency
                 reduction techniques on a prototype implementation
                 which we call MimdRAID. On a 12-disk system, for random
                 reads, we achieve a 2x improvement in latency and 21x
                 improvement in throughput compared to a single drive.
                 This is 80\% to 95\% better than the throughput
                 achieved on a conventional mirrored system.",
}


@TechReport{Fontoura99,
  author =       "Bernhard Rumpe Marcus Fontoura and Wolfgang Pree",
  title =        "{UML}-{F}: {A} Modeling Language for Object-Oriented
                 Frameworks",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-613-99",
  pages =        "22",
  year =         "December 1999; 22 Pages",
  abstract =     "The paper presents the essential features of a new
                 member of the UML language family that supports working
                 with object-oriented frameworks. This UML extension,
                 called UML-F, allows the explicit representation of
                 framework variation points. The paper discusses some of
                 the relevant aspects of UML-F, which is based on
                 standard UML extension mechanisms. A case study shows
                 how it can be used to assist framework development. A
                 discussion of additional tools for automating framework
                 implementation and instantiation rounds out the
                 paper.",
}


@TechReport{Fontoura99a,
  author =       "Marcus F. Fontoura and Carlos Jos{\'e} P. de Lucena",
  title =        "Using {UML}-{FW}, Refactoring, and Unification Rules
                 to Assist Framework Maintenance and Evolution",
  institution =  "Department of Computer Science, Princeton University",
  number =       "TR-614-99",
  pages =        "22",
  year =         "December 1999; 10 Pages",
  abstract =     "Although object-oriented software development has
                 experienced the benefits of using frameworks, a
                 thorough understanding of how to identify, design,
                 implement, and change them to meet evolving requirement
                 needs is still object of research. Therefore, framework
                 development is very expensive not only because of the
                 intrinsic difficulty related to capturing the domain
                 theory but also because of the lack of appropriate
                 methods and techniques to support framework design and
                 evolution. This paper proposes the use of the UML-FW
                 profile, together with refactoring and unification
                 rules to assist framework maintenance and evolution.",
}
