Conservative Multi-Generational Age-Based Garbage Collection with Fast Allocation

In the era of today’s technology, Garbage Collectors have high mortality and high efficiency because they look and remove garbage memory blocks among newly created objects. Many very newly created objects are included into these objects which are still live and easily can be identified as live objects. Generational Garbage Collection is a technique which is based on newer objects where the older objects are pointed by these newly created objects; because of this, these type of algorithms earn more efficiency than other garbage collectors. The only one way called “Store Operation” is used to a formerly created objects for pointing to a newly created objects and many languages have limitations for these operations. Recently allocated objects are focused more by a Garbage Collector and these objects can give more support to the above mentioned issue. The efficiency of such type of Garbage Collectors can be measured on the basis of allocation and expenditure type than the disposal of objects. In this paper, we have studied various techniques based on Generational Garbage Collection to observe object structures for producing better layout for finding live objects, in which objects with high temporal weakness are placed next to each other, so that they are likely to locate in the same generation block. This paper presents a low-overhead version of a new Garbage Collection technique, called Conservative multi-generational age-based algorithm which is simple and more efficient with fast allocation, suitable to implement for many object oriented languages. Conservative multi-generational age-based algorithm is compatible with high performance for the many managed object oriented languages

Long Term Assessment of Object Strength in a Web Service as Managed by the Garbage Collection in Java Based Services

Garbage collection is proving to be an important feature that supports high-performance web services, especially those running data-intensive applications. Due to the use of the object-oriented paradigm, many applications have increasingly opted for the dynamic memory allocation method of assigning their objects in computer memory. During program execution, the application allocates its objects to a memory space called a heap and constantly references these objects within that memory space. With the passage of time, if the objects are not referenced, they become weak/dead to the extent that they can no longer be referenced by an application which allocated them. In such a scenario, the application is required to allocate new objects to a heap in order to continue performing its functions. And, there must be a garbage collection mechanism to remove the dead/weak (unreferenced) objects from the memory heap so that the memory space can be reclaimed and dynamically allocated to other application objects. Java as a Virtual machine, performs memory allocation and reclamation by itself thereby allowing the programmer to concentrate only on the functionality of the application. In other words, the developer is not concerned about how the memory will be managed during the program execution because that will be the duty of the Java language executing on Java Virtual machine. Therefore, for Java to effectively manage the computer memory, it uses five garbage collection mechanisms which will be explained in detail in the introduction section. Most of the garbage collections are triggered based on the objects’ lifetime predictions set by the developer of the garbage collection algorithms. None or very few consider the strength of the objects that are no longer referenced in the heap. For example, some objects may still be strong enough that they can be referenced by the application but they are collected anyway because they have reached their predicted age threshold. Garbage collection mechanisms also vary when used in a different framework other than the traditional (standalone) one. For example, garbage collection in distributed systems becomes more complicated as compared to the traditional garbage collection performed in standalone systems. Similarly, garbage collection in a web-service framework has slight differences as compared to the local/standalone systems due to the inclusion of web service technology elements. In this paper, the goal is to strive to determine the strength of objects that are no longer referenced by an application in a web service as managed by Java-based services; in relation to the performance of a web application

Incremental copying garbage collection for WAM-based Prolog systems

The design and implementation of an incremental copying heap garbage collector for WAM-based Prolog systems is presented. Its heap layout consists of a number of equal-sized blocks. Other changes to the standard WAM allow these blocks to be garbage collected independently. The independent collection of heap blocks forms the basis of an incremental collecting algorithm which employs copying without marking (contrary to the more frequently used mark&copy or mark&slide algorithms in the context of Prolog). Compared to standard semi-space copying collectors, this approach to heap garbage collection lowers in many cases the memory usage and reduces pause times. The algorithm also allows for a wide variety of garbage collection policies including generational ones. The algorithm is implemented and evaluated in the context of hProlog.Comment: 33 pages, 22 figures, 5 tables. To appear in Theory and Practice of Logic Programming (TPLP

The Role and Welfare of Cart Donkeys Used in Waste Management in Karachi, Pakistan

Equine ownership is a common income-generating strategy in Pakistan. In Karachi, donkey carts are used to transport building materials, commercial produce and garbage. This study aimed to articulate the role and welfare of donkeys used in waste management. We conducted interviews with donkey owners (n = 200), households which use donkey carts for waste collection (n = 50) and key informants (n = 14). To assess the welfare of donkeys, the Standardised Equine-Based Welfare Assessment Tool (SEBWAT) was used (n = 204). Collection of waste was the primary source of income for 89% of owners interviewed. Of those directly involved in waste collection, 62% were found to be under 18 years of age. During interviews with donkey cart customers the majority reported that there would be a huge garbage build-up if donkey carts were not available. Welfare assessments demonstrated that 52.9% of donkeys had a body condition score of two. Muzzle mutilation was extremely high (78.4%) and 66.7% of donkeys had superficial knee lesions. This is the first study that has explored the role of donkey carts in waste management in Pakistan. The data demonstrate the sizable role that donkey-owning communities play in waste management and the important livelihood option this offers, as well as considerable animal welfare concerns

Beltway: Getting Around Garbage Collection Gridlock

We present the design and implementation of a new garbage collection framework that significantly generalizes existing copying collectors. The Beltway framework exploits and separates object age and incrementality. It groups objects in one or more increments on queues called belts, collects belts independently, and collects increments on a belt in first-in-first-out order. We show that Beltway configurations, selected by command line options, act and perform the same as semi-space, generational, and older-first collectors, and encompass all previous copying collectors of which we are aware. The increasing reliance on garbage collected languages such as Java requires that the collector perform well. We show that the generality of Beltway enables us to design and implement new collectors that are robust to variations in heap size and improve total execution time over the best generational copying collectors of which we are aware by up to 40%, and on average by 5 to 10%, for small to moderate heap sizes. New garbage collection algorithms are rare, and yet we define not just one, but a new family of collectors that subsumes previous work. This generality enables us to explore a larger design space and build better collectors