Garbage Collection Algorithm Research Articles

An Efficient Hot-Cold Data Separation Garbage Collection Algorithm Based on Logical Interval in NAND Flash-Based Consumer Electronics

In NAND flash-based consumer electronics, garbage collection can degrade consumer electronics performance. And the extra page writes caused by garbage collection reduce the lifespan of consumer electronics. Hot-cold data separation has a critical impact on garbage collection. Therefore, inaccurate hot-cold data separation significantly affects garbage collection overhead and the performance of wear leveling. In addition, accurate data separation depends greatly on heat calculation of each page in NAND flash and extra memory is required to record page heat information. In this paper, we propose an efficient and novel hot-cold data separation garbage collection algorithm. The proposed algorithm introduces T-P factor which combines update time and page sequence number to calculate the heat of different logical interval rather than page, thus accurate hot-cold data separation can be achieved. Based on T-P factor, garbage collection strategy is improved accordingly. Experimental results show that the proposed algorithm is superior to existing algorithms in terms of garbage collection overhead, wear leveling and extra memory consumption in NAND flash-based consumer electronics.

On-Demand Garbage Collection Algorithm with Prioritized Victim Blocks for SSDs

Because of their numerous benefits, solid-state drives (SSDs) are increasingly being used in a wide range of applications, including data centers, cloud computing, and high-performance computing. The growing demand for SSDs has led to a continuous improvement in their technology and a reduction in their cost, making them a more accessible storage solution for a wide range of users. Garbage collection (GC) is a process that reclaims wasted storage space in NAND flash memories, which are used as the memory devices for SSDs. However, the GC process can cause performance degradation and lifetime reduction. This paper proposes an efficient garbage collection (GC) scheme that minimizes overhead by invoking GC operations only when necessary. Each GC operation is executed in a specific order based on the expected storage gain and the execution cost, ensuring that the storage space requirement is met while minimizing the frequency of GC invocation. This approach not only reduces the overhead due to GC, but also improves the overall performance of SSDs, including the latency and write amplification factor (WAF) which is an important indicator of the longevity of SSDs.

Optimizing the Cost of Garbage Collection in F2FS Using Working Set Strategy

As an important part of the operating system, the file system has always received wide attention, and different types of file system architectures have been constantly proposed and practiced, this time, we mainly focus on the log structured file system (LFS) type flash friendly file system (F2FS) file system. The existing garbage collection algorithm has offered a interface for future improvement. Hence, we tried to improve existing garbage collection algorithms by implementing the working set strategy in victim select algorithm and analyze the existing deficiencies of the F2FS file system. Under the original strategy, when F2FS selects a segment, it will select the section with the fewest valid blocks. After we change it, we have completed the balance consideration of the change time, the number of valid blocks, and the proportion of changes. It is expected that the Flash device will have the longer life. By using the proposed technique, the cost of garbage collection has reduced by 10%. At the same time, based on the cold and hot data separation characteristics of the F2FS file system, we propose optimization suggestions for the cold and hot data separation strategy.

Score Based Garbage Collection Algorithm for Flash Based Storage System

A solid-state drive’s garbage collection technique considerably influences the drive’s writing performance and life duration. The garbage collection technique chooses the block to be erased so that the block can be reused. Several techniques, such as hot data identification, enhance the efficiency of garbage collection and impact flash memory access speed and lifespan. This paper proposes a garbage collection algorithm, SGC (Score-based Garbage Collection) which tries to identify data on the basis of threshold into hot and cold blocks then the process is followed by choosing victim block with the help of score for garbage collection. The SGC approach minimises SSD wear frequency and garbage collection overhead, extending SSD life and data reliability. A novel hot and cold identification system helps to reduces program/erasure cycles while increasing identification accuracy, basedon threshold data are clustered into hot and cold. The experimental findings illustrate that the SGC outperforms the existing approach under various benchmarks by reducing the frequency of block wear leveling. The simulation result shows how SGC performs well and lowers the costs, such as the number of copy and erase operation done, wear on the block, and energy consumption.Improvement percentage for wear leveling is calculated for input traces exchange, financial 1 and financial 2. For exchange trace our policy outperforms CB,CAT,GR and CATA by 19.04%,15.0%,37.03% and 10.5% respectively.

GRUBin: Time-Series Forecasting-Based Efficient Garbage Monitoring and Management System for Smart Cities

