[enh] Add clang-format check to github CI (#132)

icfaust · web-flow · commit 4282fc68b01a · 2024-02-26T12:34:23.000-08:00
diff --git a/.clang-format b/.clang-format
diff --git a/.github/workflows/linting.yml b/.github/workflows/linting.yml
@@ -0,0 +1,24 @@
+name: Lint
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  clang-format:
+
+    runs-on: intel-ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install dependencies
+      run: |
+        sudo apt update
+        sudo apt -y install clang-format
+
+    - name: Lint
+      run: |
+        find . -type f | grep -P ".*\.(c|cpp|h|hpp)\b" | xargs clang-format -style=file --dry-run -Werror
diff --git a/benchmarks/bench-ipp.cpp b/benchmarks/bench-ipp.cpp
@@ -63,13 +63,16 @@ static void ippargsort(benchmark::State &state, Args &&...args)
     // benchmark
     for (auto _ : state) {
         if constexpr (std::is_same_v<T, float>) {
-            ippsSortRadixIndexAscend_32f(arr.data(), 4, arg.data(), arrsize, temp);
+            ippsSortRadixIndexAscend_32f(
+                    arr.data(), 4, arg.data(), arrsize, temp);
         }
         else if constexpr (std::is_same_v<T, double>) {
-            ippsSortRadixIndexAscend_64f(arr.data(), 8, arg.data(), arrsize, temp);
+            ippsSortRadixIndexAscend_64f(
+                    arr.data(), 8, arg.data(), arrsize, temp);
         }
         else if constexpr (std::is_same_v<T, int32_t>) {
-            ippsSortRadixIndexAscend_32s(arr.data(), 4, arg.data(), arrsize, temp);
+            ippsSortRadixIndexAscend_32s(
+                    arr.data(), 4, arg.data(), arrsize, temp);
         }
         state.PauseTiming();
         arr = arr_bkp;
diff --git a/benchmarks/bench-objsort.hpp b/benchmarks/bench-objsort.hpp
@@ -5,7 +5,7 @@ static constexpr char euclidean[] = "euclidean";
 static constexpr char taxicab[] = "taxicab";
 static constexpr char chebyshev[] = "chebyshev";
 
-template <typename T, const char* val>
+template <typename T, const char *val>
 struct Point3D {
     T x;
     T y;
@@ -19,9 +19,7 @@ struct Point3D {
     }
     T distance()
     {
-        if constexpr (name == "x") {
-            return x;
-        }
+        if constexpr (name == "x") { return x; }
         else if constexpr (name == "euclidean") {
             return std::sqrt(x * x + y * y + z * z);
         }
@@ -77,9 +75,8 @@ static void simdobjsort(benchmark::State &state)
     std::vector<T> arr_bkp = arr;
     // benchmark
     for (auto _ : state) {
-        x86simdsort::object_qsort(arr.data(), arr.size(), [](T p) {
-            return p.distance();
-        });
+        x86simdsort::object_qsort(
+                arr.data(), arr.size(), [](T p) { return p.distance(); });
         state.PauseTiming();
         if (!std::is_sorted(arr.begin(), arr.end(), less_than_key<T>())) {
             std::cout << "sorting failed \n";
@@ -90,7 +87,7 @@ static void simdobjsort(benchmark::State &state)
 }
 
 #define BENCHMARK_OBJSORT(func, T, type, dist) \
-    BENCHMARK_TEMPLATE(func, T<type,dist>) \
+    BENCHMARK_TEMPLATE(func, T<type, dist>) \
             ->Arg(10e1) \
             ->Arg(10e2) \
             ->Arg(10e3) \
@@ -101,12 +98,12 @@ static void simdobjsort(benchmark::State &state)
 #define BENCH_ALL(dtype) \
     BENCHMARK_OBJSORT(simdobjsort, Point3D, dtype, x) \
     BENCHMARK_OBJSORT(scalarobjsort, Point3D, dtype, x) \
-    BENCHMARK_OBJSORT(simdobjsort, Point3D, dtype, taxicab ) \
+    BENCHMARK_OBJSORT(simdobjsort, Point3D, dtype, taxicab) \
     BENCHMARK_OBJSORT(scalarobjsort, Point3D, dtype, taxicab) \
     BENCHMARK_OBJSORT(simdobjsort, Point3D, dtype, euclidean) \
     BENCHMARK_OBJSORT(scalarobjsort, Point3D, dtype, euclidean) \
     BENCHMARK_OBJSORT(simdobjsort, Point3D, dtype, chebyshev) \
-    BENCHMARK_OBJSORT(scalarobjsort, Point3D, dtype, chebyshev) \
+    BENCHMARK_OBJSORT(scalarobjsort, Point3D, dtype, chebyshev)
 
 BENCH_ALL(double)
 BENCH_ALL(float)
diff --git a/benchmarks/bench-qsort.hpp b/benchmarks/bench-qsort.hpp
@@ -36,10 +36,9 @@ static void simdsort(benchmark::State &state, Args &&...args)
     }
 }
 
-
 #define BENCH_BOTH_QSORT(type) \
     BENCH_SORT(simdsort, type) \
-    BENCH_SORT(scalarsort, type) \
+    BENCH_SORT(scalarsort, type)
 
 BENCH_BOTH_QSORT(uint64_t)
 BENCH_BOTH_QSORT(int64_t)
diff --git a/benchmarks/bench-vqsort.cpp b/benchmarks/bench-vqsort.cpp
@@ -14,7 +14,8 @@ static void vqsort(benchmark::State &state, Args &&...args)
     std::vector<T> arr_bkp = arr;
     // benchmark
     for (auto _ : state) {
-        hwy::HWY_NAMESPACE::VQSortStatic(arr.data(), arrsize, hwy::SortAscending());
+        hwy::HWY_NAMESPACE::VQSortStatic(
+                arr.data(), arrsize, hwy::SortAscending());
         state.PauseTiming();
         arr = arr_bkp;
         state.ResumeTiming();
diff --git a/benchmarks/bench.h b/benchmarks/bench.h
@@ -12,14 +12,10 @@
                             })))
 
 #define BENCH_SORT(func, type) \
