Replace OnAllocationFail with boolean options.

Author: wks

src/policy/lockfreeimmortalspace.rs

@@ -151,7 +151,7 @@ impl<VM: VMBinding> Space<VM> for LockFreeImmortalSpace<VM> {
             })
             .expect("update cursor failed");
         if start + bytes > self.limit {
-            if alloc_options.on_fail.allow_oom_call() {
+            if alloc_options.allow_oom_call() {
                 panic!("OutOfMemory");
             } else {
                 return Address::ZERO;

src/policy/space.rs

@@ -85,7 +85,7 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
         alloc_options: AllocationOptions,
     ) -> bool {
         if self.will_oom_on_acquire(size) {
-            if alloc_options.on_fail.allow_oom_call() {
+            if alloc_options.allow_oom_call() {
                 VM::VMCollection::out_of_memory(
                     tls,
                     crate::util::alloc::AllocationError::HeapOutOfMemory,
@@ -111,18 +111,18 @@ pub trait Space<VM: VMBinding>: 'static + SFT + Sync + Downcast {
         // Should we poll to attempt to GC?
         // - If tls is collector, we shall not poll.
         // - If gc is disabled, we shall not poll.
-        let should_poll = VM::VMActivePlan::is_mutator(tls)
-            && VM::VMCollection::is_collection_enabled();
+        let should_poll =
+            VM::VMActivePlan::is_mutator(tls) && VM::VMCollection::is_collection_enabled();
 
         // Can we continue to allocate even if GC is triggered?
-        let allow_overcommit = alloc_options.on_fail.allow_overcommit();
+        let allow_overcommit = alloc_options.allow_overcommit;
 
         // Can we block for GC if polling triggers GC?
         // - If the MMTk instance is not initialized, there is no GC workers, and we cannot block for GC.
         // - If the on_fail option does not allow blocking, we do not block for GC, either.
         let allow_blocking_for_gc = should_poll
             && self.common().global_state.is_initialized()
-            && alloc_options.on_fail.allow_blocking_for_gc();
+            && alloc_options.at_safepoint;
 
         trace!("Reserving pages");
         let pr = self.get_page_resource();

src/util/alloc/allocator.rs

@@ -28,47 +28,54 @@ pub enum AllocationError {
     MmapOutOfMemory,
 }
 
-/// Behavior when an allocation fails, and a GC is expected.
-#[repr(u8)]
-#[derive(Copy, Clone, Default, PartialEq, bytemuck::NoUninit, Debug)]
-pub enum OnAllocationFail {
-    /// Request the GC and block until GC finishes. This is the default behavior.
-    #[default]
-    RequestGC,
-    /// Request the GC.  But instead of blocking for GC, the allocation request returns with a
-    /// failure value.
-    ReturnFailure,
-    /// Request the GC.  But instead of blocking for GC, the allocating thread continues to
-    /// allocate, overcommitting the memory.  GC will be scheduled asynchronously by the GC worker
-    /// threads, and the current mutator may stop at a safepoint as soon as possible.
-    OverCommit,
-}
-
-impl OnAllocationFail {
-    pub(crate) fn allow_oom_call(&self) -> bool {
-        *self == Self::RequestGC
-    }
-    pub(crate) fn allow_overcommit(&self) -> bool {
-        *self == Self::OverCommit
-    }
-    pub(crate) fn allow_blocking_for_gc(&self) -> bool {
-        *self == Self::RequestGC
-    }
-}
-
 /// Allow specifying different behaviors with [`Allocator::alloc_with_options`].
 #[repr(C)]
-#[derive(Copy, Clone, Default, PartialEq, bytemuck::NoUninit, Debug)]
+#[derive(Copy, Clone, PartialEq, bytemuck::NoUninit, Debug)]
 pub struct AllocationOptions {
-    /// When the allocation fails and a GC is originally expected, on_fail
-    /// allows a different behavior to avoid the GC.
-    pub on_fail: OnAllocationFail,
+    /// Whether polling is allowed.
+    ///
+    /// If true, the allocation attempt will give the GC trigger a chance to schedule a collection
+    /// if the GC trigger considers it needed.
+    ///
+    /// If false, the allocation attempt will not notify the GC trigger, and GC will not be
+    /// scheduled.
+    pub allow_polling: bool,
+    /// Whether the allocation is at a safepoint.
+    ///
+    /// If true, the allocation attempt will block for GC if GC is triggered.  It will also call
+    /// [`Collection::out_of_memory`] when out of memory.
+    ///
+    /// If false, the allocation attempt will never block for GC, and it will never call
+    /// [`Collection::out_of_memory`].  Instead it returns an null address when GC is triggerted.
+    pub at_safepoint: bool,
+    /// Whether over-committing is allowed at this allocation site.  Only meaningful if
+    /// `allow_polling == false`.
+    ///
+    /// If true, the allocation attempt will still try to allocate even if the GC trigger has
+    /// triggered a GC.
+    pub allow_overcommit: bool,
+}
+
+/// The default value for `AllocationOptions` has the same semantics as calling [`Allocator::alloc`]
+/// directly.
+impl Default for AllocationOptions {
+    fn default() -> Self {
+        Self {
+            allow_polling: true,
+            at_safepoint: true,
+            allow_overcommit: false,
+        }
+    }
 }
 
 impl AllocationOptions {
     pub(crate) fn is_default(&self) -> bool {
         *self == AllocationOptions::default()
     }
+
+    pub(crate) fn allow_oom_call(&self) -> bool {
+        self.at_safepoint
+    }
 }
 
 pub fn align_allocation_no_fill<VM: VMBinding>(
@@ -380,9 +387,7 @@ pub trait Allocator<VM: VMBinding>: Downcast {
                 return result;
             }
 
-            if result.is_zero()
-                && self.get_context().get_alloc_options().on_fail == OnAllocationFail::ReturnFailure
-            {
+            if result.is_zero() && !self.get_context().get_alloc_options().allow_oom_call() {
                 return result;
             }
 

src/util/alloc/mod.rs

@@ -6,7 +6,6 @@ pub use allocator::fill_alignment_gap;
 pub use allocator::AllocationError;
 pub use allocator::AllocationOptions;
 pub use allocator::Allocator;
-pub use allocator::OnAllocationFail;
 
 /// A list of all the allocators, embedded in Mutator
 pub(crate) mod allocators;