The waste management of an evolving smart city environment is one of the most important tasks as the living conditions and health of the population depend on proper waste management. Currently deployed systems are failing to monitor the garbage production as they use IoT-based pipelines to monitor the production in a locality, but often the device is used to get destroyed by the frequent use of dustbin. This leads to an increase in expenditure and affects the sustainability of the system. In this work, we propose an efficient and scalable garbage monitoring and collection methodology based on time-series forecasting techniques. The proposed system is also cost-effective because of the iterative deployment of rented IoT sensors, which are used to collect time series format data and then used to train the forecasting module to learn the temporal representation of the data that can produce accurate results for monitoring the fill-up time of the garbage collector. We also propose an efficient collection in-routing technique based on the ranking of bin stations on the basis of temporal and spatial data of the fill-up time and route location to minimize the collection time by making an efficient routing algorithm for garbage collection. This concept of garbage collection will be very useful for smart city planners.

Exploiting Uncorrectable Data Reuse for Performance Improvement of Flash Memory

With the increased density and the technology scaling, flash memory is more vulnerable to noise effects, overwhelmingly lowering the data retention time. The periodic data refresh technique is commonly used to retain the long-term data integrity. However, the frequent refresh requests introduce the increased access conflict and severe write amplification, leading to suboptimal performance and lifetime improvement of flash memory-based storage systems. In this article, we propose ApproxRefresh, which enables the uncorrectable data reuse with the assistance of approximate-computing applications to reduce the refresh costs. Specifically, we design a lightweight remapping-free refresh technique, called RFR, to periodically correct, compute an enhanced ECC, and only remap new ECC parity bits, which dramatically reduces the refresh costs. Then, with approximate-read and precise-read hotness awareness, ApproxRefresh selectively adopts RFR or the traditional remapping-based refresh technique to reduce the refresh costs and the read disturbance. Besides, ApproxRefresh further improves flash access performance based on data hotness and process variations. In addition, a corresponding ApproxRefresh-aware garbage collection algorithm is proposed to complete the design. Evaluations show that ApproxRefresh reduces the refresh latency by 36.19% over the state of the art.

Garbage Collection Algorithms in Flash Based Solid State Drives

Solid state drives (SSDs)have emerged as faster and more reliable data storages over the last few years. Their intrinsic characteristics prove them to be more efficient as compared to other traditional storage media such as the Hard Disk Drives (HDDs). Issues such as write amplification, however, degrade the performance and lifespan of an SSD. This issue is in turn handled by the Garbage Collection (GC) algorithms that are put in place to supply free blocks for serving the writes being made to the flash-based SSDs and thus reduce the need of extra unnecessary writes. The LRU/FIFO, Greedy, Windowed Greedy and D choices algorithms have been described to lower write amplification for incoming writes which are different in nature. The performance of the GC algorithms varies based on factors such as pre-defined hot/cold data separation, hotness of data, uniform/non-uniform nature of incoming writes, the GC window size and the number of pages in each block of the flash memory package. Finally, it can be seen that the number of write frontiers so used, can dictate the separation of hot/cold data and increase the performance of a GC algorithm.

A performance comparison of garbage collector algorithms in Java Virtual Machine

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.

On the Endurance of the d-Choices Garbage Collection Algorithm for Flash-Based SSDs

Garbage collection (GC) algorithms for flash-based solid-state drives (SSDs) have a profound impact on its performance and many studies have focused on assessing the so-called write amplification of various GC algorithms. In this article, we consider the family of d -choices GC algorithms and study (a) the extent in which these algorithms induce unequal wear and (b) the manner in which they affect the lifetime of the drive. For this purpose, we introduce two performance measures: PE fairness and SSD endurance. We study the impact of the d -choices GC algorithm on both these measures under different workloads (uniform, synthetic and trace-based) when combined with two different write modes. Numerical results show that the more complex of the two write modes, which requires hot/cold data identification, may not necessarily give rise to a significantly better SSD endurance. Further, the d -choices GC algorithm is often shown to strike a good balance between garbage collection and wear leveling for small d values (e.g., d = 10), yielding high endurance.

An average update frequency based NAND flash garbage collection algorithm

An average update frequency based NAND flash garbage collection algorithm

An Efficient and Non-Time-Sensitive File-Aware Garbage Collection Algorithm for NAND Flash-Based Consumer Electronics

NAND flash memory has been widely used in consumer electronics, such as tablet personal computers and smart phones. However, unlike traditional hard disk, a garbage collection is required to reclaim memory space during data updates. A garbage collection includes a series of extra read, write and erase operations. Both write and erase operations are time consuming process, which affect the effectiveness and efficiency of the NAND flash memory system. Moreover, flash memory blocks are challenged by the limitation of the erase count. Thus, considerable efforts have been paid to reduce the garbage collection overhead and improve wear leveling. In this paper, an efficient and non-time-sensitive file-aware garbage collection algorithm, called FaGC+, is proposed. The FaGC+ algorithm involves a novel update frequency calculation method and a novel cold-hot logical page categorization scheme. The experimental results demonstrate that the proposed algorithm outperforms existing garbage collection algorithms in terms of garbage collection overhead and time-sensitivity in wear leveling control.

