Add MacOS validation to CI (#111)

This PR adds MacOS validation with clang in github workflow. Some
changes in the codebase and tests are also made for compatibility with
MacOS.

---------

Co-authored-by: Dmitry Razdoburdin <>
Co-authored-by: ibhati <ishwar.s.bhati@intel.com>

Author: razdoburdin

.github/workflows/build-macos.yaml

@@ -0,0 +1,85 @@
+# Copyright 2025 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: MacOS Build and Test
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+  group: '${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}'
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: ${{ matrix.cxx }}, ${{ matrix.build_type }}
+    runs-on: macos-latest
+    strategy:
+      matrix:
+        build_type: [RelWithDebugInfo]
+        cxx: [clang++-15]
+        include:
+          - cxx: clang++-15
+            package: llvm@15
+            cc_name: clang
+            cxx_name: clang++
+            needs_prefix: true
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install Compiler
+      run: |
+        echo "Installing ${{ matrix.package }}..."
+        brew install ${{ matrix.package }}
+
+    - name: Configure build
+      working-directory: ${{ runner.temp }}
+      env:
+        TEMP_WORKSPACE: ${{ runner.temp }}
+      run: |
+        if [[ "${{ matrix.needs_prefix }}" == "true" ]]; then
+          # For non-default packages like llvm@15, get the install prefix
+          COMPILER_PREFIX=$(brew --prefix ${{ matrix.package }})
+          export CC="${COMPILER_PREFIX}/bin/${{ matrix.cc_name }}"
+          export CXX="${COMPILER_PREFIX}/bin/${{ matrix.cxx_name }}"
+        else
+          # For versioned GCC installs, the name is usually directly available
+          export CC="${{ matrix.cc_name }}"
+          export CXX="${{ matrix.cxx_name }}"
+        fi
+
+        cmake -B${TEMP_WORKSPACE}/build -S${GITHUB_WORKSPACE} \
+              -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} \
+              -DSVS_BUILD_BINARIES=YES \
+              -DSVS_BUILD_TESTS=YES \
+              -DSVS_BUILD_EXAMPLES=YES \
+              -DSVS_EXPERIMENTAL_LEANVEC=YES
+
+    - name: Build Tests and Utilities
+      working-directory: ${{ runner.temp }}/build
+      run: make -j$(sysctl -n hw.ncpu)
+
+    - name: Run tests
+      env:
+          CTEST_OUTPUT_ON_FAILURE: 1
+      working-directory: ${{ runner.temp }}/build/tests
+      run: ctest -C ${{ matrix.build_type }}

benchmark/include/svs-benchmark/benchmark.h

@@ -115,7 +115,19 @@ class SaveDirectoryChecker {
     ~SaveDirectoryChecker() = default;
 
   private:
-    std::unordered_set<std::filesystem::path> directories_{};
+#if defined(__APPLE__)
+    // Custom hash for macOS
+    struct PathHash {
+        std::size_t operator()(const std::filesystem::path& p) const {
+            return std::hash<std::string>{}(p.string());
+        }
+    };
+    using PathSet = std::unordered_set<std::filesystem::path, PathHash>;
+#else
+    using PathSet = std::unordered_set<std::filesystem::path>;
+#endif // __APPLE__
+
+    PathSet directories_{};
 };
 
 // Place-holder to indicate no extra arguments need forwarding to inner calls.

include/svs/core/allocator.h

@@ -41,7 +41,16 @@
 #include <array>
 #include <fcntl.h>
 #include <filesystem>
+
+// <linux/mman.h> provides some linux-specific flags like
+// MAP_POPULATE, MAP_NORESERVE, MAP_HUGETLB.
+// They can be used only with linux, and are not availiable
+// for MacOS
+
+#if defined(__linux__)
 #include <linux/mman.h>
+#endif // __linux__
+
 #include <memory>
 #include <optional>
 #include <string>
@@ -78,11 +87,19 @@ struct HugepageX86Parameters {
 };
 
 // Hugepage Allocation will happen in the order given below.
+//
+// MAP_HUGETLB, MAP_HUGE_1GB, MAP_HUGE_2MB are linux-specific
+//
+#if defined(__linux__)
 static constexpr std::array<HugepageX86Parameters, 3> hugepage_x86_options{
     HugepageX86Parameters{1 << 30, MAP_HUGETLB | MAP_HUGE_1GB},
     HugepageX86Parameters{1 << 21, MAP_HUGETLB | MAP_HUGE_2MB},
     HugepageX86Parameters{1 << 12, 0},
 };
