dymokomi/luce-canvas
Source of release 0.5.1
0.5.1 / src / tiles / residency_tests.lucb
#==============================================================================================
#
# tiles/residency_tests - Tiers and the governor
#
#==============================================================================================
## A 1024 by 512 layer (4 by 2 cells) whose every pixel differs: red and green
## from the position, blue from `seed`, alpha opaque.
func distinct_layer(device: gpu.Device, seed: f32) -> Tiles!:
var tiles = try Tiles.create(device, 1024, 512)
errdefer tiles.destroy()
let count = (usize)1024 * 512 * 4
let pixels = try new f32[count] --- in memory.heap
defer free(pixels) in memory.heap
for y in 0..<(usize)512:
for x in 0..<(usize)1024:
let at = (y * 1024 + x) * 4
pixels[at] = (f32)x / 1024.0
pixels[at + 1] = (f32)y / 512.0
pixels[at + 2] = seed
pixels[at + 3] = 1.0
try tiles.write(pixels)
return tiles
## Every pixel of `tiles`, read back.
func read_all(tiles: const Tiles*) -> f32[]!:
let pixels = try new f32[(usize)tiles.width() * (usize)tiles.height() * 4] --- in memory.heap
errdefer free(pixels) in memory.heap
try tiles.read(pixels)
return pixels
func same_samples(a: const f32[], b: const f32[]) -> bool:
if a.length != b.length:
return false
for index in 0..<a.length:
if a[index] != b[index]:
return false
return true
## How many of `tiles`' tiles are on the GPU.
func gpu_count(tiles: const Tiles*) -> usize:
var count: usize = 0
for cell in tiles.cells:
if let tile = cell:
if tile.on_gpu:
count += 1
return count
test "a tile moved to RAM reads the same, from RAM, and comes back to the GPU when drawn with":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var tiles = try distinct_layer(device, 0.25)
defer tiles.destroy()
let before = try read_all(&tiles)
defer free(before) in memory.heap
# A budget of one tile: settling moves the rest to RAM.
residency_budgets(tile_bytes, 0)
residency_advance()
let demoted = residency_report().demotions
try residency_settle(device)
assert(gpu_count(&tiles) <= 1 and residency_report().demotions > demoted)
# Reads come from the RAM copies, identical, and bring nothing back.
let after = try read_all(&tiles)
defer free(after) in memory.heap
assert(same_samples(before, after) and gpu_count(&tiles) <= 1)
# Drawing with a tile brings it back; its texels are the same.
let promoted = residency_report().promotions
let texture = (try tiles.texture(2, 1)) else trap("a painted cell")
assert(residency_report().promotions == promoted + 1 or gpu_count(&tiles) >= 1)
var texel: u8[8]
try texture.read(texel, gpu.Region(10, 20, 1, 1))
let red = from_half((u16)texel[0] | ((u16)texel[1] << 8))
let expected = before[((256 + 20) * 1024 + 512 + 10) * 4]
assert(red == from_half(to_half(expected)))
test "under a tiny budget the pixels stay exactly as they were, through edits and settling":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var first = try distinct_layer(device, 0.5)
defer first.destroy()
var second = try distinct_layer(device, 0.75)
defer second.destroy()
let one = try read_all(&first)
defer free(one) in memory.heap
let two = try read_all(&second)
defer free(two) in memory.heap
residency_budgets(tile_bytes * 3, 0)
for round in 0..<(usize)4:
residency_advance()
# Use a few tiles each round, as frames would, then settle.
_ = try first.texture((u32)(round % 4), 0)
_ = try second.texture((u32)(round % 4), 1)
try residency_settle(device)
# A copy made now shares the moved tiles and reads the same.
var copy = try first.clone()
defer copy.destroy()
let three = try read_all(©)
defer free(three) in memory.heap
let four = try read_all(&second)
defer free(four) in memory.heap
assert(same_samples(one, three) and same_samples(two, four))
test "when the device is out of memory, allocating moves unpinned tiles to RAM and succeeds":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_fail_allocations(0)
var tiles = try distinct_layer(device, 0.125)
defer tiles.destroy()
let before = try read_all(&tiles)
defer free(before) in memory.heap
residency_advance()
# An allocation fails as if the device were full: the tiles move to RAM
# (nothing was used this epoch), and the next try gets its texture.
let demoted = residency_report().demotions
residency_fail_allocations(1)
var texture = try tile_texture(device)
texture.destroy()
assert(residency_report().demotions > demoted and gpu_count(&tiles) == 0)
let after = try read_all(&tiles)
defer free(after) in memory.heap
assert(same_samples(before, after))
# A tile handed out this epoch is pinned: a shortage moves others, not it.
var spare = try distinct_layer(device, 0.875)
defer spare.destroy()
residency_advance()
_ = try tiles.texture(1, 1)
residency_fail_allocations(1)
var again = try tile_texture(device)
again.destroy()
assert((tiles.tile(1, 1) else trap("a tile")).on_gpu and gpu_count(&spare) == 0)
# With nothing left to move, a shortage is an error.
residency_advance()
for row in 0..<tiles.rows():
for column in 0..<tiles.columns():
_ = try tiles.texture(column, row)
residency_fail_allocations(20)
assert(try out_of_memory_now(device))
## Whether allocating a tile now fails with out_of_memory.
func out_of_memory_now(device: gpu.Device) -> bool!:
var texture = tile_texture(device) catch failure:
return failure.code == gpu.out_of_memory
texture.destroy()
return false
test "tiles only history holds leave the GPU before the tiles a document shows":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var shown = try distinct_layer(device, 0.3)
defer shown.destroy()
var history = try distinct_layer(device, 0.6)
defer history.destroy()
# Room for the shown layer's 8 tiles and a few more.
residency_budgets(tile_bytes * 12, 0)
residency_advance()
residency_begin_marking()
residency_mark_live(&shown)
try residency_settle(device)
assert(gpu_count(&shown) == 8 and gpu_count(&history) < 8)
test "a tile drawn into in place lets its warm RAM copy go, so reads see the new pixels":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
# Room in RAM: reading keeps warm copies of what it reads.
residency_budgets(0, (usize)1 << 30)
var tiles = try distinct_layer(device, 0.5)
defer tiles.destroy()
let first = try read_all(&tiles)
defer free(first) in memory.heap
let tile = tiles.tile(1, 0) else trap("a painted cell")
assert(tile.ram.length > 0)
# Draw into the cell's texture in place: every texel half-transparent black.
let texture = (try tiles.texture(1, 0)) else trap("a painted cell")
let texels = try new u8[(usize)tile_size * (usize)tile_size * 8] --- in memory.heap
defer free(texels) in memory.heap
for at in 0..<texels.length // 8:
let alpha = to_half(0.5)
for byte in 0..<(usize)6:
texels[at * 8 + byte] = 0
texels[at * 8 + 6] = (u8)(alpha & 0xff)
texels[at * 8 + 7] = (u8)(alpha >> 8)
try texture.upload(texels)
try tiles.redrawn(1, 0)
assert(tile.ram.length == 0)
let second = try read_all(&tiles)
defer free(second) in memory.heap
let inside = ((10 * 1024) + 256 + 10) * 4
assert(second[inside] == 0.0 and second[inside + 3] == 0.5)
# The other cells still read as before.
assert(second[(10 * 1024 + 10) * 4] == first[(10 * 1024 + 10) * 4])
test "past the RAM budget tiles go to the scratch file and read back the same":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var tiles = try distinct_layer(device, 0.5)
defer tiles.destroy()
let before = try read_all(&tiles)
defer free(before) in memory.heap
# One tile's worth of GPU and two of RAM: settling moves the rest down twice.
residency_budgets(tile_bytes, tile_bytes * 2)
residency_advance()
let spilled = residency_report().spills
try residency_settle(device)
assert(ram_tile_bytes <= tile_bytes * 2 and residency_report().spills > spilled and disk_tile_bytes > 0)
# Reads bring disk tiles back through RAM, identical.
let after = try read_all(&tiles)
defer free(after) in memory.heap
assert(same_samples(before, after) and residency_report().loads > 0)
# Settling again keeps RAM in its budget; slots are kept, so nothing is written again.
residency_advance()
let written = disk_tile_bytes
try residency_settle(device)
assert(ram_tile_bytes <= tile_bytes * 2 and disk_tile_bytes == written)
# A tile drawn with comes back to the GPU from its slot.
let texture = (try tiles.texture(3, 1)) else trap("a painted cell")
var texel: u8[8]
try texture.read(texel, gpu.Region(5, 7, 1, 1))
let green = from_half((u16)texel[2] | ((u16)texel[3] << 8))
assert(green == from_half(to_half(before[((256 + 7) * 1024 + 768 + 5) * 4 + 1])))
test "the tiles' slots are freed with them and used again":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
residency_budgets(tile_bytes, tile_bytes)
var first = try distinct_layer(device, 0.1)
residency_advance()
try residency_settle(device)
let held = disk_tile_bytes
assert(held > 0)
first.destroy()
assert(disk_tile_bytes == held - held)
let end = scratch_end
var second = try distinct_layer(device, 0.9)
defer second.destroy()
residency_advance()
try residency_settle(device)
# The second layer fits in the slots the first gave back.
assert(scratch_end == end and disk_tile_bytes > 0)
test "an epoch lasts a frame: draws into one frame share it, and a frame inside another leaves it":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
var outer_texture = try gpu.Texture.create(device, 8, 8, gpu.Format.rgba8_linear)
defer outer_texture.destroy()
var inner_texture = try gpu.Texture.create(device, 8, 8, gpu.Format.rgba8_linear)
defer inner_texture.destroy()
let before = residency_epoch
let outer = try outer_texture.frame()
let target = try outer.value().target()
let serial = target.value().frame_serial()
assert(residency_frame(serial) and residency_epoch == before + 1)
assert(not residency_frame(serial) and residency_epoch == before + 1)
let inner = try inner_texture.frame()
let inner_target = try inner.value().target()
assert(not residency_frame(inner_target.value().frame_serial()) and residency_epoch == before + 1)
inner_target.release()
_ = try inner.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
inner.release()
target.release()
_ = try outer.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
outer.release()
let next = try outer_texture.frame()
let next_target = try next.value().target()
assert(residency_frame(next_target.value().frame_serial()) and residency_epoch == before + 2)
next_target.release()
_ = try next.value().present(gpu.Color(0.0, 0.0, 0.0, 0.0))
next.release()
test "a tile from the scratch file drawn into in place lets its slot go, so it never reloads the old pixels":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var tiles = try distinct_layer(device, 0.5)
defer tiles.destroy()
# Down to the scratch file, then back to the GPU to be drawn into.
residency_budgets(tile_bytes, tile_bytes)
residency_advance()
try residency_settle(device)
let texture = (try tiles.texture(2, 0)) else trap("a painted cell")
let tile = tiles.tile(2, 0) else trap("a painted cell")
assert(tile.disk >= 0)
let texels = try new u8[(usize)tile_size * (usize)tile_size * 8] --- in memory.heap
defer free(texels) in memory.heap
for index in 0..<texels.length:
texels[index] = 0
try texture.upload(texels)
try tiles.redrawn(2, 0)
assert(tile.disk < 0 and tile.ram.length == 0)
# Moved down again and read, it is the new content: clear.
residency_advance()
try residency_settle(device)
let after = try read_all(&tiles)
defer free(after) in memory.heap
assert(after[((10 * 1024) + 512 + 10) * 4 + 3] == 0.0)
test "the process's memory is told where the system can tell it, and never past the machine's":
let held = process_memory()
if platform.macos or platform.windows or platform.linux:
assert(held > 0)
let machine = physical_memory()
if machine > 0:
assert((u64)held <= machine)
assert(residency_report().process >= held // 2)
## A test source's decode: its records are raw tile rows.
func decode_raw(context: void*?, packed: const u8[], rows: u32, into: u8[]) -> !:
_ = context
let bytes = (usize)rows * (usize)tile_size * 8
if packed.length < bytes:
error(invalid, "a raw record is short")
memory.copy(into, packed, bytes)
## Where `write_raw`'s visitor puts each cell: the file and each cell's offset.
struct RawSink:
var file: files.File*
var offsets: u64[]
var at: usize
var written: u64
func write_raw(context: void*?, cell: Cell, bytes: const u8[]) -> !:
_ = cell
let sink = (RawSink*)(context else return)
sink.offsets[sink.at] = sink.written
sink.at += 1
var done: usize = 0
while done < bytes.length:
done += try sink.file.write(bytes[done..])
sink.written += (u64)bytes.length
test "tiles backed by a document file leave the GPU and RAM without being written, and come back the same":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var tiles = try distinct_layer(device, 0.75)
defer tiles.destroy()
let before = try read_all(&tiles)
defer free(before) in memory.heap
# The layer's cells, raw, in a file of their own.
let folder = try files.create_temporary_directory((c.str)temporary_root())
defer folder.release()
let path = try paths.join(folder.value, "backing.raw")
defer path.release()
var file = try files.File.open((c.str)path.value, files.OpenMode.replace)
var cells: Cell[8] = ---
for index in 0..<(usize)8:
cells[index] = Cell(column = (u32)(index % 4), row = (u32)(index // 4))
var sink = RawSink(file = &file, offsets = try new u64[8] --- in memory.heap, at = 0, written = 0)
defer free(sink.offsets) in memory.heap
try read_cells(&tiles, cells, (void*)&sink, write_raw, warm = false)
try file.close()
let source = try open_tile_source(path.value, none, decode_raw)
for index in 0..<(usize)8:
try back_cell(&tiles, cells[index].column, cells[index].row, source, sink.offsets[index], (u32)tile_bytes, tile_size)
assert(source.references == 9)
# One tile's worth of GPU and of RAM: the rest leave both, and nothing is written.
residency_budgets(tile_bytes, tile_bytes)
residency_advance()
let disk_before = disk_tile_bytes
try residency_settle(device)
assert(gpu_count(&tiles) <= 1 and disk_tile_bytes == disk_before)
# Reads bring them back from the file, identical.
let fetched = residency_report().fetches
let after = try read_all(&tiles)
defer free(after) in memory.heap
assert(same_samples(before, after) and residency_report().fetches > fetched and disk_tile_bytes == disk_before)
# Drawn into in place, a tile lets its backing go: the file no longer holds it.
let drawn = tiles.tile(1, 0) else trap("a painted cell")
_ = try tiles.texture(1, 0)
try tiles.redrawn(1, 0)
assert(drawn.source == none and source.references == 8)
release_tile_source(source)
try files.remove_tree((c.str)folder.value)
test "tiles on the scratch file freed after the scratch file is released do not upset the accounting":
var device = gpu.Device.open() catch failure:
assert(failure.code == gpu.unavailable)
return
defer device.destroy()
defer residency_budgets(0, 0)
var tiles = try distinct_layer(device, 0.5)
residency_budgets(tile_bytes, tile_bytes)
residency_advance()
try residency_settle(device)
assert(disk_tile_bytes > 0)
# A clean exit releases the scratch file while a document (an undo history)
# still holds tiles on it; they are freed afterwards.
release_scratch()
tiles.destroy()
assert(disk_tile_bytes == 0)