Add SIMD implementations via target_clones

Arda Aytekin · Arda Aytekin · commit cbe8ac273f62 · 2023-10-27T18:09:18.000+03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -11,11 +11,36 @@ if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
 target_link_libraries(simdvec PRIVATE m)
 endif()
 
+add_library(simdvecnoattr src/simdvec-attribute.c)
+target_compile_definitions(simdvecnoattr PRIVATE NO_ATTRIBUTE)
+target_compile_features(simdvecnoattr PRIVATE c_std_11)
+target_include_directories(simdvecnoattr PUBLIC include)
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+target_link_libraries(simdvecnoattr PRIVATE m)
+endif()
+
+add_library(simdvecattr src/simdvec-attribute.c)
+target_compile_features(simdvecattr PRIVATE c_std_11)
+target_include_directories(simdvecattr PUBLIC include)
+if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
+target_link_libraries(simdvecattr PRIVATE m)
+endif()
+
 add_executable(bench src/benchmark.cpp)
 target_compile_features(bench PRIVATE cxx_std_11)
 target_link_libraries(bench PRIVATE simdvec)
 target_link_libraries(bench PRIVATE benchmark::benchmark)
 
+add_executable(bench-noattr src/benchmark-attribute.cpp)
+target_compile_features(bench-noattr PRIVATE cxx_std_11)
+target_link_libraries(bench-noattr PRIVATE simdvecnoattr)
+target_link_libraries(bench-noattr PRIVATE benchmark::benchmark)
+
+add_executable(bench-attr src/benchmark-attribute.cpp)
+target_compile_features(bench-attr PRIVATE cxx_std_11)
+target_link_libraries(bench-attr PRIVATE simdvecattr)
+target_link_libraries(bench-attr PRIVATE benchmark::benchmark)
+
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
   find_package(GTest REQUIRED)
   enable_testing()
