Skip to content

Eliminate dimensionality parameter from distance instantiations #199

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed
Copilot wants to merge 18 commits into from
Closed

Eliminate dimensionality parameter from distance instantiations #199

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
18 commits
Select commit Hold shift + click to select a range
0ecb060
Initial plan
Copilot Oct 21, 2025
2be3c52
Add comprehensive documentation to instantiation system
Copilot Oct 21, 2025
0cc4b66
Add codeql build artifacts to gitignore
Copilot Oct 21, 2025
3af6506
Refactor to instantiate only for Dynamic dimension
Copilot Oct 22, 2025
c7589ae
Complete refactoring - all tests pass, CodeQL clean
Copilot Oct 22, 2025
39a9d8b
Add codeql build artifacts to gitignore
Copilot Oct 22, 2025
d57c2f2
Add AVX_AVAILABILITY template parameter to SIMD ops
Copilot Oct 22, 2025
70c6629
Eliminate explicit instantiation of distance implementations
Copilot Oct 22, 2025
f75ca92
Complete refactoring - ready for review
Copilot Oct 22, 2025
9b2051b
Delete _codeql_detected_source_root
ahuber21 Oct 22, 2025
bbb8652
Add explicit instantiations to force AVX code generation
Copilot Oct 22, 2025
4a825ff
WIP: Move SIMD op definitions to avx .cpp files (incomplete)
Copilot Oct 22, 2025
1878a24
WIP: Implement SIMD op specializations in .cpp files
Copilot Oct 22, 2025
1a964f8
Successfully refactor instantiations to SIMD op level
Copilot Oct 22, 2025
e4dee86
reword comment, sort includes
ahuber21 Oct 22, 2025
3674727
Remove unused preprocessor.h and cleanup distance headers
Copilot Oct 22, 2025
5b23648
Add runtime dispatch wrappers for L2 distance (partial solution)
Copilot Oct 22, 2025
6cb0fa2
Revert to working state and request clarification
Copilot Oct 22, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions .gitignore
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,3 +21,5 @@ __pycache__/

# Example generated files.
example_data_*/
_codeql_build_dir/
_codeql_detected_source_root
64 changes: 19 additions & 45 deletions include/svs/core/distance/cosine.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -216,12 +216,12 @@ struct CosineSimilarityImpl {
/////

// Shared implementation among those that use floating-point arithmetic.
template <size_t SIMDWidth> struct CosineFloatOp;
template <size_t SIMDWidth, AVX_AVAILABILITY Avx> struct CosineFloatOp;

SVS_VALIDATE_BOOL_ENV(SVS_AVX512_F)
#if SVS_AVX512_F

template <> struct CosineFloatOp<16> : public svs::simd::ConvertToFloat<16> {
template <> struct CosineFloatOp<16, AVX_AVAILABILITY::AVX512> : public svs::simd::ConvertToFloat<16> {
using parent = svs::simd::ConvertToFloat<16>;
using mask_t = typename parent::mask_t;

Expand Down Expand Up @@ -287,7 +287,7 @@ struct CosineSimilarityImpl<N, int8_t, int8_t, AVX_AVAILABILITY::AVX512> {
(a_norm * b_norm);
}
// Fallback to AVX512
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand Down Expand Up @@ -320,7 +320,7 @@ struct CosineSimilarityImpl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX512> {
(a_norm * b_norm);
}
// Fallback to AVX512
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -331,7 +331,7 @@ struct CosineSimilarityImpl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX512> {
template <size_t N> struct CosineSimilarityImpl<N, float, float, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const float* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -340,7 +340,7 @@ template <size_t N>
struct CosineSimilarityImpl<N, float, uint8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const uint8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
};
};
Expand All @@ -349,7 +349,7 @@ template <size_t N>
struct CosineSimilarityImpl<N, float, int8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const int8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
};
};
Expand All @@ -358,7 +358,7 @@ template <size_t N>
struct CosineSimilarityImpl<N, float, Float16, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const Float16* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -367,7 +367,7 @@ template <size_t N>
struct CosineSimilarityImpl<N, Float16, float, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const Float16* a, const float* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -376,7 +376,7 @@ template <size_t N>
struct CosineSimilarityImpl<N, Float16, Float16, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const Float16* a, const Float16* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -391,7 +391,7 @@ SVS_VALIDATE_BOOL_ENV(SVS_AVX512_F)
SVS_VALIDATE_BOOL_ENV(SVS_AVX2)
#if !SVS_AVX512_F && SVS_AVX2

