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