Garbage collection in an uncooperative environment

Some programming languages and computer systems use dynamic memory allocation with garbage collection. It would be useful to understand how the utilization of memory depends on the stochastic parameters describing the size and life distributions of the cells. We consider a class of dynamic storage allocation systems which use a first-fit strategy to allocate cells and perform noncompacting garbage collections to recover free memory space when memory becomes fully occupied. A formula is derived for the expected number of holes (available cells) in memory immediately following a garbage collection which specializes to an analogue of Knuth's 'Fifty Percent' rule for nongarbage-collection systems. Simulations confirm the rule for exponentially distributed cell lifetimes. Other lifetime distributions are discussed. The memory-size requirements for noncompacting garbage collection are also analyzed.

Garbage collection algorithms that do not require tagging of data have been around since the early days of LISP. With the emergence of strongly-typed languages that require heap allocation, interest in tag-free garbage collection has increased. Several papers published recently describe methods for performing tag-free copying garbage collection by retaining compile-time type information at run time. However, all of these algorithms have the “stop and collect” property, in which program execution is suspended for a significant amount of time during garbage collection. For many programs an incremental garbage collection method, in which the garbage collection overhead is spread evenly throughout the computation, is desirable.

Android operating system has become one of the most popular smartphone platforms. A large number of applications are developed for Android Runtime (ART). Garbage Collection (GC) is an essential function of ART for Java-based applications. GC suspends all the application threads, called Stop The World (STW), and sacrifices application's performance. For reducing pauses to check heap, generational GC was proposed. It separates objects into two groups, the objects which probably die in the next GC and the others. Then, it tries to reduce search space and time to check. With this GC, accurate estimation of object lifetime is important. In this paper, we investigate objects' lifetime trend in modern Java-based applications of Android, and discuss a method for improving GC based on this trend. First, we introduce our monitoring system for object creations and collections in ART. Second, we present the monitoring results of recent popular Android applications and reveal the relations between lifetimes and object sizes.

In this paper, we study the current takeaway waste recycling problem and redesign the takeaway waste recycling system under the service design concept. This paper uses a combination of CBR theory and TRIZ theory to analyze and learn from similar cases of garbage collection systems, find and solve conflicts in the take-out garbage collection problem, and thus design a take-out garbage collection system under the service design concept. It provides a sustainable development direction for the existing take-out waste pollution problem and offers the possibility of green development for the whole take-out industry.KeywordsTakeway garbage recyclingGreen designService design

In this paper, we propose PGIS, a parallelism and garbage collection aware I/O Scheduler, which identifies the hot data based on trace characteristics to exploit the channel level internal parallelism of flash-based storage systems. PGIS not only fully exploits abundant channel resource in the SSD, but also it introduces a hot data identification mechanism to reduce the garbage collection overhead. By dispatching hot read data to different channel, the channel level internal parallelism is fully exploited. By dispatching hot write data to the same physical block, the garbage collection overhead has been alleviated. The experiment results show that compared with existing I/O schedulers, PGIS improves the response time and garbage collection performance significantly. Consequently, PGIS reduces the garbage collection overhead up to 30.9%, while exploiting channel level internal parallelism.

A promising technique to improve the write performance of solid-state disks (SSDs) is to use a disk write buffer. The goals of a write buffer is not only to reduce the write traffic to the flash chips but also to convert host write patterns into long and sequential write bursts. This study proposes a new buffer design consisting of a replacement policy and a write-back policy. The buffer monitors how the host workload stresses the flash translation layer upon garbage collection. This is used to dynamically adjust its replacement and write-back strategies for a good balance between write sequentiality and write randomness. When the garbage collection overhead is low, the write buffer favors high write sequentiality over low write randomness. When the flash translation layer observes a high overhead of garbage collection, the write buffer favors low write randomness over high write sequentiality. The proposed buffer design outperformed existing approaches by up to 20% under various workloads and flash translation algorithms, as will be shown in experiment results.

