parent
ff679e1cab
commit
9b266c8d3f
@ -0,0 +1,12 @@
|
|||||||
|
#version 450
|
||||||
|
|
||||||
|
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
|
||||||
|
|
||||||
|
layout(set = 0, binding = 0) buffer Data {
|
||||||
|
uint data[];
|
||||||
|
} data;
|
||||||
|
|
||||||
|
void main() {
|
||||||
|
uint idx = gl_GlobalInvocationID.x;
|
||||||
|
data.data[idx] *= 12;
|
||||||
|
}
|
||||||
@ -1,160 +0,0 @@
|
|||||||
// Copyright (c) 2017 The vulkano developers
|
|
||||||
// Licensed under the Apache License, Version 2.0
|
|
||||||
// <LICENSE-APACHE or
|
|
||||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT
|
|
||||||
// license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
|
|
||||||
// at your option. All files in the project carrying such
|
|
||||||
// notice may not be copied, modified, or distributed except
|
|
||||||
// according to those terms.
|
|
||||||
|
|
||||||
// This example demonstrates how to use the compute capabilities of Vulkan.
|
|
||||||
//
|
|
||||||
// While graphics cards have traditionally been used for graphical operations, over time they have
|
|
||||||
// been more or more used for general-purpose operations as well. This is called "General-Purpose
|
|
||||||
// GPU", or *GPGPU*. This is what this example demonstrates.
|
|
||||||
|
|
||||||
use vulkano::buffer::{BufferUsage, CpuAccessibleBuffer};
|
|
||||||
use vulkano::command_buffer::AutoCommandBufferBuilder;
|
|
||||||
use vulkano::descriptor::descriptor_set::PersistentDescriptorSet;
|
|
||||||
use vulkano::device::{Device, DeviceExtensions};
|
|
||||||
use vulkano::instance::{Instance, InstanceExtensions, PhysicalDevice};
|
|
||||||
use vulkano::pipeline::ComputePipeline;
|
|
||||||
use vulkano::sync::GpuFuture;
|
|
||||||
use vulkano::sync;
|
|
||||||
|
|
||||||
use std::sync::Arc;
|
|
||||||
|
|
||||||
fn main() {
|
|
||||||
// As with other examples, the first step is to create an instance.
|
|
||||||
let instance = Instance::new(None, &InstanceExtensions::none(), None).unwrap();
|
|
||||||
|
|
||||||
// Choose which physical device to use.
|
|
||||||
let physical = PhysicalDevice::enumerate(&instance).next().unwrap();
|
|
||||||
|
|
||||||
// Choose the queue of the physical device which is going to run our compute operation.
|
|
||||||
//
|
|
||||||
// The Vulkan specs guarantee that a compliant implementation must provide at least one queue
|
|
||||||
// that supports compute operations.
|
|
||||||
let queue_family = physical.queue_families().find(|&q| q.supports_compute()).unwrap();
|
|
||||||
|
|
||||||
// Now initializing the device.
|
|
||||||
let (device, mut queues) = Device::new(physical,
|
|
||||||
physical.supported_features(),
|
|
||||||
&DeviceExtensions::none(),
|
|
||||||
[(queue_family, 0.5)].iter().cloned()).unwrap();
|
|
||||||
|
|
||||||
// Since we can request multiple queues, the `queues` variable is in fact an iterator. In this
|
|
||||||
// example we use only one queue, so we just retrieve the first and only element of the
|
|
||||||
// iterator and throw it away.
|
|
||||||
let queue = queues.next().unwrap();
|
|
||||||
|
|
||||||
println!("Device initialized");
|
|
||||||
|
|
||||||
// Now let's get to the actual example.
|
|
||||||
//
|
|
||||||
// What we are going to do is very basic: we are going to fill a buffer with 64k integers
|
|
||||||
// and ask the GPU to multiply each of them by 12.
|
|
||||||
//
|
|
||||||
// GPUs are very good at parallel computations (SIMD-like operations), and thus will do this
|
|
||||||
// much more quickly than a CPU would do. While a CPU would typically multiply them one by one
|
|
||||||
// or four by four, a GPU will do it by groups of 32 or 64.
|
|
||||||
//
|
|
||||||
// Note however that in a real-life situation for such a simple operation the cost of
|
|
||||||
// accessing memory usually outweighs the benefits of a faster calculation. Since both the CPU
|
|
||||||
// and the GPU will need to access data, there is no other choice but to transfer the data
|
|
||||||
// through the slow PCI express bus.
|
|
||||||
|
|
||||||
// We need to create the compute pipeline that describes our operation.
|
|
||||||
//
|
|
||||||
// If you are familiar with graphics pipeline, the principle is the same except that compute
|
|
||||||
// pipelines are much simpler to create.
|
|
||||||
let pipeline = Arc::new({
|
|
||||||
mod cs {
|
|
||||||
vulkano_shaders::shader!{
|
|
||||||
ty: "compute",
|
|
||||||
src: "
|
|
||||||
#version 450
|
|
||||||
|
|
||||||
layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
|
|
||||||
|
|
||||||
layout(set = 0, binding = 0) buffer Data {
|
|
||||||
uint data[];
|
|
||||||
} data;
|
|
||||||
|
|
||||||
void main() {
|
|
||||||
uint idx = gl_GlobalInvocationID.x;
|
|
||||||
data.data[idx] *= 12;
|
|
||||||
}"
|
|
||||||
}
|
|
||||||
}
|
|
||||||
let shader = cs::Shader::load(device.clone()).unwrap();
|
|
||||||
ComputePipeline::new(device.clone(), &shader.main_entry_point(), &()).unwrap()
|
|
||||||
});
|
|
||||||
|
|
||||||
// We start by creating the buffer that will store the data.
|
|
||||||
let data_buffer = {
|
|
||||||
// Iterator that produces the data.
|
|
||||||
let data_iter = (0 .. 65536u32).map(|n| n);
|
|
||||||
// Builds the buffer and fills it with this iterator.
|
|
||||||
CpuAccessibleBuffer::from_iter(device.clone(), BufferUsage::all(), data_iter).unwrap()
|
|
||||||
};
|
|
||||||
|
|
||||||
// In order to let the shader access the buffer, we need to build a *descriptor set* that
|
|
||||||
// contains the buffer.
|
|
||||||
//
|
|
||||||
// The resources that we bind to the descriptor set must match the resources expected by the
|
|
||||||
// pipeline which we pass as the first parameter.
|
|
||||||
//
|
|
||||||
// If you want to run the pipeline on multiple different buffers, you need to create multiple
|
|
||||||
// descriptor sets that each contain the buffer you want to run the shader on.
|
|
||||||
let set = Arc::new(PersistentDescriptorSet::start(pipeline.clone(), 0)
|
|
||||||
.add_buffer(data_buffer.clone()).unwrap()
|
|
||||||
.build().unwrap()
|
|
||||||
);
|
|
||||||
|
|
||||||
// In order to execute our operation, we have to build a command buffer.
|
|
||||||
let command_buffer = AutoCommandBufferBuilder::primary_one_time_submit(device.clone(), queue.family()).unwrap()
|
|
||||||
// The command buffer only does one thing: execute the compute pipeline.
|
|
||||||
// This is called a *dispatch* operation.
|
|
||||||
//
|
|
||||||
// Note that we clone the pipeline and the set. Since they are both wrapped around an
|
|
||||||
// `Arc`, this only clones the `Arc` and not the whole pipeline or set (which aren't
|
|
||||||
// cloneable anyway). In this example we would avoid cloning them since this is the last
|
|
||||||
// time we use them, but in a real code you would probably need to clone them.
|
|
||||||
.dispatch([1024, 1, 1], pipeline.clone(), set.clone(), ()).unwrap()
|
|
||||||
// Finish building the command buffer by calling `build`.
|
|
||||||
.build().unwrap();
|
|
||||||
|
|
||||||
// Let's execute this command buffer now.
|
|
||||||
// To do so, we TODO: this is a bit clumsy, probably needs a shortcut
|
|
||||||
let future = sync::now(device.clone())
|
|
||||||
.then_execute(queue.clone(), command_buffer).unwrap()
|
|
||||||
|
|
||||||
// This line instructs the GPU to signal a *fence* once the command buffer has finished
|
|
||||||
// execution. A fence is a Vulkan object that allows the CPU to know when the GPU has
|
|
||||||
// reached a certain point.
|
|
||||||
// We need to signal a fence here because below we want to block the CPU until the GPU has
|
|
||||||
// reached that point in the execution.
|
|
||||||
.then_signal_fence_and_flush().unwrap();
|
|
||||||
|
|
||||||
// Blocks execution until the GPU has finished the operation. This method only exists on the
|
|
||||||
// future that corresponds to a signalled fence. In other words, this method wouldn't be
|
|
||||||
// available if we didn't call `.then_signal_fence_and_flush()` earlier.
|
|
||||||
// The `None` parameter is an optional timeout.
|
|
||||||
//
|
|
||||||
// Note however that dropping the `future` variable (with `drop(future)` for example) would
|
|
||||||
// block execution as well, and this would be the case even if we didn't call
|
|
||||||
// `.then_signal_fence_and_flush()`.
|
|
||||||
// Therefore the actual point of calling `.then_signal_fence_and_flush()` and `.wait()` is to
|
|
||||||
// make things more explicit. In the future, if the Rust language gets linear types vulkano may
|
|
||||||
// get modified so that only fence-signalled futures can get destroyed like this.
|
|
||||||
future.wait(None).unwrap();
|
|
||||||
|
|
||||||
// Now that the GPU is done, the content of the buffer should have been modified. Let's
|
|
||||||
// check it out.
|
|
||||||
// The call to `read()` would return an error if the buffer was still in use by the GPU.
|
|
||||||
let data_buffer_content = data_buffer.read().unwrap();
|
|
||||||
for n in 0 .. 65536u32 {
|
|
||||||
assert_eq!(data_buffer_content[n as usize], n * 12);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
Loading…
Reference in new issue