Meta-evaluation of Actors with Side-effects

This report describes research done at the Artificial Intelligence Laboratory of the Massachusetts Institute of Technology. Support for the laboratory's artificial intelligence research is provided in part by the Advanced Research Projects Agency of the Department of Defense under Office of Naval Research contract N000-14-74-C-0643.Meta-evaluation is a process which symbolically evaluates an actor and checks to see whether the actor fulfills its contract (specification). A formalism for writing contracts for actors with side-effects which allow sharing of data is presented. Typical examples of actors with side-effects are the cell, actor counterparts of the LISP function rplaca and rplacd, and procedures whose computation depends upon their input history. Meta-evaluation of actors with side-effects is carried out by using situational tags which denotes a situation (local state of an actor systems at the moment of the transmissions of messages). It is illustrated how the situational tags are used for proving the termination of the activation of actors.MIT Artificial Intelligence Laborator

Protection and Synchronization in Actor Systems

This paper presents a unified method [called ENCASING] for dealing with the closely related issues of synchronization and protection in actor systems [Hewitt et al. 1973a, 1973b, 1974a; Greif and Hewitt 1975]. Actors are a semantic concept in which no active process is ever allowed to treat anything as an object. Instead a polite request must be extended to accomplish what the activator [process] desires. Actors enable us to define effective and efficient protection schemes. Vulnerable actors can be protected before being passed out by ENCASING their behavior in a guardian which applies appropriate checks before invoking the protected actor. Protected actors can be freely passed out since they work only for actors which have the authority to use them where authority can be decided by an arbitrary procedure. Synchronization can be viewed as a [time-variant] kind of protection in which access is only allowed to the encased actor when it is safe to do so.MIT Artificial Intelligence Laborator

Formal Derivation of Concurrent Garbage Collectors

Concurrent garbage collectors are notoriously difficult to implement correctly. Previous approaches to the issue of producing correct collectors have mainly been based on posit-and-prove verification or on the application of domain-specific templates and transformations. We show how to derive the upper reaches of a family of concurrent garbage collectors by refinement from a formal specification, emphasizing the application of domain-independent design theories and transformations. A key contribution is an extension to the classical lattice-theoretic fixpoint theorems to account for the dynamics of concurrent mutation and collection.Comment: 38 pages, 21 figures. The short version of this paper appeared in the Proceedings of MPC 201

Garbage Collection in a Very Large Address Space

This research was done at the Artificial Intelligence Laboratory of the Massachusetts Institute of Technology and was supported by the Office of Naval Research under contract number N00014-75-C-0522.The address space is broken into areas that can be garbage collected separately. An area is analogous to a file on current systems. Each process has a local computation area for its stack and temporary storage that is roughly analogous to a job core image. A mechanism is introduced for maintaining lists of inter-area links, the key to separate garbage collection. This mechanism is designed to be placed in hardware and does not create much overhead. It could be used in a practical computer system that uses the same address space for all users for the life of the system. It is necessary for the hardware to implement a reference count scheme that is adequate for handling stack frames. The hardware also facilitates implementation of protection by capabilities without the use of unique codes. This is due to elimination of dangling references. Areas can be deleted without creating dangling references.MIT Artificial Intelligence Laboratory Department of Defense Office of Naval Researc

High-level real-time programming in Java

Real-time systems have reached a level of complexity beyond the scaling capability of the low-level or restricted languages traditionally used for real-time programming. While Metronome garbage collection has made it practical to use Java to implement real-time systems, many challenges remain for the construction of complex real-time systems, some specic to the use of Java and others simply due to the change in scale of such systems. The goal of our research is the creation of a comprehensive Java-based programming environment and methodology for the creation of complex real-time systems. Our goals include construction of a provably correct real-time garbage collec-tor capable of providing worst case latencies of 100 s, capa-ble of scaling from sensor nodes up to large multiprocessors; specialized programming constructs that retain the safety and simplicity of Java, and yet provide sub-microsecond la-tencies; the extension of Java's \write once, run anywhere" principle from functional correctness to timing behavior; on-line analysis and visualization that aids in the understanding of complex behaviors; and a principled probabilistic analy-sis methodology for bounding the behavior of the resulting systems. While much remains to be done, this paper describes the progress we have made towards these goals

This is not the End: Rethinking Serverless Function Termination

