Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-ply

Source of release 0.1.0

0.1.0 / tests / ply / main.lucb

## luce-ply's checks: generic PLY in every format, splats, and allocation
## failures. Every check must free everything it allocated, and an
## allocation failing anywhere must surface as memory.exhausted with nothing
## left allocated.
import c
import os
import memory
import sync
from luce_std import parallel, files
import format_checks
import splat_checks

## Counts live blocks and fails the allocation after `remaining` more.
struct Tracker: memory.Allocator:
    var upstream: memory.Allocator
    var live: usize
    var remaining: usize?
    var lock: sync.Mutex

    pub func allocate(size: usize, alignment: usize) -> u8[]?:
        if size == 0: return self.upstream.allocate(size, alignment)
        self.lock.lock()
        defer self.lock.unlock()
        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:
        return self.upstream.resize(block, size)

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

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

## Nothing may stay live after a check.
func settle(tracker: Tracker*, what: str):
    tracker.remaining = none
    if tracker.live != 0: print(f"{tracker.live} blocks still live after {what}")
    assert(tracker.live == 0)

## Fail each allocation of `check` in turn, until it runs through.
func inject(tracker: Tracker*, check: func() -> unit!, what: str):
    for stage in 0..<(usize)1000000:
        tracker.remaining = stage
        var failed = false
        check() catch failure:
            if failure.code != memory.exhausted: print(f"{what}: allocation {stage} failing gave: {failure.message}")
            assert(failure.code == memory.exhausted)
            failed = true
        if tracker.live != 0: print(f"{what}: allocation {stage} failing leaks")
        settle(tracker, what)
        if not failed: return

pub func main(arguments: str[]) -> i32!:
    _ = arguments
    if let here = os.env("LUC_TEST_DIR"):
        try os.change_dir((c.str)here)
    # Start the pool first: its starting threads free blocks in the current heap.
    parallel.warm()
    let previous = memory.heap
    var tracker = Tracker(previous, 0, none, sync.Mutex())
    memory.heap = &tracker
    defer restore(previous)
    try format_checks.meshes()
    settle(&tracker, "meshes")
    try format_checks.clouds()
    settle(&tracker, "clouds")
    try format_checks.malformed()
    settle(&tracker, "malformed files")
    try splat_checks.round_trips()
    settle(&tracker, "splat round trips")
    try splat_checks.interleaving()
    settle(&tracker, "f_rest interleaving")
    try splat_checks.compressed()
    settle(&tracker, "compressed PLY")
    inject(&tracker, format_checks.meshes, "meshes")
    inject(&tracker, format_checks.clouds, "clouds")
    inject(&tracker, splat_checks.interleaving, "f_rest interleaving")
    inject(&tracker, splat_checks.compressed, "compressed PLY")
    restore(previous)
    var scratch = try files.create_temporary_directory(".")
    defer scratch.release()
    try splat_checks.timings(scratch.value)
    try files.remove_directory((c.str)scratch.value)
    print("PASS luce-ply checks")
    return 0