rt: Generate heap snapshot also on OOM in GC

Author: dinfuehr

dora-runtime/src/gc.rs

@@ -136,14 +136,9 @@ impl Gc {
             }
         }
 
-        if let Some(ref snapshot_path) = vm.flags.snapshot_on_oom {
-            let snapshot_path = File::create(snapshot_path).expect("Failed to create file.");
-            let snapshot = SnapshotGenerator::new(vm, snapshot_path).unwrap();
-            snapshot.generate().expect("Failed to generate snapshot");
-        }
-
-        stdlib::trap(Trap::OOM as u8 as u32);
-        unreachable!()
+        safepoint::stop_the_world(vm, |threads| {
+            report_out_of_memory_error(vm, threads);
+        })
     }
 
     fn alloc_in_lab(&self, vm: &VM, size: usize) -> Option<Address> {
@@ -234,6 +229,19 @@ impl Gc {
     }
 }
 
+fn report_out_of_memory_error(vm: &VM, threads: &[Arc<DoraThread>]) -> ! {
+    if let Some(ref snapshot_path) = vm.flags.snapshot_on_oom {
+        let snapshot_path = File::create(snapshot_path).expect("Failed to create file.");
+        let snapshot = SnapshotGenerator::new(vm, snapshot_path).unwrap();
+        snapshot
+            .generate(threads)
+            .expect("Failed to generate snapshot");
+    }
+
+    stdlib::trap(Trap::OOM as u8 as u32);
+    unreachable!()
+}
+
 pub trait Collector {
     // Allocate object of given size.
     fn alloc_tlab_area(&self, vm: &VM, size: usize) -> Option<Region>;

dora-runtime/src/gc/swiper.rs

@@ -323,6 +323,7 @@ impl Collector for Swiper {
             &self.young,
             &vm.flags,
             reason,
+            threads,
         );
     }
 

dora-runtime/src/gc/swiper/controller.rs

@@ -7,9 +7,9 @@ use std::time::Instant;
 
 use crate::gc::swiper::young::YoungGen;
 use crate::gc::swiper::{CollectionKind, Heap, PAGE_SIZE, align_page_down, align_page_up};
-use crate::gc::{AllNumbers, GcReason, formatted_size};
-use crate::stdlib;
-use crate::vm::{Trap, VM, VmFlags};
+use crate::gc::{AllNumbers, GcReason, formatted_size, report_out_of_memory_error};
+use crate::threads::DoraThread;
+use crate::vm::{VM, VmFlags};
 
 pub fn init(config: &mut HeapController, args: &VmFlags) {
     assert!(config.min_heap_size <= config.max_heap_size);
@@ -58,6 +58,7 @@ pub fn stop(
     young: &YoungGen,
     args: &VmFlags,
     reason: GcReason,
+    threads: &[Arc<DoraThread>],
 ) {
     let mut config = config.lock();
 
@@ -85,7 +86,7 @@ pub fn stop(
     let young_size = align_page_down(target_young_size / 2) * 2;
 
     if old_size + young_size > config.max_heap_size {
-        stdlib::trap(Trap::OOM as u32);
+        report_out_of_memory_error(vm, threads);
     }
 
     young.resize_after_gc(vm, young_size);

dora-runtime/src/snapshot.rs

@@ -71,14 +71,16 @@ impl<'a> SnapshotGenerator<'a> {
         })
     }
 
-    pub fn generate(mut self) -> IoResult<()> {
-        safepoint::stop_the_world(self.vm, |threads| {
-            self.initialize_strings();
-            self.iterate_roots(threads);
-            self.iterate_heap();
-            self.verify_snapshot();
-            self.serialize()
-        })
+    pub fn generate(mut self, threads: &[Arc<DoraThread>]) -> IoResult<()> {
+        self.initialize_strings();
+        self.iterate_roots(threads);
+        self.iterate_heap();
+        self.verify_snapshot();
+        self.serialize()
+    }
+
+    pub fn generate_in_safepoint(self) -> IoResult<()> {
+        safepoint::stop_the_world(self.vm, |threads| self.generate(threads))
     }
 
     fn initialize_strings(&mut self) {

dora-runtime/src/stdlib.rs

@@ -1098,7 +1098,9 @@ pub extern "C" fn take_heap_snapshot() {
     let vm = get_vm();
     let file = File::create("dora.heapsnapshot").expect("Failed to create file");
     let snapshot = SnapshotGenerator::new(vm, file).unwrap();
-    snapshot.generate().expect("Failed to generate snapshot");
+    snapshot
+        .generate_in_safepoint()
+        .expect("Failed to generate snapshot");
 }
 
 pub extern "C" fn take_heap_snapshot_for_testing() {
@@ -1107,5 +1109,7 @@ pub extern "C" fn take_heap_snapshot_for_testing() {
     let vm = get_vm();
     let file = tempfile::tempfile().expect("Failed to open temporary file.");
     let snapshot = SnapshotGenerator::new(vm, file).unwrap();
-    snapshot.generate().expect("Failed to generate snapshot");
+    snapshot
+        .generate_in_safepoint()
+        .expect("Failed to generate snapshot");
 }