Overview of Real-Time Java Computing

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. Category: Embedded computing

[1]  Scott A. Mahlke,et al.  The superblock: An effective technique for VLIW and superscalar compilation , 1993, The Journal of Supercomputing.

[2]  Markus Mock,et al.  Calpa: a tool for automating selective dynamic compilation , 2000, MICRO 33.

[3]  J. Eliot B. Moss,et al.  Sapphire: copying GC without stopping the world , 2001, JGI '01.

[4]  Filip Pizlo,et al.  Stopless: a real-time garbage collector for multiprocessors , 2007, ISMM '07.

[5]  Jan Vitek,et al.  Scoped types and aspects for real-time Java memory management , 2007, Real-Time Systems.

[6]  James Gosling,et al.  The Real-Time Specification for Java , 2000, Computer.

[7]  Peter Reichel,et al.  Secure, Real-Time and Multi-Threaded General-Purpose Embedded Java Microarchitecture , 2007, 10th Euromicro Conference on Digital System Design Architectures, Methods and Tools (DSD 2007).

[8]  Siamac Fazli,et al.  Brain Computer Interfacing: A Multi-Modal Perspective , 2013, J. Comput. Sci. Eng..

[9]  Jakob Engblom,et al.  The worst-case execution-time problem—overview of methods and survey of tools , 2008, TECS.

[10]  Andrew W. Appel,et al.  Type-preserving garbage collectors , 2001, POPL '01.

[11]  Martin Schoeberl,et al.  A Java processor architecture for embedded real-time systems , 2008, J. Syst. Archit..

[12]  Wei Zhang,et al.  Accurately Estimating Worst-Case Execution Time for Multi-core Processors with Shared Direct-Mapped Instruction Caches , 2009, 2009 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications.

[13]  Qian Zhu,et al.  Adaptive optimization of the Sun Java™ real-time system garbage collector , 2009 .

[14]  Tarek S. Abdelrahman,et al.  The potential of trace-level parallelism in Java programs , 2007, PPPJ.

[15]  Martin Schoeberl,et al.  Worst-Case Execution Time Based Optimization of Real-Time Java Programs , 2012, 2012 IEEE 15th International Symposium on Object/Component/Service-Oriented Real-Time Distributed Computing.

[16]  Martin Hirzel,et al.  Dynamic hot data stream prefetching for general-purpose programs , 2002, PLDI '02.

