alibaba · JalinWang · Feb 9, 2026 · Feb 10, 2026 · Feb 10, 2026 · Feb 10, 2026
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -3,8 +3,36 @@ cmake_policy(SET CMP0077 NEW)
 project(zvec)
 set(CC_CXX_STANDARD 17)
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror=return-type")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror=return-type")
+if(MSVC)
+    set(INTTYPES_FORMAT VC7)
+    add_compile_options(/FS) #handle .pdb
+    add_compile_options(/EHsc) # def c++ exception behavior
+    add_compile_options(/Zc:preprocessor)
+    add_compile_options(/we4716) # -Werror=return-type
+
+
+    ###### reduce output length to make vibe coding work better :), which should be removed or solved later
+    add_compile_options(/wd4267 /wd4244)
+    add_compile_options(/wd4146) # unary minus operator applied to unsigned type #usage: uint32_t seg_id_{-1U};
+    add_compile_options(/wd4310) # warning C4310: cast truncates constant value
+    add_compile_options(/wd4530) #  warning C4530: C++ exception handler used, but unwind semantics are not enabled. Specify /EHsc
+    add_compile_options(/wd4251) #protobuf
+    add_compile_options(/wd4245 /wd4334 /wd4702  /wd4305 /wd4099)
+    add_compile_options(/wd4200) # flexible structure
+
+    # //warning C4334: '<<': result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)
+    # keeps |= (1 << k);
+    add_compile_options(/wd4334)
+    ######
+
+    #TODO(windows): to be verified
+    add_definitions(-DARROW_STATIC -DPARQUET_STATIC -DARROW_ACERO_STATIC -DARROW_DS_STATIC -DARROW_COMPUTE_STATIC)
+
+
+else()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Werror=return-type")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Werror=return-type")
+endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--no-as-needed")
@@ -21,6 +49,7 @@ include(${PROJECT_ROOT_DIR}/cmake/bazel.cmake)
 
 include_directories(${PROJECT_ROOT_DIR}/src/include)
 include_directories(${PROJECT_ROOT_DIR}/src)
+include_directories(${PROJECT_ROOT_DIR})
 
 option(BUILD_PYTHON_BINDINGS "Build Python bindings using pybind11" OFF)
 message(STATUS "BUILD_PYTHON_BINDINGS:${BUILD_PYTHON_BINDINGS}")

diff --git a/cmake/bazel.cmake b/cmake/bazel.cmake
@@ -621,6 +621,11 @@ function(_target_link_libraries _NAME)
       get_target_property(ALWAYS_LINK ${LIB} ALWAYS_LINK)
       if(ALWAYS_LINK)
         list(APPEND LOCAL_RESULT ${LIB})
+      elseif(MSVC AND TARGET ${LIB}_static)
+        get_target_property(_SIBLING_AL ${LIB}_static ALWAYS_LINK)
+        if(_SIBLING_AL)
+          list(APPEND LOCAL_RESULT ${LIB}_static)
+        endif()
       endif()
 
       get_target_property(DEP_LIBS ${LIB} INTERFACE_LINK_LIBRARIES)
@@ -652,6 +657,30 @@ function(_target_link_libraries _NAME)
 
   list(REMOVE_DUPLICATES ALL_LIBS_TO_PROCESS)
 
+  # On MSVC, each DLL has its own copy of template statics (e.g. Factory
+  # singletons), so registrations inside a DLL are invisible to the exe.
+  # Substitute SHARED libs with their ALWAYS_LINK _static counterparts and
+  # use /WHOLEARCHIVE so all registration code lives in the same module.
+  if(MSVC)
+    set(_SUBSTITUTED_LIBS "")
+    foreach(LIB ${ALL_LIBS_TO_PROCESS})
+      if(TARGET ${LIB} AND TARGET ${LIB}_static)
+        get_target_property(_LIB_TYPE ${LIB} TYPE)
+        get_target_property(_STATIC_AL ${LIB}_static ALWAYS_LINK)
+        if("${_LIB_TYPE}" STREQUAL "SHARED_LIBRARY" AND _STATIC_AL)
+          list(APPEND _SUBSTITUTED_LIBS ${LIB}_static)
+          list(APPEND ALL_ALWAYS_LINK_LIBS ${LIB}_static)
+          continue()
+        endif()
+      endif()
+      list(APPEND _SUBSTITUTED_LIBS ${LIB})
+    endforeach()
+    set(ALL_LIBS_TO_PROCESS ${_SUBSTITUTED_LIBS})
+    if(ALL_ALWAYS_LINK_LIBS)
+      list(REMOVE_DUPLICATES ALL_ALWAYS_LINK_LIBS)
+    endif()
+  endif()
+
   foreach(LIB ${ALL_LIBS_TO_PROCESS})
     if(NOT TARGET ${LIB})
       list(APPEND LINK_LIBS ${LIB})
