Multiple instances of run-time sys?

Multiple instances of run-time sys?

[R.A.L Williams]

In 1993 the US Navy dept. issued a series of reports on 'Advanced
Avionics Architecture and Technology' (sorry, there doesn't seem to
be any reference number) in which, among other things, they seem to
be pushing the following concepts:

1. Software reuse, presumably at library *and* application level.
2. Modular, as opposed to federated, architectures.

Studies in Europe are also coming up with the same recommendations
and this is something which we need to take seriously.

For those who are not familiar with the distinction between modular 
and federated architectures here is a brief description of my view
of them:

A Federated structure employs intelligent sensors which feed data
to a (probably centralised) main processor. The main processor has
relatively low I/O data rates because the intelligent sensors do
sensible preprocessing. This seems like a sensible architecture
until you start adding additional hardware for redundancy to improve
the reliability. The intelligent sensors will need a disproportionately
high amount of extra hardware and the system cost goes up.

A Modular structure uses dumb(er) sensors which feed (nearly) raw data
to a more powerful main processor. When redundancy is added to the
complete system this usually works out cheaper because the main
processor has better opportunities for sharing resources.

Sorry, that was just a very quick thumbnail sketch.

The key point is that to take advantage of the Modular architecture we
need, in general to be able to support both process migration and
per-cpu multi-processing to allow reconfiguration and optimal use
of resources.

Now, finally, I can get to the point of this post!

Suppose we have a CPU (one of many in the system) which is required to
run, say, two COTS applications, almost certainly from different
vendors (eg. radar processing and nav. processing). Now, both of these
are written in Ada (because we always obey the mandates don't we), but,
quite possibly, developed using different compilers.

So, what happens about the run-time systems for these applications?
Most run-time systems for embedded applications make the following
assumptions about their environment:
 - Their app. is the only one running on the CPU
 - They are supplying all hardware interfaces to the board, ie.
   initialisation, interrupt dispatch etc.

As I see it we have a number of alternatives:
1. Write an operating system that provides a 'virtual machine' for
   each app. and its run-time to run in.
2. Find a compiler that allows multiple applications and reconfiguration
   and then recompile all apps with this compiler.
3. Write our own run-time system which allows the same as 2.

There may be more. I don't know of anywhere, at present, where the
technology for any of my alternatives exists.

Does anyone have any suggestions?

Bill Williams

Re: Multiple instances of run-time sys?

[Tucker Taft]

In article <3fo5k4$su2@miranda.gmrc.gecm.com>,
R.A.L Williams <bill@valiant> wrote:
> ...
>Suppose we have a CPU (one of many in the system) which is required to
>run, say, two COTS applications, almost certainly from different
>vendors (eg. radar processing and nav. processing). Now, both of these
>are written in Ada (because we always obey the mandates don't we), but,
>quite possibly, developed using different compilers.
>
>So, what happens about the run-time systems for these applications?
>Most run-time systems for embedded applications make the following
>assumptions about their environment:
> - Their app. is the only one running on the CPU
> - They are supplying all hardware interfaces to the board, ie.
>   initialisation, interrupt dispatch etc.
>
>As I see it we have a number of alternatives:
>1. Write an operating system that provides a 'virtual machine' for
>   each app. and its run-time to run in.
>2. Find a compiler that allows multiple applications and reconfiguration
>   and then recompile all apps with this compiler.
>3. Write our own run-time system which allows the same as 2.
>
>There may be more. I don't know of anywhere, at present, where the
>technology for any of my alternatives exists.
>
>Does anyone have any suggestions?

The Distributed Systems Annex of Ada 95 is designed to allow systems to
be built out of several "partitions" working cooperatively.  
Each partition has its own run-time system; the interactions
between partitions are based on remote subprogram calls,
or on shared global data partitions.  The expectation
is that these partitions could be built by distinct compilers, and run
either together or on separate CPUs.  It remains to be seen how many
compilers will end up supporting this annex, but if it becomes widely
supported, "federated" and "distributed" systems should be relatively
easily buildable using off-the-shelf Ada 95 compilers.

>Bill Williams

-Tucker Taft   stt@inmet.com
Intermetrics, Inc.
Cambridge, MA  02138

Re: Multiple instances of run-time sys?

[Garlington KE]

We have a "modular" processing architecture on the F-22, although the
definition of modular is a little different than yours. Rather than having
a series of "black boxes" dedicated to different tasks (a radar box, a
mission management box, etc.) we have a series of common modules used for
different tasks (a standard data processor, a signal processor, etc.). The
way we handle the RTS problem is to require a common development environment
for each module type. The RTS for that environment allows multiple programs
to run on the same module, so there's no problem with conflicting RTSs.

--------------------------------------------------------------------
Ken Garlington                  GarlingtonKE@lfwc.lockheed.com
F-22 Computer Resources         Lockheed Fort Worth Co.

If LFWC or the F-22 program has any opinions, they aren't telling me.