scholarly journals A performance comparison of garbage collector algorithms in Java Virtual Machine

2019 ◽  
Vol 13 ◽  
pp. 359-365
Author(s):  
Igor Kopeć ◽  
Jakub Smołka
Keyword(s):  
Programming Languages ◽  
Memory Management ◽  
Garbage Collection ◽  
Performance Comparison ◽  
Java Virtual Machine ◽  
Garbage Collector ◽  
System Responsiveness ◽  
Automatic Memory ◽  
A Performance

In programming languages with automatic memory management garbage collection plays an important role of cleaning unused memory. Garbage collection algorithms have been developed for many years and aim to maximize the application’s performance. This paper presents and compares a performance of five garbage collection algorithms present in current version of Java 12 in three applications with different object lifetime span. The analysis covered the system responsiveness, garbage collector workload and application throughput at high application load.

A NOTE ON THE IMPLEMENTATION OF REPLICATION-BASED GARBAGE COLLECTION FOR MULTITHREADED APPLICATIONS AND MULTIPROCESSOR ENVIRONMENTS

1999 ◽  
Vol 09 (03) ◽  
pp. 391-399 ◽  
Author(s):  
ALAIN AZAGURY ◽  
ELLIOT K. KOLODNER ◽  
EREZ PETRANK
Keyword(s):  
Virtual Machine ◽  
Garbage Collection ◽  
Slight Modification ◽  
Continuous Operation ◽  
Java Virtual Machine ◽  
Multiprocessor System ◽  
Garbage Collector ◽  
Memory Coherence

Replication-based incremental garbage collection is one of the more appealing concurrent garbage collection algorithms known today. It allows continuous operation of the application (the mutator) with very short pauses for garbage collection. There is a growing need for such garbage collectors suitable for a multithreaded environments such as the Java Virtual Machine. Furthermore, it is desirable to construct collectors that also work on multiprocessor computers. We begin by pointing out an important, yet subtle point, which arises when implementing the replication-based garbage collector for a multithreaded environment. We first show that a simple and natural implementation of the algorithm may lead to an incorrect behavior of multithreaded applications. We then show that another simple and natural implementation eliminates the problem completely. Thus, the contribution of this part is in stressing this warning to future implementors. Next, we address the effects of the memory coherence model on this algorithm. We show that even when the algorithm is properly implemented with respect to our first observation, a problem might still arise when a multiprocessor system is used. Adopting a naive solution to this problem results in very frequent (and expensive) synchronization. We offer a slight modification to the algorithm which eliminates the problem and requires little synchronization.

Analyzing the Characteristic of JAVA Objects

2013 ◽  
Vol 303-306 ◽  
pp. 2329-2332 ◽  
Author(s):  
Jun Yi Li ◽  
Jing Yu Chen ◽  
Anthony S. Fong
Keyword(s):  
Memory Management ◽  
Garbage Collection ◽  
Design Method ◽  
Object Oriented ◽  
Careful Consideration ◽  
Object Oriented Programming ◽  
Release Mechanism ◽  
Access Frequency ◽  
Management Algorithm ◽  
Automatic Memory

Java is a very popular Object-oriented programming (OOP) language because of its platform independent and automatic memory release mechanism (or garbage collection). However, garbage collection also speeds CPU time and should be done after careful consideration. In the paper, memory usage behavior and run-time object characteristics, including heap and object size, object age and access frequency, are studied using several commercial benchmarks. The profiler design method and experiment detail are represented in the paper. The runtime object characteristics are very important to guide the employment of different memory management algorithm.

Integrated Hardware Garbage Collection

2021 ◽  
Vol 20 (5) ◽  
pp. 1-25
Author(s):  
Andrés Amaya García ◽  
David May ◽  
Ed Nutting
Keyword(s):  
Software Development ◽  
Programming Languages ◽  
Real Time ◽  
Program Analysis ◽  
Garbage Collection ◽  
Data Representation ◽  
Garbage Collector ◽  
Tightly Coupled ◽  
Memory Cycle ◽  
High Level