Elastic scaling is one of the central benefits provided by serverless platforms, and requires that they scale resource up and down in response to changing workloads. Serverless platforms scale-down resources by terminating previously launched instances (which are containers or processes). The serverless programming model ensures that terminating instances is safe assuming all application code running on the instance has either completed or timed out. Safety thus depends on the serverless platform's correctly determining that application processing is complete. In this paper, we start with the observation that current serverless platforms do not account for pending asynchronous I/O operations when determining whether application processing is complete. These platforms are thus unsafe when executing programs that use asynchronous I/O, and incorrectly deciding that application processing has terminated can result in data inconsistency when these platforms are used. We show that the reason for this problem is that current serverless semantics couple termination and response generation in serverless applications. We address this problem by proposing an extension to current semantics that decouples response generation and termination, and demonstrate the efficacy and benefits of our proposal by extending OpenWhisk, an open source serverless platform

A concurrent, generational garbage collector for a multithreaded implementation of ML

International audienceThis paper presents the design and implementation of a "quasi real-time" garbage collector for Concurrent Caml Light, an implementation of ML with threads. This two-generation system combines a fast, asynchronous copying collector on the young generation with a non-disruptive concurrent marking collector on the old generation. This design crucially relies on the ML compile-time distinction between mutable and immutable objects

Symbol IC-Evaluation as an Aid to Program Synthesis

This report describes research done at the Artificial Intelligence laboratory of the Massachusetts Institute of Technology. Support for the laboratory's artificial intelligence research is provided in part by the Advance Research Projects Agency of the Department of Defence under Office of Naval Research contract N00014-75-C0522.Symbolic-evaluation is the process which abstractly evaluates an actor program and checks to see whether the program fulfills its contract (specification). In this paper, a formalism based on the conceptual representation is proposed as a specification language and a proof system for programs which may include change of behavior (side-effects). The relation between algebraic specifications and the specifications based on the conceptual representation is discussed and the limitation of the current algebraic specifications is pointed out. The proposed formalism can deal with problems of side-effects which have been beyond the scope of Floyd-Hoare proof rules. Symbolic-evaluation is carried out with explicit use of the notion of situation (local state of an actor system). Uses of situational tags in assertions make it possible to state relations holding between objects in different situations. As an illustrative example, an impure actors which behave like a queue is extensively examined. The verification of a procedure which deals with the queue-actors and the correctness of its implementations are demonstrated by the symbolic-evaluation. Furthermore how the symbolic-evaluation serves as an aid to program synthesis is illustrated using two different implementations of the queue-actor.MIT Artificial Intelligence Laboratory Department of Defense Advanced Research Projects Agenc

Eliminating read barriers through procrastination and cleanliness

Managed languages use read barriers to interpret forwarding pointers introduced to keep track of copied objects. For example, in a split-heap managed runtime for a multicore environment, an object initially allocated on a local heap may be copied to a shared heap if it becomes the source of a store operation whose target location resides on the shared heap. As part of the copy operation, a forwarding pointer may be established to allow existing references to the local object to reference the copied version. In this paper, we consider the design of a managed runtime that avoids the need for read barriers. Our design is premised on the availability of a sufficient degree of concurrency to stall operations that would otherwise necessitate the copy. Stalled actions are deferred until the next local collection, avoiding exposing forwarding pointers to the mutator. In certain important cases, procrastination is unnecessary- lightweight runtime techniques can sometimes be used to allow objects to be eagerly copied when their set of incoming references is known, or when it can be determined that having multiple copies would not violate program semantics. Experimental results over a range of parallel benchmarks on a number of different architectural platforms including an 864 core Azul Vega 3, and a 48 core Intel SCC, indicate that our approach leads to notable performance gains (20- 32 % on average) without incurring any additional complexity

Lightweight Block-level Concurrent Sweeping for JavaScript Garbage Collection

