Asynchronous, complete and distributed garbage collection in the NGrid project

15 pagesThe distributed garbage collection (DGC) problem can be divided in two parts: 1) acyclic garbage collection solved by the Reference Listing method 2) cyclic garbage collection solved by the Graph Summarizer method. This reports improvements brought by the NGrid DGC project

Practical distributed garbage collection for networks with asynchronous clocks and message delay

Distributed garbage collection over a message passage network is discussed in this paper. Traditionally, this can be done by reference counting, which is fast but cannot reclaim cyclic structures or by graph traversal, e.g. mark-and-sweep or time stamping, which is capable of reclaiming cyclic structures but is slow. We propose a combined scheme which is fast in reclaiming acyclic garbage and guaranteed to reclaim cyclic garbage. Our scheme does not rely on synchronized clocks nor zero message delay and is thus practical.published_or_final_versio

Software Ticks Need No Specifications

Software bugs cost time, money, and lives. They drive software research and development efforts, and are central to modern software engineering. Yet we lack a clear and general definition of what bugs are. Some bugs are defects, clearly defined as failures to meet some requirement or specification. However,there are many forms of undesirable program behaviour that are completely compatible with a typical program’s specification. In this paper, we argue that the lack of a criterion for identifying non-defect bugs is hampering the development of tools that find and fix bugs. We propose such a criterion, based on the idea of wasted effort, discuss how bugs that meet our definition of software ticks can complement defects, and sketch how our definition can help future work on software tools

A formal soundness proof of region-based memory management for object-oriented paradigm.

Region-based memory management has been proposed as a viable alternative to garbage collection for real-time applications and embedded software. In our previous work we have developed a region type inference algorithm that provides an automatic compile-time region-based memory management for object-oriented paradigm. In this work we present a formal soundness proof of the region type system that is the target of our region inference. More precisely, we prove that the object-oriented programs accepted by our region type system achieve region-based memory management in a safe way. That means, the regions follow a stack-of-regions discipline and regions deallocation never create dangling references in the store and on the program stack. Our contribution is to provide a simple syntactic proof that is based on induction and follows the standard steps of a type safety proof. In contrast the previous safety proofs provided for other region type systems employ quite elaborate techniques

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

Deterministic Java in tiny embedded systems

As embedded systems become more and more complex, and the time to market becomes shorter, there is a need in the embedded systems community to find better programming languages that let the programmers develop correct code faster. The programming languages used today, typically C and/or Assemblers, are just too error-prone. The Java technology has therefore gained a lot of interest from developers of embedded systems in the last few years. We propose an approach based on compiling Java into native machine code via C as an intermediate language. The C code generation process should also add close interaction with a fully pre-emptive incremental garbage collector and a small and efficient real time kernel. Tests performed on a small 8-bit microprocessor show that it is possible to use a modern object oriented language with automatic memory management, such as Java, and yet generate fully predictable code that can be run in very small devices with severe memory constraints

Sketch based Distributed Garbage Collection, Theory and Empirical Elements

8 pagesObject-Oriented Programming (OOP) is a pillar of actual, and most probably future, software engineering. Within the advances for OOP, Garbage Collection (GC) is one the major improvements that brought both large productivity and reliability benefits. Yet, to our knowledge, no widely used distributed systems benefit from a complete Distributed Garbage Collector (DGC) at this time. We believe that this situation is due, a least partly, to actual DGC performance issues. In this paper, we introduce the idea of sketch based DGC where object-graph fragments are sketched rather than explicitly represented. We prove, under reasonable assumptions that sketched messages are smaller up to one order of magnitude than their explicit counterparts. Those results apply to most of state-of-art DGC methods. In the case of the Veiga and Ferreira DGC algorithm, the improvement is more than a factor~4 under very limited assumptions