dymokomi/luce-gpu
Source of release 0.5.1
0.5.1 / src / gpu / metal / transfer.lucb
#==============================================================================================
#
# transfer - The Metal readback ring
#
# DESCRIPTION:
# Shared-storage buffers made once per device and kept: on unified memory their contents
# are the host's view of the bytes, with no copy across a bus. A read batch holds one
# slot, blits every region into it in one command buffer, and waits for that once.
#
#==============================================================================================
## One shared buffer of the ring, and the command buffer still writing it.
struct MetalRingSlot:
var buffer: void*?
var data: void*?
var size: u64
var busy: bool
let metal_read_slot_count: usize = 3
let metal_read_slot_bytes: u64 = 32u64 << 20
## A free readback slot, made on first use.
func metal_read_acquire(device: MetalDevice*) -> ReadSlot!:
for index in 0..<metal_read_slot_count:
let slot = &device.reads[index]
if slot.busy:
continue
if slot.buffer == none:
let pool = objc_autoreleasePoolPush()
defer objc_autoreleasePoolPop(pool)
# MTLResourceStorageModeShared: the CPU reads the buffer in place.
let buffer = metal_new_buffer(metal_required(device.device), metal_sel("newBufferWithLength:options:"), metal_read_slot_bytes, 0) else error(failed, "could not allocate GPU readback memory")
slot.buffer = buffer
slot.data = metal_ptr(buffer, metal_sel("contents"))
slot.size = metal_read_slot_bytes
if slot.data == none:
error(failed, "Metal readback storage is inaccessible")
slot.busy = true
let data = slot.data else trap("a Metal ring slot lost its contents")
return ReadSlot(index = index, data = (u8*)data, capacity = (usize)slot.size)
error(failed, "every Metal readback slot is held; finish a read batch first")
## Blit every region of a batch into slot `index` in one command buffer, and
## commit it; the ticket holds the command buffer until it is waited for.
func metal_read_submit(device: MetalDevice*, index: usize, entries: const ReadEntry[]) -> ReadTicket!:
let pool = objc_autoreleasePoolPush()
defer objc_autoreleasePoolPop(pool)
let ring = &device.reads[index]
let command = metal_ptr(metal_required(device.queue), metal_sel("commandBuffer")) else error(failed, "could not create a Metal command buffer")
let blit = metal_ptr(command, metal_sel("blitCommandEncoder")) else error(failed, "could not create a Metal blit encoder")
for entry in entries:
let texture = (MetalTexture*)entry.texture.native
let texel = (u64)texel_bytes(texture.format)
let row = (u64)(entry.row_texels if entry.row_texels > 0 else entry.region.width) * texel
metal_copy_from_texture(blit, metal_sel("copyFromTexture:sourceSlice:sourceLevel:sourceOrigin:sourceSize:toBuffer:destinationOffset:destinationBytesPerRow:destinationBytesPerImage:"),
metal_required(texture.texture), 0, 0, LuceGpuMetalOrigin((u64)entry.region.x, (u64)entry.region.y, 0),
LuceGpuMetalExtent((u64)entry.region.width, (u64)entry.region.height, 1),
metal_required(ring.buffer), (u64)entry.offset, row, row * (u64)entry.region.height)
metal_void(blit, metal_sel("endEncoding"))
# Kept past the pool: the wait needs it.
metal_void(command, metal_sel("retain"))
metal_void(command, metal_sel("commit"))
return ReadTicket(command = command)
## Wait for a batch's command buffer and let it go, reporting execution failure.
func metal_read_wait(ticket: ReadTicket) -> !:
let command = ticket.command else return
let pool = objc_autoreleasePoolPush()
defer objc_autoreleasePoolPop(pool)
metal_void(command, metal_sel("waitUntilCompleted"))
let status = metal_uint(command, metal_sel("status"))
metal_void(command, metal_sel("release"))
if status != 4:
error(execution_failed, "Metal command execution failed")
## Whether a batch's command buffer has finished, completed or failed
## (MTLCommandBufferStatus 4 or 5), without waiting.
func metal_read_ready(ticket: ReadTicket) -> bool:
let command = ticket.command else return true
return metal_uint(command, metal_sel("status")) >= 4
## Give slot `index` back; a batch still on the GPU is waited for first, so the
## next one never shares its bytes.
func metal_read_release(device: MetalDevice*, index: usize, ticket: ReadTicket, pending: bool):
if pending:
metal_read_wait(ticket) catch failure:
_ = failure
device.reads[index].busy = false
func metal_rings_destroy(device: MetalDevice*):
for index in 0..<metal_read_slot_count:
if let buffer = device.reads[index].buffer:
metal_void(buffer, metal_sel("release"))
device.reads[index] = MetalRingSlot()
## Blit every staged copy of an upload batch from one buffer holding `staged`,
## in one command buffer, and commit it without waiting (it keeps the buffer).
func metal_upload_submit(device: MetalDevice*, entries: const UploadEntry[], staged: const u8[]) -> !:
let pool = objc_autoreleasePoolPush()
defer objc_autoreleasePoolPop(pool)
let staging = metal_buffer(metal_required(device.device), metal_sel("newBufferWithBytes:length:options:"), staged.data, (u64)staged.length, 0) else error(failed, "could not stage GPU texture data")
defer metal_void(staging, metal_sel("release"))
let command = metal_ptr(metal_required(device.queue), metal_sel("commandBuffer")) else error(failed, "could not create a Metal command buffer")
let blit = metal_ptr(command, metal_sel("blitCommandEncoder")) else error(failed, "could not create a Metal blit encoder")
for entry in entries:
let texture = (MetalTexture*)entry.texture.native
let row = (u64)entry.region.width * (u64)texel_bytes(texture.format)
metal_copy_to_texture(blit, metal_sel("copyFromBuffer:sourceOffset:sourceBytesPerRow:sourceBytesPerImage:sourceSize:toTexture:destinationSlice:destinationLevel:destinationOrigin:"),
staging, (u64)entry.offset, row, row * (u64)entry.region.height, LuceGpuMetalExtent((u64)entry.region.width, (u64)entry.region.height, 1),
metal_required(texture.texture), 0, 0, LuceGpuMetalOrigin((u64)entry.region.x, (u64)entry.region.y, 0))
metal_void(blit, metal_sel("endEncoding"))
metal_submit(command)