[398] in I/T Delivery
Rocklyn Clarke speaking about CMS Pipes on Thu, 14-Dec-2000
daemon@ATHENA.MIT.EDU (David M. Rosenberg)
Wed Dec 6 10:37:42 2000
Message-Id: <4.3.2.7.2.20001206103919.00b641f8@po9.mit.edu>
Date: Wed, 06 Dec 2000 10:40:09 -0500
To: delivery@mit.edu
From: "David M. Rosenberg" <Rosenberg@MIT.EDU> (by way of Robert Ferrara <rferrara@mit.edu>)
Mime-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
FYI.
Cheers, Bob
-----------------------
DATE: Thursday, 14 December 2000
TIME: 7:00 PM
SPONSORS: IEEE Computer Society and GBC/ACM
LOCATION: MIT (Cambridge, MA) Building 4 Room 4-231
TOPIC: CMS Pipes - Functionality Beyond Unix Pipes
SPEAKER: Rocklyn Clarke, MIT
Unix pipes provide a way to string together a series of "filters" which
each read input from a generic "standard input" source and write output
to a generic "standard output" target. A Unix pipeline can be built by
stringing together many filters, each of which performs some (usually
simple) task. A pipeline can be thought of as a (primitive) program.
VM/ESA is a modern time-sharing system which runs on IBM's System/390
servers. The operating system is capable of running thousands of virtual
machines, each of which is a complete and logically independent
emulation of a System/390 server. Thus, each user running under VM/ESA
has at his or her disposal a fully functional "virtual" System/390.
VM predates Unix. VM was born in the mid 1960s at IBM's Cambridge
Scientific Center and has made a number of contributions to the
computing industry. Originally, VM didn't have any pipes-like feature.
People noticed that Unix pipes were very useful and convenient. An
effort was started to add a similar feature to VM. The VM Pipes
implementor decided to create a more general pipeline facility that
supports pipe stages which can have multiple input connections and
multiple output connections. For example, a stage named "LOOKUP" first
reads master records from its secondary input and then reads detail
records from its primary input writing paired master and detail records
to its primary output and (optionally) writing detail records for which
there was no master record to its secondary output. After it is finished
processing all the detail records it can (optionally) write unmatched
master records to its tertiary output.
CMS Pipelines (CMS Pipes for short) is one of the most exciting
developments in VM. It allows the programmer to build powerful (and
sophisticated) "plumbing" out of interconnecting pipelines. CMS
Pipelines have been used to implement webservers, SMTP servers, and a
host of applications for parsing and processing the contents of files.
Simple CMS Pipelines can be typed into a CMS command line. However, they
are usually entered in a REXX EXEC (the CMS counterpart to a Unix shell
script). There is a syntax for commands in a REXX EXEC. CMS Pipelines
have their own syntax (similar to the syntax of Unix pipes, but a little
more complicated because it has to allow for the interconnections of
multiple pipelines). Many CMS Pipelines stages accept control arguments
which control details of that stage's behavior. The "SPECS" stage
controls the way groups of one or more input records are transformed
into one or more output records. The control arguments to the SPECS
stage are sufficiently general and complex so that they could be
described as a separate language embedded within the CMS Pipelines
language. The SPECS stage has a facility for storing data and doing
computations across multiple groups of records. This facility is called
the "407 emulation" feature, in a joking reference to the old IBM 407
Accounting Machine (because its capabilities are somewhat similar to
those of the IBM 407). The "407 emulation" mode is controlled by a
programming language embedded within the SPECS language, embedded within
the CMS Pipelines language, which is usually embedded within in the REXX
language.
This talk will explore some of the interesting functionality that has
been incorporated into CMS Pipes and ways in which it surpasses the Unix
pipes implementation which was its original inspiration.
SPEAKER BIOGRAPHY:
Rocklyn Clarke is a senior project manager in MIT's Information Systems
department (IS). He is also the former leader of MIT's Year 2000 Team.
Rocklyn was born and raised in New York City. He was first introduced to
computers in junior high school and continued working on them through
his years at the Bronx High School of Science in New York.
Rocklyn graduated from MIT in 1983 with a S.B. in Physics and continued
working there for Information Processing Services, which was later
reorganized as Information Systems. Rocklyn has worked on IBM's VM/ESA
operating system (and its predecessors) for over 18 years. He wrote the
accounting system currently in use on MIT's central S/390 processors, as
well as a number of other local system tools. Although he currently
spends most of his time on non-VM projects, he continues to follow with
great interest new developments in VM and in System 390 technology. His
latest area of interest with respect to mainframe technology is in
running Linux under VM/ESA on IBM S/390 processors.
Date: 14 December 2000, 7:00 PM, at MIT, room 4-231. An optional
pay-your-own dinner at the Bertucci's Restaurant on Main Street follows
the meeting. This meeting is free, open to the public, and no
registration is required. For more information, contact David Rosenberg
at (617) 253-8054 or <rosenberg@mit.edu>.
