Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.3

0.7.3 / tests / mesh / query_checks.lucb

## Lazy BVH lifetime, retry after exhaustion, and simultaneous first readers.
import interop
import memory
import ownership
import sync
import thread
from luce_geocore.geocore import Mesh, Vector3, mesh_type, detached_mesh

struct Gate: memory.Allocator:
    let upstream: memory.Allocator
    var lock: sync.Mutex
    var remaining: usize? = none
    var live: usize = 0

    pub func allocate(size: usize, alignment: usize) -> u8[]?:
        self.lock.lock()
        defer self.lock.unlock()
        if size == 0: return self.upstream.allocate(size, alignment)
        if let remaining = self.remaining:
            if remaining == 0: return none
            self.remaining = remaining - 1
        let block = self.upstream.allocate(size, alignment) else return none
        self.live += 1
        return block

    pub func resize(block: u8[], size: usize) -> bool:
        self.lock.lock()
        defer self.lock.unlock()
        return self.upstream.resize(block, size)

    pub func release(block: u8[]):
        self.lock.lock()
        defer self.lock.unlock()
        if block.length == 0: return
        assert(self.live > 0)
        self.live -= 1
        self.upstream.release(block)

func restore(previous: memory.Allocator):
    memory.heap = previous

func grid() -> interop.Reference[Mesh]!:
    let points = try new Vector3[192] --- in memory.heap
    defer free(points) in memory.heap
    var sizes: i64[64]
    var corners: i64[192]
    for at in 0..<(usize)64:
        let x = (f64)(at % 8) * 2.0
        let y = (f64)(at // 8) * 2.0
        points[at * 3] = Vector3(x, y, 0.0)
        points[at * 3 + 1] = Vector3(x + 1.0, y, 0.0)
        points[at * 3 + 2] = Vector3(x, y + 1.0, 0.0)
        sizes[at] = 3
        for corner in 0..<(usize)3: corners[at * 3 + corner] = (i64)(at * 3 + corner)
    return try interop.Reference[Mesh].adopt(new Mesh(points, sizes, corners) in memory.heap, mesh_type, memory.heap)

func queries(mesh: const Mesh*) -> !:
    try mesh.prepare_queries()
    let p = Vector3(0.2, 0.2, 3.0)
    let d = Vector3(0.0, 0.0, -1.0)
    assert((try mesh.surface_distance(p)) == 3.0)
    assert((try mesh.closest_face(p)) == 0)
    assert((try mesh.ray_face(p, d)) == 0)
    assert((try mesh.ray_distance(p, d)) == 3.0)
    assert((try mesh.ray_face(p, d.multiply_scalar(-1.0))) == -1)

func retry(gate: Gate*, stage: usize) -> bool!:
    let source = try grid()
    defer source.release()
    let snapshot = try source.value().without_attribute("absent", 0)
    defer snapshot.release()
    # The face of each corner is a topology cache the index reads; build it
    # first, so the baseline counts only what the index itself allocates.
    _ = try source.value().triangle_face(0)
    let baseline = gate.live
    gate.remaining = stage
    defer clear_limit(gate)
    var failed = false
    source.value().prepare_queries() catch failure:
        assert(failure.code == memory.exhausted)
        assert(gate.live == baseline)
        failed = true
    gate.remaining = none
    try source.value().prepare_queries()
    # Both attribute snapshots must share the completed cache, even after the
    # original owner closes. No allocation is permitted on a warmed query.
    gate.remaining = 0
    try queries(snapshot.value())
    source.close()
    try queries(snapshot.value())
    return failed

func clear_limit(gate: Gate*):
    gate.remaining = none

struct Readers:
    let mesh: const Mesh*
    var waiting: @u32
    var start: @u32
    var failures: @u32

func read(raw: void*?):
    let readers = (Readers*)(raw else trap("missing query readers"))
    _ = readers.waiting.add(1, .release)
    while readers.start.load(.acquire) == 0: thread.yield()
    for iteration in 0..<100:
        queries(readers.mesh) catch failure:
            _ = readers.failures.add(1, .relaxed)

func join(readers: Readers*, handles: const thread.Handle[]):
    readers.start.store(1, .release)
    for handle in handles: handle.join() catch failure: trap(failure.message)

func concurrent() -> !:
    let source = try grid()
    defer source.release()
    # A detached product is native storage, not a cross-thread ARC handle.
    let copy = try detached_mesh(source)
    defer:
        copy.close()
        free(copy) in memory.heap
    source.close()
    var readers = Readers(mesh = copy)
    var handles: thread.Handle[8]
    var started: usize = 0
    defer join(&readers, handles[..<started])
    for at in 0..<handles.length:
        handles[at] = try thread.spawn(read, (void*)&readers, name = "mesh query")
        started += 1
    while readers.waiting.load(.acquire) != 8: thread.yield()
    join(&readers, handles)
    started = 0
    assert(readers.failures.load(.acquire) == 0)
    try queries(copy)

func display_surface() -> !:
    let points = [Vector3(), Vector3(1.0, 0.0, 0.0), Vector3(1.0, 1.0, 1.0), Vector3(0.0, 1.0, 0.0)]
    let origin = Vector3(0.5, 0.5, 2.0)
    let direction = Vector3(0.0, 0.0, -1.0)
    for raised in [false, true]:
        let display: i64[6] = [0, 1, 2, 0, 2, 3] if raised else [0, 1, 3, 1, 2, 3]
        var raw = try Mesh(points, [4], [0, 1, 2, 3], display)
        defer raw.close()
        let snapshot = try raw.without_attribute("absent", 0)
        defer snapshot.release()
        let copy = try detached_mesh(snapshot)
        defer:
            copy.close()
            free(copy) in memory.heap
        let expected = 1.5 if raised else 2.0
        assert((try raw.ray_distance(origin, direction)) == expected)
        assert((try snapshot.value().ray_distance(origin, direction)) == expected)
        try copy.prepare_queries()
        assert((try copy.ray_distance(origin, direction)) == expected)
        let on_surface = Vector3(0.5, 0.5, 0.5 if raised else 0.0)
        assert((try copy.surface_distance(on_surface)) == 0.0)

pub func exercise() -> !:
    let previous = memory.heap
    var gate = Gate(upstream = previous)
    memory.heap = &gate
    defer restore(previous)
    var failures: usize = 0
    # Fail each allocation of the index build in turn until one build succeeds.
    var succeeded = false
    for stage in 0..<(usize)256:
        if try retry(&gate, stage): failures += 1
        else: succeeded = true
        ownership.collect()
        _ = ownership.finish_run(0)
        assert(gate.live == 0)
    assert(failures >= 4 and succeeded)
    for iteration in 0..<8:
        try concurrent()
        ownership.collect()
        _ = ownership.finish_run(0)
        assert(gate.live == 0)
    try display_surface()
    ownership.collect()
    _ = ownership.finish_run(0)
    assert(gate.live == 0)