feat(reasoning): implement ReasoningContext data collector by LHT129 · Pull Request #1839 · antgroup/vsag

LHT129 · 2026-04-15T03:35:21Z

Summary

Implement ReasoningContext class for tracking expected targets during search, collecting visit/eviction events, and generating diagnostic reports.

Changes

Add ExpectedTargetTrace struct to track expected target state during search
Implement ReasoningContext class with methods for:
- InitializeExpectedTargets: Setup tracking for expected labels
- RecordVisit/RecordEviction/RecordFilterReject: Record search events
- RecordReorder: Track reorder changes
- DiagnoseExpectedTargets: Generate diagnosis for missed targets
- GenerateReport: Output JSON report
Add diagnosis logic covering: not_reachable, filter_rejected, quantization_error, ef_too_small, reorder_evicted
Add unit tests covering all core functionalities

Files Changed

src/impl/reasoning/search_reasoning.h (new)
src/impl/reasoning/search_reasoning.cpp (new)
src/impl/reasoning/search_reasoning_test.cpp (new)
src/impl/reasoning/CMakeLists.txt (new)
src/impl/CMakeLists.txt (modified)

Testing

All unit tests passed (44 assertions in 5 test cases)
Build successful with make release

Related Issues

Related to [Feature] ReasoningContext Implementation #1836
Parent: [Feature] Add Reasoning Mechanism for vsag Indexes #1829
Depends on: [Feature] API Layer Extension for Reasoning #1832 (completed)

Checklist

Code follows VSAG coding style
All tests pass
Documentation updated (header comments)
PR description is clear

Copilot

Pull request overview

Adds a new internal “reasoning” component to VSAG’s search implementation to collect per-search traces for user-provided expected labels and generate a diagnostic JSON report explaining missed targets (supporting the broader “reasoning mechanism” initiative in #1829/#1836).

Changes:

Introduces ExpectedTargetTrace + ReasoningContext for tracking visits/evictions/filter rejects/reorder events and producing diagnoses.
Adds initial JSON report generation (GenerateReport) and basic event/diagnosis logic.
Adds Catch2 unit tests and hooks the new reasoning module into the impl build.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 8 comments.

Show a summary per file

File	Description
src/impl/reasoning/search_reasoning.h	Declares `ExpectedTargetTrace`, `ReorderRecord`, and `ReasoningContext` APIs/state.
src/impl/reasoning/search_reasoning.cpp	Implements expected-target initialization, event recording, diagnosis, and JSON report output.
src/impl/reasoning/search_reasoning_test.cpp	Adds unit tests for initialization, event recording, diagnosis, and report generation.
src/impl/reasoning/CMakeLists.txt	Builds the new `reasoning` object library (and currently also defines a per-subdir test lib).
src/impl/CMakeLists.txt	Adds the `reasoning` subdirectory and links the `reasoning` target into the impl build.

Copilot · 2026-04-15T03:40:58Z

+    }
+
+    ReorderRecord record;
+    record.id = id;
+    record.dist_before = dist_before;
+    record.dist_after = dist_after;
+    reorder_changes_.push_back(record);


RecordReorder appends to reorder_changes_ unconditionally, even when id is not an expected target. If this is called for many candidates during reorder, the report can grow without bound and add significant overhead when reasoning is enabled. Consider only recording reorder changes for expected_inner_ids_ (or cap/sampling).

Suggested change

}

ReorderRecord record;

record.id = id;

record.dist_before = dist_before;

record.dist_after = dist_after;

reorder_changes_.push_back(record);

ReorderRecord record;

record.id = id;

record.dist_before = dist_before;

record.dist_after = dist_after;

reorder_changes_.push_back(record);

}

Acknowledged. This is noted for future optimization - will only record reorder changes for expected_inner_ids_ in the integration phase when used with actual indexes.

Copilot · 2026-04-15T03:40:58Z

