Clémentin Tayou Djamegni

Derivation of systolic algorithms for the algebraic path problem by recurrence transformations

Abstract In this paper, we are interested in solving the algebraic path problem (APP) on regular arrays. We first unify previous contributions with recurrence transformations. Then, we propose a new localization technique without long-range communication which leads to a piecewise affine scheduling of 4 n + Θ (1) steps, where n is the size of the problem. The derivation of a locally connected space-time minimal solution with respect to the new scheduling constitutes the second contribution of the paper. This new design requires n 2 /3+ Θ ( n ) elementary processors and solves the problem in 4 n + Θ (1) steps, and this includes loading and unloading time. This is an improvement over the best previously known bounds.

A parallel algorithm for lattice construction

The construction of the concept lattice of a context is a time consuming process. However, in many practical cases where FCA has proven to provide theoretical strength, e.g., in data mining, the volume of data to analyze is huge. This fact emphasizes the need for efficient lattice manipulations. The processing of large datasets has often been approached with parallel algorithms and some preliminary studies on parallel lattice construction exist in the literature. We propose here a novel divide-and-conquer (D&C) approach that operates by data slicing. In this paper, we present a new parallel algorithm, called DAC-ParaLaX, which borrows its main operating primitives from an existing sequential procedure and integrates them into a multi-process architecture. The algorithm has been implemented using a parallel dialect of the C ++ language and its practical performances have been compared to those of a homologue sequential algorithm.

A Cost-Optimal Pipeline Algorithm for Permutation Generation in Lexicographic Order

In this paper we solve the open problem of designing a cost-optimal parallel algorithm for generating permutations ofMelements out of the set {0, 1, ?,N? 1}, in lexicographic order. Our algorithm runs on the simplest model of parallel computation, i.e., a linear array of sizeM, where each processor PE(i) needs only a constant number of words of length logN, and is responsible for producing with constant delay, theith components in the successive permutations. This algorithm runs in timeO(N!/(N?M)!) on an array of sizeMand is therefore cost-optimal when the time needed to output the permutations is taken into account. Moreover, by doubling the number of cells, it is possible to implement this algorithm on a unidirectional linear array.

Scheduling of the dag associated with pipeline inversion of triangular matrices

We are interested in methods which compute the inverse of a triangular matrix A of order n by solving the n linear systems Ax=ei, i=1,…, n, where ei is the i-th element of the canonical basis of Rn. More precisely, we consider the dependence graph associated with algorithms where the entries of matrix A are read only once and used in pipeline for the solution of these systems. We exhibit a new scheduling which induces an algorithm with time complexity T*=2n−1. The number n2/8+O(n) of processors required by this scheduling improves the best previously known bound n2/6+O(n), and is quite close to the lower bound n2/8.5+O(n).

Mapping rectangular mesh algorithms onto asymptotically space-optimal arrays

This paper deals with the systematic synthesis of space optimal arrays. As a target example, an asymptotically space-optimal array for Nx × Ny × Nz rectangular mesh algorithms with affine schedule ai + bj + ck + d is designed. The obtained bound improves the best previously known ones. The key idea underlying our approach is to compress the initial index domain along a number of directions in order to obtain a new domain that is more suitable for the application of projection methods.

Parallel computation of closed itemsets and implication rule bases

Formal concept analysis has been successfully applied as a data mining framework whereby target patterns come in the form of intent families and implication bases. Since their extraction is a challenging task, especially for large datasets, parallel techniques should be helpful in reducing the computational effort and increasing the scalability of the approach. In this paper we describe a way to parallelize a recent divide-and-conquer method computing both the intents and the Duquenne-Guiges implication basis of dataset. Wile intents admit a straightforward computation, adding the basis--whose definition is recursive-- poses harder problems, in particular, for parallel design. A first, and by no means final, solution relies on a partition of the basis that allows the crucial and inherently sequential step of redundancy removal to be nevertheless split into parallel subtasks. A prototype implementation of our method, called PARCIM, shows a nearly linear acceleration w.r.t. its sequential counter-part.

A reindexing based approach towards mapping of DAG with affine schedules onto parallel embedded systems

We address the problem of optimally mapping uniform DAGs to systolic arrays, given an affine timing function. We introduce an automatic allocation method based on a preprocessing by reindexing that transforms the initial DAG into a new one that enables the well known projection method to minimize the number of processors along a number of directions. We demonstrate its superiority to other methods, and establish the space-optimality of the proposed method. We also show an upper bound on the number of processors that corresponds to the best space complexity that both the projection method, and the so-called grouping method can give for the initial DAG. We also describe how the new allocation method can be implemented in tools.

Complexity of matrix product on modular linear systolic arrays for algorithms with affine schedules

This paper investigates the computation of matrix product on both partially pipelined and fully pipelined modular linear arrays. These investigations are guided by a constructive and unified approach for both target architectures. First, permissible affine input functions are identified by a set of necessary and sufficient conditions for various conflict avoidance. This first study also leads to complexity results. Then, algorithms whose performance represents an improvement over the best previously known bounds are exhibited.

A NEW ALGORITHM FOR DYNAMIC PROGRAMMING ON REGULAR ARRAYS

ABSTRACT Given the real entries w(i, j), 1< i < j <n, and c(i, i+1), 1< i <n, the dynamic programming problem studied here consists of computing the coefficients c(i, j)=w(i, j) + nti* i<k<j {c(i, k) + c(k, j)}, for 1< i<j< n. We show that this problem can be solved in optimal time T*=2n-1 on a regular array of size n/10 + 0(n). The number of processors required by this new algorithm improves the best previously known bound n/10 + O(n). The idea introduced here is to apply to the dependence graph associated with the problem a pre-processing that removes long-range communications in order to obtain a new locally connected graph which is suitable for the application of powerful allocation techniques.