fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-04-27 16:02:16 +00:00
Code Issues Projects Releases Wiki Activity

quick pure gc prototype

Browse Source
This commit is contained in:
dcode 2019-03-20 18:36:58 +01:00
parent 952ac8627d
commit f44dbf2646
2 changed files with 266 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
std/assembly/allocator/tlsf.ts
View File

@ -1,3 +1,8 @@
// Two-Level Segregate Fit Memory Allocator.
//
// A general purpose dynamic memory allocator specifically designed to meet real-time requirements.
// Always aligns to 8 bytes.
// ╒══════════════ Block size interpretation (32-bit) ═════════════╕ // ╒══════════════ Block size interpretation (32-bit) ═════════════╕
// 3 2 1 // 3 2 1
// 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits // 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 bits

261
std/assembly/collector/pure.ts Normal file
View File

@ -0,0 +1,261 @@
// A Pure Reference Counting Garbage Collector
//
// After the paper by DAVID F. BACON, CLEMENT R. ATTANASIO, V.T. RAJAN, STEPHEN E.SMITH
// D.Bacon, IBM T.J. Watson Research Center
// 2001 ACM 0164-0925/99/0100-0111 $00.75
import { HEADER, HEADER_SIZE } from "../runtime";
ERROR("not implemented");
/* tslint:disable */
// TODO: new builtin
declare function ITERATECHILDREN(s: Header, fn: (t: Header) => void): void;
/** Object Colorings for Cycle Collection */
const enum Color {
/** In use or free. */
BLACK = 0,
/** Possible member of cycle. */
GRAY = 1,
/** Member of garbage cycle. */
WHITE = 2,
/** Possible root of cycle. */
PURPLE = 3,
/** Acyclic. */
GREEN = 4
}
// TODO: this is a placeholder -> map this to HEADER
class Header {
rc: u32;
color: Color;
buffered: bool;
}
// When reference counts are decremented, we place potential roots of cyclic garbage into a buffer
// called Roots. Periodically, we process this buffer and look for cycles by subtracting internal
// reference counts.
var rootsBuffer: usize = 0;
var rootsOffset: usize = 0; // insertion offset
var rootsLength: usize = 0; // insertion limit
function appendRoot(header: Header): void {
if (rootsOffset >= rootsLength) {
// grow for now
let newLength = rootsLength ? 2 * rootsLength : 256 * sizeof<usize>();
let newBuffer = memory.allocate(newLength);
memory.copy(newBuffer, rootsBuffer, rootsLength);
rootsBuffer = newBuffer;
rootsLength = newLength;
}
store<usize>(rootsBuffer + rootsOffset, header);
rootsOffset += sizeof<usize>();
}
function systemFree(s: Header): void {
memory.free(changetype<usize>(s));
}
// When a reference to a node S is created, the reference count of T is incremented and it is
// colored black, since any object whose reference count was just incremented can not be garbage.
function increment(s: Header): void {
s.rc += 1;
s.color = Color.BLACK;
}
// When a reference to a node S is deleted, the reference count is decremented. If the reference
// count reaches zero, the procedure Release is invoked to free the garbage node. If the reference
// count does not reach zero, the node is considered as a possible root of a cycle.
function decrement(s: Header): void {
s.rc -= 1;
if (!s.rc) release(s);
else possibleRoot(s);
}
// When the reference count of a node reaches zero, the contained pointers are deleted, the object
// is colored black, and unless it has been buffered, it is freed. If it has been buffered, it is
// in the Roots buffer and will be freed later (in the procedure MarkRoots).
function release(s: Header): void {
ITERATECHILDREN(s, t => decrement(t));
s.color = Color.BLACK;
if (!s.buffered) systemFree(s);
}
// When the reference count of S is decremented but does not reach zero, it is considered as a
// possible root of a garbage cycle. If its color is already purple, then it is already a candidate
// root; if not, its color is set to purple. Then the buffered flag is checked to see if it has
// been purple since we last performed a cycle collection. If it is not buffered, it is added to
// the buffer of possible roots.
function possibleRoot(s: Header): void {
if (s.color != Color.PURPLE) {
s.color = Color.PURPLE;
if (!s.buffered) {
s.buffered = true;
appendRoot(s);
}
}
}
// When the root buffer is full, or when some other condition, such as low memory occurs, the
// actual cycle collection operation is invoked. This operation has three phases: MarkRoots, which
// removes internal reference counts; ScanRoots, which restores reference counts when they are
// non-zero; and finally CollectRoots, which actually collects the cyclic garbage.
function collectCycles(): void {
markRoots();
scanRoots();
collectRoots();
}
// The marking phase looks at all the nodes S whose pointers have been stored in the Roots buffer
// since the last cycle collection. If the color of the node is purple (indicating a possible root
// of a garbage cycle) and the reference count has not become zero, then MarkGray(S) is invoked to
// perform a depth-first search in which the reached nodes are colored gray and internal reference
// counts are subtracted. Otherwise, the node is removed from the Roots buffer, the buffered flag
// is cleared, and if the reference count is zero the object is freed.
function markRoots(): void {
var readOffset = rootsBuffer;
var writeOffset = readOffset;
var readLimit = readOffset + rootsOffset;
while (readOffset < readLimit) {
let s = load<Header>(readOffset);
if (s.color == Color.PURPLE && s.rc > 0) {
markGray(s);
store<Header>(writeOffset, s);
writeOffset += sizeof<usize>();
} else {
s.buffered = false;
// remove from roots
if (s.color == Color.BLACK && !s.rc) systemFree(s);
}
readOffset += sizeof<usize>();
}
rootsOffset = writeOffset - rootsBuffer;
}
// For each node S that was considered by MarkGray(S), this procedure invokes Scan(S) to either
// color the garbage subgraph white or re-color the live subgraph black.
function scanRoots(): void {
var readOffset = rootsBuffer;
var readLimit = readOffset + rootsOffset;
while (readOffset < readLimit) {
scan(load<Header>(readOffset));
readOffset += sizeof<usize>();
}
}
// After the ScanRoots phase of the CollectCycles procedure, any remaining white nodes will be
// cyclic garbage and will be reachable from the Roots buffer. This prodecure invokes CollectWhite
// for each node in the Roots buffer to collect the garbage; all nodes in the root buffer are
// removed and their buffered flag is cleared.
function collectRoots(): void {
var readOffset = rootsBuffer;
var readLimit = readOffset + rootsOffset;
while (readOffset < readLimit) {
let s = load<Header>(readOffset);
// remove from roots
s.buffered = false;
collectWhite(s);
}
rootsOffset = 0;
}
// This procedure performs a simple depth-first traversal of the graph beginning at S, marking
// visited nodes gray and removing internal reference counts as it goes.
function markGray(s: Header): void {
if (s.color != Color.GRAY) {
s.color = Color.GRAY;
ITERATECHILDREN(s, t => {
t.rc -= 1;
markGray(t);
});
}
}
// If this procedure finds a gray object whose reference count is greater than one, then that
// object and everything reachable from it are live data; it will therefore call ScanBlack(S) in
// order to re-color the reachable subgraph and restore the reference counts subtracted by
// MarkGray. However, if the color of an object is gray and its reference count is zero, then it is
// colored white, and Scan is invoked upon its chldren. Note that an object may be colored white
// and then re-colored black if it is reachable from some subsequently discovered live node.
function scan(s: Header): void {
if (s.color == Color.GRAY) {
if (s.rc > 0) scanBlack(s);
else {
s.color = Color.WHITE;
ITERATECHILDREN(s, t => scan(t));
}
}
}
// This procedure performs the inverse operation of MarkGray, visiting the nodes, changing the
// color of objects back to black, and restoring their reference counts.
function scanBlack(s: Header): void {
s.color = Color.BLACK;
ITERATECHILDREN(s, t => {
t.rc += 1;
if (t.color == Color.BLACK) scanBlack(t);
});
}
// This procedure recursively frees all white objects, re-coloring them black as it goes. If a
// white object is buffered, it is not freed; it will be freed later when it is found in the Roots
// buffer.
function collectWhite(s: Header): void {
if (s.color == Color.WHITE && !s.buffered) {
s.color = Color.BLACK;
ITERATECHILDREN(s, t => collectWhite(t));
systemFree(s);
}
}
// Garbage collector interface
// @ts-ignore: decorator
@global
function __gc_link(ref: usize, parentRef: usize): void {
increment(changetype<Header>(ref - HEADER_SIZE));
}
// @ts-ignore: decorator
@global
function __gc_unlink(ref: usize, parentRef: usize): void {
decrement(changetype<Header>(ref - HEADER_SIZE))
}
// @ts-ignore: decorator
@global
function __gc_collect(): void {
collectCycles();
}
// TODO:
// A significant constant-factor improvement can be obtained for cycle collection by observice that
// some objects are inherently acyclic. We speculate that they will comprise the majorits of
// objects in many applications. Therefore, if we can avoid cycle collection for inherently acyclic
// object, we will significantly reduce the overhead of cycle collection as a whole. [...]
//
// Acyclic classes may contain:
// - scalars;
// - references to classes that are both acyclic and final; and
// - arrays of either of the above.
//
// Our implementation marks objects whose class is acyclic with the special color green. Green
// objects are ignored by the cycle collection algorithm, except that when a dead cycle refers to
// green objects, they are collected along with the dead cycle.