Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-image

Source of release 0.45.1

0.45.1 / src / canvas / memory_tests.lucb

#==============================================================================================
#
#   canvas/memory_tests - The document under a memory budget
#
#==============================================================================================

## The document drawn at `zoom` into `target` (a frame's settling included),
## and every texel of it read back.
func frame_pixels(canvas: Canvas*, target: gpu.Texture*, zoom: f64, x: f64, y: f64, into: u8[]) -> !:
    try canvas.wait_idle()
    let frame = try target.frame()
    defer frame.release()
    let root = try frame.value().target()
    defer root.release()
    try canvas.draw(root, gpu.Rect(width = 256.0, height = 192.0), zoom, x, y)
    _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(into)

test "under a tiny memory budget the document draws, strokes, undoes and exports exactly as without one":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1500, 1100)
    defer canvas.close()
    defer residency_budgets(0, 0)
    let first = try canvas.add_layer("First")
    let second = try canvas.add_layer("Second")
    var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
    defer target.destroy()
    let fit = 256.0 / 1500.0
    var reference_fit: u8[196608]
    var reference_near: u8[196608]
    var seen: u8[196608]
    try frame_pixels(&canvas, &target, fit, 0.0, 0.0, reference_fit)
    try canvas.fill_gradient(first, 0.0, 0.0, 1500.0, 1100.0, 1.0, 0.2, 0.1, 1.0, 0.1, 0.3, 0.9, 1.0)
    try canvas.fill_gradient(second, 750.0, 550.0, 1300.0, 900.0, 0.9, 0.9, 0.2, 0.8, 0.2, 0.9, 0.4, 0.3, radial = true)
    try frame_pixels(&canvas, &target, fit, 0.0, 0.0, reference_fit)
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, reference_near)
    try canvas.save("build/memory-reference.png")
    # Two tiles' worth of GPU: everything else lives in RAM between frames.
    try canvas.set_memory_budgets(1048576, 0)
    for round in 0..<(usize)3:
        try frame_pixels(&canvas, &target, fit, 0.0, 0.0, seen)
        assert(seen == reference_fit)
        try frame_pixels(&canvas, &target, 1.0, -600.0 + (f64)round * 10.0 - 10.0 * (f64)round, -500.0, seen)
        assert(seen == reference_near)
    try canvas.settle_memory()
    assert(canvas.memory_gpu_bytes() <= 4194304 and canvas.memory_ram_bytes() > 0)
    # A stroke, undone, leaves the picture as it was; redone, as it was drawn.
    try canvas.set_brush(80.0, 0.8, 1.0, 1.0, 0.0, 0.0, 0.0, false)
    try canvas.begin_stroke(first, 700.0, 600.0)
    try canvas.extend_stroke(900.0, 700.0)
    try canvas.end_stroke()
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
    assert(seen != reference_near)
    try canvas.undo()
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
    assert(seen == reference_near)
    # The export reads the tiles wherever they are: the same file's pixels.
    try canvas.save("build/memory-budgeted.png")
    let expected = try Image.open("build/memory-reference.png")
    defer expected.release()
    let exported = try Image.open("build/memory-budgeted.png")
    defer exported.release()
    for probe in [(usize)0, 377, 749, 1100, 1499]:
        let y = probe * 1099 // 1499
        let a = try expected.value().getpixel(probe, y)
        let b = try exported.value().getpixel(probe, y)
        assert(a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a)

## One window frame as luced-2d draws it: the view, the Navigator's thumbnail
## and a popup's backdrop, three draws into one frame, read back.
func window_frame(canvas: Canvas*, target: gpu.Texture*, into: u8[]) -> !:
    try canvas.wait_idle()
    let frame = try target.frame()
    defer frame.release()
    let root = try frame.value().target()
    defer root.release()
    try canvas.draw(root, gpu.Rect(width = 256.0, height = 192.0), 1.0, -600.0, -500.0)
    try canvas.draw(root, gpu.Rect(x = 192.0, width = 64.0, height = 48.0), 64.0 / 1500.0, 0.0, 0.0)
    try canvas.draw(root, gpu.Rect(x = 0.0, y = 128.0, width = 96.0, height = 64.0), 96.0 / 1500.0, 0.0, 0.0)
    _ = try frame.value().present(gpu.Color(0.0, 0.0, 0.0, 1.0))
    try target.read(into)