The NVMe Zoned Namespace (ZNS) is a high-performance interface for flash-based solid-state drives (SSDs), which divides the logical address space into fixed-size and sequential-write zones. Meanwhile, ZNS SSDs eliminate in-device garbage collection (GC) by shifting the responsibility of GC to the host. However, the host-side GC of ZNS SSDs is not efficient. On the one hand, data migration during GC first moves data to the host buffer and then writes back the transferred data to the new location in the SSD, resulting in an unnecessary end-to-end transfer overhead. On the other hand, due to the pre-configured mapping between zones and blocks, GC incurs a large block-to-block rewrite overhead, i.e., even if most of the data in a block of the victim zone is valid, the valid data will still be rewritten to another block in the target zone. To address these issues, this article proposes a novel ZNS SSD design that features dynamic zone mapping, termed Brick-ZNS . Brick-ZNS implements two key functionalities: in-storage data migration and address remapping. New ZNS commands are first designed to realize in-storage data migration to avoid the end-to-end transfer overhead of GC while ensuring performance predictability. Then, a remapping strategy exploiting parallel physical blocks is proposed to reduce the large block-to-block rewrite overhead while ensuring zone-level access parallelism. The basic idea of the strategy is to directly remap the parallel physical blocks with a sufficient amount of valid data in the victim zone to the target zone, hence avoiding the large block-to-block rewrite overhead. Based on a full-stack SSD emulator, the evaluation results show that Brick-ZNS improves write throughput by 25% and SSD lifetime by 1.41×.

Apache Spark is an increasingly popular distributed computation framework based on in-memory computations, which enables iterative or interactive applications to run faster. In Spark, memory management is the key to performance enhancement to avoid memory bloat problems. Compared with previous static memory manager, in Spark 1.6 and later versions, unified memory manager is implemented as the default memory management model, targeting to achieve optimal memory utilization by borrowing between storage and execution memory. However, the storage memory borrowed from execution memory may frequently be evicted when memory pressure arises. It is because of frequently re- computation during cache evicted and frequent garbage collection during shuffle in iterative applications. This situation will produce runtime overhead caused by garbage collection including cache eviction and cache re-computation. We propose a memory constraint strategy for unified memory manager in Spark to reduce runtime overhead caused by garbage collection by reducing the cache eviction size. We implement the strategy in Spark 1.6.1 using SparkPageRank, WordCount and GroupByTest to compare three different memory managers. Experimental results reveal that compared unified memory manager, memory constraint strategy can achieve better performance improvement with lower job runtime and garbage collection time when the dataset sizes or the iterations are increasing.

NAND flash memory is a popular storage device for consumer electronics and it is exploited to be swap space for extending the limited main memory of consumer electronics. Due to the out-of-place update scheme provided by NAND flash memory to solve its erase-before-write hardware constraint, garbage collection should be performed to reclaim garbage in terms of invalid pages and obtain free space in terms of free blocks. The garbage collection, which consists of a series of copy operations and erase operations, is energy-consuming. In order to reduce the energy consumption, a swap-aware garbage collection algorithm for NAND flash-based consumer electronics is proposed in this paper. The proposed algorithm focuses on reducing the garbage collection overhead and improving the endurance of NAND flash memory. Experimental results show that the proposed algorithm is superior to the existing garbage collection algorithms in terms of the number of copy operations, the number of erase operations, the degree of wear-leveling, and energy consumption.

Modern object-oriented languages and programming paradigms require finer-grain division of memory than is provided by traditional paging and segmentation systems. This paper describes the design of an OSM (Object Space Manager) that allows partitioning of real memory on object, rather than page, boundaries. The time required by the OSM to create an object, or to find the beginning of an object given a pointer to any location within it, is approximately one memory cycle. Object sizes are limited only by the availability of address bits. In typical configurations of object-oriented memory modules, one OSM chip is required for every 16 RAM chips. The OSM serves a central role in the implementation of a hardware-assisted garbage collection system in which the worst-case stop-and-wait garbage collection delay ranges between 10 and 500 μsec, depending on the system configuration.

