AGCB: Adaptive Garbage Collection for Enhancing Lifetime and Performance of Bit-Alterable Flash Memory

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.

Distributed applications for data analytics have emerged to be a significant growth domain both in terms of technology as well as business relevance. With the advent of Hadoop MapReduce, several distributed execution frameworks have been developed for data analytics and machine learning applications. Many of these frameworks are written in Java, Scala or Python and run on top of the Java Virtual Machine (JVM), leaving them vulnerable to the performance impact of garbage collection (GC) operations. Application pauses induced by the Java GC are notorious in being one of the most important contributors of runtime performance bottleneck for a single process execution. These pauses are present in the distributed scenario as well, though in this case, it is significantly more complex to measure the impact of a GC pause for the overall execution runtime. Typically, in a distributed workload, a GC can result in delayed tasks impacting the overall completion time of the application. We present herein a novel way to preemptively trigger Java GC, stealing idle cycles, so as to prevent future tasks from being impacted by a GC pause during peak execution periods, resulting in improved overall application throughput.

NAND flash memory has been widely adopted as the primary data storage medium in data centers. However, the inherent characteristic of out-of-place updates in NAND flash necessitates garbage collection (GC) operations on NAND flash-based solid-state drives (SSDs), aimed at reclaiming flash blocks occupied by invalid data. GC processes entail additional read and write operations, which can lead to the blocking of user requests, thereby increasing the tail latency. Moreover, frequent execution of GC operations is prone to induce more pages to be written, further reducing the lifetime of SSDs. In light of these challenges, we introduce an innovative GC scheme, termed SplitGC. This scheme leverages the records of data redundancy gathered during periodic read scrub operations within the SSD. By analyzing these features of data duplication, SplitGC enhances the selection strategy for the victim block. Furthermore, it bifurcates the migration of valid data pages into two phases: non-duplicate pages follow standard relocation procedures, whereas the movement of duplicate pages is scheduled during idle periods of the SSD. The experiment results show that our scheme reduces tail latency induced by GC by 8% to 83% at the 99.99th percentile and significantly decreases the amount of valid page migration by 38% to 67% compared with existing schemes.

Solid-state drives (SSD) are the mainstream solutions for massive data storage today. For modern computer systems, fair resource assignment is a critical design consideration and has drawn great interests in recent years. Although there are several I/O fairness schedulers proposed on the host side for SSDs, process fairness could still be dramatically degraded if garbage collection (GC) is triggered in the device side. A GC operation could block I/O requests, which causes unpredictable read/write latency variation and further impacts fairness between processes. This paper proposes Fair-GC, a novel coordinated host and device I/O scheduling strategy to achieve true fairness considering GC interferences. The key idea is to orchestrate GC operations inside SSDs carefully such that performance of a process is penalized by GC in the same degree (or comparable) as when it runs alone. In this way, the I/O fairness maintained by the host-side scheduler can be maintained in the presence of GC. Furthermore, our scheduler ensures that the timeslice of a process maintained at the host-side scheduler is updated in a timely manner to avoid unnecessary slowdown for maintaining fairness. Experimental results with a wide range of workloads verify that the proposed technique can achieve fairness as well as improve the throughput significantly. Compared to conventional fairness-based I/O scheduler, Fair-GC can reduce the slowdown of real applications by up to 99%, and improve the throughput by as much as 225%, respectively.

FTL (Flash Translation Layer) is a memory block controller that manages the challenges of a data storage system based on flash memory technology. The design of internal parallelism in MLC-based SSDs with virtual blocks resulted in various challenges and due to the physical structure of flash memory cells based on MLC technology, it is possible to write a new page in a data block at the address after the last page is written. In parallel-based SSD design based on virtual blocks, some writes create unusable pages at the memory space, and these created holes reduce memory efficiency; consequently, it reduces the life-time of memory blocks by creating more operations, and accelerates garbage collection and merging operations. The proposed FTL offers three steps to address this constraint. Firstly, an idea was proposed to prevent costly transitions and to distribute data more evenly at memory blocks (wear leveling). Secondly, the unused holes created in virtual blocks became much fewer resulting in increased utilization of memory space. At last, a policy was proposed to prevent update blocks (log blocks) from being blocked and to postpone the merging and garbage collection by which the memory lifetime increases significantly. Simulation results showed that the number of unused erased pages and the number of extra write operations decreased up to 23% and 17%, respectively. In addition, the number of invalid released pages increased up to 21% in the proposed FTL, and the speed of I/O executions to 3%.

