Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-3d

Source of release 0.9.6

0.9.6 / src / renderers / gpu_arrays.lucb

## GPU copies of mesh arrays, keyed by the change ids of the arrays they were
## made from. Equal ids mean equal contents, so a mesh drawn again, a snapshot,
## or a moved mesh sharing its topology finds its buffers here and uploads only
## what changed: a Move re-uploads positions (8 MB for 700k points), not the
## whole mesh. A new version of an array (an edit, a new selection or hidden
## set) names the version it replaces, whose buffer is rewritten in place, so
## interaction keeps one buffer per array instead of one per state. Copies
## no frame has drawn for a while (an object left the scene) are dropped.
from luce_gpu import gpu
from luce_geocore.core.growing import Growing

## Frames an undrawn copy survives (a hidden object shown again keeps its
## buffers), and the bytes over which undrawn copies go at once.
let keep_frames: u64 = 64
let budget: usize = 1073741824

## What a buffer holds: the source array's id, which array (tag) and which
## chunk of it (part).
pub struct ArrayKey:
    pub var id: u64
    pub var tag: u8
    pub var part: u32

    ## Where the key's probe starts (its bits mixed so near ids spread).
    func spread() -> u64:
        let folded = (self.id ^ ((u64)self.tag << 56) ^ ((u64)self.part << 40)) *% 0x9E3779B97F4A7C15
        return folded ^ (folded >> 29)

## Curvature value kinds (MeshShading.curvature) whose automatic range a
## curvature copy keeps.
let range_kinds: usize = 5

struct Entry:
    var key: ArrayKey
    var buffer: gpu.Buffer
    var bytes: usize
    var used: u64
    ## A curvature copy's automatic ranges by value kind (0: not measured):
    ## derived from the same source, they live and go with it.
    var ranges: f64[5]

