Struct CommandQueue 

pub struct CommandQueue { /* private fields */ }

Apple’s id<MTLCommandQueue> — schedules GPU work.

Implementations

impl CommandQueue

pub fn add_residency_set(&self, residency_set: &ResidencySet)

Add residency_set to the queue-wide residency list.

Examples found in repository

examples/07_advanced_objects.rs (line 179)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub fn remove_residency_set(&self, residency_set: &ResidencySet)

Remove residency_set from the queue-wide residency list.

Examples found in repository

examples/07_advanced_objects.rs (line 180)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

impl CommandQueue

pub fn new_command_buffer_with_unretained_references( &self, ) -> Option<CommandBuffer>

Create a new command buffer that does not retain resources it references.

Examples found in repository

examples/05_render_and_explicit_encoders.rs (line 21)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!(
        "device: {} (registry id {})",
        device.name(),
        device.registry_id()
    );

    let queue = device.new_command_queue().expect("command queue");
    let status_buffer = queue
        .new_command_buffer_with_unretained_references()
        .expect("scratch command buffer");
    println!("scratch command buffer status={}", status_buffer.status());

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit_cb = queue.new_command_buffer().expect("blit command buffer");
    let blit = blit_cb
        .new_blit_command_encoder()
        .expect("blit command encoder");
    assert!(blit.fill_buffer(&src, 0..64, b'Z'));
    assert!(blit.copy_buffer(&src, 0, &dst, 0, 64));
    blit.end_encoding();
    blit_cb.commit();
    blit_cb.wait_until_completed();
    let copied = unsafe {
        core::slice::from_raw_parts(dst.contents().expect("dst contents").cast::<u8>(), 8)
    };
    println!("blit copied bytes: {copied:?}");

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[10, 20, 30, 40]);
    let compute_cb = queue.new_command_buffer().expect("compute command buffer");
    let compute = compute_cb
        .new_compute_command_encoder()
        .expect("compute command encoder");
    compute.set_compute_pipeline_state(&pipeline);
    compute.set_buffer(&buffer, 0, 0);
    compute.dispatch_threads((4, 1, 1), (1, 1, 1));
    compute.end_encoding();
    compute_cb.commit();
    compute_cb.wait_until_completed();
    println!("compute output: {:?}", common::read_u32_words(&buffer, 4));

    let render_library = device
        .new_library_with_source(common::RENDER_SRC)
        .expect("compile render library");
    let vertex = render_library
        .new_function("fullscreen_vertex")
        .expect("vertex function");
    let fragment = render_library
        .new_function("solid_fragment")
        .expect("fragment function");
    let render_pipeline = device
        .new_render_pipeline_state(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
        .expect("render pipeline");
    println!("render pipeline label: {:?}", render_pipeline.label());

    let render_target = device
        .new_texture(common::shared_render_target(4, 4))
        .expect("render target");
    let vertex_buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("vertex buffer");
    let render_cb = queue.new_command_buffer().expect("render command buffer");
    let render = render_cb
        .new_render_command_encoder(
            &render_target,
            load_action::CLEAR,
            store_action::STORE,
            [0.0, 0.0, 0.0, 1.0],
        )
        .expect("render command encoder");
    render.set_render_pipeline_state(&render_pipeline);
    render.set_vertex_buffer(&vertex_buffer, 0, 0);
    render.draw_primitives(primitive_type::TRIANGLE, 0, 3);
    render.end_encoding();
    render_cb.commit();
    render_cb.wait_until_completed();

    let mut rendered = vec![0_u8; 4 * 4 * 4];
    assert!(render_target.read_bytes_2d(&mut rendered, 16, (0, 0), (4, 4), 0));
    println!("first rendered pixel: {:?}", &rendered[..4]);

    let shared_texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("shared texture");
    let upload = vec![0x22_u8; 4 * 4 * 4];
    assert!(shared_texture.replace_region_2d(&upload, 16, (0, 0), (4, 4), 0));
    let mut download = vec![0_u8; upload.len()];
    assert!(shared_texture.read_bytes_2d(&mut download, 16, (0, 0), (4, 4), 0));
    let view = shared_texture
        .new_view(pixel_format::BGRA8UNORM)
        .expect("texture view");
    println!(
        "texture {}x{} usage={} storage_mode={} view_width={}",
        shared_texture.width(),
        shared_texture.height(),
        shared_texture.usage(),
        shared_texture.storage_mode(),
        view.width(),
    );
}

