dymokomi/luce-prism
Source of release 0.6.1
0.6.1 / tests / compatibility / allocations.lucb
## Exhaust each allocation point in representative composition and codec operations.
from luce_prism import prism
import memory
import interop
import ownership
import compatibility.codec_api as codec_tests
import compatibility.cache as cache_tests
from compatibility.query import plan, compare, exercise_callback
from compatibility.indexes import cloud, texts, vectors
struct Tracker: memory.Allocator:
var upstream: memory.Allocator
var live: usize
var allocations: usize
var remaining: usize?
pub func allocate(size: usize, alignment: usize) -> u8[]?:
if let remaining = self.remaining:
if remaining == 0:
return none
self.remaining = remaining - 1
let bytes = self.upstream.allocate(size, alignment) else return none
self.live += 1
self.allocations += 1
return bytes
pub func resize(bytes: u8[], size: usize) -> bool:
return self.upstream.resize(bytes, size)
pub func release(bytes: u8[]):
assert(self.live > 0)
self.live -= 1
self.upstream.release(bytes)
func exercise(kind: usize) -> !:
if kind == 22:
try codec_tests.allocation_case()
return
if kind == 23:
try cache_tests.allocation_case()
return
if kind == 24:
let doc = try prism.Document.parse("#prisma 4.0\n")
defer doc.release()
let handle = prism.define(doc, "/a", "object") catch failure:
assert(doc.value().element_count() == 0)
error(failure.code, failure.message)
defer handle.release()
let value = try prism.Value.number(4.0)
defer value.release()
let animated = handle.value().sample("v", 2.0, value) catch failure:
assert(not doc.value().has_property("/a", "v"))
error(failure.code, failure.message)
defer animated.release()
let snapshot = try doc.value().sample_value_at("/a", "v", 0)
defer snapshot.release()
assert(try snapshot.value().number_at() == 4.0)
var settings = try prism.AppSettings("unused.prisma")
defer settings.close()
try settings.set("v", value)
return
if kind == 20:
var projection = try prism.TextProjection()
defer projection.close()
assert(try projection.set_source("# Title\n\n\nbody\n", prism.Codec.markdown))
assert(try projection.set_codec(prism.Codec.prisma))
assert(not try projection.set_text("#prisma 4.0\ndef group \"a\" {"))
assert(try projection.set_codec(prism.Codec.markdown))
assert(try projection.text() == "# Title\n\n\nbody\n")
let tokens = try prism.highlight_line("# Title", prism.Codec.markdown)
defer tokens.release()
return
if kind == 21:
let first = try prism.Document.parse("#prisma 4.0\ndef node \"a\" { float v = 1 }")
defer first.release()
let second = try prism.Document.parse("#prisma 4.0\ndef node \"a\" { float v = 2 }")
defer second.release()
var log = try prism.EventLog(first)
defer log.close()
_ = log.commit(second) catch failure:
assert(log.head_offset() == 0)
error(failure.code, failure.message)
let changes = try log.since(0)
defer changes.release()
let snapshot = try log.at(1)
defer snapshot.release()
assert(try snapshot.value().equals(second))
log.compact(0) catch failure:
assert(log.earliest_offset() == 0 and log.layer_count() == 1)
error(failure.code, failure.message)
return
if kind == 19:
let doc = try prism.parse_surface("logic \"f\" { bird(tweety) } logic \"r\" { bird(X) => flies(X) } logic \"d\" { ~> -flies(tweety) } logic \"s\" { r > d } math \"x\" { -(1 + 2) * 3 }")
defer doc.release()
let text = try prism.serialize_surface(doc)
defer text.release()
var query = try interop.Reference[prism.Atom].adopt(try new prism.Atom("flies") in memory.heap, prism.atom_type, memory.heap)
defer query.release()
try query.value().constant("tweety")
assert(try prism.conclude(doc, query) == prism.ProofTag.defeasible_proof)
let why = try prism.why(doc, query)
defer why.release()
assert(why.value().defeated_count() == 1)
let derived = try prism.derive(doc)
defer derived.release()
return
if kind < 3:
let codec = prism.Codec.json if kind == 0 else (prism.Codec.html if kind == 1 else prism.Codec.svg)
let source = "{\"a\":1,\"child\":{\"escaped\":\"line\\ntext\"},\"items\":[true,null]}" if kind == 0 else ("<h2 id=\"t\">Title</h2><p>A <em>word</em> & more</p>" if kind == 1 else "<svg viewBox=\"0 0 4 4\"><text>hello</text></svg>")
let doc = try prism.decode(source.bytes, codec)
defer doc.release()
let encoded = try prism.encode(doc, prism.Codec.markdown if kind == 1 else codec)
defer encoded.release()
return
if kind == 3:
var bundle = try prism.Bundle()
defer bundle.close()
_ = try bundle.add_file("/bundle", "page.html", b"<p>hello</p>")
let bytes = try bundle.materialize("/bundle/page_html")
defer bytes.release()
return
let base = try prism.Document.parse("#prisma 4.0\ndef node \"a\" { float x = 1 float y = 2 } def node \"b\" { connect in = </a.x> }")
defer base.release()
let layer = try prism.Document.parse("#prisma 4.0\nover node \"a\" { float x = 3 unset y } delete \"/b\"")
defer layer.release()
if kind == 4:
let combined = try base.value().overlay(layer)
defer combined.release()
let value = try combined.value().get("/a", "x")
defer value.release()
let patch = try base.value().diff(combined)
defer patch.release()
let result = try prism.merge(base, patch, layer)
defer result.release()
elif kind == 5:
var library = prism.ReferenceLibrary()
defer library.close()
try library.add("source.prism", base)
let root = try prism.Document.parse("#prisma 4.0\ndef node \"root\" { reference \"source.prism\" \"/a\" }")
defer root.release()
try library.add("root.prisma", root)
let composed = try library.compose("root.prisma")
defer composed.release()
elif kind == 6:
let doc = try prism.Document.parse("#prisma 4.0\ndef mul \"mul\" { float64 a = 2 float64 b = 3 } def add \"add\" { connect a = </mul.out> connect b = </mul.out> }")
defer doc.release()
let computed = try prism.compute(doc)
defer computed.release()
elif kind == 7:
let query = try plan(base)
defer query.release()
let exists = try prism.Predicate.exists("x")
defer exists.release()
let less = try compare("x", try prism.Value.number(4.0), prism.Comparison.less)
defer less.release()
let both = try exists.value().both(less)
defer both.release()
let filtered = try query.value().filter(both)
defer filtered.release()
let ordered = try filtered.value().order_by("x")
defer ordered.release()
let reverse = try ordered.value().reverse()
defer reverse.release()
let limited = try reverse.value().limit(1)
defer limited.release()
let selection = try limited.value().select()
defer selection.release()
let document = try selection.value().document()
defer document.release()
_ = try query.value().aggregate("x", prism.Aggregate.median)
_ = try query.value().distinct_count("x")
let groups = try query.value().aggregate_by(["type"], "x", prism.Aggregate.sum)
defer groups.release()
let group_rows = try groups.value().rows(0)
defer group_rows.release()
elif kind == 8:
var index = try prism.FieldIndex(base, "x")
defer index.close()
let value = try prism.Value.integer(1)
defer value.release()
let rows = try index.equals(value)
defer rows.release()
let query = try plan(base)
defer query.release()
let result = try prism.join_on(query, "x", query, "x", prism.JoinType.outer)
defer result.release()
let connected = try prism.join_by_connection(base, query, "in")
defer connected.release()
elif kind == 9:
var schema = prism.Schema()
defer schema.close()
try schema.add_field("node", "x", prism.DType.int64, required = true, unique = true)
let violations = try schema.validate(base)
defer violations.release()
var column = try prism.ColumnTable(base, "/a")
defer column.close()
let rows = try column.filter("x", prism.Comparison.greater, 0.0)
defer rows.release()
_ = try column.aggregate("y", prism.Aggregate.average, rows)
elif kind == 10:
let registry = try interop.Reference[prism.NodeRegistry].adopt(try new prism.NodeRegistry() in memory.heap, prism.registry_type, memory.heap)
defer registry.release()
try registry.value().add_math()
var scene = try prism.Scene(base, registry)
defer scene.close()
elif kind == 11:
let doc = try cloud()
defer doc.release()
var index = try prism.SpatialIndex(doc, "loc", 1.0)
defer index.close()
let within = try index.within(prism.Vec3(1.0, 0.0, 0.0), 0.6)
defer within.release()
let nearest = try index.nearest(prism.Vec3(), 2)
defer nearest.release()
let box = try index.in_box(prism.Vec3(), prism.Vec3(2.0, 2.0, 2.0))
defer box.release()
elif kind == 12:
let doc = try texts()
defer doc.release()
var index = try prism.TextIndex(doc, "body")
defer index.close()
let found = try index.search_all("quick fox")
defer found.release()
elif kind == 13:
let doc = try vectors()
defer doc.release()
var index = try prism.VectorIndex(doc, "v")
defer index.close()
let found = try index.nearest([1.0, 0.0, 0.0], 2)
defer found.release()
elif kind == 14:
try exercise_callback()
elif kind == 15:
_ = base.value().append("/c", "node") catch failure:
assert(base.value().element_count() == 2 and base.value().child_count() == 2)
assert(not base.value().contains("/c") and base.value().contains("/a") and base.value().contains("/b"))
error(failure.code, failure.message)
elif kind == 16:
let identifier = base.value().element_id("/a") else error(prism.invalid, "missing ID")
base.value().rename("/a", "/c") catch failure:
assert(base.value().contains("/a") and not base.value().contains("/c"))
assert(base.value().path_for_id(identifier) == "/a")
error(failure.code, failure.message)
elif kind == 17:
base.value().remove("/a") catch failure:
assert(base.value().element_count() == 2 and base.value().child_count() == 2)
assert(base.value().contains("/a") and base.value().contains("/b"))
assert(base.value().connection_count() == 1)
error(failure.code, failure.message)
else:
let fragment = try base.value().extract("/a")
defer fragment.release()
let roots = base.value().instantiate(fragment) catch failure:
assert(base.value().element_count() == 2 and base.value().child_count() == 2)
error(failure.code, failure.message)
defer roots.release()
assert(roots.value().count() == 1 and base.value().contains("/a_1"))
let edited = try base.value().copy()
defer edited.release()
try edited.value().rename("/a", "/c")
let moves = try prism.renames(base, edited)
defer moves.release()
func restore(allocator: memory.Allocator):
memory.heap = allocator
func overlay_get(base: interop.Reference[prism.Document], layer: interop.Reference[prism.Document]) -> !:
let combined = try base.value().overlay(layer)
defer combined.release()
let value = try combined.value().get("/n0", "x")
defer value.release()
assert(try value.value().number_at() == 9.0)
func overlay_get_does_not_copy_base(tracker: Tracker*) -> !:
let small_base = try prism.Document.parse("#prisma 4.0\ndef node \"n0\" { float x = 1 } def node \"n1\" { float x = 1 }")
defer small_base.release()
let large_base = try prism.Document.parse("#prisma 4.0\ndef node \"n0\" { float x = 1 } def node \"n1\" { float x = 1 } def node \"n2\" { float x = 1 } def node \"n3\" { float x = 1 } def node \"n4\" { float x = 1 } def node \"n5\" { float x = 1 } def node \"n6\" { float x = 1 } def node \"n7\" { float x = 1 } def node \"n8\" { float x = 1 } def node \"n9\" { float x = 1 } def node \"n10\" { float x = 1 } def node \"n11\" { float x = 1 } def node \"n12\" { float x = 1 } def node \"n13\" { float x = 1 } def node \"n14\" { float x = 1 } def node \"n15\" { float x = 1 }")
defer large_base.release()
let overlay_layer = try prism.Document.parse("#prisma 4.0\nover node \"n0\" { float x = 9 }")
defer overlay_layer.release()
tracker.allocations = 0
try overlay_get(small_base, overlay_layer)
let small_cost = tracker.allocations
tracker.allocations = 0
try overlay_get(large_base, overlay_layer)
let large_cost = tracker.allocations
if large_cost > small_cost + small_cost // 2:
print(f"overlay+get scaled with element count: {small_cost} then {large_cost}")
assert(large_cost <= small_cost + small_cost // 2)
func warm_cycle_collector() -> !:
let doc = try prism.Document.parse("#prisma 4.0\ndef node \"n\" { float x = 1 }")
defer doc.release()
let query = try plan(doc)
defer query.release()
pub func run() -> !:
ownership.collect()
try warm_cycle_collector()
ownership.collect()
var tracker = Tracker(upstream = memory.heap)
defer restore(tracker.upstream)
memory.heap = &tracker
try overlay_get_does_not_copy_base(&tracker)
ownership.collect()
assert(tracker.live == 0)
var checked: usize = 0
for kind in 0..<(usize)25:
tracker.allocations = 0
try exercise(kind)
ownership.collect()
assert(tracker.live == 0)
let total = tracker.allocations
var successes: usize = 0
for stage in 0..=total:
tracker.remaining = stage
var succeeded = true
exercise(kind) catch failure:
if failure.code != memory.exhausted:
print(f"unexpected failure at operation {kind}, allocation {stage}: {failure.message}")
assert(failure.code == memory.exhausted)
succeeded = false
if succeeded:
successes += 1
tracker.remaining = none
ownership.collect()
if tracker.live != 0:
let live = tracker.live
print(f"allocation leak: operation {kind}, allocation {stage}, live {live}")
assert(tracker.live == 0)
checked += 1
if successes != 1:
print(f"allocation audit {kind}: {successes} successful attempts")
assert(successes == 1)
print(f"PASS {checked} allocation-failure points across codecs, composition, queries, schemas and evaluation")