Garbage collection in distributed systems

PhD ThesisThe provision of system-wide heap storage has a number of advantages. However, when the technique is applied to distributed systems automatically recovering inaccessible variables becomes a serious problem. This thesis presents a survey of such garbage collection techniques but finds that no existing algorithm is entirely suitable. A new, general purpose algorithm is developed and presented which allows individual systems to garbage collect largely independently. The effects of these garbage collections are combined, using recursively structured control mechanisms, to achieve garbage collection of the entire heap with the minimum of overheads. Experimental results show that new algorithm recovers most inaccessible variables more quickly than a straightforward garbage collection, giving an improved memory utilisation

Garbage Collection for General Graphs

Garbage collection is moving from being a utility to a requirement of every modern programming language. With multi-core and distributed systems, most programs written recently are heavily multi-threaded and distributed. Distributed and multi-threaded programs are called concurrent programs. Manual memory management is cumbersome and difficult in concurrent programs. Concurrent programming is characterized by multiple independent processes/threads, communication between processes/threads, and uncertainty in the order of concurrent operations. The uncertainty in the order of operations makes manual memory management of concurrent programs difficult. A popular alternative to garbage collection in concurrent programs is to use smart pointers. Smart pointers can collect all garbage only if developer identifies cycles being created in the reference graph. Smart pointer usage does not guarantee protection from memory leaks unless cycle can be detected as process/thread create them. General garbage collectors, on the other hand, can avoid memory leaks, dangling pointers, and double deletion problems in any programming environment without help from the programmer. Concurrent programming is used in shared memory and distributed memory systems. State of the art shared memory systems use a single concurrent garbage collector thread that processes the reference graph. Distributed memory systems have very few complete garbage collection algorithms and those that exist use global barriers, are centralized and do not scale well. This thesis focuses on designing garbage collection algorithms for shared memory and distributed memory systems that satisfy the following properties: concurrent, parallel, scalable, localized (decentralized), low pause time, high promptness, no global synchronization, safe, complete, and operates in linear time

Performance of a hierarchical distributed garbage collection algorithm in ActorFoundry

Automatic garbage collection is an essential feature so that programs can reclaim resources without the need for manual input. This feature is present in many modern languages and is a common subject of research. However, in parallel and distributed environments, programmer-controlled resource reclamation is highly error-prone. As the scale of programs increase, automatic garbage collection is of paramount importance for efficient and error-free execution. Garbage collection in the context of actor systems is especially difficult because actors are active objects and may not be garbage even if there are no references to it. An additional difficulty is to perform garbage collection on active objects without halting the current computation. This thesis implements one of the proposed algorithms which can solve the problem of garbage collection in distributed actor systems. This study also explores how parameters in this algorithm along with how the topology of an actor system affect the garbage collection. This was implemented on an existing actor framework in order to highlight key factors in the algorithm's performance. The design details and insights gained from the results of these tests are then discussed

Finer garbage collection in LINDACAP.

As open systems persist, garbage collection (GC) can be a vital aspect in managing system resources. Although garbage collection has been proposed for the standard Linda, it was a rather course-grained mechanism. This finer-grained method is offered in Lindacap, a capability-based coordination system for open distributed systems. Multicapabilities in Lindacap enable tuples to be uniquely referenced, thus providing sufficient information on the usability of tuples (data) within the tuple-space. This paper describes the garbage collection mechanism deployed in Lindacap, which involves selectively garbage collecting tuples within tuple-spaces. The authors present the approach using reference counting, followed by the tracing (mark-and-sweep) algorithm to garbage collect cyclic structures. A time-to-idle (TTI) technique is also proposed, which allows for garbage collection of multicapability regions that are being referred to by agents but are not used in a specified length of time. The performance results indicate that the incorporation of garbage collection techniques adds little overhead to the overall performance of the system. The difference between the average overhead caused by the mark-and-sweep and reference counting is small, and can be considered insignificant if the benefits brought by the mark-and-sweep is taken into account

Distributed Saturation

The Saturation algorithm for symbolic state-space generation, has been a recent break-through in the exhaustive veri cation of complex systems, in particular globally-asyn- chronous/locally-synchronous systems. The algorithm uses a very compact Multiway Decision Diagram (MDD) encoding for states and the fastest symbolic exploration algo- rithm to date. The distributed version of Saturation uses the overall memory available on a network of workstations (NOW) to efficiently spread the memory load during the highly irregular exploration. A crucial factor in limiting the memory consumption during the symbolic state-space generation is the ability to perform garbage collection to free up the memory occupied by dead nodes. However, garbage collection over a NOW requires a nontrivial communication overhead. In addition, operation cache policies become critical while analyzing large-scale systems using the symbolic approach. In this technical report, we develop a garbage collection scheme and several operation cache policies to help on solving extremely complex systems. Experiments show that our schemes improve the performance of the original distributed implementation, SmArTNow, in terms of time and memory efficiency

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

A study of thread-local garbage collection for multi-core systems

With multi-processor systems in widespread use, and programmers increasingly writing programs that exploit multiple processors, scalability of application performance is more of an issue. Increasing the number of processors available to an application by a factor does not necessarily boost that application's performance by that factor. More processors can actually harm performance. One cause of poor scalability is memory bandwidth becoming saturated as processors contend with each other for memory bus use. More multi-core systems have a non-uniform memory architecture and placement of threads and the data they use is important in tackling this problem. Garbage collection is a memory load and store intensive activity, and whilst well known techniques such as concurrent and parallel garbage collection aim to increase performance with multi-core systems, they do not address the memory bottleneck problem. One garbage collection technique that can address this problem is thread-local heap garbage collection. Smaller, more frequent, garbage collection cycles are performed so that intensive memory activity is distributed. This thesis evaluates a novel thread-local heap garbage collector for Java, that is designed to improve the effectiveness of this thread-independent garbage collection