-    MY_BENCHMARK_CAPTURE( \
-            func, type, random_128, 128, std::string("random")); \
-    MY_BENCHMARK_CAPTURE( \
-            func, type, random_256, 256, std::string("random")); \
-    MY_BENCHMARK_CAPTURE( \
-            func, type, random_512, 512, std::string("random")); \
-    MY_BENCHMARK_CAPTURE( \
-            func, type, random_1k, 1024, std::string("random")); \
+    MY_BENCHMARK_CAPTURE(func, type, random_128, 128, std::string("random")); \
+    MY_BENCHMARK_CAPTURE(func, type, random_256, 256, std::string("random")); \
+    MY_BENCHMARK_CAPTURE(func, type, random_512, 512, std::string("random")); \
+    MY_BENCHMARK_CAPTURE(func, type, random_1k, 1024, std::string("random")); \
     MY_BENCHMARK_CAPTURE(func, type, random_5k, 5000, std::string("random")); \
     MY_BENCHMARK_CAPTURE( \
             func, type, random_100k, 100000, std::string("random")); \
@@ -37,7 +33,8 @@
             func, type, smallrange_512, 512, std::string("smallrange")); \
     MY_BENCHMARK_CAPTURE( \
             func, type, smallrange_1k, 1024, std::string("smallrange")); \
