Abstract:
The information revolution that we are in the midst of has led to the use
of computers controlling applications ranging from automobiles and games, to
video-pumps in the information highway. These applications are distinguished by the fact that they use programs with special timing relationships between their constituent elements. For example, a program running in the microprocessor
controlling an ABS system in a modern automobile must sense and react to the
friction coefficient between the brake pads and the wheel at well-defined
intervals of time; failure to do so will result in a systemic failure of the
brakes. Referred to typically as embedded systems, these applications
constitute a significant portion of the potential growth in the computer
industry. However, this growth opportunity is being hampered by a lack of
adequate support via software development tools, to aid the easy, rapid and
correct prototyping of embedded applications.

In this report, we outline CoRReT, a COnstraint based environment for the
Rapid prototyping of REal Time programs. The report outlines the overall
system architecture as well as the key modules in this environment that are
being currently developed. CoRReT is a scheduling centric system in that a
suite of algorithms for instruction scheduling programs instrumented with
real-time constraints, are at its core. These algorithms are an integral
part of an (optimizing) compiler which will compile these programs automaticallywhile attempting to ensure that the timing constraints are met; when the
constraints are met, the resulting schedule for the instructions is
referred to be feasible. If a feasible schedule is found, it will be fed
automatically into a code-generator in the back-end of the compiler. Our
envisioned scheduler can --- in addition to traditional control- and
data-dependence constraints in the source program --- also cope with a
variety of timing constraints specified by the programmer.

Our focus is on computational platforms that embody parallelism at two levels
of granularity. At the highest level, we envision a tightly-coupled parallel
machine offering large-scale parallelism. In this setting, a single embedded
application can be distributed across the individual processors of the cluster. Furthermore, each processor in this parallel machine can embody Instruction
Level Parallelism (ILP) at a fine-grained level.

Unfortunately, due to a lack of automatic tools and technology that can provide compilation support for real-time constraints ubiquitous to embedded
applications, parallel computing platforms have not proliferated in this
setting. Considering the fine-grained case first, RISC processors with ILP
have not yet found a niche in this domain; currently, developers of embedded systems are reluctant to embrace ILP technologies due to the onerous task of ensuring timing relationships in the program by hand --- a difficulty compounded by parallelism (at a fine-grained level) in the processor. Clearly, providing
support through automation that frees the programmer of these difficulties,
is a means of overcoming this challenge.

Our response to this challenge via CoRReT is to develop scheduling
methodologies and tools for automatically harnessing very high performance from these platforms, in the context of embedded systems. In the absence of
time-constraints, major progress has been achieved in this direction at the
coarse-grained level. The situation is even better at the fine-grained level
where scheduling technology is being used routinely in product-quality
compilers for RISC processors.

The methodology on which CoRReT is based is independent of any particular
target processor, and is applicable to third and fourth generation languages.
Furthermore, we propose to use the same scheduling engines during the static
analysis of the program as well as during compilation. We anticipate this
``confluence'' in the scheduling algorithms to aid in shorter prototyping
cycles, since identical schedules will be used by the analysis tools and the
back-end of the compiler to generate code. We envision that the algorithms
and tools that go into CoRReT will naturally form an integral part of a
full-fledged programming environment for prototyping real-time programs on
parallel platforms.