fix(simd): umasked AVX2 load

.github/workflows/asan.yml

@@ -0,0 +1,68 @@
+# Copyright 2025 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: ASan Build and Test
+run-name: ${{ github.event.inputs.run_name || github.event.pull_request.title }}
+
+on:
+  workflow_dispatch:
+  pull_request:
+
+concurrency:
+  group: "${{ github.workflow }} @ ${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  asan-test:
+    name: clang++-18 -fsanitize=address
+    runs-on: [self-hosted, Linux, ubuntu-22.04]
+    env:
+      CXX: clang++-18
+      CC: clang-18
+
+    steps:
+      - name: "Cleanup build folder"
+        run: |
+          ls -la ./
+          sudo rm -rf ./* || true
+          sudo rm -rf ./.??* || true
+          ls -la ./
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+
+      - name: Configure build
+        working-directory: ${{ runner.temp }}
+        env:
+          TEMP_WORKSPACE: ${{ runner.temp }}
+        run: |
+          cmake -B${TEMP_WORKSPACE}/build -S${GITHUB_WORKSPACE} \
+                -DCMAKE_BUILD_TYPE=Debug \
+                -DCMAKE_CXX_FLAGS="-fsanitize=address -fno-omit-frame-pointer -g" \
+                -DCMAKE_EXE_LINKER_FLAGS="-fsanitize=address" \
+                -DSVS_BUILD_TESTS=YES \
+                -DSVS_BUILD_BINARIES=NO \
+                -DSVS_BUILD_EXAMPLES=NO
+
+      - name: Build tests
+        working-directory: ${{ runner.temp }}/build
+        run: make tests -j
+
+      - name: Run tests
+        env:
+          CTEST_OUTPUT_ON_FAILURE: 1
+          ASAN_OPTIONS: detect_leaks=0
+        working-directory: ${{ runner.temp }}/build/tests
+        run: ./tests

include/svs/core/distance/simd_utils.h

@@ -19,6 +19,7 @@
 #if defined(__i386__) || defined(__x86_64__)
 
 #include <array>
+#include <cstring>
 #include <limits>
 #include <type_traits>
 
@@ -332,11 +333,10 @@ template <> struct ConvertToFloat<8> {
     // from float
     static __m256 load(const float* ptr) { return _mm256_loadu_ps(ptr); }
     static __m256 load(mask_t m, const float* ptr) {
-        // AVX2 doesn't have native masked load, so we load and then blend
-        auto data = _mm256_loadu_ps(ptr);
-        auto zero = _mm256_setzero_ps();
-        auto mask_vec = create_blend_mask_avx2(m);
-        return _mm256_blendv_ps(zero, data, mask_vec);
+        // Full width load with blending may cause out-of-bounds read (SEGV)
+        // Therefore we use _mm256_maskload_ps which safely handles masked loads
+        auto mask_vec = _mm256_castps_si256(create_blend_mask_avx2(m));
+        return _mm256_maskload_ps(ptr, mask_vec);
     }
 
     // from float16
@@ -345,10 +345,10 @@ template <> struct ConvertToFloat<8> {
     }
 
     static __m256 load(mask_t m, const Float16* ptr) {
-        auto data = _mm256_cvtph_ps(_mm_loadu_si128(reinterpret_cast<const __m128i*>(ptr)));
-        auto zero = _mm256_setzero_ps();
-        auto mask_vec = create_blend_mask_avx2(m);
-        return _mm256_blendv_ps(zero, data, mask_vec);
+        // Safe masked load using a temporary buffer to avoid SEGV
+        __m128i buffer = _mm_setzero_si128();
+        std::memcpy(&buffer, ptr, __builtin_popcount(m) * sizeof(Float16));
+        return _mm256_cvtph_ps(buffer);
     }
 
     // from uint8
@@ -359,12 +359,10 @@ template <> struct ConvertToFloat<8> {
     }
 
     static __m256 load(mask_t m, const uint8_t* ptr) {
-        auto data = _mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(
-            _mm_cvtsi64_si128(*(reinterpret_cast<const int64_t*>(ptr)))
-        ));
-        auto zero = _mm256_setzero_ps();
-        auto mask_vec = create_blend_mask_avx2(m);
-        return _mm256_blendv_ps(zero, data, mask_vec);
+        // Safe masked load using a temporary buffer to avoid SEGV
+        int64_t buffer = 0;
+        std::memcpy(&buffer, ptr, __builtin_popcount(m) * sizeof(uint8_t));
+        return _mm256_cvtepi32_ps(_mm256_cvtepu8_epi32(_mm_cvtsi64_si128(buffer)));
     }
 
     // from int8
@@ -375,12 +373,10 @@ template <> struct ConvertToFloat<8> {
     }
 
     static __m256 load(mask_t m, const int8_t* ptr) {
-        auto data = _mm256_cvtepi32_ps(_mm256_cvtepi8_epi32(
-            _mm_cvtsi64_si128(*(reinterpret_cast<const int64_t*>(ptr)))
-        ));
-        auto zero = _mm256_setzero_ps();
-        auto mask_vec = create_blend_mask_avx2(m);
-        return _mm256_blendv_ps(zero, data, mask_vec);
+        // Safe masked load using a temporary buffer to avoid SEGV
+        int64_t buffer = 0;
+        std::memcpy(&buffer, ptr, __builtin_popcount(m) * sizeof(int8_t));
+        return _mm256_cvtepi32_ps(_mm256_cvtepi8_epi32(_mm_cvtsi64_si128(buffer)));
     }
 
     // We do not need to treat the left or right-hand differently.

tests/svs/core/distance.cpp

@@ -20,6 +20,9 @@
 // catch 2
 #include "catch2/catch_test_macros.hpp"
 
+#include <numeric>
+#include <vector>
+
 namespace {
 
 std::string_view test_table = R"(
@@ -94,3 +97,58 @@ CATCH_TEST_CASE("Distance Utils", "[core][distance][distance_type]") {
         }
     }
 }
+
+CATCH_TEST_CASE("Distance asan L2", "[distance][simd][asan][l2]") {
+    // Try various sizes to hit the case where vector capacity == size
+    // and the SIMD load reads past the end into the redzone.
+    // We test sizes that are not multiples of 8 (AVX2 width) or 16 (AVX512 width).
+    for (size_t size = 1; size < 128; ++size) {
+        std::vector<float> a(size);
+        std::vector<float> b(size);
+
+        std::iota(a.begin(), a.end(), 0.0f);
+        std::iota(b.begin(), b.end(), 1.0f);
+
+        // Ensure no spare capacity
+        a.shrink_to_fit();
+        b.shrink_to_fit();
+
+        auto dist = svs::distance::L2::compute(a.data(), b.data(), size);
+        CATCH_REQUIRE(dist >= 0);
+    }
+}
+
+CATCH_TEST_CASE("Distance asan Cosine", "[distance][simd][asan][cosine]") {
+    for (size_t size = 1; size < 128; ++size) {
+        std::vector<float> a(size);
+        std::vector<float> b(size);
+
+        std::iota(a.begin(), a.end(), 0.0f);
+        std::iota(b.begin(), b.end(), 1.0f);
+
+        // Ensure no spare capacity
+        a.shrink_to_fit();
+        b.shrink_to_fit();
+
+        auto dist =
+            svs::distance::CosineSimilarity::compute(a.data(), b.data(), 1.0f, size);
+        CATCH_REQUIRE(dist >= 0);
+    }
+}
+
+CATCH_TEST_CASE("Distance asan IP", "[distance][simd][asan][ip]") {
+    for (size_t size = 1; size < 128; ++size) {
+        std::vector<float> a(size);
+        std::vector<float> b(size);
+
+        std::iota(a.begin(), a.end(), 0.0f);
+        std::iota(b.begin(), b.end(), 1.0f);
+
+        // Ensure no spare capacity
+        a.shrink_to_fit();
+        b.shrink_to_fit();
+
+        auto dist = svs::distance::IP::compute(a.data(), b.data(), size);
+        CATCH_REQUIRE(dist >= 0);
+    }
+}