[New lab] Added a new lab about SW memory prefetching (#17)

Authored-by: @ibogosavljevic

Author: dendibakh

buildbot/runCI.py

@@ -57,6 +57,7 @@ class LabPath:
 Labs["memory_bound"]["data_packing"] = LabParams(threshold=13.0)
 Labs["memory_bound"]["loop_interchange_1"] = LabParams(threshold=85.0)
 Labs["memory_bound"]["loop_interchange_2"] = LabParams(threshold=75.0)
+Labs["memory_bound"]["swmem_prefetch_1"] = LabParams(threshold=30.0)
 Labs["misc"]["warmup"] = LabParams(threshold=50.0)
 Labs["core_bound"]["function_inlining_1"] = LabParams(threshold=35.0)
 Labs["core_bound"]["compiler_intrinsics_1"] = LabParams(threshold=60.0)

labs/memory_bound/swmem_prefetch_1/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 2.8.12)
+
+project(lab)
+
+# Optional program arguments, for example:
+# set(VALIDATE_ARGS "${CMAKE_CURRENT_SOURCE_DIR}/input.file" "${CMAKE_CURRENT_SOURCE_DIR}/output.file")
+# set(LAB_ARGS "${CMAKE_CURRENT_SOURCE_DIR}/input.file" "output.file")
+
+string(REGEX MATCH "^(.*)[\\/]labs[\\/].*$" repo "${CMAKE_CURRENT_SOURCE_DIR}")
+include(${CMAKE_MATCH_1}/tools/labs.cmake)

labs/memory_bound/swmem_prefetch_1/README.md

@@ -0,0 +1,11 @@
+# Software memory prefetching
+
+When the CPU data prefetcher cannot figure out the memory access pattern, software prefetching comes in handy. The idea is to use special instructions that tell the CPU: "Hey, I plan to use this memory location a bit later, could you fetch it for me while I do other stuff so it waits for me when I am back".
+
+In GCC and CLANG, you can use `__builtin_prefetch` to ask the CPU to prefetch data. Say, for example, that you are going to access an element of array `my_array[index]`, where `index` is some random number. To prefetch it, you will use `__builtin_prefetch(&my_array[index]);` or `__builtin_prefetch(&my_array + index);`.
+
+Prefetching can benefit the performance, but it can also hurt the performance. It benefits it if the piece of data you are trying to access is not in the data cache. It hurts it if it is. So most of the time, it pays off when there are random memory accesses on a large data structure, such as a tree or a hash map.
+
+An additional prerequisite for the speedup with prefetching is that between the time you request prefetching, and the time you actually access your data, some time needs to pass (known as "prefetching window"). Immediately accessing data that you want to prefetch will not give the expected results.
+
+Authored-by: @ibogosavljevic

labs/memory_bound/swmem_prefetch_1/bench.cpp

@@ -0,0 +1,24 @@
+
+#include "benchmark/benchmark.h"
+#include "solution.hpp"
+#include <memory>
+
+static void bench1(benchmark::State &state) {
+  // Init benchmark data
+  auto hash_map = std::make_unique<hash_map_t>(HASH_MAP_SIZE);
+  std::vector<int> lookups;
+  lookups.resize(NUMBER_OF_LOOKUPS);
+  init(hash_map.get(), lookups);
+
+  // Run the benchmark
+  for (auto _ : state) {
+    auto output = solution(hash_map.get(), lookups);
+    benchmark::DoNotOptimize(output);
+  }
+}
+
+// Register the function as a benchmark and measure time in microseconds
+BENCHMARK(bench1)->Unit(benchmark::kMillisecond);
+
+// Run the benchmark
+BENCHMARK_MAIN();

labs/memory_bound/swmem_prefetch_1/init.cpp

@@ -0,0 +1,16 @@
+#include "solution.hpp"
+#include <limits>
+#include <random>
+
+void init(hash_map_t *hash_map, std::vector<int> &lookups) {
+  std::default_random_engine generator;
+  std::uniform_int_distribution<int> distribution(
+      0, std::numeric_limits<int>::max());
+  for (int i = 0; i < HASH_MAP_SIZE; i++) {
+    hash_map->insert(distribution(generator));
+  }
+
+  for (int i = 0; i < NUMBER_OF_LOOKUPS; i++) {
+    lookups.push_back(distribution(generator));
+  }
+}

labs/memory_bound/swmem_prefetch_1/solution.cpp

@@ -0,0 +1,21 @@
+#include "solution.hpp"
+
+static int getSumOfDigits(int n) {
+  int sum = 0;
+  while (n != 0) {
+    sum = sum + n % 10;
+    n = n / 10;
+  }
+  return sum;
+}
+
+int solution(const hash_map_t *hash_map, const std::vector<int> &lookups) {
+  int result = 0;
+
+  for (int val : lookups) {
+    if (hash_map->find(val))
+      result += getSumOfDigits(val);
+  }
+
+  return result;
+}

labs/memory_bound/swmem_prefetch_1/solution.hpp

@@ -0,0 +1,35 @@
+#include <vector>
+#include <limits>
+
+static constexpr size_t HASH_MAP_SIZE = 32 * 1024 * 1024 - 5;
+static constexpr size_t NUMBER_OF_LOOKUPS = 1024 * 1024;
+
+class hash_map_t {
+    static constexpr int UNUSED = std::numeric_limits<int>::max();
+    std::vector<int> m_vector;
+    size_t N_Buckets;
+public:
+    hash_map_t(size_t size) : m_vector(size, UNUSED), N_Buckets(size) {}
+
+    bool insert(int val) {
+        int bucket = val % N_Buckets;
+        if (m_vector[bucket] == UNUSED) {
+            m_vector[bucket] = val;
+            return true;
+        }
+        return false;
+    }
+
+    bool find(int val) const {
+        int bucket = val % N_Buckets;
+        return m_vector[bucket] != UNUSED;
+    }
+
+    void prefetchForVal(int val) const {
+        int bucket = val % N_Buckets;
+        __builtin_prefetch(&m_vector[bucket]);
+    }
+};
+
+void init(hash_map_t* hash_map, std::vector<int>& lookups);
+int solution(const hash_map_t* hash_map, const std::vector<int>& lookups);

labs/memory_bound/swmem_prefetch_1/validate.cpp

@@ -0,0 +1,45 @@
+
+#include "solution.hpp"
+#include <iostream>
+#include <memory>
+
+static int getSumOfDigits(int n) {
+  int sum = 0;
+  while (n != 0) {
+    sum = sum + n % 10;
+    n = n / 10;
+  }
+  return sum;
+}
+
+static int original_solution(const hash_map_t *hash_map,
+                             const std::vector<int> &lookups) {
+  int result = 0;
+
+  for (int val : lookups) {
+    if (hash_map->find(val))
+      result += getSumOfDigits(val);
+  }
+
+  return result;
+}
+
+int main() {
+  // Init benchmark data
+  auto hash_map = std::make_unique<hash_map_t>(HASH_MAP_SIZE);
+  std::vector<int> lookups;
+  lookups.resize(NUMBER_OF_LOOKUPS);
+  init(hash_map.get(), lookups);
+
+  auto original_result = original_solution(hash_map.get(), lookups);
+  auto result = solution(hash_map.get(), lookups);
+
+  if (original_result != result) {
+    std::cerr << "Validation Failed. Original result = " << original_result
+              << "; Modified version returned = " << result << "\n";
+    return 1;
+  }
+
+  std::cout << "Validation Successful" << std::endl;
+  return 0;
+}