Actor Garbage Collection Using Vertex-Preserving Actor-to-Object Graph Transformations

With the increasing use of active object systems, agents and concurrent object oriented languages like Java, the problem of garbage collection of unused resources has become more complicated. Since Active objects are standalone computational agents identifying garbage in active objects system cannot be based on reachability from a root set (which we use for passive objects). We have to go for separate algorithm to collect garbage on system which uses active objects. For the systems which use both active and passive objects we have to use 2 separate methods for collecting garbage. To avoid this we can use a transformation algorithm that can transfer active object reference graph into passive object reference graph, after which we can apply the passive object algorithm to collect garbage from the entire system. An attempt is made to travel through the transformation algorithms.KeywordsActive ObjectsGarbage CollectionPassive ObjectsDistributed Garbage CollectionTransformation Algorithm

Evidence from experiments with single objects indicates that perceiving objects leads to automatic extraction of affordances. Here we examined the influence of implied between-object actions on affordance processing. Images of task-irrelevant object pairs (e.g., a spoon and a bowl) were followed by imperative central targets. Participants made speeded left/right responses to targets, and the responses randomly aligned with the affordance of one of the objects. The orientation of one object was manipulated across trials, leaving the colocation between objects correct or incorrect for potential interaction. Four experiments demonstrated that positioning the objects correctly for between-object actions led to a prioritization of the object active in the action (e.g., the spoon) over the passive (e.g., the bowl) object. Moreover, there was an inhibitory effect on responses to the passive object: responses congruent with the passive object were slower when pairs of objects were shown as if in interaction, compared with when they were not. The effects did not change in the single-hand response task but disappeared when the passive objects were absent-though an affordance should still have been presented by the active object. These results present evidence for affordance selection in action-related object pairs, and suggest inhibition of the action afforded by the passive objects under conditions of affordance competition.

In this paper we describe an implementation of actors in Smalltalk-80, named Actalk. This attempt is designed as a minimal extension preserving the Smalltalk-80 language.Actors are active and autonomous objects, as opposed to standard passive Smalltalk-80 objects. An actor is built from a standard Smalltalk-80 object by associating a process with it and by serializing the messages it could receive into a queue.We will study the cohabitation and synergy between the two models of computation: transfer of active messages (message and thread of activity) between passive objects, and exchange of passive messages between active objects. We propose a sketch of methodology in order to have a safe combination between these two programming paradigms.We show how to extend the Actalk kernel into various extensions to define the basic Actor model of computation, higher level programming constructs such as the 3 types of message passing (asynchronous, synchronous, and eager) proposed in the ABCL/1 programming language, and distributed architectures. All these examples are constructed as simple extensions (by using inheritance) of our kernel model.

Efforts to reason formally about programs, and in particular to prove their properties mathematically, have no practical value unless they can handle all the language facilities on which realistic programs depend. It is then not surprising that one of the biggest obstacles to the spread of such correctness-guaranteeing methods has been the lack of a good way to model the highly dynamic nature of the run-time structures created by object-oriented programs — and by most plain C or Pascal programs — with their heavy use of pointers, or references, from object to object. The present discussion proposes a mathematical theory for modeling pointer-rich object structures and proving their properties. The model only uses simple concepts from set theory: sets, relations, functions, composition, restriction, image. For run-time operations all it needs is the notion of event, a function yielding a new program state from an existing one. The model has two principal applications: •T he coarse-grained version of the model, considering only the existence or not of a reference between an object and another, gives a basis for discussing overall properties of the object structure, defining as a result the correctness constraints of memory management and especially garbage collection, full or incremental. Mathematically, this model uses a binary relation. •T he fine-grained version, based on functions which together make up the relation of the coarse-grained version, integrates the properties of individual object fields. As a result, it allows proving the correctness of classes describing structures with luxurious pointer foliage, from linked lists and graphs to B-trees and double-ended queues. This is part of a series of 3 articles. Parts 2 and 3 will be published in the May-June 2003 issue of JOT.

The number of operational satellites and debris objects in the valuable geosynchronous ring has increased steadily over time such that active debris removal missions are necessary to ensure long-term stability. These objects are very large and tumbling, making any mission scenarios requiring physical contact very challenging. In the last 10 years, the concept of using an electrostatic tractor has been investigated extensively. With the electrostatic tractor concept, active charge emission is employed to simultaneously charge the tug or services vehicle, while aiming the charge exhaust onto the passive space debris object to charge it as well. The resulting electrostatic force has been explored to actuate this debris object to a disposal orbit or to detumble the object, all without physical contact. This paper provides a survey of the related research and reviews the charging concepts, the associated electrostatic force and torque modeling, and the feedback control developments, as well as the charge sensing research.

