scientific article; zbMATH DE number 1033650
Economically reasonable VLSI systems in general are heterogeneous, i.e. they consist of both hardware and software components. Parts of the system, which are not subject to tight computation-speed constraints, are better realized by software running on programmable processors, while other parts might require fast, dedicated hardware. It is advantageous to implement as much of a system as possible in software, because software is cheaper and more flexible. This trend creates a need for software compilers as a part of electronic computer-aided design systems. Such compilers need to be linked to hardware design tools and must provide a certain flexibility. The consumer market needs for the processor architectures tailored towards certain application domains, usually in the sense of higher level of optimization. In contrast to the programmation of general-purpose computers, where the user repeatedly programmes and configures his PC so as to solve a variety of problems, such special-purpose processors are designed only once to serve a single, particular application. They interact with larger, often non-electronic environments and are therefore called embedded systems. In a heterogeneous embedded system, its software components are stored in the program ROM of the system and executed on programmable embedded processor(s). Obviously, the software must be prepared in the internal language of the processor. But, when designing an embedded systems, the hardware and software components are both designed starting from a purely functional description of the system. The first step of the design is the hardware-software partitioning, i. e. the decision whether to assign different components of the system to either hardware or software. Thus, the hardware components, particularly the instruction set of embedded processors, are specified and, consequently, the software components must be expressed in the terms of this set. For the design efficiency, the algorithms of the software components are described as programs in a high-level language and a dedicated compiler maps them into machine code. Since the hardware-software partitioning step is typically based on rough estimations, it is necessary to simulate both parts on a host computer in order to verify that all constraints in the system specification are met. If not, re-partitioning is performed and the instruction set is redefined (and the application-dedicated programs are recompiled) until a valid system implementation is found. To avoid the necessity of a separate compiler for each different instruction set, flexible retargetable compilers are necessary, which can be quickly adapted to new target processors. In addition, compilers for embedded software need to perform optimizations on the generated code. The author of this book concentrates on code generation for embedded processors and target processor modelling (which includes instruction-set specification). In particular he considers digital signal processors, very commonly used in embedded systems in areas of telecommunication and image processing. After introducing (in the chapter 1) the basic notions and presenting the considered problems, he gives in chapter 2 an introduction of the MIMOLA hardware description language, implemented in the form of the prototype compiler system RECORD. The chapter 3 presents a novel and fast technique of the analysis of processor models. Chapter 4 focusses on the tasks of code selection, register allocation and scheduling. Exploitation of potential parallelism in generated machine programs is the subject of chapter 5. A new algorithm for address generation and assignment and a novel method for code compaction (based on integer programming methods) are there presented. The capabilities of the RECORD compiler in terms of retargetability and code quality are experimentally evaluated in chapter 6. Chapter 7 concludes with a summary and hints for further research. A MIMOLA program is given in the form of an imperative language algorithm, described in a hardware-oriented superset of the PASCAL language. It is used only for describing the target processor hardware. The algorithms of the software components are formulated in a programming language DFL (Data Flow Language) designed for digital signal processors and described in the chapter 4. The code generation is the multistep process where both descriptions (of the hardware and software components) are analyzed and determine the target code.
- ISDL: An instruction set description language for retargetability and architecture exploration
- Retargeting a hardware compiler using protocol converters
- Modeling instruction semantics in ADL processor descriptions for C compiler retargeting
- Specific optimization features in a C compiler for DSPs
- Using graph models in retargetable optimizing compilers for microprocessors with VLIW architectures
- Compilers for embedded processors
- Retargetable compiler technology for embedded systems. Tools and applications
- scientific article; zbMATH DE number 4155855 (Why is no real title available?)
- Improving offset assignment for embedded processors
- A retargetable macro generation method for the evaluation of repetitive configurable architectures
- FlexCC2: An optimizing retargetable C compiler for DSP processors
- Retargetable program profiling using high level processor models
- An empirical study of retargetable compilers
- Use of F-code as a very high level intermediate language for DSP
- OCEANS: Optimizing compilers for embedded applications
- scientific article; zbMATH DE number 2167355 (Why is no real title available?)
- scientific article; zbMATH DE number 1864853 (Why is no real title available?)
- Synthesizing program generators for embedded software
- Automated Technology for Verification and Analysis
- Compiler-based code partitioning for intelligent embedded disk processing
This page was built for publication:
Report a bug (only for logged in users!)Click here to report a bug for this page (MaRDI item Q4344157)