milvus-io
/
milvus
mirror of https://github.com/milvus-io/milvus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

enhance: eliminate compile warnings (#38420) 

See: #38435

---------

Signed-off-by: Ted Xu <ted.xu@zilliz.com>
pull/38479/head
Ted Xu 2024-12-16 09:58:43 +08:00 committed by GitHub
parent c3edc85359
commit 4919ccf543
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 56 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
internal/core/CMakeLists.txt
View File

@ -148,7 +148,9 @@ if ( APPLE )
"-DELPP_THREAD_SAFE"
"-fopenmp"
"-pedantic"
"-Wno-all"
"-Wall"
"-Wno-gnu-zero-variadic-macro-arguments"
"-Wno-variadic-macros"
"-DBOOST_STACKTRACE_GNU_SOURCE_NOT_REQUIRED=1"
)
endif ()

2
internal/core/src/common/Chunk.h
View File

@ -243,7 +243,7 @@ class SparseFloatVectorChunk : public Chunk {
for (int i = 0; i < row_nums; i++) {
vec_[i] = {(offsets_ptr[i + 1] - offsets_ptr[i]) /
knowhere::sparse::SparseRow<float>::element_size(),
(uint8_t*)(data + offsets_ptr[i]),
reinterpret_cast<uint8_t*>(data + offsets_ptr[i]),
false};
dim_ = std::max(dim_, vec_[i].dim());
}

13
internal/core/src/common/ChunkWriter.cpp
View File

@ -12,6 +12,7 @@
#include "common/ChunkWriter.h"
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>
#include "arrow/array/array_binary.h"
#include "arrow/array/array_primitive.h"
@ -66,7 +67,7 @@ StringChunkWriter::write(std::shared_ptr<arrow::RecordBatchReader> data) {
int offset_start_pos = target_->tell() + sizeof(uint64_t) * offset_num;
std::vector<uint64_t> offsets;
for (auto str : strs) {
for (const auto& str : strs) {
offsets.push_back(offset_start_pos);
offset_start_pos += str.size();
}
@ -133,7 +134,7 @@ JSONChunkWriter::write(std::shared_ptr<arrow::RecordBatchReader> data) {
int offset_start_pos = target_->tell() + sizeof(uint64_t) * offset_num;
std::vector<uint64_t> offsets;
for (auto json : jsons) {
for (const auto& json : jsons) {
offsets.push_back(offset_start_pos);
offset_start_pos += json.data().size();
}
@ -142,7 +143,7 @@ JSONChunkWriter::write(std::shared_ptr<arrow::RecordBatchReader> data) {
target_->write(offsets.data(), offsets.size() * sizeof(uint64_t));
// write data
for (auto json : jsons) {
for (const auto& json : jsons) {
target_->write(json.data().data(), json.data().size());
}
}
@ -288,7 +289,7 @@ SparseFloatVectorChunkWriter::write(
int offset_start_pos = target_->tell() + sizeof(uint64_t) * offset_num;
std::vector<uint64_t> offsets;
for (auto str : strs) {
for (const auto& str : strs) {
offsets.push_back(offset_start_pos);
offset_start_pos += str.size();
}
@ -396,7 +397,7 @@ create_chunk(const FieldMeta& field_meta,
PanicInfo(Unsupported, "Unsupported data type");
}
w->write(r);
w->write(std::move(r));
return w->finish();
}
@ -493,7 +494,7 @@ create_chunk(const FieldMeta& field_meta,
PanicInfo(Unsupported, "Unsupported data type");
}
w->write(r);
w->write(std::move(r));
return w->finish();
}

12
internal/core/src/common/ChunkWriter.h
View File

@ -67,7 +67,7 @@ class ChunkWriter : public ChunkWriterBase {
auto batch_vec = data->ToRecordBatches().ValueOrDie();
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
row_nums += batch->num_rows();
auto data = batch->column(0);
auto array = std::dynamic_pointer_cast<ArrowType>(data);
@ -83,7 +83,7 @@ class ChunkWriter : public ChunkWriterBase {
}
// chunk layout: nullbitmap, data1, data2, ..., datan
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
auto data = batch->column(0);
auto null_bitmap = data->null_bitmap_data();
auto null_bitmap_n = (data->length() + 7) / 8;
@ -95,7 +95,7 @@ class ChunkWriter : public ChunkWriterBase {
}
}
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
auto data = batch->column(0);
auto array = std::dynamic_pointer_cast<ArrowType>(data);
auto data_ptr = array->raw_values();
@ -122,7 +122,7 @@ ChunkWriter<arrow::BooleanArray, bool>::write(
auto row_nums = 0;
auto batch_vec = data->ToRecordBatches().ValueOrDie();
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
row_nums += batch->num_rows();
auto data = batch->column(0);
auto array = std::dynamic_pointer_cast<arrow::BooleanArray>(data);
@ -136,7 +136,7 @@ ChunkWriter<arrow::BooleanArray, bool>::write(
target_ = std::make_shared<MemChunkTarget>(size);
}
// chunk layout: nullbitmap, data1, data2, ..., datan
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
auto data = batch->column(0);
auto null_bitmap = data->null_bitmap_data();
auto null_bitmap_n = (data->length() + 7) / 8;
@ -148,7 +148,7 @@ ChunkWriter<arrow::BooleanArray, bool>::write(
}
}
for (auto batch : batch_vec) {
for (auto& batch : batch_vec) {
auto data = batch->column(0);
auto array = std::dynamic_pointer_cast<arrow::BooleanArray>(data);
for (int i = 0; i < array->length(); i++) {

7
internal/core/src/common/FieldData.h
View File

@ -18,6 +18,7 @@
#include <string>
#include <memory>
#include <utility>
#include <oneapi/tbb/concurrent_queue.h>
@ -102,7 +103,7 @@ class FieldData<BinaryVector> : public FieldDataImpl<uint8_t, false> {
}
int64_t
get_dim() const {
get_dim() const override {
return binary_dim_;
}
@ -149,7 +150,9 @@ struct ArrowDataWrapper {
ArrowDataWrapper(std::shared_ptr<arrow::RecordBatchReader> reader,
std::shared_ptr<parquet::arrow::FileReader> arrow_reader,
std::shared_ptr<uint8_t[]> file_data)
: reader(reader), arrow_reader(arrow_reader), file_data(file_data) {
: reader(std::move(reader)),
arrow_reader(std::move(arrow_reader)),
file_data(std::move(file_data)) {
}
std::shared_ptr<arrow::RecordBatchReader> reader;
// file reader must outlive the record batch reader

2
internal/core/src/exec/expression/Expr.cpp
View File

@ -151,11 +151,11 @@ CompileExpression(const expr::TypedExprPtr& expr,
bool enable_constant_folding) {
ExprPtr result;
auto result_type = expr->type();
auto compiled_inputs = CompileInputs(expr, context, flatten_candidates);
auto GetTypes = [](const std::vector<ExprPtr>& exprs) {
std::vector<DataType> types;
types.reserve(exprs.size());
for (auto& expr : exprs) {
types.push_back(expr->type());
}

1
internal/core/src/exec/expression/Expr.h
View File

@ -382,7 +382,6 @@ class SegmentExpr : public Expr {
conditional_t<std::is_same_v<T, std::string_view>, std::string, T>
IndexInnerType;
using Index = index::ScalarIndex<IndexInnerType>;
int64_t processed_size = 0;
const Index& index =
segment_->chunk_scalar_index<IndexInnerType>(field_id_, 0);
auto* index_ptr = const_cast<Index*>(&index);

5
internal/core/src/exec/expression/UnaryExpr.cpp
View File

@ -259,9 +259,6 @@ PhyUnaryRangeFilterExpr::Eval(EvalCtx& context, VectorPtr& result) {
template <typename ValueType>
VectorPtr
PhyUnaryRangeFilterExpr::ExecRangeVisitorImplArray(OffsetVector* input) {
using GetType = std::conditional_t<std::is_same_v<ValueType, std::string>,
std::string_view,
ValueType>;
auto real_batch_size =
has_offset_input_ ? input->size() : GetNextBatchSize();
if (real_batch_size == 0) {
@ -896,7 +893,7 @@ template <typename T>
ColumnVectorPtr
PhyUnaryRangeFilterExpr::PreCheckOverflow(OffsetVector* input) {
if constexpr (std::is_integral_v<T> && !std::is_same_v<T, bool>) {
int64_t val = GetValueFromProto<int64_t>(expr_->val_);
auto val = GetValueFromProto<int64_t>(expr_->val_);
if (milvus::query::out_of_range<T>(val)) {
int64_t batch_size;

21
internal/core/src/exec/expression/UnaryExpr.h
View File

@ -35,12 +35,12 @@ namespace exec {
template <typename T, FilterType filter_type>
struct UnaryElementFuncForMatch {
typedef std::
conditional_t<std::is_same_v<T, std::string_view>, std::string, T>
IndexInnerType;
using IndexInnerType =
std::conditional_t<std::is_same_v<T, std::string_view>, std::string, T>;
void
operator()(const T* src,
size_t size,
IndexInnerType val,
TargetBitmapView res,
@ -60,9 +60,8 @@ struct UnaryElementFuncForMatch {
template <typename T, proto::plan::OpType op, FilterType filter_type>
struct UnaryElementFunc {
typedef std::
conditional_t<std::is_same_v<T, std::string_view>, std::string, T>
IndexInnerType;
using IndexInnerType =
std::conditional_t<std::is_same_v<T, std::string_view>, std::string, T>;
void
operator()(const T* src,
@ -235,9 +234,8 @@ struct UnaryElementFuncForArray {
template <typename T>
struct UnaryIndexFuncForMatch {
typedef std::
conditional_t<std::is_same_v<T, std::string_view>, std::string, T>
IndexInnerType;
using IndexInnerType =
std::conditional_t<std::is_same_v<T, std::string_view>, std::string, T>;
using Index = index::ScalarIndex<IndexInnerType>;
TargetBitmap
operator()(Index* index, IndexInnerType val) {
@ -275,9 +273,8 @@ struct UnaryIndexFuncForMatch {
template <typename T, proto::plan::OpType op>
struct UnaryIndexFunc {
typedef std::
conditional_t<std::is_same_v<T, std::string_view>, std::string, T>
IndexInnerType;
using IndexInnerType =
std::conditional_t<std::is_same_v<T, std::string_view>, std::string, T>;
using Index = index::ScalarIndex<IndexInnerType>;
TargetBitmap
operator()(Index* index, IndexInnerType val) {

4
internal/core/src/exec/operator/groupby/SearchGroupByOperator.h
View File

@ -118,11 +118,11 @@ template <typename T>
static const std::shared_ptr<DataGetter<T>>
GetDataGetter(const segcore::SegmentInternalInterface& segment,
FieldId fieldId) {
if (const segcore::SegmentGrowingImpl* growing_segment =
if (const auto* growing_segment =
dynamic_cast<const segcore::SegmentGrowingImpl*>(&segment)) {
return std::make_shared<GrowingDataGetter<T>>(*growing_segment,
fieldId);
} else if (const segcore::SegmentSealed* sealed_segment =
} else if (const auto* sealed_segment =
dynamic_cast<const segcore::SegmentSealed*>(&segment)) {
return std::make_shared<SealedDataGetter<T>>(*sealed_segment, fieldId);
} else {

4
internal/core/src/mmap/ChunkData.h
View File

@ -95,7 +95,6 @@ VariableLengthChunk<std::string>::set(const std::string* src,
uint32_t begin,
uint32_t length) {
auto mcm = storage::MmapManager::GetInstance().GetMmapChunkManager();
milvus::ErrorCode err_code;
AssertInfo(
begin + length <= size_,
"failed to set a chunk with length: {} from beign {}, map_size={}",
@ -126,7 +125,6 @@ VariableLengthChunk<knowhere::sparse::SparseRow<float>>::set(
uint32_t begin,
uint32_t length) {
auto mcm = storage::MmapManager::GetInstance().GetMmapChunkManager();
milvus::ErrorCode err_code;
AssertInfo(
begin + length <= size_,
"failed to set a chunk with length: {} from beign {}, map_size={}",
@ -157,7 +155,6 @@ VariableLengthChunk<Json>::set(const Json* src,
uint32_t begin,
uint32_t length) {
auto mcm = storage::MmapManager::GetInstance().GetMmapChunkManager();
milvus::ErrorCode err_code;
AssertInfo(
begin + length <= size_,
"failed to set a chunk with length: {} from beign {}, map_size={}",
@ -187,7 +184,6 @@ VariableLengthChunk<Array>::set(const Array* src,
uint32_t begin,
uint32_t length) {
auto mcm = storage::MmapManager::GetInstance().GetMmapChunkManager();
milvus::ErrorCode err_code;
AssertInfo(
begin + length <= size_,
"failed to set a chunk with length: {} from beign {}, map_size={}",

26
internal/core/src/mmap/ChunkedColumn.h
View File

@ -66,7 +66,7 @@ class ChunkedColumnBase : public ColumnBase {
PanicInfo(ErrorCode::Unsupported, "AppendBatch not supported");
}
virtual const char*
const char*
Data(int chunk_id) const override {
return chunks_[chunk_id]->Data();
}
@ -125,7 +125,7 @@ class ChunkedColumnBase : public ColumnBase {
chunks_.push_back(chunk);
}
virtual size_t
size_t
DataByteSize() const override {
auto size = 0;
for (auto& chunk : chunks_) {
@ -236,10 +236,11 @@ class ChunkedColumn : public ChunkedColumnBase {
public:
ChunkedColumn() = default;
// memory mode ctor
ChunkedColumn(const FieldMeta& field_meta) : ChunkedColumnBase(field_meta) {
explicit ChunkedColumn(const FieldMeta& field_meta)
: ChunkedColumnBase(field_meta) {
}
ChunkedColumn(std::vector<std::shared_ptr<Chunk>> chunks) {
explicit ChunkedColumn(const std::vector<std::shared_ptr<Chunk>>& chunks) {
for (auto& chunk : chunks) {
AddChunk(chunk);
}
@ -247,7 +248,7 @@ class ChunkedColumn : public ChunkedColumnBase {
~ChunkedColumn() override = default;
virtual SpanBase
SpanBase
Span(int64_t chunk_id) const override {
return std::dynamic_pointer_cast<FixedWidthChunk>(chunks_[chunk_id])
->Span();
@ -258,11 +259,12 @@ class ChunkedColumn : public ChunkedColumnBase {
class ChunkedSparseFloatColumn : public ChunkedColumnBase {
public:
// memory mode ctor
ChunkedSparseFloatColumn(const FieldMeta& field_meta)
explicit ChunkedSparseFloatColumn(const FieldMeta& field_meta)
: ChunkedColumnBase(field_meta) {
}
ChunkedSparseFloatColumn(std::vector<std::shared_ptr<Chunk>> chunks) {
explicit ChunkedSparseFloatColumn(
const std::vector<std::shared_ptr<Chunk>>& chunks) {
for (auto& chunk : chunks) {
AddChunk(chunk);
}
@ -311,11 +313,12 @@ class ChunkedVariableColumn : public ChunkedColumnBase {
std::conditional_t<std::is_same_v<T, std::string>, std::string_view, T>;
// memory mode ctor
ChunkedVariableColumn(const FieldMeta& field_meta)
explicit ChunkedVariableColumn(const FieldMeta& field_meta)
: ChunkedColumnBase(field_meta) {
}
ChunkedVariableColumn(std::vector<std::shared_ptr<Chunk>> chunks) {
explicit ChunkedVariableColumn(
const std::vector<std::shared_ptr<Chunk>>& chunks) {
for (auto& chunk : chunks) {
AddChunk(chunk);
}
@ -388,11 +391,12 @@ class ChunkedVariableColumn : public ChunkedColumnBase {
class ChunkedArrayColumn : public ChunkedColumnBase {
public:
// memory mode ctor
ChunkedArrayColumn(const FieldMeta& field_meta)
explicit ChunkedArrayColumn(const FieldMeta& field_meta)
: ChunkedColumnBase(field_meta) {
}
ChunkedArrayColumn(std::vector<std::shared_ptr<Chunk>> chunks) {
explicit ChunkedArrayColumn(
const std::vector<std::shared_ptr<Chunk>>& chunks) {
for (auto& chunk : chunks) {
AddChunk(chunk);
}

8
internal/core/src/mmap/Column.h
View File

@ -698,7 +698,7 @@ class SingleChunkVariableColumn : public SingleChunkColumnBase {
uint32_t size;
size = *reinterpret_cast<uint32_t*>(pos);
pos += sizeof(uint32_t);
res.emplace_back(std::string_view(pos, size));
res.emplace_back(pos, size);
pos += size;
}
return std::make_pair(res, valid_data_);
@ -710,9 +710,9 @@ class SingleChunkVariableColumn : public SingleChunkColumnBase {
FixedVector<bool> valid;
res.reserve(offsets.size());
valid.reserve(offsets.size());
for (size_t i = 0; i < offsets.size(); ++i) {
res.emplace_back(RawAt(offsets[i]));
valid.emplace_back(IsValid(offsets[i]));
for (int offset : offsets) {
res.emplace_back(RawAt(offset));
valid.emplace_back(IsValid(offset));
}
return {res, valid};
}

14
internal/core/src/segcore/ChunkedSegmentSealedImpl.cpp
View File

@ -89,7 +89,6 @@ void
ChunkedSegmentSealedImpl::LoadVecIndex(const LoadIndexInfo& info) {
// NOTE: lock only when data is ready to avoid starvation
auto field_id = FieldId(info.field_id);
auto& field_meta = schema_->operator[](field_id);
AssertInfo(info.index_params.count("metric_type"),
"Can't get metric_type in index_params");
@ -355,11 +354,6 @@ ChunkedSegmentSealedImpl::LoadFieldData(FieldId field_id, FieldDataInfo& data) {
// Don't allow raw data and index exist at the same time
// AssertInfo(!get_bit(index_ready_bitset_, field_id),
// "field data can't be loaded when indexing exists");
auto get_block_size = [&]() -> size_t {
return schema_->get_primary_field_id() == field_id
? DEFAULT_PK_VRCOL_BLOCK_SIZE
: DEFAULT_MEM_VRCOL_BLOCK_SIZE;
};
std::shared_ptr<ChunkedColumnBase> column{};
if (IsVariableDataType(data_type)) {
@ -535,7 +529,6 @@ ChunkedSegmentSealedImpl::MapFieldData(const FieldId field_id,
auto data_type = field_meta.get_data_type();
// write the field data to disk
uint64_t total_written = 0;
std::vector<uint64_t> indices{};
std::vector<std::vector<uint64_t>> element_indices{};
// FixedVector<bool> valid_data{};
@ -743,7 +736,6 @@ ChunkedSegmentSealedImpl::get_chunk_buffer(FieldId field_id,
std::shared_lock lck(mutex_);
AssertInfo(get_bit(field_data_ready_bitset_, field_id),
"Can't get bitset element at " + std::to_string(field_id.get()));
auto& field_meta = schema_->operator[](field_id);
if (auto it = fields_.find(field_id); it != fields_.end()) {
auto& field_data = it->second;
FixedVector<bool> valid_data;
@ -1025,8 +1017,8 @@ ChunkedSegmentSealedImpl::get_vector(FieldId field_id,
ReadFromChunkCache, cc, data_path, mmap_descriptor_, field_meta));
}
for (int i = 0; i < futures.size(); ++i) {
const auto& [data_path, column] = futures[i].get();
for (auto& future : futures) {
const auto& [data_path, column] = future.get();
path_to_column[data_path] = column;
}
@ -1089,7 +1081,6 @@ ChunkedSegmentSealedImpl::DropFieldData(const FieldId field_id) {
}
lck.unlock();
} else {
auto& field_meta = schema_->operator[](field_id);
std::unique_lock lck(mutex_);
if (get_bit(field_data_ready_bitset_, field_id)) {
fields_.erase(field_id);
@ -1776,7 +1767,6 @@ ChunkedSegmentSealedImpl::bulk_subscript(
int64_t count,
const std::vector<std::string>& dynamic_field_names) const {
Assert(!dynamic_field_names.empty());
auto& field_meta = schema_->operator[](field_id);
if (count == 0) {
return fill_with_empty(field_id, 0);
}