[cap-talk] Capability levels (was: The Hurd and Capabilities)

[Jed at Webstart]

At 01:27 PM 8/11/2006, David Hopwood wrote:
>Jed Donnelley wrote:
> > We've seen capabilities discussed (e.g. on this list) and implemented
> > at what I believe are three distinct levels, language (I'll refer 
> to as "low"
> > level), OS (I'll refer to as "mid" level), and network (I'll refer to as
> > "high" level).  The Mach implementation seems to fall into the mid
> > category.
>
>That's an odd way of ordering the levels. OS is below language, normally.

Here's my reasoning:

1.  Languages generate and ultimately execute direct machine instructions.
The "object" abstractions they deal with are direct data structures that
they manipulate directly.

-> Languages deal with objects on a machine instruction basis.

2.  Operating systems manage resources that are generally external
to running programs (executing at the "language" level).  Operating
systems can deal with and accept a bit more latency/overhead, etc.
because they have to already get "called"/invoked at some overhead
(a domain change) before they even get into the act.  Operating systems
support object abstractions for running processes.

-> Operating systems deal with objects on a system call (extended
virtual instruction - higher level) basis.

3.  Networks deal with objects in terms of systems of communicating
processes (active objects).  Here the overheads and latencies are again
probably at least an order of magnitude higher.

-> Networks deal with objects on a network message basis.

Still seem odd?  Why do you suggest that OS is 'normally' below language?
In what contexts?  Are you thinking somehow in terms of privileges?  I think
of privilege as pretty much orthogonal to what I might call "intimacy" that I
was using for the above ordering.  Operating systems can represent network
capabilities in terms of their objects.  Languages can represent OS 
capabilities
in terms of their data structures.  There seems to me to be a hierarchy there
that doesn't work the other way - where things fan out.

For me it seems that it could work out if we have some number of language
level object representations (with translations/conversions - sort of like
subroutine calling conventions). I would hope that we have fewer OS level
representations, one for any system presumably running multiple languages.
I'm hopeful that we eventually get to a very small number of "standard"
object representations at the network level, as those have to be shared
across all systems, and languages --- below them.

I suppose in some ways the notion of level doesn't matter so much
for the capability discussion, but the above is what makes most sense
to me.  I'm interested to hear the thoughts of others.

--Jed http://www.webstart.com/jed/