Pluralize process flag structs and method

It was confusing that they hold multiple flags, but are called
`*ProcessFlag` and that `is_set` could check multiple flags at once.

Author: KronicDeth

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,
@@ -161,13 +161,13 @@ impl ProcessControlBlock {
 
     /// Set the given process flag
     #[inline]
-    pub fn set_flags(&self, flags: ProcessFlag) {
+    pub fn set_flags(&self, flags: ProcessFlags) {
         self.flags.set(flags);
     }
 
     /// Unset the given process flag
     #[inline]
-    pub fn clear_flags(&self, flags: ProcessFlag) {
+    pub fn clear_flags(&self, flags: ProcessFlags) {
         self.flags.clear(flags);
     }
 
@@ -620,22 +620,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
@@ -27,89 +27,89 @@ impl ProcessFlag {
     // Internal value used to validate conversions from raw u32 values
     const MAX_VALUE: u32 = 1 << 5;
 }
-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 +121,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));
     }
 }

liblumen_alloc/src/erts/process/gc/collector.rs

@@ -129,7 +129,7 @@ impl<'p, 'h> GarbageCollector<'p, 'h> {
         // Unset heap_grow and need_fullsweep flags, because we are doing both
         self.process
             .flags
-            .clear(ProcessFlag::GrowHeap | ProcessFlag::NeedFullSweep);
+            .clear(ProcessFlags::GrowHeap | ProcessFlags::NeedFullSweep);
         // Allocate new heap
         let new_heap_start = alloc::heap(new_size).map_err(|alloc| GcError::Alloc(alloc))?;
         let mut new_heap = YoungHeap::new(new_heap_start, new_size);
@@ -247,7 +247,7 @@ impl<'p, 'h> GarbageCollector<'p, 'h> {
             panic!("Full sweep finished, but the needed size exceeds even the most pessimistic estimate, this must be a bug");
         } else if total_size * 3 < need_after * 4 {
             // `need_after` requires more than 75% of the current size, schedule some growth
-            self.process.flags.set(ProcessFlag::GrowHeap);
+            self.process.flags.set(ProcessFlags::GrowHeap);
         } else if total_size > need_after * 4 && self.process.min_heap_size < total_size {
             // We need less than 25% of the current heap, shrink
             let wanted = need_after * 2;
@@ -560,7 +560,7 @@ impl<'p, 'h> GarbageCollector<'p, 'h> {
     /// Determines if we should try and grow the heap even when not necessary
     #[inline]
     fn should_force_heap_growth(&self) -> bool {
-        self.process.flags.is_set(ProcessFlag::GrowHeap)
+        self.process.flags.are_set(ProcessFlags::GrowHeap)
     }
 
     /// Calculates the reduction count cost of a collection

liblumen_alloc/src/erts/process/test.rs

@@ -16,7 +16,7 @@ use super::alloc;
 fn gc_simple_fullsweep_test() {
     // Create process
     let process = process();
-    process.set_flags(ProcessFlag::NeedFullSweep);
+    process.set_flags(ProcessFlags::NeedFullSweep);
     simple_gc_test(process);
 }