This paper discusses design technology issues for embedded systems using processor cores, with a focus on software compilation tools. Architectural characteristics of contemporary processor cores are reviewed and tool requirements are formulated. This is followed by a comprehensive survey of both existing and new software compilation techniques that are considered important in the context of embedded processors

Architectural styles are named collections of constraints on configurations of architectural elements, and are believed to bring economies of scale in applying software architecture techniques to software development. Most research on architectural styles focuses on analyzing and observing the properties of such styles from their descriptions. However, comparatively little is known about the systematic design and construction of software architectures using architectural styles. Existing classifications bring out differences between architectural styles, but none provides a clear understanding of the similarities among a large number of styles. The basis of our research is the observation that architectural styles share many underlying concepts. These shared concepts lead to “architectural primitives ” that can be systematically and constructively composed to obtain elements of architectural styles. We have identified eight forms and nine functions as architectural primitives that, in our understanding, reflect the syntactic and semantic characteristics of a large number of styles. While proving such a hypothesis is difficult in the general case, we demonstrate it within the domain of network-based styles. Partial formal models of style elements composed from these architectural primitives are also constructed and shown to be analyzable.

ing away from irrelevant details is a theoretical virtue, but the kinds of abstractions that module geography makes can lead to incorrect inferences from data. That such a possibility exists is clearly demonstrated by the working memory research of Just & Carpenter (1992). Briefly, Just and Carpenter have argued that some garden path effects that were previously interpreted in terms of a syntactically encapsulated module can instead be explained by individual differences in working memory capacity. Such an explanation is not considered in a theoretical framework that systematically ignores the role of memory structures in parsing. This point should be taken regardless of whether one is convinced by the current body of empirical support for this particular model---the fact remains that such an explanation could in principle account for the data, and these alternative explanations are only discovered by developing functionally complete architectures. The next few sections describes what ...

this paper, we explore limitations to how design technology can enable the implementation of single-chip microelectronic systems that take full advantage of manufacturing technology with respect to such criteria as layout density, performance, and power dissipation. One limitation is that the integrated circuit (IC) design process---like any other design process---involves practical tradeoffs among multiple objectives. For example, there is a need to design correct and testable chips in a very short time frame and for these chips to meet a competitive requirement. A second limitation is that the effectiveness of the design process is determined by its context ---the design methodologies and flows we employ, and the designs that we essay---perhaps more than by its component tools and Manuscript received March 2, 2000; revised October 19, 2000

Forthcoming technology such as single-chip RISC/FPGA combinations make hardware compilation, fast prototyping, and FPGA replacement of ASICs all more likely. FPGAs have made a software-oriented approach to digital design feasible. This paper reviews remaining obstacles to this approach. The trade-os between use of an HDL and a `C'-variant, Handel-C, for logic synthesis are considered particularly in regard to programmability and the overall design process. A simple example in a likely application area, simulation/emulation of telecommunications switches, serves to illustrate the analysis. 1

The ideas and findings in this report should not be construed as an official DoD position. It is published in the interest of scientific and technical information exchange. FOR THE COMMANDER (signature on file)

The automation of the design of electronic systems and circuits [electronic design automation (EDA)] has a history of strong innovation. The EDA business has profoundly influenced the integrated circuit (IC) business and vice-versa. This paper reviews the technologies, algorithms, and methodologies that have been used in EDA tools and the business impact of these technologies. In particular, we will focus on four areas that have been key in defining the design methodologies over time: physical design, simulation /verification, synthesis, and test. We then look briefly into the future. Design will evolve toward more software programmability or some other kind of field configurability like field programmable gate arrays (FPGAs). We discuss the kinds of tool sets needed to support design in this environment.

The concept of “process ” has come to play a central role in many efforts to master the complexity of large computer systems. The purpose of this paper is to discuss useful methods of structuring complex processes, and to relate these to the problems of improving the quality of large computer systems. Two distinct ways of structuring systems are presented, namely, process combination, and process abstraction; these are then used to discuss such topics as concurrency, synchronization, multiprogramming, interpreters, and programmable processors. This discussion is based on a set of precise definitions for such concepts as “process,” “processor, ” “computation, ” “combination, ” and “abstraction. ” The paper relates these definitions to both current research and practical applications, with particular concern for the problems of the performance, reliability, and modifiability of computer systems. Key words and phrases: sequential process, cooperating processes, asynchronous processes, parallelism, complexity, program, processor, interpreter, hierarchical structures, abstraction, refinement.

Abstract not found

Software architecture-based approaches provide high-level abstractions to deal with complexity and richness of modern software systems. Many software systems have been found to share organizational and interaction characteristics. Architectural styles have been proposed to codify commonly used idioms of component structures, organizations and interactions. Existing classifications of architectural styles provide empirical support for style selection, but fail to systematically characterize them and do not reveal the basis underlying them. Moreover, the mapping between software architecture and design is poorly understood. My doctoral research proposes to create an understanding of, and as a result a composition framework for architectural styles using a small set of architectural primitives that are reused across styles to produce effective style implementation infrastructures. Architectural styles can be comprehensively characterized in terms of five concern areas: external structure, topology, behavior, interaction and data flow. This hypothesis is validated based on whether the characterization captures all the invariant aspects of styles, and is further confirmed through a Delphi with software architectural experts. My current research is focused on arriving at an assembly language for software architectures, Alfa, and architectural primitives, referred to as Alfa primitives, are a step towards this goal. Alfa primitives, representing architectural style characteristics, form a small set of “atomic elements” and can be reused across styles. Lightweight formal models and Java implementations of primitives and styles are created. The number of primitives is compared with sizes of primitive sets in other areas such as microprocessors and physics. Style models composed from Alfa primitives are analyzed to validate reuse of primitives. Alfa primitives can lead to effective style implementation infrastructures in terms of fidelity, performance and flexibility. Fidelity is validated based on the mapping that exists between style characteristics and Alfa primitives in the implementation. Performance is evaluated in terms of time and memory utilization of benchmark applications that use style implementation infrastructures. Flexibility is validated in terms of the change involved in implementation infrastructure for supporting extensions of styles. The main contributions of this research will be as follows: A novel approach for style characterization and understanding, A novel approach for composition of architectural styles, A small set of architectural primitives reused across styles, Compositional, lightweight formal model of styles, and An effective implementation of style infrastructures.