Common Language Infrastructure

Abstract: The functionality of the recently announced Microsoft .NET system is founded on the capabilities of the Common Language Infrastructure (CLI). Unlike some other recent systems based on virtual machines, the CLI was designed from the start to support a wide range of programming languages. It is also expected that ECMA standardization will make the CLI available on a wide range of computing platforms. This combination of multi-language capability and multiplatform implementation make the CLI an important target for future language compilers. In this paper, the technical details of the CLI are briefly described. To motivate some of the discussion a comparison is made with the Java virtual machine (JVM). The JVM was designed under rather different constraints, making it a much more difficult target for languages other than Java . We also briefly discuss the issues involved in mapping various language constructs to the primitives of the CLI.

Abstract: The term aspect-oriented programming (AOP) has come to describe the set of programming mechanisms developed specifically to express crosscutting concerns. Since crosscutting concerns cannot be properly modularized within object-oriented programming, they are expressed as aspects and are composed, or woven, with traditionally encapsulated functionality referred to as components.Many AOP models exist, but their implementations are typically coupled with a single language. To allow weaving of existing components with aspects written in the language of choice, AOP requires a language-independent tool.

Abstract: Microsoft's Shared Source CLI (code-named "Rotor") is the publicly available implementation of the ECMA Common Language Infrastructure (CLI) and the ECMA C# language specification Loaded with three million lines of source code, it presents a wealth of programming language technology that targets developers interested in the internal workings of the Microsoft NET Framework, academics working with advanced compiler technology, and people developing their own CLI implementations The CLI, at its heart, is an approach to building software that enables code from many independent sources to co-exist and interoperate safely Shared Source CLI Essentials is a companion guide to Rotor's code This concise and insightful volume provides a road map for anyone wishing to navigate, understand, or alter the Shared Source CLI code This book illustrates the design principles used in the CLI standard and discusses the complexities involved when building virtual machines Included with the book is a CD-ROM that contains all the source code and files After introducing the CLI, its core concepts, and the Shared Source CLI implementation, Shared Source CLI Essentials covers these topics: The CLI type systemComponent packaging and assembliesType loading and JIT CompilationManaged code and the execution engineGarbage collection and memory managementThe Platform Adaptation Layer (PAL): a portability layer for Win32®, Mac OS® X, and FreeBSD Written by members of the core Microsoft® team that designed the NET Framework, Shared Source CLI Essentials is for anyone who wants a deeper understanding of what goes on under the hood of the NET runtime and the ECMA CLI Advanced NET programmers, researchers, the academic community, and CLI implementers who have asked hard questions about the NET Framework will find that this behind-the-scenes look at the NET nucleus provides them with excellent resources from which they can extract answers

Abstract: The Open Runtime Platform (ORP) is a high-performance managed runtime environment (MRTE) that features exact generational garbage collection, fast thread synchronization, and multiple coexisting just-in-time compilers (JITs). ORP was designed for flexibility in order to support experiments in dynamic compilation, garbage collection, synchronization, and other technologies. It can be built to run either Java or Common Language Infrastructure (CLI) applications, to run under the Windows or Linux operating systems, and to run on the IA-32 or Itanium processor family (IPF) architectures. Achieving high performance in a MRTE presents many challenges, particularly when flexibility is a major goal. First, to enable the use of different garbage collectors and JITs, each component must be isolated from the rest of the environment through a well-defined software interface. Without careful attention, this isolation could easily harm performance. Second, MRTEs have correctness and safety requirements that traditional languages such as C++ lack. These requirements, including null pointer checks, array bounds checks, and type checks, impose additional runtime overhead. Finally, the dynamic nature of MRTEs makes some traditional compiler optimizations, such as devirtualization of method calls, more difficult to implement or more limited in applicability. To get full performance, JITs and the core virtual machine (VM) must cooperate to reduce or eliminate (where possible) these MRTE-specific overheads. In this paper, we describe the structure of ORP in detail, paying particular attention to how it supports flexibility while preserving high performance. We describe the interfaces between the garbage collector, the JIT, and the core VM; how these interfaces enable multiple garbage collectors and JITs without sacrificing performance; and how they allow the JIT and the core VM to reduce or eliminate MRTE-specific performance issues. Copyright © 2005 John Wiley & Sons, Ltd.