factor-michael@YALE.ARPA (Michael Factor) (04/15/88)
Date: Thu, 14 Apr 88 12:49:50 EDT
From: David Gelernter <gelernter-david>
To: Paul.Birkel@K.GP.CS.CMU.EDU
Subject: "Another Yale program"
Cc: factor, leichter
Subject: Can you name this project?
In a recent exposition on parallel computing in the popular press the
following paragraph appeared. Can anyone name this project, its
investigators, a contact, a publication, or provide any further information?
"Another Yale program - to monitor the equipment in an
intensive-care unit - is more flexible still. Each processor
in this system runs a different program, which monitors the
equipment for signs of a particular problem or ailment. Because
each program has its own processor, it is ever-vigilant for
signs of its disease."
This program is a so-called "Realtime Knowledge Daemon" written
by Mike Factor of the Linda group here, in collaboration with
some anaesthesiologists. The Economist guy got it wrong: each
PROCESS (not processor) runs a different decision procedure.
I'm appending abstracts from a couple of recent reports on the system.
I'll send you copies of the papers if you want them. (The program
is also discussed in a paper forthcoming in the SIGPLAN PPEALS conference
this summer.)
-------------------------------------------------------
The Parallel Process Lattice as an
Organizing Scheme for Realtime Knowledge Daemons
Michael Factor and David Gelernter
{\it Yale University \\
Department of Computer Science \\
P.O. Box 2158 Yale Station \\
New Haven, Connecticut 06520-2158} \\
{\bf Abstract.} A {\it realtime knowledge daemon} is a program that
fastens itself to a collection of data streams and monitors them,
generating appropriate comments and responding to queries, in
realtime. This type of program is called for whenever data-collection
capacity outstrips realtime data {\it monitoring} and {\it
understanding} capacity. A {\it parallel process lattice} is an
organizing structure for realtime knowledge daemons (and more broadly
for expert systems in general). A process lattice is a network of
communicating concurrent processes arranged in a series of ranks or
layers; data values flow upward through the lattice and queries may
flow downward. The intent of the process lattices is to ``waste''
processing power (an ever-cheaper commodity) by constantly monitoring
the likelihood of rare events, and eagerly computing the answers to
questions rarely asked, so that the system can respond rapidly and
gracefully to unusual circumstances. Further, the application's
character as a collection of heterogeneous, communicating expert
processes means that concurrency leads to a far simpler program than
would have been the been the case given a conventional, sequential
organization. We explain the process lattice and discuss its
suitability by describing a simple but fairly realistic prototype
designed for monitoring in an ICU.
A Prototype Realtime Knowledge Daemon
for ICU Monitoring
Michael Factor*, David Gelernter*, Perry Miller\dag and Stanley Rosenbaum\dag
{\it *Yale University \\
Department of Computer Science \\
%P.O. Box 2158 Yale Station \\
New Haven, Connecticut} \\
{\it \dag Yale University School of Medicine \\
Department of Anaesthesiology \\
New Haven, Connecticut} \\
A {\it realtime knowledge daemon} is a program that fastens itself to
a collection of data streams and monitors them, generating appropriate
comments and responding to queries, in realtime. We describe a
prototype designed for monitoring patients in a post-operative ICU.
The prototype is of interest because ($a$) its performance seems
reasonable and correct, and (our experience suggests) should continue
to be reasonable as the system grows (the current prototype isn't
comprehensive enough for clinical testing, but it continues to
expand); ($b$) the program is written using a novel ``process
lattice'' organization that holds a number of advantages for building
large expert systems. The process lattice structure results in a
program with an easily-visualizable logical structure that reflects
the structure of the domain; it imposes a regular organization on an
arbitrarily-heterogeneous set of decision procedures; it's well suited
to a parallel implementation. The prototype we discuss is written in
the parallel language Linda and runs on a commercial parallel
processor.