Ada/UNIX

[rracine@AJPO.SEI.CMU.EDU]

A reference was made to a study of Ada running on top of UNIX, which was
written up in GCN.  The reference made it seem that the language was the
problem.  Being one of the participants in the study, I can state that
the Operating System was the problem.  

The context of the study was as follows.  The Space Station Freedom Project
(that is really its correct name) decided many years ago to use Ada for all
new software.  The project is also trying to use commercial software when
possible.  So they had a number of folks (including us) look at the 
feasibility of having a System V Interface Definition (SVID) conforming
operating system be the ON-BOARD operating system for the Space Station
Freedom.

Without going into too much detail, the results we came up with are:

1) For real-time software, current implementations of SVID do not give the
   application program (in any language) enough of the processor.  There
   is too much overhead taken in Signaling, for example.

2) There are Ada implementations which are sufficient for the program,
   either with real-time operating systems under the run-time environment,
   or with their own run-time environments.

3) Since the Ada applications need the speed, and non-real-time software
   (comercial systems) need the SVID interface, why not procure a SVID
   (or POSIX) implementation ON TOP of an Ada run-time environment?

NASA (and the on-board computer contractor) are still stating a long term
SVID requirment, but I think we at least are making them look a little
closer at the implementations.

As far as Ada interfacing to UNIX, the additional overhead of converting
differing types of data is the only problem one should compare with C++,
and that can be negligible.  One could look at tasking, but C++ doesn't
have tasking.  If one really stretches one's imagination, you could call
UNIX a multitasking system, but then the comparison is unfair -- Ada is
much, much faster in all measurements.  Try to do synchronous communication
in C++.  Current Ada implementations have a one-way communication time
on the order of 50 microseconds.  The best we could do in C was a couple
of orders of magnitude longer (some number of milliseconds).

Roger Racine
C.S. Draper Laboratory, Inc.