Merge pull request #209 from lumen/process_flag_2

:erlang.process_flag(:trap_exit, boolean)

Author: KronicDeth

liblumen_alloc/src/borrow/clone_to_process.rs

@@ -1,4 +1,3 @@
-use core::alloc::Layout;
 use core::mem;
 use core::ptr::NonNull;
 
@@ -45,12 +44,8 @@ pub trait CloneToProcess {
     ///
     /// If unable to allocate a heap fragment that fits this value, `Err(Alloc)` is returned
     fn clone_to_fragment(&self) -> Result<(Term, NonNull<HeapFragment>), Alloc> {
-        let need = self.size_in_words();
-        let layout = unsafe {
-            let size = need * mem::size_of::<usize>();
-            Layout::from_size_align_unchecked(size, mem::align_of::<Term>())
-        };
-        let mut frag = unsafe { HeapFragment::new(layout)? };
+        let word_size = self.size_in_words();
+        let mut frag = unsafe { HeapFragment::new_from_word_size(word_size)? };
         let frag_ref = unsafe { frag.as_mut() };
         let term = self.clone_to_heap(frag_ref)?;
         Ok((term, frag))

liblumen_alloc/src/erts/fragment.rs

@@ -7,7 +7,7 @@ use intrusive_collections::{LinkedListLink, UnsafeRef};
 use liblumen_core::util::pointer::{distance_absolute, in_area};
 
 use crate::erts::exception::system::Alloc;
-use crate::erts::term::Term;
+use crate::erts::term::{layout_from_word_size, Term, Tuple};
 use crate::std_alloc;
 
 use super::HeapAlloc;
@@ -97,6 +97,22 @@ impl HeapFragment {
         );
         Ok(NonNull::new_unchecked(ptr))
     }
+
+    pub unsafe fn new_from_word_size(word_size: usize) -> Result<NonNull<Self>, Alloc> {
+        let layout = layout_from_word_size(word_size);
+
+        Self::new(layout)
+    }
+
+    /// Creates a new `HeapFragment` that can hold a tuple
+    pub fn tuple_from_slice(elements: &[Term]) -> Result<(Term, NonNull<HeapFragment>), Alloc> {
+        let need_in_words = Tuple::need_in_words_from_elements(elements);
+        let mut non_null_heap_fragment = unsafe { Self::new_from_word_size(need_in_words)? };
+        let heap_fragment = unsafe { non_null_heap_fragment.as_mut() };
+        let term = Tuple::clone_to_heap_from_elements(heap_fragment, elements)?;
+
+        Ok((term, non_null_heap_fragment))
+    }
 }
 impl Drop for HeapFragment {
     fn drop(&mut self) {

liblumen_alloc/src/erts/process.rs

@@ -72,7 +72,7 @@ pub struct ProcessControlBlock {
     /// The priority of the process in `scheduler`.
     pub priority: Priority,
     /// Process flags, e.g. `Process.flag/1`
-    flags: AtomicProcessFlag,
+    flags: AtomicProcessFlags,
     /// Minimum size of the heap that this process will start with
     min_heap_size: usize,
     /// The maximum size of the heap allowed for this process
@@ -122,7 +122,7 @@ impl ProcessControlBlock {
         let pid = pid::next();
 
         Self {
-            flags: AtomicProcessFlag::new(ProcessFlag::Default),
+            flags: AtomicProcessFlags::new(ProcessFlags::Default),
             min_heap_size: heap_size,
             max_heap_size: 0,
             min_vheap_size: 0,
@@ -159,18 +159,40 @@ impl ProcessControlBlock {
 
     // Flags
 
-    /// Set the given process flag
+    pub fn are_flags_set(&self, flags: ProcessFlags) -> bool {
+        self.flags.are_set(flags)
+    }
+
+    /// Set the given process flags
     #[inline]
-    pub fn set_flags(&self, flags: ProcessFlag) {
-        self.flags.set(flags);
+    pub fn set_flags(&self, flags: ProcessFlags) -> ProcessFlags {
+        self.flags.set(flags)
     }
 
-    /// Unset the given process flag
+    /// Unset the given process flags
     #[inline]
-    pub fn clear_flags(&self, flags: ProcessFlag) {
-        self.flags.clear(flags);
+    pub fn clear_flags(&self, flags: ProcessFlags) -> ProcessFlags {
+        self.flags.clear(flags)
+    }
+
+    pub fn trap_exit(&self, value: bool) -> bool {
+        let flag = ProcessFlags::TrapExit;
+
+        let old_flags = if value {
+            self.set_flags(flag)
+        } else {
+            self.clear_flags(flag)
+        };
+
+        old_flags.are_set(flag)
     }
 
+    pub fn traps_exit(&self) -> bool {
+        self.are_flags_set(ProcessFlags::TrapExit)
+    }
+
+    // Alloc
+
     /// Acquires exclusive access to the process heap, blocking the current thread until it is able
     /// to do so.
     ///
@@ -336,11 +358,7 @@ impl ProcessControlBlock {
 
     // Send
 
-    pub fn send_heap_message(
-        &self,
-        heap_fragment: NonNull<HeapFragment>,
-        data: Term,
-    ) -> Result<(), Alloc> {
+    pub fn send_heap_message(&self, heap_fragment: NonNull<HeapFragment>, data: Term) {
         let heap_fragment_ptr = heap_fragment.as_ptr();
 
         let off_heap_unsafe_ref_heap_fragment = unsafe { UnsafeRef::from_raw(heap_fragment_ptr) };
@@ -353,27 +371,32 @@ impl ProcessControlBlock {
         self.send_message(Message::HeapFragment(message::HeapFragment {
             unsafe_ref_heap_fragment: message_unsafe_ref_heap_fragment,
             data,
-        }))
+        }));
     }
 
-    pub fn send_from_self(&self, data: Term) -> Result<(), Alloc> {
-        self.send_message(Message::Process(message::Process { data }))
+    pub fn send_from_self(&self, data: Term) {
+        self.send_message(Message::Process(message::Process { data }));
     }
 
     /// Returns `true` if the process should stop waiting and be rescheduled as runnable.
     pub fn send_from_other(&self, data: Term) -> Result<bool, Alloc> {
         match self.heap.try_lock() {
-            Some(ref mut destination_heap) => {
-                let destination_data = data.clone_to_heap(destination_heap)?;
-
-                self.send_message(Message::Process(message::Process {
-                    data: destination_data,
-                }))?;
-            }
+            Some(ref mut destination_heap) => match data.clone_to_heap(destination_heap) {
+                Ok(destination_data) => {
+                    self.send_message(Message::Process(message::Process {
+                        data: destination_data,
+                    }));
+                }
+                Err(_) => {
+                    let (heap_fragment_data, heap_fragment) = data.clone_to_fragment()?;
+
+                    self.send_heap_message(heap_fragment, heap_fragment_data);
+                }
+            },
             None => {
                 let (heap_fragment_data, heap_fragment) = data.clone_to_fragment()?;
 
-                self.send_heap_message(heap_fragment, heap_fragment_data)?;
+                self.send_heap_message(heap_fragment, heap_fragment_data);
             }
         }
 
@@ -391,10 +414,8 @@ impl ProcessControlBlock {
         }
     }
 
-    fn send_message(&self, message: Message) -> Result<(), Alloc> {
-        self.mailbox.lock().borrow_mut().push(message);
-
-        Ok(())
+    fn send_message(&self, message: Message) {
+        self.mailbox.lock().borrow_mut().push(message)
     }
 
     // Terms
@@ -626,22 +647,22 @@ impl ProcessControlBlock {
 
     #[inline]
     fn is_gc_forced(&self) -> bool {
-        self.flags.is_set(ProcessFlag::ForceGC)
+        self.flags.are_set(ProcessFlags::ForceGC)
     }
 
     #[inline(always)]
     fn is_gc_delayed(&self) -> bool {
-        self.flags.is_set(ProcessFlag::DelayGC)
+        self.flags.are_set(ProcessFlags::DelayGC)
     }
 
     #[inline(always)]
     fn is_gc_disabled(&self) -> bool {
-        self.flags.is_set(ProcessFlag::DisableGC)
+        self.flags.are_set(ProcessFlags::DisableGC)
     }
 
     #[inline(always)]
     fn needs_fullsweep(&self) -> bool {
-        self.flags.is_set(ProcessFlag::NeedFullSweep)
+        self.flags.are_set(ProcessFlags::NeedFullSweep)
     }
 
     /// Performs a garbage collection, using the provided root set

liblumen_alloc/src/erts/process/flags.rs

@@ -6,8 +6,8 @@ use core::sync::atomic::{AtomicU32, Ordering};
 /// to combine multiple flags in one value.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(transparent)]
-pub struct ProcessFlag(u32);
-impl ProcessFlag {
+pub struct ProcessFlags(u32);
+impl ProcessFlags {
     #![allow(non_upper_case_globals)]
 
     /// The default value where no flags are set
@@ -23,93 +23,96 @@ impl ProcessFlag {
     pub const DisableGC: Self = Self(1 << 4);
     /// This flag indicates that GC should be delayed temporarily
     pub const DelayGC: Self = Self(1 << 5);
+    /// This flag indicates the processes linked to this process should send exit messages instead
+    /// of causing this process to exit when they exit
+    pub const TrapExit: Self = Self(1 << 6);
 
-    // Internal value used to validate conversions from raw u32 values
-    const MAX_VALUE: u32 = 1 << 5;
+    pub fn are_set(&self, flags: ProcessFlags) -> bool {
+        (*self & flags) == flags
+    }
 }
-impl Into<u32> for ProcessFlag {
+impl Into<u32> for ProcessFlags {
     #[inline]
     fn into(self) -> u32 {
         self.0
     }
 }
-impl From<u32> for ProcessFlag {
+impl From<u32> for ProcessFlags {
     #[inline]
     fn from(n: u32) -> Self {
-        assert!(n <= Self::MAX_VALUE);
         Self(n)
     }
 }
-impl Not for ProcessFlag {
+impl Not for ProcessFlags {
     type Output = Self;
 
     fn not(self) -> Self {
         Self(!self.0)
     }
 }
-impl BitOr for ProcessFlag {
+impl BitOr for ProcessFlags {
     type Output = Self;
 
     fn bitor(self, rhs: Self) -> Self {
         Self(self.0 | rhs.0)
     }
 }
-impl BitOrAssign for ProcessFlag {
+impl BitOrAssign for ProcessFlags {
     fn bitor_assign(&mut self, rhs: Self) {
         self.0 |= rhs.0
     }
 }
-impl BitAnd for ProcessFlag {
+impl BitAnd for ProcessFlags {
     type Output = Self;
 
     fn bitand(self, rhs: Self) -> Self {
         Self(self.0 & rhs.0)
     }
 }
-impl BitAndAssign for ProcessFlag {
+impl BitAndAssign for ProcessFlags {
     fn bitand_assign(&mut self, rhs: Self) {
         self.0 &= rhs.0
     }
 }
 
 /// This type is a wrapper around `AtomicU32` and provides atomic
-/// semantics for the `ProcessFlag` enum type
+/// semantics for the `ProcessFlags` enum type
 #[repr(transparent)]
-pub struct AtomicProcessFlag(AtomicU32);
-impl AtomicProcessFlag {
-    /// Create a new `AtomicProcessFlag`
+pub struct AtomicProcessFlags(AtomicU32);
+impl AtomicProcessFlags {
+    /// Create a new `AtomicProcessFlags`
     #[inline]
-    pub fn new(flag: ProcessFlag) -> Self {
+    pub fn new(flag: ProcessFlags) -> Self {
         Self(AtomicU32::new(flag.into()))
     }
 
     /// Fetch the current value, with the given `Ordering`
     #[inline]
-    pub fn load(&self, ordering: Ordering) -> ProcessFlag {
+    pub fn load(&self, ordering: Ordering) -> ProcessFlags {
         self.0.load(ordering).into()
     }
 
     /// Fetch the current value, using `Relaxed` ordering
     #[inline]
-    pub fn get(&self) -> ProcessFlag {
+    pub fn get(&self) -> ProcessFlags {
         self.0.load(Ordering::Relaxed).into()
     }
 
     /// Check if the current value contains the given flags, uses `Relaxed` ordering
     #[inline]
-    pub fn is_set(&self, flags: ProcessFlag) -> bool {
+    pub fn are_set(&self, flags: ProcessFlags) -> bool {
         self.get() & flags == flags
     }
 
     /// Set the given flags, uses `AcqRel` ordering
     #[inline]
-    pub fn set(&self, flags: ProcessFlag) -> ProcessFlag {
+    pub fn set(&self, flags: ProcessFlags) -> ProcessFlags {
         self.0.fetch_or(flags.into(), Ordering::AcqRel).into()
     }
 
     /// Clear the given flags, uses `AcqRel` ordering
     #[inline]
-    pub fn clear(&self, flags: ProcessFlag) -> ProcessFlag {
+    pub fn clear(&self, flags: ProcessFlags) -> ProcessFlags {
         let cleared = !flags;
         self.0.fetch_and(cleared.into(), Ordering::AcqRel).into()
     }
@@ -121,34 +124,34 @@ mod tests {
 
     #[test]
     fn process_flag_test() {
-        let mut flags = ProcessFlag::Default;
+        let mut flags = ProcessFlags::Default;
         // Set fullsweep
-        flags |= ProcessFlag::NeedFullSweep;
-        assert!(flags & ProcessFlag::NeedFullSweep == ProcessFlag::NeedFullSweep);
+        flags |= ProcessFlags::NeedFullSweep;
+        assert!(flags & ProcessFlags::NeedFullSweep == ProcessFlags::NeedFullSweep);
         // Set force_gc
-        flags |= ProcessFlag::ForceGC;
-        assert!(flags & ProcessFlag::NeedFullSweep == ProcessFlag::NeedFullSweep);
-        assert!(flags & ProcessFlag::ForceGC == ProcessFlag::ForceGC);
+        flags |= ProcessFlags::ForceGC;
+        assert!(flags & ProcessFlags::NeedFullSweep == ProcessFlags::NeedFullSweep);
+        assert!(flags & ProcessFlags::ForceGC == ProcessFlags::ForceGC);
         // Ensure we can check multiple flags at once
-        let checking = ProcessFlag::ForceGC | ProcessFlag::NeedFullSweep;
+        let checking = ProcessFlags::ForceGC | ProcessFlags::NeedFullSweep;
         assert!(flags & checking == checking);
         // Clear force_gc
-        flags &= !ProcessFlag::ForceGC;
-        assert!(flags & ProcessFlag::ForceGC != ProcessFlag::ForceGC);
-        assert!(flags & ProcessFlag::NeedFullSweep == ProcessFlag::NeedFullSweep);
+        flags &= !ProcessFlags::ForceGC;
+        assert!(flags & ProcessFlags::ForceGC != ProcessFlags::ForceGC);
+        assert!(flags & ProcessFlags::NeedFullSweep == ProcessFlags::NeedFullSweep);
     }
 
     #[test]
     fn atomic_process_flag_test() {
-        let flags = AtomicProcessFlag::new(ProcessFlag::Default);
-        flags.set(ProcessFlag::NeedFullSweep);
-        assert!(flags.is_set(ProcessFlag::NeedFullSweep));
-        flags.set(ProcessFlag::ForceGC);
-        assert!(flags.is_set(ProcessFlag::NeedFullSweep));
-        assert!(flags.is_set(ProcessFlag::ForceGC));
-        assert!(flags.is_set(ProcessFlag::ForceGC | ProcessFlag::NeedFullSweep));
-        flags.clear(ProcessFlag::ForceGC);
-        assert!(flags.is_set(ProcessFlag::NeedFullSweep));
-        assert!(!flags.is_set(ProcessFlag::ForceGC));
+        let flags = AtomicProcessFlags::new(ProcessFlags::Default);
+        flags.set(ProcessFlags::NeedFullSweep);
+        assert!(flags.are_set(ProcessFlags::NeedFullSweep));
+        flags.set(ProcessFlags::ForceGC);
+        assert!(flags.are_set(ProcessFlags::NeedFullSweep));
+        assert!(flags.are_set(ProcessFlags::ForceGC));
+        assert!(flags.are_set(ProcessFlags::ForceGC | ProcessFlags::NeedFullSweep));
+        flags.clear(ProcessFlags::ForceGC);
+        assert!(flags.are_set(ProcessFlags::NeedFullSweep));
+        assert!(!flags.are_set(ProcessFlags::ForceGC));
     }
 }