Results 1 - 10
of
11
A Parallel, Real-Time Garbage Collector
, 2001
"... A'(=$B#127$C7D-7E"#%9F< >$7'(-7:;<<"G$&%- 12-*#)+1+)H7IJ->0" ;<<":'(%- 1+687)29:K*,< B>0"$%L.M.D.&%<1+12%&%7< 'K)2$"#=$)2; >%"ON5<'.$D- '(="P6 9F%9:< '(IF9?B127)+/#' ..."
Abstract
-
Cited by 111 (14 self)
- Add to MetaCart
A'(=$B#127$C7D-7E"#%9F< >$7'(-7:;<<"G$&%- 12-*#)+1+)H7IJ->0" ;<<":'(%- 1+687)29:K*,< B>0"$%L.M.D.&%<1+12%&%7< 'K)2$"#=$)2; >%"ON5<'.$D- '(="P6 9F%9:< '(IF9?B127)+/#'(<&=%$$< '($C->0"Q)2$A*0-$%"R<>S- >S%- '1+)2('C&%<1+12%&%7< ' -12;<')27D09UT VW84X.D)2&YDG/'(<Z)2"#%"R[@%"R*,<B#>"$\< >]7D0C7)29FC- >I 7D'(%-"R9CB0$7./- B$\N5< 'K&=< 1+12%&%7)2<>^LE_\<X.=Z3'4$)+>&%`< B'E%- '1+)23' -12;<')27D09aX.-$"#%$)2;>0="bN5<'K$)29c/12c->0-12I$)2$%40)27.D0-"R$<9Fd)29c6 /'(-&=7)2&%- 1.Ne%-7B'(%$%L`M.D#)2$C/0-/,3'C/'(%$3>7$`7D0`%@73>$)2< >$c>%&36 =$$- '(IfNe< 'G-!/#'(-&%7)2&%- 1`)29c/12%9:3>7-7)2< >hgi'(%"B0&()+>0;j%@&=%$$)2Z )+>7('12%-Z)+>0;4kD- >"1+)+>0;!$7-&l$\->0"!; 12<*0-1Z -')2- *12%$%4^'(%"B&3)+>0; "< B*12O-1+12<&%-7)2<>^4->0"G$/,=&3)2- 17'(%-79F3>7C< N12-'(;:->0"!$9:- 1+1 <*m%&%7$%LonK>i)29c/12%9:3>7-7)2< >o*-$%"j<>p7D0G9:<")+[%"q-12;<6 ')27D9r)2$G%Z- 1+B-7%"p< >p-J$=7R< NQstvuPwGxq*y3>0&D9:- 'l$G<>pu B>Jz>73'/')2$bs={{{{#4|-O}~ 68X.-IGd127'(-u/- '(&(6K9?B127)+/'(<&%%$6 $<'L!M<G7D0:*,%$7`< NE<B#':l><X.12%"#;4.7D)2$c)2$:7D:[#'($7`)29c/#12(6 9F3>7-7)2<>J<N-c/- '(-1+123154^'(%-1+67)29Fc;- '*-;`&%<1+12%&%7< 'L M.Dc-Z('(-;Q&%<1+12%&%7<':$/,=%"PB/J)2$FPL t:-7CO/'(<&%%$$<'($c->0" sPL -7FVb/'(<&%%$$<'($%LjwG-@)29CB09r/- B$G7)29:%$:'(- >;RN'(<9 j9F$7<ti9:$%Lr>o&%<>7'(-$7%4:-i>< >65)+>0&('(%9:3>7-1G&%<1+12%&%7< ' X.D%7D3'G;3>0('(-7)2< >- 1< 'R><7(:...
Design and Implementation of a Comprehensive Real-time Java Virtual Machine
"... The emergence of standards for programming real-time systems in Java has encouraged many developers to consider its use for systems previously only built using C, Ada, or assembly language. However, the RTSJ standard in isolation leaves many important problems unaddressed, and suffers from some seri ..."
Abstract
-
Cited by 29 (5 self)
- Add to MetaCart
The emergence of standards for programming real-time systems in Java has encouraged many developers to consider its use for systems previously only built using C, Ada, or assembly language. However, the RTSJ standard in isolation leaves many important problems unaddressed, and suffers from some serious problems in usability and safety. As a result, the use of Java for real-time programming has continued to be viewed as risky and adoption has been slow. In this paper we provide a description of IBM’s new real-time Java virtual machine product, which combines Metronome realtime garbage collection, ahead-of-time compilation, and a complete implementation of the RTSJ standard, running on top of a custom real-time multiprocessor Linux kernel. We will describe the implementation of each of these components, including how they interacted both positively and negatively, and the extensions to previous work required to move it from research prototype to a system implementing the complete semantics of the Java language. The system has been adopted for hard real-time development of naval weapons systems and soft real-time telecommunications servers. We present measurements showing that the system is able to provide sub-millisecond worst-case garbage collection latencies, 50 microsecond Linux scheduling accuracy, and eliminate non-determinism due to JIT compilation.
A Typed Interface for Garbage Collection
- In Types in Language Design and Implementation
, 2003
"... An important consideration for certified code systems is the interaction of the untrusted program with the runtime system, most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collec ..."
Abstract
-
Cited by 16 (1 self)
- Add to MetaCart
An important consideration for certified code systems is the interaction of the untrusted program with the runtime system, most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector whose interface with the program is simple enough that it does not pose any certification challenges. However, this approach rules out the use of many sophisticated highperformance garbage collectors. We present the language LGC, whose type system is capable of expressing the interface of a modern high-performance garbage collector. We use LGC to describe the interface to one such collector, which involves a substantial amount of programming at the type constructor level of the language.
Tax-and-Spend: Democratic Scheduling for Real-time Garbage Collection
"... Real-time Garbage Collection (RTGC) has recently advanced to the point where it is being used in production for financial trading, military command-and-control, and telecommunications. However, among potential users of RTGC, there is enormous diversity in both application requirements and deployment ..."
Abstract
-
Cited by 11 (1 self)
- Add to MetaCart
(Show Context)
Real-time Garbage Collection (RTGC) has recently advanced to the point where it is being used in production for financial trading, military command-and-control, and telecommunications. However, among potential users of RTGC, there is enormous diversity in both application requirements and deployment environments. Previously described RTGCs tend to work well in a narrow band of possible environments, leading to fragile systems and limiting adoption of real-time garbage collection technology. This paper introduces a collector scheduling methodology called tax-and-spend and the collector design revisions needed to support it. Tax-and-spend provides a general mechanism which works well across a variety of application, machine, and operating system configurations. Tax-and-spend subsumes the predominant pre-existing RTGC scheduling techniques. It allows different policies to be applied in different contexts depending on the needs of the application. Virtual machines can co-exist compositionally on a single machine. We describe the implementation of our system, Metronome-TS, as an extension of the Metronome collector in IBM’s Real-time J9 virtual machine product, and we evaluate it running on an 8-way SMP blade with a real-time Linux kernel. Compared to the stateof-the-art Metronome system on which it is based, implemented in the identical infrastructure, it achieves almost 3x shorter latencies, comparable utilization at a 2.5x shorter time window, and mean throughput improvements of 10-20%.
A Study of Lock-Free Based Concurrent Garbage Collectors for Multicore Platform
"... Concurrent garbage collectors (CGC) have recently obtained extensive concern on multicore platform. Excellent designed CGC can improve the efficiency of runtime systems by exploring the full potential processing resources of multicore computers. Two major performance critical components for designi ..."
Abstract
- Add to MetaCart
(Show Context)
Concurrent garbage collectors (CGC) have recently obtained extensive concern on multicore platform. Excellent designed CGC can improve the efficiency of runtime systems by exploring the full potential processing resources of multicore computers. Two major performance critical components for designing CGC are studied in this paper, stack scanning and heap compaction. Since the lock-based algorithms do not scale well, we present a lock-free solution for constructing a highly concurrent garbage collector. We adopt CAS/MCAS synchronization primitives to guarantee that the programs will never be blocked by the collector thread while the garbage collection process is ongoing. The evaluation results of this study demonstrate that our approach achieves competitive performance.
General Terms
"... most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector whose interface with the program is simple enough that it does not pose any certification challenges. However, this app ..."
Abstract
- Add to MetaCart
(Show Context)
most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector whose interface with the program is simple enough that it does not pose any certification challenges. However, this approach rules out the use of many sophisticated highperformance garbage collectors. We present the language LGC, whose type system is capable of expressing the interface of a modern high-performance garbage collector. We use LGC to describe the interface to one such collector, which involves a substantial amount of programming at the type constructor level of the language. Categories and Subject Descriptors D.3.m [Programming Languages]: Miscellaneous; D.3.4 [Programming Languages]: Processors--Compilers, Memory management
ABSTRACT A Parallel, Real-Time Garbage Collector"
"... We describe a parallel, real-time garbage collector and present experimental results that demonstrate good scalability and good real-time bounds. The collector is designed for share& memory multiprocessors and is based on an earlier collector algorithm [2], which provided fixed bounds on the tim ..."
Abstract
- Add to MetaCart
(Show Context)
We describe a parallel, real-time garbage collector and present experimental results that demonstrate good scalability and good real-time bounds. The collector is designed for share& memory multiprocessors and is based on an earlier collector algorithm [2], which provided fixed bounds on the time any thread must pause for collection. However, since our earlier algorithm was designed for simple analysis, it had some im-practical features. This paper presents the extensions nec-essary for a practical implementation: reducing excessive interleaving, handling stacks and global variables, reducing double allocation, and special treatment of large and small objects. An implementation based on the modified algo-rithm is evaluated on a set of 15 SML benchmarks on a Sun Enterprise 10000, a 64-way UltraSparc-II multiproces-sor. To the best of our knowledge, this is the first imple-mentation of a parallel, real-time garbage collector. The average collector speedup is 7.5 at 8 processors and 17.7 at 32 processors. Maximum pause times range from 3 ms to 5 ms. In contrast, a non-incremental collector (whether generational or not) has maximum pause times from 10 ms to 650 ms. Compared to a non-parallel, stop-copy collector, parallelism has a 39 % overhead, while real-time behavior adds an additional 12 % overhead. Since the collector takes about 15 % of total execution time, these fea-tures have an overall time costs of 6 % and 2%. 1.
Languages, Security
"... important consideration for certified code systems is the interaction of the untrusted program with the runtime system, most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector ..."
Abstract
- Add to MetaCart
important consideration for certified code systems is the interaction of the untrusted program with the runtime system, most notably the garbage collector. Most certified code systems that treat the garbage collector as part of the trusted computing base dispense with this issue by using a collector whose interface with the program is simple enough that it does not pose any certification challenges. However, this approach rules out the use of many sophisticated highperformance garbage collectors. We present the language LGC, whose type system is capable of expressing the interface of a modern high-performance garbage collector. We use LGC to describe the interface to one such collector, which involves a substantial amount of programming at the type constructor level of the language.
A Scheduling Real-time Garbage Collection on Uni-Processors
"... Managed languages such as Java and C # are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for ..."
Abstract
- Add to MetaCart
Managed languages such as Java and C # are increasingly being considered for hard real-time applications because of their productivity and software engineering advantages. Automatic memory management, or garbage collection, is a key enabler for robust, reusable libraries, yet remains a challenge for analysis and implementation of real-time execution environments. This paper comprehensively compares leading approaches to hard real-time garbage collection. There are many design decisions involved in selecting a real-time garbage collection algorithm. For time-based garbage collectors on uni-processors one must choose whether to use periodic, slack-based or hybrid scheduling. A significant impediment to valid experimental comparison of such choices is that commercial implementations use completely different proprietary infrastructures. We present Minuteman, a framework for experimenting with real-time collection algorithms in the context of a high-performance execution environment for real-time Java. We provide the first comparison of the approaches, both experimentally using realistic workloads, and analytically in terms of schedulability.