template <> struct CosineFloatOp<8> : public svs::simd::ConvertToFloat<8> {
template <> struct CosineFloatOp<8, AVX_AVAILABILITY::AVX2> : public svs::simd::ConvertToFloat<8> {
using parent = svs::simd::ConvertToFloat<8>;
using mask_t = typename parent::mask_t;
static constexpr size_t simd_width = 8;
Expand Down Expand Up @@ -432,39 +432,39 @@ template <> struct CosineFloatOp<8> : public svs::simd::ConvertToFloat<8> {
template <size_t N> struct CosineSimilarityImpl<N, float, float, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const float* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};

template <size_t N> struct CosineSimilarityImpl<N, float, uint8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const uint8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
};
};

template <size_t N> struct CosineSimilarityImpl<N, float, int8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const int8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>(), a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>(), a, b, length);
return sum / (std::sqrt(norm) * a_norm);
};
};

template <size_t N> struct CosineSimilarityImpl<N, float, Float16, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const Float16* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};

template <size_t N> struct CosineSimilarityImpl<N, Float16, float, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const Float16* a, const float* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -473,15 +473,15 @@ template <size_t N>
struct CosineSimilarityImpl<N, Float16, Float16, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const Float16* a, const Float16* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};

template <size_t N> struct CosineSimilarityImpl<N, int8_t, int8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const int8_t* a, const int8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};
Expand All @@ -490,36 +490,10 @@ template <size_t N>
struct CosineSimilarityImpl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const uint8_t* a, const uint8_t* b, float a_norm, lib::MaybeStatic<N> length) {
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8>{}, a, b, length);
auto [sum, norm] = simd::generic_simd_op(CosineFloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
return sum / (std::sqrt(norm) * a_norm);
}
};

#endif

#if defined(__x86_64__)

