xiaoxue_admin
/
zvec
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fix: Replace VLAs with std::vector for MSVC compatibility and stack safety (#190)

This commit is contained in:
feihongxu0824 2026-03-03 10:07:21 +08:00 committed by GitHub
parent 9eb68ee061
commit 24d877da5e
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
38 changed files with 294 additions and 265 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/ailego/algorithm/lloyd_cluster.h
View File

@ -16,6 +16,7 @@
#include <algorithm>
#include <random>
#include <vector>
#include <ailego/parallel/lock.h>
#include <zvec/ailego/parallel/thread_pool.h>
#include <zvec/ailego/utility/type_helper.h>
@ -247,7 +248,7 @@ class LloydCluster {
protected:
//! Cluster the cache features
void cluster_cache_features(void) {
float scores[BatchCount];
std::vector<float> scores(BatchCount);
for (size_t i = 0, n = feature_cache_.count(); i != n; ++i) {
size_t count = centroids_matrix_.count() / BatchCount * BatchCount;
@ -258,7 +259,7 @@ class LloydCluster {
for (size_t j = 0; j != count; j += BatchCount) {
ContextType::template BatchDistance<1>(centroids_matrix_[j], feature,
centroids_matrix_.dimension(),
scores);
scores.data());
for (size_t k = 0; k < BatchCount; ++k) {
if (scores[k] < nearest_score) {
@ -271,7 +272,7 @@ class LloydCluster {
for (size_t j = count, total = centroids_matrix_.count(); j != total;
++j) {
ContextType::Distance(centroids_matrix_[j], feature,
centroids_matrix_.dimension(), scores);
centroids_matrix_.dimension(), scores.data());
if (scores[0] < nearest_score) {
nearest_score = scores[0];
@ -295,8 +296,8 @@ class LloydCluster {
return i < j;
};
float nearest_scores[BatchCount];
size_t nearest_indexes[BatchCount];
std::vector<float> nearest_scores(BatchCount);
std::vector<size_t> nearest_indexes(BatchCount);
rows.resize(BatchCount);
for (size_t i = first * BatchCount; i != last * BatchCount;
@ -304,14 +305,14 @@ class LloydCluster {
size_t count = centroids_matrix_.count() / BatchCount * BatchCount;
const StoreType *block = feature_matrix_[i];
std::fill(nearest_indexes, nearest_indexes + BatchCount, 0);
std::fill(nearest_scores, nearest_scores + BatchCount,
std::fill(nearest_indexes.data(), nearest_indexes.data() + BatchCount, 0);
std::fill(nearest_scores.data(), nearest_scores.data() + BatchCount,
std::numeric_limits<float>::max());
for (size_t j = 0; j != count; j += BatchCount) {
ContextType::template BatchDistance<BatchCount>(
centroids_matrix_[j], block, centroids_matrix_.dimension(),
&scores[0]);
scores.data());
for (size_t k = 0; k < BatchCount; ++k) {
const float *start = &scores[k * BatchCount];
@ -328,7 +329,7 @@ class LloydCluster {
++j) {
ContextType::template BatchDistance<1>(block, centroids_matrix_[j],
centroids_matrix_.dimension(),
&scores[0]);
scores.data());
for (size_t k = 0; k < BatchCount; ++k) {
float score = scores[k];

37
src/ailego/math/mips_euclidean_distance_matrix.h
View File

@ -14,6 +14,7 @@
#pragma once
#include <vector>
#include <ailego/math/norm2_matrix.h>
#include <ailego/utility/math_helper.h>
#include <zvec/ailego/internal/platform.h>
@ -108,8 +109,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
for (size_t i = 0; i < M; ++i) {
const ValueType p_val = p[i];
u2[i] = static_cast<float>(p_val * p_val);
@ -161,8 +162,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
for (size_t i = 0; i < M; ++i) {
const ValueType p_val = p[i];
u2[i] = static_cast<float>(p_val * p_val);
@ -240,7 +241,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
ValueType q_val = *q++;
float v2 = static_cast<float>(q_val * q_val);
for (size_t i = 0; i < M; ++i) {
@ -274,7 +275,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
ValueType q_val = *q++;
float v2 = static_cast<float>(q_val * q_val);
for (size_t i = 0; i < M; ++i) {
@ -327,8 +328,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
const uint32_t *p_it = reinterpret_cast<const uint32_t *>(p);
const uint32_t *q_it = reinterpret_cast<const uint32_t *>(q);
for (size_t i = 0; i < M; ++i) {
@ -383,8 +384,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
const uint32_t *p_it = reinterpret_cast<const uint32_t *>(p);
const uint32_t *q_it = reinterpret_cast<const uint32_t *>(q);
for (size_t i = 0; i < M; ++i) {
@ -495,7 +496,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
uint32_t q_val = *q_it++;
float v2 = Squared(q_val);
for (size_t i = 0; i < M; ++i) {
@ -531,7 +532,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
uint32_t q_val = *q_it++;
float v2 = Squared(q_val);
for (size_t i = 0; i < M; ++i) {
@ -613,8 +614,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
const uint32_t *p_it = reinterpret_cast<const uint32_t *>(p);
const uint32_t *q_it = reinterpret_cast<const uint32_t *>(q);
for (size_t i = 0; i < M; ++i) {
@ -669,8 +670,8 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
float v2[N];
std::vector<float> u2(M);
std::vector<float> v2(N);
const uint32_t *p_it = reinterpret_cast<const uint32_t *>(p);
const uint32_t *q_it = reinterpret_cast<const uint32_t *>(q);
for (size_t i = 0; i < M; ++i) {
@ -856,7 +857,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
uint32_t q_val = *q_it++;
float v2 = Squared(q_val);
for (size_t i = 0; i < M; ++i) {
@ -892,7 +893,7 @@ struct MipsSquaredEuclideanDistanceMatrix<
return;
}
float u2[M];
std::vector<float> u2(M);
uint32_t q_val = *q_it++;
float v2 = Squared(q_val);
for (size_t i = 0; i < M; ++i) {

10
src/ailego/math_batch/inner_product_distance_batch_impl.h
View File

@ -53,14 +53,14 @@ compute_one_to_many_avx2_fp32(
const ValueType *query, const ValueType **ptrs,
std::array<const ValueType *, dp_batch> &prefetch_ptrs,
size_t dimensionality, float *results) {
__m256 accs[dp_batch];
std::vector<__m256> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm256_setzero_ps();
}
size_t dim = 0;
for (; dim + 8 <= dimensionality; dim += 8) {
__m256 q = _mm256_loadu_ps(query + dim);
__m256 data_regs[dp_batch];
std::vector<__m256> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm256_loadu_ps(ptrs[i] + dim);
}
@ -73,13 +73,13 @@ compute_one_to_many_avx2_fp32(
accs[i] = _mm256_fnmadd_ps(q, data_regs[i], accs[i]);
}
}
__m128 sum128_regs[dp_batch];
std::vector<__m128> sum128_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
sum128_regs[i] = sum_top_bottom_avx(accs[i]);
}
if (dim + 4 <= dimensionality) {
__m128 q = _mm_loadu_ps(query + dim);
__m128 data_regs[dp_batch];
std::vector<__m128> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm_loadu_ps(ptrs[i] + dim);
}
@ -95,7 +95,7 @@ compute_one_to_many_avx2_fp32(
}
if (dim + 2 <= dimensionality) {
__m128 q = _mm_setzero_ps();
__m128 data_regs[dp_batch];
std::vector<__m128> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm_setzero_ps();
}

22
src/ailego/math_batch/inner_product_distance_batch_impl_fp16.h
View File

@ -30,7 +30,7 @@ compute_one_to_many_avx512fp16_fp16(
const ailego::Float16 *query, const ailego::Float16 **ptrs,
std::array<const ailego::Float16 *, dp_batch> &prefetch_ptrs,
size_t dimensionality, float *results) {
__m512h accs[dp_batch];
std::vector<__m512h> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm512_setzero_ph();
@ -40,7 +40,7 @@ compute_one_to_many_avx512fp16_fp16(
for (; dim + 32 <= dimensionality; dim += 32) {
__m512h q = _mm512_loadu_ph(query + dim);
__m512h data_regs[dp_batch];
std::vector<__m512h> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm512_loadu_ph(ptrs[i] + dim);
}
@ -86,7 +86,7 @@ compute_one_to_many_avx512f_fp16(
const ailego::Float16 *query, const ailego::Float16 **ptrs,
std::array<const ailego::Float16 *, dp_batch> &prefetch_ptrs,
size_t dimensionality, float *results) {
__m512 accs[dp_batch];
std::vector<__m512> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm512_setzero_ps();
@ -100,8 +100,8 @@ compute_one_to_many_avx512f_fp16(
__m512 q1 = _mm512_cvtph_ps(_mm512_castsi512_si256(q));
__m512 q2 = _mm512_cvtph_ps(_mm512_extracti64x4_epi64(q, 1));
__m512 data_regs_1[dp_batch];
__m512 data_regs_2[dp_batch];
std::vector<__m512> data_regs_1(dp_batch);
std::vector<__m512> data_regs_2(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
__m512i m =
_mm512_loadu_si512(reinterpret_cast<const __m512i *>(ptrs[i] + dim));
@ -126,7 +126,7 @@ compute_one_to_many_avx512f_fp16(
__m512 q = _mm512_cvtph_ps(
_mm256_loadu_si256(reinterpret_cast<const __m256i *>(query + dim)));
__m512 data_regs[dp_batch];
std::vector<__m512> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm512_cvtph_ps(
_mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptrs[i] + dim)));
@ -136,7 +136,7 @@ compute_one_to_many_avx512f_fp16(
dim += 16;
}
__m256 acc_new[dp_batch];
std::vector<__m256> acc_new(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
acc_new[i] = _mm256_add_ps(
_mm512_castps512_ps256(accs[i]),
@ -176,7 +176,7 @@ compute_one_to_many_avx2_fp16(
const ailego::Float16 *query, const ailego::Float16 **ptrs,
std::array<const ailego::Float16 *, dp_batch> &prefetch_ptrs,
size_t dimensionality, float *results) {
__m256 accs[dp_batch];
std::vector<__m256> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm256_setzero_ps();
@ -190,8 +190,8 @@ compute_one_to_many_avx2_fp16(
__m256 q1 = _mm256_cvtph_ps(_mm256_castsi256_si128(q));
__m256 q2 = _mm256_cvtph_ps(_mm256_extractf128_si256(q, 1));
__m256 data_regs_1[dp_batch];
__m256 data_regs_2[dp_batch];
std::vector<__m256> data_regs_1(dp_batch);
std::vector<__m256> data_regs_2(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
__m256i m =
_mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptrs[i] + dim));
@ -216,7 +216,7 @@ compute_one_to_many_avx2_fp16(
__m256 q = _mm256_cvtph_ps(
_mm_loadu_si128(reinterpret_cast<const __m128i *>(query + dim)));
__m256 data_regs[dp_batch];
std::vector<__m256> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm256_cvtph_ps(
_mm_loadu_si128(reinterpret_cast<const __m128i *>(ptrs[i] + dim)));

28
src/ailego/math_batch/inner_product_distance_batch_impl_int8.h
View File

@ -55,7 +55,7 @@ static void compute_one_to_many_avx512_vnni_int8(
const int8_t *query, const int8_t **ptrs,
std::array<const int8_t *, dp_batch> &prefetch_ptrs, size_t dimensionality,
float *results) {
__m512i accs[dp_batch];
std::vector<__m512i> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm512_setzero_si512();
}
@ -63,7 +63,7 @@ static void compute_one_to_many_avx512_vnni_int8(
for (; dim + 64 <= dimensionality; dim += 64) {
__m512i q =
_mm512_loadu_si512(reinterpret_cast<const __m512i *>(query + dim));
__m512i data_regs[dp_batch];
std::vector<__m512i> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] =
_mm512_loadu_si512(reinterpret_cast<const __m512i *>(ptrs[i] + dim));
@ -100,12 +100,12 @@ static void compute_one_to_many_avx512_vnni_int8(
// const int8_t *query, const int8_t **ptrs,
// std::array<const int8_t *, dp_batch> &prefetch_ptrs, size_t
// dimensionality, float *results) {
// __m512i accs[dp_batch];
// std::vector<__m512i> accs(dp_batch);
// size_t dim = 0;
// for (; dim + 64 <= dimensionality; dim += 64) {
// __m512i q =
// _mm512_loadu_si512(reinterpret_cast<const __m512i *>(query + dim));
// __m512i data_regs[dp_batch];
// std::vector<__m512i> data_regs(dp_batch);
// for (size_t i = 0; i < dp_batch; ++i) {
// data_regs[i] =
// _mm512_loadu_si512(reinterpret_cast<const __m512i *>(ptrs[i] +
@ -118,16 +118,16 @@ static void compute_one_to_many_avx512_vnni_int8(
// }
// __m512i q_lo = _mm512_cvtepi8_epi16(_mm512_extracti64x4_epi64(q, 0));
// __m512i q_hi = _mm512_cvtepi8_epi16(_mm512_extracti64x4_epi64(q, 1));
// __m512i data_lo[dp_batch];
// __m512i data_hi[dp_batch];
// std::vector<__m512i> data_lo(dp_batch);
// std::vector<__m512i> data_hi(dp_batch);
// for (size_t i = 0; i < dp_batch; ++i) {
// data_lo[i] =
// _mm512_cvtepi8_epi16(_mm512_extracti64x4_epi64(data_regs[i], 0));
// data_hi[i] =
// _mm512_cvtepi8_epi16(_mm512_extracti64x4_epi64(data_regs[i], 1));
// }
// __m512i prod_lo[dp_batch];
// __m512i prod_hi[dp_batch];
// std::vector<__m512i> prod_lo(dp_batch);
// std::vector<__m512i> prod_hi(dp_batch);
// for (size_t i = 0; i < dp_batch; ++i) {
// prod_lo[i] = _mm512_madd_epi16(q_lo, data_lo[i]);
// prod_hi[i] = _mm512_madd_epi16(q_hi, data_hi[i]);
@ -163,14 +163,14 @@ compute_one_to_many_avx2_int8(
const int8_t *query, const int8_t **ptrs,
std::array<const int8_t *, dp_batch> &prefetch_ptrs, size_t dimensionality,
float *results) {
__m256i accs[dp_batch];
std::vector<__m256i> accs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
accs[i] = _mm256_setzero_si256();
}
size_t dim = 0;
for (; dim + 32 <= dimensionality; dim += 32) {
__m256i q = _mm256_loadu_si256((const __m256i *)(query + dim));
__m256i data_regs[dp_batch];
std::vector<__m256i> data_regs(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_regs[i] = _mm256_loadu_si256((const __m256i *)(ptrs[i] + dim));
}
@ -181,15 +181,15 @@ compute_one_to_many_avx2_int8(
}
__m256i q_lo = _mm256_cvtepi8_epi16(_mm256_castsi256_si128(q));
__m256i q_hi = _mm256_cvtepi8_epi16(_mm256_extracti128_si256(q, 1));
__m256i data_lo[dp_batch];
__m256i data_hi[dp_batch];
std::vector<__m256i> data_lo(dp_batch);
std::vector<__m256i> data_hi(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
data_lo[i] = _mm256_cvtepi8_epi16(_mm256_castsi256_si128(data_regs[i]));
data_hi[i] =
_mm256_cvtepi8_epi16(_mm256_extracti128_si256(data_regs[i], 1));
}
__m256i prod_lo[dp_batch];
__m256i prod_hi[dp_batch];
std::vector<__m256i> prod_lo(dp_batch);
std::vector<__m256i> prod_hi(dp_batch);
for (size_t i = 0; i < dp_batch; ++i) {
prod_lo[i] = _mm256_madd_epi16(q_lo, data_lo[i]);
prod_hi[i] = _mm256_madd_epi16(q_hi, data_hi[i]);

22
src/core/algorithm/hnsw/hnsw_algorithm.cc
View File

@ -14,6 +14,7 @@
#include "hnsw_algorithm.h"
#include <chrono>
#include <iostream>
#include <vector>
#include <ailego/internal/cpu_features.h>
namespace zvec {
@ -132,13 +133,13 @@ void HnswAlgorithm::select_entry_point(level_t level, node_id_t *entry_point,
bool find_closer = false;
float dists[size];
const void *neighbor_vecs[size];
std::vector<float> dists(size);
std::vector<const void *> neighbor_vecs(size);
for (uint32_t i = 0; i < size; ++i) {
neighbor_vecs[i] = neighbor_vec_blocks[i].data();
}
dc.batch_dist(neighbor_vecs, size, dists);
dc.batch_dist(neighbor_vecs.data(), size, dists.data());
for (uint32_t i = 0; i < size; ++i) {
dist_t cur_dist = dists[i];
@ -213,7 +214,7 @@ void HnswAlgorithm::search_neighbors(level_t level, node_id_t *entry_point,
(*ctx->mutable_stats_get_neighbors())++;
}
node_id_t neighbor_ids[neighbors.size()];
std::vector<node_id_t> neighbor_ids(neighbors.size());
uint32_t size = 0;
for (uint32_t i = 0; i < neighbors.size(); ++i) {
node_id_t node = neighbors[i];
@ -231,7 +232,7 @@ void HnswAlgorithm::search_neighbors(level_t level, node_id_t *entry_point,
}
std::vector<IndexStorage::MemoryBlock> neighbor_vec_blocks;
int ret = entity.get_vector(neighbor_ids, size, neighbor_vec_blocks);
int ret = entity.get_vector(neighbor_ids.data(), size, neighbor_vec_blocks);
if (ailego_unlikely(ctx->debugging())) {
(*ctx->mutable_stats_get_vector())++;
}
@ -247,14 +248,14 @@ void HnswAlgorithm::search_neighbors(level_t level, node_id_t *entry_point,
}
// done
float dists[size];
const void *neighbor_vecs[size];
std::vector<float> dists(size);
std::vector<const void *> neighbor_vecs(size);
for (uint32_t i = 0; i < size; ++i) {
neighbor_vecs[i] = neighbor_vec_blocks[i].data();
}
dc.batch_dist(neighbor_vecs, size, dists);
dc.batch_dist(neighbor_vecs.data(), size, dists.data());
for (uint32_t i = 0; i < size; ++i) {
node_id_t node = neighbor_ids[i];
@ -336,7 +337,7 @@ void HnswAlgorithm::expand_neighbors_by_group(TopkHeap &topk,
(*ctx->mutable_stats_get_neighbors())++;
}
node_id_t neighbor_ids[neighbors.size()];
std::vector<node_id_t> neighbor_ids(neighbors.size());
uint32_t size = 0;
for (uint32_t i = 0; i < neighbors.size(); ++i) {
node_id_t node = neighbors[i];
@ -354,7 +355,8 @@ void HnswAlgorithm::expand_neighbors_by_group(TopkHeap &topk,
}
std::vector<IndexStorage::MemoryBlock> neighbor_vec_blocks;
int ret = entity.get_vector(neighbor_ids, size, neighbor_vec_blocks);
int ret =
entity.get_vector(neighbor_ids.data(), size, neighbor_vec_blocks);
if (ailego_unlikely(ctx->debugging())) {
(*ctx->mutable_stats_get_vector())++;
}

26
src/core/algorithm/hnsw/hnsw_entity.cc
View File

@ -172,8 +172,8 @@ int64_t HnswEntity::dump_vectors(
size_t padding_size = AlignSize(vector_dump_size) - vector_dump_size;
char padding[padding_size];
memset(padding, 0, sizeof(padding));
std::vector<char> padding(padding_size);
memset(padding.data(), 0, sizeof(char) * padding_size);
const void *data = nullptr;
uint32_t crc = 0U;
size_t vecs_size = 0UL;
@ -198,12 +198,12 @@ int64_t HnswEntity::dump_vectors(
continue;
}
len = dumper->write(padding, padding_size);
len = dumper->write(padding.data(), padding_size);
if (len != padding_size) {
LOG_ERROR("Dump vectors failed, write=%zu expect=%zu", len, padding_size);
return IndexError_WriteData;
}
crc = ailego::Crc32c::Hash(padding, padding_size, crc);
crc = ailego::Crc32c::Hash(padding.data(), padding_size, crc);
vecs_size += padding_size;
}
@ -224,7 +224,7 @@ int64_t HnswEntity::dump_graph_neighbors(
graph_meta.reserve(doc_cnt());
size_t offset = 0;
uint32_t crc = 0;
node_id_t mapping[l0_neighbor_cnt()];
std::vector<node_id_t> mapping(l0_neighbor_cnt());
uint32_t min_neighbor_count = 10000;
uint32_t max_neighbor_count = 0;
@ -253,7 +253,7 @@ int64_t HnswEntity::dump_graph_neighbors(
for (node_id_t i = 0; i < neighbors.size(); ++i) {
mapping[i] = neighbor_mapping[neighbors[i]];
}
data = mapping;
data = mapping.data();
}
if (dumper->write(data, size) != size) {
LOG_ERROR("Dump graph neighbor id=%u failed, size %lu", id, size);
@ -303,7 +303,7 @@ int64_t HnswEntity::dump_upper_neighbors(
hnsw_meta.reserve(doc_cnt());
size_t offset = 0;
uint32_t crc = 0;
node_id_t buffer[upper_neighbor_cnt() + 1];
std::vector<node_id_t> buffer(upper_neighbor_cnt() + 1);
for (node_id_t id = 0; id < doc_cnt(); ++id) {
node_id_t new_id = reorder_mapping.empty() ? id : reorder_mapping[id];
auto level = get_level(new_id);
@ -318,7 +318,7 @@ int64_t HnswEntity::dump_upper_neighbors(
ailego_assert_with(!!neighbors.data, "invalid neighbors");
ailego_assert_with(neighbors.size() <= neighbor_cnt(cur_level),
"invalid neighbors");
memset(buffer, 0, sizeof(buffer));
memset(buffer.data(), 0, sizeof(node_id_t) * buffer.size());
buffer[0] = neighbors.size();
if (neighbor_mapping.empty()) {
memcpy(&buffer[1], &neighbors[0], neighbors.size() * sizeof(node_id_t));
@ -327,13 +327,15 @@ int64_t HnswEntity::dump_upper_neighbors(
buffer[i + 1] = neighbor_mapping[neighbors[i]];
}
}
if (dumper->write(buffer, sizeof(buffer)) != sizeof(buffer)) {
if (dumper->write(buffer.data(), sizeof(node_id_t) * buffer.size()) !=
sizeof(node_id_t) * buffer.size()) {
LOG_ERROR("Dump graph neighbor id=%u failed, size %lu", id,
sizeof(buffer));
sizeof(node_id_t) * buffer.size());
return IndexError_WriteData;
}
crc = ailego::Crc32c::Hash(buffer, sizeof(buffer), crc);
offset += sizeof(buffer);
crc = ailego::Crc32c::Hash(buffer.data(),
sizeof(node_id_t) * buffer.size(), crc);
offset += sizeof(node_id_t) * buffer.size();
}
}
size_t padding_size = 0;

4
src/core/algorithm/hnsw/hnsw_streamer_entity.cc
View File

@ -80,8 +80,8 @@ int HnswStreamerEntity::cleanup() {
int HnswStreamerEntity::update_neighbors(
level_t level, node_id_t id,
const std::vector<std::pair<node_id_t, dist_t>> &neighbors) {
char buffer[neighbor_size_];
NeighborsHeader *hd = reinterpret_cast<NeighborsHeader *>(buffer);
std::vector<char> buffer(neighbor_size_);
NeighborsHeader *hd = reinterpret_cast<NeighborsHeader *>(buffer.data());
hd->neighbor_cnt = neighbors.size();
size_t i = 0;
for (; i < neighbors.size(); ++i) {

12
src/core/algorithm/hnsw_sparse/hnsw_sparse_algorithm.cc
View File

@ -15,6 +15,7 @@
#include "hnsw_sparse_algorithm.h"
#include <chrono>
#include <iostream>
#include <vector>
#include <ailego/internal/cpu_features.h>
namespace zvec {
@ -208,7 +209,7 @@ void HnswSparseAlgorithm::search_neighbors(level_t level,
(*ctx->mutable_stats_get_neighbors())++;
}
node_id_t neighbor_ids[neighbors.size()];
std::vector<node_id_t> neighbor_ids(neighbors.size());
uint32_t size = 0;
for (uint32_t i = 0; i < neighbors.size(); ++i) {
node_id_t node = neighbors[i];
@ -226,7 +227,8 @@ void HnswSparseAlgorithm::search_neighbors(level_t level,
}
std::vector<IndexStorage::MemoryBlock> neighbor_block_vecs;
int ret = entity.get_vector_metas(neighbor_ids, size, neighbor_block_vecs);
int ret =
entity.get_vector_metas(neighbor_ids.data(), size, neighbor_block_vecs);
if (ailego_unlikely(ctx->debugging())) {
(*ctx->mutable_stats_get_vector())++;
}
@ -337,7 +339,7 @@ void HnswSparseAlgorithm::expand_neighbors_by_group(
(*ctx->mutable_stats_get_neighbors())++;
}
node_id_t neighbor_ids[neighbors.size()];
std::vector<node_id_t> neighbor_ids(neighbors.size());
uint32_t size = 0;
for (uint32_t i = 0; i < neighbors.size(); ++i) {
node_id_t node = neighbors[i];
@ -355,8 +357,8 @@ void HnswSparseAlgorithm::expand_neighbors_by_group(
}
std::vector<IndexStorage::MemoryBlock> neighbor_block_vecs;
int ret =
entity.get_vector_metas(neighbor_ids, size, neighbor_block_vecs);
int ret = entity.get_vector_metas(neighbor_ids.data(), size,
neighbor_block_vecs);
if (ailego_unlikely(ctx->debugging())) {
(*ctx->mutable_stats_get_vector())++;
}

18
src/core/algorithm/hnsw_sparse/hnsw_sparse_entity.cc
View File

@ -299,7 +299,7 @@ int64_t HnswSparseEntity::dump_graph_neighbors(
graph_meta.reserve(doc_cnt());
size_t offset = 0;
uint32_t crc = 0;
node_id_t mapping[l0_neighbor_cnt()];
std::vector<node_id_t> mapping(l0_neighbor_cnt());
uint32_t min_neighbor_count = 10000;
uint32_t max_neighbor_count = 0;
@ -328,7 +328,7 @@ int64_t HnswSparseEntity::dump_graph_neighbors(
for (node_id_t i = 0; i < neighbors.size(); ++i) {
mapping[i] = neighbor_mapping[neighbors[i]];
}
data = mapping;
data = mapping.data();
}
if (dumper->write(data, size) != size) {
LOG_ERROR("Dump graph neighbor id=%u failed, size %lu", id, size);
@ -380,7 +380,7 @@ int64_t HnswSparseEntity::dump_upper_neighbors(
hnsw_meta.reserve(doc_cnt());
size_t offset = 0;
uint32_t crc = 0;
node_id_t buffer[upper_neighbor_cnt() + 1];
std::vector<node_id_t> buffer(upper_neighbor_cnt() + 1);
for (node_id_t id = 0; id < doc_cnt(); ++id) {
node_id_t new_id = reorder_mapping.empty() ? id : reorder_mapping[id];
auto level = get_level(new_id);
@ -395,7 +395,7 @@ int64_t HnswSparseEntity::dump_upper_neighbors(
ailego_assert_with(!!neighbors.data, "invalid neighbors");
ailego_assert_with(neighbors.size() <= neighbor_cnt(cur_level),
"invalid neighbors");
memset(buffer, 0, sizeof(buffer));
memset(buffer.data(), 0, sizeof(node_id_t) * buffer.size());
buffer[0] = neighbors.size();
if (neighbor_mapping.empty()) {
memcpy(&buffer[1], &neighbors[0], neighbors.size() * sizeof(node_id_t));
@ -404,13 +404,15 @@ int64_t HnswSparseEntity::dump_upper_neighbors(
buffer[i + 1] = neighbor_mapping[neighbors[i]];
}
}
if (dumper->write(buffer, sizeof(buffer)) != sizeof(buffer)) {
if (dumper->write(buffer.data(), sizeof(node_id_t) * buffer.size()) !=
sizeof(node_id_t) * buffer.size()) {
LOG_ERROR("Dump graph neighbor id=%u failed, size %lu", id,
sizeof(buffer));
sizeof(node_id_t) * buffer.size());
return IndexError_WriteData;
}
crc = ailego::Crc32c::Hash(buffer, sizeof(buffer), crc);
offset += sizeof(buffer);
crc = ailego::Crc32c::Hash(buffer.data(),
sizeof(node_id_t) * buffer.size(), crc);
offset += sizeof(node_id_t) * buffer.size();
}
}
size_t padding_size = 0;

4
src/core/algorithm/hnsw_sparse/hnsw_sparse_streamer_entity.cc
View File

@ -84,8 +84,8 @@ int HnswSparseStreamerEntity::cleanup() {
int HnswSparseStreamerEntity::update_neighbors(
level_t level, node_id_t id,
const std::vector<std::pair<node_id_t, dist_t>> &neighbors) {
char buffer[neighbor_size_];
NeighborsHeader *hd = reinterpret_cast<NeighborsHeader *>(buffer);
std::vector<char> buffer(neighbor_size_);
NeighborsHeader *hd = reinterpret_cast<NeighborsHeader *>(buffer.data());
hd->neighbor_cnt = neighbors.size();
size_t i = 0;
for (; i < neighbors.size(); ++i) {

8
src/core/algorithm/ivf/ivf_entity.cc
View File

@ -595,7 +595,7 @@ int IVFEntity::search(size_t inverted_list_id, const void *query,
const void *data = nullptr;
const size_t block_vecs = header_.block_vector_count;
float distances[block_vecs];
std::vector<float> distances(block_vecs);
const size_t batch_size = kBatchBlocks;
const size_t block_size = header_.block_size;
const auto norm_val = this->inverted_list_normalize_value(inverted_list_id);
@ -639,7 +639,7 @@ int IVFEntity::search(size_t inverted_list_id, const void *query,
const void *block_data = static_cast<const char *>(data) + b * block_size;
calculator_->query_features_distance(query, block_data, vecs_count,
distances);
distances.data());
*(context_stats->mutable_dist_calced_count()) += vecs_count;
@ -669,7 +669,7 @@ int IVFEntity::search(size_t inverted_list_id, const void *query,
const void *data = nullptr;
const size_t block_vecs = header_.block_vector_count;
float distances[block_vecs];
std::vector<float> distances(block_vecs);
const size_t batch_size = kBatchBlocks;
const size_t block_size = header_.block_size;
const auto norm_val = this->inverted_list_normalize_value(inverted_list_id);
@ -700,7 +700,7 @@ int IVFEntity::search(size_t inverted_list_id, const void *query,
auto block_keys = keys + b * block_vecs;
const void *block_data = static_cast<const char *>(data) + b * block_size;
calculator_->query_features_distance(query, block_data, vecs_count,
distances);
distances.data());
for (size_t k = 0; k < vecs_count; ++k) {
if (block_keys[k] != kInvalidKey) {
uint32_t id = list_meta->id_offset + (i + b) * block_vecs + k;

4
tests/ailego/math/cosine_distance_matrix_fp16_test.cc
View File

@ -387,7 +387,7 @@ void CosineBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -415,7 +415,7 @@ void CosineBenchmark(void) {
const Float16 *matrix_batch = &matrix2[i * batch_size * dimension];
CosineDistanceMatrix<Float16, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Cosine (us) \t" << elapsed_time.micro_seconds()
<< std::endl;

4
tests/ailego/math/cosine_distance_matrix_fp32_test.cc
View File

@ -323,7 +323,7 @@ void CosineBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -351,7 +351,7 @@ void CosineBenchmark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
CosineDistanceMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Cosine (us) \t" << elapsed_time.micro_seconds()
<< std::endl;

4
tests/ailego/math/cosine_distance_matrix_int8_test.cc
View File

@ -343,7 +343,7 @@ void CosineBenchmark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -371,7 +371,7 @@ void CosineBenchmark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
CosineDistanceMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Cosine (us) \t" << elapsed_time.micro_seconds()
<< std::endl;

8
tests/ailego/math/euclidean_distance_matrix_fp16_test.cc
View File

@ -550,7 +550,7 @@ void EuclideanBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -578,7 +578,7 @@ void EuclideanBenchmark(void) {
const Float16 *matrix_batch = &matrix2[i * batch_size * dimension];
EuclideanDistanceMatrix<Float16, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Euclidean (us) \t" << elapsed_time.micro_seconds()
<< std::endl;
@ -634,7 +634,7 @@ void SquaredEuclideanBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -662,7 +662,7 @@ void SquaredEuclideanBenchmark(void) {
const Float16 *matrix_batch = &matrix2[i * batch_size * dimension];
SquaredEuclideanDistanceMatrix<Float16, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched SquaredEuclidean (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/euclidean_distance_matrix_fp32_test.cc
View File

@ -540,7 +540,7 @@ void EuclideanBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -568,7 +568,7 @@ void EuclideanBenchmark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
EuclideanDistanceMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Euclidean (us) \t" << elapsed_time.micro_seconds()
<< std::endl;
@ -624,7 +624,7 @@ void SquaredEuclideanBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -652,7 +652,7 @@ void SquaredEuclideanBenchmark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
SquaredEuclideanDistanceMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched SquaredEuclidean (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/euclidean_distance_matrix_int4_test.cc
View File

@ -487,7 +487,7 @@ void EuclideanBenchmark(void) {
query1.data(), dimension / 8, &query2[0]);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -515,7 +515,7 @@ void EuclideanBenchmark(void) {
const uint8_t *matrix_batch = &matrix2[i * batch_size * dimension / 2];
EuclideanDistanceMatrix<uint8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Euclidean (us) \t" << elapsed_time.micro_seconds()
<< std::endl;
@ -572,7 +572,7 @@ void SquaredEuclideanBenchmark(void) {
query1.data(), dimension / 8, &query2[0]);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -600,7 +600,7 @@ void SquaredEuclideanBenchmark(void) {
const uint8_t *matrix_batch = &matrix2[i * batch_size * dimension / 2];
SquaredEuclideanDistanceMatrix<uint8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched SquaredEuclidean (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/euclidean_distance_matrix_int8_test.cc
View File

@ -764,7 +764,7 @@ void EuclideanBenchmark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -792,7 +792,7 @@ void EuclideanBenchmark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
EuclideanDistanceMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched Euclidean (us) \t" << elapsed_time.micro_seconds()
<< std::endl;
@ -850,7 +850,7 @@ void SquaredEuclideanBenchmark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -878,7 +878,7 @@ void SquaredEuclideanBenchmark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
SquaredEuclideanDistanceMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched SquaredEuclidean (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/hamming_distance_matrix_test.cc
View File

@ -504,7 +504,7 @@ void Hamming32Benchmark(void) {
MatrixTranspose(&query2[0], query1.data(), count, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") UINT32 " << count << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -532,7 +532,7 @@ void Hamming32Benchmark(void) {
const uint32_t *matrix_batch = &matrix2[i * batch_size * count];
HammingDistanceMatrix<uint32_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], count * 32, results);
matrix_batch, &query2[0], count * 32, results.data());
}
std::cout << "* N Batched Hamming (us) \t" << elapsed_time.micro_seconds()
<< std::endl;
@ -1001,7 +1001,7 @@ void Hamming64Benchmark(void) {
MatrixTranspose(&query2[0], query1.data(), count, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") UINT64 " << count << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -1029,7 +1029,7 @@ void Hamming64Benchmark(void) {
const uint64_t *matrix_batch = &matrix2[i * batch_size * count];
HammingDistanceMatrix<uint64_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], count * 64, results);
matrix_batch, &query2[0], count * 64, results.data());
}
std::cout << "* N Batched Hamming (us) \t" << elapsed_time.micro_seconds()
<< std::endl;

8
tests/ailego/math/inner_product_matrix_fp16_test.cc
View File

@ -652,7 +652,7 @@ void InnerProductBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -680,7 +680,7 @@ void InnerProductBenchmark(void) {
const Float16 *matrix_batch = &matrix2[i * batch_size * dimension];
InnerProductMatrix<Float16, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched InnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;
@ -736,7 +736,7 @@ void MinusInnerProductBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -764,7 +764,7 @@ void MinusInnerProductBenchmark(void) {
const Float16 *matrix_batch = &matrix2[i * batch_size * dimension];
MinusInnerProductMatrix<Float16, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched MinusInnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/inner_product_matrix_fp32_test.cc
View File

@ -623,7 +623,7 @@ void InnerProductBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -651,7 +651,7 @@ void InnerProductBenchmark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
InnerProductMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched InnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;
@ -707,7 +707,7 @@ void MinusInnerProductBenchmark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -735,7 +735,7 @@ void MinusInnerProductBenchmark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
MinusInnerProductMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched MinusInnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

4
tests/ailego/math/inner_product_matrix_int4_test.cc
View File

@ -488,7 +488,7 @@ void InnerProductBenchmark(void) {
query1.data(), dimension / 8, &query2[0]);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -516,7 +516,7 @@ void InnerProductBenchmark(void) {
const uint8_t *matrix_batch = &matrix2[i * batch_size * dimension / 2];
InnerProductMatrix<uint8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched InnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

8
tests/ailego/math/inner_product_matrix_int8_test.cc
View File

@ -534,7 +534,7 @@ void InnerProductBenchmark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -562,7 +562,7 @@ void InnerProductBenchmark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
InnerProductMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched InnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;
@ -620,7 +620,7 @@ void MinusInnerProductBenchmark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -648,7 +648,7 @@ void MinusInnerProductBenchmark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
MinusInnerProductMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, results);
matrix_batch, &query2[0], dimension, results.data());
}
std::cout << "* N Batched MinusInnerProduct (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

54
tests/ailego/math/mips_euclidean_distance_matrix_fp16_test.cc
View File

@ -58,7 +58,7 @@ static float MipsSquaredEuclideanDistance(const FixedVector<Float16, N> &lhs,
static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
size_t dim, size_t m_value, float e2) {
float squ = 0.0f;
float lhs_vec[dim + m_value];
std::vector<float> lhs_vec(dim + m_value);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -69,7 +69,7 @@ static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
lhs_vec[i] = 0.5f - squ;
squ *= squ;
}
float rhs_vec[dim + m_value];
std::vector<float> rhs_vec(dim + m_value);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
@ -80,7 +80,8 @@ static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
rhs_vec[i] = 0.5f - squ;
squ *= squ;
}
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + m_value);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + m_value);
}
template <size_t N>
@ -100,19 +101,20 @@ TEST(DistanceMatrix, GeneralRepeatedQuadraticInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_real_distribution<float> dist(-1.0, 1.0);
for (size_t i = 0; i < count; ++i) {
Float16 vec1[dim];
Float16 vec2[dim];
std::vector<Float16> vec1(dim);
std::vector<Float16> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
float norm1{0.0}, norm2{0.0};
SquaredNorm2Matrix<Float16, 1>::Compute(vec1, dim, &norm1);
SquaredNorm2Matrix<Float16, 1>::Compute(vec2, dim, &norm2);
SquaredNorm2Matrix<Float16, 1>::Compute(vec1.data(), dim, &norm1);
SquaredNorm2Matrix<Float16, 1>::Compute(vec2.data(), dim, &norm2);
const float e2 = u_val * u_val / std::max(norm1, norm2);
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, m_val, e2),
MipsSquaredEuclideanDistance(vec1, vec2, dim, m_val, e2),
epsilon);
ASSERT_NEAR(
ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, m_val, e2),
MipsSquaredEuclideanDistance(vec1.data(), vec2.data(), dim, m_val, e2),
epsilon);
}
}
@ -432,7 +434,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -465,7 +467,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
query_size>::Compute(matrix_batch,
&query2[0],
dimension, m_val,
e2, results);
e2, results.data());
}
std::cout
<< "* N Batched MipsSquaredEuclideanDistance(RepeatedQuadraticInjection) "
@ -539,7 +541,7 @@ static float MipsSquaredEuclidean(const FixedVector<Float16, N> &lhs,
static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
size_t dim, float e2) {
float squ = 0.0f;
float lhs_vec[dim + 1];
std::vector<float> lhs_vec(dim + 1);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -547,10 +549,10 @@ static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
squ += val * val;
}
float norm2;
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec.data(), dim, &norm2);
lhs_vec[dim] = std::sqrt(1 - norm2);
float rhs_vec[dim + 1];
std::vector<float> rhs_vec(dim + 1);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
@ -558,9 +560,10 @@ static float ConvertAndComputeByMips(const Float16 *lhs, const Float16 *rhs,
squ += val * val;
}
std::cout << "squ: " << squ << std::endl;
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec.data(), dim, &norm2);
rhs_vec[dim] = std::sqrt(1 - norm2);
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + 1);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + 1);
}
template <size_t N>
@ -578,18 +581,19 @@ TEST(DistanceMatrix, GeneralSphericalInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_real_distribution<float> dist(-1.0, 1.0);
for (size_t i = 0; i < count; ++i) {
Float16 vec1[dim];
Float16 vec2[dim];
std::vector<Float16> vec1(dim);
std::vector<Float16> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
float norm1{0.0}, norm2{0.0};
SquaredNorm2Matrix<Float16, 1>::Compute(vec1, dim, &norm1);
SquaredNorm2Matrix<Float16, 1>::Compute(vec2, dim, &norm2);
SquaredNorm2Matrix<Float16, 1>::Compute(vec1.data(), dim, &norm1);
SquaredNorm2Matrix<Float16, 1>::Compute(vec2.data(), dim, &norm2);
const float e2 = u_val * u_val / std::max(norm1, norm2);
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, e2),
MipsSquaredEuclidean(vec1, vec2, dim, e2), epsilon);
ASSERT_NEAR(ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, e2),
epsilon);
}
}
@ -897,7 +901,7 @@ void MipsSphericalInjectionBenchMarkk(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -928,7 +932,7 @@ void MipsSphericalInjectionBenchMarkk(void) {
query_size>::Compute(matrix_batch,
&query2[0],
dimension, e2,
results);
results.data());
}
std::cout << "* N Batched MipsSquaredEuclidean(SphericalInjection) (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

53
tests/ailego/math/mips_euclidean_distance_matrix_fp32_test.cc
View File

@ -56,7 +56,7 @@ static float MipsSquaredEuclidean(const FixedVector<float, N> &lhs,
static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
size_t dim, size_t m_value, float e2) {
float squ = 0.0f;
float lhs_vec[dim + m_value];
std::vector<float> lhs_vec(dim + m_value);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -68,7 +68,7 @@ static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
squ *= squ;
}
float rhs_vec[dim + m_value];
std::vector<float> rhs_vec(dim + m_value);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
@ -79,7 +79,8 @@ static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
rhs_vec[i] = 0.5f - squ;
squ *= squ;
}
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + m_value);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + m_value);
}
TEST(DistanceMatrix, GeneralRepeatedQuadraticInjection) {
@ -91,18 +92,20 @@ TEST(DistanceMatrix, GeneralRepeatedQuadraticInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_real_distribution<float> dist(-1.0, 1.0);
for (size_t i = 0; i < count; ++i) {
float vec1[dim];
float vec2[dim];
std::vector<float> vec1(dim);
std::vector<float> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
float norm1, norm2;
SquaredNorm2Matrix<float, 1>::Compute(vec1, dim, &norm1);
SquaredNorm2Matrix<float, 1>::Compute(vec2, dim, &norm2);
SquaredNorm2Matrix<float, 1>::Compute(vec1.data(), dim, &norm1);
SquaredNorm2Matrix<float, 1>::Compute(vec2.data(), dim, &norm2);
const float e2 = u_val * u_val / std::max(norm1, norm2);
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, m_val, e2),
MipsSquaredEuclidean(vec1, vec2, dim, m_val, e2), epsilon);
ASSERT_NEAR(
ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, m_val, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, m_val, e2),
epsilon);
}
}
@ -417,7 +420,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -446,7 +449,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
MipsSquaredEuclideanDistanceMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, m_val, e2, results);
matrix_batch, &query2[0], dimension, m_val, e2, results.data());
}
std::cout
<< "* N Batched MipsSquaredEuclidean(RepeatedQuadraticInjection) (us) \t"
@ -517,7 +520,7 @@ static float MipsSquaredEuclidean(const FixedVector<float, N> &lhs,
static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
size_t dim, float e2) {
float squ = 0.0f;
float lhs_vec[dim + 1];
std::vector<float> lhs_vec(dim + 1);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -525,10 +528,10 @@ static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
squ += val * val;
}
float norm2;
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec.data(), dim, &norm2);
lhs_vec[dim] = std::sqrt(1 - norm2);
float rhs_vec[dim + 1];
std::vector<float> rhs_vec(dim + 1);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
@ -536,9 +539,10 @@ static float ConvertAndComputeByMips(const float *lhs, const float *rhs,
squ += val * val;
}
std::cout << "squ: " << squ << std::endl;
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec.data(), dim, &norm2);
rhs_vec[dim] = std::sqrt(1 - norm2);
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + 1);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + 1);
}
template <size_t N>
@ -556,18 +560,19 @@ TEST(DistanceMatrix, GeneralSphericalInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_real_distribution<float> dist(-1.0, 1.0);
for (size_t i = 0; i < count; ++i) {
float vec1[dim];
float vec2[dim];
std::vector<float> vec1(dim);
std::vector<float> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
float norm1, norm2;
SquaredNorm2Matrix<float, 1>::Compute(vec1, dim, &norm1);
SquaredNorm2Matrix<float, 1>::Compute(vec2, dim, &norm2);
SquaredNorm2Matrix<float, 1>::Compute(vec1.data(), dim, &norm1);
SquaredNorm2Matrix<float, 1>::Compute(vec2.data(), dim, &norm2);
const float e2 = u_val * u_val / std::max(norm1, norm2);
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, e2),
MipsSquaredEuclidean(vec1, vec2, dim, e2), epsilon);
ASSERT_NEAR(ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, e2),
epsilon);
}
}
@ -873,7 +878,7 @@ void MipsSphericalInjectionBenchMarkk(void) {
MatrixTranspose(&query2[0], query1.data(), dimension, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -901,7 +906,7 @@ void MipsSphericalInjectionBenchMarkk(void) {
const float *matrix_batch = &matrix2[i * batch_size * dimension];
MipsSquaredEuclideanDistanceMatrix<float, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, e2, results);
matrix_batch, &query2[0], dimension, e2, results.data());
}
std::cout << "* N Batched MipsSquaredEuclidean(SphericalInjection) (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

45
tests/ailego/math/mips_euclidean_distance_matrix_int4_test.cc
View File

@ -58,7 +58,7 @@ static float MipsSquaredEuclidean(const FixedVector<uint8_t, N> &lhs,
static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
size_t dim, size_t m_value, float e2) {
float squ = 0.0f;
float lhs_vec[dim + m_value];
std::vector<float> lhs_vec(dim + m_value);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; i += 2) {
uint8_t v = lhs[i / 2];
@ -75,7 +75,7 @@ static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
lhs_vec[i] = 0.5f - squ;
squ *= squ;
}
float rhs_vec[dim + m_value];
std::vector<float> rhs_vec(dim + m_value);
squ = 0.0f;
for (size_t i = 0; i < dim; i += 2) {
uint8_t v = rhs[i / 2];
@ -92,7 +92,8 @@ static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
rhs_vec[i] = 0.5f - squ;
squ *= squ;
}
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + m_value);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + m_value);
}
template <size_t N>
@ -116,14 +117,16 @@ TEST(DistanceMatrix, GeneralRepeatedQuadraticInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_int_distribution<uint8_t> dist(0, 255);
for (size_t i = 0; i < count; ++i) {
uint8_t vec1[dim / 2];
uint8_t vec2[dim / 2];
std::vector<uint8_t> vec1(dim / 2);
std::vector<uint8_t> vec2(dim / 2);
for (size_t d = 0; d < dim / 2; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, m_val, e2),
MipsSquaredEuclidean(vec1, vec2, dim, m_val, e2), epsilon);
ASSERT_NEAR(
ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, m_val, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, m_val, e2),
epsilon);
}
}
@ -436,7 +439,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
dimension / 8, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -468,7 +471,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
query_size>::Compute(matrix_batch,
&query2[0],
dimension, m_val,
e2, results);
e2, results.data());
}
std::cout
<< "* N Batched MipsSquaredEuclidean(RepeatedQuadraticInjection) (us) \t"
@ -539,7 +542,7 @@ static float MipsSquaredEuclidean(const FixedVector<uint8_t, N> &lhs,
static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
size_t dim, float e2) {
float squ = 0.0f;
float lhs_vec[dim + 1];
std::vector<float> lhs_vec(dim + 1);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; i += 2) {
uint8_t v = lhs[i / 2];
@ -553,10 +556,10 @@ static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
squ += val * val;
}
float norm2;
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec.data(), dim, &norm2);
lhs_vec[dim] = std::sqrt(1 - norm2);
float rhs_vec[dim + 1];
std::vector<float> rhs_vec(dim + 1);
squ = 0.0f;
for (size_t i = 0; i < dim; i += 2) {
uint8_t v = rhs[i / 2];
@ -570,9 +573,10 @@ static float ConvertAndComputeByMips(const uint8_t *lhs, const uint8_t *rhs,
squ += val * val;
}
std::cout << "squ: " << squ << std::endl;
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec.data(), dim, &norm2);
rhs_vec[dim] = std::sqrt(1 - norm2);
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + 1);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + 1);
}
template <size_t N>
@ -594,14 +598,15 @@ TEST(DistanceMatrix, GeneralSphericalInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_int_distribution<uint8_t> dist(0, 255);
for (size_t i = 0; i < count; ++i) {
uint8_t vec1[dim / 2];
uint8_t vec2[dim / 2];
std::vector<uint8_t> vec1(dim / 2);
std::vector<uint8_t> vec2(dim / 2);
for (size_t d = 0; d < dim / 2; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, e2),
MipsSquaredEuclidean(vec1, vec2, dim, e2), epsilon);
ASSERT_NEAR(ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, e2),
epsilon);
}
}
@ -908,7 +913,7 @@ void MipsSphericalInjectionBenchMark(void) {
dimension / 8, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -939,7 +944,7 @@ void MipsSphericalInjectionBenchMark(void) {
query_size>::Compute(matrix_batch,
&query2[0],
dimension, e2,
results);
results.data());
}
std::cout << "* N Batched MipsSquaredEuclidean(SphericalInjection) (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

45
tests/ailego/math/mips_euclidean_distance_matrix_int8_test.cc
View File

@ -56,7 +56,7 @@ static float MipsSquaredEuclidean(const FixedVector<int8_t, N> &lhs,
static float ConvertAndComputeByMips(const int8_t *lhs, const int8_t *rhs,
size_t dim, size_t m_value, float e2) {
float squ = 0.0f;
float lhs_vec[dim + m_value];
std::vector<float> lhs_vec(dim + m_value);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -67,7 +67,7 @@ static float ConvertAndComputeByMips(const int8_t *lhs, const int8_t *rhs,
lhs_vec[i] = 0.5f - squ;
squ *= squ;
}
float rhs_vec[dim + m_value];
std::vector<float> rhs_vec(dim + m_value);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
@ -78,7 +78,8 @@ static float ConvertAndComputeByMips(const int8_t *lhs, const int8_t *rhs,
rhs_vec[i] = 0.5f - squ;
squ *= squ;
}
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + m_value);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + m_value);
}
template <size_t N>
@ -101,14 +102,16 @@ TEST(DistanceMatrix, GeneralRepeatedQuadraticInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_int_distribution<int8_t> dist(-127, 127);
for (size_t i = 0; i < count; ++i) {
int8_t vec1[dim];
int8_t vec2[dim];
std::vector<int8_t> vec1(dim);
std::vector<int8_t> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, m_val, e2),
MipsSquaredEuclidean(vec1, vec2, dim, m_val, e2), epsilon);
ASSERT_NEAR(
ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, m_val, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, m_val, e2),
epsilon);
}
}
@ -417,7 +420,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
dimension / 4, query_size);
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -446,7 +449,7 @@ void MipsRepeatedQuadraticInjectionBenchMark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
MipsSquaredEuclideanDistanceMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, m_val, e2, results);
matrix_batch, &query2[0], dimension, m_val, e2, results.data());
}
std::cout
<< "* N Batched MipsSquaredErclidean(RepeatedQuadraticInjection) (us) \t"
@ -517,7 +520,7 @@ static float MipsSquaredEuclidean(const FixedVector<int8_t, N> &lhs,
static float ConvertAndComputeByMips(const int8_t *lhs, const int8_t *rhs,
size_t dim, float e2) {
float squ = 0.0f;
float lhs_vec[dim + 1];
std::vector<float> lhs_vec(dim + 1);
const float eta = std::sqrt(e2);
for (size_t i = 0; i < dim; ++i) {
float val = lhs[i] * eta;
@ -525,20 +528,21 @@ static float ConvertAndComputeByMips(const int8_t *lhs, const int8_t *rhs,
squ += val * val;
}
float norm2;
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(lhs_vec.data(), dim, &norm2);
lhs_vec[dim] = std::sqrt(1 - norm2);
float rhs_vec[dim + 1];
std::vector<float> rhs_vec(dim + 1);
squ = 0.0f;
for (size_t i = 0; i < dim; ++i) {
float val = rhs[i] * eta;
rhs_vec[i] = val;
squ += val * val;
}
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec, dim, &norm2);
ailego::SquaredNorm2Matrix<float, 1>::Compute(rhs_vec.data(), dim, &norm2);
rhs_vec[dim] = std::sqrt(1 - norm2);
std::cout << "squ: " << squ << std::endl;
return ailego::Distance::SquaredEuclidean(lhs_vec, rhs_vec, dim + 1);
return ailego::Distance::SquaredEuclidean(lhs_vec.data(), rhs_vec.data(),
dim + 1);
}
template <size_t N>
@ -559,14 +563,15 @@ TEST(DistanceMatrix, GeneralSphericalInjection) {
const uint32_t count = std::uniform_int_distribution<uint32_t>(1, 1000)(gen);
std::uniform_int_distribution<int8_t> dist(-127, 127);
for (size_t i = 0; i < count; ++i) {
int8_t vec1[dim];
int8_t vec2[dim];
std::vector<int8_t> vec1(dim);
std::vector<int8_t> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = dist(gen);
vec2[d] = dist(gen);
}
ASSERT_NEAR(ConvertAndComputeByMips(vec1, vec2, dim, e2),
MipsSquaredEuclidean(vec1, vec2, dim, e2), epsilon);
ASSERT_NEAR(ConvertAndComputeByMips(vec1.data(), vec2.data(), dim, e2),
MipsSquaredEuclidean(vec1.data(), vec2.data(), dim, e2),
epsilon);
}
}
@ -878,7 +883,7 @@ void MipsSphericalInjectionBenchMark(void) {
}
const float e2 = 0.98f / squared_l2_norm;
ElapsedTime elapsed_time;
float results[batch_size * query_size];
std::vector<float> results(batch_size * query_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << query_size << " * " << block_size
@ -906,7 +911,7 @@ void MipsSphericalInjectionBenchMark(void) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
MipsSquaredEuclideanDistanceMatrix<int8_t, batch_size, query_size>::Compute(
matrix_batch, &query2[0], dimension, e2, results);
matrix_batch, &query2[0], dimension, e2, results.data());
}
std::cout << "* N Batched MipsSquaredErclidean(SphericalInjection) (us) \t"
<< elapsed_time.micro_seconds() << std::endl;

4
tests/ailego/math/norm_matrix_fp16_test.cc
View File

@ -251,7 +251,7 @@ void Norm1Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;
@ -302,7 +302,7 @@ void Norm2Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") FP16 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;

4
tests/ailego/math/norm_matrix_fp32_test.cc
View File

@ -247,7 +247,7 @@ void Norm1Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;
@ -298,7 +298,7 @@ void Norm2Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") FP32 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;

2
tests/ailego/math/norm_matrix_int4_test.cc
View File

@ -150,7 +150,7 @@ void Norm2Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") INT4 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;

6
tests/ailego/math/norm_matrix_int8_test.cc
View File

@ -199,7 +199,7 @@ void Norm1Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;
@ -251,7 +251,7 @@ void Norm2Benchmark(void) {
}
ElapsedTime elapsed_time;
float results[batch_size];
std::vector<float> results(batch_size);
std::cout << "# (" << IntelIntrinsics() << ") INT8 " << dimension << "d, "
<< batch_size << " * " << block_size << std::endl;
@ -261,7 +261,7 @@ void Norm2Benchmark(void) {
for (size_t i = 0; i < block_size; ++i) {
const int8_t *matrix_batch = &matrix2[i * batch_size * dimension];
Norm2Matrix<int8_t, batch_size>::Compute(matrix_batch, dimension,
&results[0]);
results.data());
}
std::cout << "* Batched Norm2 (us) \t" << elapsed_time.micro_seconds()
<< std::endl;

12
tests/ailego/parallel/multi_thread_list_test.cc
View File

@ -68,8 +68,8 @@ TEST(MultiThreadListTest, General) {
uint32_t num_of_producer = 100;
uint32_t num_of_producer_done = 100;
uint32_t consumer_results[num_of_consumer];
memset(consumer_results, 0, sizeof(uint32_t) * num_of_consumer);
std::vector<uint32_t> consumer_results(num_of_consumer);
std::fill(consumer_results.begin(), consumer_results.end(), 0);
for (uint32_t i = 0; i < num_of_consumer; i++) {
consumer_pool.execute(consumer, i + 1, &consumer_results[i]);
@ -124,8 +124,8 @@ TEST(MultiThreadListTest, ConsumeStopResume) {
uint32_t num_of_consumer = 100;
uint32_t num_of_producer = 100;
uint32_t consumer_results[2 * num_of_consumer];
memset(consumer_results, 0, sizeof(uint32_t) * 2 * num_of_consumer);
std::vector<uint32_t> consumer_results(2 * num_of_consumer);
std::fill(consumer_results.begin(), consumer_results.end(), 0);
for (uint32_t i = 0; i < num_of_consumer; i++) {
consumer_pool.execute(consumer, i + 1, &consumer_results[i]);
@ -227,8 +227,8 @@ TEST(MultiThreadListTest, General_Moveable) {
uint32_t num_of_producer = 100;
uint32_t num_of_producer_done = 100;
uint32_t consumer_results[num_of_consumer];
memset(consumer_results, 0, sizeof(uint32_t) * num_of_consumer);
std::vector<uint32_t> consumer_results(num_of_consumer);
std::fill(consumer_results.begin(), consumer_results.end(), 0);
for (uint32_t i = 0; i < num_of_consumer; i++) {
consumer_pool.execute(consumer_moveable, i + 1, &consumer_results[i]);

4
tests/ailego/parallel/semaphore_test.cc
View File

@ -46,7 +46,7 @@ TEST(BinarySemaphores, General) {
ailego::BinarySemaphores<1> sem_mutex1(sem_count);
std::atomic<uint32_t> total{0u};
uint32_t counts[sem_count] = {0u};
std::vector<uint32_t> counts(sem_count, 0u);
for (int i = 0; i < 2000; ++i) {
pool.execute([&]() {
int index1 = sem_mutex32.acquire();
@ -71,7 +71,7 @@ TEST(BinarySemaphores, General2) {
const int sem_count = 32;
ailego::BinarySemaphores<64> sem_mutex64(sem_count);
std::atomic<uint32_t> total{0u};
uint32_t counts[sem_count] = {0u};
std::vector<uint32_t> counts(sem_count, 0u);
bool flag = true;
for (int i = 0; i < 64; ++i) {
pool.execute([&]() {

8
tests/core/algorithm/flat/flat_streamer_test.cc
View File

@ -392,24 +392,24 @@ TEST_F(FlatStreamerTest, TestOpenClose) {
ASSERT_EQ(0, streamer->open(storage1));
auto ctx = streamer->create_context();
ASSERT_TRUE(!!ctx);
float vec1[dim];
std::vector<float> vec1(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = v1;
}
ASSERT_EQ(0, streamer->add_impl(i, vec1, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i, vec1.data(), qmeta, ctx));
checkIter(0, i / 2 + 1, streamer);
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());
float v2 = (float)(i + 1);
float vec2[dim];
std::vector<float> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec2[d] = v2;
}
ASSERT_EQ(0, streamer->open(storage2));
ctx = streamer->create_context();
ASSERT_TRUE(!!ctx);
ASSERT_EQ(0, streamer->add_impl(i + 1, vec2, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i + 1, vec2.data(), qmeta, ctx));
checkIter(1, i / 2 + 1, streamer);
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());

8
tests/core/algorithm/hnsw/hnsw_searcher_test.cpp
View File

@ -453,11 +453,11 @@ TEST_F(HnswSearcherTest, TestGeneral) {
// do linear search test
{
float query[dim];
std::vector<float> query(dim);
for (size_t i = 0; i < dim; ++i) {
query[i] = 3.1f;
}
ASSERT_EQ(0, searcher->search_bf_impl(query, qmeta, linearCtx));
ASSERT_EQ(0, searcher->search_bf_impl(query.data(), qmeta, linearCtx));
auto &linearResult = linearCtx->result();
ASSERT_EQ(3UL, linearResult[0].key());
ASSERT_EQ(4UL, linearResult[1].key());
@ -477,11 +477,11 @@ TEST_F(HnswSearcherTest, TestGeneral) {
p_keys.resize(1);
p_keys[0] = {8, 9, 10, 11, 3, 2, 1, 0};
{
float query[dim];
std::vector<float> query(dim);
for (size_t i = 0; i < dim; ++i) {
query[i] = 3.1f;
}
ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(query, p_keys, qmeta,
ASSERT_EQ(0, searcher->search_bf_by_p_keys_impl(query.data(), p_keys, qmeta,
linearByPKeysCtx));
auto &linearByPKeysResult = linearByPKeysCtx->result();
ASSERT_EQ(8, linearByPKeysResult.size());

20
tests/core/algorithm/hnsw/hnsw_streamer_test.cc
View File

@ -592,24 +592,24 @@ TEST_F(HnswStreamerTest, TestOpenClose) {
ASSERT_EQ(0, streamer->open(storage1));
auto ctx = streamer->create_context();
ASSERT_TRUE(!!ctx);
float vec1[dim];
std::vector<float> vec1(dim);
for (size_t d = 0; d < dim; ++d) {
vec1[d] = v1;
}
ASSERT_EQ(0, streamer->add_impl(i, vec1, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i, vec1.data(), qmeta, ctx));
checkIter(0, i / 2 + 1, streamer);
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());
float v2 = (float)(i + 1);
float vec2[dim];
std::vector<float> vec2(dim);
for (size_t d = 0; d < dim; ++d) {
vec2[d] = v2;
}
ASSERT_EQ(0, streamer->open(storage2));
ctx = streamer->create_context();
ASSERT_TRUE(!!ctx);
ASSERT_EQ(0, streamer->add_impl(i + 1, vec2, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i + 1, vec2.data(), qmeta, ctx));
checkIter(1, i / 2 + 1, streamer);
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());
@ -1949,11 +1949,11 @@ TEST_F(HnswStreamerTest, TestMipsEuclideanMetric) {
"proxima.mips_euclidean.metric.max_l2_norm"));
auto ctx = streamer->create_context();
for (size_t i = COUNT; i < 2 * COUNT; i++) {
float vec[dim];
std::vector<float> vec(dim);
for (size_t d = 0; d < dim; ++d) {
vec[d] = i;
}
ASSERT_EQ(0, streamer->add_impl(i, vec, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i, vec.data(), qmeta, ctx));
}
ASSERT_EQ(0, streamer->flush(0UL));
ASSERT_EQ(0, streamer->close());
@ -1970,19 +1970,19 @@ TEST_F(HnswStreamerTest, TestMipsEuclideanMetric) {
metric_params.get_as_float("proxima.mips_euclidean.metric.max_l2_norm"));
auto ctx = streamer->create_context();
for (size_t i = 0; i < COUNT; i++) {
float vec[dim];
std::vector<float> vec(dim);
for (size_t d = 0; d < dim; ++d) {
vec[d] = i;
}
ASSERT_EQ(0, streamer->add_impl(i, vec, qmeta, ctx));
ASSERT_EQ(0, streamer->add_impl(i, vec.data(), qmeta, ctx));
}
float vec[dim];
std::vector<float> vec(dim);
for (size_t d = 0; d < dim; ++d) {
vec[d] = 1.0;
}
ctx->set_topk(10);
ASSERT_EQ(0, streamer->search_impl(vec, qmeta, ctx));
ASSERT_EQ(0, streamer->search_impl(vec.data(), qmeta, ctx));
const auto &results = ctx->result();
EXPECT_EQ(results.size(), 10);
EXPECT_NEAR((uint64_t)(2 * COUNT - 1), results[0].key(), 10);

4
tests/db/index/storage/wal_file_test.cc
View File

@ -288,12 +288,12 @@ TEST_F(WalFileTest, TestBoundaryCondition) {
// write very large record 4Mb
size_t BIG_DATA_SIZE = 4 * 1024 * 1024;
uint8_t big_data[BIG_DATA_SIZE];
std::vector<uint8_t> big_data(BIG_DATA_SIZE);
for (size_t i = 0; i < BIG_DATA_SIZE; i++) {
big_data[i] = i % 256;
}
str.clear();
str.assign((const char *)big_data, BIG_DATA_SIZE);
str.assign((const char *)big_data.data(), BIG_DATA_SIZE);
wal_option.create_new = true;
ret = wal_file->open(wal_option);
ASSERT_EQ(ret, 0);