test "a frame drawn three times under a budget one draw alone exceeds completes, the same, without growing":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1500, 1100)
    defer canvas.close()
    defer residency_budgets(0, 0)
    var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
    defer target.destroy()
    var reference: u8[196608]
    var seen: u8[196608]
    try window_frame(&canvas, &target, reference)
    for index in 0..<(usize)4:
        let layer = try canvas.add_layer("Layer")
        let f = (f64)index / 4.0
        try canvas.fill_gradient(layer, 0.0, f * 300.0, 1500.0, 1100.0 - f * 200.0, 0.2 + f * 0.5, 0.9 - f * 0.4, 0.3, 1.0 if index == 0 else 0.4,
                                 0.9 - f * 0.3, 0.2 + f * 0.6, 0.8, 1.0 if index == 0 else 0.3)
    try window_frame(&canvas, &target, reference)
    # One tile of GPU: every frame's first draw pins more than that.
    try canvas.set_memory_budgets(524288, 0)
    try window_frame(&canvas, &target, seen)
    assert(seen == reference)
    try window_frame(&canvas, &target, seen)
    let derived = canvas.memory_derived_bytes()
    let uploads = canvas.memory_transient_uploads()
    for round in 0..<(usize)10:
        try window_frame(&canvas, &target, seen)
        assert(seen == reference)
    # The same frames again cost the same: nothing grows, nothing is made twice over.
    assert(canvas.memory_derived_bytes() <= derived + 1048576)
    assert(canvas.memory_transient_uploads() - uploads <= 10 * 4 * 30)

test "past the RAM budget six layers move to the scratch file, and undo and export read them back":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(1500, 1100)
    defer canvas.close()
    defer residency_budgets(0, 0)
    var target = try gpu.Texture.create(device, 256, 192, gpu.Format.rgba8_linear)
    defer target.destroy()
    var reference: u8[196608]
    var seen: u8[196608]
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, reference)
    # Compressed on the way out, as on a slow scratch disk.
    Canvas.set_compressed_tier(true)
    defer Canvas.set_compressed_tier(false)
    # Four tiles of GPU and eight of RAM against six layers of thirty tiles each.
    try canvas.set_memory_budgets(4 * 524288, 8 * 524288)
    var layers: i64[6]
    for index in 0..<(usize)6:
        layers[index] = try canvas.add_layer("Layer")
        let f = (f64)index / 6.0
        try canvas.fill_gradient(layers[index], f * 100.0, 0.0, 1500.0 - f * 100.0, 1100.0, 0.1 + f * 0.6, 0.8 - f * 0.5, 0.4, 1.0 if index == 0 else 0.35,
                                 0.8 - f * 0.2, 0.3 + f * 0.5, 0.7, 1.0 if index == 0 else 0.25)
        try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
        try canvas.settle_memory()
        assert(canvas.memory_ram_bytes() <= 8 * 524288)
    assert(canvas.memory_disk_bytes() > 0 and canvas.memory_spills() > 0)
    # Gradients pack with the .l2d codec before they go to disk.
    assert(canvas.memory_packs() > 0)
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, reference)
    try canvas.save("build/memory-disk-reference.png")
    # An export reads every tile back, and leaves RAM within its budget.
    assert(canvas.memory_ram_bytes() <= 8 * 524288)
    try canvas.save_package("build/memory-disk.l2d")
    assert(canvas.memory_ram_bytes() <= 8 * 524288)
    # A stroke and its undo, then an export: every tile read back from wherever it is.
    try canvas.set_brush(120.0, 0.8, 1.0, 1.0, 0.0, 0.0, 0.0, false)
    try canvas.begin_stroke(layers[3], 600.0, 500.0)
    try canvas.extend_stroke(1200.0, 900.0)
    try canvas.end_stroke()
    try canvas.settle_memory()
    try canvas.undo()
    try frame_pixels(&canvas, &target, 1.0, -600.0, -500.0, seen)
    assert(seen == reference)
    try canvas.settle_memory()
    assert(canvas.memory_ram_bytes() <= 8 * 524288)
    try canvas.save("build/memory-disk.png")
    let expected = try Image.open("build/memory-disk-reference.png")
    defer expected.release()
    let exported = try Image.open("build/memory-disk.png")
    defer exported.release()
    for probe in [(usize)0, 377, 749, 1100, 1499]:
        let y = probe * 1099 // 1499
        let a = try expected.value().getpixel(probe, y)
        let b = try exported.value().getpixel(probe, y)
        assert(a.r == b.r and a.g == b.g and a.b == b.b and a.a == b.a)