[17]  Mark G. Stoodley,et al.  Compilation Techniques for Real-Time Java Programs , 2007, International Symposium on Code Generation and Optimization (CGO'07).

[18]  Craig Chambers,et al.  Making pure object-oriented languages practical , 1991, OOPSLA '91.

[19]  Wei Zhang,et al.  WCET analysis of instruction caches with prefetching , 2007, LCTES '07.

[20]  Joshua S. Auerbach,et al.  Design and implementation of a comprehensive real-time java virtual machine , 2007, EMSOFT '07.

[21]  Scott A. Mahlke,et al.  Using profile information to assist classic code optimizations , 1991, Softw. Pract. Exp..

[22]  Toshiaki Yasue,et al.  A region-based compilation technique for a Java just-in-time compiler , 2003, PLDI '03.

[23]  Wei Zhang,et al.  WCET Analysis for Multi-Core Processors with Shared L2 Instruction Caches , 2008, 2008 IEEE Real-Time and Embedded Technology and Applications Symposium.

[24]  Cuntai Guan,et al.  Brain-Computer Interface in Stroke Rehabilitation , 2013, J. Comput. Sci. Eng..

[25]  Sharad Malik,et al.  Performance Analysis of Embedded Software Using Implicit Path Enumeration , 1995, 32nd Design Automation Conference.

[26]  Richard M. Karp,et al.  On-Line Algorithms Versus Off-Line Algorithms: How Much is it Worth to Know the Future? , 1992, IFIP Congress.

[27]  Guy E. Blelloch,et al.  On bounding time and space for multiprocessor garbage collection , 1999, PLDI '99.

[28]  John Whaley.  Partial method compilation using dynamic profile information , 2001, OOPSLA '01.

[29]  Martin Schoeberl,et al.  Towards a Java multiprocessor , 2007, JTRES.

[30]  Ron Cytron,et al.  Does “just in time” = “better late than never”? , 1997, POPL '97.

[31]  서정연,et al.  Journal of Computing Science and Engineering(JCSE)의 국제화 작업 , 2010 .

[32]  David Gay,et al.  Software design patterns for TinyOS , 2005, LCTES '05.

[33]  Iain Bate,et al.  Java virtual-machine support for portable worst-case execution-time analysis , 2002, Proceedings Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISIRC 2002.

[34]  David B. Whalley,et al.  Bounding worst-case instruction cache performance , 1994, 1994 Proceedings Real-Time Systems Symposium.

[35]  Karl Pettis,et al.  Profile guided code positioning , 1990, PLDI '90.

[36]  Douglas C. Schmidt,et al.  The Design and Performance of the jRate Real-Time Java Implementation , 2002, OTM.

[37]  Martin Schoeberl,et al.  WCET analysis for a Java processor , 2006, JTRES '06.

[38]  ZhiLei Chai,et al.  An effective instruction optimization method for embedded real-time Java processor , 2005, 2005 International Conference on Parallel Processing Workshops (ICPPW'05).

[39]  Wenbo Xu,et al.  Real-time Java processor optimized for RTSJ , 2007, SAC '07.

[40]  Matthew Arnold,et al.  A framework for reducing the cost of instrumented code , 2001, PLDI '01.

[41]  Jan Vitek,et al.  Real-time Java scoped memory: design patterns and semantics , 2004, Seventh IEEE International Symposium onObject-Oriented Real-Time Distributed Computing, 2004. Proceedings..

[42]  Martin C. Rinard,et al.  An Implementation of Scoped Memory for Real-Time Java , 2001, EMSOFT.

[43]  Gilbert Joseph Hansen,et al.  Adaptive systems for the dynamic run-time optimization of programs. , 1974 .

[44]  S. L. Graham,et al.  List Processing in Real Time on a Serial Computer , 1978 .

[45]  V. T. Rajan,et al.  A real-time garbage collector with low overhead and consistent utilization , 2003, POPL '03.

[46]  Roger Henriksson,et al.  Scheduling Garbage Collection in Embedded Systems , 1998 .

[47]  Per Lindgren,et al.  A correct and useful incremental copying garbage collector , 2007, ISMM '07.

[48]  Zahir Tari,et al.  On the Move to Meaningful Internet Systems. OTM 2018 Conferences , 2018, Lecture Notes in Computer Science.

[49]  Wang Yi,et al.  Combining Abstract Interpretation with Model Checking for Timing Analysis of Multicore Software , 2010, 2010 31st IEEE Real-Time Systems Symposium.

[50]  Andy J. Wellings,et al.  Addressing dynamic dispatching issues in WCET analysis for object-oriented hard real-time systems , 2002, Proceedings Fifth IEEE International Symposium on Object-Oriented Real-Time Distributed Computing. ISIRC 2002.

[51]  Sharad Malik,et al.  Efficient microarchitecture modeling and path analysis for real-time software , 1995, Proceedings 16th IEEE Real-Time Systems Symposium.

[52]  Robert S. Cohn,et al.  Design and Analysis of Profile-Based Optimization in Compaq's Compilation Tools for Alpha , 2000, J. Instr. Level Parallelism.

[53]  Wei Zhang,et al.  A Model Checking Based Approach to Bounding Worst-Case Execution Time for Multicore Processors , 2012, TECS.

[54]  Xianfeng Li,et al.  Modeling out-of-order processors for software timing analysis , 2004, 25th IEEE International Real-Time Systems Symposium.

[55]  Soo-Mook Moon,et al.  Hybrid Java Compilation of Just-in-Time and Ahead-of Time for Embedded Systems , 2012, J. Circuits Syst. Comput..

[56]  Wei Zhang,et al.  Static Timing Analysis of Shared Caches for Multicore Processors , 2012, J. Comput. Sci. Eng..

[57]  Andy J. Wellings,et al.  Deriving Java Virtual Machine Timing Models for Portable Worst-Case Execution Time Analysis , 2003, OTM Workshops.

[58]  David F. Bacon,et al.  Controlling fragmentation and space consumption in the metronome, a real-time garbage collector for Java , 2003 .

[59]  Chandra Krintz.  Coupling on-line and off-line profile information to improve program performance , 2003, International Symposium on Code Generation and Optimization, 2003. CGO 2003..

[60]  Uwe Brinkschulte,et al.  A multithreaded Java microcontroller for thread-oriented real-time event-handling , 1999, 1999 International Conference on Parallel Architectures and Compilation Techniques (Cat. No.PR00425).

[61]  V. T. Rajan,et al.  The Metronome: A Simpler Approach to Garbage Collection in Real-Time Systems , 2003, OTM Workshops.

[62]  Iain Bate,et al.  Low-level analysis of a portable Java byte code WCET analysis framework , 2000, Proceedings Seventh International Conference on Real-Time Computing Systems and Applications.

[63]  Raymond Klefstad,et al.  Toward a Unified Standard for Worst-Case Execution Time Annotations in Real-Time Java , 2007, 2007 IEEE International Parallel and Distributed Processing Symposium.

[64]  Alan Burns,et al.  Portable worst-case execution time analysis using Java Byte Code , 2000, Proceedings 12th Euromicro Conference on Real-Time Systems. Euromicro RTS 2000.

[65]  Martin Schoeberl,et al.  Java for Safety-Critical Applications , 2009 .

[66]  Abhik Roychoudhury,et al.  Scope-Aware Data Cache Analysis for WCET Estimation , 2011, 2011 17th IEEE Real-Time and Embedded Technology and Applications Symposium.

[67]  Jan Vitek,et al.  Garbage collection for safety critical Java , 2007, JTRES.

[68]  Binoy Ravindran,et al.  On Scheduling Garbage Collector in Dynamic Real-Time Systems With Statistical Timing Assurances , 2006, ISORC.

[69]  Michael Franz,et al.  Continuous program optimization: A case study , 2003, TOPL.

[70]  Stephen J. Fink,et al.  The Jalapeño virtual machine , 2000, IBM Syst. J..

[71]  Wei Zhang,et al.  Time-Predictable Java Dynamic Compilation on Multicore Processors , 2012, J. Comput. Sci. Eng..

[72]  Jan Vitek,et al.  A Real-time Java Virtual Machine for Avionics - An Experience Report , 2006, 12th IEEE Real-Time and Embedded Technology and Applications Symposium (RTAS'06).

[73]  Kim G. Larsen,et al.  Real-time specifications , 2013, International Journal on Software Tools for Technology Transfer.

[74]  Jan Vitek,et al.  A real-time Java virtual machine with applications in avionics , 2007, TECS.

[75]  Andy J. Wellings,et al.  XRTJ: An Extensible Distributed High-Integrity Real-Time Java Environment , 2003, RTCSA.

[76]  Wei Zhang,et al.  On-Line Trace Based Automatic Parallelization of Java Programs on Multicore Platforms , 2011, 2011 15th Workshop on Interaction between Compilers and Computer Architectures.

[77]  Peter Marwedel,et al.  Bus-Aware Multicore WCET Analysis through TDMA Offset Bounds , 2011, 2011 23rd Euromicro Conference on Real-Time Systems.

[78]  Craig Chambers,et al.  Debugging optimized code with dynamic deoptimization , 1992, PLDI '92.

[79]  David C. Sharp,et al.  Real-time distributed object computing: ready for mission-critical embedded system applications , 2001, Proceedings 3rd International Symposium on Distributed Objects and Applications.

[80]  Trevor Mudge,et al.  MacroSS: macro-SIMDization of streaming applications , 2010, ASPLOS 2010.

[81]  Wei Zhang,et al.  Exploiting Multi-core Processors to Improve Time Predictability for Real-Time Java Computing , 2009, 2009 15th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications.

[82]  Stephen J. Fink,et al.  Design, implementation and evaluation of adaptive recompilation with on-stack replacement , 2003, International Symposium on Code Generation and Optimization, 2003. CGO 2003..

[83]  Kelvin D. Nilsen,et al.  Performance of a hardware-assisted real-time garbage collector , 1994, ASPLOS VI.

[84]  Guillem Bernat,et al.  WCET analysis of reusable portable code , 2001, Proceedings 13th Euromicro Conference on Real-Time Systems.

[85]  Andy J. Wellings,et al.  Ravenscar‐Java: a high‐integrity profile for real‐time Java , 2002, JGI '02.

[86]  Urs Hölzle,et al.  Reconciling responsiveness with performance in pure object-oriented languages , 1996, TOPL.

[87]  Martin Schoeberl,et al.  JOP: A Java Optimized Processor for Embedded Real-Time Systems , 2008 .

[88]  Martin Hirzel,et al.  Bursty Tracing: A Framework for Low-Overhead Temporal Profiling , 2001 .

[89]  Guy E. Blelloch,et al.  A parallel, real-time garbage collector , 2001, PLDI '01.

[90]  Wei Zhang,et al.  Multicore Real-Time Scheduling to Reduce Inter-Thread Cache Interferences , 2013, J. Comput. Sci. Eng..

[91]  Sharad Malik,et al.  Cache modeling for real-time software: beyond direct mapped instruction caches , 1996, 17th IEEE Real-Time Systems Symposium.

[92]  Kelvin Nilsen,et al.  Issues in the Design and Implementation of Real-Time Java , 1998 .

[93]  Michael Franz,et al.  Continuous program optimization , 1999 .

[94]  Guangze Xiong,et al.  Minimizing memory requirement of real-time systems with concurrent garbage collector , 2005, SIGP.

[95]  Henry G. Baker,et al.  List processing in real time on a serial computer , 1978, CACM.

[96]  Per Stenström,et al.  Timing anomalies in dynamically scheduled microprocessors , 1999, Proceedings 20th IEEE Real-Time Systems Symposium (Cat. No.99CB37054).

[97]  Jens Palsberg,et al.  The essence of compiling with traces , 2011, POPL '11.

[98]  Tarek S. Abdelrahman,et al.  Automatic Trace-Based Parallelization of Java Programs , 2007, 2007 International Conference on Parallel Processing (ICPP 2007).

[99]  Damien Hardy,et al.  WCET Analysis of Multi-Level Set-Associative Data Caches , 2009, WCET.

[100]  Raymond Klefstad,et al.  Interactive Back-annotation of Worst-case Execution Time Analysis for Java Microprocessors , 2007, 13th IEEE International Conference on Embedded and Real-Time Computing Systems and Applications (RTCSA 2007).

[101]  Toshio Nakatani,et al.  A trace-based Java JIT compiler retrofitted from a method-based compiler , 2011, International Symposium on Code Generation and Optimization (CGO 2011).

[102]  Filip Pizlo,et al.  A study of concurrent real-time garbage collectors , 2008, PLDI '08.

[103]  Tulika Mitra,et al.  Modeling shared cache and bus in multi-cores for timing analysis , 2010, SCOPES.

[104]  Fridtjof Siebert,et al.  Hard real-time garbage collection in the Jamaica virtual machine , 1999, Proceedings Sixth International Conference on Real-Time Computing Systems and Applications. RTCSA'99 (Cat. No.PR00306).

[105]  Reinhard Wilhelm,et al.  Cache Behavior Prediction by Abstract Interpretation , 1996, Sci. Comput. Program..

[106]  Matthew Arnold,et al.  Online feedback-directed optimization of Java , 2002, OOPSLA '02.

[107]  Sascha Uhrig,et al.  Real-time event-handling and scheduling on a multithreaded Java microcontroller , 2003, Microprocess. Microsystems.

[108]  Yun Liang,et al.  Timing analysis of concurrent programs running on shared cache multi-cores , 2009, 2009 30th IEEE Real-Time Systems Symposium.

[109]  Sven Gestegard Robertz,et al.  Time-triggered garbage collection: robust and adaptive real-time GC scheduling for embedded systems , 2003, LCTES '03.