This document describes a new Java virtual machine called Fiji VM that targets real-time embedded systems. The Fiji VM ahead-of-time compiles Java bytecode to C code to run on embedded hardware with minimal overhead. Evaluation shows the Fiji VM can achieve throughput close to C for a collision detection benchmark on a LEON3 processor, while still meeting hard real-time deadlines through the use of a concurrent, real-time garbage collector.
This document discusses how to write shared libraries. It begins with a brief history of shared libraries for Linux, noting the limitations of the original a.out format. It then summarizes some of the drawbacks of the a.out approach for shared libraries, before introducing ELF (Executable and Linkable Format) as an improved standard. The document stresses that while ELF removes many restrictions, there are still rules that must be followed to generate decent code from shared libraries and additional techniques required for optimized code.
A New Paradigm In Linux Debug From Viosoft Corporationart_lee
1) The Arriba Debugger provides a holistic approach to debugging embedded Linux through its VMON module, which has minimal performance impact and provides full visibility of the Linux target.
2) It addresses traditional limitations by enabling debugging of loadable modules, multiple processes, and production kernels without altering target performance.
3) The Arriba Debugger integrates with the Eclipse IDE and includes the Linux Event Analyzer tool for profiling Linux events with minimal overhead.
A DSEL for Addressing the Problems Posed by Parallel ArchitecturesJason Hearne-McGuiness
The document proposes a domain-specific embedded language (DSEL) to address issues with programming parallel architectures. The DSEL aims to add parallelism capabilities to an existing language with minimal changes. It defines types like thread pools and safe collections. The DSEL is designed to provide guarantees around correctness and efficiency of generated schedules while avoiding issues with other parallel programming approaches. An implementation in C++ exists to demonstrate the DSEL.
A New Paradigm In Linux Debug From Viosoftguestc28df4
1) The Arriba Debugger provides a holistic approach to debugging embedded Linux through its VMON module, which has minimal performance impact and provides full visibility of the Linux target.
2) It addresses traditional limitations by enabling debugging of loadable modules, multiple processes, and production kernels without halting the target.
3) The Arriba Debugger and Linux Event Analyzer integrate with Eclipse and provide a comprehensive Linux development environment.
This paper presents an automated approach for high-quality preview rendering during lighting design for feature films. The system automatically generates a deep framebuffer and shaders from unmodified RenderMan scenes and shaders to enable interactive previews as lights are adjusted. It introduces an indirect framebuffer to efficiently handle antialiasing, motion blur, and transparency. Progressive refinement allows previews at coarse resolution with final quality after a few seconds. The system is being used in two major studios and demonstrates the approach on real-world production scenes.
Activiti is an open source BPM platform that is lightweight, collaborative, and standards-based using Java. It includes features like mobile clients, integration with frameworks like Spring and services like BPM, ECM, and optional connectivity. The camunda fox BPM platform is based on Activiti and includes additional components for monitoring, modeling, and development support on Java EE containers. Camunda provides training and support for both the open source and commercial editions of Activiti and fox.
This document summarizes a presentation about PlateSpin technology for simplifying data center management. The presentation covers challenges with current data center management, an overview of PlateSpin technology including workload portability and disaster recovery, and a demo of PlateSpin Forge. Attendees are offered special discounts and consulting services for implementing PlateSpin solutions within the next 60 days.
Developing Safety-Critical Java Applications with oSCJ Aleš Plšek
We present oSCJ, an implementation of the draft of Safety Critical Java (SCJ) specification. SCJ is designed to make Java amenable to writing mission- and safety-critical soft- ware. It does this by defining a subset of the Real-time Specification for Java that trades expressiveness for verifia- bility. This paper gives a high-level description of our im- plementation of the first compliance level of the SCJ speci- fication, a library called oSCJ, and reports on performance evaluation on the Ovm real-time Java virtual machine. We compare SCJ to C on both a real-time operating system on the LEON3 platform and Linux on a x86. Our results suggest that a high-degree of predictability and competitive performance can indeed be achieved.
This document discusses how to write shared libraries. It begins with a brief history of shared libraries for Linux, noting the limitations of the original a.out format. It then summarizes some of the drawbacks of the a.out approach for shared libraries, before introducing ELF (Executable and Linkable Format) as an improved standard. The document stresses that while ELF removes many restrictions, there are still rules that must be followed to generate decent code from shared libraries and additional techniques required for optimized code.
A New Paradigm In Linux Debug From Viosoft Corporationart_lee
1) The Arriba Debugger provides a holistic approach to debugging embedded Linux through its VMON module, which has minimal performance impact and provides full visibility of the Linux target.
2) It addresses traditional limitations by enabling debugging of loadable modules, multiple processes, and production kernels without altering target performance.
3) The Arriba Debugger integrates with the Eclipse IDE and includes the Linux Event Analyzer tool for profiling Linux events with minimal overhead.
A DSEL for Addressing the Problems Posed by Parallel ArchitecturesJason Hearne-McGuiness
The document proposes a domain-specific embedded language (DSEL) to address issues with programming parallel architectures. The DSEL aims to add parallelism capabilities to an existing language with minimal changes. It defines types like thread pools and safe collections. The DSEL is designed to provide guarantees around correctness and efficiency of generated schedules while avoiding issues with other parallel programming approaches. An implementation in C++ exists to demonstrate the DSEL.
A New Paradigm In Linux Debug From Viosoftguestc28df4
1) The Arriba Debugger provides a holistic approach to debugging embedded Linux through its VMON module, which has minimal performance impact and provides full visibility of the Linux target.
2) It addresses traditional limitations by enabling debugging of loadable modules, multiple processes, and production kernels without halting the target.
3) The Arriba Debugger and Linux Event Analyzer integrate with Eclipse and provide a comprehensive Linux development environment.
This paper presents an automated approach for high-quality preview rendering during lighting design for feature films. The system automatically generates a deep framebuffer and shaders from unmodified RenderMan scenes and shaders to enable interactive previews as lights are adjusted. It introduces an indirect framebuffer to efficiently handle antialiasing, motion blur, and transparency. Progressive refinement allows previews at coarse resolution with final quality after a few seconds. The system is being used in two major studios and demonstrates the approach on real-world production scenes.
Activiti is an open source BPM platform that is lightweight, collaborative, and standards-based using Java. It includes features like mobile clients, integration with frameworks like Spring and services like BPM, ECM, and optional connectivity. The camunda fox BPM platform is based on Activiti and includes additional components for monitoring, modeling, and development support on Java EE containers. Camunda provides training and support for both the open source and commercial editions of Activiti and fox.
This document summarizes a presentation about PlateSpin technology for simplifying data center management. The presentation covers challenges with current data center management, an overview of PlateSpin technology including workload portability and disaster recovery, and a demo of PlateSpin Forge. Attendees are offered special discounts and consulting services for implementing PlateSpin solutions within the next 60 days.
Developing Safety-Critical Java Applications with oSCJ Aleš Plšek
We present oSCJ, an implementation of the draft of Safety Critical Java (SCJ) specification. SCJ is designed to make Java amenable to writing mission- and safety-critical soft- ware. It does this by defining a subset of the Real-time Specification for Java that trades expressiveness for verifia- bility. This paper gives a high-level description of our im- plementation of the first compliance level of the SCJ speci- fication, a library called oSCJ, and reports on performance evaluation on the Ovm real-time Java virtual machine. We compare SCJ to C on both a real-time operating system on the LEON3 platform and Linux on a x86. Our results suggest that a high-degree of predictability and competitive performance can indeed be achieved.
This document summarizes an IT solutions company called Electric Cloud. It discusses:
1. The company was founded in 2002 and has grown to 90 employees, shipping products since 2004 and being cash flow positive and ahead of operating plan.
2. Electric Cloud's vision is to lead the market for Software Production Management solutions to remove software production bottlenecks and increase productivity up to 15 times.
3. Electric Cloud's solutions include ElectricCommander to automate processes, ElectricAccelerator to accelerate builds up to 20 times faster, and ElectricInsight for analytics.
BM Real-time Technologies for SUSE Linux Enterprise Real TimeNovell
The need for real-time quality of service (QoS) has been around for years. However, in the past, real-time solutions required custom-built hardware, proprietary real-time operating systems, and specialized skills in C, C++, or ADA. All of this has made the solutions expensive to create and maintain. With the industry now moving increasingly to open standards, IBM and Novell have recognized the opportunity to combine x86 hardware, Linux and WebSphere products to provide real-time response times.
IBM real-time technologies combine select IBM System x hardware that is optimized for real-time workloads with WebSphere Real Time for SUSE Linux Enterprise Real Time for hard real-time QoS, and WebSphere Virtual Enterprise with WebSphere Real Time for SUSE Linux Enterprise Server for differentiated soft real-time QoS. In this session, you will learn about these technologies and how to benefit from them.
The document discusses the Dalvik virtual machine (VM) used in Android. It begins by explaining what a VM is and the basic parts that make up a VM. It then discusses the differences between stack-based and register-based VMs, noting that Dalvik uses a register-based architecture. The document explains that Dalvik was chosen for Android because it executes instructions more efficiently than Java VM and requires less memory. It also discusses just-in-time (JIT) compilation techniques used to improve performance of interpreted code. Specifically, Dalvik uses a trace JIT that compiles short sequences of instructions to optimize mobile performance.
Correlation of simulation_models_using_concept_modelingSalvatore Scalera
Pre-requisite for efficient vehicle programs is the CAE driven development process. The accuracy of the models increases over time and leads to an increasing amount of available Concept models in databases. Due to the
increased acceleration of the development process, these models are critical in providing direction on vehicle architecture in the early stages of a program.
Due to the high importance of these decisions it is mandatory to trust the results of this early CAE models. Correlation of this Concept models to test or
reference mainstream CAE models creates the confidence in this approach. The correlation focuses on two aspects: 1. the level of detail required to capture
the detailed folding characteristic of the structure (e.g. siderail or B-Pillar) and 2. the process chain used to process the raw output from SFE Concept into
RADIOSS Include files (e.g. gap, contacts, spot-welding, adhesives, bolts). This process chain is implemented using HyperMesh in batch mode, details may
be found in [4]. This process chain is tuned to latest program modeling approaches and to meet the desired correlation status.
In this presentation RADIOSS safety concept models are correlated to different impact modes. Tools and methods are explained focusing on both the
automated evaluation of simulation output and the judgment of the correlation quality.
1. The document discusses real-time programming in Java, including an overview of real-time systems, real-time operating systems, and challenges in real-time programming.
2. It describes the Real-Time Specification for Java (RTSJ), which aims to make Java suitable for real-time applications by adding features like priority-based scheduling, memory areas, and asynchronous event handling.
3. The document also discusses real-time garbage collection techniques and limitations, and the future of real-time Java with standards like RTSJ and Safety-Critical Java.
The document discusses the advantages and disadvantages of embedded Java technology. It outlines the Real-Time Specification for Java (RTSJ), which provides standards for memory management, threading, and real-time capabilities. The RTSJ aims to improve performance and determinism for real-time Java applications through features like prioritized memory areas, asynchronous event handling, and enhanced threading controls. While interpreted Java can be slower than C, techniques like ahead-of-time compilation and dynamic optimization are helping to close the performance gap for embedded systems.
Jam BW is a Java-based biologist created by Afsheen Khalid, a student at the University of Education in Okara, Pakistan. The document discusses how Java applications are platform independent and can be run on any computer. It also covers some of the software problems with third-party applications, the services provided by networked computers, how laboratory devices could be programmed with Java, and how this could lead to the creation of virtual robots.
The real time publisher subscriber inter-process communication model for dist...yancha1973
1) The document proposes a real-time publisher/subscriber model for inter-process communication in distributed real-time systems.
2) In the model, processes publish and subscribe to messages using logical handles called distribution tags, without knowledge of senders/receivers.
3) An application programming interface is presented that allows processes to create/destroy tags, publish/receive messages, and query senders/receivers.
4) The model is fault-tolerant, supporting applications like clock synchronization across nodes and allowing processes to be upgraded online.
Ensuring High-performance of Mission-critical Java Applications in Multi-tena...Zhenyun Zhuang
The document discusses problems with ensuring high performance of mission-critical Java applications in multi-tenant cloud environments. It identifies issues caused by resource sharing between applications on the same platform, such as memory pressure triggering page swapping and direct reclaiming, which can severely degrade Java application performance through increased garbage collection pauses and reduced throughput. The authors investigate two scenarios in a production environment and determine that transparent huge pages, memory pressure from other applications, and interactions between the JVM and Linux memory management are key factors impacting Java application performance in multi-tenant cloud setups.
This paper presents an improved hardware acceleration scheme for Java method calls in the REALJava coprocessor. The strategy is implemented in an FPGA prototype and allows for measuring real performance increases. It validates the coprocessor concept for accelerating Java bytecode execution in embedded systems with limited CPU performance and memory availability. The coprocessor architecture is highly modular, separating communication from the execution core to improve reusability and allow for system scalability.
The document provides an overview of real-time Java and its key concepts:
- Real-time means determinism where deadlines must be met, as opposed to just fast throughput.
- The Real-Time Specification for Java (RTSJ) addresses limitations of Java SE for real-time applications like unpredictable delays from class loading and garbage collection.
- RTSJ implementations like IBM WebSphere Real Time and Sun RTS add features like high resolution timers, priority scheduling, and asynchronous event handling.
Atmosphere 2014: Switching from monolithic approach to modular cloud computin...PROIDEA
This presentation is to demonstrate, how the homogenous and centralized network architectures cease to operate efficiently and how limited are our abilities to respond to on-demand computing power in such cases. We will show you how to redesign monolithic storage architectures into modular systems, as well as how to migrate them to a scalable and flexible cloud environment.
Maciej Kuzniar - Founder and CEO of the project Oktawave. Passionate about technology related to the processing and data storage, having 10 years of experience working for enterprise customers (banks, telecoms, fmcg). Author of the concepts that support the development of tech startups and architectural solutions to ensure high HA and SLA for IT systems.
Ironfan is the foundation for your Big Data stack, making provisioning and configuring your Big Data infrastructure simple. Spin up clusters when you need them, kill them when you don't, so you can spend your time, money, and engineering focus on finding insights, not getting your machines ready.
Learn more at http://infochimps.com
The vFabric Cloud Application Platform provides a full suite of products including tc Server, RabbitMQ, GemFire, SQLFire, and App Director to build, deploy, and manage cloud applications on both private and public clouds. It offers developers tools for rapid application development as well as operations tools for automated provisioning and management of applications in production environments. The platform provides a full stack solution for building and running scalable Java applications in private, hybrid, and public cloud environments.
This document proposes improving infrastructure as a service (IaaS) cloud computing by overlapping on-demand resource allocation with opportunistic provisioning of cycles from idle cloud nodes. It extends the Nimbus cloud computing toolkit to deploy backfill virtual machines on idle nodes for high throughput computing workloads. Evaluation shows backfill VMs can increase cloud infrastructure utilization from 38.5% to 100% with only 6.39% overhead for processing workloads, benefiting both cloud providers and users.
A Survey of Performance Comparison between Virtual Machines and Containersprashant desai
Since the onset of Cloud computing and its inroads into infrastructure as a service, Virtualization has become peak
of importance in the field of abstraction and resource management. However, these additional layers of abstraction provided by virtualization come at a trade-off between performance and cost in a cloud environment where everything is on a pay-per-use basis. Containers which are perceived to be the future of virtualization are developed to address these issues. This study paper scrutinizes the performance of a conventional virtual machine and contrasts them with the containers. We cover the critical
assessment of each parameter and its behavior when its subjected to various stress tests. We discuss the implementations and their performance metrics to help us draw conclusions on which one is ideal to use for desired needs. After assessment of the result and discussion of the limitations, we conclude with prospects for future research
Performance comparison on java technologies a practical approachcsandit
Performance responsiveness and scalability is a make-or-break quality for software. Nearly
everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The
challenges faced during the life cycle of the project and the mitigation actions performed. It
compares 3 java technologies and shows how improvements are made through statistical
analysis in response time of the application. The paper concludes with result analysis.
PERFORMANCE COMPARISON ON JAVA TECHNOLOGIES - A PRACTICAL APPROACHcscpconf
Performance responsiveness and scalability is a make-or-break quality for software. Nearly everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The challenges faced during the life cycle of the project and the mitigation actions performed. It compares 3 java technologies and shows how improvements are made through statistical analysis in response time of the application. The paper concludes with result analysis.
This document discusses dynamic resource management in the cloud using an algorithm called Nephele. Nephele is a data processing framework that can explicitly exploit dynamic resource allocation in IaaS clouds for task scheduling and execution. Tasks can be assigned to different types of virtual machines that are automatically instantiated and terminated during job execution. The document describes the Nephele architecture, which follows a master-worker pattern. It also discusses challenges around data locality in cloud environments and how Nephele addresses them. Modules of the Nephele system include a job manager, task managers, and a cloud controller for managing resource allocation. The algorithm aims to improve scheduling efficiency and reduce resource overloads.
This document summarizes an IT solutions company called Electric Cloud. It discusses:
1. The company was founded in 2002 and has grown to 90 employees, shipping products since 2004 and being cash flow positive and ahead of operating plan.
2. Electric Cloud's vision is to lead the market for Software Production Management solutions to remove software production bottlenecks and increase productivity up to 15 times.
3. Electric Cloud's solutions include ElectricCommander to automate processes, ElectricAccelerator to accelerate builds up to 20 times faster, and ElectricInsight for analytics.
BM Real-time Technologies for SUSE Linux Enterprise Real TimeNovell
The need for real-time quality of service (QoS) has been around for years. However, in the past, real-time solutions required custom-built hardware, proprietary real-time operating systems, and specialized skills in C, C++, or ADA. All of this has made the solutions expensive to create and maintain. With the industry now moving increasingly to open standards, IBM and Novell have recognized the opportunity to combine x86 hardware, Linux and WebSphere products to provide real-time response times.
IBM real-time technologies combine select IBM System x hardware that is optimized for real-time workloads with WebSphere Real Time for SUSE Linux Enterprise Real Time for hard real-time QoS, and WebSphere Virtual Enterprise with WebSphere Real Time for SUSE Linux Enterprise Server for differentiated soft real-time QoS. In this session, you will learn about these technologies and how to benefit from them.
The document discusses the Dalvik virtual machine (VM) used in Android. It begins by explaining what a VM is and the basic parts that make up a VM. It then discusses the differences between stack-based and register-based VMs, noting that Dalvik uses a register-based architecture. The document explains that Dalvik was chosen for Android because it executes instructions more efficiently than Java VM and requires less memory. It also discusses just-in-time (JIT) compilation techniques used to improve performance of interpreted code. Specifically, Dalvik uses a trace JIT that compiles short sequences of instructions to optimize mobile performance.
Correlation of simulation_models_using_concept_modelingSalvatore Scalera
Pre-requisite for efficient vehicle programs is the CAE driven development process. The accuracy of the models increases over time and leads to an increasing amount of available Concept models in databases. Due to the
increased acceleration of the development process, these models are critical in providing direction on vehicle architecture in the early stages of a program.
Due to the high importance of these decisions it is mandatory to trust the results of this early CAE models. Correlation of this Concept models to test or
reference mainstream CAE models creates the confidence in this approach. The correlation focuses on two aspects: 1. the level of detail required to capture
the detailed folding characteristic of the structure (e.g. siderail or B-Pillar) and 2. the process chain used to process the raw output from SFE Concept into
RADIOSS Include files (e.g. gap, contacts, spot-welding, adhesives, bolts). This process chain is implemented using HyperMesh in batch mode, details may
be found in [4]. This process chain is tuned to latest program modeling approaches and to meet the desired correlation status.
In this presentation RADIOSS safety concept models are correlated to different impact modes. Tools and methods are explained focusing on both the
automated evaluation of simulation output and the judgment of the correlation quality.
1. The document discusses real-time programming in Java, including an overview of real-time systems, real-time operating systems, and challenges in real-time programming.
2. It describes the Real-Time Specification for Java (RTSJ), which aims to make Java suitable for real-time applications by adding features like priority-based scheduling, memory areas, and asynchronous event handling.
3. The document also discusses real-time garbage collection techniques and limitations, and the future of real-time Java with standards like RTSJ and Safety-Critical Java.
The document discusses the advantages and disadvantages of embedded Java technology. It outlines the Real-Time Specification for Java (RTSJ), which provides standards for memory management, threading, and real-time capabilities. The RTSJ aims to improve performance and determinism for real-time Java applications through features like prioritized memory areas, asynchronous event handling, and enhanced threading controls. While interpreted Java can be slower than C, techniques like ahead-of-time compilation and dynamic optimization are helping to close the performance gap for embedded systems.
Jam BW is a Java-based biologist created by Afsheen Khalid, a student at the University of Education in Okara, Pakistan. The document discusses how Java applications are platform independent and can be run on any computer. It also covers some of the software problems with third-party applications, the services provided by networked computers, how laboratory devices could be programmed with Java, and how this could lead to the creation of virtual robots.
The real time publisher subscriber inter-process communication model for dist...yancha1973
1) The document proposes a real-time publisher/subscriber model for inter-process communication in distributed real-time systems.
2) In the model, processes publish and subscribe to messages using logical handles called distribution tags, without knowledge of senders/receivers.
3) An application programming interface is presented that allows processes to create/destroy tags, publish/receive messages, and query senders/receivers.
4) The model is fault-tolerant, supporting applications like clock synchronization across nodes and allowing processes to be upgraded online.
Ensuring High-performance of Mission-critical Java Applications in Multi-tena...Zhenyun Zhuang
The document discusses problems with ensuring high performance of mission-critical Java applications in multi-tenant cloud environments. It identifies issues caused by resource sharing between applications on the same platform, such as memory pressure triggering page swapping and direct reclaiming, which can severely degrade Java application performance through increased garbage collection pauses and reduced throughput. The authors investigate two scenarios in a production environment and determine that transparent huge pages, memory pressure from other applications, and interactions between the JVM and Linux memory management are key factors impacting Java application performance in multi-tenant cloud setups.
This paper presents an improved hardware acceleration scheme for Java method calls in the REALJava coprocessor. The strategy is implemented in an FPGA prototype and allows for measuring real performance increases. It validates the coprocessor concept for accelerating Java bytecode execution in embedded systems with limited CPU performance and memory availability. The coprocessor architecture is highly modular, separating communication from the execution core to improve reusability and allow for system scalability.
The document provides an overview of real-time Java and its key concepts:
- Real-time means determinism where deadlines must be met, as opposed to just fast throughput.
- The Real-Time Specification for Java (RTSJ) addresses limitations of Java SE for real-time applications like unpredictable delays from class loading and garbage collection.
- RTSJ implementations like IBM WebSphere Real Time and Sun RTS add features like high resolution timers, priority scheduling, and asynchronous event handling.
Atmosphere 2014: Switching from monolithic approach to modular cloud computin...PROIDEA
This presentation is to demonstrate, how the homogenous and centralized network architectures cease to operate efficiently and how limited are our abilities to respond to on-demand computing power in such cases. We will show you how to redesign monolithic storage architectures into modular systems, as well as how to migrate them to a scalable and flexible cloud environment.
Maciej Kuzniar - Founder and CEO of the project Oktawave. Passionate about technology related to the processing and data storage, having 10 years of experience working for enterprise customers (banks, telecoms, fmcg). Author of the concepts that support the development of tech startups and architectural solutions to ensure high HA and SLA for IT systems.
Ironfan is the foundation for your Big Data stack, making provisioning and configuring your Big Data infrastructure simple. Spin up clusters when you need them, kill them when you don't, so you can spend your time, money, and engineering focus on finding insights, not getting your machines ready.
Learn more at http://infochimps.com
The vFabric Cloud Application Platform provides a full suite of products including tc Server, RabbitMQ, GemFire, SQLFire, and App Director to build, deploy, and manage cloud applications on both private and public clouds. It offers developers tools for rapid application development as well as operations tools for automated provisioning and management of applications in production environments. The platform provides a full stack solution for building and running scalable Java applications in private, hybrid, and public cloud environments.
This document proposes improving infrastructure as a service (IaaS) cloud computing by overlapping on-demand resource allocation with opportunistic provisioning of cycles from idle cloud nodes. It extends the Nimbus cloud computing toolkit to deploy backfill virtual machines on idle nodes for high throughput computing workloads. Evaluation shows backfill VMs can increase cloud infrastructure utilization from 38.5% to 100% with only 6.39% overhead for processing workloads, benefiting both cloud providers and users.
A Survey of Performance Comparison between Virtual Machines and Containersprashant desai
Since the onset of Cloud computing and its inroads into infrastructure as a service, Virtualization has become peak
of importance in the field of abstraction and resource management. However, these additional layers of abstraction provided by virtualization come at a trade-off between performance and cost in a cloud environment where everything is on a pay-per-use basis. Containers which are perceived to be the future of virtualization are developed to address these issues. This study paper scrutinizes the performance of a conventional virtual machine and contrasts them with the containers. We cover the critical
assessment of each parameter and its behavior when its subjected to various stress tests. We discuss the implementations and their performance metrics to help us draw conclusions on which one is ideal to use for desired needs. After assessment of the result and discussion of the limitations, we conclude with prospects for future research
Performance comparison on java technologies a practical approachcsandit
Performance responsiveness and scalability is a make-or-break quality for software. Nearly
everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The
challenges faced during the life cycle of the project and the mitigation actions performed. It
compares 3 java technologies and shows how improvements are made through statistical
analysis in response time of the application. The paper concludes with result analysis.
PERFORMANCE COMPARISON ON JAVA TECHNOLOGIES - A PRACTICAL APPROACHcscpconf
Performance responsiveness and scalability is a make-or-break quality for software. Nearly everyone runs into performance problems at one time or another. This paper discusses about
performance issues faced during one of the project implemented in java technologies. The challenges faced during the life cycle of the project and the mitigation actions performed. It compares 3 java technologies and shows how improvements are made through statistical analysis in response time of the application. The paper concludes with result analysis.
This document discusses dynamic resource management in the cloud using an algorithm called Nephele. Nephele is a data processing framework that can explicitly exploit dynamic resource allocation in IaaS clouds for task scheduling and execution. Tasks can be assigned to different types of virtual machines that are automatically instantiated and terminated during job execution. The document describes the Nephele architecture, which follows a master-worker pattern. It also discusses challenges around data locality in cloud environments and how Nephele addresses them. Modules of the Nephele system include a job manager, task managers, and a cloud controller for managing resource allocation. The algorithm aims to improve scheduling efficiency and reduce resource overloads.
This document discusses cloud native technologies and continuous integration/continuous delivery (CI/CD) practices.
It defines cloud native as using containers, microservices, immutable infrastructure and other techniques to build scalable applications on public, private or hybrid clouds. These allow for loosely coupled, resilient and observable systems.
The document then discusses how containers enable lightweight packaging and isolation which supports modern development practices. It outlines common cloud native tools and how standardizing on these helps with areas like service communication and monitoring.
Finally, it discusses how adopting CI/CD practices like automated testing, deployment and monitoring can significantly reduce the time it takes to develop and release changes from over 100 minutes to potentially just minutes. This allows for much faster
This document discusses considerations for cross-platform development frameworks. It analyzes existing frameworks like Flutter, React Native, and Weex and identifies opportunities in areas like instant apps and mini programs. The document proposes designing a new framework that adopts a web-first approach using Vue, supports dual rendering modes, and enables seamless cross-device experiences and computing. It also discusses strategies for attracting developers to new ecosystems and supporting mini programs at the virtual DOM level.
This document summarizes the Nephele framework for efficient parallel data processing using Hadoop. Nephele is designed for dynamic and heterogeneous cluster environments. It allows tasks of a processing job to be assigned to different types of virtual machines instantiated and terminated automatically during job execution. This improves resource utilization and reduces processing time and costs compared to other frameworks like Hadoop that are not suitable for dynamic resource allocation in cloud environments. The document discusses related frameworks like SCOPE, SWIFT, Falkon and Hadoop, and explains how Nephele addresses their limitations for parallel processing in clouds.
This document summarizes the Nephele framework for efficient parallel data processing using Hadoop. Nephele is designed for dynamic and heterogeneous cloud environments. It allows tasks of a job to be assigned to different types of virtual machines that are automatically instantiated and terminated during job execution. The document compares Nephele to other frameworks like Hadoop, SCOPE, SWIFT, and Falkon. Evaluation results show Nephele improves resource utilization and reduces processing time and cost compared to Hadoop by dynamically allocating resources based on workload. Future work aims to further improve Nephele's ability to adapt to resource overload or underutilization during job execution.
Similar to High level programming of embedded hard real-time devices (20)
This document discusses using multithreading in Java with LEJOS to control a line following robot. It presents the original single-threaded code and then improves it using two threads - one for line following and one for obstacle detection. The main program starts each thread and uses a DataExchange class to allow the threads to communicate and coordinate the robot's behavior. When no obstacles are detected, the line following thread controls the motors to follow a black line. When an obstacle is detected within 25cm, the obstacle detection thread stops the line following behavior.
Runtime performance evaluation of embedded softwareMr. Chanuwan
The document describes a system for measuring runtime performance of embedded software. The system makes minor changes to the real-time kernel to enable measuring execution times of processes and programs without significantly impacting performance. It was used to evaluate a real-time garbage collector and provided valuable debugging information. The system assigns unique IDs to processes and interrupts and calls an output function on certain events to log identification numbers for external analysis of timing and scheduling.
Performance testing based on time complexity analysis for embedded softwareMr. Chanuwan
The document discusses performance testing of embedded software based on time complexity analysis. It presents a method to:
1) Statically analyze software modules and compute their time complexity based on architecture design.
2) Collect runtime data from modules during testing to compare actual vs expected time complexity and detect abnormalities.
3) Experiments on an embedded human-machine interface project showed the method can find inconsistencies between design and implementation.
High-Performance Timing Simulation of Embedded SoftwareMr. Chanuwan
This paper presents a hybrid approach for high-performance timing simulation of embedded software. The approach combines static execution time analysis and back-annotation of timing information into a SystemC model. In the first step, static timing analysis determines the cycle count for each basic block using processor models. This timing information is then back-annotated into SystemC. Dynamic effects like branches and caches are handled by instrumentation code. The generated code can be simulated with 90% of the speed of untimed software. This hybrid approach aims to achieve fast and accurate timing simulation of embedded software.
High performance operating system controlled memory compressionMr. Chanuwan
This document describes a new software-based online memory compression algorithm that can increase available memory for applications by 150% without modifying applications or hardware. The algorithm, called pattern-based partial match (PBPM), explores frequent patterns within memory words and exploits similarities between words to achieve high compression ratios comparable to Lempel-Ziv compression but with half the runtime. An adaptive memory management technique is also presented to pre-allocate memory for compressed data, further increasing available memory by up to 13%. Experimental results found these techniques effective at doubling the usable memory for a wide range of applications on an embedded portable device.
Performance and memory profiling for embedded system designMr. Chanuwan
1. Memtrace is a profiling tool that provides fast and accurate performance and memory access analysis of embedded systems.
2. It analyzes memory accesses and timing of applications running on an instruction set simulator without needing instrumentation code.
3. Memtrace generates detailed profiling results for each function and variable that can be used to optimize software, design hardware accelerators, and schedule system tasks.
Application scenarios in streaming oriented embedded-system designMr. Chanuwan
This document introduces the concept of application scenarios for streaming-oriented embedded system design. It defines application scenarios as sets of similar operation modes grouped by their resource usage. The document outlines a three-step methodology for incorporating application scenarios into the design process: 1) discovering scenarios by identifying and clustering similar operation modes, 2) deriving predictors to determine the active scenario, and 3) exploiting scenarios to optimize design aspects like energy efficiency. It also discusses different ways to classify and discover scenarios, and provides examples of how previous works have used scenarios to optimize memory usage, voltage scaling, and multi-task scheduling.
Software performance simulation strategies for high-level embedded system designMr. Chanuwan
This document discusses software performance simulation strategies for high-level embedded system design. It introduces instruction set simulators (ISSs), which are accurate but slow. It also discusses binary-level simulation (BLS) and source-level simulation (SLS), which are faster approaches based on native execution. The document proposes a new approach called intermediate source code instrumentation based simulation (iSciSim) that aims to achieve high accuracy, speed, and low complexity for system-level design space exploration.
Object and method exploration for embedded systemsMr. Chanuwan
This document discusses methodologies for exploring object-oriented software design for embedded systems. It introduces a two-part methodology: 1) Method exploration optimizes method implementations by automatically selecting software/hardware components to match application requirements. 2) Object exploration explores object organization by transforming dynamic allocations to static to reduce overhead while maintaining low memory costs. Experimental results on an MP3 player show this design space exploration can provide solutions optimized for performance, energy use, and memory footprint.
A system for performance evaluation of embedded softwareMr. Chanuwan
The document proposes a performance evaluation system for embedded software. The system consists of a code analyzer, testing agents, data analyzer, and report viewer. The code analyzer inserts additional code into the source code and compiles it. Testing agents execute performance tests on the target system. The data analyzer translates raw test results into APIs. The report viewer provides graphical reports using the APIs. The system aims to help developers easily and intuitively analyze software performance without additional hardware.
Embedded architect a tool for early performance evaluation of embedded softwareMr. Chanuwan
The tool Embedded Architect provides a way to evaluate software performance early in the design process for embedded systems. It allows specifying an "evaluation scenario" based on representative control flows extracted from software source code. This scenario serves as the context for estimating execution time on different candidate architectures. The tool automates much of the scenario specification process and generates performance estimates based on architecture mappings and component parameters.
Performance prediction for software architecturesMr. Chanuwan
The document proposes an approach called APPEAR for predicting software performance in component-based systems. APPEAR uses both structural and statistical modeling techniques. It consists of two main parts: (1) calibrating a statistical regression model by measuring performance of existing applications, and (2) using the calibrated model to predict performance of new applications. Both parts are based on a model that describes relevant execution properties in terms of a "signature". The method supports flexible choice of parts modeled structurally versus statistically. It is being validated on two industrial case studies.
Model-Based Performance Prediction in Software Development: A SurveyMr. Chanuwan
This document provides a survey of model-based approaches for predicting software performance early in the development lifecycle. It reviews approaches that use queueing networks, stochastic Petri nets, and other models. The approaches are evaluated based on how integrated the software and performance models are, how early performance analysis can be done in the lifecycle, and the level of automation support. The survey finds that while progress has been made, fully integrated solutions spanning the entire lifecycle are still needed. Promising future work includes approaches with more semantic integration of models and higher degrees of automation.
Unlocking Productivity: Leveraging the Potential of Copilot in Microsoft 365, a presentation by Christoforos Vlachos, Senior Solutions Manager – Modern Workplace, Uni Systems
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
20 Comprehensive Checklist of Designing and Developing a WebsitePixlogix Infotech
Dive into the world of Website Designing and Developing with Pixlogix! Looking to create a stunning online presence? Look no further! Our comprehensive checklist covers everything you need to know to craft a website that stands out. From user-friendly design to seamless functionality, we've got you covered. Don't miss out on this invaluable resource! Check out our checklist now at Pixlogix and start your journey towards a captivating online presence today.
UiPath Test Automation using UiPath Test Suite series, part 6DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 6. In this session, we will cover Test Automation with generative AI and Open AI.
UiPath Test Automation with generative AI and Open AI webinar offers an in-depth exploration of leveraging cutting-edge technologies for test automation within the UiPath platform. Attendees will delve into the integration of generative AI, a test automation solution, with Open AI advanced natural language processing capabilities.
Throughout the session, participants will discover how this synergy empowers testers to automate repetitive tasks, enhance testing accuracy, and expedite the software testing life cycle. Topics covered include the seamless integration process, practical use cases, and the benefits of harnessing AI-driven automation for UiPath testing initiatives. By attending this webinar, testers, and automation professionals can gain valuable insights into harnessing the power of AI to optimize their test automation workflows within the UiPath ecosystem, ultimately driving efficiency and quality in software development processes.
What will you get from this session?
1. Insights into integrating generative AI.
2. Understanding how this integration enhances test automation within the UiPath platform
3. Practical demonstrations
4. Exploration of real-world use cases illustrating the benefits of AI-driven test automation for UiPath
Topics covered:
What is generative AI
Test Automation with generative AI and Open AI.
UiPath integration with generative AI
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
Maruthi Prithivirajan, Head of ASEAN & IN Solution Architecture, Neo4j
Get an inside look at the latest Neo4j innovations that enable relationship-driven intelligence at scale. Learn more about the newest cloud integrations and product enhancements that make Neo4j an essential choice for developers building apps with interconnected data and generative AI.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
“An Outlook of the Ongoing and Future Relationship between Blockchain Technologies and Process-aware Information Systems.” Invited talk at the joint workshop on Blockchain for Information Systems (BC4IS) and Blockchain for Trusted Data Sharing (B4TDS), co-located with with the 36th International Conference on Advanced Information Systems Engineering (CAiSE), 3 June 2024, Limassol, Cyprus.
High level programming of embedded hard real-time devices
1. High-level Programming of Embedded Hard Real-Time Devices
Filip Pizlo Lukasz Ziarek Ethan Blanton Petr Maj† Jan Vitek†
Fiji Systems Inc. † Purdue University
Abstract 1. Introduction
While managed languages such as C# and Java have become Hard real-time software systems must operate in the pres-
quite popular in enterprise computing, they are still consid- ence of strong resource constraints. With applications rang-
ered unsuitable for hard real-time systems. In particular, the ing from satellite control systems to high-frequency algorith-
presence of garbage collection has been a sore point for their mic trading, hard real-time systems vary widely in hardware,
acceptance for low-level system programming tasks. Real- operating system, and programming style. Yet there are
time extensions to these languages have the dubious distinc- important commonalities. Predictability of the software is
tion of, at the same time, eschewing the benefits of high- paramount, with typical systems deployed on uni-processor
level programming and failing to offer competitive perfor- architectures and hard real-time operating systems. The soft-
mance. The goal of our research is to explore the limita- ware is written to be analyzable, with simple control flow
tions of high-level managed languages for real-time systems and no dynamic memory allocation; without the former anal-
programming. To this end we target a real-world embed- ysis of the software is difficult and without the latter it is hard
ded platform, the LEON3 architecture running the RTEMS to make predictable. Therefore, it is common for real-time
real-time operating system, and demonstrate the feasibility programmers to rely on static allocation of data and object
of writing garbage collected code in critical parts of embed- pooling. The programming languages of choice are subsets
ded systems. We show that Java with a concurrent, real-time of C or Ada and for the adventurous C++.
garbage collector, can have throughput close to that of C pro- As the size of real-time code bases keeps increasing –
grams and comes within 10% in the worst observed case on million line systems are not unusual – factors such as pro-
realistic benchmark. We provide a detailed breakdown of the ductivity, reusability, and availability of trained personnel
costs of Java features and their execution times and compare have spurred interest in Java as an alternative to low-level
to real-time and throughput-optimized commercial Java vir- languages and motivated the development of real-time ex-
tual machines. tensions [9]. While Java has had some success in soft real-
time, every attempt that we are aware of to move into hard
Categories and Subject Descriptors D.3.4 [Programming real-time domain ended in defeat. The reasons are multiple.
Languages]: Processors—interpreters, run-time environ- The NASA/JPL Golden Gate project was too early, at the
ments; D.3.3 [Programming Languages]: Language Con- time performance was between 10-100 times slower than
structs and Features—classes and objects; D.4.7 [Operat- C. These conclusions were confirmed by an independent
ing Systems]: Organization and Design—real-time systems study conducted by Thales, which also observed that region-
and embedded systems. based memory management system offered at the time was
difficult to use and error-prone. It was only when IBM re-
General Terms Languages, Experimentation. searchers pushed real-time garbage collection into a produc-
tion VM [2] that Java started gaining traction. Since then,
Keywords Real-time systems, Java virtual machine, Mem- real-time garbage collection has become part of all major
ory management. real-time virtual machines. Unlike regular run-of-the-mill
garbage collection, real-time garbage collection abstractly
limits the impact that memory management can have on the
execution of a thread; either by allowing the collector to be
interrupted at any moment or limiting the collector to small
Permission to make digital or hard copies of all or part of this work for personal or quantums of work. Even with such advances, there is still
classroom use is granted without fee provided that copies are not made or distributed
for profit or commercial advantage and that copies bear this notice and the full citation
significant reluctance to take Java seriously for the most de-
on the first page. To copy otherwise, to republish, to post on servers or to redistribute manding of real-time tasks.
to lists, requires prior specific permission and/or a fee.
Scaling modern, mainstream languages and their associ-
EuroSys’10, April 13–16, 2010, Paris, France.
Copyright c 2010 ACM 978-1-60558-577-2/10/04. . . $5.00. ated runtimes down to resource-constrained embedded set-
2. tings is difficult, especially when hard real-time guarantees speed, we compare the performance of Java programs di-
must be met. This is because virtual machines are usually rectly against C. To our knowledge, this is the first compar-
tuned and engineered for maximal throughput on a small ison of Java to C for a significant real-time benchmark that
set of common benchmarks. Implementation techniques of- takes into account both throughput and predictability. Third,
ten include fast paths for the common case, and expensive we demonstrate the predictability of our garbage collector.
slow-paths for less frequent cases. Examples include inline We want to convince real-time programmers to use dynamic
caches on interface dispatch and type tests. Using bench- memory management provided by garbage collection. This
mark suites to evaluate these optimizations can be mislead- would be a major paradigm shift and a great simplification to
ing, as real-time workloads are unlikely to be represented by, real-time programming. The complexity of managing mem-
e.g. SpecJVM98. Furthermore, to guarantee against deadline ory using object pools has substantial costs both in terms of
misses, one will have to make the pessimistic assumption productivity and ensuring correctness. We also include re-
that all slow paths will be taken, and as a result estimates of sults comparing the performance of our VM to other pro-
the worst-case execution time are likely to be needlessly pes- duction Java virtual machines to better position Fiji VM in
simistic. Support for hard real-time requires an implementa- the space of Java implementations.
tion that targets predictability over throughput and bench-
marks that are representative of real-time workloads. More-
over, evaluations must be done in the context of representa-
2. State of the Art
tive hardware and operating systems. Four commercial Java virtual machines support the Real-
In this work we have selected a platform that has been time Specification for Java (RTSJ) [9]. These are the IBM
deployed on the Venus Express Mission by the European WebSphere Real-time VM [2], SUN’s Java RTS [8], Aonix’s
Space Agency (ESA). The platform’s architecture hails from PERC [26], and Jamaica from AICAS [30]. PERC is note-
the LEON processor family, which implements the SPARC worthy in that it supports features similar to those offered by
v8 instruction set, burnt on a Xilinx FPGA. The preferred the RTSJ but uses its own APIs. All of these systems sup-
real-time operating systems is RTEMS. The ESA use radi- port real-time garbage collection, though the algorithms are
ation hardened memory, either 32 or 64MB, and processors markedly different ranging from time-based to work-based
clocked at 40MHz. Their implementation language is usu- with varying degrees of support for concurrency. In addition,
ally C. Real applications are hard to get a hold of, so we use Oracle’s WebLogic Real-Time and Azul Systems’ virtual
an idealized collision detection algorithm [15] as a work- machine [11] both offer low-pause-time garbage collectors
load. Collision detection algorithms have been implemented that approach real-time performance. The execution strate-
in hardware in radar systems. Our benchmark has similar gies of these systems range from ahead-of-time compilation
characteristics to that of these real applications but is eas- to just-in-time compilation. PERC and Jamaica are the only
ier to retarget to different platforms. In the past, Java has other products currently targeting resource constrained em-
not been deemed suitable for use for what ESA refers to as bedded devices.
BSW (or Basic Software) since Java does not support in- Ovm [1] is the most direct influence on the design of
terrupt handling, measured latencies were too high and the Fiji VM. Ovm is a Java-in-Java metacircular virtual machine
overhead of the Java Native Interface (JNI) was considered that provides hard real-time guarantees. Like the Fiji VM it
prohibitive [17]. generates C code, but it also has an interpreter and just-in-
This paper addresses the perceived shortcomings of Java compiler. It was used in the first Unmanned Aerial Vehicle
in a hard real-time setting. The contributions of our work flight using avionics software written in Java [1] and the first
are threefold. First, we describe a new Java virtual machine open-source real-time garbage collector with high through-
implementation, called Fiji VM, which specifically targets put and good mutator utilization [21]. Ovm lacks function-
real-time embedded systems. Our implementation maps Java ality essential for embedded hard real-time systems. Many
bytecode directly to C leveraging knowledge of the entire applications run on minimal hardware with a small real-
program to generate efficient code. We give a detailed de- time OS kernel and performance close to C. Ovm’s perfor-
scription of how Java is mapped to C from a systems per- mance and footprint prevented us from experimenting with
spective, including a review of overheads that must be in- a wide range of embedded devices. Furthermore, Ovm suf-
troduced to maintain Java compatibility. Though the over- fered from an overly complex design and we could not en-
heads in our VM are similar to other Java virtual machines, vision how the system could ever be certified. JRate was
we are unaware of any concise review of these overheads a contemporary of Ovm that was integrated into the GCC
in the literature. Thus, we hope to help real-time program- compiler [12]. There were early ahead-of-time compilers
mers in understanding the costs of utilizing Java. Second, we that translated Java to C [19, 24] which performed, broadly
demonstrate the feasibility of running full, unmodified, Java speaking, similar static optimizations to those included in
code on an embedded LEON3 platform at high-speed while Fiji VM, but real-time support was not part of their design
meeting hard real-time deadlines. To validate our claims of goals and they targeted older versions of Java making per-
formance comparisons difficult.
3. Real-time garbage collection has been investigated for then, some compiler-inserted null checks will remain. Fiji
many years in the context of Java. Nielsen [20], Baker’s [4] VM never uses virtual memory techniques for null check-
and Henriksson’s [14] early works inspired a number of ing in order to reduce the worst-case cost of a failing null
practical algorithms including the ones used in all com- check. Like most other VMs, we use control flow analysis to
mercial VMs. The IBM Metronome collector uses periodic remove the majority of these checks. A null check is:
scheduling [3] to ensure predictable pause times. Jamaica
if (unlikely(!variable)) throwNPE();
uses a work-based techniques with fragmented objects [29]
to get around the need for a moving collector to fight frag- The out-of-line helper function throwNPE throws a null
mentation. Java RTS [10] uses a non-moving variant of Hen- pointer exception, while the intrinsic helper unlikely hints to
riksson with a scheduler that leverage the slack in real-time the C compiler that the condition is unlikely to be true. On
systems to collect garbage when no real-time task is active. compilers such as GCC, we translate unlikely to a macro for
For overviews of the main alternatives readers are referred that compiler’s branch prediction pragma.
to [16, 22]. The Real-time Specification for Java proposes a
Array bounds checks. Before any access to an array, the
form of region-based allocation to avoid the costs of garbage
compiler checks that the array index is within bounds of
collection. However, it has been found error-prone and in-
the array’s range. Arrays in Java are always indexed in the
curs non-trivial runtime overheads due to dynamic memory
range [0, n − 1], where n is the length given at allocation.
access checks [22].
As with null checks, most implementations will optimize
away these checks – but bounds check removal is nowhere
3. Designing a Real-time Virtual Machine near as successful as null check removal. Thus, these checks
The goal of Fiji VM is to provide developers with an auto- typically incur a runtime penalty. A typical array bound
mated tool for converting high-level, memory safe, Java ap- check is:
plications into small, efficient, and predictable executables
if (unlikely((unsigned)index < (unsigned)array.length))
for a wide range of embedded devices. We focus on ahead-
throwABC();
of-time compilation as an execution strategy. A just-in-time
compiler is under development but it will probably not be de-
Garbage collection checks. Ensuring type-safety requires
ployed on embedded devices. The virtual machine consists
either provably correct manual memory management or
of a compiler, a runtime library, and a choice of open-source
garbage collection. Although beneficial, garbage collection
class libraries. In addition to supporting Java 6 (without dy-
requires run-time checks. Fiji VM requires sync-points and
namic class loading) and JNI 1.4, the Fiji VM has an on-
store barriers. A sync-point checks if the stack of the current
the-fly concurrent real-time garbage collector and supports
thread should be scanned. A store barrier ensures that mod-
region-based allocation in the style of the Real-time Specifi-
ifications to the heap performed by the program are seen by
cation for Java.
the garbage collector, which may be operating concurrently.
3.1 An Ahead-of-time Java Compiler Sync-points are inserted using a policy that ensures that the
worst-case latency between sync-points is bounded. This
Our VM parses Java 1.6 (or earlier) bytecodes and gener-
implies that every loop will have at least one, which hurts
ates ANSI C. The generated code is automatically fed to
performance of tight loops. Optimizations such as loop un-
the chosen C compiler for the target platform, and linked
rolling can alleviate the overheads to some degree. A sync-
against the Fiji runtime, which consists of 10,000 lines of
point looks as follows:
code. Many Java features are mapped directly to C, while
most of the remaining features can be mapped directly, or if (unlikely(threadState−>shouldSync)) synchronize();
through a light-weight wrapper, to OS functionality. The rest
The threadState pointer refers to the VM state for the cur-
– including locking and type checking – is implemented by
rent thread. This includes the boolean field shouldSync,
our VM. Fig. 1 shows a summary of the mapping (with some
which is true when the thread should yield. For high-priority
RTEMS operating system details added for concreteness).
threads which preempt the garbage collector, these checks
We proceed with a detailed description of the various over-
never fire – if the collector is only running when the given
heads involved in compiling Java.
thread is not running, then no additional synchronization is
Java is a type-safe language. The implication for the
required. But, the presence of these checks will still result in
programmer is two-fold: a program that compiles success-
a throughput hit. With virtual memory, these checks can be
fully will never cause memory corruption, and the compiler
converted into the faster:
will insert checks which may incur a runtime performance
penalty. threadState−>poison=0;
Null checks. Before any use of a pointer, the compiler The volatile poison field is on page that is marked as write-
checks that the pointer is non-null. On some platforms, null protected whenever the VM wants the thread to yield. This is
checks may be performed using virtual memory – but even faster as it is a store rather than a load and memory stores are
4. C code implementation for RTEMS Qualitative performance comparison to
Java Source Feature Java Bytecode Feature
under Fiji VM equivalent C/C++ code
Direct C translation (=), except for
Java is slightly slower for pointer
assignments to references, which are also
Assignment (=) pop, dup, load, store, etc. assignments, but equivalent for other
copied into a stack-allocated Frame
assignments.
datastructure.
Simple Arithmetic (+, -, etc.) iadd, isub, imul, etc. Direct C translation (+, -, etc.) Same performance.
Calls to helper functions (Java semantics Java will be slower but not by much;
Division, remainder idiv, irem, etc.
differ from C semantics) division is expensive already.
Numeric casts are directly translated; Same performance. C++'s checked casts
Casts f2i, d2i, i2c, etc., checkcast
checked casts include a type check. are no faster than Java's.
if<cond>, goto, lookupswitch, if, switch, goto. Loops require
if, switch, for, while Small loops will be slower in Java.
tableswitch sync-points (1 load, 1 branch).
invokevirtual, invokeinterface, C function call with additional code at Java method invocation is considerably
Method invocation
invokespecial, invokestatic callsites, prologues, and epilogues slower, but inlining alleviates this.
N/A for C; Java exceptions will be faster
Throw/catch athrow, exception handlers if, goto
than C++ exceptions.
Static initialization - implicit Implicit on invocation, static Run-time check (1 load, 1 branch) on first Slower than C/C++, but often optimized
on first use of class field access, instantiation use away to reduce performance burden.
Null check and direct C pointer Often optimized by compiler to be as fast
Field access putfield, getfield, etc. arithmetic load/store; reference putfield as C, except for reference field stores,
results in addition code for GC barriers. which will incur a penalty.
Null check, array bounds check, array Array accesses are considerably slower in
store check, and C pointer arithmetic Java than in C due to safety checks. Even
Array access iaload, iastore, etc.
load/store. As for fields, GC barriers after optimization, many of these checks
inserted for reference array stores. remain.
C code for bump-pointer allocation. If Faster than C/C++. A garbage collector
this fails, call to helper function. The enables very fast allocation; the work of
new new, newarray, anewarray, etc. entire heap is pre-allocated by Fiji VM by organizing the heap is offloaded to a
a single call to malloc, and then separate task, which can be run in
managed internally. parallel on a multi-core architecture.
C code for fast lock acquisition, call to Faster than C/C++. Like other JVMs, Fiji
helper function on contention. Fiji VM VM has a locking implementation that
synchronized monitorenter, monitorexit
implements its own locks for Java code; outperforms OS-provided locking such as
OS locks are only used internally. pthread_mutex.
Internal Fiji VM implementation written Same performance. Implemented
Object.wait, Object.notify Object.wait, Object.notify
in C. similarly to OS condition variables.
rtems_task API, with additional Fiji VM
java.lang.Thread API java.lang.Thread API per-thread data structures such as Same performance.
ThreadState
I/O libraries (java.io.*, I/O libraries (java.io.*,
POSIX I/O Same performance.
java.nio.*, java.net.*, etc.) java.nio.*, java.net.*, etc.)
Figure 1. Java features and their mapping to C code and/or RTEMS operating system functionality under the Fiji VM.
much faster than loads, furthermore no branch is required. Local variable assignment. Most local variable assign-
However, as RTEMS does not have virtual memory, we rely ments found in Java source are either optimized away by
on the slower version of sync-points. Store barriers are the copy propagation or translated to a C local variable assign-
other source of overheads introduced by garbage collection. ment. However, for any local variable that contains a pointer
Primitive fields (integer, double, etc) need not be tracked, but that is live across an operation that may trigger garbage col-
all modifications to pointer fields are translated to: lection (a sync-point, a Java method call, or a heap alloca-
tion), the variable will be stored into a special data structure.
if (source != null && source.gcState != marked)
This is needed because C compilers do not provide support
mark(source);
for accurate stack scanning. Thus it is up to the VM to en-
target.field = source;
sure that a stack scan will accurately see all live pointers.
The null-check on source is often optimized away, but even We accomplish this by having a stack-allocated data struc-
then, a load and a branch remain in the fast path, and a ture containing copies of local heap references as in [5, 13].
function call on the slow path. Given a local variable assignment a = b, where both are ref-
5. erence types, and a is live across a sync-point, method call, static initializers. Control flow optimization is performed to
or allocation, the compiler emit the following: eliminate redundant initialization checks. Additionally, care
a = b; has been taken to ensure that the standard library classes
Frame.refs[index of a] = a; make minimal use of static initialization, or else to ensure
that the relevant initializers are called manually by the VM
Where Frame is a local struct variable, and index of a is a before program start, thus enabling the compiler to remove
compiler-chosen index for the variable a in the Frame’s list initialization checks for those classes. When a check re-
of references. This instrumentation is inserted rarely enough mains, the code is:
to not significantly impact performance.
if (unlikely(Klass.initState != initialized)) initClass(Klass);
Division and remainder. Java division has slightly differ-
ent semantics than C division. It includes a division-by-zero Klass is a global struct variable containing data about the
check which is done similarly to null-checks, and benefits class in question. Note that C++ has a similar feature to
from similar optimizations. It has slightly different over- Java’s static initializers: a code module may declare global
flow rules which require a helper that performs some ad- variables of object type, and the respective classes may have
ditional checks. We have found that the overhead of calling constructors with arbitrary code. However, unlike our im-
this helper is smaller than the cost of performing a division plementation that uses injected checks, C++ uses sophisti-
on most architectures. Therefore, this does not significantly cated linker techniques to reduce the performance penalty.
contribute to performance overhead. We have considered this, but have not implemented it be-
cause we have not found static initialization to lead to any
Loops. Loops require the insertion of sync-points. For significant overhead in the programs we have thus far tested.
small loops, this is a significant overhead – a loop that would
have otherwise only had a single branch per iteration will Field accesses. Most field accesses are compiled to simple
now have two branches. For large loops, this overhead is load-from-offset or store-to-offset operations in C, thus mak-
negligible. To demonstrate the impact of sync-points, con- ing them as fast as their C equivalents. As mentioned above
sider a program that sums an array of 100,000 integers on a stores to reference fields may include a barrier. Fortunately,
Xeon 2.33 GHz machine running Linux, with the loop be- stores are much less common than loads, and stores of ref-
ing re-executed 10,000 times. The C version needs 63.5 µs erences are less common than stores of primitives. Hence
whereas Java runs in 108.7 µs. A 71% slow down for this these checks end up having a small effect on throughput, as
pathological program. Luckily, benchmarks show, that this documented in [6].
is not representative of the performance of larger programs. Array accesses. Array accesses can be a large source of
Method invocations. A Java method invocation is trans- overheads in Java programs due to the combination of null-
lated to a C function call. Invocations have a number of indi- checks, bounds check, array store check, and store barrier.
rect overheads: (i) spilling of some local variables to the GC Array store checks only apply to stores on object arrays
map stored in the Frame, (ii) checks for exceptions following and are used to ensure that the object being stored is a
the C function’s return, and (iii) additional code to link the subtype of the array element type. This check is needed
Frame to enable stack scans. To mitigate these costs Fiji VM to maintain type safety in the presence of covariant arrays.
does aggressive de-virtualization and inlining. In practice, Put together, these checks may incur a substantial amount
almost all small methods end up being inlined, and methods of overhead in certain programs. However, programs which
thought to be called frequently are also inlined provided that primarily access arrays in a sequential fashion, and primarily
they are not too large. Thus, fewer method invocations will use arrays of primitives, will often have all of these checks
remain than what is apparent in the original program. Recur- eliminated by the compiler.
sive code is penalized by our translation scheme, as recursive Allocation. In Fiji VM, the Java new statement is efficient.
inlining is generally undesirable, but non-recursive code is It is roughly:
usually as fast as the C equivalent.
result = threadState−>bumpPtr + size;
Exception handling. The cost of throwing and catching if (result > threadState−>limitPtr) result = allocSlow();
exceptions is small. All exceptional control flow is converted else threadState−>bumpPtr = result;
to C-style if and goto statements. initObject(result);
Static initialization. Java prescribes that before a class is The code implements bump-pointer allocation, where the
used, it must be initialized. Initialization checks are inserted thread-local bumpPtr indicates the location where the next
before every static method call, static field access, and object object may be placed, and the limitPtr indicates the limit
instantiation. However, optimization is performed on static up to which objects may be safely allocated. If memory is
initializers. Initializers which are simple enough to be exe- plentiful, threads will be given page-size regions to allocate
cuted statically in the compiler are eliminated. No static ini- in; if memory is scarce or fragmentation has occurred, the
tialization needs to be performed for classes that do not have memory regions will be small and allocSlow will attempt
6. first-fit allocation. The initObject routine is a simple inline 3.2 Object layout
function that establishes the object’s header, and typically Java objects are laid out contiguously by our VM – i.e. a
involves two stores. Java object will have a similar memory structure to a C++
In the common case, this code is much faster than calling object or C struct. This allows for the fastest possible array
malloc, since no synchronization is required, and the rele- accesses and field accesses, as described above. As for C++
vant fast path code is inlined. In the slow path, this code is no objects that are not POD (plain-old-data; C++ objects qual-
worse than most malloc implementations – unless memory ify as POD if they have no virtual methods), Java objects
is exhausted. The Fiji VM garbage collector is designed to require a “vtable” header for virtual dispatch and run-time
run concurrently to the program, and thus fresh memory will type identification. The Fiji VM “vtable” pointer refers to
be freed all the time. However, if the collector is not paced either a TypeData structure, which contains the vtable as
appropriately, memory may be exhausted requiring allocat- well as type identification information used for type checks,
ing threads to pause until the collector completes. or a Monitor structure. The Monitor is used for storing the
lock, in case the object was used for locking. Thus, for Java
Synchronization. The synchronized statement is the pri- objects that never flow into a synchronized statement, there
mary locking facility provided in Java. Like most Java lock is no space overhead for locking. The Monitor points to the
implementations, the Fiji VM has its own locking code. In TypeData of the object; the latter contains a pointer at the
our case, locks must also support the priority inheritance same offset pointing to itself.1 Thus, getting the TypeData
protocol [27] to avoid cases of priority inversion due to lock- for an object requires a double-indirection. In addition, ev-
ing. The fast path, for uncontended lock acquisition, is basi- ery object has a GC header, which includes everything nec-
cally a compare-and-set and the slow path is mostly func- essary for garbage collection (such as the mark state of the
tionally identical to a POSIX mutex lock in PRIO INHERIT object, which indicates whether the object is marked in this
mode. However, unlike POSIX locks, the Fiji locking code collection cycle, and a pointer to the next-marked object,
also implements full debugging, profiling, and lock recur- used by the GC to create a linked list of marked objects)
sion support by default. Thus Fiji locks can be viewed as as well as everything needed to implement scoped memory
implementing a superset of POSIX locking functionality. in the RTSJ. Thus, every Java object requires two words of
Nonetheless, Fiji locks are faster than POSIX locks in the overhead. Additionally, Java arrays have an additional word
common case, and asymptotically no worse in the worst devoted to the array length. Thus, a zero-length array will re-
case. The main source of speedups is that our fast path is in- quire a total of three words of memory, while an object with
lined, and that it only has one mode thus removing the need no fields will require two words of memory. In summary,
to perform mode checks on every lock operation. To demon- Fiji VM’s object overheads are no worse than those found in
strate the speed of locking, we wrote a simple test program a typical C++ runtime: consider that a C++ object will have
that makes 10,000,000 lock acquisitions and releases in both one word for the vtable, and at least one other word used for
Java and C. The Java version is using synchronized while the bookkeeping by the malloc implementation.
C version is using pthread mutex using the default config-
uration (i.e. the C lock is configured for strictly less function- 3.3 High-level optimizations
ality, as it will lack recursion and priority inheritance; we do The Fiji compiler performs a variety of optimizations,
this to give the C code a “head start”). Both versions were at multiple stages of compilation, using a static-single-
run on a Xeon 2.33GHz running Linux; the Linux version is assignment (SSA) intermediate representation. The opti-
2.6.27 and includes the optimized futex-based locking. The mizations currently performed include:
performance of an average lock acquisition and release pair
from this test is as follows. • Virtualization – turning interface calls into virtual calls
• Devirtualization – turning virtual calls into direct calls
C version: 54.3 ns Java version: 31.1 ns • Inlining
• Copy propagation
The C locking implementation is 74% slower than Fiji VM’s
• Sparse conditional constant propagation
locks. The Linux lock implementation is one of the fastest
available, relying on Fast User level Mutexes to allow fast- • Tail duplication
path locking to occur entirely in user-space, using a sin- • Type propagation (0CFA) both intra- and inter-procedural.
gle atomic operation. However, even which futexes, POSIX
• Null check elimination
locks still require out-of-line calls and additional checks that
are neither mandatory nor desirable in Java. This demon- • Array bounds check elimination
strates that although Java maybe slower on some programs, 1 Strictly
speaking there is one word of overhead per TypeData (i.e. one
the reverse case – pathological programs for which Java is word per class). In our case this is a compile-time constant as we do not
substantially faster – also exists. consider dynamic loading.
7. • Global value numbering aggressively virtualize, devirtualize, and inline method calls,
• Load-load optimization as well as to remove unnecessary type checks. Because of
its simplicity, our 0CFA analysis converges very rapidly (20
• Loop peeling and unrolling
seconds for all of SpecJVM98 with the full GNU Classpath
0.97.2 2 , and less than a second for either smaller programs
The majority of these optimizations – all but virtualization, or programs that use our FijiCore library that targets embed-
whole-program control flow analysis (0CFA from [28]), and ded systems). Although the analysis is crucial to our per-
array bounds check elimination – would also be found in formance, giving us a 50% to 2× performance win on most
a C++ compiler, or even a C compiler. Devirtualization in programs, a thorough comparison of this algorithm’s perfor-
Java or C++ is equivalent to function pointer alias analysis, mance relative to other scalable 0CFA algorithms has not yet
something that GCC does. The reason why we include these been made.
analyses in Fiji VM even though GCC includes them as well
is two-fold: first, we have the benefit of richer type informa- 3.4 Type inclusion and interface dispatch
tion; and second, we are inserting additional code into the The TypeData record contains all information necessary
program as shown in Fig. 1. Java type information allows us to perform virtual method dispatch, interface method dis-
to observe optimization opportunities that GCC would have patch, reflective invocations, reflective field accesses, and
been obligated to conservatively overlook. Doing optimiza- type inclusion tests (instanceof and checked casts). Virtual
tions like loop unrolling and peeling early – before emitting method dispatch is done as in other statically typed single-
C code – allows us to reduce the overheads of code we later subclassing object-oriented languages; the TypeData record
insert, such as sync-points. However, though these optimiza- has a vtable appended to it, through which virtual calls are
tions all provide some speed-ups, the most profitable opti- made. Interface dispatch and type inclusion are more in-
mization remains inlining. In particular, we have found it to teresting since these operations often have implementations
be most profitable when applied only to the smallest meth- that are not constant-time. In Fiji both operations are guaran-
ods. We always inline non-recursive methods whose bodies teed constant-time. In the case of type inclusion, we use type
are smaller than a callsite. For other methods we inline based displays [18] generated using graph coloring. For interface
on a variety of heuristics, such as frequency of execution of method dispatch, we use graph coloring to allow interface
the call based on static estimates, and further size estimates methods that are never implemented in the same classes to
of the callee as well as caller. However, it should be noted share the same interface table entry. For all of SpecJVM98,
that even if our compiler inlined only methods with bodies this approach leads to 12 buckets (12 bytes per type) for type
smaller than the native code for a call, we would reap most inclusion and 10 interface table entries. The interface tables
of the benefits of our more complicated approach. are further compressed by only including an interface table
In our implementation, we have made the following three in types that implement interface methods, and then strip-
observations: (i) inlining works best with devirtualization, ping interface tables that have leading or trailing NULL en-
(ii) devirtualization works best with virtualization, and (iii) tries.
both devirtualization and virtualization work best in the pres-
ence of an analysis that can accurately identify the points-to 3.5 The Runtime System
set of the receiver at a callsite. For this, we employ a scalable The runtime is light-weight; it contains two components: the
control flow analysis (0CFA), in which all points-to sets are memory manager (for scoped-memory and garbage collec-
represented using a single machine word. 0CFA is short for tion) and an OS abstraction layer for threading and locking.
monomorphic (zero context sensitivity, hence the ‘0’) con- The runtime currently runs on POSIX-like platforms like
trol flow analysis; all compilers include some form of this Linux, NetBSD, and Mac OS X, and on top of the RTEMS
analysis at the intra-procedural level. Fiji VM does it over classic API. In this section, we discuss our memory man-
the whole program in order to determine, for each variable, agement, locking, and threading in some detail. Note that
what kinds of objects it might point to. Our points-to sets the Java libraries have its own OS abstractions for I/O and
are tuned so that they either represent null (i.e. the variable whatever other facilities the libraries may choose to support.
in question never points to any valid object), uniquely iden-
tify a type (for example: an instance of a HashMap), identify 3.6 Garbage Collection
any types that are subtypes of a type (for example: HashMap Fiji VM currently supports an Immix-style [7] on-the-fly
or any subtype of HashMap), or the set of all possible types. concurrent real-time garbage collector. This collector can be
Care is taken to ensure that program variables accessed re- run in either a purely concurrent, or a purely slack-based
flectively or via native code are presumed to point to any mode [16]. Immix is a “mark-region” collector that segre-
object; hence this analysis rewards programs that do not use gates free memory into regions and lines. The collector pro-
reflection, which is typically the case for embedded Java pro- ceeds by first marking those objects that are reachable by
grams as the reflective APIs are severely restricted in Java
Micro Edition. The results of the analysis are used to more 2 http://www.gnu.org/software/classpath
8. the program, and then identifying large contiguous chunks pointers to be register-allocated by the C compiler in most
of free memory (regions) that can be reclaimed rapidly, as cases allowing very good performance. Though this solves
well as small chunks of memory (lines), which constitute the accurate GC problem, it does not address the need to
fragmentation. In this system, objects are allocated in either scan every thread’s stack at the beginning of a collection cy-
a bump-pointer fashion (for regions) or first-fit fashion (for cle. To do this we leverage the observation that (i) real-time
lines); first-fit allocation over lines is preferred and bump- threads only yield the CPU at shallow stacks [25], and (ii) a
pointer is only used when all lines have been exhausted. slack-based collector can only commence stack scanning if
Free lines occur rarely in practice, and filling them quickly it was yielded to by the real-time threads. Thus, if the collec-
as soon as they are found minimizes fragmentation. Due to tor is scanning stacks it is guaranteed that it will be able to do
the sparsity of lines, bump-pointer allocation is used most so very rapidly for real-time threads (due to shallow stacks)
of the time in typical programs. While this approach does and will never have to wait for those threads to converge
not support defragmentation, it is mostly lock-free, on-the- to a safepoint where stack scanning is possible since those
fly (i.e. no global stop-the-world phase), and has very short threads must already be at such a point. Stack scanning thus
pauses. In fact, the only “pauses” are due to stack scanning, causes real-time threads to not be able to run during the very
which only affects low-priority threads. This collector can short (microsecond-level) interval during which their shal-
be thought of as similar to the WebSphere Metronome [3], low stacks are scanned. But we have never seen this affect
in that like that collector, it lacks defragmentation, but is oth- the predictability or performance of those threads.
erwise well suited for real-time applications. We have sepa-
rately measured the throughput of this collector to be compa- 3.6.1 Threading and Locking
rable to non-real-time collectors [23]. We believe this to be The threading and locking implementations are simple: we
largely thanks to its use of Immix-style allocation and highly pass all of the hard work to the underlying operating system.
concurrent design. Java threads become native threads. This leads to a simple
The Fiji collector runs either concurrently to the pro- implementation; our entire threading and locking implemen-
gram (when running on a multiprocessor machine) or at a tation for both POSIX and RTEMS is under 6,000 lines of C
predefined priority. In either mode, the collector never of- code. As well, the use of the operating system’s threading
floads work into application actions. In particular, an alloca- implementation allows for natural multiprocessing support;
tion will never perform collection work. When running at Fiji VM simply had multiprocessor support from the start.
a priority that is lower than some application thread, that Java I/O calls result in calls to POSIX I/O functions. Thus
thread is only suspended if it makes a request for memory code that relies heavily on threading and I/O will not see any
that cannot be immediately satisfied. Proving that this does performance degradation under Fiji VM.
not happen is an analogous problem to proving the schedu-
lability of a real-time system. In fact, a fixed-priority col- 4. Evaluation
lector that can run at priorities lower than the application
(the so called “slack-based” strategy) has very well defined The goal of this section is to demonstrate that Java is suit-
schedulability tests as shown in Kalibera et al’s work on the able for use in hard real-time settings. To this end, we strive
Minuteman garbage collector [16]. Of course, just as with to set a up representative workload on a realistic evaluation
any schedulability analysis, one that includes a collector is platform and compare the costs of idiomatic Java to C. To
not an easy task and is always OS-, hardware-, runtime-, and this end we select the CDx benchmark which models an
application-dependent. We do not include such an analysis in air traffic Collision Detector algorithm. The Java version of
this paper though we are aware of empiric approaches [16] the code, CDj, was originally implemented by the first au-
that make it possible. thor, while the C version, CDc, was created by Gaith Had-
Compiling Java bytecode to C has traditionally been seen dad at UCF and modified by us [15].3 The benchmark is ar-
as a challenge for accurate garbage collectors such as ours, ray intensive and performs significant mathematical compu-
as C compilers do not support the generation of stack maps. tations, making it well suited to low-level C programming
However, a number of well-known approaches exist for cir- idioms and a good challenge for a Java implementation.
cumventing this [5]. We use the Henderson-style linked list Furthermore, the benchmark has interesting allocation pat-
approach in which every pointer local variable is stored in terns, which do not permit a successful completion of the
a thread-local data structure accessible to the collector. We benchmark without some form of memory management.4
further optimize this approach for the fact that in Fiji VM The platform we selected for our experiment is the LEON3 –
objects are never moved by the collector. Since object point- a SPARC-based architecture that is used both by the NASA
ers only need to be stored into this data structure when (i) 3 Sources are available from http://www.ovmj.net/cdx. The version
they are known to not already be there and (ii) they will be used for this paper is tagged as “eurosys”.
live after the next sync-point or method call, we can optimize 4 We observe that the CDc version of the code is using malloc/free whereas
away a large number of these stores. This allows for object many real-time programmers would rather use object pooling to prevent
fragmentation and have more predictable allocation times.
9. and the European Space Agency [17] – and the RTEMS real- two steps. First, the set of all aircraft is reduced into multi-
time operating system. ple smaller sets. This step allows to quickly rule out aircrafts
We also compare Fiji VM to other commercial virtual that are far from each other. Second, for each cluster, every
machines to elucidate the importance of our design choices two aircraft are checked for collisions. Both the reduction
on predictability and to verify how our performance stacks and the checking operate on pairs of 3-d vectors describing
up to that of other real-time virtual machine and to mature the initial position, i, and the final position, f , of an aircraft
throughput oriented VMs. As most Java implementations (i is from the previous frame, f is from the current frame). A
do not run on the LEON3 platform, we switch to a desk- frame also contains a call sign which identifies the aircraft.
top setting and evaluate IBM’s WebSphere SRT and SUN’s A motion vector m is then defined as m = f − i.
Hotspot Client and Server. As WebSphere is optimized for The code size of the Java version, CDj, is 3859 lines of
multicores, we use the multicore version of the Fiji VM. code while the C version is 3371. CDc is somewhat simpler
Our real-time experiments were run on a GR-XC3S-1500 since it does not have hooks for the multiple configurations
LEON development board.5 The board’s Xilinx Spartan3- supported by the Java version. CDc is written in an idiomatic
1500 field programmable gate array was flashed with a C style that tries to follow the algorithmic behavior of the
LEON3 configuration running at 40Mhz. The develop- Java code with some small differences. For instance, the
ment board has an 8MB flash PROM and 64MB of PC133 hash table used by the C code does not require as much
SDRAM split into two 32MB banks. The version of RTEMS allocation and have constant time traversal.
is 4.9.3. We used the Rapita Systems RTBx Data Logger6 for In a departure from the CDx benchmark we modified the
on-device profiling. The desktop were run on an 8-core Intel collision detection code to compute the radar frames. One
Xeon X5460 3.16GHz machine with 8GB of RAM, running configuration of CDx is using another thread for this, we
Ubuntu 7.10 with the 2.6.22-14-server 64-bit SMP kernel. did not use it to avoid the interference for our experiment.
The version of Hotspot used is jdk1.6.0 12 and WebSphere The other configuration uses pre-computed frames, but due
reports “IBM J9 VM (build 2.5, J2RE 1.6.0 IBM J9 2.5 to memory constraints it was not possible to load 10,000 pre-
Linux x86-32 jvmxi3260srt-20081016 24573 (JIT enabled, computed frames on our embedded board. The main impact
AOT enabled)”. of this change is that it forced us to have longer periods.
4.1 CDx Overview
The CDx benchmark suite is open source family of bench- 4.2 Comparing C to Java
marks with identical algorithmic behavior that target differ-
ent hard and soft real-time platforms. While a complete de- The version of CDx used in our benchmark has a single
scription is given in [15], we will present enough informa- real-time periodic tasks (CD) configured to run every 300
tion for readers to understand the overall nature of the com- milliseconds. We configured the benchmark with 6 airplanes
putation performed in CDx. and executed the algorithm for 10,000 iterations. The Java
The benchmark is structured around a periodic real-time version ran with a GC thread enabled. The GC is set to run
thread that detects potential aircraft collisions based on sim- at a lower priority than the CD task. As the CD thread takes
ulated radar frames. The benchmark can thus be used to mea- between 147 and 275 milliseconds (see Fig. 2), this leaves
sure the time between releases of the periodic task as well as the collector substantially less than 50% of the schedule to
the time it takes to compute the collisions. The need for de- perform memory reclamation. Still, the collector keeps up,
tection of potential collisions prior to their occurrence makes and no outliers are ever produced due to memory exhaustion.
CDx a real-time benchmark. Each frame must be processed The raw runtime performance of CDc compared to CDj
in a timely fashion. is presented in Fig. 2. For real-time developers the key met-
The algorithm detects a collision whenever the distance ric of performance is the worst observed time, in our bench-
between any two aircraft is smaller than a pre-defined prox- marks Java is only 10% slower than C in the worst-case. On
imity radius. The distance is measured from a single point average CDc is 30% faster than CDj. In both executions no
representing an aircraft location. As locations are only deadlines were missed. The computation took roughly 45
known at times when the radar frames are generated, they minutes to complete on the LEON3 platform. A more de-
have to be approximated for the times in between. The ap- tailed view of the performance of CDc and CDj for a subset
proximated trajectory is the shortest path between the known of the iterations is presented in Fig. 3. The graph clearly in-
locations. A constant speed is assumed between two consec- dicates that there is a strong correlation between the peaks
utive radar frames. For this assumption to be realistic, the observed in CDc and CDj. Notice, however, that the peaks
frequency of the radar frames should be high and the detec- in CDj are on average smaller than those in CDc relative to
tion has to be fast. This is achieved by splitting detection into baseline performance (i.e. the distance from average to peak
is greater for C than for Java). Overall this data suggests that
5 Further specifications can be found at http://www.gaisler.com. while Java is somewhat slower, there are no sources of un-
6 For more information see http://www.rapitasystems.com. predictability in our implementation.
10. 1000 1000
500 500
Number of Samples
(Logarithmic Scale)
100 100
50 50
10 10
5 5
1 1
100 150 200 250 300 100 150 200 250 300
CDc: Duration of Iteration Execution on RTEMS/LEON3 CDj on Fiji VM: Duration of Iteration Execution on
in Milliseconds RTEMS/LEON3 in Milliseconds
Figure 2. Histograms of iteration execution times for CDc and CDj on RTEMS/LEON3. Java’s worst observed case is 10% slower than
C, and the median is 30% slower.
300
CDj worst case
Iteration Execution Time in Milliseconds
CDc worst case
250
200
150
100 CDc CDj on Fiji VM
2000 2050 2100 2150 2200
Iteration number
Figure 3. A detailed runtime comparison of CDc and CDj for 200 iterations. Java and C execution times are closely correlated. CDj is
run with GC enabled. In 10,000 iterations there are 15 collections, but they never impact execution time.
Figure 4 shows correlations between the execution time check. Thus we expect that the amount of extra work dur-
of each iteration in Java to that of the same iteration in C. ing longer iterations will result in greater penalties for Java.
Iterations that take longer are ones that have either more Yet this correlation shows this not to be the case: longer it-
suspected collisions, or more actual collisions. A “suspected erations do not penalize Java any more than they penalize
collision” is a condition in which the aircraft are sufficiently C, indicating that either many of the checks can be elimi-
close that the algorithm must perform more work in order nated by the Fiji VM compiler or else that they simply do
to determine if an actual collision occurred. An actual col- not cost much. For a more detailed look, we plotted the
lision requires more work because a collision report must Java iteration execution time versus the number of various
be produced. The former requires more data structure ac- checks in Figures 5, 6, and 7. The number of checks per it-
cesses, more arithmetic, and more allocation, while the latter eration were measured using RTBx instrumentation. These
requires more allocation. The C code does not have any over- figures show that the benchmark’s iterations have six dis-
head penalties for data structure accesses: no null checks, no tinct “modes” – i.e. the number of checks executed is fairly
array bounds checks, and no type checks. The Java code, on discretized. This likely corresponds to the number of sus-
the other hand, makes heavy use of Java container classes. pected collisions (since there are six planes, we would expect
Container class accesses will introduce at a minimum a six such modes). Two additional conclusions can be drawn
nullcheck, and sometimes an array bounds check or a type from these figures. First, even though the code is dominated
11. Iteration Execution Time in Milliseconds
250
CDj on Fiji VM: Iteration Execution Time in Milliseconds
250
200
150
1100 1200 1300 1400 1500 1600
200 Number of Array Bounds Checks
Figure 6. Correlation between number of array bounds checks in
an iteration and that iteration’s execution time in CDj.
Iteration Execution Time in Milliseconds
150
250
100 150 200 250
CDc: Iteration Execution Time in Milliseconds 200
Figure 4. Execution time correlation between CDc and CDj.
150
500 550 600 650 700 750
Iteration Execution Time in Milliseconds
Number of Type Checks
250
Figure 7. Correlation between number of type checks in an iter-
ation and that iteration’s execution time in CDj.
200
per 100 microseconds of execution on a 40MHz processor,
which adds up to about one branch every 4,000 cycles. This
150
implies that Java’s safety guarantees are not a major factor
1200 1300 1400 1500 1600 1700 1800 in performance for this program. However, we do see that
Number of Null Checks
Java is indeed slower than C and suspect that this is due to
the overall performance degradation from the sum total of
Figure 5. Correlation between number of null checks in an itera- all of Java’s overheads, including ones we were unable to
tion and that iteration’s execution time in CDj.
study in greater detail: for example the Henderson frames
used for accurate stack scanning, sync-points, procedure call
overheads, etc.
by operations that would appear to cause safety checks, the
rate at which these checks are executed is quite small. Sec-
ond, for longer iterations the execution time can vary by a lot 4.3 Java VM Comparison
even though the number of checks remain the same, indicat- In this experiment we compare WebSphere SRT, Hotspot
ing that safety checks are not much of a factor in execution Client, Hotspot Server and Fiji VM using the same bench-
time. For example: null checks, which are the most frequent, mark but running on a multicore. CDj was configured to use
are only executed at most at a rate of about ten per millisec- up to 60 planes with a 10 milliseconds period and 10,000 it-
ond. A null check that does not fail results in nothing but a erations. All VMs were given maximum heap sizes of 35MB
branch at the machine code level (and indeed, in CDj none to execute CDj and were run with default options. The goal
of the safety checks ever fail). This means that the presence of the experiment is to have a rough idea of the difference
of Java’s null checks only adds about one additional branch in predictability between WebSphere and Fiji, and in per-
12. Number of Samples excluding first 1000
1000 1000
500 500
(Logarithmic Scale)
100 100
50 50
10 10
5 5
1 1
50 100 150 200 250 300 350 50 100 150 200 250 300 350
CDj on Fiji VM: Duration of Iteration Execution on CDj on IBM Websphere Metronome SRT: Duration
Linux/x86 in Microseconds of Iteration Execution on Linux/x86 in Microseconds
Number of Samples excluding first 1000
1000 1000
500 500
(Logarithmic Scale)
100 100
50 50
10 10
5 5
1 1
50 100 150 200 250 300 350 50 100 150 200 250 300 350
CDj on JDK HotSpot 1.6 Client: Duration of Iteration CDj on JDK HotSpot 1.6 Server: Duration of
Execution on Linux/x86 in Microseconds Iteration Execution on Linux/x86 in Microseconds
Figure 8. Histograms of iteration execution times for CDj on Linux/x86. Fiji VM achieves the best observed worst-case and has the tightest
distribution of execution times – representing the best predictability. WebSphere SRT has a slightly better average performance but with a
larger variance. Hotspot client and server have the best average-case performance but exhibit poor worst-case performance with outliers
above 300 microseconds. We exclude the first 1,000 iterations from the measurements to avoid initialization bias.
4000
Worst-case Iteration Execution Time
3000
Sun JDK HotSpot 1.6 Server
in Microseconds
Sun JDK HotSpot 1.6 Client
2000
IBM Websphere Metronome SRT
1000 Fiji VM
0
0 100 200 300 400
Number of CDj Iterations dropped at the beginning of execution
Figure 9. Start-up costs. The Y-axis shows the worst-case observed execution time, while the X-axis shows iterations dropped from the
10,000 performed for each VM. The initial iterations are dominated by the just-in-time compiler. This is particularly true for Hotspot server.
WebSphere also has a JIT but it is tuned to stabilize faster. In comparison, the Fiji VM does not suffer from start-up jitter. If roughly 300 or
more iterations are dropped, the JIT-based systems have a worst-case that approaches Fiji VM’s. At that point the worst-case is dominated
by garbage collection where the Fiji VM performs well due to its fully concurrent and slack-based collection strategy.
13. formance between real-time VMs (WebSphere and Fiji) and is about 30% and, more importantly, the worst observed exe-
production throughput optimized VMs (Hotspot). cution time of the Java program is only 10% higher than that
The histogram of Fig. 8 show the frequency of execution of the corresponding C program. The implication of these
times for each VM with the first 1,000 iterations of the algo- results is that Java, even with the presence of a garbage col-
rithm dropped to avoid bias due to the just-in-time compiler. lector, can be used in many hard real-time contexts.
The data demonstrates that average case performance is bet-
ter for Hotspot. Specifically, Hotspot Server is 37% faster
than Fiji and client is 4.7% faster. This is to be expected as it Acknowledgments. The authors thank Tomas Kalibera and
does not emphasizes predictability. The worst observed case Gaith Haddad for their work on the CDx benchmark, the
is more important for real-time developers. There Hotspot anonymous reviewers and Gilles Muller for their helpful
performs between 185% and 200% worse than Fiji, these comments.
difference are caused by garbage collection pauses. As for
the comparison with WebSphere, Fiji has an observed worst-
case that is 4% better than WebSphere but run 15% slower
References
on average. Fiji VM has the tightest distribution (i.e. least [1] A RMBUSTER , A., BAKER , J., C UNEI , A., H OLMES , D.,
deviation from peaks to valleys) of any virtual machine for F LACK , C., P IZLO , F., P LA , E., P ROCHAZKA , M., AND
this benchmark. V ITEK , J. A Real-time Java virtual machine with applications
in avionics. ACM Transactions in Embedded Computing
In many real-time applications start-up behavior is im-
Systems (TECS) 7, 1 (2007), 1–49.
portant. Fig. 9 illustrates the evolution of the worst observed
time as we remove initial iterations of the benchmark. By [2] AUERBACH , J. S., BACON , D. F., B LAINEY, B., C HENG ,
this we mean that position 0 on the X-axis shows the worst P., DAWSON , M., F ULTON , M., G ROVE , D., H ART, D.,
AND S TOODLEY, M. G. Design and implementation
observed case for 10,000 iterations of the algorithm. This
of a comprehensive real-time Java virtual machine. In
measure is dominated by the cost of just-in-time compila- International conference on Embedded software (EMSOFT)
tion. At offset 100, for example, the graph shows the worst- (2007), pp. 249–258.
case observed between iterations 101 and 10,000. Finally,
[3] BACON , D. F., C HENG , P., AND R AJAN , V. T. A real-time
the far right of the graph shows the worst-case times when
garbage collecor with low overhead and consistent utilization.
the first 400 iterations are ignored. At that point the worst- In Symposium on Principles of Programming Languages
case time is dominated by GC. It is interesting to observe that (POPL) (Jan. 2003).
the costs of JIT compilation are highest in Hotspot Server
[4] BAKER , H. G. The treadmill: real-time garbage collection
and they take longer to stabilize. Hotspot Client is less ag-
without motion sickness. SIGPLAN Notices 27, 3 (1992),
gressive and reaches fixpoint in around 60 iterations of the 66–70.
benchmark. WebSphere tries to compile code quickly, but
the data shows that some compilation is still happening un- [5] BAKER , J., C UNEI , A., K ABILERA , T., P IZLO , F., AND
V ITEK , J. Accurate garbage collection in uncooperative
til around 200 iterations. Unsurprisingly, Fiji has no start up
environments revisited. Concurrency and Computation:
jitters as it is an ahead-of-time compiler.
Practice and Experience (2009).
[6] B LACKBURN , S., AND H OSKING , A. Barriers: friend or
5. Conclusion foe? In International Symposium on Memory Management
Programming hard real-time embedded devices is particu- (ISMM) (2004), pp. 143–151.
larly demanding as code must be both predictable and effi- [7] B LACKBURN , S. M., AND M C K INLEY, K. S. Immix: a
cient. As the size of embedded code bases rises, ensuring the mark-region garbage collector with space efficiency, fast
correctness and safety of critical programs written in low- collection, and mutator performance. In Conference on
level languages such as C is becoming increasingly difficult. Programming Language Design and Implementation (PLDI)
(2008), pp. 22–32.
While high-level languages such Java and C# have been ad-
vocated as being better suited for developing large software [8] B OLLELLA , G., D ELSART, B., G UIDER , R., L IZZI , C.,
systems, their suitability for embedded development is still AND PARAIN , F. Mackinac: Making HotSpot real-time.
being debated. In International Symposium on Object-Oriented Real-Time
Distributed Computing (ISORC) (2005), pp. 45–54.
This paper highlights the overheads of using Java for hard
real-time development by contrasting the performance of a [9] B OLLELLA , G., G OSLING , J., B ROSGOL , B., D IBBLE , P.,
representative benchmark written in C and Java on a LEON3 F URR , S., AND T URNBULL , M. The Real-Time Specification
processor with the RTEMS operating system. The Java pro- for Java. Addison-Wesley, June 2000.
gram is executed by a new Java virtual machine, the Fiji VM, [10] B RUNO , E., AND B OLLELLA , G. Real-Time Java Program-
which compiles Java ahead-of-time to C and which has run- ming: With Java RTS. Addison-Wesley, 2009.
time system that includes a real-time garbage collector. The [11] C LICK , C., T ENE , G., AND W OLF, M. The pauseless GC
results are encouraging as the throughput overhead of Java algorithm. In International Conference on Virtual Execution
14. Environments (VEE) (2005), pp. 46–56. [26] S CHOOFS , T., J ENN , E., L ERICHE , S., N ILSEN , K.,
[12] C ORSARO , A., AND S CHMIDT, D. The design and G AUTHIER , L., AND R ICHARD -F OY, M. Use of PERC pico
performace of the jRate Real-Time Java implementation. in the AIDA avionics platform. In International Workshop
In The 4th International Symposium on Distributed Objects on Java Technologies for Real-Time and Embedded Systems
and Applications (DOA’02) (2002). (JTRES) (2009), pp. 169–178.
[13] H ENDERSON , F. Accurate garbage collection in an uncooper- [27] S HA , L., R AJKUMAR , R., AND L EHOCZKY, J. P. Priority
ative environment. In Proceedings of the ACM International inheritance protocols: An approach to real-time synchroniza-
Symposium on Memory Management (Feb. 2002), vol. 38, tion. IEEE Transactions on Computers 29, 9 (Sept. 1990),
ACM, pp. 256–263. 1175–1185.
[14] H ENRIKSSON , R. Scheduling Garbage Collection in [28] S HIVERS , O. Control flow analysis in scheme. In Conference
Embedded Systems. PhD thesis, Lund University, July 1998. on Programming Language design and Implementation
(PLDI) (1988), pp. 164–174.
[15] K ALIBERA , T., H AGELBERG , J., P IZLO , F., P LSEK , A.,
AND B EN T ITZER AND , J. V. Cdx: A family of real-time Java
[29] S IEBERT, F. The impact of realtime garbage collection on
benchmarks. In International Workshop on Java Technologies realtime Java programming. In International Symposium on
for Real-time and Embedded Systems (JTRES) (September Object-Oriented Real-Time Distributed Computing (ISORC)
2009). (2004), pp. 33–40.
[16] K ALIBERA , T., P IZLO , F., H OSKING , A., AND V ITEK , J. [30] S IEBERT, F., AND WALTER , A. Deterministic execution of
Scheduling hard real-time garbage collection. In Proceedings Java’s primitive bytecode operations. In Java Virtual Machine
of the IEEE Real-Time Systems Symposium (RTSS) (Dec. Research and Technology Symposium (JVM) (2001), pp. 141–
2009). 152.
[17] K ALIBERA , T., P ROCHAZKA , M., P IZLO , F., V ITEK , J.,
Z ULIANELLO , M., AND D ECKY, M. Real-time Java in
space: Potential benefits and open challenges. In Proceedings
of DAta Systems In Aerospace (DASIA) (2009).
[18] K RALL , A., V ITEK , J., AND H ORSPOOL , N. R. Near
optimal hierarchical encoding of types. In Proceedings of
the European Conference on Object-Oriented Programming
(ECOOP) (Jyvaskyla, Finland, June 1997).
[19] M ULLER , G., AND S CHULTZ , U. P. Harissa: A hybrid
approach to Java execution. IEEE Software 16, 2 (1999).
[20] N ILSEN , K. Garbage collection of strings and linked data
structured in real time. Software, Practice & Experience 18,
7 (1988), 613–640.
[21] P IZLO , F., AND V ITEK , J. An empirical evalutation of
memory management alternatives for Real-time Java. In
Proceedings of the 27th IEEE Real-Time Systems Symposium
(RTSS) (Dec. 2006).
[22] P IZLO , F., AND V ITEK , J. Memory management for real-
time Java: State of the art. In Proceedings of the IEEE
International Symposium on Object-oriented Real-Time
Distributed Computing (ISORC) (Orlando, FL, May 2008).
[23] P IZLO , F., Z IAREK , L., AND V ITEK , J. Towards Java on
bare metal with the Fiji VM. In International Workshop
on Java Technologies for Real-time and Embedded Systems
(JTRES) (September 2009).
[24] P ROEBSTING , T., T OWNSEND , G., B RIDGES , P., H ART-
MAN , J., N EWSHAM , T., AND WATTERSON , S. Toba: Java
for applications – A way ahead of time (WAT) compiler. In
Conference on Object-Oriented Technologies and Systems
(1997).
[25] P UFFITSCH , W., AND S CHOEBERL , M. Non-blocking root
scanning for real-time garbage collection. In International
Workshop on Java Technologies for Real-Time and Embedded
Systems (JTRES) (2008), pp. 68–76.