-    MY_BENCHMARK_CAPTURE(func, type, smallrange_5k, 5000, std::string("smallrange")); \
+    MY_BENCHMARK_CAPTURE( \
+            func, type, smallrange_5k, 5000, std::string("smallrange")); \
     MY_BENCHMARK_CAPTURE( \
             func, type, smallrange_100k, 100000, std::string("smallrange")); \
     MY_BENCHMARK_CAPTURE( \
diff --git a/examples/avx2-32bit-qsort.cpp b/examples/avx2-32bit-qsort.cpp
@@ -1,6 +1,7 @@
 #include "avx2-32bit-qsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     float arr[size];
     avx2_qsort(arr, size);
diff --git a/examples/avx512-16bit-qsort.cpp b/examples/avx512-16bit-qsort.cpp
@@ -1,6 +1,7 @@
 #include "avx512-16bit-qsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     short arr[size];
     avx512_qsort(arr, size);
diff --git a/examples/avx512-32bit-qsort.cpp b/examples/avx512-32bit-qsort.cpp
@@ -1,6 +1,7 @@
 #include "avx512-32bit-qsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     float arr[size];
     avx512_qsort(arr, size);
diff --git a/examples/avx512-64bit-qsort.cpp b/examples/avx512-64bit-qsort.cpp
@@ -1,6 +1,7 @@
 #include "avx512-64bit-qsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     double arr[size];
     avx512_qsort(arr, size);
diff --git a/examples/avx512-argsort.cpp b/examples/avx512-argsort.cpp
@@ -1,6 +1,7 @@
 #include "avx512-64bit-argsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     float arr[size];
     std::vector<size_t> arg1 = avx512_argsort(arr, size);
diff --git a/examples/avx512-kv.cpp b/examples/avx512-kv.cpp
@@ -1,6 +1,7 @@
 #include "avx512-64bit-keyvaluesort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     int64_t arr1[size];
     uint64_t arr2[size];
diff --git a/examples/avx512fp-16bit-qsort.cpp b/examples/avx512fp-16bit-qsort.cpp
@@ -1,6 +1,7 @@
 #include "avx512fp16-16bit-qsort.hpp"
 
-int main() {
+int main()
+{
     const int size = 1000;
     _Float16 arr[size];
     avx512_qsort(arr, size);
diff --git a/lib/x86simdsort-avx2.cpp b/lib/x86simdsort-avx2.cpp
@@ -20,7 +20,7 @@
     void partial_qsort(type *arr, size_t k, size_t arrsize, bool hasnan) \
     { \
         avx2_partial_qsort(arr, k, arrsize, hasnan); \
-    }\
+    } \
     template <> \
     std::vector<size_t> argsort(type *arr, size_t arrsize, bool hasnan) \
     { \
diff --git a/lib/x86simdsort-internal.h b/lib/x86simdsort-internal.h
@@ -11,7 +11,8 @@ namespace avx512 {
     XSS_HIDE_SYMBOL void qsort(T *arr, size_t arrsize, bool hasnan = false);
     // key-value quicksort
     template <typename T1, typename T2>
-    XSS_EXPORT_SYMBOL void keyvalue_qsort(T1 *key, T2* val, size_t arrsize, bool hasnan = false);
+    XSS_EXPORT_SYMBOL void
+    keyvalue_qsort(T1 *key, T2 *val, size_t arrsize, bool hasnan = false);
     // quickselect
     template <typename T>
     XSS_HIDE_SYMBOL void
@@ -35,7 +36,8 @@ namespace avx2 {
     XSS_HIDE_SYMBOL void qsort(T *arr, size_t arrsize, bool hasnan = false);
     // key-value quicksort
     template <typename T1, typename T2>
-    XSS_EXPORT_SYMBOL void keyvalue_qsort(T1 *key, T2* val, size_t arrsize, bool hasnan = false);
+    XSS_EXPORT_SYMBOL void
+    keyvalue_qsort(T1 *key, T2 *val, size_t arrsize, bool hasnan = false);
     // quickselect
     template <typename T>
     XSS_HIDE_SYMBOL void
@@ -59,7 +61,8 @@ namespace scalar {
     XSS_HIDE_SYMBOL void qsort(T *arr, size_t arrsize, bool hasnan = false);
     // key-value quicksort
     template <typename T1, typename T2>
-    XSS_EXPORT_SYMBOL void keyvalue_qsort(T1 *key, T2* val, size_t arrsize, bool hasnan = false);
+    XSS_EXPORT_SYMBOL void
+    keyvalue_qsort(T1 *key, T2 *val, size_t arrsize, bool hasnan = false);
     // quickselect
     template <typename T>
     XSS_HIDE_SYMBOL void
diff --git a/lib/x86simdsort-scalar.h b/lib/x86simdsort-scalar.h
@@ -4,25 +4,24 @@
 
 namespace xss {
 namespace utils {
-/* O(1) permute array in place: stolen from
+    /* O(1) permute array in place: stolen from
  * http://www.davidespataro.it/apply-a-permutation-to-a-vector */
-template<typename T>
-void apply_permutation_in_place(T* arr, std::vector<size_t> arg)
-{
-    for(size_t i = 0 ; i < arg.size() ; i++) {
-        size_t curr = i;
-        size_t next = arg[curr];
-        while(next != i)
-        {
-            std::swap(arr[curr], arr[next]);
+    template <typename T>
+    void apply_permutation_in_place(T *arr, std::vector<size_t> arg)
+    {
+        for (size_t i = 0; i < arg.size(); i++) {
+            size_t curr = i;
+            size_t next = arg[curr];
+            while (next != i) {
+                std::swap(arr[curr], arr[next]);
+                arg[curr] = curr;
+                curr = next;
+                next = arg[next];
+            }
             arg[curr] = curr;
-            curr = next;
-            next = arg[next];
         }
-        arg[curr] = curr;
     }
-}
-} // utils
+} // namespace utils
 
 namespace scalar {
     template <typename T>
@@ -79,7 +78,7 @@ namespace scalar {
         return arg;
     }
     template <typename T1, typename T2>
-    void keyvalue_qsort(T1 *key, T2* val, size_t arrsize, bool hasnan)
+    void keyvalue_qsort(T1 *key, T2 *val, size_t arrsize, bool hasnan)
     {
         std::vector<size_t> arg = argsort(key, arrsize, hasnan);
         utils::apply_permutation_in_place(key, arg);
diff --git a/lib/x86simdsort-skx.cpp b/lib/x86simdsort-skx.cpp
@@ -35,36 +35,35 @@
 
 #define DEFINE_KEYVALUE_METHODS(type) \
     template <> \
-    void keyvalue_qsort(type *key, uint64_t* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, uint64_t *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
     } \
     template <> \
-    void keyvalue_qsort(type *key, int64_t* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, int64_t *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
     } \
     template <> \
-    void keyvalue_qsort(type *key, double* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, double *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
     } \
     template <> \
-    void keyvalue_qsort(type *key, uint32_t* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, uint32_t *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
     } \
     template <> \
-    void keyvalue_qsort(type *key, int32_t* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, int32_t *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
     } \
     template <> \
-    void keyvalue_qsort(type *key, float* val, size_t arrsize, bool hasnan) \
+    void keyvalue_qsort(type *key, float *val, size_t arrsize, bool hasnan) \
     { \
         avx512_qsort_kv(key, val, arrsize, hasnan); \
-    } \
-
+    }
 
 namespace xss {
 namespace avx512 {
diff --git a/lib/x86simdsort.cpp b/lib/x86simdsort.cpp
diff --git a/lib/x86simdsort.h b/lib/x86simdsort.h
diff --git a/src/avx512-16bit-qsort.hpp b/src/avx512-16bit-qsort.hpp
diff --git a/tests/test-qsort.cpp b/tests/test-qsort.cpp
diff --git a/utils/custom-compare.h b/utils/custom-compare.h
diff --git a/utils/custom-float.h b/utils/custom-float.h
diff --git a/utils/rand_array.h b/utils/rand_array.h

Original file line number	Diff line number	Diff line change
`@@ -36,10 +36,9 @@ static void simdsort(benchmark::State &state, Args &&...args)`
`36`	`36`	`}`
`37`	`37`	`}`
`38`	`38`
`39`		`-`
`40`	`39`	`#define BENCH_BOTH_QSORT(type) \`
`41`	`40`	`BENCH_SORT(simdsort, type) \`
`42`		`- BENCH_SORT(scalarsort, type) \`
	`41`	`+ BENCH_SORT(scalarsort, type)`
`43`	`42`
`44`	`43`	`BENCH_BOTH_QSORT(uint64_t)`
`45`	`44`	`BENCH_BOTH_QSORT(int64_t)`