#include "svs/multi-arch/x86/preprocessor.h"
// TODO: connect with dim_supported_list
DISTANCE_CS_EXTERN_TEMPLATE(64, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(96, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(100, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(128, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(160, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(200, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(512, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(768, AVX_AVAILABILITY::AVX512);
DISTANCE_CS_EXTERN_TEMPLATE(Dynamic, AVX_AVAILABILITY::AVX512);

DISTANCE_CS_EXTERN_TEMPLATE(64, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(96, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(100, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(128, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(160, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(200, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(512, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(768, AVX_AVAILABILITY::AVX2);
DISTANCE_CS_EXTERN_TEMPLATE(Dynamic, AVX_AVAILABILITY::AVX2);

#endif
} // namespace svs::distance
68 changes: 21 additions & 47 deletions include/svs/core/distance/euclidean.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -228,16 +228,16 @@ template <size_t N, typename Ea, typename Eb, AVX_AVAILABILITY Avx> struct L2Imp

// SIMD accelerated operations that convert both left and right hand arguments to
// ``float`` and perform arithmetic on those floating point operands.
template <size_t SIMDWidth> struct L2FloatOp;
template <size_t SIMDWidth, AVX_AVAILABILITY Avx> struct L2FloatOp;

// SIMD accelerated operations that convert both left and right hand arguments to
// ``To`` and perform arithmetic on those integer operands.
template <std::integral To, size_t SIMDWidth> struct L2VNNIOp;
template <std::integral To, size_t SIMDWidth, AVX_AVAILABILITY Avx> struct L2VNNIOp;

SVS_VALIDATE_BOOL_ENV(SVS_AVX512_F)
#if SVS_AVX512_F

template <> struct L2FloatOp<16> : public svs::simd::ConvertToFloat<16> {
template <> struct L2FloatOp<16, AVX_AVAILABILITY::AVX512> : public svs::simd::ConvertToFloat<16> {
using parent = svs::simd::ConvertToFloat<16>;
using mask_t = typename parent::mask_t;

Expand All @@ -262,7 +262,7 @@ template <> struct L2FloatOp<16> : public svs::simd::ConvertToFloat<16> {
SVS_VALIDATE_BOOL_ENV(SVS_AVX512_VNNI)
#if SVS_AVX512_VNNI

template <> struct L2VNNIOp<int16_t, 32> : public svs::simd::ConvertForVNNI<int16_t, 32> {
template <> struct L2VNNIOp<int16_t, 32, AVX_AVAILABILITY::AVX512> : public svs::simd::ConvertForVNNI<int16_t, 32> {
using parent = svs::simd::ConvertForVNNI<int16_t, 32>;
using reg_t = typename parent::reg_t;
using mask_t = typename parent::mask_t;
Expand Down Expand Up @@ -294,21 +294,21 @@ template <size_t N> struct L2Impl<N, int8_t, int8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const int8_t* a, const int8_t* b, lib::MaybeStatic<N> length) {
if (__builtin_expect(svs::detail::avx_runtime_flags.is_avx512vnni_supported(), 1)) {
return simd::generic_simd_op(L2VNNIOp<int16_t, 32>(), a, b, length);
return simd::generic_simd_op(L2VNNIOp<int16_t, 32, AVX_AVAILABILITY::AVX512>(), a, b, length);
}
// fallback to AVX512
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const uint8_t* a, const uint8_t* b, lib::MaybeStatic<N> length) {
if (__builtin_expect(svs::detail::avx_runtime_flags.is_avx512vnni_supported(), 1)) {
return simd::generic_simd_op(L2VNNIOp<int16_t, 32>(), a, b, length);
return simd::generic_simd_op(L2VNNIOp<int16_t, 32, AVX_AVAILABILITY::AVX512>(), a, b, length);
}
// fallback to AVX512
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
}
};

Expand All @@ -318,42 +318,42 @@ template <size_t N> struct L2Impl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX512>
template <size_t N> struct L2Impl<N, float, float, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const float* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, float, uint8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const uint8_t* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
};
};

template <size_t N> struct L2Impl<N, float, int8_t, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const int8_t* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
};
};

template <size_t N> struct L2Impl<N, float, Float16, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const float* a, const Float16* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, Float16, float, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const Float16* a, const float* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, Float16, Float16, AVX_AVAILABILITY::AVX512> {
SVS_NOINLINE static float
compute(const Float16* a, const Float16* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<16>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<16, AVX_AVAILABILITY::AVX512>{}, a, b, length);
};
};

Expand All @@ -367,7 +367,7 @@ SVS_VALIDATE_BOOL_ENV(SVS_AVX512_F)
SVS_VALIDATE_BOOL_ENV(SVS_AVX2)
#if !SVS_AVX512_F && SVS_AVX2

template <> struct L2FloatOp<8> : public svs::simd::ConvertToFloat<8> {
template <> struct L2FloatOp<8, AVX_AVAILABILITY::AVX2> : public svs::simd::ConvertToFloat<8> {
using parent = svs::simd::ConvertToFloat<8>;
using mask_t = typename parent::mask_t;
static constexpr size_t simd_width = 8;
Expand All @@ -393,71 +393,45 @@ template <> struct L2FloatOp<8> : public svs::simd::ConvertToFloat<8> {
template <size_t N> struct L2Impl<N, float, float, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const float* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, Float16, Float16, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const Float16* a, const Float16* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, float, Float16, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const Float16* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, float, int8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const float* a, const int8_t* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, int8_t, int8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const int8_t* a, const int8_t* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

template <size_t N> struct L2Impl<N, uint8_t, uint8_t, AVX_AVAILABILITY::AVX2> {
SVS_NOINLINE static float
compute(const uint8_t* a, const uint8_t* b, lib::MaybeStatic<N> length) {
return simd::generic_simd_op(L2FloatOp<8>{}, a, b, length);
return simd::generic_simd_op(L2FloatOp<8, AVX_AVAILABILITY::AVX2>{}, a, b, length);
}
};

#endif

#if defined(__x86_64__)

#include "svs/multi-arch/x86/preprocessor.h"

// TODO: connect with dim_supported_list
DISTANCE_L2_EXTERN_TEMPLATE(64, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(96, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(100, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(128, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(160, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(200, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(512, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(768, AVX_AVAILABILITY::AVX512);
DISTANCE_L2_EXTERN_TEMPLATE(Dynamic, AVX_AVAILABILITY::AVX512);

DISTANCE_L2_EXTERN_TEMPLATE(64, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(96, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(100, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(200, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(128, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(200, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(512, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(768, AVX_AVAILABILITY::AVX2);
DISTANCE_L2_EXTERN_TEMPLATE(Dynamic, AVX_AVAILABILITY::AVX2);
#endif

} // namespace svs::distance
Loading