Defining persistence in terms of reachability is fundamental to achieving orthogonality of persistence. It is implicit to the principles of orthogonal persistence and is a part of the ODMG 3.0 data objects standard. Although space reclamation in the context of persistence by reachability can be achieved automatically using garbage collection, relatively few papers address the problem of implementing garbage collection in a transactional storage system.Atransactional GC algorithm must operate correctly in the face of failure, and in particular must deal with the problem of transaction abort, which by undoing changes such as the deletion of references, subverts the GC reachability axiom of 'once garbage always garbage'.In this paper we make two key contributions. First, we present a generic approach to the design of transactional collectors that promotes clarity, generality, and understandability, and then using this approach, we present a new transactional garbage collection algorithm, TMOS. Our design approach brings together three independent components--a mutator, a transactional store, and a GC algorithm. TMOS represents the application of the Mature Object Space family of GC algorithms to the transactional context through our approach to transactional GC design.

Real-time embedded software is mostly written in low level language such as C and assembler. But such systems are hard to test, maintain, and port to other platform. The Java language is entering to the real-time embedded systems because of its robustness, simplicity and portability etc. However, It is very difficult to estimate the worst-case execution time of Java code currently. This is due to dynamic class loading and method calls, especially the automatic garbage collection. The paper has research-ed present solutions for garbage collection, and studied the memory management of the real-time specification of Java (RTSJ). Then the rational solute-on for RTSJ is to adapt incremental garbage collection and the region memory management.

On contemporary cache-coherent Non-Uniform Memory Access (ccNUMA) architectures, applications with a large memory footprint suffer from the cost of the garbage collector (GC), because, as the GC scans the reference graph, it makes many remote memory accesses, saturating the interconnect between memory nodes. We address this problem with NumaGiC, a GC with a mostly-distributed design. In order to maximise memory access locality during collection, a GC thread avoids accessing a different memory node, instead notifying a remote GC thread with a message; nonetheless, NumaGiC avoids the drawbacks of a pure distributed design, which tends to decrease parallelism. We compare NumaGiC with Parallel Scavenge and NAPS on two different ccNUMA architectures running on the Hotspot Java Virtual Machine of OpenJDK 7. On Spark and Neo4j, two industry-strength analytics applications, with heap sizes ranging from 160GB to 350GB, and on SPECjbb2013 and SPECjbb2005, ourgc improves overall performance by up to 45% over NAPS (up to 94% over Parallel Scavenge), and increases the performance of the collector itself by up to 3.6x over NAPS (up to 5.4x over Parallel Scavenge).

In automatic memory management programming language, the garbage collector is an important feature which reclaims memory that is no longer referenced by the program. The tracing collector performs a transitive closure across the object reference graph. And this process may result in too many cache misses, because the traverse exhibits poor locality. Previous studies have already proposed using software prefetching to improve memory performance of garbage collector. In this work, we studied the characteristic of prefetch instructions on x86 platforms in detail, and proposed a method to control the prefetch ratios by address thresholds. The experimental results show that a further improvement and optimization is obtained by tuning the prefetch ratio. We use these results to devise some guidelines for optimizing the memory performance as well as minimizing the collection pause times.

We describe a semantic type soundness result, formalized in the Coq proof assistant, for a compiler from a simple functional language into an idealized assembly language. Types in the high-level language are interpreted as binary relations, built using both second-order quantification and separation, over stores and values in the low-level machine.

Java runtime frees applications from manual memory management by its automatic garbage collection (GC), at the cost of stop-the-world pauses. State-of-the-art collectors leverage multiple generations, which will inevitably suffer from a full GC phase scanning the whole heap and induce a pause tens of times longer than normal collections, which largely affects both throughput and latency of the entire system. In this paper, we analyze the full GC performance of HotSpot Parallel Scavenge garbage collector comprehensively and study its algorithm design in depth. We find out that heavy dependencies among heap regions cause poor thread utilization. Furthermore, many heap regions contain mostly live objects (referred to as dense regions), which are unnecessary to collect. To solve these problems, we introduce two kinds of optimizations: allocating shadow regions dynamically as compaction destination to eliminate region dependencies and skipping dense regions to reduce GC workload. Evaluation results show the optimizations lead to averagely 2.6X (up to 4.5X) improvement in full GC throughput and thereby boost the application performance by 18.2% on average (58.4% at best).

Speed and ease of accelerator design is a growing need. High level programming languages have provided significant gains in the software world, but lag for hardware. We present a hardware implementation of a garbage collector that automates memory management, one of the major conveniences of modern software languages. Our garbage collector runs concurrently with the application it serves, using already-idle memory slots to do its work with little to no impact on performance. To achieve this, our collector exploits rapid synchronization that is straightforward in hardware but difficult in software. This synchronization enables the collector to interleave with fine pockets of idleness on a per-cycle, per-heap basis. Our collector typically incurred negligible overhead, only slowing the application to wait for collection to free memory when the heaps were so small that the collector could not keep pace with allocation. We also found that our concurrent collector performs best under an eager collection policy that collects garbage well before the application exhausts the available memory. Although this eager strategy performs more collection operations than strictly necessary, the application never pauses because our collector operates entirely in the background.

