#include "sve/sve.hpp"
#include <algorithm>
#include <cstring>
#include <thread>
#include <utility>
#include <vector>
#if defined(_MSC_VER)
# include <cstdlib>
#endif
namespace sve::par {
namespace {
constexpr std::size_t kMinParallel = 1u << 16;
constexpr std::size_t kGrain = 64;
std::size_t chunk_len(std::size_t n, std::size_t t) noexcept {
const std::size_t raw = (n + t - 1) / t;
return ((raw + kGrain - 1) / kGrain) * kGrain;
}
std::vector<std::pair<std::size_t, std::size_t>> split(std::size_t n, std::size_t cl) {
std::vector<std::pair<std::size_t, std::size_t>> v;
for (std::size_t i = 0; i < n; i += cl) v.emplace_back(i, std::min(i + cl, n));
return v;
}
constexpr std::size_t kTailGuard = 16;
void fill_exact(std::span<const std::int32_t> c, std::int32_t thr,
std::span<std::int32_t> dst) {
std::size_t found = 0;
std::size_t sp = c.size();
while (sp > 0 && found < kTailGuard) {
--sp;
if (c[sp] > thr) ++found;
}
std::size_t body_end = 0, w = 0;
if (found >= kTailGuard) {
body_end = sp;
w = sve::filter_into_i32(c.subspan(0, sp), thr, dst);
}
for (std::size_t i = body_end; i < c.size(); ++i)
if (c[i] > thr) dst[w++] = c[i];
}
}
std::size_t threads() noexcept {
static const std::size_t t = [] () -> std::size_t {
if (const char* e = std::getenv("SVE_THREADS")) {
const long v = std::strtol(e, nullptr, 10);
if (v >= 1) return static_cast<std::size_t>(v);
}
const unsigned hc = std::thread::hardware_concurrency();
return hc ? hc : 1u;
}();
return t;
}
std::size_t count_gt_i32(std::span<const std::int32_t> d, std::int32_t thr) {
const std::size_t t = threads();
if (t <= 1 || d.size() < kMinParallel) return sve::count_gt_i32(d, thr);
const auto parts = split(d.size(), chunk_len(d.size(), t));
std::vector<std::size_t> res(parts.size());
std::vector<std::thread> ws;
ws.reserve(parts.size());
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
res[k] = sve::count_gt_i32(d.subspan(parts[k].first, parts[k].second - parts[k].first), thr);
});
for (auto& w : ws) w.join();
std::size_t total = 0;
for (auto v : res) total += v;
return total;
}
std::size_t count_gt_f32(std::span<const float> d, float thr) {
const std::size_t t = threads();
if (t <= 1 || d.size() < kMinParallel) return sve::count_gt_f32(d, thr);
const auto parts = split(d.size(), chunk_len(d.size(), t));
std::vector<std::size_t> res(parts.size());
std::vector<std::thread> ws;
ws.reserve(parts.size());
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
res[k] = sve::count_gt_f32(d.subspan(parts[k].first, parts[k].second - parts[k].first), thr);
});
for (auto& w : ws) w.join();
std::size_t total = 0;
for (auto v : res) total += v;
return total;
}
std::int64_t sum_i32(std::span<const std::int32_t> d) {
const std::size_t t = threads();
if (t <= 1 || d.size() < kMinParallel) return sve::sum_i32(d);
const auto parts = split(d.size(), chunk_len(d.size(), t));
std::vector<std::int64_t> res(parts.size());
std::vector<std::thread> ws;
ws.reserve(parts.size());
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
res[k] = sve::sum_i32(d.subspan(parts[k].first, parts[k].second - parts[k].first));
});
for (auto& w : ws) w.join();
std::int64_t total = 0;
for (auto v : res) total += v;
return total;
}
std::optional<std::size_t> find_i32(std::span<const std::int32_t> d, std::int32_t needle) {
const std::size_t t = threads();
if (t <= 1 || d.size() < kMinParallel) return sve::find_i32(d, needle);
const auto parts = split(d.size(), chunk_len(d.size(), t));
std::vector<std::optional<std::size_t>> res(parts.size());
std::vector<std::thread> ws;
ws.reserve(parts.size());
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
const auto [b, e] = parts[k];
if (auto r = sve::find_i32(d.subspan(b, e - b), needle)) res[k] = b + *r;
});
for (auto& w : ws) w.join();
for (const auto& r : res)
if (r) return r; return std::nullopt;
}
std::size_t filter_into_i32(std::span<const std::int32_t> d, std::int32_t thr,
std::span<std::int32_t> out) {
const std::size_t t = threads();
if (t <= 1 || d.size() < kMinParallel) return sve::filter_into_i32(d, thr, out);
const auto parts = split(d.size(), chunk_len(d.size(), t));
std::vector<std::size_t> cnt(parts.size());
std::vector<std::thread> ws;
ws.reserve(parts.size());
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
const auto [b, e] = parts[k];
cnt[k] = sve::count_gt_i32(d.subspan(b, e - b), thr);
});
for (auto& w : ws) w.join();
ws.clear();
std::vector<std::size_t> prefix(parts.size() + 1, 0);
for (std::size_t k = 0; k < parts.size(); ++k) prefix[k + 1] = prefix[k] + cnt[k];
for (std::size_t k = 0; k < parts.size(); ++k)
ws.emplace_back([&, k] {
const auto [b, e] = parts[k];
fill_exact(d.subspan(b, e - b), thr, out.subspan(prefix[k], cnt[k]));
});
for (auto& w : ws) w.join();
return prefix.back();
}
}