Gyula A. Mago

A network of microprocessors to execute reduction languages, part I

This paper describes the architecture of a cellular processor capable of directly and efficiently executing reduction languages as defined by Backus. The processor consists of two interconnected networks of microprocessors, one of which is a linear array of identical cells, and the other a tree-structured network of identical cells. Both kinds of cells have modest processing and storage requirements. The processor directly interprets a high-level language, and its efficient operation is not restricted to any special class of problems. Memory space permitting, the processor accommodates the unbounded parallelism allowed by reduction languages in any single user program; it is also able to execute many user programs simultaneously.

Monotone Functions in Sequential Circuits

This paper is concerned with the problem of realizing an arbitrary syndconous or asynchronous sequential machine using only monotone AMR (or decreasing) switching functions. It has been found that h ion always exist, that in the asynchronous case only nomal fundamental mode flow tables are considered. Univesl state assignmments resulting in monotone inceasing (or next-state funtions are characterized using the concept of an (i,j) completely separating system.

Realization Methods for Asynchronous Sequential Circuits

This paper gives a unified approach for describing various systematic ways of using built-in delays in normal fundamental mode circuits. The transition of the circuit from one total stable state to another is characterized by the constraints imposed upon the next-state functions, and the realization method is characterized by the conditions under which these constraints can be satisfied simultaneously.

Data sharing in an FFP machine

The possibility of expressing data sharing in FPs is discussed. The Paterson-Wegman unification algorithm is considered, in which data sharing is indispensable to achieve efficient (linear time) execution. An FP implementation of this algorithm is shown to execute in linear time on an FFP machine. “Associative” versions of some of Backuss FP functions and combining forms appear to be very useful in dealing with irregular data objects such as graphs.

Copying operands versus copying results: A solution to the problem of large operands in FFP'S

In functional programming languages with reduction semantics, operators “use up” their operands to produce their results. This makes it difficult to execute efficiently certain computations, such as one in which several operators are applied—in succession or in parallel—to a large operand. The problem is that providing each operator with a separate copy of the large operand is a costly operation in most computer models. This paper proposes a solution to this problem in the context of a cellular computer that directly executes FFPs. The operators involved are applied in succession to the large operand, and only their results (with the exception of that of the last operator applied) need be moved. Providing each operator with a fresh copy of the large operand incurs no overhead in time. The proposed solution often allows one to avoid unproductive copying, and to suppress parallelism when it does not pay. The functional forms conditional, WHILE loop and construction are among the examples discussed. For example, when executing the conditional usually both the predicate and one of the “arms” of the conditional are applied to the operand. Since the result of the predicate computation is small, the overhead in the execution time of the conditional is negligible. A recursive matrix multiplication program described by Backus uses conditional and construction extensively. The proposed implementation technique reduces the execution time of this program on the cellular computer in question from O(n3) to O(n2).

Minimizing maximum flows in linear graphs

We define a linear graph to be a connected acyclic graph each of whose nodes is of degree one or two. We consider a flow problem in linear graphs in which a commodity flows from source nodes to sink nodes. Each source node has a specified value denoting an amount of a commodity to be disposed of and each sink node has a specified capacity denoting the maximum amount of the commodity it can absorb; edges are capable of carrying an arbitrary quantity of the commodity. A solution is a set of flows which transports the commodity from all source nodes to sink nodes without overfilling any sink. A solution is defined to be optimal if it is minimax, that is, the largest flow along any edge is as small as possible. We describe 0(n2) and 0(n) algorithms for finding optimal solutions.