pub struct GpuArrays:
    var entries: Growing[Entry]
    ## Open-addressed index of `entries` by key: an entry's position + 1,
    ## 0 for an empty slot; at least twice as many slots as entries.
    var slots: Growing[u32]
    var scratch: Growing[u8]
    var device: gpu.Device
    var frame: u64
    ## Uploads and bytes so far, for tests and benchmarks.
    pub var uploads: u64
    pub var uploaded: u64

    pub func init():
        self.entries = Growing[Entry]()
        self.slots = Growing[u32]()
        self.scratch = Growing[u8]()
        self.device = gpu.Device()
        self.frame = 0
        self.uploads = 0
        self.uploaded = 0

    ## Start a frame on `device`; a different device drops every copy.
    pub func begin(device: gpu.Device) -> !:
        if self.device.is_open() and not self.device.same(&device):
            self.clear()
        if not self.device.is_open():
            self.device = try device.share()
        self.frame += 1

    ## Whether a frame has named the device the copies live on; and a share
    ## of it (the caller releases it).
    pub func has_device() -> bool:
        return self.device.is_open()

    pub func device_handle() -> gpu.Device:
        return self.device

    ## The copy of `key`, marked used this frame.
    pub func find(key: ArrayKey) -> gpu.Buffer?:
        let at = self.locate(key) else return none
        let entry = &self.entries.items[at]
        entry.used = self.frame
        return entry.buffer

    ## The automatic curvature range of value `kind` remembered with the
    ## copy of `key`, or none.
    pub func range(key: ArrayKey, kind: i64) -> f64?:
        let at = self.locate(key) else return none
        if kind < 0 or (usize)kind >= range_kinds: return none
        let value = self.entries.items[at].ranges[(usize)kind]
        return value if value > 0.0 else none

    ## Remember `value` as the copy of `key`'s range of value `kind`.
    pub func remember_range(key: ArrayKey, kind: i64, value: f64):
        let at = self.locate(key) else return
        if kind >= 0 and (usize)kind < range_kinds: self.entries.items[at].ranges[(usize)kind] = value

    ## Room to pack `bytes` bytes before `store`; reused between arrays.
    pub func staging(bytes: usize) -> u8[]!:
        try self.scratch.reserve(bytes)
        return self.scratch.items[..<bytes]

    ## Rewrite bytes `offset`.. of the copy of `parent` (same tag and part,
    ## `total` bytes, unused this frame) with `data` and rename it `key`: a
    ## local edit uploads its neighbourhood. None when there is no such copy.
    pub func patch(key: ArrayKey, parent: u64, total: usize, offset: usize, data: const u8[]) -> gpu.Buffer?!:
        let at = self.replaceable(key, parent, total) else return none
        if data.length > 0: try self.entries.items[at].buffer.upload(offset, data)
        self.uploads += 1
        self.uploaded += (u64)data.length
        self.rename(at, key)
        return self.entries.items[at].buffer

    ## Upload `data` as the copy of `key`. When the copy of `parent` (the
    ## version `key`'s replaces) has the same size and no draw of this frame
    ## reads it, it is rewritten in place: the device orders the copy after
    ## earlier frames, which keep the old contents.
    pub func store(key: ArrayKey, data: const u8[], parent: u64 = 0) -> gpu.Buffer!:
        self.uploads += 1
        self.uploaded += (u64)data.length
        if let at = self.replaceable(key, parent, data.length):
            try self.entries.items[at].buffer.upload(0, data)
            self.rename(at, key)
            return self.entries.items[at].buffer
        let buffer = try gpu.Buffer.create(self.device, data)
        self.entries.push(Entry(key, buffer, data.length, self.frame, [0.0, 0.0, 0.0, 0.0, 0.0])) catch failure:
            var created = buffer
            created.destroy()
            error(failure.code, failure.message)
        self.index(self.entries.count - 1) catch failure:
            self.entries.count -= 1
            var created = buffer
            created.destroy()
            error(failure.code, failure.message)
        return buffer

    ## Drop copies undrawn for `keep_frames` frames, or undrawn this frame
    ## when the copies exceed the budget.
    pub func trim():
        var total: usize = 0
        for entry in self.entries.view(): total += entry.bytes
        var kept: usize = 0
        for at in 0..<self.entries.count:
            var entry = self.entries.items[at]
            let stale = entry.used + keep_frames < self.frame or (total > budget and entry.used != self.frame)
            if stale:
                total -= entry.bytes
                entry.buffer.destroy()
                continue
            self.entries.items[kept] = entry
            kept += 1
        if kept == self.entries.count: return
        self.entries.count = kept
        self.reindex()

    ## Buffers held.
    pub func count() -> usize:
        return self.entries.count

    pub func clear():
        for at in 0..<self.entries.count: self.entries.items[at].buffer.destroy()
        self.entries.clear()
        self.reindex()
        self.device.destroy()

    pub func close():
        self.clear()
        self.entries.close()
        self.slots.close()
        self.scratch.close()

    # mark: The index

    ## The entry of the copy of `parent` that `key`'s version may take over:
    ## same tag, part and size, and not read by a draw of this frame.
    func replaceable(key: ArrayKey, parent: u64, bytes: usize) -> usize?:
        if parent == 0 or parent == key.id: return none
        let at = self.locate(ArrayKey(parent, key.tag, key.part)) else return none
        let entry = &self.entries.items[at]
        if entry.bytes != bytes or entry.used == self.frame: return none
        return at

    ## Entry `at` now holds `key`'s contents: renamed and marked used.
    func rename(at: usize, key: ArrayKey):
        self.unindex(self.entries.items[at].key)
        let entry = &self.entries.items[at]
        entry.key = key
        entry.used = self.frame
        entry.ranges = [0.0, 0.0, 0.0, 0.0, 0.0]
        # The slot freed above makes room: no growth is needed.
        self.place(at)

    func locate(key: ArrayKey) -> usize?:
        if self.slots.count == 0: return none
        let mask = self.slots.count - 1
        var slot = (usize)key.spread() & mask
        while self.slots.items[slot] != 0:
            let at = (usize)self.slots.items[slot] - 1
            if self.entries.items[at].key == key: return at
            slot = (slot + 1) & mask
        return none

    ## Index entry `at`, doubling the table first when it would pass half full.
    func index(at: usize) -> !:
        if self.entries.count * 2 > self.slots.count:
            try self.slots.fill(64 if self.slots.count == 0 else self.slots.count * 2, 0)
            for earlier in 0..<self.entries.count: self.place(earlier)
            return
        self.place(at)

    func place(at: usize):
        let mask = self.slots.count - 1
        var slot = (usize)self.entries.items[at].key.spread() & mask
        while self.slots.items[slot] != 0: slot = (slot + 1) & mask
        self.slots.items[slot] = (u32)(at + 1)

    ## Remove `key`'s slot, moving later members of its probe run back so
    ## lookups need no tombstones.
    func unindex(key: ArrayKey):
        let at = self.locate(key) else return
        let mask = self.slots.count - 1
        var hole = (usize)key.spread() & mask
        while (usize)self.slots.items[hole] != at + 1: hole = (hole + 1) & mask
        var next = (hole + 1) & mask
        while self.slots.items[next] != 0:
            let home = (usize)self.entries.items[(usize)self.slots.items[next] - 1].key.spread() & mask
            # It may fill the hole unless its home lies cyclically in (hole, next].
            let stays = (home > hole and home <= next) if hole <= next else (home > hole or home <= next)
            if not stays:
                self.slots.items[hole] = self.slots.items[next]
                hole = next
            next = (next + 1) & mask
        self.slots.items[hole] = 0

    func reindex():
        for at in 0..<self.slots.count: self.slots.items[at] = 0
        for at in 0..<self.entries.count: self.place(at)