change: move domain module to sync submodule

examples/01_basic/main.rs

@@ -4,8 +4,8 @@ use anyhow::Result;
 use futures::executor::block_on;
 
 use phobos::command_buffer::traits::*;
-use phobos::domain::All;
 use phobos::prelude::*;
+use phobos::sync::domain::All;
 use phobos::vk;
 
 use crate::example_runner::{Context, ExampleApp, ExampleRunner, load_spirv_file, WindowContext};

examples/03_raytracing/main.rs

@@ -5,9 +5,9 @@ use ash::vk;
 use glam::{Mat4, Vec3};
 use log::{info, trace};
 
-use phobos::domain::{All, Compute};
 use phobos::pipeline::raytracing::RayTracingPipelineBuilder;
 use phobos::prelude::*;
+use phobos::sync::domain::{All, Compute};
 use phobos::util::align::align;
 
 use crate::example_runner::{Context, create_shader, ExampleApp, ExampleRunner, load_spirv_file, save_dotfile, WindowContext};

src/command_buffer/compute.rs

@@ -4,9 +4,9 @@ use ash::vk;
 use crate::{Allocator, ComputeCmdBuffer, ComputeSupport, Error};
 use crate::command_buffer::IncompleteCommandBuffer;
 use crate::core::device::ExtensionID;
-use crate::domain::ExecutionDomain;
 use crate::query_pool::{AccelerationStructurePropertyQuery, QueryPool};
 use crate::raytracing::*;
+use crate::sync::domain::ExecutionDomain;
 
 impl<D: ComputeSupport + ExecutionDomain, A: Allocator> ComputeCmdBuffer for IncompleteCommandBuffer<'_, D, A> {
     /// Sets the current compute pipeline by looking up the given name in the pipeline cache.
@@ -16,7 +16,7 @@ impl<D: ComputeSupport + ExecutionDomain, A: Allocator> ComputeCmdBuffer for Inc
     /// # Example
     /// ```
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use anyhow::Result;
     /// // Assumes "my_pipeline" was previously added to the pipeline cache with `PipelineCache::create_named_compute_pipeline()`,
     /// // and that cmd was created with this cache.
@@ -56,7 +56,7 @@ impl<D: ComputeSupport + ExecutionDomain, A: Allocator> ComputeCmdBuffer for Inc
     /// # Example
     /// ```
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use anyhow::Result;
     /// // Assumes "my_pipeline" was previously added to the pipeline cache with `PipelineCache::create_named_compute_pipeline()`,
     /// // and that cmd was created with this cache.

src/command_buffer/graphics.rs

@@ -4,15 +4,15 @@ use ash::vk;
 use crate::{Allocator, BufferView, Error, GfxSupport, GraphicsCmdBuffer, ImageView};
 use crate::command_buffer::IncompleteCommandBuffer;
 use crate::core::device::ExtensionID;
