Showing papers by "Jean-Luc Gaudiot published in 1991"

Advanced Topics in Data-Flow Computing

Abstract: A research monograph demonstrating the advances that have been made in data-flow computing since the basic principles were first introduced some 20 years ago. It also points out the immediate applications of this approach and assesses its future for large-scale multiprocessing.

Scalability analysis in gracefully-degradable large systems

Abstract: The scalability of large degradable homogeneous multiprocessors is analyzed. The objective is to assess the limitations, imposed by reliability considerations, on the number of processors. The analysis of the mean-time-to-failure and the mission-time shows that, for a given value of the coverage factor, there exists a value of the number of processors at which these measures are maximal. As the system size is increased beyond this value, the reliability of the system becomes a rapidly decreasing function of the number of processors. For computations with linear speed-up, the amount of reliable computational work is constant for large system-sizes. When the speed-up is not linear, this amount is a decreasing function of the number of processors. Therefore, for large system-sizes and same technology, increasing the number of processors results in a decrease of the average amount of reliable computational work the system can deliver. Graceful degradation in large fault-tolerant systems is not scalable. >

Input/output operations for hybrid data-flow/control-flow systems

Abstract: Hybrid data-flow/control-flow systems combine the advantages of the data-flow model: functionality and tolerance to communication and memory latencies with the efficient instruction scheduling of the control-flow model. The absence of global state in such hybrid multiprocessors and multiprocessors in general renders the implementation of state tasks such as input/output operations very difficult to implement. A distributed file-pointer scheme for incorporating I/O operations onto the data-flow model has been developed. A dependency detection algorithm detects and classifies cases of potential access conflicts. A conflict resolution data-flow graph is then created which at execution time safely distributes file-pointers to the I/O actors. This scheme has also been implemented on a hybrid data-flow control-flow multiprocessor: the decoupled data-driven multiprocessor with variable resolution actors. >

A macro actor/token implementation of production systems on a data-flow multiprocessor

Abstract: The importance of production systems in artificial intelligence has been repeatedly demonstrated by a number of expert systems. Much effort has therefore been expended on finding an efficient processing mechanism to process production systems. While data-flow principles of execution offer the promise of high programmability for numerical computations, we study here variable resolution actors, called macro actors, a processing mechanism for production systems. Characteristics of the production system paradigm are identified, based on which we introduce the concept of macro tokens as a companion to macro actors. A set of guidelines is identified in the context of production systems to derive well-formed macro actors from primitive micro actors. Parallel pattern matching is written in macro actors/tokens to be executed on our Macro Data-flow simulator. Simulation results demonstrate that the macro approach can be an efficient implementation of production systems.

Parallel processing of production systems on data-flow multiprocessors

Abstract: The importance of production systems in artificial intelligence has been repeatedly demonstrated by a large number of rule-based expert systems developed and used for the last decade. As the number and size of expert systems grow, there has however been an emerging obstacle in the processing of such an important application: the large match time. Much effort has been therefore expended on developing special algorithms and architectures dedicated to the efficient execution of production systems. This thesis presents methods to improve the processing time of production systems. In particular, two approaches are undertaken to reduce the matching time of an inference cycle: software approach in algorithm level and hardware approach in implementation level. Bottlenecks of the most widely used match algorithm have been identified, based on which a new algorithm, the MRN match algorithm, is developed in algorithm level. Experimental results of benchmark production systems indicate that the MRN match algorithm can give 4-6 fold speedup over the best match algorithm, regardless of the type of computer used. The MRN match algorithm can give a multiplicative effect when coupled with any match algorithm used for production systems. In implementation level, data-flow principles of execution have been employed as architectural models. A generic production system is implemented in micro actor data-flow principle to explore the parallelism in fine grain processing. Parallelism in the medium grain processing of production systems is explicated through the implementation of a production system in macro actor data-flow principle. Simulation results indicate that the data-flow multiprocessors can give 17 fold speedup out of 32 processing elements when coupled with the MRN match algorithm. The approaches taken in this thesis demonstrate that the data-flow principles of execution are not limited to numerical computation but also find applications in non-numeric computation. (Copies available exclusively from Micrographics Department, Doheny Library, USC, Los Angeles, CA 90089-0182.)

A scheme to extract run-time parallelism form sequential loops

Abstract: In some numerical simulation programs such as Comput ational Fluid Dynamics applications, it is quite common for program loop constructs to include array accessing statements which are themselves subscripted by another array. It is very difficult and in many cases impossible to detect parallelism by subscript analysis at compile time. The dat~flow model of computation is viewed as a good candidate for parallel processing due to its ability to exploit parallelism at run-time. The main purpose of this paper is to utilize data-flow principle in order to exploit run-time parallelism in the type of loops aforementioned. Due to its characteristics such as nonstrict operation and full functionality at the graph level, our proposed Token Relabeling method has the potential to be a good structure handling scheme in cases where array access patterns are very irregular.

Chaotic Linear System Solvers in a Variable-Grain Data-Driven Multiprocessor System

Abstract: Linear systems are important problems in many scientific applications. While asynchronous methods are effective solutions to linear systems, they are difficult to realize due to the chaotic behavior of the algorithms. In this paper, we investigate the implementation as well as the performance of an asynchronous method, namely chaotic relaxation, in our Variable-grain Tagged-Token Data-flow (VTD) System. We compare asynchronous methods with synchronous methods executed on both the fine-grain and the coarse-grain execution models. New high-level data-flow language constructs are introduced in order to express asynchronous operations. A new firing rule that deviates from the single assignment rule of functional languages is proposed to support the implementation of asynchronous computations in the VTD system. In addition to the conventional speedup measure, we then define new performance measurements, called Growth Factor, Scalability Factor, and Robustness to characterize the system performance from the machine and application viewpoints. Simulation results indicate that asynchronous methods are more efficient than synchronous methods and that the coarse-grain execution mode is more efficient that the fine-grain execution mode in our VTD system.