rendy_chain/chain/

link.rs

use crate::{
    node::State,
    resource::{AccessFlags, Resource},
    schedule::{QueueId, SubmissionId},
};

/// State of the link associated with queue.
/// Contains submissions range, combined access and stages bits by submissions from the range.
#[derive(Clone, Copy, Debug)]
pub struct LinkQueueState<R: Resource> {
    pub first: usize,
    pub last: usize,
    pub access: R::Access,
    pub stages: rendy_core::hal::pso::PipelineStage,
}

impl<R> LinkQueueState<R>
where
    R: Resource,
{
    fn new(node: &LinkNode<R>) -> Self {
        LinkQueueState {
            first: node.sid.index(),
            last: node.sid.index(),
            access: node.state.access,
            stages: node.state.stages,
        }
    }

    fn push(&mut self, node: &LinkNode<R>) {
        assert!(self.last < node.sid.index());
        self.access |= node.state.access;
        self.stages |= node.state.stages;
        self.last = node.sid.index();
    }
}

/// This type defines what states resource are at some point in time when commands recorded into
/// corresponding submissions are executed.
/// Those commands doesn't required to perform actions with all access types declared by the link.
/// But performing actions with access types not declared by the link is prohibited.
#[derive(Clone, Debug)]
pub struct Link<R: Resource> {
    /// Combination of all accesses.
    access: R::Access,

    /// Combination of all usages.
    usage: R::Usage,

    /// Common layout for all submissions.
    layout: R::Layout,

    /// Combination of all stages.
    stages: rendy_core::hal::pso::PipelineStage,

    /// Number of queues involved.
    queue_count: usize,

    /// State per queue.
    queues: Vec<Option<LinkQueueState<R>>>,

    /// Family of queues.
    family: rendy_core::hal::queue::QueueFamilyId,
}

/// Node for the link.
#[derive(Debug)]
pub struct LinkNode<R: Resource> {
    /// Submission id of the node.
    pub sid: SubmissionId,

    /// Resource state of the node.
    pub state: State<R>,
}

impl<R> Link<R>
where
    R: Resource,
{
    /// Create new link with first attached submission.
    ///
    /// # Parameters
    ///
    /// `access`    - Access flags performed in submission.
    /// `usage`     - Usage flags required by submission.
    pub fn new(node: LinkNode<R>) -> Self {
        let mut link = Link {
            access: node.state.access,
            usage: node.state.usage,
            layout: node.state.layout,
            stages: node.state.stages,
            queue_count: 1,
            queues: Vec::new(),
            family: node.sid.family(),
        };
        link.ensure_queue(node.sid.queue().index());
        link.queues[node.sid.queue().index()] = Some(LinkQueueState::new(&node));
        link
    }

    fn ensure_queue(&mut self, index: usize) {
        if index >= self.queues.len() {
            let reserve = index - self.queues.len() + 1;
            self.queues.reserve(reserve);
            while index >= self.queues.len() {
                self.queues.push(None);
            }
        }
    }

    /// Get queue family that owns the resource at the link.
    /// All associated submissions must be from the same queue family.
    pub fn family(&self) -> rendy_core::hal::queue::QueueFamilyId {
        self.family
    }

    /// Get usage.
    pub fn submission_state(&self, sid: SubmissionId) -> State<R> {
        assert_eq!(sid.family(), self.family);
        let lqs = self.queues[sid.queue().index()].as_ref().unwrap();
        State {
            access: lqs.access,
            layout: self.layout,
            stages: lqs.stages,
            usage: self.usage,
        }
    }

    /// Get usage.
    pub fn state(&self) -> State<R> {
        State {
            access: self.access,
            layout: self.layout,
            stages: self.stages,
            usage: self.usage,
        }
    }

    /// Get access.
    pub fn access(&self) -> R::Access {
        self.access
    }

    /// Get layout.
    pub fn layout(&self) -> R::Layout {
        self.layout
    }

    /// Get usage.
    pub fn usage(&self) -> R::Usage {
        self.usage
    }

    // /// Get usage.
    // pub fn stages(&self) -> rendy_core::hal::pso::PipelineStage {
    //     self.stages
    // }

    /// Check if the link is associated with only one queue.
    pub fn single_queue(&self) -> bool {
        self.queue_count == 1
    }

    /// Check if the given state and submission are compatible with link.
    /// If compatible then the submission can be associated with the link.
    pub fn compatible(&self, node: &LinkNode<R>) -> bool {
        // If queue the same and states are compatible.
        self.family == node.sid.family() && !(self.access | node.state.access).exclusive()
    }

    /// Insert submission with specified state to the link.
    /// It must be compatible.
    /// Associating submission with the link will allow the submission
    /// to be executed in parallel with other submissions associated with this link.
    /// Unless other chains disallow.
    ///
    /// # Panics
    ///
    /// This function will panic if `state` and `sid` are not compatible.
    /// E.g. `Link::compatible` didn't return `true` for the arguments.
    ///
    pub fn add_node(&mut self, node: LinkNode<R>) {
        assert_eq!(self.family, node.sid.family());
        self.ensure_queue(node.sid.queue().index());

        self.access |= node.state.access;
        self.usage |= node.state.usage;
        self.stages |= node.state.stages;

        match &mut self.queues[node.sid.queue().index()] {
            &mut Some(ref mut queue) => {
                queue.push(&node);
            }
            slot @ &mut None => {
                self.queue_count += 1;
                *slot = Some(LinkQueueState::new(&node));
            }
        }
    }

    // /// Check if ownership transfer is required between those links.
    // pub fn transfer_required(&self, next: &Self) -> bool {
    //     self.family != next.family
    // }

    /// Iterate over queues.
    pub fn queues(&self) -> impl Iterator<Item = (QueueId, &LinkQueueState<R>)> {
        let family = self.family;
        self.queues
            .iter()
            .enumerate()
            .filter_map(move |(index, queue)| {
                queue
                    .as_ref()
                    .map(move |queue| (QueueId::new(family, index), queue))
            })
    }

    /// Get particular queue
    pub fn queue(&self, qid: QueueId) -> &LinkQueueState<R> {
        assert_eq!(qid.family(), self.family);
        self.queues[qid.index()].as_ref().unwrap()
    }
}