Overview of Real-Time Java Computing

  • cc icon
  • ABSTRACT

    This paper presents a complete survey of recent techniques that are applied in the field of real-time Java computing. It focuses on the issues that are especially important for hard real-time applications, which include time predictable garbage collection, worst-case execution time analysis of Java programs, real-time Java threads scheduling and compiler techniques designed for real-time purpose. It also evaluates experimental frameworks that can be used for researching real-time Java. This overview is expected to help researchers understand the state-of-the-art and advance the research in real-time Java computing.


  • KEYWORD

    Performance , Reliability , Java , WCET analysis , Compiler , Hard real-time systems

  • I. INTRODUCTION

    Real-time systems ranging from aircraft and nuclear power plant controllers to video games and speech recognition have become an increasingly important part of our society. The small stand-alone real-time applications of the past are giving way to a new type of networked realtime systems that are running on heterogeneous computing and networking environments; for example, integrated battleship management, VoIP-based telecommunications, stock arbitrage, and automotive systems [1]. The software development for real-time systems has also become more and more complex, due to the increase in the size, longevity, and required features of these systems. Following its successful use in Web applications, middleware, and enterprise software development, Java can offer significant advantages such as productivity, reliability, and portability for developing large and complex real-time software, and thus becomes an attractive option for realtime software design. A study by Nortel Networks indicated that using real-time Java doubled their productivity in developing telecom equipment and base stations [2].

    For real-time systems, especially hard real-time and safety-critical systems, it is crucial to know the worstcase execution time (WCET) [3] to ensure that each task can meet its deadline. WCET should be computed based on static timing analysis, rather than measurement alone, because in general it is impossible to exhaustively measure all program paths in order to locate the longest execution time. The WCET of a real-time task however, is heavily dependent on the programming language used to implement this task, as well as the target processor and the compiler optimizations. Java, designed to run its byte code on Java Virtual Machine (JVM) for portability across different computing platforms, is a serious challenge for predictable execution and WCET analysis. Without solving this problem, Java cannot be safely used in hard realtime and safety-critical systems. Even for firm or soft realtime systems, unpredictable and varied execution time of Java computing may significantly compromise the quality of service.

    Traditional JVM designs have mainly focused on improving the average-case performance, which may result in too much unpredictability with the use of multiple threads, dynamic compilation, automatic garbage collection, and so on. Since the first discussion of issues in design and implementation of real-time Java [4] was proposed in the 1990s, a considerable amount of remarkable research work has been done to adapt Java to real-time purpose. The Real-Time for Java Experts Group began to develop Real- Time Specification for Java (RTSJ) in March 1999 [5]. The RTSJ has been evaluated for uses in avionics and space systems by Boeing and Jet Propulsion Laboratory (JPL) [6,7]. There are also a number of commercial implementations such as Sun Microsystems Mackinac, IBM WebSphere Real Time, TimeSys jTime, and Aicas JamaicaVM, as well as several open source implementations including OVM and jRate. A more recent effort regarding safety-critical Java software is the Safety-Critical Java (SCJ) Specification [8].

    Due to the widespread use of real-time applications and the increasing use of Java in developing real-time software with hard deadlines, it becomes important for real-time researchers and developers to understand how to achieve time predictability in Java based computing. This paper presents an overview of the most recent and important studies in the area of real-time Java computing. More specifically, this paper will present related studies on real-time Java in the following topics:

    - Real-time threads and scheduling

    - Time predictability of Java code

    - Bounded garbage collection

    - Suitable compilation and optimization

    The rest of this paper is organized by these four main issues. Sections II to V present the newest work on one of the above topics. Section VI describes a special way to implement real-time Java by hardware, that is, Java processor. Section VII discusses available tools and frameworks that may be used for real-time Java research and the last section gives the summary and conclusion.

    II. REAL-TIME THREADS AND SCHEDULING

    The RTSJ [5] by Java Expert Group firstly gives an abstract definition of real-time threads and scheduling. Two kinds of real-time threads are defined in addition to normal Java threads. One is real-time thread and another is no-heap real-time thread. NHRTs are not permitted to access the heap so that it can avoid the possible delay caused by garbage collection. On the other hand, RTs can access heap so that they have more flexibility in coding and are suitable for code with a higher tolerance for longer delays, such as soft real-time application.

    The RTSJ also provided minimum requirements for real-time Java scheduling. All implementation of RTSJ must provide a fixed-priority preemptive scheduler with no fewer than 28 unique priorities. RTSJ is open for extension of other scheduling algorithms, and the implementation relies on the support of real-time operating systems.

    Similarly to RTSJ definition, the Ravenscar-Java [9] defines its real-time threads and scheduler. Additionally, it derives two specific types of threads from RTSJ: periodic real-time threads and sporadic event handlers. This design is based on the behavior of real-time applications whereby most threads wake up and do their job after fixed time intervals.

    III. TIME PREDICTABILITY OF JAVA CODE

    It is necessary for real-time Java applications to know the WCET of Java programs. Since Java code is firstly compiled into Java byte code (JBC) and then executed on JVMs, it is quite natural to analyze the WCET of a Java program in two steps: JBC level and lower platformdependent level.

      >  A. WCET Analysis at JBC Level

    There have been many research efforts to conduct WCET analysis for C programs. Lundqvist and Stenstrom [10] discovered timing anomalies in out-of-order superscalar processors. Li and Malik [11] and Li et al. [12] proposed the implicit path enumeration technique (IPET) to compute the worst-case path for deriving the WCET accurately. Recently, the timing analysis has been extended from single-core processors [13-19] to multicore processors [20-28]. A good summary of contributions in the area of WCET analysis can be found in [3].

    Java itself is very friendly to JBC level WCET static analysis with its well-formed object-oriented structure and features. JBC stored in Java class files is easily read and analyzed by the WCET analyzer, which generates control flow graph (CFG) and basic block (BB) of given Java programs. With Java annotations which are supported by most modern Java compilers, additional information such as loop bounds can also be provided.

    A series of works have been done in this area. Puschner and Bernat [29] described a general method that can be applied for the Java program using the integer linear programming (ILP) technique. Bernat et al. [30] provided an implementation of the WCET analyzer based on Java annotations. Bate et al. [31] modified the Kaffe [32] and Komodo [33] to support WCET of Java applications running on these two JVMs. Control flow and data flow are both considered in these studies. The works in [34,35] designed an extension to bring loop bounds, timing modes, and dynamic dispatch semantics into the WCET analyzer. Harmon and Klefstad [36] then attempted to construct a standard of Java annotations for WCET analysis, based on all previous works. Hepp and Schoeberl [37] explored WCET-based optimizations for Java programs.

      >  B. Platform-Dependent WCET Analysis for Java

    The only gap between JBC WCET and reality is the low level, platform-dependent timing model of JVMs. The exact execution time of each JBC and combination of JBCs is needed to compute the final WCET of any Java program. Hu et al. [38] attempted to solve this problem by two methods: profiling based and benchmark based. The profiling method inserts instrument codes into the Java program and collects execution times of JBCs. As another way, by running specially designed benchmarks, the same job can be done on all kinds of platforms without changing the instrument codes. Bate et al. [39] studied the JBC execution overhead due to the JVMs and processor pipelines, as well as the effects on the WCET of each JBC. However, these works are all measurement based. There is still no way to statically analyze the low level WCET for a particular JVM and platform.

    IV. REAL-TIME JAVA MEMORY MANAGEMENT

    Java’s automatic memory management, garbage collection (GC), is a very good feature and brings great benefit to software development. However, most current garbage collectors are not time predictable. As a result, GC actually prevents Java programs from being adapted in the real-time area. It is totally unacceptable that a realtime task is interrupted by GC thread and does not know when it can be up and running again.

      >  A. Bypassing Garbage Collection

    The first idea is to remove the unpredictable GC from the real-time Java system. That is why the scoped memory and immortal memory section are defined in RTSJ [5]. In this case, the objects in real-time threads are managed by programmers instead of JVMs. The developers take care of the memory areas that are used for real-time tasks and leave the other part to GC. The GC thread holds lower priority than real-time threads and thus cannot interfere with them. Time predictability is guaranteed but the flexibility is lost in development. Most of the implementations of RTSJ support this kind of technique bypassing GC. Besides, researchers made an effort to improve the efficiency of this scoped memory. Beebee and Rinard [40] implemented the scoped memory model and evaluated its efficiency. Corsaro and Schmidt [41] presented another implementation of real-time JRate. Pizlo et al. [42] presented an informal introduction to the semantics of the scoped management rules of the RTSJ, and it also provided a group of design patterns which can be applied to achieve a higher efficiency of scoped memory. Andreae [43] provided a complete programming model of the scoped memory model to simplify the memory analysis that has to be done by developers. Bypassing GC is proved to be easy to apply to existing JVMs and brings small overhead to runtime memory management. However, it is limited because of the great difficulty it brought to the developers. Without the GC feature, programmers have to pay much more attention to the objects in real-time tasks to avoid memory error. Although scoped memory may be a good solution of small short-term projects, realtime GC is definitely necessary for future real-time Java systems.

      >  B. Time-Predictable Garbage Collection

    Baker’s incremental copying collector [44] is the first idea of real-time GC. In this work, the memory mutator operation leads to the GC operation. Hence, GC is predictable and the worst case is that every read or allocation invokes a certain amount of collection operations. It is not very efficient yet provides a way to implement realtime GC. This so called work-based GC is then developed by many other following researchers, such as [45] and [46] in JamaicaVM. The basic idea is kept while overhead of allocation detection and unnecessary collection is significantly reduced. Even hardware can be used to assist GC efficiency and reduce WCET bounds, as presented in [47].

    On the other hand, Bacon et al. [48] developed a timebased approach that invokes a collector at regular intervals. This kind of GC requires read/write barriers in order to maintain consistency, and the memory allocation must be time predictable. The quota of CPU time for GC can be dynamically computed and set at runtime based on the memory usage of real-time threads. This technique is then applied in IBM’s real-time JVM [49] named as Metronome [50,51]. Henriksson [52] also proposed a timebased GC strategy which set the collector to active only when the processor is idle. The idea then is improved in [53]. The key issue of time-based real-time GC is how much time should be given to the collector. Schoeberl and Vitek [54] presented the algorithm to compute the GC quota and interval in their study. Cho et al. [55] used statistical tools to guarantee the algorithm’s effectiveness and superiority.

      >  C. Concurrent Garbage Collection

    Both time-based and work-based real-time GC have the same problem, that is, the processor is fully occupied by the collector thread at the GC stage. Thus thread switching has to be performed when a real-time task is presented. Fortunately, the improvement of multiprocessor technique brings a new approach that can avoid this problem. The concurrent GC runs on a different processor other than real-time tasks. As a result, the overhead of switching threads is reduced to a minimum. However, there are several serious challenges: synchronization between processors, access lock to memory objects, and so on.

    The first multiprocessor concurrent GC implementation was presented by [56], which applied the algorithm in [57] on a 64-processor machine. It greatly reduced the pause time of GC to the millisecond level. After that, various kinds of concurrent GC algorithms and implementations were presented by researchers to further improve it. Xian and Xiong [58] showed that their technique can effectively reduce the memory amount used by concurrent real-time GC, which is relatively huge. Sapphire [59] implemented a copying collector for Java with low overhead and short pause time. Pizlo et al. [60] compared three lock-free concurrent GC algorithms: STOPLESS [61], CHICKEN, and CLOVER, which have the pause time as microsecond level. Although these algorithms are designed for and implemented by C#, it is easy to adapt them to Java since they are similar VM based language.

    V. COMPILATION FOR REAL-TIME JAVA

    Compilation and optimization are also critical issues of real-time Java. Just-in-time (JIT) compilation is already widely used in modern JVMs because of the performance boost it provides. Speculative optimizations are also an essential part now in many advanced JVMs. However, the JIT compiler and some optimizations bring unpredictability into Java applications, so that they cannot be simply used in real-time Java systems, where an old interpreter and ahead-of-time (AOT) compiler take their chances.

      >  A. Interpretation

    Interpretation is the most original way to execute JBCs. It reads the JBCs from classes and translates them into native code, and then executes them. It is slow but has excellent time predictability as the interpretation of each JBC can be easily measured. For this reason, most real-time JVMs, such as IBM WebSphere VM [49], Sun Java Real-Time System [62], and Open VM [63], provide the interpreter mode. However, the performance limits this mode to be used in modern real-time systems.

      >  B. JIT Compilation

    To improve interpreter performance, JVMs use the JIT compiler to compile the code sequence into native code on the fly before it executes. However, the JIT-only strategy introduces compilation overhead at runtime. To address this problem, a JVM can focus on optimizing only “hotspots”, while the rest of the code can be either interpreted or compiled by a basic compiler without optimization. Examples of adaptive optimization systems include HotSpot virtual machine [64] from Sun (now Oracle), Jikes RVM [65] from IBM, and Open Runtime Platform (ORP) [66] from Intel Corporation. To identify hot-spots, researchers have proposed to use online hardware profiling mechanisms such as counters and samplings [67-71], or to use program instrumentation [72-78], combined instrumentation and sampling [79-81], or coupled offline and online profiling [82]. To further improve adaptive optimization, a number of techniques have been developed; for example, recompilation [83], deferred and partial compilation [84-86], and dynamic deoptimization [87]. The idea of dynamic and adaptive compilation has also been extended and studied in other contexts, among them hybrid JIT compilation [88], trace-based parallelization [89-93], and adaptive garbage collection [94].

    While the JIT compiler is useful for improving the average- case performance of non-real-time Java applications, for real-time systems, the JIT compiler has two main drawbacks. One is that it interrupts other threads from execution and the time it takes is unpredictable. Secondly, the speculative optimizations are not suitable for real-time applications. [95] compared AOT and JIT compilers and [96] introduced their implementation and evaluation in IBM WebSphere VM. However, the JIT compiler is still capable of soft real-time systems, as reported in [1]. A carefully managed priority is necessary and some optimizations must be turned off. In addition, Sun and Zhang [97,98] explored multicore processors to improve time predictability of dynamic compilation.

      >  C. AOT Compilation

    The AOT compiler does most of the work before execution, with only the dynamic part left to runtime. The AOT compilation can provide higher performance than interpretation, while keeping good time predictability. However, the part that the AOT compiler cannot complete before execution is very crucial to the performance. For example, the AOT compiler has no idea of class references nor dynamically generated classes. It has to use a resolution thread to patch such information during runtime. Furthermore, none of the aggressive inlining can be performed by the AOT compiler due to lack of class references, which loses a great chance to improve performance. In any case, the AOT compiler is still the best choice for hard real-time systems, and is included in most modern real-time JVMs [49,62,63].

    VI. JAVA PROCESSORS FOR REAL-TIME COMPUTING

    Beside all the above software approaches, hardware implementation of JVM which is called Java processor is also presented as a solution of real-time systems. Basically, a Java processor is a stack based processor and executes JBC directly. Method cache and stack cache take the places of instruction cache and data cache, separately, inside of Java processors. It is possible that Java processors are designed to be deterministic in terms of execution time. Komodo [33] is an early implementation of Java processors that provide the main Java features and support real-time tasks. [99] continued working on Komodo processor with advanced scheduling and event-handling algorithms. SHAP [100] is another Java processor that is designed specifically for real-time systems. It implements fast context switching and concurrent GC. JOP [101,102] is a well-developed Java processor which is WCET analyzable. Method cache in JOP simplifies the analysis of WCET in control flow, because only thread switching can introduce cache misses. Tools for performing WCET analysis on JOP is provided in [103]. The high level WCET analysis is based on ILP and a low level timing model is provided by JOP properties. Similar works have also been done in [104,105]. Besides, Harmon and Klefstad [106] adapted their work of WCET annotation to Java processors, and made it interactive to developers in order to offer various feedbacks.

    VII. EXPERIMENTAL FRAMEWORKS

    The research resources of real-time Java are quite limited. Only a few real-time JVMs are completed and fewer of them are under an open-source license.

    IBM [49] and Sun Microsystem (now Oracle) [62] are two main companies who provide well-developed commercial real-time Java products. Evaluation or academic version of their real-time JVM can be obtained from the Internet. However, the source code is unavailable.

    OVM [63] is a good choice. It is open-sourced, supports most of RTSJ’s features, and is still an active research project [6,107] with some documents. It has been tested in our lab and appears to work well. There are two main problems with OVM: first, its JIT compiler is quite simple and incomplete (lack of dynamic class loading); second, OVM is obviously designed for a single processor. Extra work is needed if we want to do some research on multicore systems.

    An alternative may be jRate [108], whose source code is also available. jRate is an extension to the GNU GCJ compiler and a group of runtime libraries. It implemented most features needed by RTSJ.

    Another candidate is Jikes RVM [65]. Although Jikes RVM is not designed for real time purpose, it is the most completed open-source JVM. Actually the prototype of the Metronome garbage collector is implemented on Jikes RVM. So it is possible to develop real-time extension for Jikes RVM.

    A Java library named Javolution [109] may be helpful. It is an extended library on Sun Java implementing RTSJ. It is open-sourced.

    Aside from these software solutions, the JOP [101] Java processor is also open-sourced, in VHDL format. So it is possible to combine it with some simulators such as SimpleScalar or Trimaran so as to build a multiprocessor system. There is some research work [110] focusing on multiprocessor, and I think this is a very promising research field.

    VIII. CONCLUSIONS

    Real-time embedded systems have increasingly become integral to our society. Real-time applications range from safety-critical systems such as aircraft and nuclear power plant controllers, to entertainment software such as video games and graphics animation. Recently, there have been growing interests in using Java for a wide variety of both soft- and hard-real-time systems, primarily due to Java’s inherent features such as platform independence, scalability and safety. However, to enable real-time Java computing, the computation time of Java applications must be predictable, which is especially important for hard realtime and safety-critical systems.

    This paper surveys this relatively new research area, which is expected to help researchers understand the state-of-the-art and to advance the real-time Java computing. In this work, we have reviewed the RTSJ and the WCET analysis of Java applications at both the byte code level and the architectural level. Since garbage collection can disrupt the time predictability, we have surveyed the state-of-the-art solutions of real-time Java GC for both uniprocessors and multiple processors. Due to the importance of JIT compilation on the performance of Java programs, we have also discussed the compiler issues for real-time Java applications. In addition to the softwarebased solutions to achieve time-predictable Java computing, we have also briefly explained the current work in designing real-time Java processors. To assist new researchers in selecting a suitable real-time Java experimental framework, this paper also listed a number of current open-source and private real-time JVMs, libraries and soft Java processors.

    As can be seen in this overview, real-time Java computing is an active and promising research field. There are many research challenges and opportunities as well. Based on this survey, further investigation is still needed in the following directions:

    - Time-predictable dynamic compilation for real-time Java applications

    - Real-time Java on multiprocessor (multiple uniprocessor OR uniprocessor+Java processor)

    - Low level Java WCET analysis with architectural timing information (cache, branch prediction, etc.)

    - Multiprocessor/multicore real-time GC algorithms.

  • 1. Auerbach J., Bacon D. F., Blainey B., Cheng P., Dawson M., Fulton M., Grove D., Hart D., Stoodley M. 2007 “Design and implementation of a comprehensive real-time Java virtual machine” [in Proceedings of the 7th ACM & IEEE International Conference on Embedded Software] P.249-258 google
  • 2. Lammers D. 2005 “Real-time Java: reliability quest fuels RT Java projects,” Electronic Engineering Times google
  • 3. Wilhelm R., Engblom J., Ermedahl A., Holsti N., Thesing S., Whalley D. B., Bernat G., Ferdinand C., Heckmann R., Mitra T. 2008 “The worst-case execution time problem: overview of methods and survey of tools” [ACM Transactions on Embedded Computing Systems] Vol.7 google doi
  • 4. Nilsen K. “Issues in the design and implementation of realtime Java” google
  • 5. Gosling J., Bollella G. 2000 The Real-Time Specification for Java google
  • 6. Baker J., Cunei A., Flack C., Pizlo F., Prochazka M., Vitek J., Armbruster A., Pla E., Holmes D. 2006 “A real-time Java virtual machine for avionics: an experience report” [in Proceedings of the 12th IEEE Real-Time and Embedded Technology and Applications Symposium] P.384-396 google
  • 7. Sharp D. 2001 “Real-time distributed object computing: ready for mission-critical embedded system applications” [in Proceedings of the 3rd International Symposium on Distributed Objects and Applications] P.3-4 google
  • 8. Henties T., Hunt J., Locke D., Nilsen K., Schoeberl M., Vitek J. 2009 “Java for safety-critical applications” [in 2nd International Workshop on the Certification of Safety-Critical Software Controlled Systems] google
  • 9. Kwon J., Wellings A., King S. 2002 “Ravenscar-Java: a high integrity profile for real-time Java” [in Proceedings of the 2002 Joint ACM-ISCOPE Conference on Java Grande] P.131-140 google
  • 10. Lundqvist T., Stenstrom P. 1999 “Timing anomalies in dynamically scheduled microprocessors” [in Proceedings of the 20th IEEE Real-Time Systems Symposium] P.12-21 google
  • 11. Li Y. S., Malik S. 1995 “Performance analysis of embedded software using implicit path enumeration” [in Proceedings of the ACM SIGPLAN Workshop on Languages, Compilers, and Tools for Real-Time Systems] P.456-461 google
  • 12. Li Y. S., Malik S., Wolfe A. 1995 “Efficient microarchitecture modeling and path analysis for real-time software” [in Proceedings of the 16th Real-Time Systems Symposium] P.298 google
  • 13. Arnold R., Mueller F., Whalley D., Harmon M. 1994 “Bounding worst-case instruction cache performance” [in Proceedings of the 15th IEEE Real-Time Systems Symposium] P.172-181 google
  • 14. Li Y. S., Malik S., Wolfe A. 1996 “Cache modeling for realtime software: beyond direct mapped instruction cache” [in Proceedings of the 17th Real-Time Systems Symposium] P.254-263 google
  • 15. Alt M., Ferdinand C., Martin F., Wilhelm R., Cousot R., Schmidt D. 1996 “Cache behavior prediction by abstract interpretation,” Static Analysis, Lecture Notes in Computer Science vol. 1145 P.52-66 google
  • 16. Yan J., Zhang W. 2007 “WCET analysis of instruction caches with prefetching” [in Proceedings of the ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems] P.175-184 google
  • 17. Lesage B., Hardy D., Puaut I. 2009 “WCET analysis of multi-level set-associative data caches” [in Proceedings of the 9th International Workshop on Worst-Case Execution Time Analysis] google
  • 18. Huynh B., Ju L., Roychoudhury A. 2011 “Scope-aware data cache analysis for WCET estimation” [in Proceedings of the 17th IEEE Real-Time and Embedded Technology and Applications Symposium] P.203-212 google
  • 19. Li X., Roychoudhury A., Mitra T. 2004 “Modeling out-oforder processors for software timing analysis” [in Proceedings of the 25th IEEE International Real-Time Systems Symposium] P.92-103 google
  • 20. Yan J., Zhang W. 2008 “WCET analysis for multi-core processors with shared instruction caches” [in Proceedings of 14th IEEE Real-Time and Embedded Technology and Applications Symposium] P.80-89 google
  • 21. Zhang W., Yan J. 2009 “Accurately estimating worst-case execution time for multi-core processors with shared instruction caches” [in Proceedings of the 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications] P.455-463 google
  • 22. Li Y., Suhendra V., Liang Y., Mitra T., Roychoudhury A. 2009 “Timing analysis of concurrent programs running on shared cache multi-cores” [in Proceedings of the IEEE Real-time System Symposium] P.57-67 google
  • 23. Zhang W., Yan J. 2012 “Static timing analysis of shared caches for multicore processors” [Journal of Computing Science and Engineering] Vol.6 P.267-278 google doi
  • 24. Wu L., Zhang W. 2012 “A model checking based approach to bounding worst-case execution time for multicore processors” [ACM Transactions on Embedded Computer Systems] Vol.11 google
  • 25. Ding Y., Zhang W. 2013 “Multicore real-time scheduling to reduce inter-thread cache interferences” [Journal of Computing Science and Engineering] Vol.7 P.67-80 google doi
  • 26. Lv M., Yi W., Guan N., Yu G. 2010 “Combining abstract interpretation with model checking for timing analysis of multicore software” [in Proceedings of the 31th IEEE International Real-time System Symposium] P.339-349 google
  • 27. Kelter T., Falk H., Marwedel P., Chattopadhyay S., Roychoudhury A. 2011 “Bus-aware multicore WCET analysis through TDMA offset bounds” [in Proceedings of the 23rd Euromicro Conference on Real-time Systems] P.3-12 google
  • 28. Chattopadhyay S., Roychoudhury A., Mitra T. 2010 “Modeling shared cache and bus in multi-cores for timing analysis” [in Proceedings of the 13th International Workshop on Software and Compilers for Embedded Systems] google
  • 29. Puschner P., Bernat G. 2001 “Wcet analysis of reusable portable code” [in Proceedings of the 13th Euromicro Conference on Real-Time Systems] P.45-52 google
  • 30. Bernat G., Burns A., Wellings A. 2000 “Portable worst-case execution time analysis using Java byte code” [in Proceedings of the 12th Euromicro conference on Real-time systems] P.81-88 google
  • 31. Bate L., Bernat G., Puschner P. 2002 “Java virtual-machine support for portable worst-case execution-time analysis” [in Proceedings of the 5th IEEE International Symposium on Object-Oriented Real-Time Distributed Computing] P.83-90 google
  • 32. Kaffe Java Virtual Machine google
  • 33. Brinkschulte U., Krakowski C., Kreuzinger J., Ungerer T. 1999 “A multithreaded Java microcontroller for threadoriented real-time event handling” [in Proceedings of the International Conference on Parallel Architectures and Compilation Techniques] P.34-39 google
  • 34. Hu E. Y., Bernat G., Wellings A. 2002 “Addressing dynamic dispatching issues in WCET analysis for object-oriented hard real-time systems” [in Proceedings of the 5th IEEE International Symposium on Object-Oriented Real-Time Distributed Computing] P.109-116 google
  • 35. Hu E. Y., Wellings A., Bernat G., Chen J., Hong S. 2004 “XRTJ: an extensible distributed high-integrity real-time Java environment,” Real- Time and Embedded Computing Systems and Applications, Lecture Notes in Computer Science vol. 2968 P.208-228 google
  • 36. Harmon T., Klefstad R. 2007 “Toward a unified standard for worst-case execution time annotations in real-time Java” [in Proceedings of 21th International Parallel and Distributed Processing Symposium] P.1-8 google
  • 37. Hepp S., Schoeberl M. 2012 “Worst-case execution time based optimization of real-time Java programs” [in Proceedings of IEEE 15th International Symposium on Object/Component/Service-Oriented Real-Time] P.64-70 google
  • 38. Hu E. Y., Wellings A., Bernat G., Meersman R., Tari Z. 2003 “Deriving Java virtual machine timing models for portable worst-case execution time analysis,” On The Move to Meaningful Internet Systems 2003: OTM 2003 Workshops, Lecture Notes in Computer Science vol. 2889 P.411-424 google
  • 39. Bate I., Bernat G., Murphy G., Puschner P. 2000 “Low-level analysis of a portable Java byte code WCET analysis framework” [in Proceedings of Seventh International Conference on Real-Time Computing Systems and Applications] P.39-48 google
  • 40. Beebee W. S., Rinard M. C. 2001 “An implementation of scoped memory for real-time Java” [in Proceedings of the 1st International Workshop on Embedded Software] P.289-305 google
  • 41. Corsaro A., Schmidt D. C., Meersman R., Tari Z. 2002 “The design and performance of the jRate real-time Java implementation,” On the Move to Meaningful Internet Systems 2002: CoopIS, DOA, and ODBASE, Lecture Notes in Computer Science vol. 2519 P.900-921 google
  • 42. Pizlo F., Fox J., Holmes D., Vitek J. 2004 “Real-time Java scoped memory: design patterns and semantics” [in Proceeding Object-Oriented Real-Time Distributed Computing] P.101-110 google
  • 43. Andreae C., Coady Y., Gibbs C., Noble J., Vitek J., Zhao T. 2007 “Scoped types and aspects for real-time Java memory management” [Real-Time Systems] Vol.37 P.1-44 google
  • 44. Henry J., Baker G. 1978 “List processing in real time on a serial computer” [Communications of the ACM] Vol.21 P.280-294 google doi
  • 45. Kero M., Nordlander J., Lindgren P. 2007 “A correct and useful incremental copying garbage collector” [in Proceedings of the 6th International Symposium on Memory Management] P.129-140 google
  • 46. Siebert F. 1999 “Hard real-time garbage-collection in the Jamaica virtual machine” [in Proceedings of the 6th International Conference on Real-Time Computing Systems and Applications] P.96-102 google
  • 47. Schmidt W. J., Nilsen K. D. 1994 “Performance of a hardware- assisted real-time garbage collector” [in Proceedings of the 6th International Conference on Architectural Support for Programming Languages and Operating Systems] P.76-85 google
  • 48. Bacon D. F., Cheng P., Rajan V. T. 2003 “A real-time garbage collector with low overhead and consistent utilization” [ACM SIGPLAN Notices] Vol.38 P.285-298 google doi
  • 49. IBM WebSphere Virtual Machine google
  • 50. Bacon D., Cheng P., Meersman R., Tari Z. 2003 “The metronome: an simpler approach to garbage collection in real-time systems,” On The Move to Meaningful Internet Systems 2003: OTM 2003 Workshops, Lecture Notes in Computer Science vol. 2889 P.466-478 google
  • 51. Bacon D. F., Cheng P., Rajan V. T. 2003 “Controlling fragmentation and space consumption in the metronome, a realtime garbage collector for Java” [ACM SIGPLAN Notices] Vol.38 P.81-92 google doi
  • 52. Henriksson R. 1998 “Scheduling garbage collection in embedded systems” google
  • 53. Robertz S. G., Henriksson R. 2003 “Time-triggered garbage collection: robust and adaptive real-time GC scheduling for embedded systems” [ACM SIGPLAN Notices] Vol.38 P.93-102 google doi
  • 54. Schoeberl M., Vitek J. 2007 “Garbage collection for safety critical Java” [in Proceedings of the 5th International Workshop on Java Technologies for Real-Time and Embedded Systems] P.85-93 google
  • 55. Cho H., Na C., Ravindran B., Jensen E. D. 2007 “On scheduling garbage collector in dynamic real-time systems with statistical timing assurances” [Real-Time Systems] Vol.36 P.23-46 google doi
  • 56. Cheng P., Blelloch G. E. 2001 “A parallel, real-time garbage collector” [in Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation] P.125-136 google
  • 57. Blelloch G. E., Cheng P. 1999 “On bounding time and space for multiprocessor garbage collection” [ACM SIGPLAN Notices] Vol.34 P.104-117 google doi
  • 58. Xian Y., Xiong G. 2005 “Minimizing memory requirement of real-time systems with concurrent garbage collector” [ACM SIGPLAN Notices] Vol.40 P.40-48 google doi
  • 59. Hudson R. L., Moss J. E. B. 2001 “Sapphire: copying GC without stopping the world” [in Proceedings of the Joint ACM-ISCOPE Conference on Java Grande] P.48-57 google
  • 60. Pizlo F., Petrank E., Steensgaard B. 2008 “A study of concurrent real-time garbage collectors” [in Proceedings of the ACM SIGPLAN Conference on Programming Language Design and Implementation] P.33-44 google
  • 61. Pizlo F., Frampton D., Petrank E., Steensgaard B. 2007 “Stopless: a real-time garbage collector for multiprocessors” [in Proceedings of the 6th International Symposium on Memory Management] P.159-172 google
  • 62. Sun Microsystem Real-Time Java System google
  • 63. Open Virtual Machine google
  • 64. Java SE HotSpot at a Glance google
  • 65. Jikes RVM google
  • 66. Alpern B., Attanasio C. R., Barton J. J., Burke M. G., Cheng P., Choi J. D., Cocchi A., Fink S. J., Grove D., Hind M. 2000 “The Jalapeno virtual machine” [IBM Systems Journal] Vol.39 P.211-221 google doi
  • 67. Hlzle U., Ungar D. 1996 “Reconciling responsiveness with performance in pure object-oriented languages” [ACM Transactions on Programming Languages and Systems] Vol.18 P.355-400 google doi
  • 68. Plezbert M. P., Cytron R. K. 1997 “Does ‘just in time’ = ‘better late than never’?” [in Proceedings of the 24th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages] P.120-131 google
  • 69. Karp R. M. 1992 “On-line algorithms versus off-line algorithms: How much is it worth to know the future?” [in Proceedings of the IFIP 12th World Computer Congress on Algorithms, Software, Architecture] P.416-429 google
  • 70. Kistler T. P. 1999 “Continuous program optimization” google
  • 71. Kistler T., Franz M. 2003 “Continuous program optimization: a case study” [ACM Transactions on Programming Languages and Systems] Vol.25 P.500-548 google doi
  • 72. Pettis K., Hansen R. C. 1990 “Profile guided code positioning” [ACM SIGPLAN Notices] Vol.25 P.16-27 google doi
  • 73. Chang P. P., Mahlke S. A., Hwu W. W. 1991 “Using profile information to assist classic code optimizations” [Software-Practice & Experience] Vol.21 P.1301-1321 google doi
  • 74. Hwu W., Mahlke S. A., Chen W. Y., Chang P. P., Warter N. J., Bringmann R. A., Ouellette R. G., Hank R. E., Kiyohara T., Haab G. E., Holm J. G., Lavery D. M. 1993 “The superblock: an effective technique for VLIW and superscalar compilation” [Journal of Supercomputing] Vol.7 P.229-248 google doi
  • 75. Cohn R., Lowney P. G. 2000 “Design and analysis of profilebased optimization in Compaq’s compilation tools for alpha” [Journal of Instruction-Level Parallelism] Vol.3 P.1-25 google
  • 76. Mock M., Chambers C., Eggers S. 2000 “Calpa: a tool for automating selective dynamic compilation” [in Proceedings of the 33rd annual ACM/IEEE international symposium on Microarchitecture] P.291-302 google
  • 77. Arnold M., Hind M., Ryder B. G. 2002 “Online feedbackdirected optimization of Java” [ACM SIGPLAN Notices] Vol.37 P.111-129 google doi
  • 78. Whaley J. 2001 “Partial method compilation using dynamic profile information” [ACM SIGPLAN Notices] Vol.36 P.166-179 google doi
  • 79. Arnold M., Ryder B. G. 2001 “A framework for reducing the cost of instrumented code” [ACM SIGPLAN Notices] Vol.36 P.168-179 google doi
  • 80. Hirzel M., Chilimbi T. 2001 “Bursty tracing: a framework for low-overhead temporal profiling” [in Proceeding of the 4th ACM Workshop on Feedback-Directed and Dynamic Optimization] P.117-126 google
  • 81. Chilimbi T. M., Hirzel M. 2002 “Dynamic hot data stream prefetching for general-purpose programs” [ACM SIGPLAN Notices] Vol.37 P.199-209 google doi
  • 82. Krintz C. 2003 “Coupling on-line and off-line profile information to improve program performance” [in Proceeding of the International Symposium on Code Generation and Optimization] P.69-78 google
  • 83. Fink S. J., Qian F. 2003 “Design, implementation and evaluation of adaptive recompilation with on-stack replacement” [in Proceedings of the International Symposium on Code Generation and Optimization] P.241-252 google
  • 84. Hansen G. J. 1974 “Adaptive systems for the dynamic run-time optimization of programs” google
  • 85. Chambers C., Ungar D. 1991 “Making pure object-oriented languages practical” [in Proceeding of ACM Conference Object-Oriented Programming Systems, Languages, and Applications] P.1-15 google
  • 86. Suganuma T., Yasue T., Nakatani T. 2003 “A region-based compilation technique for a Java just-in-time compiler” [ACM SIGPLAN Notices] Vol.38 P.312-323 google doi
  • 87. Holzle U., Chambers C., Ungar D. 1992 “Debugging optimized code with dynamic deoptimization” [ACM SIGPLAN Notices] Vol.27 P.32-43 google doi
  • 88. Oh H. S., Moon S. M., Jung D. H. 2012 “Hybrid Java compilation of just-in-time and ahead-of-time for embedded systems” [Journal of Circuits, Systems and Computers] Vol.21 google doi
  • 89. Bradel B. J., Abdelrahman T. S. 2007 “Automatic tracebased parallelization of Java programs” [in Proceedings of the International Conference on Parallel Processing] P.26 google
  • 90. Bradel B. J., Abdelrahman T. S. 2007 “The potential of trace-level parallelism in Java programs” [in Proceedings of the 5th International Symposium on Principles and Practice of Programming in Java] P.167-174 google
  • 91. Guo S., Palsberg J. 2011 “The essence of compiling with traces” [in Proceedings of the 38th annual ACM SIGPLANSIGACT Symposium on Principles of Programming Languages] P.563-574 google
  • 92. Inoue H., Hayashizaki H., Wu P., Nakatani T. 2011 “A trace-based Java JIT compiler retrofitted from a methodbased compiler” [in Proceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimization] P.246-256 google
  • 93. Sun Y., Zhang W. 2012 “On-line trace based automatic parallelization of Java programs on multicore platforms” [Journal of Computing Science and Engineering] Vol.6 P.105-118 google doi
  • 94. Zhu Q., Vergerov D. 2009 “Adaptive optimization of the sun Java real-time system garbage collector,” Technical Report google
  • 95. Stoodley M., Ma K., Lut M. 2007 “Real-time Java, part 2: comparing compilation techniques,” Technical Report google
  • 96. Fulton M., Stoodley M. 2007 “Compilation techniques for real-time Java programs” [in Proceedings of the International Symposium on Code Generation and Optimization] P.221-231 google
  • 97. Zhang W., Sun Y. 2012 “Time-predictable Java dynamic compilation on multicore processors” [Journal of Computing Science and Engineering] Vol.6 P.26-38 google
  • 98. Sun Y., Zhang W. 2009 “Exploiting multi-core processors to improve time predictability for real-time Java computing” [in Proceedings of the 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications] P.447-454 google
  • 99. Kreuzinger J., Brinkschulte U., Pfeffer M., Uhrig S., Ungerer T. 2003 “Real-time event-handling and scheduling on a multithreaded Java microcontroller” [Microprocessors and Microsystems] Vol.27 P.19-31 google
  • 100. Zabel M., Preuber T. B., Reichel P., Spallek R. G. 2007 “Secure, real-time and multi-threaded general-purpose embedded Java microarchitecture” [in Proceedings of the 10th Euromicro Conference on Digital System Design Architectures, Methods and Tools] P.59-62 google
  • 101. Schoeberl M. 2005 “JOP: a Java optimized processor for embedded real-time systems” google
  • 102. Schoeberl M. 2008 “A Java processor architecture for embedded real-time systems” [Journal of Systems Architecture] Vol.54 P.265-286 google doi
  • 103. Schoeberl M., Pedersen R. 2006 “WCET analysis for a Java processor” [in Proceedings of the 4th International Workshop on Java Technologies for Real-Time and Embedded Systems] P.202-211 google
  • 104. Lei C. Z., Qiang T. Z., Ming W. L., Liang T. S. 2005 “An effective instruction optimization method for embedded real-time Java processor” [in Proceedings of the International Conference on Parallel Processing Workshops] P.225-231 google
  • 105. Chai Z., Zhao W., Xu W. 2007 “Real-time Java processor optimized for RTSJ” [in Proceedings of the ACM Symposium on Applied Computing] P.1540-1544 google
  • 106. Harmon T., Klefstad R. 2007 “Interactive back-annotation of worst-case execution time analysis for Java microprocessors” [in Proceedings of the 13th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications] P.209-216 google
  • 107. Armbruster A., Baker J., Cunei A., Flack C., Holmes D., Pizlo F., Pla E., Prochazka M., Vitek J. 2007 “A real-time Java virtual machine with applications in avionics” [ACM Transactions on Embedded Computing Systems] Vol.7 google
  • 108. jRate google
  • 109. Javolution Library google
  • 110. Pitter C., Schoeberl M. 2007 “Towards a Java multiprocessor” [in Proceedings of the 5th International Workshop on Java Technologies for Real-Time and Embedded Systems] P.144-151 google