: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

@@ -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: ProcessFlags) {
-        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: ProcessFlags) {
-        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.
     ///

liblumen_alloc/src/erts/process/flags.rs

@@ -23,9 +23,13 @@ impl ProcessFlags {
     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 ProcessFlags {
     #[inline]
@@ -36,7 +40,6 @@ impl Into<u32> for ProcessFlags {
 impl From<u32> for ProcessFlags {
     #[inline]
     fn from(n: u32) -> Self {
-        assert!(n <= Self::MAX_VALUE);
         Self(n)
     }
 }

liblumen_alloc/src/erts/process/heap.rs

@@ -63,6 +63,10 @@ impl ProcessHeap {
         // Run the collector
         gc.collect(need)
     }
+
+    pub fn heap_available(&self) -> usize {
+        self.young.unused()
+    }
 }
 impl HeapAlloc for ProcessHeap {
     #[inline]

liblumen_alloc/src/erts/process/test.rs

@@ -48,6 +48,55 @@ fn gc_fullsweep_after_tenuring_test() {
     tenuring_gc_test(process, true);
 }
 
+mod are_flags_set {
+    use super::*;
+
+    #[test]
+    fn trap_exit_is_not_set_by_default() {
+        let process = process();
+
+        assert_eq!(process.are_flags_set(ProcessFlags::TrapExit), false);
+    }
+}
+
+mod trap_exit {
+    use super::*;
+
+    #[test]
+    fn returns_true_for_the_default_old_value() {
+        let process = process();
+
+        assert_eq!(process.trap_exit(true), false);
+    }
+
+    #[test]
+    fn returns_old_value() {
+        let process = process();
+
+        assert_eq!(process.trap_exit(true), false);
+        assert_eq!(process.trap_exit(false), true);
+    }
+}
+
+mod traps_exit {
+    use super::*;
+
+    #[test]
+    fn returns_false_by_default() {
+        let process = process();
+
+        assert_eq!(process.traps_exit(), false);
+    }
+
+    #[test]
+    fn returns_true_after_trap_exit_true() {
+        let process = process();
+
+        assert_eq!(process.trap_exit(true), false);
+        assert_eq!(process.traps_exit(), true);
+    }
+}
+
 mod integer {
     use super::*;
 

liblumen_alloc/src/erts/term.rs

@@ -29,7 +29,9 @@ pub use term::*;
 pub use tuple::*;
 pub use typed_term::*;
 
+use core::alloc::Layout;
 use core::fmt;
+use core::mem;
 use core::str::Utf8Error;
 
 use crate::erts::exception::system::Alloc;
@@ -204,15 +206,19 @@ pub(crate) fn follow_moved(term: Term) -> Term {
 /// needed to hold that number of bytes, rounding up if necessary
 #[inline]
 pub(crate) fn to_word_size(bytes: usize) -> usize {
-    use core::mem;
     use liblumen_core::alloc::alloc_utils::round_up_to_multiple_of;
 
     round_up_to_multiple_of(bytes, mem::size_of::<usize>()) / mem::size_of::<usize>()
 }
 
+pub(crate) fn layout_from_word_size(word_size: usize) -> Layout {
+    let byte_size = word_size * mem::size_of::<Term>();
+
+    unsafe { Layout::from_size_align_unchecked(byte_size, mem::align_of::<Term>()) }
+}
+
 /// Returns the size in words required to hold the non-header fields of type `T`
 #[inline]
 pub(crate) fn arity_of<T: Sized>() -> usize {
-    use core::mem;
     to_word_size(mem::size_of::<T>() - mem::size_of::<Term>())
 }

liblumen_alloc/src/erts/term/tuple.rs

@@ -56,6 +56,39 @@ pub struct Tuple {
     header: Term,
 }
 impl Tuple {
+    pub fn clone_to_heap_from_elements<A: HeapAlloc>(
+        heap: &mut A,
+        elements: &[Term],
+    ) -> Result<Term, Alloc> {
+        // The result of calling this will be a Tuple with everything located
+        // contiguously in memory
+        unsafe {
+            // Allocate the space needed for the header and all the elements
+            let len = elements.len();
+            let words = Self::need_in_words_from_len(len);
+
+            let tuple_ptr = heap.alloc(words)?.as_ptr() as *mut Self;
+            // Write the header
+            tuple_ptr.write(Tuple::new(len));
+
+            let mut element_ptr = tuple_ptr.offset(1) as *mut Term;
+            // Write each element
+            for element in elements {
+                if element.is_immediate() {
+                    element_ptr.write(*element);
+                } else {
+                    // Recursively call clone_to_heap, and then write the box header here
+                    let boxed = element.clone_to_heap(heap)?;
+                    element_ptr.write(boxed);
+                }
+
+                element_ptr = element_ptr.offset(1);
+            }
+
+            Ok(Term::make_boxed(tuple_ptr))
+        }
+    }
+
     /// Create a new `Tuple` struct
     ///
     /// NOTE: This does not allocate space for the tuple, it simply
@@ -91,10 +124,34 @@ impl Tuple {
     /// the memory needed by elements of the tuple
     #[inline]
     pub fn layout(num_elements: usize) -> Layout {
-        let size = mem::size_of::<Self>() + (num_elements * mem::size_of::<Term>());
+        let size = Self::need_in_bytes_from_len(num_elements);
         unsafe { Layout::from_size_align_unchecked(size, mem::align_of::<Term>()) }
     }
 
+    /// The number of bytes for the header and immediate terms or box term pointer to elements
+    /// allocated elsewhere.
+    pub fn need_in_bytes_from_len(len: usize) -> usize {
+        mem::size_of::<Self>() + (len * mem::size_of::<Term>())
+    }
+
+    /// The number of words for the header and immediate terms or box term pointer to elements
+    /// allocated elsewhere.
+    pub fn need_in_words_from_len(len: usize) -> usize {
+        to_word_size(Self::need_in_bytes_from_len(len))
+    }
+
+    /// The number of words for the header and immediate terms or box term pointer and the data
+    /// the box is pointing to.
+    pub fn need_in_words_from_elements(elements: &[Term]) -> usize {
+        let mut words = Self::need_in_words_from_len(elements.len());
+
+        for element in elements {
+            words += element.size_in_words();
+        }
+
+        words
+    }
+
     /// Constructs an iterator over elements of the tuple
     #[inline]
     pub fn iter(&self) -> Iter {
@@ -185,47 +242,11 @@ unsafe impl AsTerm for Tuple {
 }
 impl CloneToProcess for Tuple {
     fn clone_to_heap<A: HeapAlloc>(&self, heap: &mut A) -> Result<Term, Alloc> {
-        // The result of calling this will be a Tuple with everything located
-        // contigously in memory
-        unsafe {
-            // Allocate the space needed for the header and all the elements
-            let num_elements = self.len();
-            let words =
-                to_word_size(mem::size_of::<Self>() + (num_elements * mem::size_of::<Term>()));
-            let ptr = heap.alloc(words)?.as_ptr() as *mut Self;
-            // Get pointer to the old head element location
-            let old_head = self.head();
-            // Get pointer to the new head element location
-            let head = ptr.add(1) as *mut Term;
-            // Write the header
-            ptr::write(
-                ptr,
-                Self {
-                    header: self.header,
-                },
-            );
-            // Write each element
-            for offset in 0..num_elements {
-                let old = *old_head.add(offset);
-                if old.is_immediate() {
-                    ptr::write(head.add(offset), old);
-                } else {
-                    // Recursively call clone_to_process, and then write the box header here
-                    let boxed = old.clone_to_heap(heap)?;
-                    ptr::write(head.add(offset), boxed);
-                }
-            }
-            Ok(Term::make_boxed(ptr))
-        }
+        Tuple::clone_to_heap_from_elements(heap, self)
     }
 
     fn size_in_words(&self) -> usize {
-        let elements = self.len();
-        let mut words = to_word_size(mem::size_of::<Self>() + (elements * mem::size_of::<Term>()));
-        for element in self.iter() {
-            words += element.size_in_words();
-        }
-        words
+        Self::need_in_words_from_elements(self)
     }
 }
 

lumen_runtime/src/otp/erlang.rs

@@ -7,6 +7,7 @@ pub mod exit_1;
 pub mod link_1;
 pub mod monotonic_time_0;
 pub mod number_or_badarith_1;
+pub mod process_flag_2;
 pub mod self_0;
 pub mod send_2;
 pub mod spawn_3;