PatchDataField.cpp

Go to the documentation of this file.

// -------------------------------------------------------//
//
// SHAMROCK code for hydrodynamics
// Copyright (c) 2021-2026 Timothée David--Cléris <tim.shamrock@proton.me>
// SPDX-License-Identifier: CeCILL Free Software License Agreement v2.1
// Shamrock is licensed under the CeCILL 2.1 License, see LICENSE for more information
//
// -------------------------------------------------------//

 
#include "shambase/aliases_int.hpp"
#include "shambase/exception.hpp"
#include "shambase/memory.hpp"
#include "shambase/narrowing.hpp"
#include "shambase/string.hpp"
#include "shamalgs/algorithm.hpp"
#include "shamalgs/details/numeric/numeric.hpp"
#include "shamalgs/primitives/append_subset_to.hpp"
#include "shamalgs/primitives/dot_sum.hpp"
#include "shamalgs/primitives/equals.hpp"
#include "shamalgs/primitives/mock_value.hpp"
#include "shamalgs/primitives/mock_vector.hpp"
#include "shamalgs/primitives/reduction.hpp"
#include "shamalgs/random.hpp"
#include "shamalgs/reduction.hpp"
#include "shambackends/kernel_call.hpp"
#include "shambackends/vec.hpp"
#include "shamrock/legacy/utils/sycl_vector_utils.hpp"
#include "shamrock/patch/PatchDataField.hpp"
#include "shamsys/NodeInstance.hpp"
#include "shamsys/legacy/log.hpp"
#include <algorithm>
#include <memory>
#include <numeric>
#include <vector>
 
template<class T>
class Kernel_Extract_element;
 
template<class T>
void PatchDataField<T>::extract_element(u32 pidx, PatchDataField<T> &to) {
 
    auto fast_extract_ptr = [](u32 idx, u32 length, auto cnt) {
        T end_ = cnt[length - 1];
        T extr = cnt[idx];
 
        cnt[idx] = end_;
 
        return extr;
    };
 
    auto sub_extract
        = [fast_extract_ptr](u32 pidx, PatchDataField<T> &from, PatchDataField<T> &to) {
              const u32 nvar        = from.get_nvar();
              const u32 idx_val     = pidx * nvar;
              const u32 idx_out_val = to.get_val_cnt();
 
              u32 from_sz = from.get_val_cnt();
 
              to.expand(1);
 
              {
 
                  auto &buf_to   = to.get_buf();
                  auto &buf_from = from.get_buf();
 
                  sham::EventList depends_list;
                  T *acc_to   = buf_to.get_write_access(depends_list);
                  T *acc_from = buf_from.get_write_access(depends_list);
 
                  sham::DeviceQueue &q = shamsys::instance::get_compute_scheduler().get_queue();
 
                  auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
                      const u32 nvar_loc = nvar;
 
                      cgh.single_task<Kernel_Extract_element<T>>([=]() {
                          for (u32 i = nvar_loc - 1; i < nvar_loc; i--) {
                              acc_to[idx_out_val + i]
                                  = (fast_extract_ptr(idx_val + i, from_sz, acc_from));
                          }
                      });
                  });
 
                  buf_to.complete_event_state(e);
                  buf_from.complete_event_state(e);
              }
 
              from.shrink(1);
          };
 
    sub_extract(pidx, *this, to);
}
 
template<class T>
void PatchDataField<T>::extract_elements(
    const sham::DeviceBuffer<u32> &idxs, PatchDataField<T> &to) {
    if (&to == this) {
        throw shambase::make_except_with_loc<std::invalid_argument>(
            "source and destination for extract_elements cannot be the same");
    }
    StackEntry stack_loc{};
    append_subset_to(idxs, idxs.get_size(), to);
    remove_ids(idxs, idxs.get_size());
}
 
template<class T>
bool PatchDataField<T>::check_field_match(PatchDataField<T> &f2) {
    bool match = true;
 
    match = match && (field_name == f2.field_name);
    match = match && (nvar == f2.nvar);
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
 
    // it will also check that the size is the same
    match = match && shamalgs::primitives::equals(dev_sched, buf, f2.buf);
 
    return match;
}
 
