Use __builtin_cpu_supports

Raghuveer Devulapalli · Raghuveer Devulapalli · commit b66f42677633 · 2023-08-03T13:58:42.000-07:00
diff --git a/benchmarks/bench-argsort.hpp b/benchmarks/bench-argsort.hpp
@@ -52,7 +52,7 @@ template <typename T, class... Args>
 static void avx512argsort(benchmark::State &state, Args &&...args)
 {
     auto args_tuple = std::make_tuple(std::move(args)...);
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         state.SkipWithMessage("Requires AVX512 BW ISA");
     }
     // Perform setup here
diff --git a/benchmarks/bench-partial-qsort.hpp b/benchmarks/bench-partial-qsort.hpp
@@ -3,10 +3,10 @@
 template <typename T>
 static void avx512_partial_qsort(benchmark::State &state)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         state.SkipWithMessage("Requires AVX512 BW ISA");
     }
-    if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
         state.SkipWithMessage("Requires AVX512 VBMI2 ISA");
     }
     // Perform setup here
diff --git a/benchmarks/bench-qselect.hpp b/benchmarks/bench-qselect.hpp
@@ -3,10 +3,10 @@
 template <typename T>
 static void avx512_qselect(benchmark::State &state)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         state.SkipWithMessage("Requires AVX512 BW ISA");
     }
-    if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
         state.SkipWithMessage("Requires AVX512 VBMI2 ISA");
     }
     // Perform setup here
diff --git a/benchmarks/bench-qsort-common.h b/benchmarks/bench-qsort-common.h
@@ -5,7 +5,7 @@
 #include "avx512-32bit-qsort.hpp"
 #include "avx512-64bit-argsort.hpp"
 #include "avx512-64bit-qsort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <benchmark/benchmark.h>
 
diff --git a/benchmarks/bench-qsort.hpp b/benchmarks/bench-qsort.hpp
@@ -41,10 +41,10 @@ template <typename T, class... Args>
 static void avx512qsort(benchmark::State &state, Args &&...args)
 {
     auto args_tuple = std::make_tuple(std::move(args)...);
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         state.SkipWithMessage("Requires AVX512 BW ISA");
     }
-    if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
         state.SkipWithMessage("Requires AVX512 VBMI2");
     }
     // Perform setup here
