improve the memcpy benchmark (#9490)

- remove the multi-threaded tests, they added too much noise
- added a memset test
- make sure we allocate the buffer aligned to 16KB

Author: pixelflinger

libs/utils/benchmark/benchmark_memcpy.cpp

@@ -18,25 +18,125 @@
 
 #include <benchmark/benchmark.h>
 
+#include <utils/memalign.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <vector>
+
+// ------------------------------------------------------------------------------------------------
+
+#ifdef __linux__
+#include <sched.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#endif
+
+// Returns true if successful, false if failed
+static bool pinThreadToCore(int core_id) {
+#ifdef __linux__
+    cpu_set_t cpuset;
+    CPU_ZERO(&cpuset);
+    CPU_SET(core_id, &cpuset);
+
+    // 0 = current thread
+    int const result = sched_setaffinity(0, sizeof(cpu_set_t), &cpuset);
+    return (result == 0);
+#else
+    (void)core_id;
+    return false;
+#endif
+}
+
+// ------------------------------------------------------------------------------------------------
+
+static constexpr size_t ALIGNMENT = 16 << 10;
+
+template<class T, size_t Align>
+struct AlignedAllocator {
+    using value_type = T;
+
+    template<class U>
+    struct rebind {
+        using other = AlignedAllocator<U, Align>;
+    };
+
+    AlignedAllocator() noexcept = default;
+
+    template<class U>
+    explicit AlignedAllocator(const AlignedAllocator<U, Align>&) noexcept {}
+
+    T* allocate(size_t const n) {
+        size_t const bytes = n * sizeof(T);
+        // std::aligned_alloc requires size to be a multiple of alignment.
+        size_t const aligned_bytes = ((bytes + Align - 1) / Align) * Align;
+        void* ptr = utils::aligned_alloc(aligned_bytes, Align);
+        return static_cast<T*>(ptr);
+    }
+
+    void deallocate(T* p, size_t) noexcept {
+        utils::aligned_free(p);
+    }
+};
+
+template<typename T>
+using PageAlignedVector = std::vector<T, AlignedAllocator<T, ALIGNMENT>>;
+
+// ------------------------------------------------------------------------------------------------
 
 static void BM_memcpy(benchmark::State& state) {
-    char* src = new char[state.range(0)];
-    char* dst = new char[state.range(0)];
-    memset(src, 'x', (size_t)state.range(0));
+    // pinThreadToCore(7);
+    int64_t const size = state.range(0);
+    PageAlignedVector<char> src(size);
+    PageAlignedVector<char> dst(size);
+
+    // make all these pages resident
+    memset(src.data(), 0, size);
+    memset(dst.data(), 0, size);
+    benchmark::ClobberMemory();
 
     {
-        PerformanceCounters pc(state);
-        for (auto _ : state) {
-            memcpy(dst, src, (size_t)state.range(0));
+        // PerformanceCounters const pc(state);
+        for (auto _: state) {
+            memcpy(dst.data(), src.data(), size);
             benchmark::DoNotOptimize(dst);
             benchmark::DoNotOptimize(src);
-            benchmark::ClobberMemory();
         }
     }
-    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
+    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(size));
+}
+
+static void BM_memset(benchmark::State& state) {
+    //pinThreadToCore(7);
+    int64_t const size = state.range(0);
+    PageAlignedVector<char> src(size);
 
-    delete[] src;
-    delete[] dst;
+    // make all these pages resident
+    memset(src.data(), 0, size);
+    benchmark::ClobberMemory();
+
+    {
+        // PerformanceCounters const pc(state);
+        for (auto _: state) {
+            memset(src.data(), 0, size);
+            benchmark::DoNotOptimize(src);
+        }
+    }
+    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(size));
 }
 
-BENCHMARK(BM_memcpy)->Range(8, 8192<<10)->Threads(1)->Threads(8);
+BENCHMARK(BM_memcpy)
+    ->DenseRange( 4<<10, 128<<10,   8<<10)
+    ->DenseRange(128<<10,  4<<20, 128<<10)
+    ->DenseRange(  4<<20, 16<<20,   1<<20)
+    ->DenseRange( 16<<20, 32<<20,   2<<20)
+    ;
+
+BENCHMARK(BM_memset)
+    ->DenseRange( 4<<10, 128<<10,   8<<10)
+    ->DenseRange(128<<10,  4<<20, 128<<10)
+    ->DenseRange(  4<<20, 16<<20,   1<<20)
+    ->DenseRange( 16<<20, 32<<20,   2<<20)
+    ;