Kazuaki Rokusawa

Data-flow based execution mechanisms of Parallel and Concurrent Prolog

Study attempts to show that our machine architecture based on the data flow model is suitable for two types of logic programming languages with different aims: one is Parallel Prolog and the other is Concurrent Prolog. The data flow model can naturally implement parallel computation, and it has close similarity to these languages. Unification and nondeterministic control, two basic functions of these languages, are represented by data flow graphs and interpreted by the machine. Several representations of variables, that facilitate the development of parallel unification and nondeterministic control mechanisms for these languages, the unification and control primitives needed to execute these languages on this architecture are presented.

The architecture and preliminary evaluation results of the experimental parallel inference machine PIM-D

A parallel inference machine based on the dataflow model and the mechanisms to support two types of logic programming languages are presented. The machine is constructed from multiple processing elements and structure memories interconnected through a low-latency hierarchical network. The preliminary evaluation results of the experimental machine are also presented. The evaluation results show that the machine can exploit parallelism in programs.

A new external reference management and distributed unification for KL1

This paper describes a new external reference management scheme for KL1, a committed choice logic programming language based on GHC. The significance of the new scheme is that it realizes incremental inter-processor garbage collection. Previous distributed implementations of committed choice languages had not seriously addressed inter-processor garbage collection.Incremental inter-precessor garbage collection is realized by the Weighted Export Counting (WEC). It is a first attempt to use the weighted reference counting technique in logic programming language implementation, and is also new in that it has introduced export and import tables for making independent local garbage collection possible and reducing the number of inter-processor read requests.The problems with exhaustion of reference counts and indirect exportation are discussed. Since the binding order rule adopted in our previous implementation for avoiding creation of reference loops is insufficient in the presence of indirect exportation, a new binding order rule is introduced. We prove that avoidance of reference loops is guaranteed and also prove that the unification procedure always terminates for non-circular structures.

Distributed memory implementation of KLIC

This paper describes external reference management and distributed unification in a distributed implementation of a concurrent logic programming language KL1. This implementation is based on the KLIC system. KLIC has a feature calledgeneric objects that enable easy modification and extension of the system without changes in the core implementation. This distributed implementation is built upon the same core and external references are represented using generic objects. Unification operations are defined as methods of generic objects. Since creation of interprocessor reference loops cannot be avoided, we studied a new unification scheme that can cope with interprocessor reference loops. We built several experimental distributed systems that all demonstrate reasonable efficiency.

A scheme for state change in a distributed environment using weighted throw counting

This paper proposes a scheme for changing the execution state of a pool of processes in a distributed environment where there may be processes in transit. The scheme can detect the completion of state change using weighted throw counting and detect the termination as well. It works whether the communication channels are synchronous or asynchronous, FIFO or non-FIFO. The message complexity of the scheme is typically O(number of processing elements).<<ETX>>

The parallel logic programming system in the FGCS project and its future directions

Abstract In the fifth generation computer systems (FGCS) project, a parallel logic programming language, KL1, was adopted as the projects kernel language. It was not only used to determine architectures of highly parallel machines called parallel inference machines (PIMs) consisting of about 1000 element processors but also used as a system description language to develop basic software such as a parallel operating system (PIMOS), and symbolic processing and knowledge processing application systems such as knowledge description languages, a parallel theorem prover, and a protein sequence analysis program. It achieved great success in exploiting of parallelism involved in several important application systems. The prototype of the FGCS attained a linear speed-up that was proportional to the number of processing elements (PEs) for the application systems we had targeted. The MGTP parallel theorem prover was one of such application systems, and can prove theorems based on full first-order logic. Thus, it indicates the possibility of designing a new practical knowledge representation language whose expressive power will be much greater than that of conventional ones. In the FGCS follow-on project, KL1 and its programming system were ported to Unix-based stock parallel machines. This new system called KLIC is expected to greatly extend the use of highly parallel systems.

Quiescence Detection in a Distributed KLIC Implementation

Quiescence detection is a fundamental facility for parallel and distributed processing. This paper describes schemes for quiescence detection in a distributed KLIC implementation. KLIC is a portable implementation of concurrent logic programming language KL1. Termination is detected using the weighted throw counting (WTC) scheme. Based on the scheme a scheme for global suspension was invented. The postmortem system built-in predicate which provides meta programming facilities was designed, and its distributed implementation is also presented.