IPCHINOOK is a design tool for distributed embedded systems. It gains leverage from the use of a carefully chosen set of design abstractions that raise the level of designer interaction during the specification, synthesis, and simulation of the design. IPCHINOOK focuses on a component-based approach to system building that enhances the ability to reuse existing software modules. This is accomplished through a new model for constructing components that enables composition of control-flow as well as data-flow. The designer then maps the elements of the specification to a target architecture: a set of processing elements and communication channels. IPCHINOOK synthesizes all of the detailed communication and synchronization instructions. Designers get feedback via a cosimulation engine that permits rapid evaluation. By shortening the design cycle, designers are able to more completely explore the design space of possible architectures and/or improve time-to-market. IPCHINOOK is embodied in a system development environment that supports the design methodology by integrating a user interface for system specification, simulation, and synthesis tools. By raising the level of abstraction of specifications above the low-level targetspecific implementation, and by automating the generation of these difficult and error-prone details, IPCHINOOK lets designers focus on global architectural and functionality decisions. The complexity of modem embedded system design requires designers to leverage the reuse of both software and hardware IP modules. In this paper, we focus on software components (e.g., MPEG decoders, control algorithms, and user interfaces). These modules are designed with a particular API that cannot adapt well to new system contexts. Many assumptions about the way the components will be used are embedded in their implementation, making it difficult (if not impossible, due to concerns about proprietary information) and time consuming (to understand their code well enough) to make the appropriate modifications. This ZP integration problem is exacerbated by the fact that many embedded systems use multiple processing elements and highly specialized communication topologies in the interests of meeting cost, power, and performance constraints. The modules must now not only be composed appropriately but their activities must also be coordinated across more than one processor. The communication and synchronization code required to do this cannot be generally anticipated. A common solution is to provide a general embedded operating system that can perform these functions. However, this still requires adapting the modules to the new run-time environment and opens up the design to inefficiencies due to the full generality of this operating system. If we follow this IP-based approach to system design along its logical trajectory, we see that the design cycle is dominated by system integration time, rather than component design. In such a scenario, the task of generating the low-level interfaces between components and optimizing their coordination must be automated so that designers can investigate architectures and partitionings that better satisfy the design constraints. For designers' efficiency and for IP protection, tools are needed that provide specific support for system integration. IPCHINOOK is an example of a new generation of IP-oriented system design tools. It is targeted to specifically address the three problems of: Component models of software IP suffer from some fundamental problems. First, their fixed APIs may not anticipate how the components will be used, thus limiting their applicability when designers cannot directly modify their code, and causing reverse engineering and maintenance problems when designers can. Second, composing multiple IP components often requires designers to spend an inordinate amount of time writing and debugging custom integration code. Finally, due to information hiding and imperfect anticipation of what internal component state needs to be exported, the integration code often ends up duplicating the state of the components (and their associated transition functions) in order to make it visibile. In IPCHINOOK, we formalize component coordination into a separate system assembly step that leads to reusable composition constructs. To accomplish this, we permit the explicit coordination of statdcontrol between components in addition to an event-based model appropriate for data-flow and more traditional APIs. Intermodule communication software must be tailored to the application by taking into account factors such as the capabilities of the processing elemenets, their interconnection mechanisms, the system's physical topology, and how functionality 44
IPCHINOOK REF is a design tool for distributed, embedded systems.
IPCHINOOK: an integrated IP-based design framework for distributed embedded systems