examples/06_resources_and_archives.rs (line 18)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!("device: {}", device.name());

    let queue = device
        .new_command_queue_with_max_command_buffer_count(4)
        .expect("bounded command queue");
    let scratch = queue
        .new_command_buffer_with_unretained_references()
        .expect("bounded scratch command buffer");
    println!("bounded queue scratch status={}", scratch.status());

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let args = library.new_function("use_args").expect("use_args function");
    let argument_encoder = args.new_argument_encoder(0).expect("argument encoder");
    let argument_buffer = device
        .new_buffer(
            argument_encoder.encoded_length(),
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("argument buffer");
    let payload = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("payload buffer");
    let texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("argument texture");
    argument_encoder.set_argument_buffer(&argument_buffer, 0);
    argument_encoder.set_buffer(&payload, 0, 0);
    argument_encoder.set_texture(&texture, 1);
    println!(
        "argument encoder length={} alignment={}",
        argument_encoder.encoded_length(),
        argument_encoder.alignment(),
    );

    let backing = device
        .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
        .expect("backing buffer");
    let buffer_texture = backing
        .new_texture_view_2d(pixel_format::BGRA8UNORM, 16, 4, 64, 0)
        .expect("buffer-backed texture");
    println!(
        "buffer-backed texture {}x{} fmt={}",
        buffer_texture.width(),
        buffer_texture.height(),
        buffer_texture.pixel_format(),
    );

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        let heap_buffer = heap
            .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
            .expect("heap buffer");
        let heap_texture = heap
            .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
            .expect("heap texture");
        println!(
            "heap size={} used={} current={} max_available={}",
            heap.size(),
            heap.used_size(),
            heap.current_allocated_size(),
            heap.max_available_size(256),
        );
        println!(
            "heap buffer len={} heap texture {}x{} purgeable={}",
            heap_buffer.length(),
            heap_texture.width(),
            heap_texture.height(),
            heap.set_purgeable_state(apple_metal::purgeable_state::KEEP_CURRENT),
        );
    } else {
        println!("heaps are unavailable on this device");
    }

    match device.new_log_state(log_level::INFO, 1_024) {
        Ok(log_state) => {
            let _ = device
                .new_command_queue_with_log_state(4, &log_state)
                .expect("log-state queue");
            println!("created queue with log state");
        }
        Err(error) => println!("log state unavailable on this OS: {error}"),
    }

    if device.supports_dynamic_libraries() {
        let dynamic_path = common::artifact_path("example-dylib.metallib");
        let dynamic_library = device
            .new_dynamic_library_with_source(
                common::DYNAMIC_LIB_SRC,
                dynamic_path.to_string_lossy().as_ref(),
            )
            .expect("dynamic library from source");
        dynamic_library
            .serialize_to_file(&dynamic_path)
            .expect("serialize dynamic library");
        let reloaded = device
            .load_dynamic_library(&dynamic_path)
            .expect("reload dynamic library");
        println!("dynamic library install name: {}", reloaded.install_name());

        let render_library = device
            .new_library_with_source(common::RENDER_SRC)
            .expect("compile render library");
        let vertex = render_library
            .new_function("fullscreen_vertex")
            .expect("vertex function");
        let fragment = render_library
            .new_function("solid_fragment")
            .expect("fragment function");
        let increment = library
            .new_function("increment")
            .expect("increment function");

        let archive_path = common::artifact_path("example-archive.metalarc");
        let archive = device.new_binary_archive(None).expect("binary archive");
        archive
            .add_compute_function(&increment)
            .expect("archive compute pipeline");
        archive
            .add_render_functions(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
            .expect("archive render pipeline");
        archive
            .serialize_to_file(&archive_path)
            .expect("serialize binary archive");
        let _ = device
            .new_binary_archive(Some(&archive_path))
            .expect("reload binary archive");
        println!("binary archive written to {}", archive_path.display());
    } else {
        println!("dynamic libraries unsupported; skipping archive serialization");
    }
}

impl CommandQueue

pub fn new_command_buffer(&self) -> Option<CommandBuffer>

Create a new command buffer for recording GPU commands.

Examples found in repository

examples/03_command_buffer_blit.rs (line 14)

