Jong-Chuang Tsay

Design of efficient regular arrays for matrix multiplication by two-step regularization

A two-step regularization method in which first permutation sequences and then broadcast planes are selected is proposed to design various regular iterative algorithms for matrix multiplication. The regular iterative algorithms are then spacetime mapped to regular arrays, such as mesh, cylindrical, two-layered mesh, and orbital arrays. The proposed method can be used to design regular arrays with execution time of less than N (problem size). >

Some new designs of 2-D array for matrix multiplication and transitive closure

We present some new regular iterative algorithms for matrix multiplication and transitive closure. With these algorithms, by spacetime mapping the 2-D arrays with 2N-1 and upper bound [(3N-1)/2] execution times for matrix multiplication can be obtained. Meanwhile, we can derive a 2-D array with 4N-2 execution rime for transitive closure based on the sequential Warshall-Floyd algorithm. All these new 2-D arrays for matrix multiplication and transitive closure have the advantages of faster and more regular than other previous designs. >

Design of space-optimal regular arrays for algorithms with linear schedules

The problem of designing space-optimal 2D regular arrays for N/spl times/N/spl times/N cubical mesh algorithms with linear schedule ai+bj+ck, 1/spl les/a/spl les/b/spl les/c, and N=nc, is studied. Three novel nonlinear processor allocation methods, each of which works by combining a partitioning technique (gcd-partition) with different nonlinear processor allocation procedures (traces), are proposed to handle different cases. In cases where a+b/spl les/c, which are dealt with by the first processor allocation method, space-optimal designs can always he obtained in which the number of processing elements is equal to N/sup 2c. For other cases where a+b>c and either a=b and b=c, two other optimal processor allocation methods are proposed. Besides, the closed form expressions for the optimal number of processing elements are derived for these cases. >

A systolic design for generating permutations in lexicographic order

Abstract In this paper, we shall design a systolic algorithm for generating all N! permutations of N objects. The algorithm is time efficient, generates all permutations in lexicographic order, and can be execuded on a simple computation model (systolic array). Futhermore, because the algorithm is systolic, it is suitable for VLSI implementation.

A systolic generation of combinations

A parallel algorithm for generating all combinations ofm (m fixed) items out of anyn given items in lexicographic order is presented. The computational model is a linear systolic array consisting ofm identical processing elements. This algorithm requires {ie23-1} time-steps for the {ie23-2} combinations, that is, one output at each time-step. Since all processing elements perform the same program, it is suitable for VLSI implementation. Based on mathematical induction, such an algorithm is proved to be correct.

A family of efficient regular arrays for algebraic path problem

The method of decomposing a dependence graph into multiple phases with an appropriate m-phase schedule function is useful for designing faster regular arrays for matrix multiplication and transitive closure. In this paper, we further apply this method to design several parallel algorithms for the algebraic path problem and derive N/spl times/N 2D regular arrays with execution times [9N/2]-2 (for the cylindrical array and the orthogonal one) and 4N-2 (for the spherical one). >

Some combinatorial aspects of parallel algorithm design for matrix multiplication

Some combinatorial characteristics of matrix multiplication on regular two-dimensional arrays are studied. From the studies, the authors are able to design many efficient varieties of the cylindrical array and the two-layered mesh array for matrix multiplication. To design a cylindrical array for matrix multiplication, a systematic design procedure is proposed. In this design procedure, Latin square (a special type of matrix) plays an important role. To design a two-layered mesh array, it is found that there is a transformation procedure to transform a cylindrical array to a two-layered mesh array. >

AN OPTIMAL SYSTOLIC ALGORITHM FOR THE SET PARTITIONING PROBLEM

Generating set partitions is frequently necessary in combinatorial algorithms. In this paper, we shall utilize Moldovans space-time mapping methodology to design a systolic algorithm for the set partitioning problem. The algorithm is cost-optimal design and can generate all set partitions in lexicographic order. Since it can be run on a linear systolic array, it is very amenable to VLSI implementation.

Designing Lower-Dimensional Regular Arrays for Algorithms with Uniform Dependencies

In this paper, we will propose a polynomial-time method to designm-dimensional regular arrays forn(n?m+ 1) dimensional algorithms with uniform dependencies, regular algorithms. The proposed method has two steps: the first one is to transform an independently partitioned regular algorithm to a new one, which has an identity dependence matrix. We call this stepidentity transformation, which is an affine one. In the second step, we propose a spacetime mapping in a fixed form to map the new regular algorithm to a lower-dimensional regular array. Thus, anaffine spacetime mappingis constructed by combining the identity transformation and the fixed forms spacetime mapping together. With the proposed affine spacetime mapping, the original regular algorithm can be mapped to a lower-dimensional regular array in polynomial time, which depends only on the number of dimensions of the regular algorithm. Meanwhile, the designed regular array is asymptotically optimal in time and space.

An optimal parallel algorithm for generating permutations in minimal change order

Permutation generation is an important problem in combinatorial computing. In this paper we present an optimal parallel algorithm to generate all N! permutations of N objects. The algorithm is designed to be executed on a very simple computation model that is a linear array with N identical processors. Because of the simplicity and regularity of the processors, the model is very suitable for VLSI implementation. Another advantageous characteristic of this design is that it can generate all the permutations in minimal change order.