KL1(ID:1562/kl:001)Kernel Language 1Kernel Language 1. An experimental AND-parallel version of KL0 for the ICOT project, Japan. An implementation of FGHC. Related languages
References: in The Computer Journal 33(6) December, 1990 view details in The Computer Journal 33(6) December, 1990 view details in The Computer Journal 37(6) Special Issue on Distributed Operating Systems June 1994 view details in The Computer Journal 37(6) Special Issue on Distributed Operating Systems June 1994 view details in The Computer Journal 37(6) Special Issue on Distributed Operating Systems June 1994 view details The successful implementation of ICOT?s logic programming language KLl was attributed to its data-flow synchronization. According to T. Chikayama (in a personal communication), the majority of concurrent logic programming languages as described in Shapiro?s 1989 paper can be considered as data-flow languages, based on the fact that they use data-flow synchronization. Although these languages are thought of as data-flow languages, the synchronization is provided in software, and none of them has been implemented on a data-flow machine (at least not in Japan). in Annals of the History of Computing 16(4) Winter 1994 view details Kazunori Ueda, Takashi Chikayama, "Design of the kernel language for the parallel inference machine", Computer J., 33, #6, pp. 494-500. 1990, KL1 is the kernel language of the FGCS project; it is intended to allow logic programming on PIMs (Parallel Inference Machines). At first sight, KL1 seems Prolog-like, and it is introduced as such, but there are profound differences, the main one being that KL1 has no built-in resolution mechanism; it has unification of parameters, though. Several problems had to be solved to reach a form of Horn Clauses that would accommodate parallelism, synchronization, I/O and efficient implementation easily. KL1 clauses are protected by guards, which are in themselves goals; these goals in the guards are restricted to built-in predicates only. When a goal comes up for evaluation, all guards of all clauses of it are evaluated in parallel; the guards cannot instantiate variables, and if a guard needs the value of an uninstantiated variable, it blocks. If all goals in a guard succeed, the corresponding clause is available. If one or more guards succeed, one of the available clauses is chosen, and the goals in its body are evaluated in parallel; these goals .I can instantiate variables. The above assures that if an instantiation is made, it is never revoked. Output to other processes is done by making bindings visible to them (through shared variables) and input is done by accepting instantiation from outside. This design provides parallelism and synchronization, but robs the Horn Clauses of their search capability, since it precludes any form of backtracking. Consequently, KL1 is not a logic language in the normal sense of the word. To control and improve the efficiency, KL1 has a superimposed pragma language, the objects of which are the processes (goals being evaluated) described by the program. Processes can be manipulated (assigned to a processor; given a priority; etc.) singly or in groups. The latter are defined by the programmer and are called .I sho-en s. The pragmas do not affect the correctness and may be obeyed, delayed or ignored at the discretion of the OS. This separates program correctness from program optimization by parallelism. An instantiated variable is immutable, but to gain efficiency, KL1 has instructions to obtain a modified copy of a variable quickly. If no other process (= goal being evaluated) uses the variable, the variable is modified in situ, otherwise a copy is made. The paper describes the lines of reasoning that led to the design of KL1. Yasunori Kimura, Takashi Chikayama, "An abstract KL1 machine and its instruction set", in 1987 Symposium on Logic Programming, pp. 468-477. 1987, KL1 is flat guarded Horn clauses, i.e., Prolog with a point of no return in each right hand side. The code before the point of no return, the guard, may contain built-in predicates only. In reducing the goal, the guards of all of its alternatives are reduced in parallel (OR parallelism). For all that succeed, the guarded code is reduced in parallel (AND parallelism). The paper describes an interpreter which is structured in such a way that parts of it can be easily implemented in hardware. It is similar to the Warren machine. Extract: Review of language James R. McGraw, "The VAL language: description and analysis", ACM TOPLAS, 4, #1, pp. 44-82. Jan. 1982, VAL is a side effect free language, based on expressions and non-recursive functions. Normally the language is single-definition, but in a fairly complex for...do...iter construct redefinition is allowed to handle iteration. Its main features are explained using a single example, quad integration. in Annals of the History of Computing 16(4) Winter 1994 view details Resources
|