Verifying a Concurrent Garbage Collector with a Rely-Guarantee Methodology

Concurrent garbage collection algorithms are a challenge for program verification. In this paper, we address this problem by proposing a mechanized proof methodology based on the Rely-Guarantee proof technique. We design a compiler intermediate representation with strong type guarantees, dedicated support for abstract concurrent data structures, and high-level iterators on runtime internals. In addition, we define an Rely-Guarantee program logic supporting an incremental proof methodology where annotations and invariants can be progressively enriched. We formalize the intermediate representation, the proof system, and prove the soundness of the methodology in the Coq proof assistant. Equipped with this, we prove a fully concurrent garbage collector where mutators never have to wait for the collector.

Cross-component garbage collection

Embedding a modern language runtime as a component in a larger software system is popular these days. Communication between these systems often requires keeping references to each others' objects. In this paper we present and discuss the problem of cross-component memory management where reference cycles across component boundaries may lead to memory leaks and premature reclamation of objects may lead to dangling cross-component references. We provide a generic algorithm for effective, efficient, and safe garbage collection over component boundaries, which we call cross-component tracing. We designed and implemented cross-component tracing in the Chrome web browser where the JavaScript virtual machine V8 is embedded into the rendering engine Blink. Cross-component tracing from V8's JavaScript heap to Blink's C++ heap improves garbage collection latency and eliminates long-standing memory leaks for real websites in Chrome. We show how cross-component tracing can help web developers to reason about reachability and retainment of objects spanning both V8 and Blink components based on Chrome's heap snapshot memory tool. Cross-component tracing was enabled by default for all websites in Chrome version 57 and is also deployed in other widely used software systems such as Opera, Cobalt, and Electron.

Model-based prediction of automatic memory management and garbage collection behavior

Performance models focus on resource consumption and the effects of CPU, network, or hard-disk utilization. These resources usually have the largest effect on the response times and throughput of an application. However, deficient memory management can have severe effects on an application and its runtime, such as overlong response times or even crashes. As memory management has been disregarded in performance simulations, we address this gap with an approach based on memory measurements and derived metrics to predict the behavior of this resource and the effects on the CPU. Although numerous works exist that analyze memory management and especially garbage collections, accurate prediction models are rare. We demonstrate the automatic extraction of memory behavior using a performance model generator. Furthermore, the approach is evaluated using the SPECjEnterprise2010 and the SPECjEnterpriseNEXT industry benchmark, using different resource environments, garbage collection algorithms, and workloads. This work demonstrates that a certain set of probabilities allows one to create a memory profile for an architecture and predict the behavior of the memory management. The results of such predictions can be used for better capacity planning (on-premise), cost-prediction (cloud), architecture evaluation and optimization, or memory profiling. This approach allows for a continuous model-based evaluation of an enterprise architecture regarding its memory footprint.

Skip compactors for garbage collection based on space utilization

ABSTRACTThe mark-compact garbage collection algorithm shifts live objects so that they are next to each other to maximize space utilization efficiency and enable rapid object allocation. However, the algorithm requires multiple passes over a heap of objects, extending the time required for reclaiming unused memory. To shorten the collection time, we propose a skip compactor for garbage collection algorithm that avoids accessing dead objects by merging contiguous dead objects and reduces the number of object relocations. In this paper, we have implemented the proposed algorithm in the Jikes RVM, and measured the performance with the SPECjvm98 and DaCapo2006 benchmark suites. The proposed algorithm reduces the pause time of programs by 25% on average.

A Study on Garbage Collection Algorithms for Big Data Environments

The need to process and store massive amounts of data—Big Data—is a reality. In areas such as scientific experiments, social networks management, credit card fraud detection, targeted advertisement, and financial analysis, massive amounts of information are generated and processed daily to extract valuable, summarized information. Due to its fast development cycle (i.e., less expensive to develop), mainly because of automatic memory management, and rich community resources, managed object-oriented programming languages (e.g., Java) are the first choice to develop Big Data platforms (e.g., Cassandra, Spark) on which such Big Data applications are executed. However, automatic memory management comes at a cost. This cost is introduced by the garbage collector, which is responsible for collecting objects that are no longer being used. Although current (classic) garbage collection algorithms may be applicable to small-scale applications, these algorithms are not appropriate for large-scale Big Data environments, as they do not scale in terms of throughput and pause times. In this work, current Big Data platforms and their memory profiles are studied to understand why classic algorithms (which are still the most commonly used) are not appropriate, and also to analyze recently proposed and relevant memory management algorithms, targeted to Big Data environments. The scalability of recent memory management algorithms is characterized in terms of throughput (improves the throughput of the application) and pause time (reduces the latency of the application) when compared to classic algorithms. The study is concluded by presenting a taxonomy of the described works and some open problems, with regard to Big Data memory management, that could be addressed in future works.

