Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.7

0.7.7 / tests / mesh / main.lucb

## luce-geocore's Base gate: every mesh check, with allocation failure
## injected at each stage and no allocation left live afterwards.
import c
import io
import memory
import os
import ownership
import sync
from luce_std import process
from luce_std import parallel as std_parallel
from luce_geocore.kernel import clear_group_cache
import polygon_checks
import scale_checks
import display_checks
import position_checks
import distance_checks
import partition_checks
import query_checks
import dissolve_checks
import attribute_checks
import precision_checks
import shading_checks
import set_checks
import group_language_checks
import verb_checks
import modeling_checks
import bevel_checks
import subdivision_checks
import curve_checks
import codec_checks
import field_checks
import sdf_edit_checks
import sketch_checks
import detail_checks
import scene_checks
import material_checks
import polydraw_checks
import select_checks
import select_rule_checks
import instance_checks
import g6_checks
import extrude_inset_checks
import cut_slide_checks
import face_tool_checks
import symmetry_checks
import fill_checks
import bridge_shape_checks
import subdivide_select_checks
import split_checks
import dissolve_tool_checks
import merge_checks
import sweep_checks
import knife_checks
import reduce_checks
import shape_checks
import large_face_checks
import contract_checks
import unit_checks
import primitive_checks
import retopology_checks
from luce_geocore.kernel import set_small_faces

## Counts live blocks and fails the allocation after `remaining` more.
## Kernels allocate on pool workers too, so it takes a lock.
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 but the bounded, process-wide group-bits cache
## (groups/cache.lucb: the last 16 evaluated groups), which is flushed first.
func settle(tracker: Tracker*):
    tracker.remaining = none
    clear_group_cache()
    ownership.collect()
    _ = ownership.finish_run(0)
    assert(tracker.live == 0)

## Fail each of the first `stages` allocations of `check` in turn; every
## failure must be memory.exhausted and leave nothing allocated.
func inject(tracker: Tracker*, stages: usize, check: func() -> unit!):
    for stage in 0..<stages:
        tracker.remaining = stage
        check() catch failure:
            assert(failure.code == memory.exhausted)
        settle(tracker)

## `--small-faces N`: faces of more than N corners take the heap path (see
## face_scratch), so every check runs it too.
func small_faces_argument(arguments: const str[]) -> usize?:
    for at in 0..<arguments.length:
        if arguments[at] != "--small-faces" or at + 1 >= arguments.length: continue
        var value: usize = 0
        for byte in arguments[at + 1].bytes:
            assert(byte >= 48 and byte <= 57, "--small-faces takes a number")
            value = value * 10 + (usize)(byte - 48)
        return value
    return none

## Every check once and, unless this is already a variant, again in a fresh process with
## nearly every face on the large-face (heap) path.
pub func main(arguments: str[]) -> i32!:
    let status = try checks(arguments)
    if status != 0 or arguments.length > 1: return status
    let program = try os.executable()
    var small: c.str[2] = ["--small-faces", "4"]
    try again(program, small[..<2], none)
    return 0

## Run this program again with `words` and `environment`, showing what it printed; fail
## unless it exits 0.
func again(program: str, words: const c.str[], environment: const c.str[]?) -> !:
    let ran = try process.run((c.str)program, words, "", environment)
    defer ran.release()
    try io.stdout().write(ran.value.output)
    if ran.value.exit_code != 0:
        try io.stderr().write(ran.value.error_output)
        error(failed_variant, "a variant run of the checks failed")

let failed_variant: ErrorCode = ErrorCode.package(9)

