hibana 0.5.2

Const-projected Affine Multiparty Session Types for choreography-first Rust protocols
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

//! Affine lane guard used by cursor endpoints.
//!
//! The guard is the detached RAII witness for a leased lane. `LaneLease`
//! creates it only after converting the borrow-bound rendezvous lease into a
//! `Port`, so the endpoint keeps only the shorter borrow lifetime.

use core::cell::Cell;
use core::marker::PhantomData;

use crate::runtime::{config::Clock, consts::LabelUniverse};
use crate::{
    control::cap::mint::EpochTbl, control::types::Lane, rendezvous::core::Rendezvous,
    transport::Transport,
};

/// Lease-backed lane guard.
///
/// Dropping the guard releases the lane via the underlying rendezvous.
/// The raw pointer erases the longer rendezvous lifetime; the shorter endpoint
/// borrow is carried by `active_leases`.
pub(crate) struct LaneGuard<'lease, T: Transport, U: LabelUniverse, C: Clock> {
    rendezvous: *const (),
    lane: Lane,
    active_leases: &'lease Cell<u32>,
    _marker: PhantomData<fn() -> (T, U, C)>,
}

impl<'lease, T, U, C> LaneGuard<'lease, T, U, C>
where
    T: Transport,
    U: LabelUniverse,
    C: Clock,
{
    pub(crate) fn new_detached(
        rendezvous: *const (),
        lane: Lane,
        active_leases: &'lease Cell<u32>,
    ) -> Self {
        Self {
            rendezvous,
            lane,
            active_leases,
            _marker: PhantomData,
        }
    }

    #[inline]
    pub(crate) fn detach_rendezvous(&mut self) {
        self.rendezvous = core::ptr::null();
    }
}

impl<'lease, T, U, C> Drop for LaneGuard<'lease, T, U, C>
where
    T: Transport,
    U: LabelUniverse,
    C: Clock,
{
    fn drop(&mut self) {
        let lane = self.lane;
        if !self.rendezvous.is_null() {
            unsafe {
                let rv = &*self
                    .rendezvous
                    .cast::<Rendezvous<'static, 'static, T, U, C, EpochTbl>>();
                if let Some(sid) = rv.release_lane(lane) {
                    rv.emit_lane_release(sid, lane);
                }
            }
        }

        let current = self.active_leases.get();
        debug_assert!(current > 0, "lane_release underflow");
        self.active_leases.set(current.saturating_sub(1));
    }
}