Struct State 

pub struct State { /* private fields */ }

Implementations

impl State

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

impl State

pub fn temporary(command_buffer: &MetalCommandBuffer) -> Option<Self>

pub fn temporary_with_buffer_size( command_buffer: &MetalCommandBuffer, buffer_size: usize, ) -> Option<Self>

Examples found in repository

examples/07_optimizer_and_state.rs (line 43)

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

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    let temporary_a =
        State::temporary_with_buffer_size(&command_buffer, 32).expect("temporary state a");
    let temporary_b =
        State::temporary_with_buffer_size(&command_buffer, 64).expect("temporary state b");
    let unique_count =
        state_batch_increment_read_count(&[&temporary_a, &temporary_a, &temporary_b], 1);
    assert_eq!(unique_count, 2);
    assert_eq!(
        temporary_a.resource_type_at_index(0),
        state_resource_type::BUFFER
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let resource_list = StateResourceList::new().expect("resource list");
    resource_list.append_buffer(16);
    let persistent_state =
        State::new_with_resource_list(&device, &resource_list).expect("persistent state");
    assert_eq!(persistent_state.resource_count(), 1);
    assert_eq!(persistent_state.buffer_size_at_index(0), 16);

    let (gradient_buffer, gradient_vector) = vector_with_values(&device, &[0.1, -0.2]);
    let (values_buffer, values_vector) = vector_with_values(&device, &[1.0, -1.0]);
    let (result_buffer, result_vector) = vector_with_values(&device, &[0.0, 0.0]);
    let optimizer = NNOptimizerStochasticGradientDescent::new(&device, 0.5).expect("sgd");
    let base = optimizer.as_optimizer().expect("optimizer base");
    assert_eq!(base.regularization_type(), nn_regularization_type::NONE);

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    optimizer.encode_vector(
        &command_buffer,
        &gradient_vector,
        &values_vector,
        None,
        &result_vector,
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let _ = gradient_buffer;
    let _ = values_buffer;
    let output = read_f32_values(&result_buffer, 2);
    println!("{output:?}");
}

pub fn new_with_buffer_size( device: &MetalDevice, buffer_size: usize, ) -> Option<Self>

pub fn new_with_resource_list( device: &MetalDevice, resource_list: &StateResourceList, ) -> Option<Self>

Examples found in repository

examples/07_optimizer_and_state.rs (line 59)

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

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    let temporary_a =
        State::temporary_with_buffer_size(&command_buffer, 32).expect("temporary state a");
    let temporary_b =
        State::temporary_with_buffer_size(&command_buffer, 64).expect("temporary state b");
    let unique_count =
        state_batch_increment_read_count(&[&temporary_a, &temporary_a, &temporary_b], 1);
    assert_eq!(unique_count, 2);
    assert_eq!(
        temporary_a.resource_type_at_index(0),
        state_resource_type::BUFFER
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let resource_list = StateResourceList::new().expect("resource list");
    resource_list.append_buffer(16);
    let persistent_state =
        State::new_with_resource_list(&device, &resource_list).expect("persistent state");
    assert_eq!(persistent_state.resource_count(), 1);
    assert_eq!(persistent_state.buffer_size_at_index(0), 16);

    let (gradient_buffer, gradient_vector) = vector_with_values(&device, &[0.1, -0.2]);
    let (values_buffer, values_vector) = vector_with_values(&device, &[1.0, -1.0]);
    let (result_buffer, result_vector) = vector_with_values(&device, &[0.0, 0.0]);
    let optimizer = NNOptimizerStochasticGradientDescent::new(&device, 0.5).expect("sgd");
    let base = optimizer.as_optimizer().expect("optimizer base");
    assert_eq!(base.regularization_type(), nn_regularization_type::NONE);

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    optimizer.encode_vector(
        &command_buffer,
        &gradient_vector,
        &values_vector,
        None,
        &result_vector,
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let _ = gradient_buffer;
    let _ = values_buffer;
    let output = read_f32_values(&result_buffer, 2);
    println!("{output:?}");
}

pub fn temporary_with_resource_list( command_buffer: &MetalCommandBuffer, resource_list: &StateResourceList, ) -> Option<Self>

pub fn resource_count(&self) -> usize

Examples found in repository

examples/07_optimizer_and_state.rs (line 60)

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

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    let temporary_a =
        State::temporary_with_buffer_size(&command_buffer, 32).expect("temporary state a");
    let temporary_b =
        State::temporary_with_buffer_size(&command_buffer, 64).expect("temporary state b");
    let unique_count =
        state_batch_increment_read_count(&[&temporary_a, &temporary_a, &temporary_b], 1);
    assert_eq!(unique_count, 2);
    assert_eq!(
        temporary_a.resource_type_at_index(0),
        state_resource_type::BUFFER
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let resource_list = StateResourceList::new().expect("resource list");
    resource_list.append_buffer(16);
    let persistent_state =
        State::new_with_resource_list(&device, &resource_list).expect("persistent state");
    assert_eq!(persistent_state.resource_count(), 1);
    assert_eq!(persistent_state.buffer_size_at_index(0), 16);

    let (gradient_buffer, gradient_vector) = vector_with_values(&device, &[0.1, -0.2]);
    let (values_buffer, values_vector) = vector_with_values(&device, &[1.0, -1.0]);
    let (result_buffer, result_vector) = vector_with_values(&device, &[0.0, 0.0]);
    let optimizer = NNOptimizerStochasticGradientDescent::new(&device, 0.5).expect("sgd");
    let base = optimizer.as_optimizer().expect("optimizer base");
    assert_eq!(base.regularization_type(), nn_regularization_type::NONE);

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    optimizer.encode_vector(
        &command_buffer,
        &gradient_vector,
        &values_vector,
        None,
        &result_vector,
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let _ = gradient_buffer;
    let _ = values_buffer;
    let output = read_f32_values(&result_buffer, 2);
    println!("{output:?}");
}

pub fn read_count(&self) -> usize

pub fn set_read_count(&self, count: usize)

pub fn is_temporary(&self) -> bool

pub fn buffer_size_at_index(&self, index: usize) -> usize

Examples found in repository

examples/07_optimizer_and_state.rs (line 61)

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

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    let temporary_a =
        State::temporary_with_buffer_size(&command_buffer, 32).expect("temporary state a");
    let temporary_b =
        State::temporary_with_buffer_size(&command_buffer, 64).expect("temporary state b");
    let unique_count =
        state_batch_increment_read_count(&[&temporary_a, &temporary_a, &temporary_b], 1);
    assert_eq!(unique_count, 2);
    assert_eq!(
        temporary_a.resource_type_at_index(0),
        state_resource_type::BUFFER
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let resource_list = StateResourceList::new().expect("resource list");
    resource_list.append_buffer(16);
    let persistent_state =
        State::new_with_resource_list(&device, &resource_list).expect("persistent state");
    assert_eq!(persistent_state.resource_count(), 1);
    assert_eq!(persistent_state.buffer_size_at_index(0), 16);

    let (gradient_buffer, gradient_vector) = vector_with_values(&device, &[0.1, -0.2]);
    let (values_buffer, values_vector) = vector_with_values(&device, &[1.0, -1.0]);
    let (result_buffer, result_vector) = vector_with_values(&device, &[0.0, 0.0]);
    let optimizer = NNOptimizerStochasticGradientDescent::new(&device, 0.5).expect("sgd");
    let base = optimizer.as_optimizer().expect("optimizer base");
    assert_eq!(base.regularization_type(), nn_regularization_type::NONE);

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    optimizer.encode_vector(
        &command_buffer,
        &gradient_vector,
        &values_vector,
        None,
        &result_vector,
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let _ = gradient_buffer;
    let _ = values_buffer;
    let output = read_f32_values(&result_buffer, 2);
    println!("{output:?}");
}

pub fn texture_info_at_index(&self, index: usize) -> StateTextureInfo

pub fn resource_type_at_index(&self, index: usize) -> usize

Examples found in repository

examples/07_optimizer_and_state.rs (line 50)

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

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    let temporary_a =
        State::temporary_with_buffer_size(&command_buffer, 32).expect("temporary state a");
    let temporary_b =
        State::temporary_with_buffer_size(&command_buffer, 64).expect("temporary state b");
    let unique_count =
        state_batch_increment_read_count(&[&temporary_a, &temporary_a, &temporary_b], 1);
    assert_eq!(unique_count, 2);
    assert_eq!(
        temporary_a.resource_type_at_index(0),
        state_resource_type::BUFFER
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let resource_list = StateResourceList::new().expect("resource list");
    resource_list.append_buffer(16);
    let persistent_state =
        State::new_with_resource_list(&device, &resource_list).expect("persistent state");
    assert_eq!(persistent_state.resource_count(), 1);
    assert_eq!(persistent_state.buffer_size_at_index(0), 16);

    let (gradient_buffer, gradient_vector) = vector_with_values(&device, &[0.1, -0.2]);
    let (values_buffer, values_vector) = vector_with_values(&device, &[1.0, -1.0]);
    let (result_buffer, result_vector) = vector_with_values(&device, &[0.0, 0.0]);
    let optimizer = NNOptimizerStochasticGradientDescent::new(&device, 0.5).expect("sgd");
    let base = optimizer.as_optimizer().expect("optimizer base");
    assert_eq!(base.regularization_type(), nn_regularization_type::NONE);

    let command_buffer = queue.new_command_buffer().expect("command buffer");
    optimizer.encode_vector(
        &command_buffer,
        &gradient_vector,
        &values_vector,
        None,
        &result_vector,
    );
    command_buffer.commit();
    command_buffer.wait_until_completed();

    let _ = gradient_buffer;
    let _ = values_buffer;
    let output = read_f32_values(&result_buffer, 2);
    println!("{output:?}");
}

pub fn synchronize_on_command_buffer(&self, command_buffer: &MetalCommandBuffer)

pub fn resource_size(&self) -> usize

Trait Implementations

impl Drop for State

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 State

impl Sync for State