The most significant issue in cities is garbage collection. The average amount of waste a person produces daily rises as the population grows, creating severe waste management issues. Any municipality's most pressing issues are bin status monitoring, locating the shortest route, and vehicle costs. The problem's consequences result in inadequate waste monitoring and management procedures. An effective garbage collection system that periodically measures the amount of garbage in the bins is used to solve these issues. The shortest route can be determined using this bin's status. The vehicle only went to the places where the bins in the city are full. The Wi-Fi module will transmit all of the information to the municipality. The main objective of the proposed work is to create a flexible application that dynamically solve the issue of late bin clearance, poor management of bins etc. The path selection is made by using the Travelling Salesman Algorithm in the Dynamic programming approach. The sensor network is utilized to gather information regarding the garbage contents in the bins and remotely trigger the request for a cleaning process using the Internet of Things. The internet is connected with microcontroller hardware using a Node-MCU device, or ESP8266, a small internet-supporting module that works as a plug-and-play module to any microcontroller. The primary objective of this system is to send information to the municipality and the mobile application regarding the status of the bin, the minimum cost path, the total travel distance, and the kind of vehicle required. This system aims to shorten travel time, save money on diesel and human resources for garbage collection, and improve waste collection and monitoring.

We investigate methods to improve the performance of algorithms for automatic storage reclamation of object databases. These algorithms are based on a technique called partitioned garbage collection, in which a subset of the entire database is collected independently of the rest. We evaluate how different application, database system, and garbage collection implementation parameters affect the performance of garbage collection in object database systems. We focus specifically on investigating the policy that is used to select which partition in the database should be collected. Three of the policies that we investigate are based on the intuition that the values of overwritten pointers provide good hints about where to find garbage. A fourth policy investigated chooses the partition with the greatest presence in the I/O buffer. Using simulations based on a synthetic database, we show that one of our policies requires less I/O to collect more garbage than any existing implementable policy. Furthermore, that policy performs close to a locally optimal policy over a wide range of simulation parameters, including database size, collection rate, and database connectivity. We also show what impact these simulation parameters have on application performance and investigate the expected costs and benefits of garbage collection in such systems.

Big Data processing often suffers from significant memory pressure, resulting in excessive garbage collection (GC) and out-of-memory (OOM) errors, harming system performance and reliability. Therefore, users tend to give an excessive heap size to applications to avoid job failure, causing low cluster utilization.

Many of today’s programming languages are broken. Poor performance, lack of features and hard-to-reason-about semantics can cost dearly in software maintenance and inecient execution. The problem is only getting worse with programming languages proliferating and hardware becoming more complicated. An important reason for this brokenness is that much of language design is implementation-driven. The diculties in implementation and insucient understanding of concepts bake bad designs into the language itself. Concurrency, architectural details and garbage collection are three fundamental concerns that contribute much to the complexities of implementing managed languages. We propose the micro virtual machine, a thin abstraction designed specifically to relieve implementers of managed languages of the most fundamental implementation challenges that currently impede good design. The micro virtual machine targets abstractions over memory (garbage collection), architecture (compiler backend), and concurrency. We motivate the micro virtual machine and give an account of the design and initial experience of a concrete instance, which we call Mu, built over a two year period. Our goal is to remove an important barrier to performant and semantically sound managed language design and implementation.

Read barriers synchronize compacting garbage collection and application processing in a simple yet elegant way. Unfortunately, read barrier checks are expensive to implement in software, and even with hardware support, the clustering of read barrier faults irregularly impairs application progress to an unacceptable extent. For this reason, read barriers are often considered unsuitable for hard real-time systems.In this paper, we introduce a novel hardware read barrier design for an object-based RISC architecture. The design integrates read barrier checking and, for the first time, read barrier fault handling directly into a processor pipeline.Our system handles read barrier faults within 20 clock cycles on average. Despite fault clustering, all application programs we have run on our prototype show minimum mutator utilizations of more that 55% within arbitrary time intervals of only 1ms. Thanks to this property, our system facilitates worst case estimates for tasks with very short response times, thereby paving the way for garbage collection in embedded systems with extremely fine-grained real-time requirements.