Recently, storage systems have observed a great leap in performance, reliability, endurance, and cost, due to the advance in non-volatile memory technologies, such as NAND flash memory. However, although delivering better performance, shock resistance, and energy efficiency than mechanical hard disks, NAND flash memory comes with unique characteristics and operational constraints, and cannot be directly used as an ideal block device. In particular, to address the notorious write-once property, garbage collection is necessary to clean the outdated data on flash memory. However, garbage collection is very time-consuming and often becomes the performance bottleneck of flash memory. Moreover, because flash memory cells endure very limited writes (as compared to mechanical hard disks) before they are worn out, the wear-leveling design is also indispensable to equalize the use of flash memory space and to prolong the flash memory lifetime. In response, this paper surveys state-of-the-art garbage collection and wear-leveling designs, so as to assist the design of flash memory management in various application scenarios. The future development trends of flash memory, such as the widespread adoption of higher-level flash memory and the emerging of three-dimensional (3D) flash memory architectures, are also discussed.

The paper presents the cache performance analysis of the Chronological Garbage Collection algorithm used in the LVM system. The LVM is a new Logic Virtual Machine for Prolog. It adopts one stack policy for all dynamic memory requirements and cooperates with an efficient garbage collection algorithm, Chronological Garbage Collection to recuperate space, not as deliberate garbage collection operation but as a natural activity of the LVM engine to gather useful objects. This algorithm takes advantages of the traditional copying, mark-compact, generational, and incremental garbage collection schemes. In order to determine the improvement of cache performance under our garbage collection algorithm, we developed an emulator to do the trace driven cache simulation. Direct mapped cache and set-associative cache with different cache sizes, block sizes and set associativities are simulated and measured. The objectives of this simulation are to verify and validate our experimental results, and to find important factors which influence the performance of the CGC algorithm.

Recently, in-memory big data processing frameworks have emerged, such as Apache Spark and Ignite, to accelerate workloads requiring frequent data reuse. With effective in-memory caching these frameworks eliminate most of I/O operations, which would otherwise be necessary for communication between producer and consumer tasks. However, this performance benefit is nullified if the memory footprint exceeds available memory size, due to excessive spill and garbage collection (GC) operations. To fit the working set in memory, two system parameters play an important role: number of data partitions (N <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">partitions</inf> ) specifying task granularity, and number of tasks per each executor (N <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">threads</inf> ) specifying the degree of parallelism in execution. Existing approaches to optimizing these parameters either do not take into account workload characteristics, or optimize only one of the parameters in isolation, thus yielding suboptimal performance. This paper introduces WASP, a workload-aware task scheduler and partitioner, which jointly optimizes both parameters at runtime. To find an optimal setting, WASP first analyzes the DAG structure of a given workload, and uses an analytical model to predict optimal settings of N <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">partitions</inf> and N <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">threads</inf> for all stages based on their computation types. Taking this as input, the WASP scheduler employs a hill climbing algorithm to find an optimal N <inf xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">threads</inf> for each stage, thus maximizing concurrency while minimizing data spills and GCs. We prototype WASP on Spark and evaluate it using six workloads on three different parallel platforms. WASP improves performance by up to 3.22× and reduces the cluster operating cost on cloud by up to 40%, over the baseline following Spark Tuning Guidelines and provides robust performance for both shuffle-heavy and shuffle-light workloads.

For NAND flash-based storage systems, managing garbage collection (GC) efficiently is a critical requirement to achieve both high performance and long lifetimes. In this paper, we propose a just-in-time GC technique, called JIT-GC, which invokes background GC operations only when necessary depending on future write demands. JIT-GC was motivated by our measurement study, which strongly suggested that deciding when to invoke background GC operations is a key parameter for efficient GC. By accurately estimating the amount of future SSD writes, JIT-GC can choose the best time to invoke a background GC operation. JIT-GC reserves necessary free space in advance so that high write performance can be achieved while it extends the SSD lifetime by preventing premature block erasures. Our evaluations on real SSDs show that JIT-GC can achieve both high performance and long lifetimes, thus overcoming the shortcomings of existing background GC invocation heuristics.

Garbage collection (GC) algorithms play a key role in reducing the write amplification in flash-based solid state drives, where the write amplification affects the lifespan and speed of the drive. This paper introduces a mean field model to assess the write amplification and the distribution of the number of valid pages per block for a class C of GC algorithms. Apart from the Random GC algorithm, class C includes two novel GC algorithms: the d-Choices GC algorithm, that selects d blocks uniformly at random and erases the block containing the least number of valid pages among the $d$ selected blocks, and the Random++ GC algorithm, that repeatedly selects another block uniformly at random until it finds a block with a lower than average number of valid blocks. Using simulation experiments we show that the proposed mean field model is highly accurate in predicting the write amplification (for drives with $N=50000$ blocks). We further show that the d-Choices GC algorithm has a write amplification close to that of the Greedy GC algorithm even for small d values, e.g., d = 10, and offers a more attractive trade-off between its simplicity and its performance than the Windowed GC algorithm introduced and analyzed in earlier studies. The Random++ algorithm is shown to be less effective as it is even inferior to the FIFO algorithm when the number of pages $b$ per block is large (e.g., for b ≥ 64).

