oak-team/oak-gpui
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use a safe API for Arena

Browse Source
This commit is contained in:
Antonio Scandurra
2023-12-15 19:03:37 +01:00
parent be73dd852d
commit 0a57171066
3 changed files with 134 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/gpui2/src/arena.rs
+94 -56
View File
@@ -1,40 +1,49 @@
use std::{
alloc,
cell::Cell,
ops::{Deref, DerefMut},
ptr::{self, NonNull},
rc::Rc,
};
pub struct Arena {
start: NonNull<u8>,
offset: usize,
elements: Vec<ArenaElement>,
}
impl Default for Arena {
fn default() -> Self {
unsafe {
let layout = alloc::Layout::from_size_align(16 * 1024 * 1024, 1).unwrap();
let ptr = alloc::alloc(layout);
Self {
start: NonNull::new_unchecked(ptr),
offset: 0,
elements: Vec::new(),
}
}
}
}
struct ArenaElement {
value: NonNull<u8>,
drop: unsafe fn(NonNull<u8>),
}
impl Drop for ArenaElement {
fn drop(&mut self) {
unsafe {
(self.drop)(self.value);
}
}
}
pub struct Arena {
start: NonNull<u8>,
offset: usize,
elements: Vec<ArenaElement>,
valid: Rc<Cell<bool>>,
}
impl Arena {
pub fn clear(&mut self) {
for element in self.elements.drain(..) {
unsafe {
(element.drop)(element.value);
pub fn new(size_in_bytes: usize) -> Self {
unsafe {
let layout = alloc::Layout::from_size_align(size_in_bytes, 1).unwrap();
let ptr = alloc::alloc(layout);
Self {
start: NonNull::new_unchecked(ptr),
offset: 0,
elements: Vec::new(),
valid: Rc::new(Cell::new(true)),
}
}
}
pub fn clear(&mut self) {
self.valid.set(false);
self.valid = Rc::new(Cell::new(true));
self.elements.clear();
self.offset = 0;
}
@@ -46,42 +55,71 @@ impl Arena {
unsafe {
let layout = alloc::Layout::for_value(&value).pad_to_align();
let value_ptr = self.start.as_ptr().add(self.offset).cast::<T>();
ptr::write(value_ptr, value);
let ptr = NonNull::new_unchecked(self.start.as_ptr().add(self.offset).cast::<T>());
ptr::write(ptr.as_ptr(), value);
let value = NonNull::new_unchecked(value_ptr);
self.elements.push(ArenaElement {
value: value.cast(),
value: ptr.cast(),
drop: drop::<T>,
});
self.offset += layout.size();
ArenaRef(value)
ArenaRef {
ptr,
valid: self.valid.clone(),
}
}
}
}
pub struct ArenaRef<T: ?Sized>(NonNull<T>);
impl Drop for Arena {
fn drop(&mut self) {
self.clear();
}
}
impl<T: ?Sized> Copy for ArenaRef<T> {}
pub struct ArenaRef<T: ?Sized> {
ptr: NonNull<T>,
valid: Rc<Cell<bool>>,
}
impl<T: ?Sized> Clone for ArenaRef<T> {
fn clone(&self) -> Self {
Self(self.0)
Self {
ptr: self.ptr,
valid: self.valid.clone(),
}
}
}
impl<T: ?Sized> ArenaRef<T> {
pub unsafe fn map<U: ?Sized>(mut self, f: impl FnOnce(&mut T) -> &mut U) -> ArenaRef<U> {
let u = f(self.get_mut());
ArenaRef(NonNull::new_unchecked(u))
pub fn map<U: ?Sized>(mut self, f: impl FnOnce(&mut T) -> &mut U) -> ArenaRef<U> {
ArenaRef {
ptr: unsafe { NonNull::new_unchecked(f(&mut *self)) },
valid: self.valid,
}
}
pub unsafe fn get(&self) -> &T {
self.0.as_ref()
fn validate(&self) {
assert!(
self.valid.get(),
"attempted to dereference an ArenaRef after its Arena was cleared"
);
}
}
pub unsafe fn get_mut(&mut self) -> &mut T {
self.0.as_mut()
impl<T: ?Sized> Deref for ArenaRef<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
self.validate();
unsafe { self.ptr.as_ref() }
}
}
impl<T: ?Sized> DerefMut for ArenaRef<T> {
fn deref_mut(&mut self) -> &mut Self::Target {
self.validate();
unsafe { self.ptr.as_mut() }
}
}
@@ -93,25 +131,25 @@ mod tests {
#[test]
fn test_arena() {
let mut arena = Arena::default();
let mut a = arena.alloc(1u64);
let mut b = arena.alloc(2u32);
let mut c = arena.alloc(3u16);
let mut d = arena.alloc(4u8);
assert_eq!(unsafe { *a.get_mut() }, 1);
assert_eq!(unsafe { *b.get_mut() }, 2);
assert_eq!(unsafe { *c.get_mut() }, 3);
assert_eq!(unsafe { *d.get_mut() }, 4);
let mut arena = Arena::new(1024);
let a = arena.alloc(1u64);
let b = arena.alloc(2u32);
let c = arena.alloc(3u16);
let d = arena.alloc(4u8);
assert_eq!(*a, 1);
assert_eq!(*b, 2);
assert_eq!(*c, 3);
assert_eq!(*d, 4);
arena.clear();
let mut a = arena.alloc(5u64);
let mut b = arena.alloc(6u32);
let mut c = arena.alloc(7u16);
let mut d = arena.alloc(8u8);
assert_eq!(unsafe { *a.get_mut() }, 5);
assert_eq!(unsafe { *b.get_mut() }, 6);
assert_eq!(unsafe { *c.get_mut() }, 7);
assert_eq!(unsafe { *d.get_mut() }, 8);
let a = arena.alloc(5u64);
let b = arena.alloc(6u32);
let c = arena.alloc(7u16);
let d = arena.alloc(8u8);
assert_eq!(*a, 5);
assert_eq!(*b, 6);
assert_eq!(*c, 7);
assert_eq!(*d, 8);
// Ensure drop gets called.
let dropped = Rc::new(Cell::new(false));
crates/gpui2/src/element.rs
+6 -6
View File
@@ -415,16 +415,16 @@ impl AnyElement {
{
let element =
FRAME_ARENA.with_borrow_mut(|arena| arena.alloc(Some(DrawableElement::new(element))));
let element = unsafe { element.map(|element| element as &mut dyn ElementObject) };
let element = element.map(|element| element as &mut dyn ElementObject);
AnyElement(element)
}
pub fn layout(&mut self, cx: &mut WindowContext) -> LayoutId {
unsafe { self.0.get_mut() }.layout(cx)
self.0.layout(cx)
}
pub fn paint(&mut self, cx: &mut WindowContext) {
unsafe { self.0.get_mut() }.paint(cx)
self.0.paint(cx)
}
/// Initializes this element and performs layout within the given available space to determine its size.
@@ -433,7 +433,7 @@ impl AnyElement {
available_space: Size<AvailableSpace>,
cx: &mut WindowContext,
) -> Size<Pixels> {
unsafe { self.0.get_mut() }.measure(available_space, cx)
self.0.measure(available_space, cx)
}
/// Initializes this element and performs layout in the available space, then paints it at the given origin.
@@ -443,11 +443,11 @@ impl AnyElement {
available_space: Size<AvailableSpace>,
cx: &mut WindowContext,
) {
unsafe { self.0.get_mut() }.draw(origin, available_space, cx)
self.0.draw(origin, available_space, cx)
}
pub fn inner_id(&self) -> Option<ElementId> {
unsafe { self.0.get() }.element_id()
self.0.element_id()
}
}
crates/gpui2/src/window.rs
+34 -36
View File
@@ -99,7 +99,7 @@ struct FocusEvent {
slotmap::new_key_type! { pub struct FocusId; }
thread_local! {
pub static FRAME_ARENA: RefCell<Arena> = RefCell::new(Arena::default());
pub static FRAME_ARENA: RefCell<Arena> = RefCell::new(Arena::new(16 * 1024 * 1024));
}
impl FocusId {
@@ -829,14 +829,15 @@ impl<'a> WindowContext<'a> {
mut handler: impl FnMut(&Event, DispatchPhase, &mut WindowContext) + 'static,
) {
let order = self.window.next_frame.z_index_stack.clone();
let handler = FRAME_ARENA.with_borrow_mut(|arena| {
arena.alloc(
move |event: &dyn Any, phase: DispatchPhase, cx: &mut WindowContext<'_>| {
handler(event.downcast_ref().unwrap(), phase, cx)
},
)
});
let handler = unsafe { handler.map(|handler| handler as _) };
let handler = FRAME_ARENA
.with_borrow_mut(|arena| {
arena.alloc(
move |event: &dyn Any, phase: DispatchPhase, cx: &mut WindowContext<'_>| {
handler(event.downcast_ref().unwrap(), phase, cx)
},
)
})
.map(|handler| handler as _);
self.window
.next_frame
.mouse_listeners
@@ -855,14 +856,15 @@ impl<'a> WindowContext<'a> {
&mut self,
listener: impl Fn(&Event, DispatchPhase, &mut WindowContext) + 'static,
) {
let listener = FRAME_ARENA.with_borrow_mut(|arena| {
arena.alloc(move |event: &dyn Any, phase, cx: &mut WindowContext<'_>| {
if let Some(event) = event.downcast_ref::<Event>() {
listener(event, phase, cx)
}
let listener = FRAME_ARENA
.with_borrow_mut(|arena| {
arena.alloc(move |event: &dyn Any, phase, cx: &mut WindowContext<'_>| {
if let Some(event) = event.downcast_ref::<Event>() {
listener(event, phase, cx)
}
})
})
});
let listener = unsafe { listener.map(|handler| handler as _) };
.map(|handler| handler as _);
self.window.next_frame.dispatch_tree.on_key_event(listener);
}
@@ -877,8 +879,9 @@ impl<'a> WindowContext<'a> {
action_type: TypeId,
listener: impl Fn(&dyn Any, DispatchPhase, &mut WindowContext) + 'static,
) {
let listener = FRAME_ARENA.with_borrow_mut(|arena| arena.alloc(listener));
let listener = unsafe { listener.map(|handler| handler as _) };
let listener = FRAME_ARENA
.with_borrow_mut(|arena| arena.alloc(listener))
.map(|handler| handler as _);
self.window
.next_frame
.dispatch_tree
@@ -1284,14 +1287,15 @@ impl<'a> WindowContext<'a> {
cx.with_key_dispatch(Some(KeyContext::default()), None, |_, cx| {
for (action_type, action_listeners) in &cx.app.global_action_listeners {
for action_listener in action_listeners.iter().cloned() {
let listener = FRAME_ARENA.with_borrow_mut(|arena| {
arena.alloc(
move |action: &dyn Any, phase, cx: &mut WindowContext<'_>| {
action_listener(action, phase, cx)
},
)
});
let listener = unsafe { listener.map(|listener| listener as _) };
let listener = FRAME_ARENA
.with_borrow_mut(|arena| {
arena.alloc(
move |action: &dyn Any, phase, cx: &mut WindowContext<'_>| {
action_listener(action, phase, cx)
},
)
})
.map(|listener| listener as _);
cx.window
.next_frame
.dispatch_tree
@@ -1478,7 +1482,6 @@ impl<'a> WindowContext<'a> {
// Capture phase, events bubble from back to front. Handlers for this phase are used for
// special purposes, such as detecting events outside of a given Bounds.
for (_, handler) in &mut handlers {
let handler = unsafe { handler.get_mut() };
handler(event, DispatchPhase::Capture, self);
if !self.app.propagate_event {
break;
@@ -1488,7 +1491,6 @@ impl<'a> WindowContext<'a> {
// Bubble phase, where most normal handlers do their work.
if self.app.propagate_event {
for (_, handler) in handlers.iter_mut().rev() {
let handler = unsafe { handler.get_mut() };
handler(event, DispatchPhase::Bubble, self);
if !self.app.propagate_event {
break;
@@ -1538,8 +1540,7 @@ impl<'a> WindowContext<'a> {
context_stack.push(context);
}
for mut key_listener in node.key_listeners.clone() {
let key_listener = unsafe { key_listener.get_mut() };
for key_listener in node.key_listeners.clone() {
key_listener(event, DispatchPhase::Capture, self);
if !self.propagate_event {
return;
@@ -1551,8 +1552,7 @@ impl<'a> WindowContext<'a> {
for node_id in dispatch_path.iter().rev() {
// Handle low level key events
let node = self.window.rendered_frame.dispatch_tree.node(*node_id);
for mut key_listener in node.key_listeners.clone() {
let key_listener = unsafe { key_listener.get_mut() };
for key_listener in node.key_listeners.clone() {
key_listener(event, DispatchPhase::Bubble, self);
if !self.propagate_event {
return;
@@ -1604,12 +1604,11 @@ impl<'a> WindowContext<'a> {
let node = self.window.rendered_frame.dispatch_tree.node(*node_id);
for DispatchActionListener {
action_type,
mut listener,
listener,
} in node.action_listeners.clone()
{
let any_action = action.as_any();
if action_type == any_action.type_id() {
let listener = unsafe { listener.get_mut() };
listener(any_action, DispatchPhase::Capture, self);
if !self.propagate_event {
return;
@@ -1622,13 +1621,12 @@ impl<'a> WindowContext<'a> {
let node = self.window.rendered_frame.dispatch_tree.node(*node_id);
for DispatchActionListener {
action_type,
mut listener,
listener,
} in node.action_listeners.clone()
{
let any_action = action.as_any();
if action_type == any_action.type_id() {
self.propagate_event = false; // Actions stop propagation by default during the bubble phase
let listener = unsafe { listener.get_mut() };
listener(any_action, DispatchPhase::Bubble, self);
if !self.propagate_event {
return;