Human Folly about “garbage-collection”

index

Nonmoving GC merge (well-typed.com):
a new low-latency non-moving GC landed in GHC 8.1.0. #Haskell #garbage-collection
on 02026-05-26
Why do we need to call luas collectgarbage twice (stackoverflow.com):
for #performance testing in #Lua you may have to invoke #garbage-collection twice (with collectgarbage()) to ensure that finalizers actually run. Quoting PIL: “The first time the collector detects that an object with a finalizer is not reachable, the collector resurrects the object and queues it to be finalized. Once its finalizer runs, Lua marks the object as finalized. The next time the collector detects that the object is not reachable, it deletes the object. If you want to ensure that all garbage in your program has been actually released, you must call collectgarbage twice; the second call will delete the objects that were finalized during the first call.”
on 02026-01-06
On impossibility composing finalizers (lobste.rs):
comments on Wingo’s #FFI #garbage-collection post
on 02025-12-26
On the impossibility of composing finalizers and FFI (wingolog.org):
Andy Wingo thinks composing finalizers with #FFI is impossible because the #garbage-collection might decide that the object whose guts an FFI function is returning a reference to has become unreferenced.
on 02025-12-26
GC (github.com):
#Wasm got #garbage-collection support (useful for things like #OCaml)
on 02025-08-30
Babys first garbage collector (journal.stuffwithstuff.com):
an older #garbage-collection #tutorial in 100 lines of C. #small-is-beautiful
on 02024-11-22
Copygc (jennyjams.net):
a #garbage-collection #tutorial #small-is-beautiful
on 02024-11-22
Dagc (erights.org):
distributed acyclic #garbage-collection in #CapTP for #capability-systems
on 02023-09-02
Lec21 Schorr Waite (cs.cornell.edu):
#PDF #paper by David Gries “Schorr-Waite Graph Marking Algorithm –Developed With Style” where he gives the Deutsch-Schorr-Waite #garbage-collection graph-marking algorithm as something like p = root; q = vroot; while (p != vroot) { p.m++; if (p.m == 3 || p.car.m == 0) { [p, p.car, p.cdr, q] = [p.car, p.cdr, q, p]; } else { [p.car, p.cdr, q] = [p.cdr, q, p.car]; } where the comma-assignment statements are multiple assignments and .m goes from 0 (for unvisited) to 3 (for marked), nil pointers are represented by pointers to a node whose car and cdr point to itself, and vroot is a special distinguished node that we pretend is the parent of the root. #algorithms
on 02023-07-05
(arxiv.org):
“An Empirical Lower Bound on the Overheads of Production Garbage Collectors” very clever #PDF on #garbage-collection #performance
on 02022-02-09
(hindawi.com):
A #paper on concurrent #lock-free #garbage-collection
on 02019-02-01
Epoch (aturon.github.io):
#Lock-free concurrency and optimistic synchronization without #garbage-collection in #Rust. #cs
on 02019-02-01
Aitr (publications.ai.mit.edu):
#PDF of Sobalvarro’s 1988 bachelor’s thesis on adding generational #garbage-collection to Lucid Common Lisp in 1986 and 1987 without support from the virtual memory system. He mentions that the Lieberman & Hewitt paper described an approach that required “invisible pointers”. Apparently at this point three other generational GCs existed: Ungar’s in Berkeley Smalltalk, Wirfs-Brock’s in Tektronix’s Smalltalk, and Moon’s on the Symbolics 3600. 68 pp.
on 02017-01-03
Realtime (web.media.mit.edu):
the #paper introducing generational #garbage-collection; Lieberman & Hewitt 1980, but not published by ACM until 1983. I think this version wasn’t practical but I don’t quite remember why.
on 02017-01-03
On GC in games response to Jeff and Casey (randomwalk.nfshost.com):
#garbage-collection in #video-games
on 02016-10-10
Citation (dl.acm.org):
#paper on #real-time #garbage-collection of #Flash
on 02016-10-10