dymokomi/luce-geocore
Source of release 0.7.8
0.7.8 / src / verbs / face_batch.lucb
## Faces built apart from a TopologyBuilder, so a verb can make its faces in
## parallel: each range of its work fills its own batch, and
## `append_batches` adds the batches in order, all at once
## (every batch on its own thread), renumbering each batch's corner mixes
## after the ones before it. A face is copied whole from the source (its
## corners and triangles are its parent's; nothing is stored but its size)
## or drafted corner by corner.
pub struct FaceBatch:
## Per face: its parent, 1 when copied whole from it (0 drafted), and
## its corner count.
var parents: Growing[i32]
var copied: Growing[u8]
var sizes: Growing[i32]
## The drafted faces' corners, their parents (codes of `mix` below -1).
var corners: Growing[i32]
var corner_parents: Growing[i32]
var mix: Mix
## Every face's corners, copied ones included.
var corner_total: usize
## Where the face being drafted starts in `corners`.
var face_start: usize
pub func init():
self.parents = Growing[i32]()
self.copied = Growing[u8]()
self.sizes = Growing[i32]()
self.corners = Growing[i32]()
self.corner_parents = Growing[i32]()
self.mix = Mix()
self.corner_total = 0
self.face_start = 0
pub func close():
self.parents.close()
self.copied.close()
self.sizes.close()
self.corners.close()
self.corner_parents.close()
self.mix.close()
pub func face_count() -> usize:
return self.parents.count
## Source face `face` (of `offsets`) copied whole.
pub func copy_face(offsets: const i32[], face: usize) -> !:
let size = offsets[face + 1] - offsets[face]
try self.parents.push((i32)face)
try self.copied.push(1)
try self.sizes.push(size)
self.corner_total += (usize)size
## Start a drafted face whose parent is `parent`.
pub func face(parent: i32) -> !:
try self.parents.push(parent)
try self.copied.push(0)
self.face_start = self.corners.count
pub func corner(point: i32, parent: i32) -> !:
try self.corners.push(point)
try self.corner_parents.push(parent)
## A corner mix several corners share (TopologyBuilder.shared_mix); its
## code counts within this batch until the batch is appended.
pub func shared_mix(parents: const i32[], weights: const f32[]) -> i32!:
if self.mix.offsets.count == 0: try self.mix.offsets.push(0)
return try mix_entry(&self.mix, parents, weights)
pub func shared_corner(point: i32, mix: i32) -> !:
try self.corners.push(point)
try self.corner_parents.push(mix)
## Close the face begun last (at least 3 corners).
pub func end_face() -> !:
let size = self.corners.count - self.face_start
if size < 3: error(errors.invalid, "an operation made a face with fewer than 3 corners")
try self.sizes.push((i32)size)
self.corner_total += size
## Mix entries and their parents.
func mix_entries() -> usize:
return self.mix.offsets.count - 1 if self.mix.offsets.count > 0 else 0
## Where each batch lands in the builder's arrays.
struct BatchPlace:
var face: usize
var corner: usize
var mix_entry: usize
var mix_parent: usize
struct AppendWork:
var builder: TopologyBuilder*
var batches: const FaceBatch[]
var places: const BatchPlace[]
var source_offsets: const i32[]
var source_corners: const i32[]
## Add `batches` to `builder` in order (their copied faces are `source`'s),
## every batch on its own thread.
func append_batches(builder: TopologyBuilder*, source: const Mesh*, batches: const FaceBatch[]) -> !:
let places = try new BatchPlace[batches.length + 1] --- in memory.heap
defer free(places) in memory.heap
var place = BatchPlace(builder.face_parents.count, builder.corners.count, builder.corner_mix.offsets.count - 1, builder.corner_mix.parents.count)
for at in 0..<batches.length:
places[at] = place
place.face += batches[at].face_count()
place.corner += batches[at].corner_total
place.mix_entry += batches[at].mix_entries()
place.mix_parent += batches[at].mix.parents.count
places[batches.length] = place
try builder.offsets.reserve(place.face + 1)
try builder.face_parents.reserve(place.face)
try builder.copied.reserve(place.face)
try builder.corners.reserve(place.corner)
try builder.corner_parents.reserve(place.corner)
try builder.corner_mix.offsets.reserve(place.mix_entry + 1)
try builder.corner_mix.parents.reserve(place.mix_parent)
try builder.corner_mix.weights.reserve(place.mix_parent)
var work = AppendWork(builder, batches, places[..<batches.length + 1], source.offset_span(), source.corner_span())
try parallel.for_each(batches.length, (void*)&work, append_batch)
builder.offsets.count = place.face + 1
builder.face_parents.count = place.face
builder.copied.count = place.face
builder.corners.count = place.corner
builder.corner_parents.count = place.corner
builder.corner_mix.offsets.count = place.mix_entry + 1
builder.corner_mix.parents.count = place.mix_parent
builder.corner_mix.weights.count = place.mix_parent
func append_batch(context: void*, index: usize, worker: usize) -> !:
let work = (AppendWork*)context
let builder = work.builder
let batch = &work.batches[index]
let place = work.places[index]
# A batch's mix code -2 - e becomes -2 - (e + its first entry).
let shift = (i32)place.mix_entry
var corner = place.corner
var drafted: usize = 0
for face in 0..<batch.face_count():
let at = place.face + face
let parent = batch.parents.items[face]
let size = (usize)batch.sizes.items[face]
builder.face_parents.items[at] = parent
builder.copied.items[at] = batch.copied.items[face]
if batch.copied.items[face] != 0:
let first = (usize)work.source_offsets[(usize)parent]
memory.copy(builder.corners.items[corner..], work.source_corners[first..<first + size], size)
for k in 0..<size: builder.corner_parents.items[corner + k] = (i32)(first + k)
else:
memory.copy(builder.corners.items[corner..], batch.corners.items[drafted..<drafted + size], size)
for k in 0..<size:
let code = batch.corner_parents.items[drafted + k]
builder.corner_parents.items[corner + k] = code - shift if code <= -2 else code
drafted += size
corner += size
builder.offsets.items[at + 1] = (i32)corner
let entries = batch.mix_entries()
for entry in 0..<entries: builder.corner_mix.offsets.items[place.mix_entry + entry + 1] = batch.mix.offsets.items[entry + 1] + (i32)place.mix_parent
let parents = batch.mix.parents.count
if parents > 0:
memory.copy(builder.corner_mix.parents.items[place.mix_parent..], batch.mix.parents.view(), parents)
memory.copy(builder.corner_mix.weights.items[place.mix_parent..], batch.mix.weights.view(), parents)
## One verb's faces made in parallel by `batched_faces`.
struct BatchRun:
var batches: FaceBatch[]
var context: void*
var work: func(void*, usize, usize, FaceBatch*) -> unit!
var count: usize
var chunk: usize
func batch_piece(context: void*, index: usize, worker: usize) -> !:
let run = (BatchRun*)context
let first = index * run.chunk
let end = first + run.chunk if first + run.chunk < run.count else run.count
let work = run.work
try work(run.context, first, end, &run.batches[index])
## Faces made in parallel: 0..<count cut into ranges of `chunk`, `work`
## filling each range's batch on its own thread (its arguments: `context`,
## the range, the batch), the batches then added to `builder` in order, so
## the faces come out as one thread would make them.
func batched_faces(builder: TopologyBuilder*, source: const Mesh*, count: usize, chunk: usize, context: void*, work: func(void*, usize, usize, FaceBatch*) -> unit!) -> !:
if count == 0: return
let pieces = (count + chunk - 1) // chunk
let batches = try new FaceBatch[pieces] --- in memory.heap
for at in 0..<pieces: batches[at] = FaceBatch()
defer:
for at in 0..<pieces: batches[at].close()
free(batches) in memory.heap
var run = BatchRun(batches[..<pieces], context, work, count, chunk)
try parallel.for_each(pieces, (void*)&run, batch_piece)
try append_batches(builder, source, batches[..<pieces])