We propose a mathematical foundation for reasoning about the correctness and computational complexity of record handling algorithms, using algebraic methods recently introduced in graph theory. A class of pattern matching and replacement rules for graphs is specified, such that applications of rules in the class can readily be programmed as rapid transformations of record structures. When transformations of record structures are formalized as applications of rules to appropriate graphs, recent Church-Rosser type theorems of algebraic graph theory become available for proving that families of transformations are well behaved. In particular, we show that any Church-Rosser family of transformations can be combined with housekeeping operations involving indirect pointers and garbage collection without losing the Church-Rosser property, provided certain mild conditions on the rules defining the family are satisfied. This leads to suggestions for the design of record handling facilities in high level languages, especially when housekeeping chores are to be performed asynchronously by service processes that run in parallel with the main process. We also show how to express the net effect of two transformations as a single transformation. These results and the general theorems that support them can be used to analyze the behavior of a large record structure that can be updated asynchronously by several parallel processes or users.KeywordsColored GraphGarbage CollectionHigh Level LanguageGarbage CollectorFast ProductionThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Concurrent processes can be extremely difficult to reason about, both for programmers and formally. One approach to coping with this difficulty is to study new programming languages and type features such as Session Types. Session types take as their conceptual notion of concurrency as a collection of processes linked together via channels and provide type-level coordination between processes using these channels. Logically motivated programming languages exploit the idea that providing a proof of a theorem in a logic is similar to proving that a given term has a particular type in a programming language and vice versa. These connections can be interesting for a few different reasons. First, when language and logic are independently discovered and independently useful, the existence of a connection suggests that both are onto some fundamentally important idea. Additionally, a connection provides a basis both for sanity checking our ideas and also can be fruitful grounds for inspiration by seeing how variants of either the logic or the language are reflected through the connection. This thesis primarily describes an exploration of logically motivated session types, SILL. Polar- ization, classifying propositions as either positive or negative, provides a natural way to describe a logically based session typing language with asynchronous communication while retaining a semantics that is reasonably implementable. Additionally, polarization gives us a way to smoothly integrate synchronous channels into SILL without needing a semantic extension. When combined with Adjoint Logic, this gives us an ability to incorporate a variety of modalities with relatively little work. From a practical perspective, this gives SILL access to persistent processes and garbage collection. We additionally explore a trio of loosely related extensions to SILL, and their logical connections, inspired by the above results: bundled message passing to reduce the number of communications performed by processes; racy programs, enabled by a select / epoll -like mechanism; and asynchronous receiving, an almost generalization of the basic asynchronous semantics. We have three different implementations of SILL: a simple but relatively full featured interpreter written in OCaml; a fragment of SILL as an embedded domain specific language in Haskell; and a cleaner version of the same in Idris. Lastly, we show that Liquid Types and Session Types are compatible. This gives us one notion of a dependently session typed language.

Hardware enclaves assist in constructing a trusted execution environment (TEE) to store private code and data and thus become an appealing solution to enhance applications’ security. Nevertheless, state-of-the-art enclave implementations like Intel Software Guard Extensions (SGX) have severe performance issues and hinder the deployment of more complicated applications, especially those written in high-level languages like Java. To reduce the performance overhead, prior work has partitioned applications or rebuilt lightweight language runtimes, but they either require manual labor from developers or fail to provide full-fledged support for existing applications. This work instead provides <i>SAJ</i> , a runtime built upon a full-fledged Java virtual machine (JVM) and thus requires no modifications to applications. <i>SAJ</i> first analyzes the performance of vanilla JVMs running in enclaves and finds that the memory management overhead and boot phase are culprits for performance slowdown. For memory management, <i>SAJ</i> introduces SGX-aware heap layout and garbage collector, which reduces both GC and application execution time. As for the boot phase, <i>SAJ</i> introduces an address-conscious launching mechanism to improve the boot performance. The evaluation under representative Java applications shows that <i>SAJ</i> can reduce the overall GC pause time, application time, and boot time by 2.93 <inline-formula><tex-math notation="LaTeX">$\boldsymbol{\times}$</tex-math></inline-formula> , 2.58 <inline-formula><tex-math notation="LaTeX">$\boldsymbol{\times}$</tex-math></inline-formula> , and 2.73 <inline-formula><tex-math notation="LaTeX">$\boldsymbol{\times}$</tex-math></inline-formula> on average, respectively.