@@ -672,7 +701,7 @@ function(_target_link_libraries _NAME)
       endif()
     else()
       # Microsoft Visual C++
-      list(APPEND LINK_LIBS /WHOLEARCHIVE:$<TARGET_FILE:${LIB}>)
+      list(APPEND MSVC_WHOLEARCHIVE_OPTS /WHOLEARCHIVE:$<TARGET_FILE:${LIB}>)
       get_target_property(OTHER_LINK_LIBS ${LIB} INTERFACE_LINK_LIBRARIES)
       if(OTHER_LINK_LIBS)
         foreach(OTHER_LIB ${OTHER_LINK_LIBS})
@@ -691,6 +720,9 @@ function(_target_link_libraries _NAME)
   endforeach()
 
   target_link_libraries(${_NAME} ${LINK_LIBS})
+  if(MSVC_WHOLEARCHIVE_OPTS)
+    target_link_options(${_NAME} PRIVATE ${MSVC_WHOLEARCHIVE_OPTS})
+  endif()
   if(LIBS_DEPS)
     add_dependencies(${_NAME} ${LIBS_DEPS})
     target_include_directories(${_NAME} PRIVATE "${LIBS_INCS}")

diff --git a/cmake/utils.cmake b/cmake/utils.cmake
@@ -12,7 +12,7 @@ function(apply_patch_once patch_name target_dir patch_file)
 
     #message(STATUS "Applying patch '${patch_name}' to ${target_dir} ...")
     execute_process(
-        COMMAND patch -p1 -i "${patch_file}"
+        COMMAND git apply --ignore-space-change --ignore-whitespace "${patch_file}"
         WORKING_DIRECTORY "${target_dir}"
         RESULT_VARIABLE patch_result
         OUTPUT_VARIABLE patch_stdout

diff --git a/src/ailego/buffer/buffer_manager.cc b/src/ailego/buffer/buffer_manager.cc
@@ -103,7 +103,7 @@ struct BufferManager::BufferContext {
 
   ~BufferContext() {
     if (vector) {
-      free(vector);
+      ailego_aligned_free(vector);
     }
   }
 
@@ -256,15 +256,15 @@ bool BufferManager::BufferContext::read_vector() {
   }
   AILEGO_DEFER([this] { file.close(); });
   uint32_t len = id.vector().length;
-  auto ret = posix_memalign((void **)&vector, 64, len);  // 64-byte alignment
-  if (ret != 0 || vector == nullptr) {
+  vector = (uint8_t *)ailego_aligned_malloc(len, 64);  // 64-byte alignment
+  if (vector == nullptr) {
     LOG_ERROR("Failed to allocate buffer for file[%s]", file_name.c_str());
     return false;
   }
   uint32_t offset = id.vector().offset;
   if (file.read(offset, vector, len) != len) {
     LOG_ERROR("Failed to read file[%s]", file_name.c_str());
-    free(vector);
+    ailego_aligned_free(vector);
     vector = nullptr;
     return false;
   }
@@ -390,7 +390,7 @@ class BufferManager::BufferPool {
       if (victim->id.type == BufferID::TYPE::PARQUET) {
         victim->arrow_refs.clear();
       } else {
-        free(victim->vector);
+        ailego_aligned_free(victim->vector);
         victim->vector = nullptr;
       }
       victim->state = BufferContext::State::IDLE;
@@ -585,10 +585,15 @@ uint64_t BufferManager::total_size_in_bytes() const {
 }
 
 
-BufferManager::~BufferManager() {
+void BufferManager::cleanup() {
   for (auto pool : pools_) {
     delete pool;
   }
+  pools_.clear();
+}
+
+BufferManager::~BufferManager() {
+  cleanup();
 }
 
 

diff --git a/src/ailego/internal/cpu_features.cc b/src/ailego/internal/cpu_features.cc
@@ -15,7 +15,9 @@
 #include "cpu_features.h"
 #include <cstddef>
 
-#if !defined(_MSC_VER) && !defined(__ARM_ARCH)
+#if defined(_MSC_VER)
+#include <intrin.h>
+#elif !defined(__ARM_ARCH)
 #include <cpuid.h>
 #endif
 

diff --git a/src/ailego/io/file.cc b/src/ailego/io/file.cc
@@ -639,14 +639,28 @@ ssize_t File::offset(void) const {
 }
 
 void *File::MemoryMap(NativeHandle handle, ssize_t off, size_t len, int opts) {
-  LARGE_INTEGER file_size;
-  file_size.QuadPart = len;
+  // Root cause: Windows MapViewOfFile requires the file offset to be aligned to
+  // the allocation granularity (64 KB), but segment offsets were only
+  // page-aligned (4 KB). Also, CreateFileMapping was using len instead of
+  // off + len as the max size.
+  //
+  // Fix: Align the view offset down to allocation granularity, adjust the map
+  // length, and return base + excess. MemoryUnmap recovers the base by rounding
+  // down to granularity.
+
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  DWORD granularity = si.dwAllocationGranularity;
+  ssize_t aligned_off = (off / (ssize_t)granularity) * (ssize_t)granularity;
+  size_t excess = (size_t)(off - aligned_off);
+
+  LARGE_INTEGER max_size;
+  max_size.QuadPart = off + len;
 
-  // Create map object
   HANDLE file_mapping = CreateFileMapping(
       handle, nullptr,
       ((opts & File::MMAP_READONLY) ? PAGE_READONLY : PAGE_READWRITE),
-      file_size.HighPart, file_size.LowPart, nullptr);
+      max_size.HighPart, max_size.LowPart, nullptr);
   ailego_null_if_false(file_mapping != nullptr);
 
   DWORD desired_access = FILE_MAP_READ;
@@ -656,14 +670,17 @@ void *File::MemoryMap(NativeHandle handle, ssize_t off, size_t len, int opts) {
   if (!(opts & File::MMAP_SHARED)) {
     desired_access |= FILE_MAP_COPY;
   }
-  file_size.QuadPart = off;
 
-  // Map the whole file to memory and close handle
-  void *addr = MapViewOfFile(file_mapping, desired_access, file_size.HighPart,
-                             file_size.LowPart, 0);
+  LARGE_INTEGER view_offset;
+  view_offset.QuadPart = aligned_off;
+  size_t view_len = len + excess;
+
+  void *base = MapViewOfFile(file_mapping, desired_access, view_offset.HighPart,
+                             view_offset.LowPart, view_len);
   CloseHandle(file_mapping);
 
-  ailego_null_if_false(addr);
+  ailego_null_if_false(base);
+  void *addr = (char *)base + excess;
   if (opts & File::MMAP_LOCKED) {
     VirtualLock(addr, len);
   }
@@ -673,8 +690,17 @@ void *File::MemoryMap(NativeHandle handle, ssize_t off, size_t len, int opts) {
   return addr;
 }
 
-void *File::MemoryMap(size_t, int) {
-  return nullptr;
+void *File::MemoryMap(size_t len, int opts) {
+  void *addr =
+      VirtualAlloc(nullptr, len, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
+  ailego_null_if_false(addr);
+  if (opts & File::MMAP_LOCKED) {
+    VirtualLock(addr, len);
+  }
+  if (opts & File::MMAP_WARMUP) {
+    File::MemoryWarmup(addr, len);
+  }
+  return addr;
 }
 
 void *File::MemoryRemap(void *, size_t, void *, size_t) {
@@ -683,7 +709,14 @@ void *File::MemoryRemap(void *, size_t, void *, size_t) {
 
 void File::MemoryUnmap(void *addr, size_t /*len*/) {
   ailego_return_if_false(addr);
-  UnmapViewOfFile(addr);
+  MEMORY_BASIC_INFORMATION mbi;
+  if (VirtualQuery(addr, &mbi, sizeof(mbi))) {
+    if (mbi.Type == MEM_MAPPED) {
+      UnmapViewOfFile(mbi.AllocationBase);
+    } else {
+      VirtualFree(mbi.AllocationBase, 0, MEM_RELEASE);
+    }
+  }
 }
 
 bool File::MemoryFlush(void *addr, size_t /*len*/) {

diff --git a/src/ailego/math/distance_matrix_accum_fp16.i b/src/ailego/math/distance_matrix_accum_fp16.i
@@ -82,7 +82,7 @@
   __m128 xmm_sum_0_0 = _mm_add_ps(_mm256_castps256_ps128(ymm_sum_0_0),        \
                                   _mm256_extractf128_ps(ymm_sum_0_0, 1));     \
   if (qe >= qe_aligned + 2) {                                                 \
-    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(m)));         \
+    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(m)));         \
     __m128 xmm_q = _mm_cvtph_ps(                                              \
         _mm_shufflelo_epi16(_mm_broadcast_si32(q), _MM_SHUFFLE(1, 1, 0, 0))); \
     ACCUM_FP32_STEP_SSE(xmm_m, xmm_q, xmm_sum_0_0)                            \
@@ -120,8 +120,8 @@
   __m128 xmm_sum_0_1 = _mm_add_ps(_mm256_castps256_ps128(ymm_sum_0_1),        \
                                   _mm256_extractf128_ps(ymm_sum_0_1, 1));     \
   if (qe >= qe_aligned + 4) {                                                 \
-    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(m)));         \
-    __m128 xmm_q = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(q)));         \
+    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(m)));         \
+    __m128 xmm_q = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(q)));         \
     __m128 xmm_p = _mm_permute_ps(xmm_q, _MM_SHUFFLE(2, 2, 0, 0));            \
     ACCUM_FP32_STEP_SSE(xmm_m, xmm_p, xmm_sum_0_0)                            \
     xmm_p = _mm_permute_ps(xmm_q, _MM_SHUFFLE(3, 3, 1, 1));                   \
@@ -164,7 +164,7 @@
   __m128 xmm_sum_0_0 = _mm_add_ps(_mm256_castps256_ps128(ymm_sum_0_0),       \
                                   _mm256_extractf128_ps(ymm_sum_0_0, 1));    \
   if (q != qe) {                                                             \
-    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(m)));        \
+    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(m)));        \
     __m128 xmm_q = _mm_cvtph_ps(_mm_set1_epi16(*(const short *)(q)));        \
     ACCUM_FP32_STEP_SSE(xmm_m, xmm_q, xmm_sum_0_0)                           \
   }                                                                          \