template<class T>
void PatchDataField<T>::append_subset_to(
    const sham::DeviceBuffer<u32> &idxs_buf, u32 sz, PatchDataField &pfield) const {
 
    if (pfield.nvar != nvar)
        throw shambase::make_except_with_loc<std::invalid_argument>(
            "field must be similar for extraction");
 
    if (static_cast<size_t>(sz) != idxs_buf.get_size())
        throw shambase::make_except_with_loc<std::invalid_argument>(
            "the size of the idxs buffer does not match the size of the subset");
 
    if (sz > 0) {
        const u32 start_enque = pfield.get_val_cnt();
        const u32 nvar        = get_nvar();
        pfield.expand(sz);
 
        shamalgs::primitives::append_subset_to(buf, idxs_buf, nvar, pfield.get_buf(), start_enque);
    }
}
 
template<class T>
void PatchDataField<T>::append_subset_to(
    sycl::buffer<u32> &idxs_buf, u32 sz, PatchDataField &pfield) {
 
    if (sz > 0) {
        sham::DeviceBuffer<u32> buffer(sz, shamsys::instance::get_compute_scheduler_ptr());
        buffer.copy_from_sycl_buffer(idxs_buf);
        append_subset_to(buffer, sz, pfield);
    }
}
 
template<class T>
void PatchDataField<T>::append_subset_to(const std::vector<u32> &idxs, PatchDataField &pfield) {
 
    u32 sz = shambase::narrow_or_throw<u32>(idxs.size());
 
    if (sz > 0) {
        sham::DeviceBuffer<u32> idxs_buf(sz, shamsys::instance::get_compute_scheduler_ptr());
        idxs_buf.copy_from_stdvec(idxs);
        append_subset_to(idxs_buf, sz, pfield);
    }
}
 
template<class T>
class PdatField_insert_element;
 
template<class T>
void PatchDataField<T>::insert_element(T v) {
    if (nvar != 1) {
        shambase::throw_unimplemented();
    }
    u32 ins_pos = get_val_cnt();
    expand(1);
 
    auto sptr = shamsys::instance::get_compute_scheduler_ptr();
    auto &q   = sptr->get_queue();
 
    sham::EventList depends_list;
    T *acc = get_buf().get_write_access(depends_list);
 
    auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
        auto id_ins = ins_pos;
        auto val    = v;
 
        cgh.single_task<PdatField_insert_element<T>>([=]() {
            acc[id_ins] = val;
        });
    });
 
    get_buf().complete_event_state(e);
}
 
template<class T>
class PdatField_apply_offset;
 
template<class T>
void PatchDataField<T>::apply_offset(T off) {
 
    if (get_obj_cnt() > 0) {
 
        auto sptr = shamsys::instance::get_compute_scheduler_ptr();
        auto &q   = sptr->get_queue();
 
        sham::EventList depends_list;
        T *acc = get_buf().get_write_access(depends_list);
 
        auto e = q.submit(depends_list, [&](sycl::handler &cgh) {
            auto val = off;
 
            cgh.parallel_for<PdatField_apply_offset<T>>(
                sycl::range<1>{get_val_cnt()}, [=](sycl::id<1> idx) {
                    acc[idx] += val;
                });
        });
        get_buf().complete_event_state(e);
    }
}
 
template<class T>
class PdatField_insert;
 
template<class T>
void PatchDataField<T>::insert(const PatchDataField<T> &f2) {
    get_buf().append(f2.get_buf());
}
 
template<class T>
void PatchDataField<T>::index_remap_resize(sham::DeviceBuffer<u32> &index_map, u32 len) {
 
    if (!buf.is_empty()) {
 
        auto sched_ptr = shamsys::instance::get_compute_scheduler_ptr();
 
        auto get_new_buf = [&]() {
            if (nvar == 1) {
                return shamalgs::algorithm::index_remap(sched_ptr, buf, index_map, len);
            } else {
                return shamalgs::algorithm::index_remap_nvar(sched_ptr, buf, index_map, len, nvar);
            }
        };
 
        buf = get_new_buf();
    }
}
 
