As software becomes increasingly complex and difficult to analyze, it is more and more common for developers to use high-level, type-safe, object-oriented (OO) programming languages and to architect systems that comprise multiple components. Different components are often implemented in different programming languages. In state-of-the-art multicomponent, multi-language systems, cross-component communication relies on remote procedure calls (RPC) and message passing. As components are increasingly co-located on the same physical machine to ensure high utilization of multi-core systems, there is a growing potential for using shared memory for cross-language cross-runtime communication.

The growth in complexity of modern systems makes it increasingly difficult to extract high-performance. The software stacks for such systems typically consist of multiple layers and include managed runtime environments (MREs). In this paper, we investigate techniques to improve cooperation between these layers and the hardware to increase the efficacy of automatic memory management in MREs.

Compactors that move or copy objects need to adjust pointers. In extant compactors, pointer adjustment involves inspecting every pointer in the heap and computing the target address for each pointer. At the same time, in modern Managed Runtime Environments (MREs), only a fraction of pointers in the heap changes during compaction. This is because state-of-the-art MREs do not compact the prefix of the heap that contains few dead objects, allowing gaps between live objects and tolerating small space overhead. We describe the design and implementation of the Single-Referent Collector (SRC), a new compactor that reduces the cost of pointer manipulation by avoiding inspection and adjustment of pointers that do not change. SRC exploits the fact that in modern applications, most live objects have only one incoming pointer. For such objects, SRC stores the address of the referent in the object header. Only objects that move have their referent inspected and adjusted. The remaining pointers in the heap are not processed. SRC uses an overflow table to handle objects with multiple incoming pointers. We investigate a number of standard benchmarks and open-source applications to substantiate key statistical observations that underlie the design of SRC. We implement SRC in the HotSpot JVM as part of a generational collection system and compare it empirically with the Lisp2 compactor. We find that, by decreasing the cost of pointer processing, SRC enables significant reduction in pause times and improves application throughput.

Parallel and concurrent garbage collectors are increasingly employed by managed runtime environments (MREs) to maintain scalability, as multi-core architectures and multi-threaded applications become pervasive. Moreover, state-of-the-art MREs commonly implement compaction to eliminate heap fragmentation and enable fast linear object allocation.

Developers commonly build contemporary enterprise applications using type-safe, component-based platforms, such as J2EE, and architect them to comprise multiple tiers, such as a web container, application server, and database engine. Administrators increasingly execute each tier in its own managed runtime environment (MRE) to improve reliability and to manage system complexity through the fault containment and modularity offered by isolated MRE instances. Such isolation, however, necessitates expensive cross-tier communication based on protocols such as object serialization and remote procedure calls. Administrators commonly co-locate communicating MREs on a single host to reduce communication overhead and to better exploit increasing numbers of available processing cores. However, state-of-the-art MREs offer no support for more efficient communication between co-located MREs, while fast inter-process communication mechanisms, such as shared memory, are widely available as a standard operating system service on most modern platforms.

Modern, resource-intensive enterprise and scientific applications are increasingly architected using parallel and distributed components deployed on grid platforms. Grid environments are typically heterogeneous and subject to large load variations. Such characteristics require a portable programming infrastructure and comprehensive support for resource management as well as dynamic adaptation to varying resource availability. Resource-aware applications pro-actively monitor and dynamically adapt their behavior to accommodate to changing resource consumption constraints. Strategies such as internal load-balancing and job re-submission can correct sub-optimal scheduling decisions and thus enhance performance. As utilizing the potential of resource awareness requires close interaction with resource management subsystems, implementations often rely on low-level, platform-specific features, which impair portability. What is needed is uncompromised portability of all aspects of resource management in grid systems. We demonstrate that the Java platform, equipped with the APIs for distributed resource management, can be used for building a portable grid infrastructure. In particular, we describe the design and implementation of a cluster management system capable of controlled execution of parallel, resource-aware Java applications. We empirically show that our solution allows for efficient, fine-grained resource management, sufficient for tapping the performance benefits promised by the resource-conscious applications.

Enterprise applications are increasingly being built using type-safe programming platforms and deployed over horizontally scalable systems. Horizontal scalability depends crucially on the ability to monitor resource usage and to define and enforce resource management policies capable of guaranteeing a desired service level. However, current safe language platforms have very limited support for resource management, and their cluster-enabled versions reflect this deficiency. We describe an architecture of federated Java/spl trade/ virtual machines. Its distinguishing feature is an integrated resource management interface that addresses the above issues. It offers programmatic control over monitoring and controlling the allocation of resources to applications and their components. The scope of each policy can span multiple nodes, realizing finegrained control. New resource types can be defined and integrated into the framework. Remote management of local resources and the notion of cluster-global resources form a powerful combination capable of expressing policies that achieve effective performance isolation for cluster applications.