Struct MatrixMultiplication 

pub struct MatrixMultiplication { /* private fields */ }

Implementations

impl MatrixMultiplication

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

impl MatrixMultiplication

pub fn new( device: &MetalDevice, descriptor: MatrixMultiplicationDescriptor, ) -> Option<Self>

Build a configurable GEMM kernel with optional transposition and scaling.

pub fn new_simple( device: &MetalDevice, result_rows: usize, result_columns: usize, interior_columns: usize, ) -> Option<Self>

Convenience constructor for the common C = A * B case.

Examples found in repository

examples/02_matrix_multiply.rs (line 67)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let left_desc = MatrixDescriptor::contiguous(2, 3, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");
    let right_desc = MatrixDescriptor::contiguous(3, 2, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");
    let result_desc = MatrixDescriptor::contiguous(2, 2, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");

    let left_buffer = device
        .new_buffer(
            left_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate left buffer");
    let right_buffer = device
        .new_buffer(
            right_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate right buffer");
    let result_buffer = device
        .new_buffer(
            result_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate result buffer");

    let left_values = [1.0_f32, 2.0, 3.0, 4.0, 5.0, 6.0];
    let right_values = [7.0_f32, 8.0, 9.0, 10.0, 11.0, 12.0];
    let zeros = [0.0_f32; 4];

    let _ = left_buffer.write_bytes(as_bytes(&left_values));
    let _ = right_buffer.write_bytes(as_bytes(&right_values));
    let _ = result_buffer.write_bytes(as_bytes(&zeros));

    let left =
        Matrix::new_with_buffer(&left_buffer, left_desc).expect("failed to wrap left matrix");
    let right =
        Matrix::new_with_buffer(&right_buffer, right_desc).expect("failed to wrap right matrix");
    let result =
        Matrix::new_with_buffer(&result_buffer, result_desc).expect("failed to wrap result matrix");

    let gemm = MatrixMultiplication::new_simple(&device, 2, 2, 3)
        .expect("failed to create matrix multiplication kernel");
    let command_buffer = queue
        .new_command_buffer()
        .expect("failed to allocate command buffer");
    gemm.encode(&command_buffer, &left, &right, &result);
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let output = read_f32s(&result_buffer, 4);
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in output.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {output:?}"
        );
    }

    println!("matmul smoke passed: {output:?}");
}

pub fn encode( &self, command_buffer: &CommandBuffer, left: &Matrix, right: &Matrix, result: &Matrix, )

Encode the matrix multiplication onto a command buffer.

Examples found in repository

examples/02_matrix_multiply.rs (line 72)

fn main() {
    let device = MetalDevice::system_default().expect("no Metal device available");
    let queue = device
        .new_command_queue()
        .expect("failed to create command queue");

    let left_desc = MatrixDescriptor::contiguous(2, 3, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");
    let right_desc = MatrixDescriptor::contiguous(3, 2, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");
    let result_desc = MatrixDescriptor::contiguous(2, 2, data_type::FLOAT32)
        .expect("FLOAT32 matrix descriptor should be supported");

    let left_buffer = device
        .new_buffer(
            left_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate left buffer");
    let right_buffer = device
        .new_buffer(
            right_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate right buffer");
    let result_buffer = device
        .new_buffer(
            result_desc.matrix_bytes,
            resource_options::STORAGE_MODE_SHARED,
        )
        .expect("failed to allocate result buffer");

    let left_values = [1.0_f32, 2.0, 3.0, 4.0, 5.0, 6.0];
    let right_values = [7.0_f32, 8.0, 9.0, 10.0, 11.0, 12.0];
    let zeros = [0.0_f32; 4];

    let _ = left_buffer.write_bytes(as_bytes(&left_values));
    let _ = right_buffer.write_bytes(as_bytes(&right_values));
    let _ = result_buffer.write_bytes(as_bytes(&zeros));

    let left =
        Matrix::new_with_buffer(&left_buffer, left_desc).expect("failed to wrap left matrix");
    let right =
        Matrix::new_with_buffer(&right_buffer, right_desc).expect("failed to wrap right matrix");
    let result =
        Matrix::new_with_buffer(&result_buffer, result_desc).expect("failed to wrap result matrix");

    let gemm = MatrixMultiplication::new_simple(&device, 2, 2, 3)
        .expect("failed to create matrix multiplication kernel");
    let command_buffer = queue
        .new_command_buffer()
        .expect("failed to allocate command buffer");
    gemm.encode(&command_buffer, &left, &right, &result);
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let output = read_f32s(&result_buffer, 4);
    let expected = [58.0_f32, 64.0, 139.0, 154.0];
    for (actual, expected_value) in output.iter().zip(expected) {
        assert!(
            (actual - expected_value).abs() < 1.0e-4,
            "unexpected matrix multiply result: {output:?}"
        );
    }

    println!("matmul smoke passed: {output:?}");
}

Trait Implementations

impl Drop for MatrixMultiplication

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 MatrixMultiplication

impl Sync for MatrixMultiplication