Paris(ID:2338/par030)

CM Assembler 

PARallel Instruction Set. Low-level language for the Connection Machine.
Related languages
Paris => *LISP   Targetting
Paris => C*   Targetting
Paris => CM Fortran   Targetting
References:
  • Hilils, W Daniel "The Connection Machine" The MIT Press,Cambridge MA 1985 view details
  • Connection Machine CM200 Series Technical Summary- Technical report Thinking Machines Corporation Cambridge MA June 1991 view details
  • Schauble, C. J. C. "The Connection Machine CM: An Introduction" High Performance Scientific Computing University of Colorado at Boulder September 1993 view details Extract: CM Languages
    One of the original purposes of the computer was artificial intelligence - the eventual goal was a "thinking machine" Each processor was only a one      bit processor. The idea was to provide one processor per pixel for image processing, one processor per transistor for VLSI simulation, or one processor per concept for semantic networks.
    The first high-level language implemented for the machine was *Lisp, a parallel extension of Lisp. In fact, the design of portions of the *Lisp language are discussed in the Hillis dissertation.
    However, as the first version of this supercomputer came onto the market, TMC discovered that there was also significant interest - and money - for supercomputers that could be used for numerical and scientific computing.
    Hence, a faster version of the machine came out in 1987 called the CM-1; this was the first of the CM series of computers. It included floating-point hardware, a faster clock, and increased the memory to 64K bits per processor. These models emphasised the use of data parallel programming. Both C* and CM Fortran were available on this machine, in addition to *Lisp. Extract: PARIS operations
    The language Paris (PARallel Instruction Set) is used to express the parallel operations that are to be run on the PPU. All *Lisp, CM Fortran or C* parallel commands are compiled into Paris instructions. Such operations include parallel arithmetic operations (both floating-point and fixed), vector summation (and other reduction operations), sorting, and matrix multiplication.
    [...]
    A sequencer receives Paris instructions from the FE and breaks them down into a sequence of low-level instructions which can be handled by the one-bit processors. When that is done the sequencer broadcasts these instructions to all the processors in its section. Each processor then executes the instructions in parallel with the other processors. When the execution of low-level instructions is completed, control is returned to the FE. Used independently, each section sets up its own grid layout for computation and communication for each array; if the sections are grouped together, one grid per array is laid over all the processors. These grids may be altered dynamically during the execution of the program.