dymokomi/luce-3d
Source of release 0.9.3
0.9.3 / tests / bench / bench.lucb
## The geometry-core benchmark (docs/BENCHMARKS.md): every operation the
## design's targets name, on the 700k-face grid. Build with --native --opt 2;
## tests/bench/run.py does, and prints the table against the targets.
import memory
import time
import interop
from luce_gpu import gpu
from luce_3d import graphics as three
from luce_std import parallel
from luce_geocore.geocore import Vector3, Mesh, mesh_type, detached_mesh
from luce_3d.graphics import EditOverlay
from fixtures import Counter, GridArrays, make_mesh, chosen_faces, face_points, since, report, report_bytes, side
from display import Viewport
func restore(previous: memory.Allocator):
memory.heap = previous
pub func main(arguments: str[]) -> i32!:
var grid = try GridArrays()
defer grid.close()
# Start the pool first: its starting threads free blocks in the current heap.
parallel.warm()
let previous = memory.heap
var counter = Counter(previous)
memory.heap = &counter
defer restore(previous)
var start = time.now()
let mesh = try make_mesh(&grid)
defer mesh.release()
report("construct", since(start))
report_bytes("mesh core", counter.live)
let m = mesh.value()
print(f"# grid: {m.point_count()} points, {m.face_count()} faces, {m.vertex_count()} corners, {(try m.edge_count())} edges, {m.index_count() // 3} triangles")
try baselines(&grid)
try attributes(mesh, &counter)
let faces = try chosen_faces()
defer free(faces) in memory.heap
let points = try face_points(m, faces)
defer free(points) in memory.heap
try selection(mesh, faces)
try moves(mesh, points)
try queries(mesh, points)
try display(mesh, points)
return 0
## Primitive costs the design's budgets are derived from.
func baselines(grid: const GridArrays*) -> !:
let count = grid.points.length
var start = time.now()
let copy = try new Vector3[count] --- in memory.heap
defer free(copy) in memory.heap
memory.copy(copy, grid.points, count)
report("baseline: memcpy f64 positions", since(start))
start = time.now()
let packed = try new f32[count * 3] --- in memory.heap
defer free(packed) in memory.heap
for at in 0..<count:
packed[at * 3] = (f32)grid.points[at].x
packed[at * 3 + 1] = (f32)grid.points[at].y
packed[at * 3 + 2] = (f32)grid.points[at].z
report("baseline: pack f32x3 positions", since(start))
## Adding an attribute should cost that attribute alone, not every other one.
func attributes(mesh: interop.Reference[Mesh], counter: const Counter*) -> !:
let m = mesh.value()
let weights = try new f64[(usize)m.point_count()] --- in memory.heap
defer free(weights) in memory.heap
for at in 0..<weights.length: weights[at] = (f64)at
var start = time.now()
let weighted = try m.with_attribute("weight", 0, 1, weights)
defer weighted.release()
report("attribute add: point f64", since(start))
let uv = try new f64[(usize)m.vertex_count() * 2] --- in memory.heap
defer free(uv) in memory.heap
for at in 0..<uv.length: uv[at] = (f64)(at % 7) * 0.125
let before = counter.live
start = time.now()
let textured = try weighted.value().with_attribute("uv", 1, 2, uv)
defer textured.release()
report("attribute add: corner uv on a mesh with weight", since(start))
report_bytes("uv attribute", counter.live - before)
start = time.now()
let masked = try textured.value().with_attribute("mask", 2, 1, weights[..<(usize)m.face_count()])
defer masked.release()
report("attribute add: face on a mesh with uv + weight", since(start))
## Selecting 1k faces: the overlay's selection batch and the gizmo centre.
func selection(mesh: interop.Reference[Mesh], faces: const i64[]) -> !:
var overlay = EditOverlay()
defer overlay.close()
let start = time.now()
try overlay.update(mesh, 2, faces, -1)
_ = try EditOverlay.center(mesh, 2, faces)
report("select 1k faces (overlay + centre)", since(start))
## A Move of 1k faces (4k points), bare and with attributes, and the worker
## to UI hand-off of its result.
func moves(mesh: interop.Reference[Mesh], points: const i64[]) -> !:
let m = mesh.value()
let delta = Vector3(0.0, 0.1, 0.0)
var start = time.now()
let moved = try m.moved_points(points, delta)
defer moved.release()
report("move 1k faces: bare mesh", since(start))
let values = try new f64[(usize)m.vertex_count() * 2] --- in memory.heap
defer free(values) in memory.heap
for at in 0..<values.length: values[at] = (f64)(at % 5)
let uv = try m.with_attribute("uv", 1, 2, values)
defer uv.release()
let weighted = try uv.value().with_attribute("weight", 0, 1, values[..<(usize)m.point_count()])
defer weighted.release()
let masked = try weighted.value().with_attribute("mask", 2, 1, values[..<(usize)m.face_count()])
defer masked.release()
start = time.now()
let moved_rich = try masked.value().moved_points(points, delta)
defer moved_rich.release()
report("move 1k faces: mesh with uv + weight + mask", since(start))
start = time.now()
let handed = try detached_mesh(moved_rich)
report("worker to UI hand-off", since(start))
handed.close()
free(handed) in memory.heap
## CPU spatial queries: the BVH build, picks, and the index after a Move.
func queries(mesh: interop.Reference[Mesh], points: const i64[]) -> !:
let m = mesh.value()
var start = time.now()
try m.prepare_queries()
report("BVH build", since(start))
start = time.now()
var hits: i64 = 0
for at in 0..<1000:
let x = (f64)(at % 37) / 37.0 - 0.5
let z = (f64)(at % 41) / 41.0 - 0.5
hits += try m.ray_face(Vector3(x, 5.0, z), Vector3(0.0, -1.0, 0.0))
report("1000 BVH ray picks", since(start))
let moved = try m.moved_points(points, Vector3(0.0, 0.1, 0.0))
defer moved.release()
start = time.now()
try moved.value().prepare_queries()
report("BVH after a Move (rebuild or refit)", since(start))
assert(hits != 0)
## First display, a camera-only redraw, and the redraw of a moved mesh; the
## Move round trip adds the cook and hand-off measured the same way.
func display(mesh: interop.Reference[Mesh], points: const i64[]) -> !:
var view = Viewport() catch failure:
print(f"# display skipped: {failure.message}")
return
defer view.close()
try view.show(mesh)
report("display: first draw of a new mesh", try view.draw())
try view.orbit(0.1)
report("display: camera-only redraw", try view.draw())
let start = time.now()
let moved = try mesh.value().moved_points(points, Vector3(0.0, 0.1, 0.0))
defer moved.release()
let handed = try detached_mesh(moved)
let owner = try interop.Reference[Mesh].adopt(handed, mesh_type, memory.heap)
defer owner.release()
let cooked = since(start)
try view.show(owner)
let drawn = try view.draw()
report("display: redraw after a Move", drawn)
report("Move 1k faces round trip (cook + hand-off + display)", cooked + drawn)