Build MMTk on macOS (#719)

This PR allows mmtk-core to build on macOS (x86_64). This PR finishes a task in #206. This PR does not guarantee that MMTk works properly on macOS. It only makes sure that we can build and run our unit tests on macOS. This should be a good first step for any following work on macOS.

Changes:
* Use `malloc_size` instead of `malloc_usable_size` on macOS
* Use `MAP_FIXED` instead of `MAP_FIXED_NOREPLACE` on macOS
* Remove warnings when building `scheduler::affinity` on macOS
* Make a few tests only run on linux (related with thread affinity and mmap)
* Test our pre-code-review test on `macos-12` and `x86_64-apple-darwin`

Author: qinsoon

.github/scripts/ci-setup-i686-unknown-linux-gnu.sh

@@ -7,3 +7,4 @@ sudo apt-get install build-essential gcc-multilib -y
 sudo dpkg --add-architecture i386
 sudo apt-get update
 sudo apt-get install zlib1g-dev:i386
+sudo apt-get install libc6-dev-i386

.github/scripts/ci-setup-x86_64-apple-darwin.sh

@@ -0,0 +1 @@
+set -xe

.github/workflows/pre-review-ci.yml

@@ -28,6 +28,7 @@ jobs:
         target:
           - { os: ubuntu-18.04, triple: x86_64-unknown-linux-gnu }
           - { os: ubuntu-18.04, triple: i686-unknown-linux-gnu }
+          - { os: macos-12, triple: x86_64-apple-darwin }
         rust: ${{ fromJson(needs.setup-test-matrix.outputs.rust )}}
 
     name: ${{ matrix.target.triple }} / ${{ matrix.rust }}
@@ -53,10 +54,7 @@ jobs:
 
       # Test
       - name: Test
-        run: |
-          sudo apt-get update
-          sudo apt-get install libc6-dev-i386
-          ./.github/scripts/ci-test.sh
+        run: ./.github/scripts/ci-test.sh
 
       # Style checks
       - name: Style checks

Cargo.toml

@@ -25,7 +25,6 @@ mmtk-macros = { version = "0.16.0", path = "macros/" }
 libc = "0.2"
 jemalloc-sys = { version = "0.3.2", features = ["disable_initial_exec_tls"], optional = true }
 mimalloc-sys = { version = "0.1.6", optional = true }
-hoard-sys = { version = "0.1.2", optional = true }
 lazy_static = "1.1"
 log = { version = "0.4", features = ["max_level_trace", "release_max_level_off"] }
 crossbeam = "0.8.1"
@@ -131,7 +130,6 @@ malloc_counted_size = []
 # this does not replace the global Rust allocator, but provides these libraries for GC implementation
 malloc_mimalloc = ["mimalloc-sys"]
 malloc_jemalloc = ["jemalloc-sys"]
-malloc_hoard = ["hoard-sys"]
 # Use the native mimalloc allocator for malloc. This is not tested by me (Yi) yet, and it is only used to make sure that some code
 # is not compiled in default builds.
 malloc_native_mimalloc = []

src/scheduler/affinity.rs

@@ -2,7 +2,6 @@ use super::worker::ThreadId;
 use crate::util::options::AffinityKind;
 #[cfg(target_os = "linux")]
 use libc::{cpu_set_t, sched_getaffinity, sched_setaffinity, CPU_COUNT, CPU_SET, CPU_ZERO};
-use std::mem::MaybeUninit;
 
 /// Represents the ID of a logical CPU on a system.
 pub type CoreId = u16;
@@ -12,6 +11,7 @@ pub type CoreId = u16;
 #[cfg(target_os = "linux")]
 /// Return the total number of cores allocated to the program.
 pub fn get_total_num_cpus() -> u16 {
+    use std::mem::MaybeUninit;
     unsafe {
         let mut cs = MaybeUninit::zeroed().assume_init();
         CPU_ZERO(&mut cs);
@@ -45,6 +45,7 @@ impl AffinityKind {
 #[cfg(target_os = "linux")]
 /// Bind the current thread to the specified core.
 fn bind_current_thread_to_core(cpu: CoreId) {
+    use std::mem::MaybeUninit;
     unsafe {
         let mut cs = MaybeUninit::zeroed().assume_init();
         CPU_ZERO(&mut cs);
@@ -55,6 +56,6 @@ fn bind_current_thread_to_core(cpu: CoreId) {
 
 #[cfg(not(target_os = "linux"))]
 /// Bind the current thread to the specified core.
-fn bind_current_thread_to_core(cpu: CoreId) {
+fn bind_current_thread_to_core(_cpu: CoreId) {
     unimplemented!()
 }

src/util/malloc/library.rs

@@ -74,5 +74,12 @@ mod libc_malloc {
     // Posix
     pub use libc::posix_memalign;
     // GNU
+    #[cfg(target_os = "linux")]
     pub use libc::malloc_usable_size;
+    #[cfg(target_os = "macos")]
+    extern "C" {
+        pub fn malloc_size(ptr: *const libc::c_void) -> usize;
+    }
+    #[cfg(target_os = "macos")]
+    pub use self::malloc_size as malloc_usable_size;
 }

src/util/memory.rs

@@ -39,13 +39,20 @@ pub unsafe fn dzmmap(start: Address, size: usize) -> Result<()> {
     ret
 }
 
+#[cfg(target_os = "linux")]
+// MAP_FIXED_NOREPLACE returns EEXIST if already mapped
+const MMAP_FLAGS: libc::c_int = libc::MAP_ANON | libc::MAP_PRIVATE | libc::MAP_FIXED_NOREPLACE;
+#[cfg(target_os = "macos")]
+// MAP_FIXED is used instead of MAP_FIXED_NOREPLACE (which is not available on macOS). We are at the risk of overwriting pre-existing mappings.
+const MMAP_FLAGS: libc::c_int = libc::MAP_ANON | libc::MAP_PRIVATE | libc::MAP_FIXED;
+
 /// Demand-zero mmap (no replace):
 /// This function mmaps the memory and guarantees to zero all mapped memory.
 /// This function will not overwrite existing memory mapping, and it will result Err if there is an existing mapping.
 #[allow(clippy::let_and_return)] // Zeroing is not neceesary for some OS/s
 pub fn dzmmap_noreplace(start: Address, size: usize) -> Result<()> {
     let prot = PROT_READ | PROT_WRITE | PROT_EXEC;
-    let flags = libc::MAP_ANON | libc::MAP_PRIVATE | libc::MAP_FIXED_NOREPLACE;
+    let flags = MMAP_FLAGS;
     let ret = mmap_fixed(start, size, prot, flags);
     // We do not need to explicitly zero for Linux (memory is guaranteed to be zeroed)
     #[cfg(not(target_os = "linux"))]
@@ -61,8 +68,7 @@ pub fn dzmmap_noreplace(start: Address, size: usize) -> Result<()> {
 /// We can use this to reserve the address range, and then later overwrites the mapping with dzmmap().
 pub fn mmap_noreserve(start: Address, size: usize) -> Result<()> {
     let prot = PROT_NONE;
-    let flags =
-        libc::MAP_ANON | libc::MAP_PRIVATE | libc::MAP_FIXED_NOREPLACE | libc::MAP_NORESERVE;
+    let flags = MMAP_FLAGS | libc::MAP_NORESERVE;
     mmap_fixed(start, size, prot, flags)
 }
 
@@ -119,10 +125,10 @@ pub fn handle_mmap_error<VM: VMBinding>(error: Error, tls: VMThread) -> ! {
 /// Checks if the memory has already been mapped. If not, we panic.
 // Note that the checking has a side effect that it will map the memory if it was unmapped. So we panic if it was unmapped.
 // Be very careful about using this function.
+#[cfg(target_os = "linux")]
 pub fn panic_if_unmapped(start: Address, size: usize) {
     let prot = PROT_READ | PROT_WRITE;
-    // MAP_FIXED_NOREPLACE returns EEXIST if already mapped
-    let flags = libc::MAP_ANON | libc::MAP_PRIVATE | libc::MAP_FIXED_NOREPLACE;
+    let flags = MMAP_FLAGS;
     match mmap_fixed(start, size, prot, flags) {
         Ok(_) => panic!("{} of size {} is not mapped", start, size),
         Err(e) => {
@@ -135,6 +141,13 @@ pub fn panic_if_unmapped(start: Address, size: usize) {
     }
 }
 
+#[cfg(not(target_os = "linux"))]
+pub fn panic_if_unmapped(_start: Address, _size: usize) {
+    // This is only used for assertions, so MMTk will still run even if we never panic.
+    // TODO: We need a proper implementation for this. As we do not have MAP_FIXED_NOREPLACE, we cannot use the same implementation as Linux.
+    // Possibly we can use posix_mem_offset for both OS/s.
+}
+
 pub fn munprotect(start: Address, size: usize) -> Result<()> {
     wrap_libc_call(
         &|| unsafe { libc::mprotect(start.to_mut_ptr(), size, PROT_READ | PROT_WRITE | PROT_EXEC) },
@@ -232,6 +245,7 @@ mod tests {
         })
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn test_mmap_noreplace() {
         serial_test(|| {
@@ -269,6 +283,7 @@ mod tests {
         })
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     #[should_panic]
     fn test_check_is_mmapped_for_unmapped() {
@@ -300,6 +315,7 @@ mod tests {
         })
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     #[should_panic]
     fn test_check_is_mmapped_for_unmapped_next_to_mapped() {

src/util/options.rs

@@ -890,6 +890,7 @@ mod tests {
         })
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn test_thread_affinity_single_core() {
         serial_test(|| {
@@ -910,6 +911,7 @@ mod tests {
         })
     }
 
+    #[cfg(target_os = "linux")]
     #[test]
     fn test_thread_affinity_generate_core_list() {
         serial_test(|| {

src/util/raw_memory_freelist.rs

@@ -258,7 +258,10 @@ mod tests {
             Ok(guard) => guard,
             Err(poisoned) => poisoned.into_inner(),
         };
+        #[cfg(target_os = "linux")]
         let start = unsafe { Address::from_usize(0x8000_0000) };
+        #[cfg(target_os = "macos")]
+        let start = unsafe { Address::from_usize(0x2400_0000_0000) };
         let extent = BYTES_IN_PAGE;
         let pages_per_block = RawMemoryFreeList::default_block_size(list_size as _, 1);
         assert_eq!(pages_per_block, 1);

vmbindings/dummyvm/src/tests/mod.rs

@@ -6,6 +6,7 @@
 // There are also helpers for creating fixtures in `fixture/mod.rs`.
 mod issue139;
 mod handle_mmap_oom;
+#[cfg(target_os = "linux")]
 mod handle_mmap_conflict;
 mod allocate_align_offset;
 mod allocate_without_initialize_collection;