ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *DYND_UNUSED(src_tp),
size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds),
const std::map<std::string, ndt::type> &DYND_UNUSED(tp_vars)) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data),
const char *DYND_UNUSED(dst_arrmeta), size_t DYND_UNUSED(nsrc),
const char *const *DYND_UNUSED(src_arrmeta)) { kb.emplace_back<KernelType>(kernreq); });
return dst_tp;
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &DYND_UNUSED(dst_tp), size_t DYND_UNUSED(nsrc), const ndt::type *src_tp,
size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds),
const std::map<std::string, ndt::type> &DYND_UNUSED(tp_vars)) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq,char *DYND_UNUSED(data), const char *DYND_UNUSED(dst_arrmeta),
size_t DYND_UNUSED(nsrc), const char *const *DYND_UNUSED(src_arrmeta)) {
kb.emplace_back<dereference_kernel>(kernreq);
});
return src_tp[0].extended<ndt::pointer_type>()->get_target_type();
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *DYND_UNUSED(src_tp),
size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds),
const std::map<std::string, ndt::type> &DYND_UNUSED(tp_vars)) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta,
size_t DYND_UNUSED(nsrc), const char *const *DYND_UNUSED(src_arrmeta)) {
kb.emplace_back<string_split_kernel>(
kernreq, reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta)->blockref);
});
return dst_tp;
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *src_tp,
size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds),
const std::map<std::string, ndt::type> &DYND_UNUSED(tp_vars)) {
size_t src0_data_size = src_tp[0].get_data_size();
cg.emplace_back([src0_data_size](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data),
const char *DYND_UNUSED(dst_arrmeta), size_t DYND_UNUSED(nsrc),
const char *const *DYND_UNUSED(src_arrmeta)) {
kb.emplace_back<pairwise_byteswap_ck>(kernreq, src0_data_size);
});
return dst_tp;
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t nsrc, const ndt::type *src_tp, size_t nkwd, const array *kwds,
const std::map<std::string, ndt::type> &DYND_UNUSED(tp_vars)) {
typedef functional::apply_member_function_kernel<T, mem_func_type, N> kernel_type;
cg.emplace_back([ obj = m_obj, mem_func = m_mem_func, kwds = typename kernel_type::kwds_type(nkwd, kwds) ](
kernel_builder & kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta,
size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) {
kb.emplace_back<kernel_type>(kernreq, obj, mem_func,
typename kernel_type::args_type(data, dst_arrmeta, src_arrmeta), kwds);
});
return this->resolve_return_type(dst_tp, nsrc, src_tp, nkwd, kwds);
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t nsrc, const ndt::type *src_tp, size_t nkwd, const array *kwds,
const std::map<std::string, ndt::type> &tp_vars) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data),
const char *dst_arrmeta, size_t nsrc, const char *const *src_arrmeta) {
kb.emplace_back<right_compound_kernel>(kernreq);
const char *child_src_arrmeta[2] = {src_arrmeta[0], dst_arrmeta};
kb(kernreq | kernel_request_data_only, nullptr, dst_arrmeta, nsrc + 1, child_src_arrmeta);
});
ndt::type child_src_tp[2] = {src_tp[0], dst_tp};
m_child->resolve(this, nullptr, cg, dst_tp, nsrc + 1, child_src_tp, nkwd, kwds, tp_vars);
return dst_tp;
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t nsrc, const ndt::type *src_tp, size_t nkwd, const array *kwds,
const std::map<std::string, ndt::type> &tp_vars) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta, size_t nsrc,
const char *const *src_arrmeta) {
kb.emplace_back<where_kernel>(
kernreq, data, reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta)->stride,
reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta)->blockref);
kb(kernel_request_single, nullptr, nullptr, nsrc - 1, src_arrmeta);
});
m_child->resolve(this, nullptr, cg, ndt::make_type<bool>(), nsrc - 1, src_tp, nkwd, kwds, tp_vars);
return dst_tp;
}
ndt::type resolve(base_callable *caller, char *DYND_UNUSED(data), call_graph &cg, const ndt::type &dst_tp,
size_t DYND_UNUSED(nsrc), const ndt::type *src_tp, size_t nkwd, const array *kwds,
const std::map<std::string, ndt::type> &tp_vars) {
cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta,
size_t nsrc, const char *const *src_arrmeta) {
size_t self_offset = kb.size();
kb.emplace_back<forward_na_kernel<I...>>(kernreq);
kb(kernel_request_single, nullptr, dst_arrmeta, nsrc, src_arrmeta);
for (intptr_t i : std::array<index_t, sizeof...(I)>({I...})) {
size_t is_na_offset = kb.size() - self_offset;
kb(kernel_request_single, nullptr, nullptr, 1, src_arrmeta + i);
kb.get_at<forward_na_kernel<I...>>(self_offset)->is_na_offset[i] = is_na_offset;
}
size_t assign_na_offset = kb.size() - self_offset;
kb(kernel_request_single, nullptr, nullptr, 0, nullptr);
kb.get_at<forward_na_kernel<I...>>(self_offset)->assign_na_offset = assign_na_offset;
});
ndt::type src_value_tp[2];
for (intptr_t i = 0; i < 2; ++i) {
src_value_tp[i] = src_tp[i];
}
for (intptr_t i : std::array<index_t, sizeof...(I)>({I...})) {
src_value_tp[i] = src_value_tp[i].extended<ndt::option_type>()->get_value_type();
}
base_callable *child;
if (m_child.is_null()) {
child = caller;
} else {
child = m_child.get();
}
ndt::type res_value_tp =
child->resolve(this, nullptr, cg, dst_tp.is_symbolic() ? child->get_ret_type() : dst_tp, 2, src_value_tp,
nkwd, kwds, tp_vars);
for (index_t i : std::array<index_t, sizeof...(I)>({I...})) {
is_na->resolve(this, nullptr, cg, ndt::make_type<bool>(), 1, src_tp + i, 0, nullptr, tp_vars);
}
return assign_na->resolve(this, nullptr, cg, ndt::make_type<ndt::option_type>(res_value_tp), 0, nullptr, nkwd,
kwds, tp_vars);
}
void subresolve(call_graph &cg, const char *data) {
std::array<bool, N> arg_broadcast = reinterpret_cast<const node_type *>(data)->arg_broadcast;
std::array<bool, N> arg_var = reinterpret_cast<const node_type *>(data)->arg_var;
intptr_t res_alignment = reinterpret_cast<const node_type *>(data)->res_alignment;
cg.emplace_back([arg_broadcast, arg_var, res_alignment](
kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta,
size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) {
const ndt::var_dim_type::metadata_type *dst_md =
reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta);
std::array<const char *, N> child_src_arrmeta;
std::array<intptr_t, N> src_stride;
std::array<intptr_t, N> src_offset;
std::array<intptr_t, N> src_size;
for (size_t i = 0; i < N; ++i) {
if (arg_var[i]) {
const ndt::var_dim_type::metadata_type *src_md =
reinterpret_cast<const ndt::var_dim_type::metadata_type *>(src_arrmeta[i]);
src_stride[i] = src_md->stride;
src_offset[i] = src_md->offset;
child_src_arrmeta[i] = src_arrmeta[i] + sizeof(ndt::var_dim_type::metadata_type);
// src_size[i] = -1;
} else {
if (arg_broadcast[i]) {
src_stride[i] = 0;
src_offset[i] = 0;
child_src_arrmeta[i] = src_arrmeta[i];
src_size[i] = 1;
} else {
src_offset[i] = 0;
src_stride[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->stride;
src_size[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->dim_size;
}
}
}
kb.emplace_back<elwise_kernel<var_dim_id, fixed_dim_id, TraitsType, N>>(
kernreq, dst_md->blockref.get(), res_alignment, dst_md->stride, dst_md->offset, src_stride.data(),
src_offset.data(), src_size.data(), arg_var.data());
kb(kernel_request_strided, nullptr, dst_arrmeta + sizeof(ndt::var_dim_type::metadata_type), N,
child_src_arrmeta.data());
});
}
ndt::type resolve(base_callable *caller, char *data, call_graph &cg, const ndt::type &dst_tp,
size_t DYND_UNUSED(nsrc), const ndt::type *src_tp, size_t nkwd, const array *kwds,
const std::map<std::string, ndt::type> &tp_vars) {
base_callable *child = reinterpret_cast<data_type *>(data)->child;
size_t &i = reinterpret_cast<data_type *>(data)->i;
cg.emplace_back([i](kernel_builder &kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta,
size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) {
kb.emplace_back<outer_kernel<NArg>>(kernreq, i, dst_arrmeta, src_arrmeta);
const char *src_element_arrmeta[NArg];
for (size_t j = 0; j < i; ++j) {
src_element_arrmeta[j] = src_arrmeta[j];
}
src_element_arrmeta[i] = src_arrmeta[i] + sizeof(size_stride_t);
for (size_t j = i + 1; j < NArg; ++j) {
src_element_arrmeta[j] = src_arrmeta[j];
}
kb(kernel_request_strided, data, dst_arrmeta + sizeof(size_stride_t), NArg, src_element_arrmeta);
});
ndt::type arg_element_tp[NArg];
for (size_t j = 0; j < i; ++j) {
arg_element_tp[j] = src_tp[j];
}
arg_element_tp[i] = src_tp[i].extended<ndt::base_dim_type>()->get_element_type();
for (size_t j = i + 1; j < NArg; ++j) {
arg_element_tp[j] = src_tp[j];
}
size_t j = i;
while (i < NArg && arg_element_tp[i].is_scalar()) {
++i;
}
ndt::type ret_element_tp;
if (i < NArg) {
ret_element_tp = caller->resolve(this, data, cg, dst_tp, NArg, arg_element_tp, nkwd, kwds, tp_vars);
} else {
ret_element_tp =
child->resolve(this, nullptr, cg, child->get_ret_type(), NArg, arg_element_tp, nkwd, kwds, tp_vars);
}
return src_tp[j].extended<ndt::base_dim_type>()->with_element_type(ret_element_tp);
}
void subresolve(call_graph &cg, const char *data) {
bool res_broadcast = reinterpret_cast<const data_type *>(data)->res_ignore;
const std::array<bool, N> &arg_broadcast = reinterpret_cast<const data_type *>(data)->arg_broadcast;
cg.emplace_back([res_broadcast, arg_broadcast](kernel_builder &kb, kernel_request_t kernreq, char *data,
const char *dst_arrmeta, size_t DYND_UNUSED(nsrc),
const char *const *src_arrmeta) {
size_t size;
if (res_broadcast) {
size = reinterpret_cast<const size_stride_t *>(src_arrmeta[0])->dim_size;
} else {
size = reinterpret_cast<const size_stride_t *>(dst_arrmeta)->dim_size;
}
intptr_t dst_stride;
const char *child_dst_arrmeta;
if (res_broadcast) {
dst_stride = 0;
child_dst_arrmeta = dst_arrmeta;
} else {
dst_stride = reinterpret_cast<const size_stride_t *>(dst_arrmeta)->stride;
child_dst_arrmeta = dst_arrmeta + sizeof(size_stride_t);
}
std::array<intptr_t, N> src_stride;
std::array<const char *, N> child_src_arrmeta;
for (size_t i = 0; i < N; ++i) {
if (arg_broadcast[i]) {
src_stride[i] = 0;
child_src_arrmeta[i] = src_arrmeta[i];
} else {
src_stride[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->stride;
child_src_arrmeta[i] = src_arrmeta[i] + sizeof(size_stride_t);
}
}
kb.emplace_back<elwise_kernel<fixed_dim_id, fixed_dim_id, TraitsType, N>>(kernreq, data, size, dst_stride,
src_stride.data());
kb(kernel_request_strided, TraitsType::child_data(data), child_dst_arrmeta, N, child_src_arrmeta.data());
});
}
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg,
const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *src_tp,
size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds),
const std::map<std::string, ndt::type> &tp_vars) {
const ndt::type &src0_element_tp = src_tp[0].extended<ndt::fixed_dim_type>()->get_element_type();
size_t src0_element_data_size = src0_element_tp.get_data_size();
cg.emplace_back([src0_element_data_size](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data),
const char *DYND_UNUSED(dst_arrmeta), size_t DYND_UNUSED(nsrc),
const char *const *src_arrmeta) {
kb.emplace_back<sort_kernel>(
kernreq, reinterpret_cast<const fixed_dim_type_arrmeta *>(src_arrmeta[0])->dim_size,
reinterpret_cast<const fixed_dim_type_arrmeta *>(src_arrmeta[0])->stride, src0_element_data_size);
kb(kernel_request_single, nullptr, nullptr, 2, nullptr);
});
const ndt::type child_src_tp[2] = {src0_element_tp, src0_element_tp};
less->resolve(this, nullptr, cg, ndt::make_type<bool1>(), 2, child_src_tp, 0, nullptr, tp_vars);
return dst_tp;
}