+#else
+static constexpr std::array<HugepageX86Parameters, 1> hugepage_x86_options{
+    HugepageX86Parameters{1 << 12, 0}};
+#endif // __linux__
 
 namespace detail {
 
@@ -104,14 +121,21 @@ struct HugepageAllocation {
         auto pagesize = params.pagesize;
         auto flags = params.mmap_flags;
         sz = lib::round_up_to_multiple_of(bytes, pagesize);
-        ptr = mmap(
-            nullptr,
-            sz,
-            PROT_READ | PROT_WRITE,
-            MAP_PRIVATE | MAP_ANONYMOUS | MAP_POPULATE | flags,
-            -1,
-            0
-        );
+
+        int mmap_flags = MAP_PRIVATE;
+#if defined(MAP_ANONYMOUS)
+        mmap_flags |= MAP_ANONYMOUS;
+#elif defined(MAP_ANON)
+        mmap_flags |= MAP_ANON;
+#else
+#error "System does not support anonymous mmap (no MAP_ANONYMOUS or MAP_ANON)"
+#endif
+// Add Linux-specific flags
+#ifdef __linux__
+        mmap_flags |= MAP_POPULATE;
+#endif // __linux__
+
+        ptr = mmap(nullptr, sz, PROT_READ | PROT_WRITE, mmap_flags | flags, -1, 0);
 
         if (ptr != MAP_FAILED) {
             break;
@@ -489,15 +513,16 @@ class MemoryMapper {
             }
         }
         lseek(fd, 0, SEEK_SET);
+
+        int mmap_flags = MAP_SHARED; // Accessible from all processes
+// Add Linux-specific flags
+#ifdef __linux__
+        mmap_flags |= MAP_NORESERVE; // Don't reserve space in DRAM for this until used
+        mmap_flags |= MAP_POPULATE;  // Populate page table entries in the DRAM
+#endif                               // __linux__
+
         void* base = ::mmap(
-            nullptr,
-            bytes.value(),
-            mmap_permissions(permission_),
-            MAP_NORESERVE       // Don't reserve space in DRAM for this until used
-                | MAP_SHARED    // Accessible from all processes
-                | MAP_POPULATE, // Populate page table entries in the DRAM
-            fd,
-            0
+            nullptr, bytes.value(), mmap_permissions(permission_), mmap_flags, fd, 0
         );
         close(fd);
 

include/svs/lib/datatype.h

@@ -276,6 +276,13 @@ template<> inline constexpr DataType datatype_v<uint16_t> = DataType::uint16;
 template<> inline constexpr DataType datatype_v<uint32_t> = DataType::uint32;
 template<> inline constexpr DataType datatype_v<uint64_t> = DataType::uint64;
 
+#if defined(__APPLE__)
+template<> inline constexpr DataType datatype_v<size_t> =
+    sizeof(size_t) == 8 ? DataType::uint64 :
+    sizeof(size_t) == 4 ? DataType::uint32 :
+    DataType::undef;
+#endif // __APPLE__
+
 template<> inline constexpr DataType datatype_v<int8_t> = DataType::int8;
 template<> inline constexpr DataType datatype_v<int16_t> = DataType::int16;
 template<> inline constexpr DataType datatype_v<int32_t> = DataType::int32;

include/svs/lib/memory.h

@@ -61,7 +61,9 @@ template <typename T> struct Allocator {
     }
 
     constexpr void deallocate(value_type* ptr, size_t count) noexcept {
-        ::operator delete(static_cast<void*>(ptr), sizeof(T) * count, std::align_val_t(alignof(T)));
+        ::operator delete(
+            static_cast<void*>(ptr), sizeof(T) * count, std::align_val_t(alignof(T))
+        );
     }
 
     // Intercept zero-argument construction to do default initialization.

include/svs/lib/spinlock.h

@@ -22,11 +22,11 @@ namespace svs {
 
 namespace detail {
 inline void pause() {
-  #if defined(__i386__) || defined(__x86_64__)
+#if defined(__i386__) || defined(__x86_64__)
     __builtin_ia32_pause();
-  #else //  __aarch64__
-    asm volatile ("yield" ::: "memory");
-  #endif
+#else //  __aarch64__
+    asm volatile("yield" ::: "memory");
+#endif
 }
 } // namespace detail
 

include/svs/lib/threads/thunks.h

@@ -104,7 +104,8 @@ template <typename F, typename I> struct Thunk<F, DynamicPartition<I>> {
                     return;
                 }
 
-                auto stop = std::min(grainsize * (i + 1), iterator_size);
+                auto stop =
+                    std::min(grainsize * (i + 1), static_cast<uint64_t>(iterator_size));
                 auto this_range =
                     IteratorPair{std::begin(space) + start, std::begin(space) + stop};
                 f(this_range, tid);

tests/integration/inverted/build.cpp

@@ -64,7 +64,8 @@ void run_test(const Queries& queries, ThreadPoolProto threadpool_proto) {
     auto strategy = Strategy();
 
     // Distance between the obtained results and reference ressults.
-    const double epsilon = 0.005;
+    const double epsilon = 0.01;
+
     constexpr svs::DistanceType distance_type = svs::distance_type_v<decltype(distance)>;
     auto expected_results = test_dataset::inverted::expected_build_results(
         distance_type, svsbenchmark::Uncompressed(svs::DataType::float32)

tests/svs/core/allocator.cpp

@@ -42,7 +42,11 @@ static_assert(std::is_same_v<typename Traits::pointer, float*>);
 static_assert(std::is_same_v<typename Traits::const_pointer, const float*>);
 static_assert(std::is_same_v<typename Traits::void_pointer, void*>);
 static_assert(std::is_same_v<typename Traits::const_void_pointer, const void*>);
+#if defined(__APPLE__)
+static_assert(std::is_same_v<typename Traits::difference_type, long>);
+#else
 static_assert(std::is_same_v<typename Traits::difference_type, int64_t>);
+#endif // __APPLE__
 static_assert(std::is_same_v<typename Traits::size_type, size_t>);
 static_assert(std::is_same_v<
               typename Traits::propagate_on_container_copy_assignment,

tests/svs/core/distances/simd_utils.cpp

@@ -64,4 +64,4 @@ CATCH_TEST_CASE("Masks", "[distance]") {
     CATCH_REQUIRE(svs::create_mask<16>(svs::lib::MaybeStatic<16>()) == 0xFFFF);
 }
 
-#endif  // defined(__i386__) || defined(__x86_64__)
+#endif // defined(__i386__) || defined(__x86_64__)

tests/svs/index/inverted/clustering.cpp

@@ -412,8 +412,8 @@ CATCH_TEST_CASE("Clustering with Logger", "[logging]") {
     auto clustering_parameters = svs::index::inverted::ClusteringParameters()
                                      .percent_centroids(svs::lib::Percent(0.1))
                                      .epsilon(0.05)
-                                     .max_replicas(8)
-                                     .max_cluster_size(200);
+                                     .max_replicas(12)
+                                     .max_cluster_size(300);
     auto centroids = svs::index::inverted::randomly_select_centroids(
         data.size(),
         svs::lib::narrow_cast<size_t>(

tests/svs/lib/threads/threadpool.cpp

@@ -117,7 +117,7 @@ CATCH_TEST_CASE("Thread Pool", "[core][threads][threadpool]") {
                 [&](const auto& range, uint64_t tid) {
                     std::lock_guard lock{mutex};
                     seen_threads.push_back(tid);
-                    ranges.push_back(threads::UnitRange<size_t>{
+                    ranges.push_back(threads::UnitRange<uint64_t>{
                         *(range.begin()), *(range.end())});
                 }
             );

tests/svs/lib/timing.cpp

@@ -45,6 +45,22 @@ void stress(svs::lib::Timer& timer, size_t max_depth = 3, size_t max_flat = 3) {
         }
     }
 }
+
+//
+// We use a busy_sleep instead of std::this_thread::sleep_for.
+// std::this_thread::sleep_for guarantees that the sleep will be
+// not shorter than the required time.
+// For some platforms (like MacOS), a sleep can be much longer,
+// so if we need the sleep time to be close to the required,
+// busy sleep is a good choice.
+
+void busy_sleep(std::chrono::nanoseconds duration) {
+    auto start = std::chrono::steady_clock::now();
+    while (std::chrono::steady_clock::now() - start < duration) {
+        // spin
+    }
+}
+
 } // namespace
 
 CATCH_TEST_CASE("Timing", "[lib][timing]") {
@@ -66,16 +82,16 @@ CATCH_TEST_CASE("Timing", "[lib][timing]") {
         auto timer = svs::lib::Timer();
         {
             auto x = timer.push_back("a");
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            busy_sleep(std::chrono::milliseconds(10));
         }
         {
             auto x = timer.push_back("b");
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            busy_sleep(std::chrono::milliseconds(10));
         }
         {
             auto x = timer.push_back("b");
             auto y = timer.push_back("c");
-            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+            busy_sleep(std::chrono::milliseconds(10));
         }
 
         // Number of elapsed time should be pretty close to the sleep time.