diff --git a/include/simdvec-attribute.h b/include/simdvec-attribute.h
@@ -0,0 +1,23 @@
+#ifndef __SIMDVEC_ATTRIBUTE_H__
+#define __SIMDVEC_ATTRIBUTE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#define restrict __restrict
+#endif
+
+#include <stdint.h>
+
+float l2_distance(const int16_t, const float *restrict, const float *restrict);
+float inner_product(const int16_t, const float *restrict,
+                    const float *restrict);
+float cosine_distance(const int16_t, const float *restrict,
+                      const float *restrict);
+float l1_distance(const int16_t, const float *restrict, const float *restrict);
+float l2_norm(const int16_t, const float *);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // __SIMDVEC_ATTRIBUTE_H__
diff --git a/src/benchmark-attribute.cpp b/src/benchmark-attribute.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include <random>
+#include <vector>
+
+#include <benchmark/benchmark.h>
+
+#include "simdvec-attribute.h"
+
+static void BM_dot_product(benchmark::State &state) {
+  const int16_t dim = state.range(0);
+  std::mt19937 gen(42);
+  std::normal_distribution<float> dist(0.0f, 1.0f);
+  std::vector<float> x(dim), y(dim);
+  std::generate(x.begin(), x.end(), [&]() { return dist(gen); });
+  std::generate(y.begin(), y.end(), [&]() { return dist(gen); });
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(inner_product(dim, x.data(), y.data()));
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_dot_product)
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 16 * (1 << 10), 2),
+    });
+
+static void BM_cosine_distance(benchmark::State &state) {
+  const int16_t dim = state.range(0);
+  std::mt19937 gen(42);
+  std::normal_distribution<float> dist(0.0f, 1.0f);
+  std::vector<float> x(dim), y(dim);
+  std::generate(x.begin(), x.end(), [&]() { return dist(gen); });
+  std::generate(y.begin(), y.end(), [&]() { return dist(gen); });
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(cosine_distance(dim, x.data(), y.data()));
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_cosine_distance)
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 16 * (1 << 10), 2),
+    });
+
+static void BM_l1_distance(benchmark::State &state) {
+  const int16_t dim = state.range(0);
+  std::mt19937 gen(42);
+  std::normal_distribution<float> dist(0.0f, 1.0f);
+  std::vector<float> x(dim), y(dim);
+  std::generate(x.begin(), x.end(), [&]() { return dist(gen); });
+  std::generate(y.begin(), y.end(), [&]() { return dist(gen); });
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(l1_distance(dim, x.data(), y.data()));
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_l1_distance)
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 16 * (1 << 10), 2),
+    });
+
+static void BM_l2_distance(benchmark::State &state) {
+  const int16_t dim = state.range(0);
+  std::mt19937 gen(42);
+  std::normal_distribution<float> dist(0.0f, 1.0f);
+  std::vector<float> x(dim), y(dim);
+  std::generate(x.begin(), x.end(), [&]() { return dist(gen); });
+  std::generate(y.begin(), y.end(), [&]() { return dist(gen); });
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(l2_distance(dim, x.data(), y.data()));
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_l2_distance)
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 16 * (1 << 10), 2),
+    });
+
+static void BM_l2_norm(benchmark::State &state) {
+  const int16_t dim = state.range(0);
+  std::mt19937 gen(42);
+  std::normal_distribution<float> dist(0.0f, 1.0f);
+  std::vector<float> x(dim);
+  std::generate(x.begin(), x.end(), [&]() { return dist(gen); });
+
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(l2_norm(dim, x.data()));
+    benchmark::ClobberMemory();
+  }
+}
+
+BENCHMARK(BM_l2_norm)
+    ->ArgsProduct({
+        benchmark::CreateRange(1 << 10, 16 * (1 << 10), 2),
+    });
+
+BENCHMARK_MAIN();
diff --git a/src/simdvec-attribute.c b/src/simdvec-attribute.c
@@ -0,0 +1,85 @@
+#include <math.h>
+#include <stdint.h>
+
+#include "simdvec-attribute.h"
+
+#ifdef _MSC_VER
+#define __attribute__(x)
+#elif defined(NO_ATTRIBUTE)
+#define __attribute__(x)
+#endif
+
+__attribute__((target_clones("default", "avx", "fma", "avx512f"))) static float
+l2_distance_impl(const int16_t dim, const float *restrict x,
+                 const float *restrict y) {
+  float distance = 0.0;
+  for (int16_t i = 0; i < dim; i++) {
+    const float diff = x[i] - y[i];
+    distance += diff * diff;
+  }
+  return distance;
+}
+
+__attribute__((target_clones("default", "avx", "fma", "avx512f"))) static float
+inner_product_impl(const int16_t dim, const float *restrict x,
+                   const float *restrict y) {
+  float dot = 0.0;
+  for (int16_t i = 0; i < dim; i++)
+    dot += x[i] * y[i];
+  return dot;
+}
+
+__attribute__((target_clones("default", "avx", "fma", "avx512f"))) static float
+cosine_distance_impl(const int16_t dim, const float *restrict x,
+                     const float *restrict y) {
+  float dot = 0.0;
+  float normx = 0.0;
+  float normy = 0.0;
+  for (int16_t i = 0; i < dim; i++) {
+    dot += x[i] * y[i];
+    normx += x[i] * x[i];
+    normy += y[i] * y[i];
+  }
+  return dot / sqrtf(normx * normy);
+}
+
+__attribute__((target_clones("default", "avx", "fma", "avx512f"))) static float
+l1_distance_impl(const int16_t dim, const float *restrict x,
+                 const float *restrict y) {
+  float distance = 0.0;
+  for (int16_t i = 0; i < dim; i++)
+    distance += fabsf(x[i] - y[i]);
+  return distance;
+}
+
+__attribute__((target_clones("default", "avx", "fma", "avx512f"))) static float
+l2_norm_impl(const int16_t dim, const float *x) {
+  float norm = 0.0;
+  for (int16_t i = 0; i < dim; i++)
+    norm += x[i] * x[i];
+  return norm;
+}
+
+float l2_distance(const int16_t dim, const float *restrict x,
+                  const float *restrict y) {
+  return l2_distance_impl(dim, x, y);
+}
+
+float inner_product(const int16_t dim, const float *restrict x,
+                    const float *restrict y) {
+  return inner_product_impl(dim, x, y);
+}
+
+float cosine_distance(const int16_t dim, const float *restrict x,
+                      const float *restrict y) {
+  return cosine_distance_impl(dim, x, y);
+}
+
+float l1_distance(const int16_t dim, const float *restrict x,
+                  const float *restrict y) {
+  return l1_distance_impl(dim, x, y);
+}
+
+float l2_norm(const int16_t dim, const float *x) {
+  return l2_norm_impl(dim, x);
+}
