Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-usd

Source of release 0.9.4

0.9.4 / tests / checks / main.lucb

## luce-usd's Base gate: every module check in turn, under a heap that counts
## live blocks, so each check must free everything it allocated. `inject`
## fails a check's allocations one at a time: every failure must surface as
## memory.exhausted and leave nothing allocated.
import memory
import sync
from luce_std import parallel
import sniff_checks
import path_checks
import asset_checks
import value_checks
import number_checks
import usda_checks
import usdc_checks
import usdz_checks
import expression_checks
import geom_checks
import pcp_checks
import spline_checks
import array_edit_checks
import cad_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)

## Stages enough to fail every allocation of any check here.
let every: usize = 1000000

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

## Nothing may stay live after a check.
func settle(tracker: Tracker*, what: str = "a check"):
    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 (or for
## the first `stages` of them).
func inject(tracker: Tracker*, stages: usize, check: func() -> unit!):
    for stage in 0..<stages:
        tracker.remaining = stage
        var failed = false
        check() catch failure:
            assert(failure.code == memory.exhausted)
            failed = true
        if tracker.live != 0: print(f"allocation {stage} failing leaks")
        settle(tracker)
        if not failed: return

pub func main(arguments: str[]) -> i32!:
    # Start the pool first: its starting threads free blocks in the current heap.
    parallel.warm()
    try cad_checks.warm()
    let previous = memory.heap
    var tracker = Tracker(previous, 0, none, sync.Mutex())
    memory.heap = &tracker
    defer restore(previous)
    try sniff_checks.exercise()
    settle(&tracker, "sniff_checks")
    try path_checks.exercise()
    settle(&tracker, "path_checks")
    inject(&tracker, every, path_checks.allocations)
    try asset_checks.exercise()
    settle(&tracker, "asset_checks")
    try value_checks.exercise()
    settle(&tracker, "value_checks")
    inject(&tracker, every, value_checks.allocations)
    try number_checks.exercise()
    settle(&tracker, "number_checks")
    try usda_checks.exercise()
    settle(&tracker, "usda_checks")
    try usda_checks.round_trip()
    settle(&tracker, "usda round trip")
    try usda_checks.fixtures()
    settle(&tracker, "usda fixtures")
    try usda_checks.large_arrays()
    settle(&tracker, "usda large arrays")
    inject(&tracker, every, usda_checks.round_trip)
    inject(&tracker, every, usda_checks.fixtures)
    try usdc_checks.fixtures()
    settle(&tracker, "usdc fixtures")
    try usdc_checks.integers()
    settle(&tracker, "integer coding")
    try usdc_checks.damaged()
    settle(&tracker, "damaged crates")
    inject(&tracker, every, usdc_checks.values_fixture)
    inject(&tracker, every, usdc_checks.properties_fixture)
    inject(&tracker, every, usdc_checks.composition_fixture)
    inject(&tracker, every, usdc_checks.arrays_fixture)
    try usdc_checks.writes()
    settle(&tracker, "usdc writes")
    inject(&tracker, every, usdc_checks.writes)
    try spline_checks.evaluation()
    try spline_checks.loops_and_offsets()
    try spline_checks.round_trips()
    settle(&tracker, "splines")
    inject(&tracker, every, spline_checks.round_trips)
    try array_edit_checks.exercise()
    settle(&tracker, "array edits")
    try cad_checks.exercise()
    settle(&tracker, "CAD patches")
    memory.heap = previous
    try cad_checks.prepare()
    memory.heap = &tracker
    inject(&tracker, every, cad_checks.export_prepared)
    memory.heap = previous
    cad_checks.release_prepared()
    memory.heap = &tracker
    inject(&tracker, every, array_edit_checks.exercise)
    try usdz_checks.exercise()
    settle(&tracker, "usdz")
    inject(&tracker, every, usdz_checks.exercise)
    try geom_checks.transforms()
    settle(&tracker, "transforms")
    inject(&tracker, every, geom_checks.transforms)
    try geom_checks.imported()
    settle(&tracker, "import")
    inject(&tracker, every, geom_checks.imported)
    try geom_checks.mesh_features()
    try geom_checks.mesh_at_time()
    try geom_checks.mesh_units()
    settle(&tracker, "mesh import")
    inject(&tracker, every, geom_checks.mesh_features)
    try geom_checks.folded_faces()
    try geom_checks.scene_instances()
    inject(&tracker, every, geom_checks.scene_instances)
    inject(&tracker, every, geom_checks.folded_faces)
    try geom_checks.big_face()
    inject(&tracker, every, geom_checks.big_face)
    try geom_checks.shapes()
    settle(&tracker, "shapes")
    try geom_checks.curves_and_points()
    settle(&tracker, "curves")
    inject(&tracker, every, geom_checks.curves_and_points)
    try geom_checks.instancer()
    settle(&tracker, "instancer")
    inject(&tracker, every, geom_checks.instancer)
    try geom_checks.mesh_round_trip()
    try geom_checks.elements_round_trip()
    settle(&tracker, "round trips")
    inject(&tracker, every, geom_checks.mesh_round_trip)
    inject(&tracker, every, geom_checks.elements_round_trip)
    try splat_checks.fixture()
    try splat_checks.round_trips()
    try splat_checks.prims_and_halves()
    settle(&tracker, "splats")
    inject(&tracker, every, splat_checks.fixture)
    try pcp_checks.museum()
    settle(&tracker, "museum")
    inject(&tracker, every, pcp_checks.museum)
    try pcp_checks.flattened()
    settle(&tracker, "flattened")
    inject(&tracker, every, pcp_checks.flattened)
    try pcp_checks.builtins()
    inject(&tracker, every, pcp_checks.builtins)
    try expression_checks.expressions()
    inject(&tracker, every, expression_checks.expressions)
    memory.heap = previous
    try splat_checks.timing()
    return 0