template<class T>
void PatchDataField<T>::index_remap(sham::DeviceBuffer<u32> &index_map, u32 len) {
 
    if (len != get_obj_cnt()) {
        throw shambase::make_except_with_loc<std::invalid_argument>(sham::format(
            "the match of the new index map does not match with the patchdatafield obj count: {} "
            "!= {}",
            len,
            get_obj_cnt()));
    }
 
    index_remap_resize(index_map, len);
}
 
template<class T>
void PatchDataField<T>::permut_vars(const std::vector<u32> &permut) {
    if (permut.size() != get_nvar()) {
        throw shambase::make_except_with_loc<std::invalid_argument>(sham::format(
            "the number of permut is not equal to the patchdatafield nvar: {} != {}",
            permut.size(),
            get_nvar()));
    }
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
    auto &q        = dev_sched->get_queue();
 
    sham::DeviceBuffer<u32> permut_buf(
        permut.size(), shamsys::instance::get_compute_scheduler_ptr());
    permut_buf.copy_from_stdvec(permut);
 
    sham::DeviceBuffer<T> copy = buf.copy();
 
    sham::kernel_call(
        q,
        sham::MultiRef{copy, permut_buf},
        sham::MultiRef{buf},
        get_val_cnt(),
        [nvar = nvar](u32 i, const T *src, const u32 *permut, T *dst) {
            u32 obj_id = i / nvar;
            u32 var_id = i % nvar;
 
            u32 new_var_id = permut[var_id];
 
            dst[obj_id * nvar + new_var_id] = src[i];
        });
}
 
template<class T>
void PatchDataField<T>::remove_ids(const sham::DeviceBuffer<u32> &ids_to_rem, u32 len) {
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
    auto &q        = dev_sched->get_queue();
 
    if (len > get_obj_cnt()) {
        throw shambase::make_except_with_loc<std::invalid_argument>(sham::format(
            "the number of ids to remove is greater than the patchdatafield obj count: {} > {}",
            len,
            get_obj_cnt()));
    }
 
    if (len == 0) {
        return;
    }
 
    auto nobj      = get_obj_cnt();
    auto remaining = nobj - len;
 
    sham::DeviceBuffer<u32> keep_flag(get_obj_cnt(), dev_sched);
    keep_flag.fill(1);
 
    sham::kernel_call(
        q,
        sham::MultiRef{ids_to_rem},
        sham::MultiRef{keep_flag},
        len,
        [](u32 i, const u32 *idx, u32 *idx_map) {
            idx_map[idx[i]] = 0;
        });
 
    auto keep_ids = shamalgs::numeric::stream_compact(dev_sched, keep_flag, nobj);
 
    if (keep_ids.get_size() != remaining) {
 
        // post mortem analysis
 
        std::vector<u32> ids_to_rem_vec = ids_to_rem.copy_to_stdvec_idx_range(0, len);
 
        std::sort(ids_to_rem_vec.begin(), ids_to_rem_vec.end());
 
        bool has_duplicates = false;
 
        // Adjacent elements in ids_to_rem_vec should be different
        has_duplicates = std::adjacent_find(ids_to_rem_vec.begin(), ids_to_rem_vec.end())
                         != ids_to_rem_vec.end();
 
        std::vector<u32> keep_flags_vec = keep_flag.copy_to_stdvec();
 
        // compute keep flags sum
        u32 keep_flags_sum = std::accumulate(keep_flags_vec.begin(), keep_flags_vec.end(), u32(0));
 
        std::string log = sham::format(
            "the number of remaining ids {} is different from the expected {}",
            keep_ids.get_size(),
            remaining);
 
        log += "\n\nAdditional information:\n";
        if (has_duplicates) {
            log += "  ids_to_rem has duplicates = true\n";
        } else {
            log += "  ids_to_rem has duplicates = false\n";
        }
        log += sham::format("  keep flags sum = {}\n", keep_flags_sum);
 
        throw shambase::make_except_with_loc<std::invalid_argument>(log);
    }
 
    index_remap_resize(keep_ids, remaining);
}
 
