David S. Greenberg

Optimal embeddings of butterfly-like graphs in the hypercube

We present optimal embeddings of three genres of butterfly-like graphs in the (boolean) hypercube; each embedding is specified via a linear-time algorithm. Our first embedding finds an instance of the FFT graph as a subgraph of the smallest hypercube that is big enough to hold it; thus, we embed then-level FFT graph, which has (n+1)2n vertices, in the (n+⌈log2(n+1)⌉)-dimensional hypercube, with unit dilation. This embedding yields a mapping of the pipelined FFT algorithm on the hypercube architecture, which is optimal in all resources (time, processor utilization, load balancing, etc.) and which is on-line in the sense that inputs can be added to the transform even during the computation. Second, we find optimal embeddings of then-level butterfly graph and then-level cube-connected cycles graph, each of which hasn2n vertices, in the (n+⌈log2n⌉)-dimensional hypercube. These embeddings, too, have optimal dilation, congestion, and expansion. The dilation is 1+(n mod 2), which is best possible. Our embeddings indicate that these two bounded-degree approximations to the hypercube do not have any communication power that is not already present in the hypercube.

Routing multiple paths in hypercubes

We present new techniques for mapping computations onto hypercubes. Our methods speed up classical implementations of grid and tree communications by a factor of Θ(n), wheren is the number of hypercube dimensions. The speedups are asymptotically the best possible.

Tight Bounds for On-Line Tree Embeddings

Many tree–structured computations are inherently parallel. As leaf processes are recursively spawned they can be assigned to independent processors in a multicomputer network. To maintain load balance, an on–line mapping algorithm must distribute processes equitably among processors. Additionally, the algorithm itself must be distributed in nature, and process allocation must be completed via message–passing with minimal communication overhead. This paper investigates bounds on the performance of deterministic and randomized algorithms for on–line tree embedding. In particular, we study tradeoffs between performance (load–balance) and communication overhead (message congest ion). We give a simple technique to derive lower bounds on the congestion that any on–line allocation algorithm must incur in order to guarantee load balance. This technique works for both randomized and deterministic algorithms, although we find that the performance of randomized on-line algorithms to be somewhat better than that of deterministic algorithms. Optimal bounds are achieved for several networks including multi–dimensional grids and butterflies.

Efficient wiring of reconfigurable parallel processors

Chips (or chip sets) which include one or more CPUS, some local memory, and rudimentary communications and routing hardware are becoming common (eg. transputers, SRCS HNet, thenodes ofmost MIMD machines). These chips provide the possibihty of tailoring the topology of a machine to a particular problem. Rather than asking thestandardquestion of how to best coerce one’s algorithm to fit an existing topology, one can ask what would be the best topology for the algorithm. This paper defines the efficiency of a topology for an algorithm and gives upper and lower bounds on the best efficiency achievable (as a function of the number of different communication patterns used by the algorithm). This approach is then applied to algorithms which use stencil patterned communications. The result is the definition of topologies which are significantly more efficient than the naive topology.

Traversing Directed Eulerian Mazes (Extended Abstract)

Two algorithms for threading directed Eulerian mazes are described. Each of these algorithms is performed by a traveling robot whose control is a finite-state automaton. Each of the algorithms puts one pebble in one of the exits of every vertex. These pebbles indicate an Eulerian cycle of the maze. The simple algorithm performs O(|V|·|E|) edge traversals, while the advanced one traverses every edge three times. Both algorithms use memory of size O(log dout(v) in every vertex v.