Subject: Rain ideas
From: Matthai Philipose (matthai@cs.washington.edu)
Date: Thu Feb 07 2002 - 07:52:10 PST
Hi folks,
Here are some additional ideas regarding Rain. Most of it is old hat.
Maybe the first and last point are the new ones.
Matthai
Programming system support for:
2.1 Controlling resource usage
<This is my previous e-mail>
2.2 Supporting dynamic evolution
This includes support for:
-Modifying program code as it runs
-Modifying program data while the program is running
-Doing the above in a safe way
2.3 System maintenance tasks
-Dynamically instrument code to monitor behavior for debugging, security
-Supporting "roll-back" on bugs: on a seg-fault can we re-play the last
N instructions?
[2.2 and 2.3 can be achieved by a complete meta-programming interface, I
think]
2.4 Optimizing "generic message" interface
Can the vast majority of the XML message sends be optimized away as
function calls. Can a lot of the call-by-value messages (which involve
huge amounts of marshalling) be compiled away?
------------------------------------------
An additional direction that may be interesting is that of providing an
interface and run-time support for controlling the use of underlying
resources by the application. This has to do with moving code and data
around (with varying degree of application-level input as to how to do
it) during the life of the program/system in ways that satisfies the
requirement of the application. At some level, this looks like the
scheduling problem in compilers:
+ How do we represent (perhaps in an programmer-extensible way),
the underlying resources available to the computation e.g. network
bandwidth, latency, connectivity, power, computing speeds,
administrative privileges? The parallel for conventional compilers is
the machine model used by a static scheduler which has things like
latencies for various operations, number of registers and function
units, etc.
+ How do we represent the resource requirements of a program? In
the conventional world, this corresponds to the CFG/PDG of a program
that needs to be scheduled, i.e. the functional units for each
instruction are the resources, and the dependence edges between the
instructions are the constraints expressing requirements on how they are
used.
+ Given an application with certain resource requirements, how do
we map it onto the underyling fabric? This corresponds to the
conventional scheduling problem, but potentially much richer because
constraints are richer, and may have to solved online.
+ What's the programming-language level interface to these
resources to expose to the application programmer? This is different
from conventional compilers, since machine level details are not (modulo
the old "register" keywords) exposed to the user, and you don't get
scheduling/register allocation hints/requirements from users. However, I
think it's pretty certain that for apps of this kind, application-level
programmers would really want to have some say on resource requirements
for their programs.
This is traditionally an area that is the bread-and-butter of
operating-systems folk, but in this era of blurring lines between OS's
and run-time systems, and the increasing relevance of programming
language research in operating systems ;-), there's no reason for us not
to take a bite out of it. The key question is whether integrating
resource scheduling with language-level support gives any extra mileage
in this domain.
Matthai
_______________________________________________
Cecil mailing list
Cecil@cs.washington.edu
http://majordomo.cs.washington.edu/mailman/listinfo/cecil
This archive was generated by hypermail 2b25 : Thu Feb 07 2002 - 07:48:06 PST