|
ESW today is written
using low level programming languages such as C or even
Assembler to cope with the tight constraints on performance
and cost typical of most embedded systems. The tools
available for creating and debugging software are no
different than the ones used for standard software:
compilers, assemblers, debuggers and cross compilers. If any
difference can be found, it is in their quality: most tools
for ESW are rather primitive when compared to equivalent
tools for richer platforms. On the other hand, ESW needs
hardware support for debugging and performance evaluation
that in general is not a big issue for traditional software.
In most embedded software, operating systems were
application dependent and developed in house. Once more
performance and memory requirements forced this approach.
When
embedded software was simple, there was hardly any
need for a more sophisticated approach. However,
with the increased complexity of ES applications,
this rather primitive approach has become the
bottleneck and most system companies have decided to
enhance their software design methodology to
increase productivity and product quality. However,
we do not believe that the real reasons for such a
sorry state are well understood. We have seen a
flurry of activities towards the adoption of
object-oriented approaches and other syntactically
driven methods that have certainly value in cleaning
the structure and the documentation of embedded
software but have barely scratched the surface in
terms of quality assurance and time-to-market. Along
this line, we also saw a growing interest towards
standardization of Real-Time Operating Systems (RTOS)
either de facto or through standard bodies
such as the OSEK committee established by the German
automotive industry. RTOS and traditional Integrated
Development Environments (IDEs) dominate the ESW
market. ESW design automation is still a small
segment, even though this is the place for
productivity gains.
In
some applications, the need to capture
specifications at high levels of abstraction have
led to use of modeling tools, such as the Mathworks
Matlab and Simulink tools. These tools allow
designers to quickly assemble algorithms and
simulate behavior. However, the mathematical models
supported by such tools do not cover the full
spectrum of embedded system design. The lack of
formal data flow support is critical. The lack of
integration between the FSM capture tool (State
Flow) and Simulink is also a problem.
This
is a key area in our vision, as at this level we
will have the best results in terms of functional
correctness and error free refinement to
implementation. The understanding of the
mathematical properties of the embedded sys-tem
functionality is a major emphasis of COLUMBUS.
We
believe that mathematical models (models that are
not just formal, but also manipulatable) offer the
vehicle for integrating in a systematic and coherent
fashion a variety of diverse efforts in system
specification, design, synthesis (code generation),
analysis (validation), execution (run-time support),
and maintenance (design evolution). Mathematical
models offer a precise common language that permits
multiple approaches with complementary strengths to
be directed towards a single design.
1. Rapid composition of
domain-specific modeling languages. Model-based design of
complex embedded systems necessitates the use of
domain-specific notations and novel modeling paradigms.
Based on years of research at UCB and VU, we will examine
how to support the rapid composition of domain-specific
modeling languages dedicated to embedded system development.
Specifically, following our previous research on
meta-modeling and meta-languages, we will investigate (a)
how to compose and validate complex meta-models, and (b) how
to extend meta-modeling constructs to very large, dynamic,
networked embedded systems. Formalization of meta-model
reuse, composition of complex languages from pre-fabricated
and generic meta-model components will be addressed.
2. Modeling on different levels of abstractions with
automatic transformations. Development of complex embedded
applications involves a number of modeling and synthesis
activities. While the representation and refinement of
designs is a well-addressed area in general software
engineering, very little is known about how these techniques
can be carried over to the field of embedded systems.
Embedded system design is complicated by the fact that
changes on the implementation level have profound impact on
the overall system performance (with respect to
requirements), and it is very hard to maintain this
dependency. In coordination with the meta-modeling research
area, we will investigate how to represent and store complex
requirement, design, and implementation models in modeling
environments, where the model elements are actively linked
together, and changes can be propagated across the different
levels via appropriate transformations.
3. Interfaces theories for component-based design. We
develop rich interface specification languages for
components. While a traditional interface specifies only
static information such as the types of input and output
parameters, a rich interface may specify dynamic properties
such as a specific call order of the methods offered by a
component, or a specific timing requirement on method calls.
If formal, such interfaces can be checked automatically for
compatibility. While lightweight (it requires only interface
specifications, not behavioral specifications), this
technique can uncover many concurrency and timing flaws at
design time, much the way traditional type systems detect
many software errors.
|