func checks(arguments: str[]) -> i32!:
    if let limit = small_faces_argument(arguments):
        set_small_faces(limit)
        print(f"small faces: at most {limit} corners")
    # Start the pool first: its starting threads free blocks in the current heap.
    std_parallel.warm()
    try query_checks.exercise()
    let previous = memory.heap
    var tracker = Tracker(previous, 0, none, sync.Mutex())
    memory.heap = &tracker
    defer restore(previous)
    inject(&tracker, 96, polygon_checks.exercise)
    try polygon_checks.exercise()
    inject(&tracker, 192, dissolve_checks.allocations)
    try dissolve_checks.exercise()
    try partition_checks.exercise()
    settle(&tracker)
    inject(&tracker, 96, partition_checks.single)
    try scale_checks.exercise()
    distance_checks.exercise()
    settle(&tracker)
    inject(&tracker, 256, display_checks.exercise)
    try display_checks.exercise()
    inject(&tracker, 128, position_checks.exercise)
    try position_checks.exercise()
    settle(&tracker)
    inject(&tracker, 160, attribute_checks.exercise)
    try attribute_checks.exercise()
    settle(&tracker)
    inject(&tracker, 160, precision_checks.exercise)
    try precision_checks.exercise()
    settle(&tracker)
    inject(&tracker, 96, shading_checks.exercise)
    try shading_checks.exercise()
    settle(&tracker)
    inject(&tracker, 400, set_checks.exercise)
    try set_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, group_language_checks.exercise)
    try group_language_checks.exercise()
    settle(&tracker)
    inject(&tracker, 400, verb_checks.exercise)
    try verb_checks.exercise()
    settle(&tracker)
    inject(&tracker, 400, modeling_checks.exercise)
    try modeling_checks.exercise()
    settle(&tracker)
    inject(&tracker, 400, bevel_checks.exercise)
    try bevel_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, g6_checks.exercise)
    try g6_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, extrude_inset_checks.exercise)
    try extrude_inset_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, cut_slide_checks.exercise)
    try cut_slide_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, face_tool_checks.exercise)
    try face_tool_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, symmetry_checks.exercise)
    try symmetry_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, fill_checks.exercise)
    try fill_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, bridge_shape_checks.exercise)
    try bridge_shape_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, split_checks.exercise)
    try split_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, dissolve_tool_checks.exercise)
    try dissolve_tool_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, merge_checks.exercise)
    try merge_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, sweep_checks.exercise)
    try sweep_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, knife_checks.exercise)
    try knife_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, reduce_checks.exercise)
    try reduce_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, shape_checks.exercise)
    try shape_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, subdivide_select_checks.exercise)
    try subdivide_select_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, subdivision_checks.exercise)
    try subdivision_checks.exercise()
    settle(&tracker)
    inject(&tracker, 700, curve_checks.exercise)
    try curve_checks.run()
    settle(&tracker)
    inject(&tracker, 400, codec_checks.exercise)
    try codec_checks.exercise()
    settle(&tracker)
    inject(&tracker, 200, instance_checks.exercise)
    try instance_checks.exercise()
    settle(&tracker)
    inject(&tracker, 500, field_checks.allocations)
    try field_checks.allocations()
    settle(&tracker)
    try field_checks.run()
    settle(&tracker)
    inject(&tracker, 300, sdf_edit_checks.exercise)
    try sdf_edit_checks.run()
    settle(&tracker)
    inject(&tracker, 300, polydraw_checks.exercise)
    try polydraw_checks.run()
    settle(&tracker)
    inject(&tracker, 200, select_checks.exercise)
    try select_checks.run()
    settle(&tracker)
    inject(&tracker, 300, select_rule_checks.exercise)
    try select_rule_checks.run()
    settle(&tracker)
    inject(&tracker, 200, detail_checks.exercise)
    try detail_checks.run()
    settle(&tracker)
    inject(&tracker, 200, scene_checks.exercise)
    try scene_checks.run()
    settle(&tracker)
    inject(&tracker, 300, material_checks.exercise)
    try material_checks.run()
    settle(&tracker)
    inject(&tracker, 400, sketch_checks.exercise)
    try sketch_checks.run()
    settle(&tracker)
    inject(&tracker, 300, large_face_checks.exercise)
    try large_face_checks.run()
    settle(&tracker)
    inject(&tracker, 300, contract_checks.exercise)
    try contract_checks.run()
    settle(&tracker)
    inject(&tracker, 200, unit_checks.exercise)
    try unit_checks.run()
    settle(&tracker)
    inject(&tracker, 300, primitive_checks.exercise)
    try primitive_checks.exercise()
    settle(&tracker)
    inject(&tracker, 300, retopology_checks.exercise)
    try retopology_checks.exercise()
    settle(&tracker)
    print("ok polygon meshes, operators, queries and allocation failures")
    return 0