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
77
78

use {
    crate::{Allocation, AllocationRequirements, AllocatorError},
    std::{cell::RefCell, rc::Rc},
};

/// Move an composable allocator into a Rc RefCell.
pub fn into_shared<T: ComposableAllocator>(allocator: T) -> Rc<RefCell<T>> {
    Rc::new(RefCell::new(allocator))
}

pub trait ComposableAllocator {
    /// Allocate GPU memory based on the given requirements.
    ///
    /// # Safety
    ///
    /// Unsafe because memory must be freed before the device is destroyed.
    unsafe fn allocate(
        &mut self,
        allocation_requirements: AllocationRequirements,
    ) -> Result<Allocation, AllocatorError>;

    /// Return a GPU memory allocation to the device.
    ///
    /// # Safety
    ///
    /// Unsafe because:
    ///  - memory must be freed by the application before the device is
    ///    destroyed
    ///  - the application is responsible for synchronizing access to device
    ///    memory. It is an error to free memory while ongoing GPU operations
    ///    are still referencing it.
    unsafe fn free(&mut self, allocation: Allocation);
}

impl ComposableAllocator for Box<dyn ComposableAllocator> {
    unsafe fn allocate(
        &mut self,
        allocation_requirements: AllocationRequirements,
    ) -> Result<Allocation, AllocatorError> {
        self.as_mut().allocate(allocation_requirements)
    }

    unsafe fn free(&mut self, allocation: Allocation) {
        self.as_mut().free(allocation)
    }
}

impl<T> ComposableAllocator for Box<T>
where
    T: ComposableAllocator,
{
    unsafe fn allocate(
        &mut self,
        allocation_requirements: AllocationRequirements,
    ) -> Result<Allocation, AllocatorError> {
        self.as_mut().allocate(allocation_requirements)
    }

    unsafe fn free(&mut self, allocation: Allocation) {
        self.as_mut().free(allocation)
    }
}

impl<T> ComposableAllocator for Rc<RefCell<T>>
where
    T: ComposableAllocator,
{
    unsafe fn allocate(
        &mut self,
        allocation_requirements: AllocationRequirements,
    ) -> Result<Allocation, AllocatorError> {
        self.borrow_mut().allocate(allocation_requirements)
    }

    unsafe fn free(&mut self, allocation: Allocation) {
        self.borrow_mut().free(allocation)
    }
}