morphic function test. Good definitions help one to readily recognize which pattern to apply. There is also a well written section on inheritance related bugs, carried through to chapter 11 on testing reusable components. Table 11.1 shows the six languages compared with respect to performance across abstract and generic class. The advantage of Java over the others is apparent. Chapters 13 and 14 build subsystem test into system tests. Keep in mind that subsystem and system are defined by the author for his purpose. Chapter 15 is devoted to regression where regression is defined as once having passed a baseline test but now has a modified component. The system with modified component is said to be in need of regression testing. Section 4 Test Models is composed of chapters 16 through 19. The purpose of this section is to help the reader develop application specific test automation. Since it is application specific, it may be of limited value for those that fall outside the authors application set. The book is a little quirky in the way chapters are developed. Chapter 16 is only five pages long compared to chapter 10s 175 pages. The author takes literary license here , but perhaps allowance should be made for the complexity of the topic. Chapter 17 introduces a interesting concept of building in test code into the application. The author says that a assertion is a Boolean expression that defines the necessary conditions for correct execution. Basically these are checks and double checks, and they make good sense in some applications such as an operating system. To bolster this view the author gives some amazing statistics on IBMs OS/400 operating system. Chapter 18 is on test oracles. A test oracle is a code fragment of a test code system that produces the results of a test case. An oracle is something that can be trusted to deliver the expected results. Several patterns of oracles are discussed from parametric to gold. He foes on to tackle automated test result evaluation. Some of these concepts make sense for a trusted operating system but not for an application running under a trusted OS but the author does not make that distinction. Chapter 19 is on the topic of test harness design. A test harness is the nomenclature of a set that contains test case, test suites, stubs, drivers and control systems. This is all the elements …

Theories of programming languages

Escape analysis is a static analysis that determines whether the lifetime of data may exceed its static scope.This paper first presents the design and correctness proof of an escape analysis for JavaTM. This analysis is interprocedural, context sensitive, and as flow-sensitive as the static single assignment form. So, assignments to object fields are analyzed in a flow-insensitive manner. Since Java is an imperative language, the effect of assignments must be precisely determined. This goal is achieved thanks to our technique using two interdependent analyses, one forward, one backward. We introduce a new method to prove the correctness of this analysis, using aliases as an intermediate step. We use integers to represent the escaping parts of values, which leads to a fast and precise analysis.Our implementation [Blanchet 1999], which applies to the whole Java language, is then presented. Escape analysis is applied to stack allocation and synchronization elimination. In our benchmarks, we stack allocate 13p to 95p of data, eliminate more than 20p of synchronizations on most programs (94p and 99p on two examples) and get up to 43p runtime decrease (21p on average). Our detailed experimental study on large programs shows that the improvement comes more from the decrease of the garbage collection and allocation times than from improvements on data locality, contrary to what happened for ML. This comes from the difference in the garbage collectors.

/pdf/escape-analysis-for-javatm-theory-and-practice-3l9iapw4nx.pdf

Escape analysis for JavaTM: Theory and practice

Fragmentation can cause serious loss of memory in systems that are using dynamic memory management. Any useful memory management system must therefore provide means to limit fragmentation. Today's garbage collector implementations often do this by moving objects in a way that free memory is non-fragmented. This paper presents a new object model that is based on fixed size blocks. The model eliminates external fragmentation without the need to move objects. A Java virtual machine and a static Java bytecode compiler that use this object model have been implemented and analysed using the SPECjvm98 benchmark suite. This Java implementation allows for deterministic memory management as needed in real-time systems that is difficult to achieve with moving collectors and unparalleled by current implementations.

Eliminating external fragmentation in a non-moving garbage collector for Java

This book covers the essential elements of parallel processing and parallel algorithms. It is unique in that it is a self-contained book. It covers everything fundamental to parallel processing from computer architecture to parallel programming and parallel algorithms. It is designed to function as a text for an undergraduate course in parallel processing, but also works well as a comprehensive reference for professionals interested in all phases of parallel processing and parallel programming.

Parallel processing and parallel algorithms: theory and computation