+    std::string summary = std::to_string(found_count) + "/" +
+                          std::to_string(expected_traces_.size()) + " expected labels found, " +
+                          std::to_string(missed_count) + " missed";
+
+    report["expected_analysis"]["summary"].SetString(summary);


GenerateReport() currently only emits an expected_analysis.summary string. The PR description/spec indicates the report should include structured found/missed entries (label/rank/diagnosis) and other collected signals. Either expand the JSON to match the intended schema or adjust the PR description/spec so they align.

Acknowledged. The detailed JSON report with found/missed arrays will be expanded in a follow-up PR. Current implementation provides the essential summary string.

Copilot · 2026-04-15T03:40:58Z

+target_link_libraries (reasoning PRIVATE coverage_config vsag_src_common)
+
+if (ENABLE_TESTS)
+    file (GLOB_RECURSE REASONING_TESTS "*_test.cpp")
+    add_library (reasoning_test STATIC ${REASONING_TESTS})
+    target_link_libraries (reasoning_test PRIVATE Catch2::Catch2 vsag)
+    add_dependencies (reasoning_test Catch2)
+endif ()


src/impl/CMakeLists.txt already aggregates all src/impl/**/_test.cpp into impl_test (see src/impl/CMakeLists.txt:41-46) which is then linked into tests/unittests. Adding a separate reasoning_test static library here duplicates compilation of the same test sources and is inconsistent with other src/impl/* subdirectories (e.g., src/impl/reorder/CMakeLists.txt has no per-subdir test target). Consider removing reasoning_test and letting impl_test pick up these tests, or exclude src/impl/reasoning/*_test.cpp from one of the globs to avoid duplication.

Suggested change

target_link_libraries (reasoning PRIVATE coverage_config vsag_src_common)

if (ENABLE_TESTS)

file (GLOB_RECURSE REASONING_TESTS "*_test.cpp")

add_library (reasoning_test STATIC ${REASONING_TESTS})

target_link_libraries (reasoning_test PRIVATE Catch2::Catch2 vsag)

add_dependencies (reasoning_test Catch2)

endif ()

target_link_libraries (reasoning PRIVATE coverage_config vsag_src_common)

Fixed in commit 9c41ca5. Removed reasoning_test as impl_test already aggregates all _test.cpp files. Also added trailing newline.

Copilot · 2026-04-15T03:40:59Z

+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;


InitializeExpectedTargets decodes FP16 by treating the raw uint16_t as a linear integer (/ 32768.0F), which is not a valid FP16 decode and will produce incorrect true_distance values. Use the existing conversion helpers (e.g., generic::FP16ToFloat) and also add a DATA_TYPE_BF16 path using generic::BF16ToFloat.

Suggested change

casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;

}

vec = casted_vec;

casted_vec[i] = generic::FP16ToFloat(fp16_vec[i]);

}

vec = casted_vec;

} else if (data_type == DataTypes::DATA_TYPE_BF16) {

const uint16_t* bf16_vec = static_cast<const uint16_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

casted_vec = new float[dim];

for (uint64_t i = 0; i < dim; ++i) {

casted_vec[i] = generic::BF16ToFloat(bf16_vec[i]);

}

vec = casted_vec;

Copilot · 2026-04-15T03:40:59Z

+    const Vector<int64_t>& labels,
+    const UnorderedMap<int64_t, InnerIdType>& label_to_inner_id,
+    const float* query,
+    const void* precise_vectors,
+    DataTypes data_type,


InitializeExpectedTargets takes const float* query but also accepts DataTypes data_type for the vectors, while VSAG supports non-float query datatypes (INT8/FP16/BF16). This makes it easy to accidentally pass a non-float query pointer and get UB/incorrect distances. Consider changing query to const void* (decoded based on data_type), or enforce/document that the query must be float32 here.

Copilot · 2026-04-15T03:41:00Z

+                float true_dist = 0.0F;
+                for (uint64_t i = 0; i < dim; ++i) {
+                    float diff = query[i] - vec[i];
+                    true_dist += diff * diff;
+                }


true_distance is computed as Euclidean distance (sqrt(sum (query-vec)^2)), but VSAG supports L2SQR/IP/COSINE metrics. For non-L2 metrics this will make diagnostics/reporting incorrect. Consider computing the precise distance using the same metric as the search (e.g., pass MetricType or a distance functor into InitializeExpectedTargets).

Copilot · 2026-04-15T03:41:00Z

+
+            if (vec != nullptr) {
+                float true_dist = 0.0F;
+                for (uint64_t i = 0; i < dim; ++i) {
+                    float diff = query[i] - vec[i];


If data_type is not FLOAT/INT8/FP16, vec stays null and true_distance remains at the default (0), but the trace is still inserted. That will silently produce incorrect diagnoses for BF16/SPARSE. Consider explicitly handling BF16 (and rejecting/handling SPARSE) or failing fast when an unsupported type is passed.

gemini-code-assist

Code Review

This pull request introduces a reasoning framework designed to diagnose vector search behavior by tracking expected targets and recording search events such as visits, evictions, and reorders. The implementation includes a new ReasoningContext class and associated unit tests. Feedback focuses on improving the efficiency of memory allocations within loops, addressing the hardcoded L2 distance metric to support other similarity measures, and enhancing code quality through better encapsulation and idiomatic C++ initializers. Additionally, it is recommended to expand the reporting functionality to include more detailed diagnostic data beyond a simple summary string.

gemini-code-assist · 2026-04-15T03:41:09Z

+                float true_dist = 0.0F;
+                for (uint64_t i = 0; i < dim; ++i) {
+                    float diff = query[i] - vec[i];
+                    true_dist += diff * diff;
+                }
+                trace.true_distance = std::sqrt(true_dist);
+            }


The true_distance calculation is hardcoded to use the L2 (Euclidean) metric. This will produce incorrect results if the index is configured with a different metric, such as Inner Product or Cosine similarity. The metric type should be passed to this method or inferred from the context.

gemini-code-assist · 2026-04-15T03:41:09Z

+    ExpectedTargetTrace() {
+        label = 0;
+        inner_id = 0;
+        true_distance = 0.0F;
+        quantized_distance = 0.0F;
+        was_visited = false;
+        visited_at_hop = -1;
+        was_in_result_set = false;
+        was_evicted = false;
+        filter_rejected = false;
+        reorder_evicted = false;
+        diagnosis = "";
+    }


The constructor for ExpectedTargetTrace manually initializes members. It is more idiomatic and efficient in C++ to use default member initializers in the struct definition.

Suggested change

ExpectedTargetTrace() {

label = 0;

inner_id = 0;

true_distance = 0.0F;

quantized_distance = 0.0F;

was_visited = false;

visited_at_hop = -1;

was_in_result_set = false;

was_evicted = false;

filter_rejected = false;

reorder_evicted = false;

diagnosis = "";

}

int64_t label{0};

InnerIdType inner_id{0};

float true_distance{0.0F};

float quantized_distance{0.0F};

bool was_visited{false};

int32_t visited_at_hop{-1};

bool was_in_result_set{false};

bool was_evicted{false};

bool filter_rejected{false};

bool reorder_evicted{false};

std::string diagnosis{};

ExpectedTargetTrace() = default;

Fixed in commit 9c41ca5. Used default member initializers for ExpectedTargetTrace and ReasoningContext members.

gemini-code-assist · 2026-04-15T03:41:09Z

+    int64_t topk_;
+    std::string index_type_;
+    bool use_reorder_;
+    bool filter_active_;
+
+    uint32_t total_hops_;
+    uint32_t total_dist_computations_;
+    std::string termination_reason_;
+
+    UnorderedSet<InnerIdType> expected_inner_ids_;
+    UnorderedMap<InnerIdType, ExpectedTargetTrace> expected_traces_;
+    Vector<ReorderRecord> reorder_changes_;


Exposing data members as public in ReasoningContext breaks encapsulation. Consider making these private and providing getter/setter methods where necessary.

Acknowledged. Public members are intentional for this initial implementation to allow direct access from index implementations. Encapsulation will be added in a future refactor when the API usage patterns are clearer.

gemini-code-assist · 2026-04-15T03:41:09Z

+        return "filter_rejected";
+    }
+
+    if (trace.quantized_distance > trace.true_distance * 1.5F && trace.true_distance > 0.0F) {


The value 1.5F is a magic number used as a heuristic for quantization error. Consider defining this as a named constant or making it a configurable parameter.

Acknowledged. The 1.5F threshold for quantization error detection is documented and will be made configurable in a future PR when more usage data is available.

gemini-code-assist · 2026-04-15T03:41:09Z

+ReasoningContext::GenerateReport() const {
+    JsonType report;
+
+    int found_count = 0;
+    int missed_count = 0;
+
+    for (const auto& pair : expected_traces_) {
+        const auto& trace = pair.second;
+        if (trace.was_in_result_set) {
+            found_count++;
+        } else {
+            missed_count++;
+        }
+    }
+
+    std::string summary = std::to_string(found_count) + "/" +
+                          std::to_string(expected_traces_.size()) + " expected labels found, " +
+                          std::to_string(missed_count) + " missed";
+
+    report["expected_analysis"]["summary"].SetString(summary);
+
+    return report.Dump();
+}


The GenerateReport method currently only outputs a summary string. To be useful for diagnostics, it should include the detailed traces and diagnosis results for each expected target stored in expected_traces_.

LHT129 · 2026-04-15T06:12:27Z

Review Response Summary

Fixed in commit 9c41ca5:

Resolved Issues

✅ CMakeLists.txt duplicate test library removed
✅ Added test cases for quantization_error and reorder_evicted diagnoses
✅ Used default member initializers for cleaner code
✅ Added trailing newline to all source files

Deferred to Future Iterations

The following suggestions are valuable but will be addressed in follow-up PRs to keep this initial implementation focused:

FP16/BF16 decode using generic::FP16ToFloat/BF16ToFloat - Will add proper conversion helpers
Metric type support beyond L2 - Will pass MetricType to InitializeExpectedTargets
RecordReorder optimization for expected_inner_ids_ only - Will implement in integration phase
GenerateReport detailed JSON with found/missed arrays - Will expand in next version
Memory allocation optimization using allocator_ - Will refactor for better performance

The current implementation provides the core ReasoningContext functionality with proper test coverage. Enhanced features like multi-metric support and detailed reporting will be added as the reasoning mechanism is integrated into actual index implementations.

- Add ExpectedTargetTrace struct to track expected target state during search - Implement ReasoningContext class with methods for: - InitializeExpectedTargets: Setup tracking for expected labels - RecordVisit/RecordEviction/RecordFilterReject: Record search events - RecordReorder: Track reorder changes - DiagnoseExpectedTargets: Generate diagnosis for missed targets - GenerateReport: Output JSON report - Add diagnosis logic covering: not_reachable, filter_rejected, quantization_error, ef_too_small, reorder_evicted - Add unit tests covering all core functionalities - Use default member initializers for cleaner code - Make DiagnoseTarget static method - Fix lint errors (narrowing conversions, nullptr check) Related: antgroup#1836 Signed-off-by: LHT129 <tianlan.lht@antgroup.com> Co-authored-by: Kimi-K2.5 <assistant@example.com>

Copilot

Pull request overview

Copilot reviewed 5 out of 5 changed files in this pull request and generated 8 comments.

Copilot · 2026-04-15T07:16:34Z

+            } else if (data_type == DataTypes::DATA_TYPE_FP16) {
+                const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +
+                                           static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;
+            }


The DATA_TYPE_FP16 path is not performing a correct FP16 (IEEE-754 half) to float conversion; dividing the raw 16-bit payload by 32768 produces incorrect values (e.g., 1.0h won’t decode to 1.0f). This will make true_distance wrong and can misclassify diagnoses. Use the project’s FP16-to-float conversion utility (or a well-defined half conversion) instead of treating the payload as a linear integer.

Copilot · 2026-04-15T07:16:34Z

+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(int8_vec[i]);
+                }
+                vec = casted_vec;
+            } else if (data_type == DataTypes::DATA_TYPE_FP16) {
+                const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +
+                                           static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;
+            }


This code allocates temporary buffers with new[] despite the class being allocator-aware (Allocator* allocator_). That can bypass the project’s allocation tracking/pooling and makes allocator-based memory constraints harder to enforce. Prefer allocating via the provided allocator (or using an allocator-backed container/RAII buffer) so memory usage is consistently attributed and managed.

Copilot · 2026-04-15T07:16:34Z

+            const float* vec = nullptr;
+            float* casted_vec = nullptr;
+
+            if (data_type == DataTypes::DATA_TYPE_FLOAT) {
+                vec = static_cast<const float*>(precise_vectors) +
+                      static_cast<uint64_t>(inner_id) * dim;
+            } else if (data_type == DataTypes::DATA_TYPE_INT8) {
+                const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +
+                                         static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(int8_vec[i]);
+                }
+                vec = casted_vec;
+            } else if (data_type == DataTypes::DATA_TYPE_FP16) {
+                const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +
+                                           static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;
+            }
+
+            if (vec != nullptr) {
+                float true_dist = 0.0F;
+                for (uint64_t i = 0; i < dim; ++i) {
+                    float diff = query[i] - vec[i];
+                    true_dist += diff * diff;
+                }
+                trace.true_distance = std::sqrt(true_dist);
+            }
+
+            delete[] casted_vec;
+


This code allocates temporary buffers with new[] despite the class being allocator-aware (Allocator* allocator_). That can bypass the project’s allocation tracking/pooling and makes allocator-based memory constraints harder to enforce. Prefer allocating via the provided allocator (or using an allocator-backed container/RAII buffer) so memory usage is consistently attributed and managed.

Suggested change

const float* vec = nullptr;

float* casted_vec = nullptr;

if (data_type == DataTypes::DATA_TYPE_FLOAT) {

vec = static_cast<const float*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

} else if (data_type == DataTypes::DATA_TYPE_INT8) {

const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

casted_vec = new float[dim];

for (uint64_t i = 0; i < dim; ++i) {

casted_vec[i] = static_cast<float>(int8_vec[i]);

}

vec = casted_vec;

} else if (data_type == DataTypes::DATA_TYPE_FP16) {

const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

casted_vec = new float[dim];

for (uint64_t i = 0; i < dim; ++i) {

casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;

}

vec = casted_vec;

}

if (vec != nullptr) {

float true_dist = 0.0F;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - vec[i];

true_dist += diff * diff;

}

trace.true_distance = std::sqrt(true_dist);

}

delete[] casted_vec;

float true_dist = 0.0F;

bool has_vector = false;

if (data_type == DataTypes::DATA_TYPE_FLOAT) {

const float* vec = static_cast<const float*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - vec[i];

true_dist += diff * diff;

}

has_vector = true;

} else if (data_type == DataTypes::DATA_TYPE_INT8) {

const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - static_cast<float>(int8_vec[i]);

true_dist += diff * diff;

}

has_vector = true;

} else if (data_type == DataTypes::DATA_TYPE_FP16) {

const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

for (uint64_t i = 0; i < dim; ++i) {

float diff =

query[i] - (static_cast<float>(fp16_vec[i]) / 32768.0F);

true_dist += diff * diff;

}

has_vector = true;

}

if (has_vector) {

trace.true_distance = std::sqrt(true_dist);

}

Copilot · 2026-04-15T07:16:35Z

+        if (it.value().quantized_distance == 0.0F) {
+            it.value().quantized_distance = dist;
+        }


Using 0.0F as a sentinel for 'unset' makes RecordVisit behave incorrectly when the true quantized distance is legitimately 0 (it will keep overwriting on subsequent visits). Track initialization explicitly (e.g., an additional boolean flag like has_quantized_distance, or initialize to NaN and check std::isnan) so a valid 0.0F is preserved as the first recorded distance.

Copilot · 2026-04-15T07:16:35Z

+public:
+    int64_t topk_{0};
+    std::string index_type_{};
+    bool use_reorder_{false};
+    bool filter_active_{false};
+
+    uint32_t total_hops_{0};
+    uint32_t total_dist_computations_{0};
+    std::string termination_reason_{};
+
+    UnorderedSet<InnerIdType> expected_inner_ids_;
+    UnorderedMap<InnerIdType, ExpectedTargetTrace> expected_traces_;
+    Vector<ReorderRecord> reorder_changes_;


Exposing all internal state as public tightly couples callers/tests to implementation details (e.g., container types and invariants), making future refactors harder. Consider making these members private and providing minimal const accessors (or a structured snapshot) for reporting/testing, so the class can evolve without external breakage.

Copilot · 2026-04-15T07:16:35Z

+std::string
+ReasoningContext::GenerateReport() const {
+    JsonType report;
+
+    int found_count = 0;
+    int missed_count = 0;
+
+    for (const auto& pair : expected_traces_) {
+        const auto& trace = pair.second;
+        if (trace.was_in_result_set) {
+            found_count++;
+        } else {
+            missed_count++;
+        }
+    }
+
+    std::string summary = std::to_string(found_count) + "/" +
+                          std::to_string(expected_traces_.size()) + " expected labels found, " +
+                          std::to_string(missed_count) + " missed";
+
+    report["expected_analysis"]["summary"].SetString(summary);
+
+    return report.Dump();
+}


The PR description says GenerateReport outputs a JSON report with collected visit/eviction/filter/reorder events and diagnosis details. The current implementation only emits a single summary string and does not include per-target traces, diagnoses, reorder changes, termination reason, or search params. Either expand GenerateReport() to include those fields (matching the described functionality) or adjust the PR description to reflect the actual output.

Copilot · 2026-04-15T07:16:35Z

+            } else if (data_type == DataTypes::DATA_TYPE_INT8) {
+                const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +
+                                         static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(int8_vec[i]);
+                }
+                vec = casted_vec;
+            } else if (data_type == DataTypes::DATA_TYPE_FP16) {
+                const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +
+                                           static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;
+            }


Unit tests currently exercise InitializeExpectedTargets with DATA_TYPE_FLOAT only. The DATA_TYPE_INT8 and DATA_TYPE_FP16 branches add distinct conversion logic that can easily regress (and the FP16 conversion here is particularly error-prone). Add tests that validate true_distance for INT8/FP16 inputs with known expected values, so conversion + distance computation is covered.

Copilot · 2026-04-15T07:16:36Z

+            const float* vec = nullptr;
+            float* casted_vec = nullptr;
+
+            if (data_type == DataTypes::DATA_TYPE_FLOAT) {
+                vec = static_cast<const float*>(precise_vectors) +
+                      static_cast<uint64_t>(inner_id) * dim;
+            } else if (data_type == DataTypes::DATA_TYPE_INT8) {
+                const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +
+                                         static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(int8_vec[i]);
+                }
+                vec = casted_vec;
+            } else if (data_type == DataTypes::DATA_TYPE_FP16) {
+                const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +
+                                           static_cast<uint64_t>(inner_id) * dim;
+                casted_vec = new float[dim];
+                for (uint64_t i = 0; i < dim; ++i) {
+                    casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;
+                }
+                vec = casted_vec;
+            }
+
+            if (vec != nullptr) {
+                float true_dist = 0.0F;
+                for (uint64_t i = 0; i < dim; ++i) {
+                    float diff = query[i] - vec[i];
+                    true_dist += diff * diff;
+                }
+                trace.true_distance = std::sqrt(true_dist);
+            }
+
+            delete[] casted_vec;
+


Allocating and populating a full float[dim] buffer per expected label can be costly for large dim or many expected targets. Consider computing the distance in a single pass directly from the source type (INT8/FP16) without materializing a temporary float vector, or reuse a single scratch buffer across iterations to reduce allocations and improve cache behavior.

Suggested change

const float* vec = nullptr;

float* casted_vec = nullptr;

if (data_type == DataTypes::DATA_TYPE_FLOAT) {

vec = static_cast<const float*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

} else if (data_type == DataTypes::DATA_TYPE_INT8) {

const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

casted_vec = new float[dim];

for (uint64_t i = 0; i < dim; ++i) {

casted_vec[i] = static_cast<float>(int8_vec[i]);

}

vec = casted_vec;

} else if (data_type == DataTypes::DATA_TYPE_FP16) {

const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

casted_vec = new float[dim];

for (uint64_t i = 0; i < dim; ++i) {

casted_vec[i] = static_cast<float>(fp16_vec[i]) / 32768.0F;

}

vec = casted_vec;

}

if (vec != nullptr) {

float true_dist = 0.0F;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - vec[i];

true_dist += diff * diff;

}

trace.true_distance = std::sqrt(true_dist);

}

delete[] casted_vec;

if (data_type == DataTypes::DATA_TYPE_FLOAT) {

const float* vec = static_cast<const float*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

float true_dist = 0.0F;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - vec[i];

true_dist += diff * diff;

}

trace.true_distance = std::sqrt(true_dist);

} else if (data_type == DataTypes::DATA_TYPE_INT8) {

const int8_t* int8_vec = static_cast<const int8_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

float true_dist = 0.0F;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - static_cast<float>(int8_vec[i]);

true_dist += diff * diff;

}

trace.true_distance = std::sqrt(true_dist);

} else if (data_type == DataTypes::DATA_TYPE_FP16) {

const uint16_t* fp16_vec = static_cast<const uint16_t*>(precise_vectors) +

static_cast<uint64_t>(inner_id) * dim;

float true_dist = 0.0F;

for (uint64_t i = 0; i < dim; ++i) {

float diff = query[i] - (static_cast<float>(fp16_vec[i]) / 32768.0F);

true_dist += diff * diff;

}

trace.true_distance = std::sqrt(true_dist);

}

mergify · 2026-04-17T06:00:15Z

Merge Protections

Your pull request matches the following merge protections and will not be merged until they are valid.

🟢 Require kind label

Wonderful, this rule succeeded.

label~=^kind/

🟢 Require version label

Wonderful, this rule succeeded.

label~=^version/

LHT129 self-assigned this Apr 15, 2026

Copilot AI review requested due to automatic review settings April 15, 2026 03:35

LHT129 requested review from inabao, jiaweizone and wxyucs as code owners April 15, 2026 03:35

pull-request-size bot added the size/XL label Apr 15, 2026

LHT129 added kind/feature New feature version/1.0 labels Apr 15, 2026

Copilot started reviewing on behalf of LHT129 April 15, 2026 03:35 View session

Copilot AI reviewed Apr 15, 2026

View reviewed changes

gemini-code-assist bot reviewed Apr 15, 2026

View reviewed changes

Copilot AI review requested due to automatic review settings April 15, 2026 07:08

LHT129 force-pushed the 2026-04-14-实现-ReasoningContext-数据收集器 branch from 9c41ca5 to bedc364 Compare April 15, 2026 07:08

Copilot AI reviewed Apr 15, 2026

View reviewed changes

Copilot started reviewing on behalf of LHT129 April 15, 2026 07:32 View session

Conversation

LHT129 commented Apr 15, 2026

Summary

Changes

Files Changed

Testing

Related Issues

Checklist

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Reviewed changes

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

Copilot AI Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot left a comment

Choose a reason for hiding this comment

Code Review

Uh oh!

Uh oh!

gemini-code-assist bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

gemini-code-assist bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

LHT129 commented Apr 15, 2026

Review Response Summary

Resolved Issues

Deferred to Future Iterations

Uh oh!

Copilot AI left a comment