template<class T>
PatchDataField<T> PatchDataField<T>::mock_field(
    u64 seed, u32 obj_cnt, std::string name, u32 nvar, T vmin, T vmax) {
 
    std::vector<T> buf = shamalgs::primitives::mock_vector<T>(seed, obj_cnt * nvar, vmin, vmax);
    PatchDataField<T> ret(name, nvar, obj_cnt);
    ret.get_buf().copy_from_stdvec(buf);
 
    return ret;
}
 
template<class T>
PatchDataField<T> PatchDataField<T>::mock_field(u64 seed, u32 obj_cnt, std::string name, u32 nvar) {
    using Prop = shambase::VectorProperties<T>;
    return PatchDataField<T>::mock_field(
        seed, obj_cnt, name, nvar, Prop::get_min(), Prop::get_max());
}
 
template<class T>
void PatchDataField<T>::serialize_buf(shamalgs::SerializeHelper &serializer) {
    StackEntry stack_loc{false};
    u32 obj_cnt = get_obj_cnt();
    serializer.write(obj_cnt);
    shamlog_debug_sycl_ln("PatchDataField", "serialize patchdatafield len=", obj_cnt);
    if (obj_cnt > 0) {
        serializer.write_buf(buf, get_val_cnt());
    }
}
 
template<class T>
PatchDataField<T> PatchDataField<T>::deserialize_buf(
    shamalgs::SerializeHelper &serializer, std::string field_name, u32 nvar) {
    StackEntry stack_loc{false};
    u32 cnt;
    serializer.load(cnt);
    shamlog_debug_sycl_ln("PatchDataField", "deserialize patchdatafield len=", cnt);
 
    if (cnt > 0) {
        sham::DeviceBuffer<T> buf(cnt * nvar, serializer.get_device_scheduler());
        serializer.load_buf(buf, cnt * nvar);
        return PatchDataField<T>(std::move(buf), field_name, nvar);
    } else {
        return PatchDataField<T>(field_name, nvar, cnt);
    }
}
 
template<class T>
shamalgs::SerializeSize PatchDataField<T>::serialize_buf_byte_size() {
 
    using H = shamalgs::SerializeHelper;
    return H::serialize_byte_size<u32>() + H::serialize_byte_size<T>(get_val_cnt());
}
 
template<class T>
void PatchDataField<T>::serialize_full(shamalgs::SerializeHelper &serializer) {
    StackEntry stack_loc{false};
    serializer.write(nvar);
    serializer.write(field_name);
    serialize_buf(serializer);
}
 
template<class T>
shamalgs::SerializeSize PatchDataField<T>::serialize_full_byte_size() {
    using H = shamalgs::SerializeHelper;
    return (H::serialize_byte_size<u32>()) + H::serialize_byte_size(field_name)
           + serialize_buf_byte_size();
}
 
template<class T>
PatchDataField<T> PatchDataField<T>::deserialize_full(shamalgs::SerializeHelper &serializer) {
    StackEntry stack_loc{false};
    u32 nvar;
    serializer.load(nvar);
    std::string field_name;
    serializer.load(field_name);
 
    return deserialize_buf(serializer, field_name, nvar);
}
 
template<class T>
T PatchDataField<T>::compute_max() const {
    StackEntry stack_loc{};
    if (is_empty()) {
        throw shambase::make_except_with_loc<std::invalid_argument>("the field is empty");
    }
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
    return shamalgs::primitives::max(dev_sched, buf, 0, get_val_cnt());
}
 
template<class T>
T PatchDataField<T>::compute_min() const {
    StackEntry stack_loc{};
    if (is_empty()) {
        throw shambase::make_except_with_loc<std::invalid_argument>("the field is empty");
    }
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
    return shamalgs::primitives::min(dev_sched, buf, 0, get_val_cnt());
}
 