-use crate::domain::ExecutionDomain;
+use crate::sync::domain::ExecutionDomain;
 
 impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for IncompleteCommandBuffer<'_, D, A> {
     /// Sets the viewport and scissor regions to the entire render area. Can only be called inside a renderpass.
     /// # Example
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn set_viewport<C: GraphicsCmdBuffer>(cmd: C) -> C {
     ///     // Now the current viewport and scissor cover the current attachment's entire area
     ///     cmd.full_viewport_scissor()
@@ -36,7 +36,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn set_viewport<C: GraphicsCmdBuffer>(cmd: C) -> C {
     ///     cmd.viewport(vk::Viewport {
     ///         x: 0.0,
@@ -60,7 +60,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn set_scissor<C: GraphicsCmdBuffer>(cmd: C) -> C {
     ///     cmd.scissor(vk::Rect2D {
     ///         offset: Default::default(),
@@ -86,7 +86,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn draw<C: GraphicsCmdBuffer>(cmd: C, vertex_buffer: &BufferView) -> Result<C> {
     ///     cmd.full_viewport_scissor()
     ///        .bind_graphics_pipeline("my_pipeline")?
@@ -111,7 +111,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn draw_indexed<C: GraphicsCmdBuffer>(cmd: C, vertex_buffer: &BufferView, index_buffer: &BufferView) -> Result<C> {
     ///     cmd.full_viewport_scissor()
     ///        .bind_graphics_pipeline("my_pipeline")?
@@ -164,7 +164,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// # Example
     /// ```
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use anyhow::Result;
     /// // Assumes "my_pipeline" was previously added to the pipeline cache with `PipelineCache::create_named_pipeline()`,
     /// // and that cmd was created with this cache.
@@ -194,7 +194,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn draw<C: GraphicsCmdBuffer>(cmd: C, vertex_buffer: &BufferView) -> Result<C> {
     ///     cmd.bind_vertex_buffer(0, vertex_buffer)
     ///        .draw(6, 1, 0, 0)
@@ -222,7 +222,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn draw_indexed<C: GraphicsCmdBuffer>(cmd: C, vertex_buffer: &BufferView, index_buffer: &BufferView) -> Result<C> {
     ///     cmd.bind_vertex_buffer(0, vertex_buffer)
     ///        .bind_index_buffer(index_buffer, vk::IndexType::UINT32)
@@ -281,7 +281,7 @@ impl<D: GfxSupport + ExecutionDomain, A: Allocator> GraphicsCmdBuffer for Incomp
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn set_polygon_mode<C: GraphicsCmdBuffer>(cmd: C) -> Result<C> {
     ///     // Subsequent drawcalls will get a wireframe view.
     ///     cmd.set_polygon_mode(vk::PolygonMode::LINE)

src/command_buffer/incomplete.rs

@@ -10,10 +10,10 @@ use crate::{Allocator, BufferView, DebugMessenger, DescriptorCache, DescriptorSe
 use crate::command_buffer::{CommandBuffer, IncompleteCommandBuffer};
 use crate::command_buffer::state::{RenderingAttachmentInfo, RenderingInfo};
 use crate::core::queue::Queue;
-use crate::domain::ExecutionDomain;
 use crate::pipeline::create_info::PipelineRenderingInfo;
 use crate::query_pool::{QueryPool, ScopedQuery, TimestampQuery};
 use crate::raytracing::acceleration_structure::AccelerationStructure;
+use crate::sync::domain::ExecutionDomain;
 
 impl<'q, D: ExecutionDomain, A: Allocator> IncompleteCmdBuffer<'q, A> for IncompleteCommandBuffer<'q, D, A> {
     type Domain = D;
@@ -67,7 +67,7 @@ impl<'q, D: ExecutionDomain, A: Allocator> IncompleteCmdBuffer<'q, A> for Incomp
     /// ```
     /// # use phobos::*;
     /// # use anyhow::Result;
-    /// # use phobos::domain::{ExecutionDomain, Graphics};
+    /// # use phobos::sync::domain::{ExecutionDomain, Graphics};
     /// fn finish_command_buffer<D: ExecutionDomain>(cmd: IncompleteCommandBuffer<D>) -> Result<CommandBuffer<D>> {
     ///     // Releases the lock on a queue associated with the domain `D`, allowing other command
     ///     // buffers to start recording on this domain.
@@ -183,7 +183,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// reflect this change. This function is not extremely useful at the moment.
     /// # Example
     /// ```
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::{BufferView, IncompleteCommandBuffer};
     /// # use anyhow::Result;
     /// fn use_descriptor_forget<'q, D: ExecutionDomain>(cmd: IncompleteCommandBuffer<'q, D>, buffer: &BufferView, other_buffer: &BufferView) -> Result<IncompleteCommandBuffer<'q, D>> {
@@ -210,7 +210,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use anyhow::Result;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::*;
     /// fn use_resolve_and_bind<'q, D: ExecutionDomain>(cmd: IncompleteCommandBuffer<'q, D>, image: &ImageView, sampler: &Sampler) -> Result<IncompleteCommandBuffer<'q, D>> {
     ///     let resource = VirtualResource::image("image");
@@ -243,7 +243,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use anyhow::Result;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::*;
     /// fn use_bind_sampled_image<'q, D: ExecutionDomain + GfxSupport>(cmd: IncompleteCommandBuffer<'q, D>, image: &ImageView, sampler: &Sampler) -> Result<IncompleteCommandBuffer<'q, D>> {
     ///     cmd.bind_sampled_image(0, 0, image, sampler)?
@@ -266,7 +266,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use anyhow::Result;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::*;
     /// fn use_bind_uniform_buffer<'q, D: ExecutionDomain + GfxSupport>(cmd: IncompleteCommandBuffer<'q, D>, buffer: &BufferView) -> Result<IncompleteCommandBuffer<'q, D>> {
     ///     cmd.bind_uniform_buffer(0, 0, buffer)?
@@ -289,7 +289,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use anyhow::Result;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::*;
     /// fn use_bind_storage_buffer<'q, D: ExecutionDomain + GfxSupport>(cmd: IncompleteCommandBuffer<'q, D>, buffer: &BufferView) -> Result<IncompleteCommandBuffer<'q, D>> {
     ///     cmd.bind_storage_buffer(0, 0, buffer)?
@@ -314,7 +314,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use anyhow::Result;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use phobos::*;
     /// fn use_bind_storage_image<'q, D: ExecutionDomain + GfxSupport>(cmd: IncompleteCommandBuffer<'q, D>, image: &ImageView) -> Result<IncompleteCommandBuffer<'q, D>> {
     ///     cmd.bind_storage_image(0, 0, image)?
@@ -435,7 +435,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// fn use_push_constant<D: ExecutionDomain>(cmd: IncompleteCommandBuffer<D>) -> IncompleteCommandBuffer<D> {
     ///     // Assumes a pipeline is bound, and that this pipeline has a vertex shader with the specified push constant range.
     ///     let data: f32 = 1.0;
@@ -450,7 +450,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// # Example
     /// ```
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// fn use_push_constants<D: ExecutionDomain>(cmd: IncompleteCommandBuffer<D>) -> IncompleteCommandBuffer<D> {
     ///     // Assumes a pipeline is bound, and that this pipeline has a vertex shader with the specified push constant range.
     ///     let data: [f32; 2] = [64.0, 32.0];
@@ -497,7 +497,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// ```
     /// # use log::warn;
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use anyhow::Result;
     /// fn check_pipeline_cache<D: ExecutionDomain + GfxSupport>(cmd: IncompleteCommandBuffer<D>) -> Result<IncompleteCommandBuffer<D>> {
     ///     if cmd.has_pipeline_cache() {
@@ -517,7 +517,7 @@ impl<D: ExecutionDomain, A: Allocator> IncompleteCommandBuffer<'_, D, A> {
     /// ```
     /// # use log::warn;
     /// # use phobos::*;
-    /// # use phobos::domain::ExecutionDomain;
+    /// # use phobos::sync::domain::ExecutionDomain;
     /// # use anyhow::Result;
     /// fn check_descriptor_cache<D: ExecutionDomain>(cmd: IncompleteCommandBuffer<D>, buffer: &BufferView) -> Result<IncompleteCommandBuffer<D>> {
     ///     if cmd.has_descriptor_cache() {

src/command_buffer/mod.rs

@@ -34,8 +34,8 @@ use ash::vk;
 
 use crate::{Allocator, CmdBuffer, DefaultAllocator, DescriptorCache, DescriptorSetBuilder, Device, Error, ExecutionManager, PipelineCache};
 use crate::core::queue::Queue;
-use crate::domain::ExecutionDomain;
 use crate::pipeline::create_info::PipelineRenderingInfo;
+use crate::sync::domain::ExecutionDomain;
 
 pub mod compute;
 pub mod graphics;
@@ -51,7 +51,7 @@ pub(crate) mod state;
 /// # Example
 /// ```
 /// # use phobos::*;
-/// # use phobos::domain::ExecutionDomain;
+/// # use phobos::sync::domain::ExecutionDomain;
 /// # use anyhow::Result;
 ///
 /// fn finish_and_wait<D: ExecutionDomain + 'static>(exec: ExecutionManager, cmd: IncompleteCommandBuffer<D>) -> Result<()> {
@@ -74,7 +74,7 @@ pub struct CommandBuffer<D: ExecutionDomain> {
 /// # Example
 /// ```
 /// # use phobos::*;
-/// # use phobos::domain::{ExecutionDomain, Graphics};
+/// # use phobos::sync::domain::{ExecutionDomain, Graphics};
 /// # use anyhow::Result;
 /// fn submit_some_commands(exec: ExecutionManager) -> Result<()> {
 ///     let cmd: IncompleteCommandBuffer<Graphics> = exec.on_domain::<Graphics>(None, None)?;

src/command_buffer/traits.rs

@@ -3,12 +3,13 @@ use std::sync::MutexGuard;
 use anyhow::Result;
 use ash::vk;
 
-use crate::{Allocator, BufferView, DescriptorCache, Device, domain, ExecutionManager, ImageView, PipelineCache};
+use crate::{Allocator, BufferView, DescriptorCache, Device, ExecutionManager, ImageView, PipelineCache};
 use crate::command_buffer::CommandBuffer;
 use crate::core::queue::Queue;
-use crate::domain::ExecutionDomain;
 use crate::query_pool::{AccelerationStructurePropertyQuery, QueryPool};
 use crate::raytracing::*;
+use crate::sync::domain;
+use crate::sync::domain::ExecutionDomain;
 
 /// Trait representing a command buffer that supports transfer commands.
 pub trait TransferCmdBuffer {

src/command_buffer/transfer.rs

@@ -3,7 +3,7 @@ use ash::vk;
 
 use crate::{Allocator, BufferView, Error, ImageView, TransferCmdBuffer, TransferSupport};
 use crate::command_buffer::IncompleteCommandBuffer;
-use crate::domain::ExecutionDomain;
+use crate::sync::domain::ExecutionDomain;
 
 impl<D: TransferSupport + ExecutionDomain, A: Allocator> TransferCmdBuffer for IncompleteCommandBuffer<'_, D, A> {
     /// Copy one buffer to the other.
@@ -13,7 +13,7 @@ impl<D: TransferSupport + ExecutionDomain, A: Allocator> TransferCmdBuffer for I
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn copy_buffer<C: TransferCmdBuffer>(cmd: C, src: &BufferView, dst: &BufferView) -> Result<C> {
     ///     cmd.copy_buffer(src, dst)
     /// }
@@ -42,7 +42,7 @@ impl<D: TransferSupport + ExecutionDomain, A: Allocator> TransferCmdBuffer for I
     /// ```
     /// # use anyhow::Result;
     /// # use phobos::*;
-    /// # use phobos::domain::*;
+    /// # use phobos::sync::domain::*;
     /// fn copy_buffer_to_image<C: TransferCmdBuffer>(cmd: C, src: &BufferView, dst: &ImageView) -> Result<C> {
     ///     cmd.copy_buffer_to_image(src, dst)
     /// }

src/graph/pass.rs

@@ -77,10 +77,10 @@ use ash::vk;
 
 use crate::{Allocator, DefaultAllocator, Error, InFlightContext, PhysicalResourceBindings, VirtualResource};
 use crate::command_buffer::IncompleteCommandBuffer;
-use crate::domain::ExecutionDomain;
 use crate::graph::pass_graph::PassResource;
 use crate::graph::resource::{AttachmentType, ResourceUsage};
 use crate::pipeline::PipelineStage;
+use crate::sync::domain::ExecutionDomain;
 
 /// The returned value from a pass callback function.
 pub type PassFnResult<'q, D, A> = Result<IncompleteCommandBuffer<'q, D, A>>;

src/graph/pass_graph.rs

@@ -11,12 +11,12 @@ use petgraph::graph::NodeIndex;
 use petgraph::prelude::EdgeRef;
 
 use crate::{Allocator, DefaultAllocator, Error};
-use crate::domain::ExecutionDomain;
 use crate::graph::pass::{BoxedPassFn, EmptyPassExecutor, Pass};
 use crate::graph::resource::ResourceUsage;
 use crate::graph::task_graph::{Barrier, Node, Resource, Task, TaskGraph};
 use crate::graph::virtual_resource::VirtualResource;
 use crate::pipeline::PipelineStage;
+use crate::sync::domain::ExecutionDomain;
 
 /// Virtual GPU resource in a task graph.
 #[derive(Derivative, Default, Clone)]

src/graph/record.rs

@@ -11,11 +11,11 @@ use petgraph::visit::EdgeRef;
 use crate::{Allocator, BufferView, DebugMessenger, Error, ImageView, InFlightContext, PassGraph, PhysicalResourceBindings};
 use crate::command_buffer::IncompleteCommandBuffer;
 use crate::command_buffer::state::{RenderingAttachmentInfo, RenderingInfo};
-use crate::domain::ExecutionDomain;
 use crate::graph::pass_graph::{BuiltPassGraph, PassNode, PassResource, PassResourceBarrier};
 use crate::graph::physical_resource::PhysicalResource;
 use crate::graph::resource::{AttachmentType, ResourceUsage};
 use crate::graph::task_graph::{Node, Resource};
+use crate::sync::domain::ExecutionDomain;
 
 pub trait RecordGraphToCommandBuffer<D: ExecutionDomain, U, A: Allocator> {
     /// Records a render graph to a command buffer. This also takes in a set of physical bindings to resolve virtual resource names

src/lib.rs

@@ -106,7 +106,6 @@ pub mod allocator;
 pub mod command_buffer;
 pub mod core;
 pub mod descriptor;
-pub mod domain;
 pub mod graph;
 pub mod pipeline;
 pub mod sync;

src/prelude.rs

@@ -18,7 +18,6 @@ pub use crate::core::queue::QueueType;
 pub use crate::descriptor::builder::DescriptorSetBuilder;
 pub use crate::descriptor::cache::DescriptorCache;
 pub use crate::descriptor::descriptor_set::DescriptorSet;
-pub use crate::domain;
 pub use crate::graph::pass::{Pass, PassBuilder};
 pub use crate::graph::pass_graph::PassGraph;
 pub use crate::graph::physical_resource::PhysicalResourceBindings;
@@ -37,6 +36,8 @@ pub use crate::resource::image::{Image, ImageView};
 pub use crate::resource::query_pool::*;
 pub use crate::resource::raytracing::*;
 pub use crate::sampler::Sampler;
+pub use crate::sync::domain;
+pub use crate::sync::domain;
 pub use crate::sync::execution_manager::ExecutionManager;
 pub use crate::sync::fence::*;
 pub use crate::sync::semaphore::*;

src/sync/execution_manager.rs

@@ -7,7 +7,7 @@ use ash::vk;
 use crate::{Allocator, CmdBuffer, DescriptorCache, Device, Error, Fence, PhysicalDevice, PipelineCache};
 use crate::command_buffer::*;
 use crate::core::queue::{DeviceQueue, Queue};
-use crate::domain::ExecutionDomain;
+use crate::sync::domain::ExecutionDomain;
 use crate::sync::submit_batch::SubmitBatch;
 
 /// The execution manager is responsible for allocating command buffers on correct

src/sync/mod.rs

@@ -16,3 +16,4 @@ pub mod fence;
 pub mod semaphore;
 pub mod submit_batch;
 pub mod thread_context;
+pub mod domain;