Solid State Drives (SSDs) have replaced magnetic disks in many application areas, as they provide very high performance for arbitrary access patterns. Nevertheless, data written to a physical page has to be erased before a page can be rewritten. The corresponding garbage collection (GC) process can only be performed on a block granularity, where a block includes many pages, impacting both the performance and lifetime of an SSD. The cost of a GC process is typically measured in terms of its write amplification, i.e., the number of blocks internally written by the SSD divided by the number of write requests of the host.Several GC heuristics have been proposed to optimize the write amplification of SSDs. These heuristics have been mostly empirically evaluated, while no thorough theoretical results are available on the optimality of GC algorithms even for seemingly simple cases like uniform and independent access distributions.In this work, we theoretically investigate the GREEDY GC strategy for uniformly independently distributed write accesses. We therefore model the garbage collection process on SSDs as a stochastic process and prove that the expected write amplification incurred by the GREEDY GC strategy is at most that of any other online GC strategy.

Garbage collection represents an important feature of many modern systems that allows programmers to avoid explicit memory management and related common errors. However, its usage introduces problems in software performance engineering, because on the one hand the system exhibits better performances when there is low memory occupancy and on the other hand the garbage collection activity blocks other processes, so it may introduce a performance drawback. We propose a queueing model to analyse a system with a garbage collector, where customers arrive according to a Poisson process and the service time distribution depends on the amount of free memory. Customer arrivals correspond to process activations in the system. The model parameters allow one to specify the garbage collector service rate, and the distribution of the delays between successive activations. We show that the process underlying such a queueing model is a Quasi-Birth-Death stochastic process and we derive the steady-state analysis via Matrix Geometric Methods. Finally, we propose a heuristic based on this model to derive an appropriate and effective garbage collector activation rate in order to minimise the average system response time. The parametrisation is done using system statistics.

With the advent of new flash-based memory technologies with ultra-low latency, directly applying inline data deduplication in flash-based storage devices can degrade the system performance since key deduplication operations lie on the shortened critical write path of such devices. To address the problem, we propose a Content-Aware Garbage Collection scheme (CAGC), which embeds the data deduplication into the data movement workflow of the Garbage Collection (GC) process in ultra-low latency flash-based SSDs. By parallelizing the operations of valid data pages migration, hash computing and flash block erase, the deduplication-induced performance overhead is alleviated and redundant page writes during the GC period are eliminated. To further reduce data writes and write amplification during GC, CAGC separates and stores data pages in different regions based on their reference counts. The performance evaluation of our CAGC prototype implemented in FlashSim shows that CAGC significantly reduces the number of flash blocks erased and data pages migrated during GC, leading to improved user I/O performance and reliability of ultra-low latency flash-based SSDs.

Long-tail latency values significantly affect the user experience and hence they are a major concern in modern systems. However, tail latency characteristics of applications developed using microservices architecture are still unknown. In this paper, we focus on analyzing and characterizing the behaviour of tail latency values of microservices workloads under service's peak sustainable throughput with a closed system model. Our particular focus is to investigate the impact of heap size, garbage collection, concurrency and service demand on the tail latency. Our study has two parts. First, we develop and experiment on four microservices micro benchmarks representing CPU bound, network I/O bound, memory bound and database I/O bound to find the tail characteristics under different concurrency, heap, service demand and garbage collector. Then, in the second part, we explore the tail latency characteristics identified on micro benchmarks by testing those conditions using standard microservices benchmark application, Socks Shop. We observe first that microservices latency distributions exhibit the power law behavior. Second, we systematically prove that microservices workload distributions do not exhibit the heavy tailed behavior. We show that increasing the level of concurrency and service demand increases the tail latency. We use queuing simulation to prove our claims. Finally, we show that tail latency values of memory bound and database I/O bound microservices workloads are correlated with heap size and garbage collection.

The scope of this study was to identify which categories of urban waste are associated with cases of dengue and to evaluate the impact of garbage collection on dengue infection in the City of Recife (Brazil). Data from categorized waste weighing and the confirmed cases of dengue in the city were used. The data were analyzed using Pearson's correlation coefficient for the 13 categories of urban garbage, followed by Multivariate Linear Regression, selecting the variables by the stepwise method. A negative correlation between dengue infections in seven categories was identified: household garbage (r = -0.835), differentiated residues (r = -0.835), special operations residues (r = -0.711), building rubble (r = -0.687), selective waste collection (r = -0.425) and tires (r = -0.423). The regression model was able to explain 75% of the variation, indicating that an increase of 1,000 tons in household garbage collection provides a decrease of 0.032 in cases of dengue, while the same increase in tire collection esults in a decrease of 0.465. The results show that garbage collection has a strong negative impact on dengue cases and can be adopted as a prevention strategy by municipal governments.