Vector comparisons #2119
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,123 @@ | ||
| #include <cstdint> | ||
| #include <limits> | ||
| #include <type_traits> | ||
| #include <cstddef> | ||
|
|
||
| #include <arcticdb/util/vector_common.hpp> | ||
| #include <arcticdb/util/preconditions.hpp> | ||
|
|
||
| namespace arcticdb { | ||
|
|
||
| #if HAS_VECTOR_EXTENSIONS | ||
|
|
||
| template<typename Vec, typename U> | ||
| inline void fill_vector(Vec &vec, U value) { | ||
| U* p = reinterpret_cast<U*>(&vec); | ||
| constexpr size_t count = sizeof(Vec) / sizeof(U); | ||
| for (size_t i = 0; i < count; i++) { | ||
| p[i] = value; | ||
| } | ||
| } | ||
|
|
||
| template<typename T> | ||
| class MeanFinder { | ||
| static_assert(is_supported_int<T>::value || is_supported_float<T>::value, "Unsupported type"); | ||
| public: | ||
| static double find(const T* __restrict data, size_t n) { | ||
| util::check(n > 0, "Empty array provided"); | ||
| using VectorType = vector_type<T>; | ||
| using AccumVectorType = vector_type<double>; | ||
| constexpr size_t elements_per_vector = sizeof(VectorType) / sizeof(T); | ||
| constexpr size_t doubles_per_vector = sizeof(AccumVectorType) / sizeof(double); | ||
| constexpr size_t vectors_per_acc = elements_per_vector / doubles_per_vector; | ||
| AccumVectorType vsum; | ||
| double* vsum_ptr = reinterpret_cast<double*>(&vsum); | ||
| fill_vector<AccumVectorType, double>(vsum, 0.0); | ||
| size_t valid_count = 0; | ||
| const VectorType* vdata = reinterpret_cast<const VectorType*>(data); | ||
| const size_t vector_len = n / elements_per_vector; | ||
| for (size_t i = 0; i < vector_len; i++) { | ||
| VectorType v = vdata[i]; | ||
| const T* v_arr = reinterpret_cast<const T*>(&v); | ||
| if constexpr (std::is_floating_point_v<T>) { | ||
| bool has_nan = false; | ||
| for (size_t j = 0; j < elements_per_vector; j++) { | ||
| if (std::isnan(v_arr[j])) { has_nan = true; break; } | ||
| } | ||
| if (!has_nan) { | ||
| for (size_t chunk = 0; chunk < vectors_per_acc; chunk++) { | ||
| size_t base = chunk * doubles_per_vector; | ||
| for (size_t j = 0; j < doubles_per_vector; j++) { | ||
| if constexpr (std::is_same_v<T, double>) | ||
| vsum_ptr[j] += v_arr[base + j]; | ||
| else | ||
| vsum_ptr[j] += static_cast<double>(v_arr[base + j]); | ||
| } | ||
| } | ||
| valid_count += elements_per_vector; | ||
| } else { | ||
| for (size_t chunk = 0; chunk < vectors_per_acc; chunk++) { | ||
| size_t base = chunk * doubles_per_vector; | ||
| for (size_t j = 0; j < doubles_per_vector; j++) { | ||
| size_t idx = base + j; | ||
| if (!std::isnan(v_arr[idx])) { | ||
| if constexpr (std::is_same_v<T, double>) | ||
| vsum_ptr[j] += v_arr[idx]; | ||
| else | ||
| vsum_ptr[j] += static_cast<double>(v_arr[idx]); | ||
| valid_count++; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| } else { | ||
| for (size_t chunk = 0; chunk < vectors_per_acc; chunk++) { | ||
| size_t base = chunk * doubles_per_vector; | ||
| for (size_t j = 0; j < doubles_per_vector; j++) { | ||
| vsum_ptr[j] += static_cast<double>(v_arr[base + j]); | ||
| } | ||
| } | ||
| valid_count += elements_per_vector; | ||
| } | ||
| } | ||
| double total = 0.0; | ||
| for (size_t j = 0; j < doubles_per_vector; j++) { | ||
| total += vsum_ptr[j]; | ||
| } | ||
| const T* remain = data + (vector_len * elements_per_vector); | ||
| size_t rem = n % elements_per_vector; | ||
| for (size_t i = 0; i < rem; i++) { | ||
| if constexpr (std::is_floating_point_v<T>) { | ||
| if (!std::isnan(remain[i])) { | ||
| if constexpr (std::is_same_v<T, double>) | ||
| total += remain[i]; | ||
| else | ||
| total += static_cast<double>(remain[i]); | ||
| valid_count++; | ||
| } | ||
| } else { | ||
| total += static_cast<double>(remain[i]); | ||
| valid_count++; | ||
| } | ||
| } | ||
| return valid_count > 0 ? total / static_cast<double>(valid_count) : 0.0; | ||
| } | ||
| }; | ||
|
|
||
| template<typename T> | ||
| double find_mean(const T* __restrict data, size_t n) { | ||
| return MeanFinder<T>::find(data, n); | ||
| } | ||
|
|
||
| #else | ||
|
|
||
| template <typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value>::type> | ||
| double find_mean(const T* data, std::size_t size) { | ||
| util::check(size > 0, "Cannot compute mean of an empty array."); | ||
| double sum = std::accumulate(data, data + size, 0.0); | ||
| return sum / size; | ||
| } | ||
|
|
||
| #endif | ||
|
|
||
| } // namespace arcticdb |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,93 @@ | ||
| #include <cstdint> | ||
| #include <limits> | ||
| #include <type_traits> | ||
| #include <cstddef> | ||
| #include <algorithm> | ||
|
|
||
| #include <arcticdb/util/vector_common.hpp> | ||
|
|
||
| namespace arcticdb { | ||
|
|
||
| #if HAS_VECTOR_EXTENSIONS | ||
|
|
||
| template<typename T, typename Comparator> | ||
| class FloatExtremumFinder { | ||
| static_assert(is_supported_float<T>::value, "Type must be float or double"); | ||
| static_assert(std::is_floating_point_v<T>, "Type must be floating point"); | ||
| public: | ||
| static T find(const T* data, size_t n) { | ||
| if (n == 0) | ||
| return Comparator::identity(); | ||
| using vec_t = vector_type<T>; | ||
| constexpr size_t lane_count = sizeof(vec_t) / sizeof(T); | ||
| vec_t vext; | ||
| for (size_t i = 0; i < lane_count; i++) | ||
| reinterpret_cast<T*>(&vext)[i] = Comparator::identity(); | ||
|
|
||
| const vec_t* vdata = reinterpret_cast<const vec_t*>(data); | ||
| size_t vlen = n / lane_count; | ||
| for (size_t i = 0; i < vlen; i++) { | ||
| vec_t v = vdata[i]; | ||
| if constexpr (Comparator::is_min) | ||
| vext = (v < vext) ? v : vext; | ||
| else | ||
| vext = (v > vext) ? v : vext; | ||
| } | ||
| T result = Comparator::identity(); | ||
| const T* lanes = reinterpret_cast<const T*>(&vext); | ||
| for (size_t i = 0; i < lane_count; i++) { | ||
| if (lanes[i] == lanes[i]) | ||
| result = Comparator::compare(lanes[i], result); | ||
| } | ||
| const T* remain = data + (vlen * lane_count); | ||
| size_t remain_count = n % lane_count; | ||
| for (size_t i = 0; i < remain_count; i++) { | ||
| if (remain[i] == remain[i]) | ||
| result = Comparator::compare(remain[i], result); | ||
| } | ||
| return result; | ||
| } | ||
| }; | ||
|
|
||
| template<typename T> | ||
| struct FloatMinComparator { | ||
| static constexpr bool is_min = true; | ||
| static T identity() { return std::numeric_limits<T>::infinity(); } | ||
| static T compare(T a, T b) { return std::min(a, b); } | ||
| }; | ||
|
|
||
| template<typename T> | ||
| struct FloatMaxComparator { | ||
| static constexpr bool is_min = false; | ||
| static T identity() { return -std::numeric_limits<T>::infinity(); } | ||
| static T compare(T a, T b) { return std::max(a, b); } | ||
| }; | ||
|
|
||
| template<typename T> | ||
| T find_float_min(const T* data, size_t n) { | ||
| return FloatExtremumFinder<T, FloatMinComparator<T>>::find(data, n); | ||
| } | ||
|
|
||
| template<typename T> | ||
| T find_float_max(const T* data, size_t n) { | ||
| return FloatExtremumFinder<T, FloatMaxComparator<T>>::find(data, n); | ||
| } | ||
|
|
||
| #else | ||
|
There was a problem hiding this comment. Same comments below the |
||
|
|
||
| template<typename T> | ||
| typename std::enable_if<std::is_floating_point<T>::value, T>::type | ||
| find_float_min(const T *data, size_t n) { | ||
| util::check(size != 0, "Got zero size in find_float_min"); | ||
|
Check failure on line 81 in cpp/arcticdb/util/min_max_float.hpp
|
||
| return *std::min_element(data, data + n); | ||
| } | ||
|
|
||
| template<typename T> | ||
| typename std::enable_if<std::is_floating_point<T>::value, T>::type | ||
| find_float_max(const T *data, size_t n) { | ||
| util::check(size != 0, "Got zero size in find_float_max"); | ||
|
Check failure on line 88 in cpp/arcticdb/util/min_max_float.hpp
|
||
| return *std::max_element(data, data + n); | ||
| } | ||
|
|
||
| #endif | ||
| } // namespace arcticdb | ||
Oops, something went wrong.
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
Uncomment