fn main() {
    let dev = MetalDevice::system_default().expect("no Metal");
    let queue = dev.new_command_queue().expect("queue");
    let src = dev
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("src");
    let dst = dev
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("dst");
    let _ = src.write_bytes(b"hello GPU blit from apple-metal-rs!!!!!");

    let cb = queue.new_command_buffer().expect("cb");
    assert!(cb.blit_copy_buffer(&src, 0, &dst, 0, 64));
    cb.commit();
    cb.wait_until_completed();

    let p = dst.contents().unwrap().cast::<u8>();
    let bytes = unsafe { core::slice::from_raw_parts(p, 40) };
    let s = String::from_utf8_lossy(bytes);
    println!("GPU blit result: {s:?}");
    assert!(s.starts_with("hello GPU blit"));
}

examples/04_compute_shader.rs (line 55)

fn main() {
    let device = MetalDevice::system_default().expect("MTLCreateSystemDefaultDevice");
    println!("Device unified={}", device.has_unified_memory());

    let lib = device
        .new_library_with_source(KERNEL_SRC)
        .expect("compile MSL source");
    println!("✅ Compiled library {:p}", lib.as_ptr());

    let func = lib.new_function("mul2").expect("locate function 'mul2'");
    println!("✅ Found function mul2 {:p}", func.as_ptr());

    let pso = device
        .new_compute_pipeline_state(&func)
        .expect("build compute pipeline state");
    println!("✅ Compute pipeline state {:p}", pso.as_ptr());

    let byte_len = N * core::mem::size_of::<f32>();
    let buffer = device
        .new_buffer(byte_len, resource_options::STORAGE_MODE_SHARED)
        .expect("allocate buffer");

    let slice: &mut [f32] = unsafe {
        core::slice::from_raw_parts_mut(
            buffer.contents().expect("buffer.contents").cast::<f32>(),
            N,
        )
    };
    for (i, x) in slice.iter_mut().enumerate() {
        *x = i as f32;
    }
    println!("Input : {slice:?}");

    let queue = device.new_command_queue().expect("MTLCommandQueue");
    let cb = queue.new_command_buffer().expect("MTLCommandBuffer");
    let ok = cb.dispatch_compute_1d(&pso, &[&buffer], N, 1);
    assert!(ok, "dispatch_compute_1d failed");
    cb.commit();
    cb.wait_until_completed();

    let slice: &[f32] = unsafe {
        core::slice::from_raw_parts(buffer.contents().expect("buffer.contents").cast::<f32>(), N)
    };
    println!("Output: {slice:?}");

    for (i, &v) in slice.iter().enumerate() {
        let expected = (i as f32) * 2.0;
        assert_eq!(v, expected, "element {i} expected {expected} got {v}");
    }
    println!("✅ All {N} elements correctly doubled by the GPU kernel");
}