@@ -198,7 +198,7 @@
   if (q != qe) {                                                             \
     __m128 xmm_q_0 = _mm_cvtph_ps(_mm_set1_epi16(*(const short *)(q + 0)));  \
     __m128 xmm_q_1 = _mm_cvtph_ps(_mm_set1_epi16(*(const short *)(q + 1)));  \
-    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(m)));        \
+    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(m)));        \
     MATRIX_VAR_PROC(1, 2, 0, xmm_m, xmm_q, xmm_sum, ACCUM_FP32_STEP_SSE)     \
   }                                                                          \
   if (((uintptr_t)out & 0xf) == 0) {                                         \
@@ -233,8 +233,8 @@
   __m128 xmm_sum_0_3 = _mm_add_ps(_mm256_castps256_ps128(ymm_sum_0_3),       \
                                   _mm256_extractf128_ps(ymm_sum_0_3, 1));    \
   if (q != qe) {                                                             \
-    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(m)));        \
-    __m128 xmm_q = _mm_cvtph_ps(_mm_set1_epi64(*(const __m64 *)(q)));        \
+    __m128 xmm_m = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(m)));        \
+    __m128 xmm_q = _mm_cvtph_ps(_mm_set1_epi64x(*(const long long *)(q)));        \
     __m128 xmm_p = _mm_permute_ps(xmm_q, _MM_SHUFFLE(0, 0, 0, 0));           \
     ACCUM_FP32_STEP_SSE(xmm_m, xmm_p, xmm_sum_0_0)                           \
     xmm_p = _mm_permute_ps(xmm_q, _MM_SHUFFLE(1, 1, 1, 1));                  \

