github/wgpu
1
1
Fork 0
mirror of https://github.com/gfx-rs/wgpu.git synced 2026-04-22 03:02:01 -04:00
Code Issues Packages Projects Releases Wiki Activity

Storage indexing

Browse Source
This commit is contained in:
Dzmitry Malyshau
2019-02-25 22:32:59 -05:00
parent dd73675868
commit 5b129704a0
9 changed files with 124 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
wgpu-native/src/command/compute.rs
View File

@@ -38,8 +38,7 @@ pub extern "C" fn wgpu_compute_pass_end_pass(pass_id: ComputePassId) -> CommandB
HUB.command_buffers
.write()
.get_mut(pass.cmb_id.value)
.raw
[pass.cmb_id.value].raw
.push(pass.raw);
pass.cmb_id.value
}
@@ -49,8 +48,7 @@ pub extern "C" fn wgpu_compute_pass_dispatch(pass_id: ComputePassId, x: u32, y:
unsafe {
HUB.compute_passes
.write()
.get_mut(pass_id)
.raw
[pass_id].raw
.dispatch([x, y, z]);
}
}
@@ -62,9 +60,9 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
bind_group_id: BindGroupId,
) {
let mut pass_guard = HUB.compute_passes.write();
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
let bind_group_guard = HUB.bind_groups.read();
let bind_group = bind_group_guard.get(bind_group_id);
let bind_group = &bind_group_guard[bind_group_id];
//Note: currently, WebGPU compute passes have synchronization defined
// at a dispatch granularity, so we insert the necessary barriers here.
@@ -81,10 +79,9 @@ pub extern "C" fn wgpu_compute_pass_set_bind_group(
if let Some(pipeline_layout_id) = pass.binder.provide_entry(index as usize, bind_group_id, bind_group) {
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let pipeline_layout = pipeline_layout_guard.get(pipeline_layout_id);
unsafe {
pass.raw.bind_compute_descriptor_sets(
&pipeline_layout.raw,
&pipeline_layout_guard[pipeline_layout_id].raw,
index as usize,
iter::once(&bind_group.raw),
&[],
@@ -99,9 +96,9 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
pipeline_id: ComputePipelineId,
) {
let mut pass_guard = HUB.compute_passes.write();
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
let pipeline_guard = HUB.compute_pipelines.read();
let pipeline = pipeline_guard.get(pipeline_id);
let pipeline = &pipeline_guard[pipeline_id];
unsafe {
pass.raw.bind_compute_pipeline(&pipeline.raw);
@@ -112,7 +109,7 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
}
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let pipeline_layout = pipeline_layout_guard.get(pipeline.layout_id);
let pipeline_layout = &pipeline_layout_guard[pipeline.layout_id];
let bing_group_guard = HUB.bind_groups.read();
pass.binder.pipeline_layout_id = Some(pipeline.layout_id.clone());
@@ -124,12 +121,12 @@ pub extern "C" fn wgpu_compute_pass_set_pipeline(
.enumerate()
{
if let Some(bg_id) = entry.expect_layout(bgl_id) {
let bind_group = bing_group_guard.get(bg_id);
let desc_set = &bing_group_guard[bg_id].raw;
unsafe {
pass.raw.bind_compute_descriptor_sets(
&pipeline_layout.raw,
index,
iter::once(&bind_group.raw),
iter::once(desc_set),
&[]
);
}

21
wgpu-native/src/command/mod.rs
View File

@@ -102,7 +102,7 @@ impl CommandBufferHandle {
{
let buffer_barriers = buffer_iter.map(|(id, transit)| {
let b = buffer_guard.get(id);
let b = &buffer_guard[id];
trace!("transit {:?} {:?}", id, transit);
hal::memory::Barrier::Buffer {
states: conv::map_buffer_state(transit.start) .. conv::map_buffer_state(transit.end),
@@ -112,7 +112,7 @@ impl CommandBufferHandle {
}
});
let texture_barriers = texture_iter.map(|(id, transit)| {
let t = texture_guard.get(id);
let t = &texture_guard[id];
trace!("transit {:?} {:?}", id, transit);
let aspects = t.full_range.aspects;
hal::memory::Barrier::Image {
@@ -148,7 +148,7 @@ pub extern "C" fn wgpu_command_encoder_finish(
) -> CommandBufferId {
HUB.command_buffers
.write()
.get_mut(command_encoder_id)
[command_encoder_id]
.is_recording = false; //TODO: check for the old value
command_encoder_id
}
@@ -158,9 +158,9 @@ pub fn command_encoder_begin_render_pass(
desc: RenderPassDescriptor,
) -> RenderPass<Backend> {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_encoder_id);
let cmb = &mut cmb_guard[command_encoder_id];
let device_guard = HUB.devices.read();
let device = device_guard.get(cmb.device_id.value);
let device = &device_guard[cmb.device_id.value];
let view_guard = HUB.texture_views.read();
let mut current_comb = device.com_allocator.extend(cmb);
@@ -187,7 +187,7 @@ pub fn command_encoder_begin_render_pass(
let swap_chain_links = &mut cmb.swap_chain_links;
let depth_stencil_key = depth_stencil_attachment.map(|at| {
let view = view_guard.get(at.attachment);
let view = &view_guard[at.attachment];
if let Some(ex) = extent {
assert_eq!(ex, view.extent);
} else {
@@ -213,13 +213,12 @@ pub fn command_encoder_begin_render_pass(
});
let color_keys = color_attachments.iter().map(|at| {
let view = view_guard.get(at.attachment);
let view = &view_guard[at.attachment];
if view.is_owned_by_swap_chain {
let link = match HUB.textures
.read()
.get(view.texture_id.value)
.swap_chain_link
[view.texture_id.value].swap_chain_link
{
Some(ref link) => SwapChainLink {
swap_chain_id: link.swap_chain_id.clone(),
@@ -308,7 +307,7 @@ pub fn command_encoder_begin_render_pass(
.key()
.attachments
.iter()
.map(|&id| &view_guard.get(id).raw);
.map(|&id| &view_guard[id].raw);
unsafe {
device
@@ -381,7 +380,7 @@ pub fn command_encoder_begin_compute_pass(
command_encoder_id: CommandEncoderId,
) -> ComputePass<Backend> {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_encoder_id);
let cmb = &mut cmb_guard[command_encoder_id];
let raw = cmb.raw.pop().unwrap();
let stored = Stored {

30
wgpu-native/src/command/render.rs
View File

@@ -38,7 +38,7 @@ pub extern "C" fn wgpu_render_pass_end_pass(pass_id: RenderPassId) -> CommandBuf
}
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(pass.cmb_id.value);
let cmb = &mut cmb_guard[pass.cmb_id.value];
match cmb.raw.last_mut() {
Some(ref mut last) => {
@@ -73,7 +73,7 @@ pub extern "C" fn wgpu_render_pass_set_index_buffer(
let mut pass_guard = HUB.render_passes.write();
let buffer_guard = HUB.buffers.read();
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
let buffer = pass.trackers.buffers
.get_with_extended_usage(
&*buffer_guard,
@@ -109,7 +109,7 @@ pub extern "C" fn wgpu_render_pass_set_vertex_buffers(
slice::from_raw_parts(offset_ptr, count)
};
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
for &id in buffers {
pass.trackers.buffers
.get_with_extended_usage(
@@ -122,7 +122,7 @@ pub extern "C" fn wgpu_render_pass_set_vertex_buffers(
let buffers = buffers
.iter()
.map(|&id| &buffer_guard.get(id).raw)
.map(|&id| &buffer_guard[id].raw)
.zip(offsets.iter().map(|&off| off as u64));
unsafe {
@@ -141,8 +141,7 @@ pub extern "C" fn wgpu_render_pass_draw(
unsafe {
HUB.render_passes
.write()
.get_mut(pass_id)
.raw
[pass_id].raw
.draw(
first_vertex .. first_vertex + vertex_count,
first_instance .. first_instance + instance_count,
@@ -162,8 +161,7 @@ pub extern "C" fn wgpu_render_pass_draw_indexed(
unsafe {
HUB.render_passes
.write()
.get_mut(pass_id)
.raw
[pass_id].raw
.draw_indexed(
first_index .. first_index + index_count,
base_vertex,
@@ -179,9 +177,9 @@ pub extern "C" fn wgpu_render_pass_set_bind_group(
bind_group_id: BindGroupId,
) {
let mut pass_guard = HUB.render_passes.write();
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
let bind_group_guard = HUB.bind_groups.read();
let bind_group = bind_group_guard.get(bind_group_id);
let bind_group = &bind_group_guard[bind_group_id];
pass.trackers.buffers
.consume_by_extend(&bind_group.used.buffers)
@@ -193,7 +191,7 @@ pub extern "C" fn wgpu_render_pass_set_bind_group(
if let Some(pipeline_layout_id) = pass.binder.provide_entry(index as usize, bind_group_id, bind_group) {
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let pipeline_layout = pipeline_layout_guard.get(pipeline_layout_id);
let pipeline_layout = &pipeline_layout_guard[pipeline_layout_id];
unsafe {
pass.raw.bind_graphics_descriptor_sets(
&pipeline_layout.raw,
@@ -211,9 +209,9 @@ pub extern "C" fn wgpu_render_pass_set_pipeline(
pipeline_id: RenderPipelineId,
) {
let mut pass_guard = HUB.render_passes.write();
let pass = pass_guard.get_mut(pass_id);
let pass = &mut pass_guard[pass_id];
let pipeline_guard = HUB.render_pipelines.read();
let pipeline = pipeline_guard.get(pipeline_id);
let pipeline = &pipeline_guard[pipeline_id];
unsafe {
pass.raw.bind_graphics_pipeline(&pipeline.raw);
@@ -224,7 +222,7 @@ pub extern "C" fn wgpu_render_pass_set_pipeline(
}
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let pipeline_layout = pipeline_layout_guard.get(pipeline.layout_id);
let pipeline_layout = &pipeline_layout_guard[pipeline.layout_id];
let bing_group_guard = HUB.bind_groups.read();
pass.binder.pipeline_layout_id = Some(pipeline.layout_id.clone());
@@ -236,12 +234,12 @@ pub extern "C" fn wgpu_render_pass_set_pipeline(
.enumerate()
{
if let Some(bg_id) = entry.expect_layout(bgl_id) {
let bind_group = bing_group_guard.get(bg_id);
let desc_set = &bing_group_guard[bg_id].raw;
unsafe {
pass.raw.bind_graphics_descriptor_sets(
&pipeline_layout.raw,
index,
iter::once(&bind_group.raw),
iter::once(desc_set),
&[]
);
}

8
wgpu-native/src/command/transfer.rs
View File

@@ -42,7 +42,7 @@ pub extern "C" fn wgpu_command_buffer_copy_buffer_to_buffer(
size: u32,
) {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_buffer_id);
let cmb = &mut cmb_guard[command_buffer_id];
let buffer_guard = HUB.buffers.read();
let (src_buffer, src_usage) = cmb.trackers.buffers
@@ -101,7 +101,7 @@ pub extern "C" fn wgpu_command_buffer_copy_buffer_to_texture(
copy_size: Extent3d,
) {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_buffer_id);
let cmb = &mut cmb_guard[command_buffer_id];
let buffer_guard = HUB.buffers.read();
let texture_guard = HUB.textures.read();
@@ -184,7 +184,7 @@ pub extern "C" fn wgpu_command_buffer_copy_texture_to_buffer(
copy_size: Extent3d,
) {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_buffer_id);
let cmb = &mut cmb_guard[command_buffer_id];
let buffer_guard = HUB.buffers.read();
let texture_guard = HUB.textures.read();
@@ -260,7 +260,7 @@ pub extern "C" fn wgpu_command_buffer_copy_texture_to_texture(
copy_size: Extent3d,
) {
let mut cmb_guard = HUB.command_buffers.write();
let cmb = cmb_guard.get_mut(command_buffer_id);
let cmb = &mut cmb_guard[command_buffer_id];
let texture_guard = HUB.textures.read();
let (src_texture, src_usage) = cmb.trackers.textures

148
wgpu-native/src/device.rs
View File

@@ -207,7 +207,7 @@ impl DestroyedResources<back::Backend> {
if num_refs <= 4 {
// assert_eq!(num_refs, 4);
let resource_id = self.mapped.swap_remove(i).value;
let buf = buffer_guard.get(resource_id);
let buf = &buffer_guard[resource_id];
let submit_index = buf.life_guard.submission_index.load(Ordering::Acquire);
match self
.active
@@ -225,7 +225,7 @@ impl DestroyedResources<back::Backend> {
let mut buffer_guard = HUB.buffers.write();
for buffer_id in self.ready_to_map.drain(..) {
let buffer = buffer_guard.get_mut(buffer_id);
let buffer = &mut buffer_guard[buffer_id];
let mut operation = None;
std::mem::swap(&mut operation, &mut buffer.pending_map_operation);
match operation {
@@ -363,7 +363,7 @@ pub fn device_create_buffer(
desc: &resource::BufferDescriptor,
) -> resource::Buffer<back::Backend> {
let device_guard = HUB.devices.read();
let device = &device_guard.get(device_id);
let device = &device_guard[device_id];
let (usage, memory_properties) = conv::map_buffer_usage(desc.usage);
let mut buffer = unsafe {
@@ -418,8 +418,7 @@ pub fn device_track_buffer(
) {
let query = HUB.devices
.read()
.get(device_id)
.trackers
[device_id].trackers
.lock()
.buffers
.query(buffer_id, &ref_count, resource::BufferUsageFlags::empty());
@@ -442,11 +441,10 @@ pub extern "C" fn wgpu_device_create_buffer(
#[no_mangle]
pub extern "C" fn wgpu_buffer_destroy(buffer_id: BufferId) {
let buffer_guard = HUB.buffers.read();
let buffer = buffer_guard.get(buffer_id);
let buffer = &buffer_guard[buffer_id];
HUB.devices
.read()
.get(buffer.device_id.value)
.destroyed
[buffer.device_id.value].destroyed
.lock()
.destroy(
ResourceId::Buffer(buffer_id),
@@ -463,7 +461,7 @@ pub fn device_create_texture(
let aspects = format.surface_desc().aspects;
let usage = conv::map_texture_usage(desc.usage, aspects);
let device_guard = HUB.devices.read();
let device = &device_guard.get(device_id);
let device = &device_guard[device_id];
let mut image = unsafe {
device.raw.create_image(
@@ -530,8 +528,7 @@ pub fn device_track_texture(
) {
let query = HUB.devices
.read()
.get(device_id)
.trackers
[device_id].trackers
.lock()
.textures
.query(texture_id, &ref_count, resource::TextureUsageFlags::UNINITIALIZED);
@@ -556,13 +553,12 @@ pub fn texture_create_view(
desc: &resource::TextureViewDescriptor,
) -> resource::TextureView<back::Backend> {
let texture_guard = HUB.textures.read();
let texture = texture_guard.get(texture_id);
let texture = &texture_guard[texture_id];
let raw = unsafe {
HUB.devices
.read()
.get(texture.device_id.value)
.raw
[texture.device_id.value].raw
.create_image_view(
&texture.raw,
conv::map_texture_view_dimension(desc.dimension),
@@ -598,13 +594,10 @@ pub fn device_track_view(
) {
let device_id = HUB.textures
.read()
.get(texture_id)
.device_id
.value;
[texture_id].device_id.value;
let initialized = HUB.devices
.read()
.get(device_id)
.trackers
[device_id].trackers
.lock()
.views
.query(view_id, &ref_count);
@@ -629,7 +622,7 @@ pub fn texture_create_default_view(
texture_id: TextureId
) -> resource::TextureView<back::Backend> {
let texture_guard = HUB.textures.read();
let texture = texture_guard.get(texture_id);
let texture = &texture_guard[texture_id];
let view_kind = match texture.kind {
hal::image::Kind::D1(_, 1) => hal::image::ViewKind::D1,
@@ -642,8 +635,7 @@ pub fn texture_create_default_view(
let raw = unsafe{
HUB.devices
.read()
.get(texture.device_id.value)
.raw
[texture.device_id.value].raw
.create_image_view(
&texture.raw,
view_kind,
@@ -682,11 +674,10 @@ pub extern "C" fn wgpu_texture_create_default_view(texture_id: TextureId) -> Tex
#[no_mangle]
pub extern "C" fn wgpu_texture_destroy(texture_id: TextureId) {
let texture_guard = HUB.textures.read();
let texture = texture_guard.get(texture_id);
let texture = &texture_guard[texture_id];
HUB.devices
.read()
.get(texture.device_id.value)
.destroyed
[texture.device_id.value].destroyed
.lock()
.destroy(
ResourceId::Texture(texture_id),
@@ -697,15 +688,13 @@ pub extern "C" fn wgpu_texture_destroy(texture_id: TextureId) {
#[no_mangle]
pub extern "C" fn wgpu_texture_view_destroy(texture_view_id: TextureViewId) {
let texture_view_guard = HUB.texture_views.read();
let view = texture_view_guard.get(texture_view_id);
let view = &texture_view_guard[texture_view_id];
let device_id = HUB.textures
.read()
.get(view.texture_id.value)
.device_id.value;
[view.texture_id.value].device_id.value;
HUB.devices
.read()
.get(device_id)
.destroyed
[device_id].destroyed
.lock()
.destroy(
ResourceId::TextureView(texture_view_id),
@@ -718,7 +707,7 @@ pub fn device_create_sampler(
device_id: DeviceId, desc: &resource::SamplerDescriptor
) -> resource::Sampler<back::Backend> {
let device_guard = HUB.devices.read();
let device = &device_guard.get(device_id);
let device = &device_guard[device_id];
let info = hal::image::SamplerInfo {
min_filter: conv::map_filter(desc.min_filter),
@@ -773,8 +762,7 @@ pub fn device_create_bind_group_layout(
let raw = unsafe {
HUB.devices
.read()
.get(device_id)
.raw
[device_id].raw
.create_descriptor_set_layout(
bindings.iter().map(|binding| {
hal::pso::DescriptorSetLayoutBinding {
@@ -815,14 +803,13 @@ pub fn device_create_pipeline_layout(
let bind_group_layout_guard = HUB.bind_group_layouts.read();
let descriptor_set_layouts = bind_group_layout_ids
.iter()
.map(|&id| &bind_group_layout_guard.get(id).raw);
.map(|&id| &bind_group_layout_guard[id].raw);
// TODO: push constants
let pipeline_layout = unsafe {
HUB.devices
.read()
.get(device_id)
.raw
[device_id].raw
.create_pipeline_layout(descriptor_set_layouts, &[])
}
.unwrap();
@@ -851,9 +838,9 @@ pub fn device_create_bind_group(
desc: &binding_model::BindGroupDescriptor,
) -> binding_model::BindGroup<back::Backend> {
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id];
let bind_group_layout_guard = HUB.bind_group_layouts.read();
let bind_group_layout = bind_group_layout_guard.get(desc.layout);
let bind_group_layout = &bind_group_layout_guard[desc.layout];
let bindings = unsafe {
slice::from_raw_parts(desc.bindings, desc.bindings_length as usize)
};
@@ -886,11 +873,11 @@ pub fn device_create_bind_group(
hal::pso::Descriptor::Buffer(&buffer.raw, range)
}
binding_model::BindingResource::Sampler(id) => {
let sampler = sampler_guard.get(id);
let sampler = &sampler_guard[id];
hal::pso::Descriptor::Sampler(&sampler.raw)
}
binding_model::BindingResource::TextureView(id) => {
let view = texture_view_guard.get(id);
let view = &texture_view_guard[id];
used.views.query(id, &view.life_guard.ref_count);
used.textures
.transit(
@@ -943,8 +930,7 @@ pub fn device_create_shader_module(
let shader = unsafe {
HUB.devices
.read()
.get(device_id)
.raw
[device_id].raw
.create_shader_module(spv)
.unwrap()
};
@@ -967,7 +953,7 @@ pub fn device_create_command_encoder(
_desc: &command::CommandEncoderDescriptor,
) -> command::CommandBuffer<back::Backend> {
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id];
let dev_stored = Stored {
value: device_id,
@@ -1005,7 +991,7 @@ pub extern "C" fn wgpu_queue_submit(
command_buffer_count: usize,
) {
let mut device_guard = HUB.devices.write();
let device = device_guard.get_mut(queue_id);
let device = &mut device_guard[queue_id];
let mut swap_chain_links = Vec::new();
let command_buffer_ids =
@@ -1027,23 +1013,17 @@ pub extern "C" fn wgpu_queue_submit(
// finish all the command buffers first
for &cmb_id in command_buffer_ids {
let comb = command_buffer_guard.get_mut(cmb_id);
let comb = &mut command_buffer_guard[cmb_id];
swap_chain_links.extend(comb.swap_chain_links.drain(..));
// update submission IDs
comb.life_guard.submission_index
.store(old_submit_index, Ordering::Release);
for id in comb.trackers.buffers.used() {
buffer_guard
.get(id)
.life_guard
.submission_index
buffer_guard[id].life_guard.submission_index
.store(old_submit_index, Ordering::Release);
}
for id in comb.trackers.textures.used() {
texture_guard
.get(id)
.life_guard
.submission_index
texture_guard[id].life_guard.submission_index
.store(old_submit_index, Ordering::Release);
}
@@ -1085,9 +1065,7 @@ pub extern "C" fn wgpu_queue_submit(
.into_iter()
.flat_map(|link| {
//TODO: check the epoch
surface_guard
.get(link.swap_chain_id)
.swap_chain
surface_guard[link.swap_chain_id].swap_chain
.as_ref()
.map(|swap_chain| (
&swap_chain.frames[link.image_index as usize].sem_available,
@@ -1100,7 +1078,7 @@ pub extern "C" fn wgpu_queue_submit(
//TODO: may `OneShot` be enough?
command_buffers: command_buffer_ids
.iter()
.flat_map(|&cmb_id| &command_buffer_guard.get(cmb_id).raw),
.flat_map(|&cmb_id| &command_buffer_guard[cmb_id].raw),
wait_semaphores,
signal_semaphores: &[], //TODO: signal `sem_present`?
};
@@ -1145,9 +1123,9 @@ pub fn device_create_render_pipeline(
desc: &pipeline::RenderPipelineDescriptor,
) -> pipeline::RenderPipeline<back::Backend> {
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id];
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let layout = &pipeline_layout_guard.get(desc.layout).raw;
let layout = &pipeline_layout_guard[desc.layout].raw;
let shader_module_guard = HUB.shader_modules.read();
let color_states = unsafe {
@@ -1218,7 +1196,7 @@ pub fn device_create_render_pipeline(
.to_str()
.to_owned()
.unwrap(), // TODO
module: &shader_module_guard.get(desc.vertex_stage.module).raw,
module: &shader_module_guard[desc.vertex_stage.module].raw,
specialization: hal::pso::Specialization {
// TODO
constants: &[],
@@ -1230,7 +1208,7 @@ pub fn device_create_render_pipeline(
.to_str()
.to_owned()
.unwrap(), // TODO
module: &shader_module_guard.get(desc.fragment_stage.module).raw,
module: &shader_module_guard[desc.fragment_stage.module].raw,
specialization: hal::pso::Specialization {
// TODO
constants: &[],
@@ -1360,9 +1338,9 @@ pub fn device_create_compute_pipeline(
desc: &pipeline::ComputePipelineDescriptor,
) -> pipeline::ComputePipeline<back::Backend> {
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id].raw;
let pipeline_layout_guard = HUB.pipeline_layouts.read();
let layout = &pipeline_layout_guard.get(desc.layout).raw;
let layout = &pipeline_layout_guard[desc.layout].raw;
let pipeline_stage = &desc.compute_stage;
let shader_module_guard = HUB.shader_modules.read();
@@ -1371,7 +1349,7 @@ pub fn device_create_compute_pipeline(
.to_str()
.to_owned()
.unwrap(), // TODO
module: &shader_module_guard.get(pipeline_stage.module).raw,
module: &shader_module_guard[pipeline_stage.module].raw,
specialization: hal::pso::Specialization {
// TODO
constants: &[],
@@ -1392,7 +1370,7 @@ pub fn device_create_compute_pipeline(
};
let pipeline = unsafe {
device.raw
device
.create_compute_pipeline(&pipeline_desc, None)
.unwrap()
};
@@ -1421,13 +1399,13 @@ pub fn device_create_swap_chain(
info!("creating swap chain {:?}", desc);
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id];
let mut surface_guard = HUB.surfaces.write();
let surface = surface_guard.get_mut(surface_id);
let surface = &mut surface_guard[surface_id];
let (caps, formats, _present_modes, _composite_alphas) = {
let adapter_guard = HUB.adapters.read();
let adapter = adapter_guard.get(device.adapter_id);
let adapter = &adapter_guard[device.adapter_id];
assert!(surface.raw.supports_queue_family(&adapter.queue_families[0]));
surface.raw.compatibility(&adapter.physical_device)
};
@@ -1533,13 +1511,11 @@ pub fn swap_chain_populate_textures(
textures: Vec<resource::Texture<back::Backend>>,
) {
let mut surface_guard = HUB.surfaces.write();
let swap_chain = surface_guard
.get_mut(swap_chain_id)
.swap_chain
let swap_chain = surface_guard[swap_chain_id].swap_chain
.as_mut()
.unwrap();
let device_guard = HUB.devices.read();
let device = device_guard.get(swap_chain.device_id.value);
let device = &device_guard[swap_chain.device_id.value];
let mut trackers = device.trackers.lock();
for (i, mut texture) in textures.into_iter().enumerate() {
@@ -1620,9 +1596,9 @@ pub extern "C" fn wgpu_buffer_set_sub_data(
start: u32, count: u32, data: *const u8,
) {
let buffer_guard = HUB.buffers.read();
let buffer = buffer_guard.get(buffer_id);
let buffer = &buffer_guard[buffer_id];
let mut device_guard = HUB.devices.write();
let device = device_guard.get_mut(buffer.device_id.value);
let device = &mut device_guard[buffer.device_id.value];
//Note: this is just doing `update_buffer`, which is limited to 64KB
@@ -1692,15 +1668,14 @@ pub extern "C" fn wgpu_buffer_map_read_async(
start: u32, size: u32, callback: BufferMapReadCallback, userdata: *mut u8,
) {
let mut buffer_guard = HUB.buffers.write();
let buffer = buffer_guard.get_mut(buffer_id);
let device_guard = HUB.devices.read();
let device = device_guard.get(buffer.device_id.value);
let buffer = &mut buffer_guard[buffer_id];
let range = start as u64..(start + size) as u64;
buffer.pending_map_operation = Some(BufferMapOperation::Read(range, callback, userdata));
device
.destroyed
HUB.devices
.read()
[buffer.device_id.value].destroyed
.lock()
.map(buffer_id, buffer.life_guard.ref_count.clone());
}
@@ -1711,15 +1686,14 @@ pub extern "C" fn wgpu_buffer_map_write_async(
start: u32, size: u32, callback: BufferMapWriteCallback, userdata: *mut u8,
) {
let mut buffer_guard = HUB.buffers.write();
let buffer = buffer_guard.get_mut(buffer_id);
let device_guard = HUB.devices.read();
let device = device_guard.get(buffer.device_id.value);
let buffer = &mut buffer_guard[buffer_id];
let range = start as u64..(start + size) as u64;
buffer.pending_map_operation = Some(BufferMapOperation::Write(range, callback, userdata));
device
.destroyed
HUB.devices
.read()
[buffer.device_id.value].destroyed
.lock()
.map(buffer_id, buffer.life_guard.ref_count.clone());
}
@@ -1729,9 +1703,9 @@ pub extern "C" fn wgpu_buffer_unmap(
buffer_id: BufferId,
) {
let mut buffer_guard = HUB.buffers.write();
let buffer = buffer_guard.get_mut(buffer_id);
let mut device_guard = HUB.devices.write();
let device = device_guard.get_mut(buffer.device_id.value);
let buffer = &mut buffer_guard[buffer_id];
let device_guard = HUB.devices.read();
let device = &device_guard[buffer.device_id.value];
if !buffer.mapped_write_ranges.is_empty() {
unsafe { device.raw.flush_mapped_memory_ranges( buffer.mapped_write_ranges.iter().map(|r| {(&buffer.memory, r.clone())}) ).unwrap() }; // TODO

10
wgpu-native/src/hub.rs
View File

@@ -83,13 +83,17 @@ pub struct Storage<T> {
map: VecMap<(T, Epoch)>,
}
impl<T> Storage<T> {
pub fn get(&self, id: Id) -> &T {
impl<T> ops::Index<Id> for Storage<T> {
type Output = T;
fn index(&self, id: Id) -> &T {
let (ref value, epoch) = self.map[id.0 as usize];
assert_eq!(epoch, id.1);
value
}
pub fn get_mut(&mut self, id: Id) -> &mut T {
}
impl<T> ops::IndexMut<Id> for Storage<T> {
fn index_mut(&mut self, id: Id) -> &mut T {
let (ref mut value, epoch) = self.map[id.0 as usize];
assert_eq!(epoch, id.1);
value

16
wgpu-native/src/instance.rs
View File

@@ -58,7 +58,7 @@ pub extern "C" fn wgpu_instance_create_surface_from_winit(
) -> SurfaceId {
let raw = HUB.instances
.read()
.get(instance_id)
[instance_id]
.create_surface(window);
let surface = SurfaceHandle::new(raw);
HUB.surfaces.register_local(surface)
@@ -76,7 +76,7 @@ pub fn instance_create_surface_from_xlib(
#[cfg(all(unix, feature = "gfx-backend-vulkan"))]
SurfaceHandle::new(HUB.instances
.read()
.get(instance_id)
[instance_id]
.create_surface_from_xlib(display, window)
)
}
@@ -103,7 +103,7 @@ pub fn instance_create_surface_from_macos_layer(
#[cfg(feature = "gfx-backend-metal")]
SurfaceHandle::new(HUB.instances
.read()
.get(instance_id)
[instance_id]
.create_surface_from_layer(layer as *mut _)
)
}
@@ -130,13 +130,13 @@ pub fn instance_create_surface_from_windows_hwnd(
#[cfg(any(feature = "gfx-backend-dx11", feature = "gfx-backend-dx12"))]
let raw = HUB.instances
.read()
.get(instance_id)
[instance_id]
.create_surface_from_hwnd(hwnd);
#[cfg(all(target_os = "windows", feature = "gfx-backend-vulkan"))]
let raw = HUB.instances
.read()
.get(instance_id)
[instance_id]
.create_surface_from_hwnd(hinstance, hwnd);
#[cfg_attr(not(target_os = "windows"), allow(unreachable_code))]
@@ -159,7 +159,7 @@ pub fn instance_get_adapter(
desc: &AdapterDescriptor,
) -> AdapterHandle {
let instance_guard = HUB.instances.read();
let instance = instance_guard.get(instance_id);
let instance = &instance_guard[instance_id];
let (mut low, mut high, mut other) = (None, None, None);
for adapter in instance.enumerate_adapters() {
match adapter.info.device_type {
@@ -190,8 +190,8 @@ pub fn adapter_create_device(
adapter_id: AdapterId,
_desc: &DeviceDescriptor,
) -> DeviceHandle {
let mut adapter_guard = HUB.adapters.write();
let adapter = adapter_guard.get_mut(adapter_id);
let adapter_guard = HUB.adapters.read();
let adapter = &adapter_guard[adapter_id];
let (raw, queue_group) = adapter.open_with::<_, hal::General>(1, |_qf| true).unwrap();
let mem_props = adapter.physical_device.memory_properties();
DeviceHandle::new(raw, adapter_id, queue_group, mem_props)

21
wgpu-native/src/swap_chain.rs
View File

@@ -95,8 +95,7 @@ pub extern "C" fn wgpu_swap_chain_get_next_texture(
let (image_index, device_id, descriptor) = {
let mut surface_guard = HUB.surfaces.write();
let swap_chain = surface_guard
.get_mut(swap_chain_id)
.swap_chain
[swap_chain_id].swap_chain
.as_mut()
.unwrap();
let sync = hal::FrameSync::Semaphore(&swap_chain.sem_available);
@@ -120,8 +119,7 @@ pub extern "C" fn wgpu_swap_chain_get_next_texture(
let mut surface_guard = HUB.surfaces.write();
let swap_chain = surface_guard
.get_mut(swap_chain_id)
.swap_chain
[swap_chain_id].swap_chain
.as_mut()
.unwrap();
@@ -134,7 +132,7 @@ pub extern "C" fn wgpu_swap_chain_get_next_texture(
};
let device_guard = HUB.devices.read();
let device = device_guard.get(device_id);
let device = &device_guard[device_id];
assert_ne!(swap_chain.acquired.len(), swap_chain.acquired.capacity(),
"Unable to acquire any more swap chain images before presenting");
@@ -146,11 +144,7 @@ pub extern "C" fn wgpu_swap_chain_get_next_texture(
}
mem::swap(&mut frame.sem_available, &mut swap_chain.sem_available);
match HUB.textures
.read()
.get(frame.texture_id.value)
.swap_chain_link
{
match HUB.textures.read()[frame.texture_id.value].swap_chain_link {
Some(ref link) => *link.epoch.lock() += 1,
None => unreachable!(),
}
@@ -167,8 +161,7 @@ pub extern "C" fn wgpu_swap_chain_present(
) {
let mut surface_guard = HUB.surfaces.write();
let swap_chain = surface_guard
.get_mut(swap_chain_id)
.swap_chain
[swap_chain_id].swap_chain
.as_mut()
.unwrap();
@@ -176,10 +169,10 @@ pub extern "C" fn wgpu_swap_chain_present(
let frame = &mut swap_chain.frames[image_index as usize];
let mut device_guard = HUB.devices.write();
let device = device_guard.get_mut(swap_chain.device_id.value);
let device = &mut device_guard[swap_chain.device_id.value];
let texture_guard = HUB.textures.read();
let texture = texture_guard.get(frame.texture_id.value);
let texture = &texture_guard[frame.texture_id.value];
match texture.swap_chain_link {
Some(ref link) => *link.epoch.lock() += 1,
None => unreachable!(),

6
wgpu-native/src/track.rs
View File

@@ -287,7 +287,7 @@ impl<U: Copy + GenericUsage + BitOr<Output = U> + PartialEq> Tracker<Id, U> {
usage: U,
permit: TrackPermit,
) -> Result<(&'a T, Tracktion<U>), U> {
let item = storage.get(id);
let item = &storage[id];
self.transit(id, item.borrow(), usage, permit)
.map(|tracktion| (item, tracktion))
}
@@ -298,7 +298,7 @@ impl<U: Copy + GenericUsage + BitOr<Output = U> + PartialEq> Tracker<Id, U> {
id: Id,
usage: U,
) -> Result<&'a T, U> {
let item = storage.get(id);
let item = &storage[id];
self.transit(id, item.borrow(), usage, TrackPermit::EXTEND)
.map(|_tracktion| item)
}
@@ -309,7 +309,7 @@ impl<U: Copy + GenericUsage + BitOr<Output = U> + PartialEq> Tracker<Id, U> {
id: Id,
usage: U,
) -> Result<(&'a T, Option<U>), U> {
let item = storage.get(id);
let item = &storage[id];
self.transit(id, item.borrow(), usage, TrackPermit::REPLACE)
.map(|tracktion| (item, match tracktion {
Tracktion::Init |