Luce packages
LuceLuce BaseLuciaOS

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(&copy)
    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)