diff --git a/src/ailego/math/distance_matrix_fp16.i b/src/ailego/math/distance_matrix_fp16.i
@@ -67,9 +67,9 @@
     }                                                                        \
     case 4: {                                                                \
       __m256 ymm_lhs = _mm256_cvtph_ps(                                      \
-          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(lhs))));           \
+          _mm_set_epi64x((long long)(_MASK), *(const long long *)(lhs)));    \
       __m256 ymm_rhs = _mm256_cvtph_ps(                                      \
-          _mm_set_epi64((__m64)(_MASK), *((const __m64 *)(rhs))));           \
+          _mm_set_epi64x((long long)(_MASK), *(const long long *)(rhs)));    \
       _PROC(ymm_lhs, ymm_rhs, _RES##_0_0)                                    \
       break;                                                                 \
     }                                                                        \
@@ -125,7 +125,7 @@
   {                                                              \
     __m256 ymm_m = _mm256_cvtph_ps(_LOAD((const __m128i *)(m))); \
     __m256 ymm_q = _mm256_cvtph_ps(_mm_shufflehi_epi16(          \
-        _mm_shufflelo_epi16(_mm_set1_epi64(*(const __m64 *)(q)), \
+        _mm_shufflelo_epi16(_mm_set1_epi64x(*(const long long *)(q)), \
                             _MM_SHUFFLE(1, 1, 0, 0)),            \
         _MM_SHUFFLE(3, 3, 2, 2)));                               \
     _PROC(ymm_m, ymm_q, _RES##_0_0)                              \
@@ -155,7 +155,7 @@
 //! Iterative process of computing distance (FP16, M=4, N=2)
 #define MATRIX_FP16_ITER_4X2_AVX(m, q, _RES, _LOAD, _PROC)       \
   {                                                              \
-    __m128i xmm_qi = _mm_set1_epi64(*(const __m64 *)(q));        \
+    __m128i xmm_qi = _mm_set1_epi64x(*(const long long *)(q));    \
     __m256 ymm_m = _mm256_cvtph_ps(_LOAD((const __m128i *)(m))); \
     __m256 ymm_q_0 = _mm256_cvtph_ps(_mm_shufflehi_epi16(        \
         _mm_shufflelo_epi16(xmm_qi, _MM_SHUFFLE(0, 0, 0, 0)),    \

diff --git a/src/ailego/math/inner_product_matrix.h b/src/ailego/math/inner_product_matrix.h
@@ -852,7 +852,7 @@ struct MinusInnerProductSparseMatrix {
                                              const void *sparse_value,
                                              std::string &buffer);
 
-  static inline float ComputeInnerProductSparseInSegment(
+  static float ComputeInnerProductSparseInSegment(
       uint32_t m_sparse_count, const uint16_t *m_sparse_index,
       const ValueType *m_sparse_value, uint32_t q_sparse_count,
       const uint16_t *q_sparse_index, const ValueType *q_sparse_value);

diff --git a/src/ailego/math/inner_product_matrix_fp16.cc b/src/ailego/math/inner_product_matrix_fp16.cc
diff --git a/src/ailego/math/inner_product_matrix_fp16_avx512.cc b/src/ailego/math/inner_product_matrix_fp16_avx512.cc
@@ -735,7 +735,7 @@ float InnerProductSparseInSegmentAVX512FP16(uint32_t m_sparse_count,
                                              _mm_loadu_ph(val_start_2 + k)));
     }
 
-    Float16 __attribute__((aligned(16))) tmp_res[8];
+    alignas(16) Float16 tmp_res[8];
     _mm_store_ph(tmp_res, sum128);
     sum += (tmp_res[0] + tmp_res[1] + tmp_res[2] + tmp_res[3] + tmp_res[4] +
             tmp_res[5] + tmp_res[6] + tmp_res[7]);

diff --git a/src/ailego/math/inner_product_matrix_fp32.cc b/src/ailego/math/inner_product_matrix_fp32.cc
diff --git a/src/ailego/math/inner_product_matrix_fp32_sse.cc b/src/ailego/math/inner_product_matrix_fp32_sse.cc
@@ -298,7 +298,7 @@ float InnerProductSparseInSegmentSSE(uint32_t m_sparse_count,
                                              _mm_loadu_ps(val_start_2 + k)));
     }
 
-    float __attribute__((aligned(16))) tmp_res[4];
+    alignas(16) float tmp_res[4];
     _mm_store_ps(tmp_res, sum128);
     sum += (tmp_res[0] + tmp_res[1] + tmp_res[2] + tmp_res[3]);
   }

diff --git a/src/ailego/math/mips_euclidean_distance_matrix_fp32.cc b/src/ailego/math/mips_euclidean_distance_matrix_fp32.cc
diff --git a/src/ailego/math/mips_euclidean_distance_matrix_fp32_sse.cc b/src/ailego/math/mips_euclidean_distance_matrix_fp32_sse.cc
@@ -328,7 +328,7 @@ float MipsInnerProductSparseInSegmentSSE(uint32_t m_sparse_count,
                                              _mm_loadu_ps(val_start_2 + k)));
     }
 
-    float __attribute__((aligned(16))) tmp_res[4];
+    alignas(16) float tmp_res[4];
     _mm_store_ps(tmp_res, sum128);
     sum += (tmp_res[0] + tmp_res[1] + tmp_res[2] + tmp_res[3]);
   }

diff --git a/src/ailego/math/norm_matrix_fp16.i b/src/ailego/math/norm_matrix_fp16.i
@@ -49,7 +49,7 @@
     }                                                                          \
     case 4: {                                                                  \
       __m256 ymm_m = _mm256_cvtph_ps(                                          \
-          _mm_set_epi64((__m64)(0ull), *((const __m64 *)(m))));                \
+          _mm_set_epi64x(0LL, *(const long long *)(m)));                \
       NORM_FP32_STEP_AVX(ymm_m, _RES##_0_0)                                    \
       break;                                                                   \
     }                                                                          \