From c8a0b44099c146c8b5282265fb5f66822512dbe1 Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 01:42:10 +0000 Subject: [PATCH 1/6] Make raw_memory_freelist 64bits only --- src/util/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/util/mod.rs b/src/util/mod.rs index 79922a8b06..16a31b8b04 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -73,6 +73,7 @@ mod freelist; mod int_array_freelist; /// Implementation of GenericFreeList backed by raw memory, allocated /// on demand direct from the OS (via mmap). +#[cfg(target_pointer_width = "64")] mod raw_memory_freelist; pub use self::address::Address; From 12202aa2af030fc85c991af22f073e2524e8b906 Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 02:42:24 +0000 Subject: [PATCH 2/6] Debug: Run tests with 1 single test thread --- .github/scripts/ci-test.sh | 3 +++ .github/workflows/minimal-tests-core.yml | 3 +++ 2 files changed, 6 insertions(+) diff --git a/.github/scripts/ci-test.sh b/.github/scripts/ci-test.sh index 42bca18c91..80084971b9 100755 --- a/.github/scripts/ci-test.sh +++ b/.github/scripts/ci-test.sh @@ -4,6 +4,9 @@ export RUST_BACKTRACE=1 # Run all tests with 1G heap export MMTK_GC_TRIGGER=FixedHeapSize:1000000000 +# To debug +export RUST_TEST_THREADS=1 + for_all_features "cargo test" # target-specific features diff --git a/.github/workflows/minimal-tests-core.yml b/.github/workflows/minimal-tests-core.yml index 2ab5e31072..4c22f03fe9 100644 --- a/.github/workflows/minimal-tests-core.yml +++ b/.github/workflows/minimal-tests-core.yml @@ -63,6 +63,9 @@ jobs: # Test - name: Test run: ./.github/scripts/ci-test.sh + - name: Setup tmate session + if: ${{ failure() }} + uses: mxschmitt/action-tmate@v3 # Style checks - name: Style checks From d1a18410b6d0c747a01678bf3a96b5faad02f6fe Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 04:19:27 +0000 Subject: [PATCH 3/6] Change the MMAP test address. After the tests, unmap exactly what we mmap. --- src/util/heap/layout/byte_map_mmapper.rs | 39 +++++++++++++----------- src/util/test_util/mod.rs | 4 +-- 2 files changed, 24 insertions(+), 19 deletions(-) diff --git a/src/util/heap/layout/byte_map_mmapper.rs b/src/util/heap/layout/byte_map_mmapper.rs index b3b70b6d6f..538b96fece 100644 --- a/src/util/heap/layout/byte_map_mmapper.rs +++ b/src/util/heap/layout/byte_map_mmapper.rs @@ -229,16 +229,16 @@ mod tests { #[test] fn ensure_mapped_1page() { serial_test(|| { + let pages = 1; + let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); + let end_chunk = + ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); + let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); - let pages = 1; mmapper.ensure_mapped(FIXED_ADDRESS, pages).unwrap(); - let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); - let end_chunk = ByteMapMmapper::address_to_mmap_chunks_up( - FIXED_ADDRESS + pages_to_bytes(pages), - ); for chunk in start_chunk..end_chunk { assert_eq!( mmapper.mapped[chunk].load(Ordering::Relaxed), @@ -247,7 +247,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, MAX_SIZE).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); }, ) }) @@ -256,16 +256,16 @@ mod tests { #[test] fn ensure_mapped_1chunk() { serial_test(|| { + let pages = MMAP_CHUNK_BYTES >> LOG_BYTES_IN_PAGE as usize; + let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); + let end_chunk = + ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); + let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); - let pages = MMAP_CHUNK_BYTES >> LOG_BYTES_IN_PAGE as usize; mmapper.ensure_mapped(FIXED_ADDRESS, pages).unwrap(); - let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); - let end_chunk = ByteMapMmapper::address_to_mmap_chunks_up( - FIXED_ADDRESS + pages_to_bytes(pages), - ); for chunk in start_chunk..end_chunk { assert_eq!( mmapper.mapped[chunk].load(Ordering::Relaxed), @@ -274,7 +274,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, MAX_SIZE).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); }, ) }) @@ -283,11 +283,14 @@ mod tests { #[test] fn ensure_mapped_more_than_1chunk() { serial_test(|| { + let pages = (MMAP_CHUNK_BYTES + MMAP_CHUNK_BYTES / 2) >> LOG_BYTES_IN_PAGE as usize; + let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); + let end_chunk = + ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); + let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); - let pages = - (MMAP_CHUNK_BYTES + MMAP_CHUNK_BYTES / 2) >> LOG_BYTES_IN_PAGE as usize; mmapper.ensure_mapped(FIXED_ADDRESS, pages).unwrap(); let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); @@ -303,7 +306,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, MAX_SIZE).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); }, ) }) @@ -312,6 +315,7 @@ mod tests { #[test] fn protect() { serial_test(|| { + let test_memory_size = MMAP_CHUNK_BYTES * 2; with_cleanup( || { // map 2 chunks @@ -335,7 +339,7 @@ mod tests { ); }, || { - memory::munmap(FIXED_ADDRESS, MAX_SIZE).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); }, ) }) @@ -344,6 +348,7 @@ mod tests { #[test] fn ensure_mapped_on_protected_chunks() { serial_test(|| { + let test_memory_size = MMAP_CHUNK_BYTES * 2; with_cleanup( || { // map 2 chunks @@ -380,7 +385,7 @@ mod tests { ); }, || { - memory::munmap(FIXED_ADDRESS, MAX_SIZE).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); }, ) }) diff --git a/src/util/test_util/mod.rs b/src/util/test_util/mod.rs index 56348b276e..15214fb499 100644 --- a/src/util/test_util/mod.rs +++ b/src/util/test_util/mod.rs @@ -46,10 +46,10 @@ mod test { } } -// Test with an address that works for 32bits. +// Test with an address that works for 32bits. The address is chosen empirically. #[cfg(target_os = "linux")] const TEST_ADDRESS: Address = - crate::util::conversions::chunk_align_down(unsafe { Address::from_usize(0x6000_0000) }); + crate::util::conversions::chunk_align_down(unsafe { Address::from_usize(0x7000_0000) }); #[cfg(target_os = "macos")] const TEST_ADDRESS: Address = crate::util::conversions::chunk_align_down(unsafe { Address::from_usize(0x2_0000_0000) }); From 3fe8e5443c5f230ee76bcf3c1300f15416168a84 Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 04:20:03 +0000 Subject: [PATCH 4/6] Revert "Debug: Run tests with 1 single test thread" This reverts commit 12202aa2af030fc85c991af22f073e2524e8b906. --- .github/scripts/ci-test.sh | 3 --- .github/workflows/minimal-tests-core.yml | 3 --- 2 files changed, 6 deletions(-) diff --git a/.github/scripts/ci-test.sh b/.github/scripts/ci-test.sh index 80084971b9..42bca18c91 100755 --- a/.github/scripts/ci-test.sh +++ b/.github/scripts/ci-test.sh @@ -4,9 +4,6 @@ export RUST_BACKTRACE=1 # Run all tests with 1G heap export MMTK_GC_TRIGGER=FixedHeapSize:1000000000 -# To debug -export RUST_TEST_THREADS=1 - for_all_features "cargo test" # target-specific features diff --git a/.github/workflows/minimal-tests-core.yml b/.github/workflows/minimal-tests-core.yml index 4c22f03fe9..2ab5e31072 100644 --- a/.github/workflows/minimal-tests-core.yml +++ b/.github/workflows/minimal-tests-core.yml @@ -63,9 +63,6 @@ jobs: # Test - name: Test run: ./.github/scripts/ci-test.sh - - name: Setup tmate session - if: ${{ failure() }} - uses: mxschmitt/action-tmate@v3 # Style checks - name: Style checks From d1453cce26784a7b11b5f3d1f3e17878728c7364 Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 04:31:39 +0000 Subject: [PATCH 5/6] Still compile raw_memory_freelist and its tests for 32 bits --- src/util/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/src/util/mod.rs b/src/util/mod.rs index 16a31b8b04..79922a8b06 100644 --- a/src/util/mod.rs +++ b/src/util/mod.rs @@ -73,7 +73,6 @@ mod freelist; mod int_array_freelist; /// Implementation of GenericFreeList backed by raw memory, allocated /// on demand direct from the OS (via mmap). -#[cfg(target_pointer_width = "64")] mod raw_memory_freelist; pub use self::address::Address; From 266026f4d14f9799a90a1b567ecde5b277349c83 Mon Sep 17 00:00:00 2001 From: Yi Lin Date: Thu, 21 Mar 2024 06:34:32 +0000 Subject: [PATCH 6/6] Minor refactoring in tests --- src/util/heap/layout/byte_map_mmapper.rs | 38 +++++++++++++----------- 1 file changed, 21 insertions(+), 17 deletions(-) diff --git a/src/util/heap/layout/byte_map_mmapper.rs b/src/util/heap/layout/byte_map_mmapper.rs index 538b96fece..083ad5a3e4 100644 --- a/src/util/heap/layout/byte_map_mmapper.rs +++ b/src/util/heap/layout/byte_map_mmapper.rs @@ -233,7 +233,7 @@ mod tests { let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); let end_chunk = ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); - let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; + let test_memory_bytes = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); @@ -247,7 +247,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_bytes).unwrap(); }, ) }) @@ -260,7 +260,7 @@ mod tests { let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); let end_chunk = ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); - let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; + let test_memory_bytes = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); @@ -274,7 +274,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_bytes).unwrap(); }, ) }) @@ -287,7 +287,7 @@ mod tests { let start_chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); let end_chunk = ByteMapMmapper::address_to_mmap_chunks_up(FIXED_ADDRESS + pages_to_bytes(pages)); - let test_memory_size = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; + let test_memory_bytes = (end_chunk - start_chunk) * MMAP_CHUNK_BYTES; with_cleanup( || { let mmapper = ByteMapMmapper::new(); @@ -306,7 +306,7 @@ mod tests { } }, || { - memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_bytes).unwrap(); }, ) }) @@ -315,18 +315,20 @@ mod tests { #[test] fn protect() { serial_test(|| { - let test_memory_size = MMAP_CHUNK_BYTES * 2; + let test_memory_bytes = MMAP_CHUNK_BYTES * 2; + let test_memory_pages = test_memory_bytes >> LOG_BYTES_IN_PAGE; + let protect_memory_bytes = MMAP_CHUNK_BYTES; + let protect_memory_pages = protect_memory_bytes >> LOG_BYTES_IN_PAGE; with_cleanup( || { // map 2 chunks let mmapper = ByteMapMmapper::new(); - let pages_per_chunk = MMAP_CHUNK_BYTES >> LOG_BYTES_IN_PAGE as usize; mmapper - .ensure_mapped(FIXED_ADDRESS, pages_per_chunk * 2) + .ensure_mapped(FIXED_ADDRESS, test_memory_pages) .unwrap(); // protect 1 chunk - mmapper.protect(FIXED_ADDRESS, pages_per_chunk); + mmapper.protect(FIXED_ADDRESS, protect_memory_pages); let chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); assert_eq!( @@ -339,7 +341,7 @@ mod tests { ); }, || { - memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_bytes).unwrap(); }, ) }) @@ -348,18 +350,20 @@ mod tests { #[test] fn ensure_mapped_on_protected_chunks() { serial_test(|| { - let test_memory_size = MMAP_CHUNK_BYTES * 2; + let test_memory_bytes = MMAP_CHUNK_BYTES * 2; + let test_memory_pages = test_memory_bytes >> LOG_BYTES_IN_PAGE; + let protect_memory_pages_1 = MMAP_CHUNK_BYTES >> LOG_BYTES_IN_PAGE; // protect one chunk in the first protect + let protect_memory_pages_2 = test_memory_pages; // protect both chunks in the second protect with_cleanup( || { // map 2 chunks let mmapper = ByteMapMmapper::new(); - let pages_per_chunk = MMAP_CHUNK_BYTES >> LOG_BYTES_IN_PAGE as usize; mmapper - .ensure_mapped(FIXED_ADDRESS, pages_per_chunk * 2) + .ensure_mapped(FIXED_ADDRESS, test_memory_pages) .unwrap(); // protect 1 chunk - mmapper.protect(FIXED_ADDRESS, pages_per_chunk); + mmapper.protect(FIXED_ADDRESS, protect_memory_pages_1); let chunk = ByteMapMmapper::address_to_mmap_chunks_down(FIXED_ADDRESS); assert_eq!( @@ -373,7 +377,7 @@ mod tests { // ensure mapped - this will unprotect the previously protected chunk mmapper - .ensure_mapped(FIXED_ADDRESS, pages_per_chunk * 2) + .ensure_mapped(FIXED_ADDRESS, protect_memory_pages_2) .unwrap(); assert_eq!( mmapper.mapped[chunk].load(Ordering::Relaxed), @@ -385,7 +389,7 @@ mod tests { ); }, || { - memory::munmap(FIXED_ADDRESS, test_memory_size).unwrap(); + memory::munmap(FIXED_ADDRESS, test_memory_bytes).unwrap(); }, ) })