template<class T>
T PatchDataField<T>::compute_sum() const {
    StackEntry stack_loc{};
    if (is_empty()) {
        throw shambase::make_except_with_loc<std::invalid_argument>("the field is empty");
    }
 
    auto dev_sched = shamsys::instance::get_compute_scheduler_ptr();
    return shamalgs::primitives::sum(dev_sched, buf, 0, get_val_cnt());
}
 
template<class T>
shambase::VecComponent<T> PatchDataField<T>::compute_dot_sum() {
    StackEntry stack_loc{};
    if (is_empty()) {
        throw shambase::make_except_with_loc<std::invalid_argument>("the field is empty");
    }
 
    return shamalgs::primitives::dot_sum(buf, 0, get_val_cnt());
}
 
template<class T>
bool PatchDataField<T>::has_nan() {
    StackEntry stack_loc{};
 
    return shamalgs::reduction::has_nan(buf, get_val_cnt());
}
template<class T>
bool PatchDataField<T>::has_inf() {
    StackEntry stack_loc{};
 
    return shamalgs::reduction::has_inf(buf, get_val_cnt());
}
template<class T>
bool PatchDataField<T>::has_nan_or_inf() {
    StackEntry stack_loc{};
 
    return shamalgs::reduction::has_nan_or_inf(buf, get_val_cnt());
}

// Define the patchdata field for all classes in XMAC_LIST_ENABLED_FIELD
 
#ifndef DOXYGEN
    #define X(a) template class PatchDataField<a>;
XMAC_LIST_ENABLED_FIELD
    #undef X
#endif

// data mocking for patchdata field
 
const u32 obj_mock_cnt = 6000;
 
#ifndef DOXYGEN
template<>
void PatchDataField<f32>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
 
    std::vector<f32> out(obj_cnt * nvar);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32(distf64(eng));
    }
 
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f32_2>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f32_2> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32_2{distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f32_3>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f32_3> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32_3{distf64(eng), distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f32_4>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f32_4> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32_4{distf64(eng), distf64(eng), distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f32_8>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f32_8> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32_8{
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f32_16>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f32_16> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f32_16{
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64(distf64(eng));
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64_2>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64_2> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64_2{distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64_3>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64_3> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64_3{distf64(eng), distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64_4>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64_4> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64_4{distf64(eng), distf64(eng), distf64(eng), distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64_8>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64_8> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64_8{
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<f64_16>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_real_distribution<f64> distf64(1, obj_mock_cnt);
 
    std::vector<f64_16> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = f64_16{
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng),
            distf64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<u32>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<u32> distu32(1, obj_mock_cnt);
 
    std::vector<u32> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = distu32(eng);
    }
    buf.copy_from_stdvec(out);
}
template<>
void PatchDataField<u64>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<u64> distu64(1, obj_mock_cnt);
 
    std::vector<u64> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = distu64(eng);
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<u32_3>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<u32> distu32(1, obj_mock_cnt);
 
    std::vector<u32_3> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = u32_3{distu32(eng), distu32(eng), distu32(eng)};
    }
    buf.copy_from_stdvec(out);
}
template<>
void PatchDataField<u64_3>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<u64> distu64(1, obj_mock_cnt);
 
    std::vector<u64_3> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = u64_3{distu64(eng), distu64(eng), distu64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<i64_3>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<i64> disti64(1, obj_mock_cnt);
 
    std::vector<i64_3> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = i64_3{disti64(eng), disti64(eng), disti64(eng)};
    }
    buf.copy_from_stdvec(out);
}
 
template<>
void PatchDataField<i64>::gen_mock_data(u32 obj_cnt, std::mt19937 &eng) {
    resize(obj_cnt);
    std::uniform_int_distribution<i64> disti64(1, obj_mock_cnt);
 
    std::vector<i64> out(obj_cnt * nvar);
 
    for (u32 i = 0; i < get_val_cnt(); i++) {
        out[i] = i64{disti64(eng)};
    }
    buf.copy_from_stdvec(out);
}
#endif