Merge branch 'main' into snmalloc-rs-integration

Author: mjp41

src/snmalloc/aal/aal.h

@@ -9,21 +9,10 @@
 #include "../ds_core/ds_core.h"
 #include "aal_concept.h"
 #include "aal_consts.h"
-
-#if __has_include(<time.h>)
-#  include <time.h>
-#  ifdef CLOCK_MONOTONIC
-#    define SNMALLOC_TICK_USE_CLOCK_GETTIME
-#  endif
-#endif
 #include "snmalloc/stl/utility.h"
 
 #include <stdint.h>
 
-#ifndef SNMALLOC_TICK_USE_CLOCK_GETTIME
-#  include <chrono>
-#endif
-
 #if ( \
   defined(__i386__) || defined(_M_IX86) || defined(_X86_) || \
   defined(__amd64__) || defined(__x86_64__) || defined(_M_X64) || \
@@ -169,37 +158,17 @@ namespace snmalloc
     /**
      * Return an architecture-specific cycle counter.
      *
-     * If the compiler provides a portable prefetch builtin, use it directly,
-     * otherwise delegate to the architecture-specific layer.  This allows new
-     * architectures to avoid needing to implement a custom `tick` method
-     * if they are used only with a compiler that provides the builtin.
+     * If the architecture reports that CPU cycle counters are unavailable,
+     * use any architecture-specific implementation that exists, otherwise
+     * fall back to zero. When counters are available, prefer a compiler
+     * builtin and then the architecture-specific implementation.
      */
     static inline uint64_t tick() noexcept
     {
       if constexpr (
         (Arch::aal_features & NoCpuCycleCounters) == NoCpuCycleCounters)
       {
-#ifdef SNMALLOC_TICK_USE_CLOCK_GETTIME
-        // the buf is populated by clock_gettime
-        SNMALLOC_UNINITIALISED timespec buf;
-        // we can skip the error checking here:
-        // * EFAULT: for out-of-bound pointers (buf is always valid stack
-        // memory)
-        // * EINVAL: for invalid clock_id (we only use CLOCK_MONOTONIC enforced
-        // by POSIX.1)
-        // Notice that clock_gettime is a usually a vDSO call, so the overhead
-        // is minimal.
-        ::clock_gettime(CLOCK_MONOTONIC, &buf);
-        return static_cast<uint64_t>(buf.tv_sec) * 1000'000'000 +
-          static_cast<uint64_t>(buf.tv_nsec);
-#  undef SNMALLOC_TICK_USE_CLOCK_GETTIME
-#else
-        auto tick = std::chrono::high_resolution_clock::now();
-        return static_cast<uint64_t>(
-          std::chrono::duration_cast<std::chrono::nanoseconds>(
-            tick.time_since_epoch())
-            .count());
-#endif
+        return 0;
       }
       else
       {

src/snmalloc/backend_helpers/backend_helpers.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "../mem/mem.h"
 #include "authmap.h"
 #include "buddy.h"

src/snmalloc/ds_aal/ds_aal.h

@@ -7,4 +7,5 @@
 #include "../aal/aal.h"
 #include "flaglock.h"
 #include "prevent_fork.h"
+#include "seqset.h"
 #include "singleton.h"

src/snmalloc/ds_core/seqset.h src/snmalloc/ds_aal/seqset.hsrc/snmalloc/ds_core/seqset.h renamed to src/snmalloc/ds_aal/seqset.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "mitigations.h"
 
 namespace snmalloc

src/snmalloc/ds_core/cheri.h

@@ -15,5 +15,4 @@
 #include "mitigations.h"
 #include "ptrwrap.h"
 #include "redblacktree.h"
-#include "seqset.h"
 #include "tid.h"

src/snmalloc/ds_core/ds_core.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "bounds_checks.h"
 #include "globalalloc.h"
 #include "libc.h"

src/snmalloc/global/global.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "backend_concept.h"
 #include "backend_wrappers.h"
 #include "check_init.h"

src/snmalloc/mem/mem.h

@@ -17,6 +17,7 @@
 #include <strings.h>
 #include <sys/mman.h>
 #include <sys/uio.h>
+#include <time.h>
 #include <unistd.h>
 
 #if __has_include(<sys/random.h>)
@@ -404,6 +405,28 @@ namespace snmalloc
         (static_cast<uint64_t>(ts.tv_nsec) / 1000000);
     }
 
+    static uint64_t tick()
+    {
+      if constexpr (
+        (Aal::aal_features & NoCpuCycleCounters) != NoCpuCycleCounters)
+      {
+        return Aal::tick();
+      }
+      else
+      {
+        auto hold = KeepErrno();
+
+        struct timespec ts;
+        if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
+        {
+          error("Failed to get monotonic time");
+        }
+
+        return (static_cast<uint64_t>(ts.tv_sec) * 1'000'000'000) +
+          static_cast<uint64_t>(ts.tv_nsec);
+      }
+    }
+
     static uint64_t dev_urandom()
     {
       union

src/snmalloc/pal/pal_posix.h

@@ -7,8 +7,8 @@
 #ifdef _WIN32
 #  ifndef _MSC_VER
 #    include <errno.h>
-#    include <stdio.h>
 #  endif
+#  include <cstdio>
 #  ifndef WIN32_LEAN_AND_MEAN
 #    define WIN32_LEAN_AND_MEAN
 #  endif
@@ -309,12 +309,11 @@ namespace snmalloc
       return result;
     }
 
-    static uint64_t internal_time_in_ms()
+    static uint64_t performance_counter_frequency()
     {
-      // Performance counter is a high-precision monotonic clock.
       static stl::Atomic<uint64_t> freq_cache = 0;
-      constexpr uint64_t ms_per_second = 1000;
       SNMALLOC_UNINITIALISED LARGE_INTEGER buf;
+
       auto freq = freq_cache.load(stl::memory_order_relaxed);
       if (SNMALLOC_UNLIKELY(freq == 0))
       {
@@ -324,10 +323,36 @@ namespace snmalloc
         freq = static_cast<uint64_t>(buf.QuadPart);
         freq_cache.store(freq, stl::memory_order_relaxed);
       }
+
+      return freq;
+    }
+
+    static uint64_t internal_time_in_ms()
+    {
+      constexpr uint64_t ms_per_second = 1000;
+      SNMALLOC_UNINITIALISED LARGE_INTEGER buf;
+      auto freq = performance_counter_frequency();
       ::QueryPerformanceCounter(&buf);
       return (static_cast<uint64_t>(buf.QuadPart) * ms_per_second) / freq;
     }
 
+    static uint64_t tick()
+    {
+      if constexpr (
+        (Aal::aal_features & NoCpuCycleCounters) != NoCpuCycleCounters)
+      {
+        return Aal::tick();
+      }
+      else
+      {
+        constexpr uint64_t ns_per_second = 1'000'000'000;
+        SNMALLOC_UNINITIALISED LARGE_INTEGER buf;
+        auto freq = performance_counter_frequency();
+        ::QueryPerformanceCounter(&buf);
+        return (static_cast<uint64_t>(buf.QuadPart) * ns_per_second) / freq;
+      }
+    }
+
 #  ifdef PLATFORM_HAS_WAITONADDRESS
     using WaitingWord = char;