Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-geocore

Source of release 0.7.7

0.7.7 / tests / code / bench.lucb

## Whole cooks through the Code node over a 1M-point grid: the Stage 1 targets.
import interop
import time
from luce_geocore.geocore import GeometrySet
from luce_geocore import kernel as geocore_kernel
from luce_geocore.geocore import MeshPrimitives
import support
import voxels

func measure(name: str, body: str, target: f64) -> !:
    # A grid of 1M points with point normals (up), as an imported mesh has.
    let set = try support.run(try support.big_grid_set(1000), support.points_mode, "p.N = [0.0, 1.0, 0.0, 0.0]\n")
    _ = try support.run(set, support.points_mode, body)
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<5:
        let started = time.now()
        let made = try support.run_with(set, support.points_mode, "", body, "", support.no_names(), support.no_values())
        let spent = time.since(started)
        _ = made
        if spent < best: best = spent
    print(f"{name}\t{(f64)best / 1000000.0}\t{target}")

pub func run_all() -> !:
    try measure("wave", "p.P[1] += math32.sin(p.P[0] * 4.0) * 0.1\n", 10.0)
    try measure("noise displacement", "let amount = k.f32(\"amount\", 0.2)\nlet scale = k.f32(\"scale\", 3.0)\nlet n = snoise(p.P * scale + [0.0, 0.0, (f32)k.time, 0.0])\np.P = p.P + p.N * (n * amount)\n", 25.0)
    try measure("rand3", "p.Cd = rand3(p.ptnum)\n", 8.0)
    try measure("empty", "", 3.0)
    try measure("curlnoise", "p.P = p.P + curlnoise(p.P * 3.0) * 0.01\n", 0.0)
    try measure("wnoise", "let w = wnoise(p.P * 8.0)\np.Cd = [w.f1, w.f2, 0.0, 0.0]\n", 0.0)
    try measure("pcopen + pcfilter smoothing (20 points)", "p.P = k.input(0).pcopen(p.P, 0.006, 20).filter_vec3(\"P\")\n", 0.0)
    try measure("twist (a Mat3 per point)", "let m = Mat3.rotation(p.P[1] * 2.0, [0.0, 1.0, 0.0, 0.0])\np.P = m.transform(p.P)\n", 0.0)
    _ = geocore_kernel.code_compiles()
    try grid_build()
    try families()

## One timing of a whole cook (best of 5, after a warm one).
func time_cook(name: str, set: interop.Reference[GeometrySet], input1: interop.Reference[GeometrySet]?, mode: i64, body: str, count: i64, target: f64) -> !:
    _ = try support.run_inputs(set, input1, mode, body, count)
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<5:
        let started = time.now()
        let made = try support.run_inputs(set, input1, mode, body, count)
        let spent = time.since(started)
        _ = made
        if spent < best: best = spent
    print(f"{name}\t{(f64)best / 1000000.0}\t{target}")

## Stage 3 and 4 families over 1M points: nearpoints, xyzdist and add_point.
func families() -> !:
    let grid = try support.big_grid_set(1000)
    try time_cook("nearpoints smoothing (10 nearest)", grid, none, support.points_mode, "let near = k.input(0).nearpoints(p.P, 0.0045, 10)\nvar sum: f32[4] = [0.0, 0.0, 0.0, 0.0]\nfor i in 0..<near.count:\n    sum = sum + k.input(0).point_P(near.points[i])\np.P = sum * (1.0 / (f32)near.count)\n", 0, 80.0)
    let target = try support.run(try support.big_grid_set(225), support.points_mode, "p.P[1] = 0.25 + 0.1 * math32.sin(p.P[0] * 6.0)\n")
    let near = try support.run(try support.big_grid_set(225), support.points_mode, "p.P[1] = 0.01 * math32.sin(p.P[0] * 6.0 + p.P[2] * 4.0)\n")
    try time_cook("xyzdist to 100k triangles, near the surface", grid, near, support.points_mode, "p.Cd = [k.input(1).xyzdist(p.P), 0.0, 0.0, 0.0]\n", 0, 120.0)
    try time_cook("xyzdist to 100k triangles, 0.15-0.35 away (stress)", grid, target, support.points_mode, "p.Cd = [k.input(1).xyzdist(p.P), 0.0, 0.0, 0.0]\n", 0, 120.0)
    let ball = try support.closed_sphere(142, 71)
    try time_cook("windingnumber against a 10,082-face sphere", grid, ball, support.points_mode, "p.Cd = [k.input(1).windingnumber(p.P + [0.0, 1.0, 0.0, 0.0]), 0.0, 0.0, 0.0]\n", 0, 0.0)
    try time_cook("remove_point of half of 1M", grid, none, support.points_mode, "if p.ptnum % 2 == 0: k.remove_point(p.ptnum)\n", 0, 20.0)
    try time_cook("set_point_f32 x 1M (scattered)", grid, none, support.points_mode, "k.set_point_f32((p.ptnum * 7) % 1000000, \"mass\", 1.0)\n", 0, 0.0)
    let arrays = try support.run(grid, support.points_mode, "p.set_f32_array(\"w\", k.floats().append(1.0).append(2.0).append(3.0).append((f32)p.ptnum))\n")
    try time_cook("set_f32_array, 4 items x 1M", grid, none, support.points_mode, "p.set_f32_array(\"w\", k.floats().append(1.0).append(2.0).append(3.0).append((f32)p.ptnum))\n", 0, 0.0)
    try time_cook("f32_array, 4 items x 1M (summed)", arrays, none, support.points_mode, "let a = p.f32_array(\"w\")\nvar sum: f32 = 0.0\nfor i in 0..<a.len():\n    sum += a.at(i)\np.P[1] = sum * 0.001\n", 0, 0.0)
    try voxel_bench()
    try time_cook("add_point x 1M (Numbers)", try support.empty_set(), none, support.numbers_mode, "_ = k.add_point([(f32)n * 0.001, 0.0, 0.0, 0.0])\n", 1000000, 60.0)

## MeshPrimitives.grid at its largest: 2048 divisions, 4.2M points.
pub func grid_build() -> !:
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<3:
        let started = time.now()
        let grid = try MeshPrimitives.grid(2.0, 2048)
        let spent = time.since(started)
        if (try grid.get()).point_count() != 2049 * 2049: trap("grid size")
        if spent < best: best = spent
    print(f"grid 2048\t{(f64)best / 1000000.0}\t0")

## 128^3 dense voxels (16^3 leaves) given a noise density by Run Over Voxels.
func voxel_bench() -> !:
    let box = try voxels.volume(try support.empty_set(), "density", 0.0, 6.35, 12.7, 0.1, true)
    let body = "x.value = max(noise(x.P * 0.7) - 0.4, 0.0)\n"
    _ = try voxels.voxel_run(box, "density", body)
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<5:
        let started = time.now()
        _ = try voxels.voxel_run(box, "density", body)
        let spent = time.since(started)
        if spent < best: best = spent
    print(f"voxels 128^3 dense, noise density\t{(f64)best / 1000000.0}\t0")