diff --git a/benchmarks/bench-qsortfp16.cpp b/benchmarks/bench-qsortfp16.cpp
@@ -1,12 +1,12 @@
 #include "avx512fp16-16bit-qsort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <benchmark/benchmark.h>
 
 template <typename T>
 static void avx512_qsort(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         size_t ARRSIZE = state.range(0);
         std::vector<T> arr;
@@ -35,7 +35,7 @@ static void avx512_qsort(benchmark::State &state)
 template <typename T>
 static void stdsort(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         size_t ARRSIZE = state.range(0);
         std::vector<T> arr;
@@ -67,7 +67,7 @@ BENCHMARK(stdsort<_Float16>)->Arg(10000)->Arg(1000000);
 template <typename T>
 static void avx512_qselect(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         int64_t K = state.range(0);
         size_t ARRSIZE = 10000;
@@ -98,7 +98,7 @@ static void avx512_qselect(benchmark::State &state)
 template <typename T>
 static void stdnthelement(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         int64_t K = state.range(0);
         size_t ARRSIZE = 10000;
@@ -133,7 +133,7 @@ BENCHMARK(stdnthelement<_Float16>)->Arg(10)->Arg(100)->Arg(1000)->Arg(5000);
 template <typename T>
 static void avx512_partial_qsort(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         int64_t K = state.range(0);
         size_t ARRSIZE = 10000;
@@ -164,7 +164,7 @@ static void avx512_partial_qsort(benchmark::State &state)
 template <typename T>
 static void stdpartialsort(benchmark::State &state)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         // Perform setup here
         int64_t K = state.range(0);
         size_t ARRSIZE = 10000;
diff --git a/meson.build b/meson.build
@@ -24,14 +24,14 @@ subdir('benchmarks')
 testexe = executable('testexe',
                      include_directories : [src, utils],
                      dependencies : gtest_dep,
-                     link_whole : [libtests, libcpuinfo]
+                     link_whole : [libtests]
                     )
 
 benchexe = executable('benchexe',
                       include_directories : [src, utils, bench],
                       dependencies : [gbench_dep],
                       link_args: ['-lbenchmark_main'],
-                      link_whole : [libbench, libcpuinfo],
+                      link_whole : [libbench],
                      )
 
 summary({
diff --git a/tests/test-argselect.hpp b/tests/test-argselect.hpp
@@ -11,7 +11,7 @@ TYPED_TEST_SUITE_P(avx512argselect);
 
 TYPED_TEST_P(avx512argselect, test_random)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         const int arrsize = 1024;
         auto arr = get_uniform_rand_array<TypeParam>(arrsize);
         std::vector<int64_t> sorted_inx;
diff --git a/tests/test-argsort-common.h b/tests/test-argsort-common.h
@@ -1,5 +1,5 @@
 #include "avx512-64bit-argsort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <algorithm>
 #include <gtest/gtest.h>
diff --git a/tests/test-argsort.hpp b/tests/test-argsort.hpp
@@ -10,7 +10,7 @@ TYPED_TEST_SUITE_P(avx512argsort);
 
 TYPED_TEST_P(avx512argsort, test_random)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii <= 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -39,7 +39,7 @@ TYPED_TEST_P(avx512argsort, test_random)
 
 TYPED_TEST_P(avx512argsort, test_constant)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii <= 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -71,7 +71,7 @@ TYPED_TEST_P(avx512argsort, test_constant)
 
 TYPED_TEST_P(avx512argsort, test_small_range)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii <= 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -100,7 +100,7 @@ TYPED_TEST_P(avx512argsort, test_small_range)
 
 TYPED_TEST_P(avx512argsort, test_sorted)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii <= 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -129,7 +129,7 @@ TYPED_TEST_P(avx512argsort, test_sorted)
 
 TYPED_TEST_P(avx512argsort, test_reverse)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii <= 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -159,7 +159,7 @@ TYPED_TEST_P(avx512argsort, test_reverse)
 
 TYPED_TEST_P(avx512argsort, test_array_with_nan)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";
     }
     if (!std::is_floating_point<TypeParam>::value) {
@@ -193,7 +193,7 @@ TYPED_TEST_P(avx512argsort, test_array_with_nan)
 
 TYPED_TEST_P(avx512argsort, test_max_value_at_end_of_array)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";
     }
     std::vector<int64_t> arrsizes;
@@ -224,7 +224,7 @@ TYPED_TEST_P(avx512argsort, test_max_value_at_end_of_array)
 
 TYPED_TEST_P(avx512argsort, test_all_inf_array)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";
     }
     std::vector<int64_t> arrsizes;
diff --git a/tests/test-keyvalue.cpp b/tests/test-keyvalue.cpp
@@ -4,7 +4,7 @@
  * *******************************************/
 
 #include "avx512-64bit-keyvaluesort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <gtest/gtest.h>
 #include <vector>
@@ -30,7 +30,7 @@ TYPED_TEST_SUITE_P(KeyValueSort);
 
 TYPED_TEST_P(KeyValueSort, test_64bit_random_data)
 {
-    if (cpu_has_avx512bw()) {
+    if (__builtin_cpu_supports("avx512bw")) {
         std::vector<int64_t> keysizes;
         for (int64_t ii = 0; ii < 1024; ++ii) {
             keysizes.push_back((TypeParam)ii);
diff --git a/tests/test-partial-qsort.hpp b/tests/test-partial-qsort.hpp
@@ -10,8 +10,8 @@ TYPED_TEST_P(avx512_partial_sort, test_ranges)
     int64_t arrsize = 1024;
     int64_t nranges = 500;
 
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<TypeParam> arr;
diff --git a/tests/test-qselect.hpp b/tests/test-qselect.hpp
@@ -7,8 +7,8 @@ TYPED_TEST_SUITE_P(avx512_select);
 
 TYPED_TEST_P(avx512_select, test_random)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
@@ -51,8 +51,8 @@ TYPED_TEST_P(avx512_select, test_random)
 
 TYPED_TEST_P(avx512_select, test_small_range)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
diff --git a/tests/test-qsort-common.h b/tests/test-qsort-common.h
@@ -4,7 +4,7 @@
 #include "avx512-16bit-qsort.hpp"
 #include "avx512-32bit-qsort.hpp"
 #include "avx512-64bit-qsort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <gtest/gtest.h>
 
diff --git a/tests/test-qsort-fp.hpp b/tests/test-qsort-fp.hpp
@@ -13,7 +13,7 @@ TYPED_TEST_SUITE_P(avx512_sort_fp);
 TYPED_TEST_P(avx512_sort_fp, test_random_nan)
 {
     const int num_nans = 3;
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         GTEST_SKIP() << "Skipping this test, it requires avx512bw";
     }
     std::vector<int64_t> arrsizes;
diff --git a/tests/test-qsort.hpp b/tests/test-qsort.hpp
@@ -12,8 +12,8 @@ TYPED_TEST_SUITE_P(avx512_sort);
 
 TYPED_TEST_P(avx512_sort, test_random)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
@@ -41,8 +41,8 @@ TYPED_TEST_P(avx512_sort, test_random)
 
 TYPED_TEST_P(avx512_sort, test_reverse)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
@@ -72,8 +72,8 @@ TYPED_TEST_P(avx512_sort, test_reverse)
 
 TYPED_TEST_P(avx512_sort, test_constant)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
@@ -103,8 +103,8 @@ TYPED_TEST_P(avx512_sort, test_constant)
 
 TYPED_TEST_P(avx512_sort, test_small_range)
 {
-    if (cpu_has_avx512bw()) {
-        if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if (__builtin_cpu_supports("avx512bw")) {
+        if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
             GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
         }
         std::vector<int64_t> arrsizes;
@@ -131,10 +131,10 @@ TYPED_TEST_P(avx512_sort, test_small_range)
 
 TYPED_TEST_P(avx512_sort, test_max_value_at_end_of_array)
 {
-    if (!cpu_has_avx512bw()) {
+    if (!__builtin_cpu_supports("avx512bw")) {
         GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";
     }
-    if ((sizeof(TypeParam) == 2) && (!cpu_has_avx512_vbmi2())) {
+    if ((sizeof(TypeParam) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {
         GTEST_SKIP() << "Skipping this test, it requires avx512_vbmi2";
     }
     std::vector<int64_t> arrsizes;
diff --git a/tests/test-qsortfp16.cpp b/tests/test-qsortfp16.cpp
@@ -4,14 +4,14 @@
  * *******************************************/
 
 #include "avx512fp16-16bit-qsort.hpp"
-#include "cpuinfo.h"
+
 #include "rand_array.h"
 #include <gtest/gtest.h>
 #include <vector>
 
 TEST(avx512_qsort_float16, test_arrsizes)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii < 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -41,7 +41,7 @@ TEST(avx512_qsort_float16, test_arrsizes)
 
 TEST(avx512_qsort_float16, test_special_floats)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         const int arrsize = 1111;
         std::vector<_Float16> arr;
         std::vector<_Float16> sortedarr;
@@ -75,7 +75,7 @@ TEST(avx512_qsort_float16, test_special_floats)
 
 TEST(avx512_qselect_float16, test_arrsizes)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         std::vector<int64_t> arrsizes;
         for (int64_t ii = 0; ii < 1024; ++ii) {
             arrsizes.push_back(ii);
@@ -120,7 +120,7 @@ TEST(avx512_qselect_float16, test_arrsizes)
 
 TEST(avx512_partial_qsort_float16, test_ranges)
 {
-    if (cpu_has_avx512fp16()) {
+    if (__builtin_cpu_supports("avx512fp16")) {
         int64_t arrsize = 1024;
         int64_t nranges = 500;
 

Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ template <typename T, class... Args>`
`52`	`52`	`static void avx512argsort(benchmark::State &state, Args &&...args)`
`53`	`53`	`{`
`54`	`54`	`auto args_tuple = std::make_tuple(std::move(args)...);`
`55`		`- if (!cpu_has_avx512bw()) {`
	`55`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`56`	`56`	`state.SkipWithMessage("Requires AVX512 BW ISA");`
`57`	`57`	`}`
`58`	`58`	`// Perform setup here`
Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,10 @@`
`3`	`3`	`template <typename T>`
`4`	`4`	`static void avx512_partial_qsort(benchmark::State &state)`
`5`	`5`	`{`
`6`		`- if (!cpu_has_avx512bw()) {`
	`6`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`7`	`7`	`state.SkipWithMessage("Requires AVX512 BW ISA");`
`8`	`8`	`}`
`9`		`- if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {`
	`9`	`+ if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {`
`10`	`10`	`state.SkipWithMessage("Requires AVX512 VBMI2 ISA");`
`11`	`11`	`}`
`12`	`12`	`// Perform setup here`
Original file line number	Diff line number	Diff line change
`@@ -3,10 +3,10 @@`
`3`	`3`	`template <typename T>`
`4`	`4`	`static void avx512_qselect(benchmark::State &state)`
`5`	`5`	`{`
`6`		`- if (!cpu_has_avx512bw()) {`
	`6`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`7`	`7`	`state.SkipWithMessage("Requires AVX512 BW ISA");`
`8`	`8`	`}`
`9`		`- if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {`
	`9`	`+ if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {`
`10`	`10`	`state.SkipWithMessage("Requires AVX512 VBMI2 ISA");`
`11`	`11`	`}`
`12`	`12`	`// Perform setup here`
Original file line number	Diff line number	Diff line change
`@@ -41,10 +41,10 @@ template <typename T, class... Args>`
`41`	`41`	`static void avx512qsort(benchmark::State &state, Args &&...args)`
`42`	`42`	`{`
`43`	`43`	`auto args_tuple = std::make_tuple(std::move(args)...);`
`44`		`- if (!cpu_has_avx512bw()) {`
	`44`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`45`	`45`	`state.SkipWithMessage("Requires AVX512 BW ISA");`
`46`	`46`	`}`
`47`		`- if ((sizeof(T) == 2) && (!cpu_has_avx512_vbmi2())) {`
	`47`	`+ if ((sizeof(T) == 2) && (!__builtin_cpu_supports("avx512vbmi2"))) {`
`48`	`48`	`state.SkipWithMessage("Requires AVX512 VBMI2");`
`49`	`49`	`}`
`50`	`50`	`// Perform setup here`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ TYPED_TEST_SUITE_P(avx512argselect);`
`11`	`11`
`12`	`12`	`TYPED_TEST_P(avx512argselect, test_random)`
`13`	`13`	`{`
`14`		`- if (cpu_has_avx512bw()) {`
	`14`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`15`	`15`	`const int arrsize = 1024;`
`16`	`16`	`auto arr = get_uniform_rand_array<TypeParam>(arrsize);`
`17`	`17`	`std::vector<int64_t> sorted_inx;`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ TYPED_TEST_SUITE_P(avx512argsort);`
`10`	`10`
`11`	`11`	`TYPED_TEST_P(avx512argsort, test_random)`
`12`	`12`	`{`
`13`		`- if (cpu_has_avx512bw()) {`
	`13`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`14`	`14`	`std::vector<int64_t> arrsizes;`
`15`	`15`	`for (int64_t ii = 0; ii <= 1024; ++ii) {`
`16`	`16`	`arrsizes.push_back(ii);`
`@@ -39,7 +39,7 @@ TYPED_TEST_P(avx512argsort, test_random)`
`39`	`39`
`40`	`40`	`TYPED_TEST_P(avx512argsort, test_constant)`
`41`	`41`	`{`
`42`		`- if (cpu_has_avx512bw()) {`
	`42`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`43`	`43`	`std::vector<int64_t> arrsizes;`
`44`	`44`	`for (int64_t ii = 0; ii <= 1024; ++ii) {`
`45`	`45`	`arrsizes.push_back(ii);`
`@@ -71,7 +71,7 @@ TYPED_TEST_P(avx512argsort, test_constant)`
`71`	`71`
`72`	`72`	`TYPED_TEST_P(avx512argsort, test_small_range)`
`73`	`73`	`{`
`74`		`- if (cpu_has_avx512bw()) {`
	`74`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`75`	`75`	`std::vector<int64_t> arrsizes;`
`76`	`76`	`for (int64_t ii = 0; ii <= 1024; ++ii) {`
`77`	`77`	`arrsizes.push_back(ii);`
`@@ -100,7 +100,7 @@ TYPED_TEST_P(avx512argsort, test_small_range)`
`100`	`100`
`101`	`101`	`TYPED_TEST_P(avx512argsort, test_sorted)`
`102`	`102`	`{`
`103`		`- if (cpu_has_avx512bw()) {`
	`103`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`104`	`104`	`std::vector<int64_t> arrsizes;`
`105`	`105`	`for (int64_t ii = 0; ii <= 1024; ++ii) {`
`106`	`106`	`arrsizes.push_back(ii);`
`@@ -129,7 +129,7 @@ TYPED_TEST_P(avx512argsort, test_sorted)`
`129`	`129`
`130`	`130`	`TYPED_TEST_P(avx512argsort, test_reverse)`
`131`	`131`	`{`
`132`		`- if (cpu_has_avx512bw()) {`
	`132`	`+ if (__builtin_cpu_supports("avx512bw")) {`
`133`	`133`	`std::vector<int64_t> arrsizes;`
`134`	`134`	`for (int64_t ii = 0; ii <= 1024; ++ii) {`
`135`	`135`	`arrsizes.push_back(ii);`
`@@ -159,7 +159,7 @@ TYPED_TEST_P(avx512argsort, test_reverse)`
`159`	`159`
`160`	`160`	`TYPED_TEST_P(avx512argsort, test_array_with_nan)`
`161`	`161`	`{`
`162`		`- if (!cpu_has_avx512bw()) {`
	`162`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`163`	`163`	`GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";`
`164`	`164`	`}`
`165`	`165`	`if (!std::is_floating_point<TypeParam>::value) {`
`@@ -193,7 +193,7 @@ TYPED_TEST_P(avx512argsort, test_array_with_nan)`
`193`	`193`
`194`	`194`	`TYPED_TEST_P(avx512argsort, test_max_value_at_end_of_array)`
`195`	`195`	`{`
`196`		`- if (!cpu_has_avx512bw()) {`
	`196`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`197`	`197`	`GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";`
`198`	`198`	`}`
`199`	`199`	`std::vector<int64_t> arrsizes;`
`@@ -224,7 +224,7 @@ TYPED_TEST_P(avx512argsort, test_max_value_at_end_of_array)`
`224`	`224`
`225`	`225`	`TYPED_TEST_P(avx512argsort, test_all_inf_array)`
`226`	`226`	`{`
`227`		`- if (!cpu_has_avx512bw()) {`
	`227`	`+ if (!__builtin_cpu_supports("avx512bw")) {`
`228`	`228`	`GTEST_SKIP() << "Skipping this test, it requires avx512bw ISA";`
`229`	`229`	`}`
`230`	`230`	`std::vector<int64_t> arrsizes;`