dymokomi/luce-image
Source of release 0.45.0
0.45.0 / 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])