Root scanning is the task of identifying references to heap objects that are stored outside of the heap itself, in global and local variables and on the execution stack. Root scanning is particularly difficult within an incremental garbage collector that needs to be deterministic or give hard realtime guarantees. Here, a method that allows exact root scanning is presented. The basic idea is to ensure that copies of all root references exist on the heap whenever the garbage collector might become active. This approach reduces the root scanning phase of the garbage collection cycle to an efficient constant-time operation. A Java virtual machine and a static Java byte-- code compiler that use this technique have been implemented and analysed using the SPECjvm98 benchmark suite. This Java implementation allows for deterministic memory management as needed in real-time systems that is difficult to achieve with traditional methods to perform root scanning.

/pdf/constant-time-root-scanning-for-deterministic-garbage-30qn2ykxax.pdf

Constant-Time Root Scanning for Deterministic Garbage Collection

TurboJ is an off-line Java compiler, translating Java byte-codes to native code. TurboJ operates in conjunction with a Java Virtual Machine (JVM); among the supported JVMs are those on HPUX, Linux, and Wind River’s Tornado for Java (running under VxWorks). Interfacing with a standard JVM entails benefits not enjoyed by the alternate “standalone” approach; particularly important for embedded systems is the opportunity to reduce the memory footprint via mixed-mode execution.

TurboJ, a Java Bytecode-to-Native Compiler

We propose a profile based code selection scheme for an AOT Java compiler. This scheme relies on a model that accurately predicts the speedup of a given selection. The model takes into account the cross-call patterns of the application. This approach allows us to reduce the size of compiled code significantly for several benchmarks.

/pdf/speedup-prediction-for-selective-compilation-of-embedded-21xnbg6p87.pdf

Speedup Prediction for Selective Compilation of Embedded Java Programs

Modeling languages propose convenient abstractions and transformations to handle the complexity of today’s embedded systems. Based on the formalism of the Hierarchical State Machine, they enable the expression of hierarchical control parallelism. However, they face two important challenges when it comes to modeling data-intensive applications: no unified approach that also accounts for data-parallel actions and no effective code optimization and generation flows. We propose a modeling language extended with parallel action semantics and hierarchical indexed-state machines suitable for computationally intensive applications. Together with its formal semantics, we present an optimizing model compiler aiming for the generation of efficient data-parallel implementations.

/pdf/from-a-formalized-parallel-action-language-to-its-efficient-4hlm0p65wj.pdf

From a Formalized Parallel Action Language to Its Efficient Code Generation

The complexity of Embedded System (ES) development is increasing dramatically. This has several cumulative sources: the intricate combination of data-intensive, computational and control aspects; the ubiquity of parallelism and heterogeneity of modern architectures; and the diversity of target-specific, non-deterministic programming models (e.g., C++ with explicit message passing, OpenCL, VHDL). Model-Driven Engineering (MDE) proposes to manage complexity by raising the level of abstraction for designers and developers, and refining the implementation for a particular context and platform through model transformations. In such frameworks, behavior is often specified by means of Hierarchical State Machines (HSMs) equiped with an action language. However, although such models represent some level of control parallelism through objects and HSMs, data parallelism, compound data, and the exploitation and optimization thereof remains very limited.In this paper, we propose an action language that seamlessly combines HSMs with data parallelism and operations on compound data. It preserves the expressivity of HSM and captures a layout-neutral description of data organisation. It also extends message-passing with an intuitive semantics for this additional paralellism and provides strong foundation for array-based optimisation techniques. We present this language together with a baseline code generation flow to enable the production of efficient, low-level imperative code.

A parallel action language for embedded applications and its compilation flow

The scientific foundations of embedded system development associate two disciplines that have largely grown on their own: computer science and electrical engineering This superposition of two domains with little common ground raises a number of industrial issues in team work organisation, sound progress tracking, and cooperation between these different skills and cultures In this paper we introduce HOE², an integrated MDE method for embedded system development that is organised around a set of limited yet powerful artefacts We describe how HOE² can address the issues faced during development of mixed HW/SW systems and present the first version of a tool dedicated to its instrumentation

/pdf/efficient-embedded-system-development-a-workbench-for-an-4zj8zqmmd2.pdf

Christian Fabre

Papers

TurboJ, a Java Bytecode-to-Native Compiler

Speedup Prediction for Selective Compilation of Embedded Java Programs

From a Formalized Parallel Action Language to Its Efficient Code Generation

A parallel action language for embedded applications and its compilation flow

Efficient Embedded System Development: A Workbench for an Integrated Methodology