Honors Proposal
                           Jim Basney


Title     Distributed Implementation of the C-Linda Programming
          Language
          
Sponsor   Rich Salter
          
Abstract  Distributed systems provide a way for a programmer to
          write parallel programs without the need for a multi-
          processor machine; instead the available network of
          single-processor machines can be used.  Professor David
          Arnow (Brooklyn College) has developed an extension to
          the C programming language for distributed programming
          called DP.  I plan to develop an extension to DP,
          namely an implementation of the C-Linda programming
          language, such that a program written in C-Linda can be
          compiled to a distributed program with the inclusion of
          a header file (linda.h) and/or the invocation of a
          preprocessor or derivative C compiler (clc).
          
Narrative I worked with Professor Arnow during Winter Term 1994
          to implement large size message passing (fragmentation
          and assembly) in DP.  This gave me the opportunity to
          become familiar with the DP library.  Writing a C-Linda
          compiler has been a goal in the DP project, and David
          is pleased to have me do this as an honors project.  DP
          implements message passing, process spawning and
          control, and other routines for distributed
          programming.
          
          A first step in this project would be to compile and
          install DP on the Oberlin computer science network.
          There have been minor problems (i.e., compiler errors
          due to compiler compatibility issues) installing DP at
          Oberlin in the past; therefore, this is not a trivial
          first step.  However, it should be a very minor part of
          the project.
          
          Much of the project will involve writing library
          routines to implement C-Linda function calls in DP.
          The C-Linda language consists of the following
          functions: in(s), rd(s), inp(s), rdp(s), out(t),
          eval(t) where t is a tuple and s is an anti-tuple.
          However, the syntax for these function calls does not
          conform to standard C syntax.  Therefore, it may also
          be necessary to write a preprocessor or a derivative C
          compiler.  A preprocessor would make a pass through the
          source code, making changes to the code to conform to C
          syntax (and perhaps adding type and syntax
          information).  This is preferable to writing a
          derivative C compiler, i.e., modifying the gnu C
          compiler to accept C-Linda programs.
          
          If it happens that this project is more than I can
          complete in two semesters, I will implement a compiler
          for a subset of the C-Linda language, perhaps by
          requiring the user to specify additional information in
          Linda function calls and/or using a more C-like syntax
          for Linda function calls.  Although this is sub-
          optimal, I believe that a subset of the language would
          still provide some powerful additions to the C language
          for distributed programming.
          
          On the other hand, if I complete the above specified
          project early, I would like to explore performance
          comparisons between the distributed Linda system and a
          parallel system (for example, using C threads on Teddy,
          our 4 processor machine) to quantify some of the trade-
          offs between distributed and parallel, shared-memory
          systems.
          
          During my work I will be consulting C-Linda reference
          manuals and texts on parallel and concurrent
          programming, networks and operating systems.  Two texts
          that have been valuable in preparing this proposal are:
          
               Gelernter, David and Suresh Jagannathan.
                    Programming Linguistics.  Cambridge,
                    Massachusetts: The MIT Press, 1990.  Chapter
                    9: Parallel Languages.
               Carriero, Nicholas and David Gelernter.  How to
                    Write Parallel Programs: A First Course.
                    Cambridge, Massachusetts: The MIT Press,
                    1990.  Chapter 3: Basic Data Structures,
                    Appendix: C-Linda Reference Manual.
               
          I will also be in touch with Professor Arnow during the
          project with any questions I may have about the DP
          system.