Garbage collected programming languages, such as Python and C#, have accelerated software development. These modern languages increase productivity and software reliability as they provide high-level data representation and control structures. Modern languages are widely used in software development for mobile, desktop, and server devices, but their adoption is limited in real-time embedded systems. There is clear interest in supporting modern languages in embedded devices as emerging markets, like the Internet of Things, demand ever smarter and more reliable products. Multiple commercial and open-source projects, such as Zerynth and MicroPython, are attempting to provide support. But these projects rely on software garbage collectors that impose high overheads and introduce unpredictable pauses, preventing their use in many embedded applications. These limitations arise from the unsuitability of conventional processors for performing efficient, predictable garbage collection. We propose the Integrated Hardware Garbage Collector (IHGC); a garbage collector tightly coupled with the processor that runs continuously in the background. Further, we introduce a static analysis technique to guarantee that real-time programs are never paused by the collector. Our design allocates a memory cycle to the collector when the processor is not using the memory. The IHGC achieves this by careful division of collection work into single-memory-access steps that are interleaved with the processor’s memory accesses. As a result, our collector eliminates run-time overheads and enables real-time program analysis. The principles behind the IHGC can be used in conjunction with existing architectures. For example, we simulated the IHGC alongside the ARMv6-M architecture. Compared to a conventional processor, our experiments indicate that the IHGC offers 1.5–7 times better performance for programs that rely on garbage collection. The IHGC delivers the benefits of garbage-collected languages with real-time performance but without the complexity and overheads inherent in software collectors.

Multiple-Core PLC CPU Implementation and Programming

2018 ◽  
Vol 27 (10) ◽  
pp. 1850162 ◽  
Author(s):  
Adam Milik
Keyword(s):  
Programming Languages ◽  
Data Flow ◽  
Control Program ◽  
Performance Comparison ◽  
Memory Cells ◽  
Data Flow Graph ◽  
Flow Graph ◽  
Synchronization Mechanism ◽  
Intermediate Data ◽  
A Performance

The paper presents a complete approach to the multithreaded execution of a control program prepared according to IEC61131-3 standard. The program is mapped to a dedicated multiple-core CPU unit. The CPU consists of multiple independent bit and word CPUs. The computation synchronization mechanism is based on memory cells with semaphored access, which enable hardware-level synchronization. The paper presents in detail the architecture, results of implementation and the achieved performance. The custom-developed compiler translates standard programming languages into a multithreaded executable form. It utilizes an original intermediate data flow graph to optimize and recognize program parallelisms. The program is automatically partitioned and mapped to the available computing resources. The paper is concluded with a performance comparison of program executions using the standard single-threaded and proposed approaches.

scholarly journals Distributed communication in ML

2000 ◽  
Vol 10 (1) ◽  
pp. 91-120
Author(s):  
MARK HAYDEN
Keyword(s):  
Programming Languages ◽  
Memory Management ◽  
Group Communication ◽  
Careful Attention ◽  
Distributed Communication ◽  
High Level ◽  
Automatic Memory ◽  
High Level Abstraction

We present our experience in implementing a group communication toolkit in Objective Caml, a dialect of the ML family of programming languages. We compare the toolkit both quantitatively and qualitatively to a predecessor toolkit which was implemented in C. Our experience shows that using the high-level abstraction features of ML gives substantial advantages. Some of these features, such as automatic memory management and message marshalling, allowed us to concentrate on those pieces of the implementation which required careful attention in order to achieve good performance. We conclude with a set of suggested changes to ML implementations.

The Efficacy of Unenhanced MR Imaging for the Diagnosis of Acute Appendicitis: A Performance Comparison Versus Abdominal Ultrasonography

2008 ◽  
Vol 58 (2) ◽  
pp. 133
Author(s):  
Ji Eun Seok ◽  
Seon Jeong Min ◽  
Seong Whi Cho ◽  
Ik Won Kang ◽  
Dae Hyun Hwang ◽  
...  
Keyword(s):  
Mr Imaging ◽  
Acute Appendicitis ◽  
Performance Comparison ◽  
Abdominal Ultrasonography ◽  
A Performance
Sign in / Sign up

Export Citation Format

Share Document