Model checking copy phases of concurrent copying garbage collection with various memory models

Modern concurrent copying garbage collection (GC), in particular, real-time GC, uses fine-grained synchronizations with a mutator, which is the application program that mutates memory, when it moves objects in its copy phase. It resolves a data race using a concurrent copying protocol, which is implemented as interactions between the collector threads and the read and write barriers that the mutator threads execute. The behavioral effects of the concurrent copying protocol rely on the memory model of the CPUs and the programming languages in which the GC is implemented. It is difficult, however, to formally investigate the behavioral properties of concurrent copying protocols against various memory models. To address this problem, we studied the feasibility of the bounded model checking of concurrent copying protocols with memory models. We investigated a correctness-related behavioral property of copying protocols of various concurrent copying GC algorithms, including real-time GC Stopless, Clover, Chicken, Staccato, and Schism against six memory models, total store ordering (TSO), partial store ordering (PSO), relaxed memory ordering (RMO), and their variants, in addition to sequential consistency (SC) using bounded model checking. For each combination of a protocol and memory model, we conducted model checking with a model of a mutator. In this wide range of case studies, we found faults in two GC algorithms, one of which is relevant to the memory model. We fixed these faults with the great help of counterexamples. We also modified some protocols so that they work under some memory models weaker than those for which the original protocols were designed, and checked them using model checking. We believe that bounded model checking is a feasible approach to investigate behavioral properties of concurrent copying protocols under weak memory models.

NG2C: pretenuring garbage collection with dynamic generations for HotSpot big data applications

Big Data applications suffer from unpredictable and unacceptably high pause times due to Garbage Collection (GC). This is the case in latency-sensitive applications such as on-line credit-card fraud detection, graph-based computing for analysis on social networks, etc. Such pauses compromise latency requirements of the whole application stack and result from applications' aggressive buffering/caching of data, exposing an ill-suited GC design, which assumes that most objects will die young and does not consider that applications hold large amounts of middle-lived data in memory. To avoid such pauses, we propose NG2C, a new GC algorithm that combines pretenuring with user-defined dynamic generations. By being able to allocate objects into different generations, NG2C is able to group objects with similar lifetime profiles in the same generation. By allocating objects with similar lifetime profiles close to each other, i.e. in the same generation, we avoid object promotion (copying between generations) and heap fragmentation (which leads to heap compactions) both responsible for most of the duration of HotSpot GC pause times. NG2C is implemented for the OpenJDK 8 HotSpot Java Virtual Machine, as an extension of the Garbage First GC. We evaluate NG2C using Cassandra, Lucene, and GraphChi with three different GCs: Garbage First (G1), Concurrent Mark Sweep (CMS), and NG2C. Results show that NG2C decreases the worst observable GC pause time by up to 94.8% for Cassandra, 85.0% for Lucene and 96.45% for GraphChi, when compared to current collectors (G1 and CMS). In addition, NG2c has no negative impact on application throughput or memory usage.

Stable Greedy

Commodity solid state drives (SSDs) have recently begun involving the adoption of powerful controllers for multichannel flash management at the page level. However, many of these models still use primitive garbage-collection algorithms, because previous approaches are subject to poor scalability with high-capacity flash memory. This study presents Stable Greedy for garbage collection in page-mapping multichannel SSDs. Stable Greedy identifies page-accurate data hotness using block-level information, and jointly considers block space utilization and block stability for victim selection. Its design considers flash wear leveling for SSD lifetime enhancement at the block level as well as at the channel level. Stable Greedy runs at a constant time, and requires limited RAM space. The simulation results revealed that Stable Greedy outperformed previous methods considerably under various workloads and multichannel architectures. Stable Greedy was successfully implemented on the OpenSSD platform, and the actual performance measurements were consistent with the simulation results.

On the power of asymmetry and memory in flash-based SSD garbage collection

The power of d random choices has been widely recognized in the balls-and-bins, hashing and load balancing setting and various refinements such as the introduction of asymmetry or memory have been proposed. Recently, the d-choices garbage collection algorithm for flash-based SSDs was introduced and shown to provide an excellent tradeoff between performance and simplicity. In this paper we study the impact of asymmetry and memory on the performance of the d-choices garbage collection algorithm using both mean field models and trace-based simulations. Numerical examples demonstrate that both asymmetry and memory reduce the write amplification, however the reduction is typically less than 2% when exploiting asymmetry, while more significant gains exceeding 10% are observed when memory is introduced.