examples/05_render_and_explicit_encoders.rs (line 31)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    println!(
        "device: {} (registry id {})",
        device.name(),
        device.registry_id()
    );

    let queue = device.new_command_queue().expect("command queue");
    let status_buffer = queue
        .new_command_buffer_with_unretained_references()
        .expect("scratch command buffer");
    println!("scratch command buffer status={}", status_buffer.status());

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit_cb = queue.new_command_buffer().expect("blit command buffer");
    let blit = blit_cb
        .new_blit_command_encoder()
        .expect("blit command encoder");
    assert!(blit.fill_buffer(&src, 0..64, b'Z'));
    assert!(blit.copy_buffer(&src, 0, &dst, 0, 64));
    blit.end_encoding();
    blit_cb.commit();
    blit_cb.wait_until_completed();
    let copied = unsafe {
        core::slice::from_raw_parts(dst.contents().expect("dst contents").cast::<u8>(), 8)
    };
    println!("blit copied bytes: {copied:?}");

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[10, 20, 30, 40]);
    let compute_cb = queue.new_command_buffer().expect("compute command buffer");
    let compute = compute_cb
        .new_compute_command_encoder()
        .expect("compute command encoder");
    compute.set_compute_pipeline_state(&pipeline);
    compute.set_buffer(&buffer, 0, 0);
    compute.dispatch_threads((4, 1, 1), (1, 1, 1));
    compute.end_encoding();
    compute_cb.commit();
    compute_cb.wait_until_completed();
    println!("compute output: {:?}", common::read_u32_words(&buffer, 4));

    let render_library = device
        .new_library_with_source(common::RENDER_SRC)
        .expect("compile render library");
    let vertex = render_library
        .new_function("fullscreen_vertex")
        .expect("vertex function");
    let fragment = render_library
        .new_function("solid_fragment")
        .expect("fragment function");
    let render_pipeline = device
        .new_render_pipeline_state(&vertex, &fragment, pixel_format::BGRA8UNORM, 1)
        .expect("render pipeline");
    println!("render pipeline label: {:?}", render_pipeline.label());

    let render_target = device
        .new_texture(common::shared_render_target(4, 4))
        .expect("render target");
    let vertex_buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("vertex buffer");
    let render_cb = queue.new_command_buffer().expect("render command buffer");
    let render = render_cb
        .new_render_command_encoder(
            &render_target,
            load_action::CLEAR,
            store_action::STORE,
            [0.0, 0.0, 0.0, 1.0],
        )
        .expect("render command encoder");
    render.set_render_pipeline_state(&render_pipeline);
    render.set_vertex_buffer(&vertex_buffer, 0, 0);
    render.draw_primitives(primitive_type::TRIANGLE, 0, 3);
    render.end_encoding();
    render_cb.commit();
    render_cb.wait_until_completed();

    let mut rendered = vec![0_u8; 4 * 4 * 4];
    assert!(render_target.read_bytes_2d(&mut rendered, 16, (0, 0), (4, 4), 0));
    println!("first rendered pixel: {:?}", &rendered[..4]);

    let shared_texture = device
        .new_texture(TextureDescriptor::new_2d(4, 4, pixel_format::BGRA8UNORM))
        .expect("shared texture");
    let upload = vec![0x22_u8; 4 * 4 * 4];
    assert!(shared_texture.replace_region_2d(&upload, 16, (0, 0), (4, 4), 0));
    let mut download = vec![0_u8; upload.len()];
    assert!(shared_texture.read_bytes_2d(&mut download, 16, (0, 0), (4, 4), 0));
    let view = shared_texture
        .new_view(pixel_format::BGRA8UNORM)
        .expect("texture view");
    println!(
        "texture {}x{} usage={} storage_mode={} view_width={}",
        shared_texture.width(),
        shared_texture.height(),
        shared_texture.usage(),
        shared_texture.storage_mode(),
        view.width(),
    );
}

examples/07_advanced_objects.rs (line 21)