학위논문 (석사)-- 서울대학교 대학원 : 전기·컴퓨터공학부, 2014. 8. 이재진.자바스크립트는 클라이언트의 웹페이지의 동적인 동작을 가능하게 하기위해 고안된 동적 타입 언어이다. 주로 데스크탑과 서버의 웹 어플리케이션에 사용되어 왔다. 자바스크립트의 쉬운 문법적 특성으로 인해, 최근 데스크탑 서버를 넘어 모바일에서 사용되기 시작했다. 기존의 자바스크립트 엔진들은, 주로동작하는 환경이 자원이 풍부한 데스크탑과 서버이므로, 성능 향상에 초점을 맞추었다. 하지만, 시스템 자원이 한정적인 모바일 기기에 사용되면서, 가비지 컬랙션을 통해 효율적인 메모리 사용에 대한 필요성이 증대되고 있다. 자바스크립트엔진들은 고유의 메모리공간인 자바스크립트힙을관리하기위해, 자체적인 가비지 컬랙션 알고리즘을 사용한다. 자바스크립트의 메모리 사용 공간을 최소화 하기 위해, 가비지 컬랙션이 더 자주 불릴 수 있다. 하지만, 가비지 컬랙션의 빈번한 호출로 인한 시스템 자원 소모로, 자바스크립트의 성 능을 저하 시킬 수 있다. 이처럼, 가비지 컬랙션의 메모리 감소효과와 시스템 성능 간에는 상충관계가 존재한다. 본 논문에서는 보편적으로 쓰이는 가비지 컬랙션 기법인 마크 앤 스윕 기법의 가비지 컬랙터에 대해 성능 저하 없는 메모리 향상 기법을 제시한다. 스위핑과정을 별도의 쓰레드에 할당하면서, 마킹 후에 발생하는 빈 블럭들을 조기에 수거하여 재사용 가능하게 한다. 사용하고 남은 블럭들은 마킹 시에 별도의 쓰레드를 통해 소멸한다. 이는 동기화 비용 없이 힙 공간을 효율적으로 관리할 수 있게 한다. 제안한 알고리즘은 웹킷 엔진에 포함되어있는 자바스크립트 엔진인, 자바스크립트코어에 구현되었다. 성능 비교는 ARM 기반의 모바일 운영체제에서 진행되었으며, 성능 저하없이 상당한 메모리 감소효과를 볼 수 있었다.JavaScript is a dynamic-typed language originally developed for dynamic behaviors of web pages on client-side. It has been mainly used for web application development on desktop and servers. Because of its popularity and rapid development style, it is now also used beyond desktop and servers, especially on mobile devices. Most JavaScript engines has been improved putting higher priority on better performance because their target machines are desktop and servers having abundant system resources. However, as it starts to be used on embedded devices which have limited resources, it is required on JavaScript engines to make efficent use of system resources, esepecially memory resource. JavaScript engines uses their own garbage collection algorithms to manage JavaScript heap. To reduce memory footprint of JavaScript, garbage collections should be called more frequently. However, since aggressive use of time consuming operations in garbage collection can slow down the JavaScript application, there is a trade-off between the effectiveness and the execution time of garbage collection. In this paper, we present a lightweight, block-level concurrent sweeping mechanism for a mark-and-sweep garbage collector. The sweeping process is detached to an additional thread to eagerly collect free memory blocks and recycle it. To minimize the overhead that comes from the synchronization between the mutator thread and the new sweeping thread, we have chosen a course grained block-level collecting scheme for sweeping. To avoid contention that comes from object destruction, we execute the object destruction phase concurrently with the foreground marking phase. We have implemented our algorithm in JavaScript Core (JSC) engine embedded in the WebKit browser that uses a variant of mark-and-sweep algorithm to manage JavaScript objects. The original garbage collection implementation performs lazy sweeping that cannot reuse the free blocks. We evaluate our implementation on an ARM-based mobile system and show that memory utilization of the system is significantly improved without performance degradation.초록 i 제 1 장 서론 1 제 2 장 본론 5 2.1 가비지 컬랙션 개관 5 2.2 자바스크립트코어의 메모리 관리 6 2.2.1 힙 공간 할당 7 2.2.2 가비지 컬랙션 8 2.2.3 점증적 스위핑 기법(Incremental Sweeping) 11 2.3 블럭수준 동시적 스위핑 기법 구현 13 2.3.1 핵심 아이디어 13 2.3.2 블럭 수준 스위핑 메커니즘 15 2.3.3 점증적 스위핑 기법의 병용 17 2.4 실험 결과 17 2.4.1 실험 환경 18 2.4.2 벤치마크 어플리케이션 18 2.4.3 메모리 사용 패턴 측정 20 2.4.4 가비지 컬랙션 후 힙 공간 측정 21 2.4.5 메모리 사용량 측정 23 2.4.6 성능 변화 32 2.5 관련 연구 34 제 3 장 결론 37 참고문헌 44 Abstract 45Maste