This page is deprecated and may contain some information that is no longer relevant or accurate.
Real-Time Software Components (RTSC)
Project Proposal: Real-Time Software Components (RTSC)
- Real-Time Software Components for Embedded Systems
- How RTSC fits into the Eclipse Ecosystem
- Proposed Project Lead and Initial Committers
- Interested Parties
- Code Contributions
Real-Time Software Components for Embedded SystemsThe Real-Time Software Components (RTSC) project is a proposed open source project under the Device Software Development Platform project. This proposal is in the Pre-Proposal Phase as defined in the Eclipse Development Process document and follows the Eclipse Proposal Guidelines. It is written to declare the intent and scope of the project and to solicit additional participation and input from the Eclipse and embedded developer community. You are invited to comment on and/or join the project. Please send all feedback to the http://www.eclipse.org/newsportal/thread.php?group=eclipse.dsdp.rtsc newsgroup.
- integration with TPTP to enable the test of deeply the embedded C content;
- use of the Device Kit portion of the SODA project (which has similar needs for monitoring);
- the monitoring and data collection components of COSMOS; and
- use of EMF to enable specification of components using existing UML tools but generating RTSC components that run in highly-resource constrained environments.
BackgroundComponent based development has proven itself to have significant benefits in the enterprise IT and web-based environments; complex applications are quickly created and very few, if any, are created from scratch – they all leverage a rich set of third-party open-source or commercial components. Beyond object-oriented language support, component models address all phases of the software lifecycle and standardize software abstractions to the point where – without any ad-hoc conventions or schedule coordination among the participants – interfaces defined by one company can be implemented by a second and used by a third. Moreover, tools that leverage the additional structure imposed by this standardization facilitate the development and (re)use of components, further accelerating the creation of applications assembled from components created by third-parties. Although real-time embedded systems are increasingly being developed with object-oriented languages and techniques, to enable the same level of cross-company reuse and rapid application development, a component model and supporting tools are needed. However, existing enterprise models (such as JavaBeans, .NET, Corba, etc.) do not address the unique challenges of embedded systems:
- embedded platforms are extremely cost and power sensitive (Ganssle2006): to minimize cost and power consumption, a wide variety of CPUs, peripherals, and memories are employed with limited code space and MIPS capacity.
- embedded software must be "optimal": to work within the constraints of small memory and relatively slow clock rates necessitated by the cost and power constraints, software must be as small and fast as possible.
- existing software is predominantly written in C and assembly language (Nass2007): no standard definition of interfaces nor a common runtime that enables multiple implementations of an interface within a single application exists.
- no standard C/C++ compiler toolchain exists for all devices: while GCC supports many CPUs, to achieve the necessary performance from their "portable" ANSI C code bases, developers must leverage C/C++ compilers from the device manufactures that achieve "optimal" performance for their devices.
The RTSC Model
Sometimes through heroism you can make something work. However, understanding why it worked, abstracting it, making it a primitive is the key to getting to the next order of magnitude of scale. – Robert CalderbankThe RTSC model and tools enable development of components written in C using any compiler toolchain on any development host for any embedded platform. These components can be configured, assembled, and optimized for use within any embedded real-time system. By focusing on design-time rather than on runtime component assembly, the RTSC model and tools enable many of the component-based benefits to scale down to even the most resource constrained embedded system while leveraging existing C/C++ code bases and tool chains. The RTSC tools, developed over a period of 7 years, are already in use by several Texas Instruments (TI) development groups and have been used to produce "mass market" products such as the DSP/BIOS Real-Time Operating System and the Codec Engine multi-media middleware framework. While these products enjoy the benefits of not having to reinvent the capabilities provided by the RTSC tools, the value of these tools and the motivation to create new tools increases dramatically as adoption of RTSC increases. However, wide-spread adoption is only possible if the model and base tooling are open and freely available.
How RTSC fits into the Eclipse EcosystemThe Eclipse DSDP and Tools projects already contain many projects applicable to the development of embedded applications. The goal of the "Real-Time Software Components" project is to complement those existing projects (e.g. CDT), extend Eclipse to provide component based developed environment appropriate for virtually any embedded device with components implemented using C/C++, and encourage extensions of existing component based tools used by Java developers to apply to RTSC components. The goal is to create a component development platform that can drive the embedded C programmer through the component lifecycle from design (modeling tools), development (C/C++ cross-compiling), testing (unit test frameworks), deployment (package creation tools), and installation (component selection and inter-component compatibility checking). To be successful, this project needs to foster the development of a rich set of both tools and target content. Although TI and some of its third parties currently ship a variety of interesting RTSC components (an RTOS, multi-media middlware, and codecs), a correspondingly rich set of tools built atop the Eclipse platform together with an open RTSC core component model will greatly accelerate the creation of interesting components and component-based applications on a variety of embedded platforms (including non-TI platforms).
ScopeThe goal for the RTSC project is to refine and standardize the core RTSC component model and foundational tools in an effort to bring component-based development advantages to all embedded C/C++ developers. The elements included in this project are listed in the Core Architectural Elements section below. By making this core infrastructure open, extensible, and freely available, we expect to seed additional projects that provide
- more sophisticated tools for component development: unit test frameworks, refactoring tools, etc.
- integration with other popular embedded tools and languages: UML, Doxygen, static checking tools (e.g., Coverity Prevent or Klockwork), etc.
- alternative or domain-specific component composition tools; e.g., a GEF based tool to create an application from existing components or a multi-core component development environment such as Zeligsoft's CE 3.0 product
- rich visualization of component-based applications: graphical representations of the relationships among constituent components, Dependency Structure Matrix tools, etc.
- extensions of existing component-based tools enjoyed by the Java developer to support RTSC components
RTSC OverviewThe RTSC tools and component model have enjoyed continuous development since 2000 by a small group of senior embedded software developers. Since 2004, the DSP/BIOS 5.x RTOS – created using the RTSC tools – has shipped along with the RTSC tools to ensure that any development system that included DSP/BIOS could consume components (called packages) created by any other development group. Today, internal groups within Texas Instruments regularly (re)build, test, and deploy hundreds of RTSC packages. Many of these packages are used worldwide by thousands of developers both inside and outside Texas Instruments.
- DSP/BIOS 5.x – one of the most popular embedded RTOS's (Turley2006) – is deployed as a bundle of more than 56 packages,
- Codec Engine multi-media middleware runtime (which requires DSP/BIOS) is an independently deployed bundle of more than 21 packages,
- a wide variety of video, imaging, speech, and audio codecs – developed by both Texas Instruments and its third parties – are delivered as a packages, and
- the RTSC toolset itself is delivered as a bundle of over 125 packages
- package selection, compatibility checks, and side-by-side installation
- side-by-side multi-target build with managed toolchains for both cross and native compilers
- toolchain-independent package build specifications
- component configuration and assembly tool
- document generation from component specifications
- component-specific views of internal data structures
- component compatibility checking
- component packaging tools
- on-device real-time logging and diagnostics to monitor system activity
Core ConceptsThe RTSC component model centers around three top-level concepts: modules, interfaces, and packages. Roughly speaking, modules correspond to Java or C++ classes, interfaces correspond to Java interfaces, and packages correspond to Java jars. Unlike Java, however, RTSC components provide code for two distinct environments: development hosts (with "unlimited" resources) and embedded runtime platforms (with very limited resources). It is this ability for components to operate in and be "configured" on the development host that allows them to scale their runtime requirements to a level appropriate for each embedded system in which they operate. More specifically:
- All content is logically and physically structured around a trio of programmatic constructs: modules, which encapsulate a related set of types and functions, and have both an external specification and a concrete internal implementation; interfaces, which effectively become abstract modules – a specification without an implementation – that other modules and interfaces can inherit; and packages, which serve as general-purpose containers for modules and interfaces as well as other software artifacts including legacy content.
- All content in the form of modules and interfaces exists in two complementary programming domains: a target domain, where target-content is bound into an application program executing on a particular hardware platform; and a host-based meta domain, where associated meta-content plays an active role in the design-time configuration as well as the run-time analysis of target programs.
- All content ultimately resides within individual packages that become the focal point for managing content throughout its life-cycle: all packages are built, tested, released, and deployed as a unit; and while largely self-contained, packages will in general require the presence of other packages that are likewise identified by their globally-unique name and time-varying compatibility key.
- Component Interface Definition Language (IDL) - to specify interfaces all components
- Component configuration and assembly tool - to enable rapid creation of applications from components at design-time
- Package build tool - to create a deployable component (i.e., a RTSC package) from pre-built artifacts and support managed multi-target side-by-side builds of C/C++ and Java sources.
- Embedded runtime support package - a scalable platform-independent runtime that includes printf-like diagnostic support, memory allocation, and basic concurrency control
- Package documentation tool - to automatically generate online package reference documentation from IDL specifications
- Package management tool - to select, check compatibility of, and install specified packages (and their prerequisites)
- Component runtime display tool - to support component-specific views of in-the-field runtime objects managed by the component
- Core Packages includes over one hundred packages necessary to create, install, configure, and monitor embedded runtime content on a variety of platforms using virtually any C/C++ compiler, and
- Essential Utilities includes both command-line and SWT based tools to view package documentation, manage installation and updates of packages, and view the state of a deployed embedded application.
- packages with metaonly modules/interfaces that themselves support the general build/release/deploy life-cycle of other RTSC packages; just as many contemporary programming environments bootstrap themselves (e.g., all of Java is Java classes), RTSC packages are ultimately managed through other well-known RTSC packages that lie at the core of XDCTOOLS.
- packages with target modules/interfaces that provide a first layer of run-time support for C programs containing other RTSC modules; portable across all targets, these modules augment the standard C runtime library with better embedded support for pluggable memory allocators, event logging plus error handling, entry/exit of critical sections, as well as overall program startup/shutdown.
- building and releasing packages
- generating documentation from specs, and
- managing package repositories
OrganizationWe propose this project should be undertaken within the top-level Eclipse Device Software Development Platform (DSDP) project.
- Doug Gaff
- Martin Oberhuber
Proposed Project Lead and Initial Committers
- Dave Russo, TI (lead)
- Bob Frankel, TI
- Jon Rowlands, TI
- Sasa Slijepcevic, TI