test "the scratch folder can be chosen before the first spill":
    try Canvas.set_scratch_folder("build")
    try Canvas.set_scratch_folder("")

## Session previews at 100% at two places, over black, into views `at` and
## `at` + 1 of `views` (each `size` bytes): (-900, -600) then (-200, -100).
func session_views(canvas: Canvas*, target: gpu.Texture*, views: u8[], size: usize, at: usize) -> !:
    try drawn(canvas, target, 1.0, -900.0, -600.0, views[at * size..<(at + 1) * size])
    # Frames between the two, each settling: what the first pinned may leave the GPU.
    try canvas.settle_memory()
    try drawn(canvas, target, 0.125, 0.0, 0.0, views[(at + 1) * size..<(at + 2) * size])
    try canvas.settle_memory()
    try drawn(canvas, target, 1.0, -200.0, -100.0, views[(at + 1) * size..<(at + 2) * size])

## A transform (whole layer, then a floating selection), a filter preview and a
## liquify push on `layer`, each drawn at two places into eight `views`;
## `budget` GPU bytes (0 for none).
func previews_under(canvas: Canvas*, layer: i64, target: gpu.Texture*, budget: i64, views: u8[], size: usize) -> !:
    try canvas.set_memory_budgets(budget, 0)
    try canvas.begin_transform(layer)
    try canvas.preview_transform(0.9, 0.9, 12.0, 60.0, -40.0, 1024.0, 1024.0)
    try session_views(canvas, target, views, size, 0)
    try canvas.end_transform(false)
    try canvas.select_rectangle(700, 250, 1000, 900, 0)
    try canvas.begin_transform(layer)
    try canvas.preview_transform(0.8, 0.8, -10.0, -150.0, 120.0, 1200.0, 700.0)
    try session_views(canvas, target, views, size, 2)
    try canvas.end_transform(false)
    try canvas.deselect()
    try canvas.begin_preview(layer)
    try canvas.preview_filter(0, 20.0, 60.0, 0.0)
    try session_views(canvas, target, views, size, 4)
    try canvas.end_preview(false)
    try canvas.set_retouch(5)
    try canvas.set_brush(300.0, 0.5, 1.0, 1.0, 1.0, 0.0, 0.0, false)
    try canvas.begin_stroke(layer, 250.0, 400.0)
    try canvas.extend_stroke(1000.0, 800.0)
    try canvas.settle_memory()
    try canvas.extend_stroke(1200.0, 700.0)
    try session_views(canvas, target, views, size, 6)
    try canvas.end_stroke()
    try canvas.undo()

test "previews that last many frames draw from tiles the memory tiers moved off the GPU meanwhile":
    var device = gpu.Device.open() catch failure:
        assert(failure.code == gpu.unavailable)
        return
    defer device.destroy()
    var canvas = try Canvas(2048, 2048)
    defer canvas.close()
    defer residency_budgets(0, 0)
    let layer = try canvas.add_layer("Paint")
    var target = try gpu.Texture.create(device, 256, 256, gpu.Format.rgba8_linear)
    defer target.destroy()
    let size = (usize)256 * 256 * 4
    let expected = try new u8[size * 8] --- in memory.heap
    defer free(expected) in memory.heap
    let seen = try new u8[size * 8] --- in memory.heap
    defer free(seen) in memory.heap
    try drawn(&canvas, &target, 0.125, 0.0, 0.0, expected[0..<size])
    try canvas.fill_gradient(layer, 0.0, 0.0, 2048.0, 2048.0, 1.0, 0.2, 0.1, 1.0, 0.1, 0.3, 0.9, 1.0)
    try paint_rectangles(&canvas, layer)
    try previews_under(&canvas, layer, &target, 0, expected, size)
    # Two tiles of GPU: every frame moves what the last one pinned to RAM,
    # releasing the textures the session saw when it began.
    let demoted = canvas.memory_demotions()
    try previews_under(&canvas, layer, &target, 1048576, seen, size)
    assert(canvas.memory_demotions() > demoted)
    for at in 0..<(usize)8:
        assert(seen[at * size..<(at + 1) * size] == expected[at * size..<(at + 1) * size])