fn main() {
    let device = MetalDevice::system_default().expect("Metal device available");
    let queue = device.new_command_queue().expect("command queue");
    let counter_sets = device.counter_set_names();
    println!("counter sets: {counter_sets:?}");

    if let Some(event) = device.new_shared_event() {
        event.set_signaled_value(1);
        println!("event signaled value={}", event.signaled_value());
        let signal = queue
            .new_command_buffer()
            .expect("event signal command buffer");
        signal.encode_signal_event(&event, 2);
        signal.commit();
        signal.wait_until_completed();
        println!(
            "event reached value 2: {}",
            event.wait_until_signaled_value(2, 1_000),
        );

        let wait = queue
            .new_command_buffer()
            .expect("event wait command buffer");
        wait.encode_wait_for_event(&event, 2);
        wait.commit();
        wait.wait_until_completed();
    }

    let fence_a = device.new_fence();
    let fence_b = device.new_fence();
    let sample_buffer = counter_sets.first().and_then(|name| {
        if device.supports_counter_sampling(counter_sampling_point::AT_BLIT_BOUNDARY) {
            device
                .new_counter_sample_buffer(name, 2, storage_mode::SHARED, Some("example-samples"))
                .ok()
        } else {
            None
        }
    });

    let src = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("source buffer");
    let dst = device
        .new_buffer(64, resource_options::STORAGE_MODE_SHARED)
        .expect("destination buffer");
    let blit = queue.new_command_buffer().expect("blit command buffer");
    let encoder = blit.new_blit_command_encoder().expect("blit encoder");
    let _ = encoder.fill_buffer(&src, 0..64, b'Q');
    if let Some(fence) = fence_a.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();

    let blit = queue
        .new_command_buffer()
        .expect("second blit command buffer");
    let encoder = blit
        .new_blit_command_encoder()
        .expect("second blit encoder");
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        let _ = encoder.sample_counters(sample_buffer, 0, false);
    }
    let _ = encoder.copy_buffer(&src, 0, &dst, 0, 64);
    encoder.end_encoding();
    blit.commit();
    blit.wait_until_completed();
    if let Some(sample_buffer) = sample_buffer.as_ref() {
        println!(
            "resolved counter bytes={}",
            sample_buffer
                .resolve_range(0..1)
                .map_or(0, |bytes| bytes.len())
        );
    }

    let library = device
        .new_library_with_source(common::COMPUTE_SRC)
        .expect("compile compute library");
    let increment = library
        .new_function("increment")
        .expect("increment function");
    let pipeline = device
        .new_compute_pipeline_state(&increment)
        .expect("compute pipeline");
    let visible_table = pipeline.new_visible_function_table(1);
    let intersection_table = if device.supports_raytracing() {
        pipeline.new_intersection_function_table(1)
    } else {
        None
    };
    if let Some(table) = intersection_table.as_ref() {
        table.set_opaque_triangle_intersection_function(intersection_function_signature::NONE, 0);
    }
    let acceleration_structure = if device.supports_raytracing() {
        device.new_acceleration_structure_with_size(256)
    } else {
        None
    };

    let buffer = device
        .new_buffer(16, resource_options::STORAGE_MODE_SHARED)
        .expect("compute buffer");
    common::write_u32_words(&buffer, &[1, 2, 3, 4]);
    let texture = device
        .new_texture(apple_metal::TextureDescriptor::new_2d(
            4,
            4,
            apple_metal::pixel_format::BGRA8UNORM,
        ))
        .expect("compute texture");
    let compute = queue.new_command_buffer().expect("compute command buffer");
    let encoder = compute
        .new_compute_command_encoder()
        .expect("compute command encoder");
    encoder.set_compute_pipeline_state(&pipeline);
    encoder.set_buffer(&buffer, 0, 0);
    encoder.set_texture(&texture, 1);
    if let Some(fence) = fence_a.as_ref() {
        encoder.wait_for_fence(fence);
    }
    if let Some(table) = visible_table.as_ref() {
        encoder.set_visible_function_table(table, 2);
    }
    if let Some(table) = intersection_table.as_ref() {
        encoder.set_intersection_function_table(table, 3);
    }
    if let Some(acceleration_structure) = acceleration_structure.as_ref() {
        encoder.set_acceleration_structure(acceleration_structure, 4);
    }
    encoder.dispatch_threadgroups((1, 1, 1), (4, 1, 1));
    if let Some(fence) = fence_b.as_ref() {
        encoder.update_fence(fence);
    }
    encoder.end_encoding();
    compute.commit();
    compute.wait_until_completed();
    println!(
        "compute buffer after dispatch: {:?}",
        common::read_u32_words(&buffer, 4)
    );

    if let Some(indirect) = device.new_indirect_command_buffer(
        indirect_command_type::CONCURRENT_DISPATCH,
        1,
        0,
        0,
        4,
        resource_options::STORAGE_MODE_PRIVATE,
    ) {
        indirect.reset_range(0..1);
        println!("indirect command buffer size={}", indirect.size());
    }

    if let Some(heap) = device.new_heap(1 << 20, storage_mode::SHARED) {
        if let Ok(residency_set) = device.new_residency_set(Some("example-residency"), 4) {
            let heap_buffer = heap
                .new_buffer(256, resource_options::STORAGE_MODE_SHARED)
                .expect("heap buffer");
            residency_set.add_buffer(&heap_buffer);
            residency_set.add_heap(&heap);
            residency_set.commit();
            residency_set.request_residency();
            queue.add_residency_set(&residency_set);
            queue.remove_residency_set(&residency_set);
            residency_set.end_residency();
            residency_set.remove_all_allocations();
            residency_set.commit();
            println!(
                "residency allocation count={}",
                residency_set.allocation_count()
            );
        } else {
            println!("residency sets unavailable on this OS");
        }
    }

    if let Some(capture_manager) = CaptureManager::shared() {
        println!(
            "capture supported for developer tools={} active={}",
            capture_manager.supports_destination(capture_destination::DEVELOPER_TOOLS),
            capture_manager.is_capturing(),
        );
        if let Some(scope) = capture_manager.new_capture_scope_with_device(&device) {
            scope.begin();
            scope.end();
        }
        if let Some(scope) = capture_manager.new_capture_scope_with_command_queue(&queue) {
            scope.begin();
            scope.end();
        }
    }
}

pub const fn as_ptr(&self) -> *mut c_void

Raw id<MTLCommandQueue> pointer.

Trait Implementations

impl Drop for CommandQueue

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Send for CommandQueue

impl Sync for CommandQueue