forked from M-Labs/nac3
core/ndstrides: add basic NDArray IRRT functions
This commit is contained in:
parent
f78a60a644
commit
04897ec8d4
|
@ -0,0 +1,305 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <irrt/error_context.hpp>
|
||||||
|
#include <irrt/int_defs.hpp>
|
||||||
|
#include <irrt/ndarray/def.hpp>
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
namespace ndarray {
|
||||||
|
namespace basic {
|
||||||
|
namespace util {
|
||||||
|
/**
|
||||||
|
* @brief Asserts that `shape` does not contain negative dimensions.
|
||||||
|
*
|
||||||
|
* @param ndims Number of dimensions in `shape`
|
||||||
|
* @param shape The shape to check on
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void assert_shape_no_negative(ErrorContext* errctx, SizeT ndims,
|
||||||
|
const SizeT* shape) {
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++) {
|
||||||
|
if (shape[axis] < 0) {
|
||||||
|
errctx->set_error(errctx->error_ids->value_error,
|
||||||
|
"negative dimensions are not allowed; axis {0} "
|
||||||
|
"has dimension {1}",
|
||||||
|
axis, shape[axis]);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Returns the number of elements of an ndarray given its shape.
|
||||||
|
*
|
||||||
|
* @param ndims Number of dimensions in `shape`
|
||||||
|
* @param shape The shape of the ndarray
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
SizeT calc_size_from_shape(SizeT ndims, const SizeT* shape) {
|
||||||
|
SizeT size = 1;
|
||||||
|
for (SizeT axis = 0; axis < ndims; axis++) size *= shape[axis];
|
||||||
|
return size;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Compute the array indices of the `nth` (0-based) element of an ndarray given only its shape.
|
||||||
|
*
|
||||||
|
* @param ndims Number of elements in `shape` and `indices`
|
||||||
|
* @param shape The shape of the ndarray
|
||||||
|
* @param indices The returned indices indexing the ndarray with shape `shape`.
|
||||||
|
* @param nth The index of the element of interest.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void set_indices_by_nth(SizeT ndims, const SizeT* shape, SizeT* indices,
|
||||||
|
SizeT nth) {
|
||||||
|
for (int32_t i = 0; i < ndims; i++) {
|
||||||
|
int32_t axis = ndims - i - 1;
|
||||||
|
int32_t dim = shape[axis];
|
||||||
|
|
||||||
|
indices[axis] = nth % dim;
|
||||||
|
nth /= dim;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} // namespace util
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the number of elements of an `ndarray`
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.size`
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
SizeT size(const NDArray<SizeT>* ndarray) {
|
||||||
|
return util::calc_size_from_shape(ndarray->ndims, ndarray->shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return of the number of its content of an `ndarray`.
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.nbytes`.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
SizeT nbytes(const NDArray<SizeT>* ndarray) {
|
||||||
|
return size(ndarray) * ndarray->itemsize;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Update the strides of an ndarray given an ndarray `shape`
|
||||||
|
* and assuming that the ndarray is fully c-contagious.
|
||||||
|
*
|
||||||
|
* You might want to read https://ajcr.net/stride-guide-part-1/.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void set_strides_by_shape(NDArray<SizeT>* ndarray) {
|
||||||
|
SizeT stride_product = 1;
|
||||||
|
for (SizeT i = 0; i < ndarray->ndims; i++) {
|
||||||
|
int axis = ndarray->ndims - i - 1;
|
||||||
|
ndarray->strides[axis] = stride_product * ndarray->itemsize;
|
||||||
|
stride_product *= ndarray->shape[axis];
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the pointer to the element indexed by `indices`.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
uint8_t* get_pelement_by_indices(const NDArray<SizeT>* ndarray,
|
||||||
|
const SizeT* indices) {
|
||||||
|
uint8_t* element = ndarray->data;
|
||||||
|
for (SizeT dim_i = 0; dim_i < ndarray->ndims; dim_i++)
|
||||||
|
element += indices[dim_i] * ndarray->strides[dim_i];
|
||||||
|
return element;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return the pointer to the nth (0-based) element in a flattened view of `ndarray`.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
uint8_t* get_nth_pelement(const NDArray<SizeT>* ndarray, SizeT nth) {
|
||||||
|
SizeT* indices = (SizeT*)__builtin_alloca(sizeof(SizeT) * ndarray->ndims);
|
||||||
|
util::set_indices_by_nth(ndarray->ndims, ndarray->shape, indices, nth);
|
||||||
|
return get_pelement_by_indices(ndarray, indices);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Like `get_nth_pelement` but asserts that `nth` is in bounds.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
uint8_t* checked_get_nth_pelement(ErrorContext* errctx,
|
||||||
|
const NDArray<SizeT>* ndarray, SizeT nth) {
|
||||||
|
SizeT arr_size = ndarray->size();
|
||||||
|
if (!(0 <= nth && nth < arr_size)) {
|
||||||
|
errctx->set_error(
|
||||||
|
errctx->error_ids->index_error,
|
||||||
|
"index {0} is out of bounds, valid range is {1} <= index < {2}",
|
||||||
|
nth, 0, arr_size);
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
return get_nth_pelement(ndarray, nth);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Set an element in `ndarray`.
|
||||||
|
*
|
||||||
|
* @param pelement Pointer to the element in `ndarray` to be set.
|
||||||
|
* @param pvalue Pointer to the value `pelement` will be set to.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void set_pelement_value(NDArray<SizeT>* ndarray, uint8_t* pelement,
|
||||||
|
const uint8_t* pvalue) {
|
||||||
|
__builtin_memcpy(pelement, pvalue, ndarray->itemsize);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Get the `len()` of an ndarray, and asserts that `ndarray` is a sized object.
|
||||||
|
*
|
||||||
|
* This function corresponds to `<an_ndarray>.__len__`.
|
||||||
|
*
|
||||||
|
* @param dst_length The returned result
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void len(ErrorContext* errctx, const NDArray<SizeT>* ndarray,
|
||||||
|
SliceIndex* dst_length) {
|
||||||
|
// numpy prohibits `__len__` on unsized objects
|
||||||
|
if (ndarray->ndims == 0) {
|
||||||
|
errctx->set_error(errctx->error_ids->type_error,
|
||||||
|
"len() of unsized object");
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
*dst_length = (SliceIndex)ndarray->shape[0];
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Copy data from one ndarray to another of the exact same size and itemsize.
|
||||||
|
*
|
||||||
|
* Both ndarrays will be viewed in their flatten views when copying the elements.
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
void copy_data(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
|
||||||
|
__builtin_assume(src_ndarray->itemsize == dst_ndarray->itemsize);
|
||||||
|
|
||||||
|
for (SizeT i = 0; i < size(src_ndarray); i++) {
|
||||||
|
auto src_element = ndarray::basic::get_nth_pelement(src_ndarray, i);
|
||||||
|
auto dst_element = ndarray::basic::get_nth_pelement(dst_ndarray, i);
|
||||||
|
ndarray::basic::set_pelement_value(dst_ndarray, dst_element,
|
||||||
|
src_element);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Return a boolean indicating if `ndarray` is (C-)contiguous.
|
||||||
|
*
|
||||||
|
* You may want to see: ndarray's rules for C-contiguity: https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
|
||||||
|
*/
|
||||||
|
template <typename SizeT>
|
||||||
|
bool is_c_contiguous(const NDArray<SizeT>* ndarray) {
|
||||||
|
// Other references:
|
||||||
|
// - tinynumpy's implementation: https://github.com/wadetb/tinynumpy/blob/0d23d22e07062ffab2afa287374c7b366eebdda1/tinynumpy/tinynumpy.py#L102
|
||||||
|
// - ndarray's flags["C_CONTIGUOUS"]: https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags
|
||||||
|
// - ndarray's rules for C-contiguity: https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45
|
||||||
|
|
||||||
|
// From https://github.com/numpy/numpy/blob/df256d0d2f3bc6833699529824781c58f9c6e697/numpy/core/src/multiarray/flagsobject.c#L95C1-L99C45:
|
||||||
|
//
|
||||||
|
// The traditional rule is that for an array to be flagged as C contiguous,
|
||||||
|
// the following must hold:
|
||||||
|
//
|
||||||
|
// strides[-1] == itemsize
|
||||||
|
// strides[i] == shape[i+1] * strides[i + 1]
|
||||||
|
// [...]
|
||||||
|
// According to these rules, a 0- or 1-dimensional array is either both
|
||||||
|
// C- and F-contiguous, or neither; and an array with 2+ dimensions
|
||||||
|
// can be C- or F- contiguous, or neither, but not both. Though there
|
||||||
|
// there are exceptions for arrays with zero or one item, in the first
|
||||||
|
// case the check is relaxed up to and including the first dimension
|
||||||
|
// with shape[i] == 0. In the second case `strides == itemsize` will
|
||||||
|
// can be true for all dimensions and both flags are set.
|
||||||
|
|
||||||
|
if (ndarray->ndims == 0) {
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ndarray->strides[ndarray->ndims - 1] != ndarray->itemsize) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
for (SizeT i = 1; i < ndarray->ndims; i++) {
|
||||||
|
SizeT axis_i = ndarray->ndims - i - 1;
|
||||||
|
if (ndarray->strides[axis_i] !=
|
||||||
|
ndarray->shape[axis_i + 1] + ndarray->strides[axis_i + 1]) {
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
} // namespace basic
|
||||||
|
} // namespace ndarray
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
extern "C" {
|
||||||
|
using namespace ndarray::basic;
|
||||||
|
|
||||||
|
uint32_t __nac3_ndarray_size(NDArray<int32_t>* ndarray) {
|
||||||
|
return size(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t __nac3_ndarray_size64(NDArray<int64_t>* ndarray) {
|
||||||
|
return size(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t __nac3_ndarray_nbytes(NDArray<int32_t>* ndarray) {
|
||||||
|
return nbytes(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint64_t __nac3_ndarray_nbytes64(NDArray<int64_t>* ndarray) {
|
||||||
|
return nbytes(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_len(ErrorContext* errctx, NDArray<int32_t>* ndarray,
|
||||||
|
SliceIndex* dst_len) {
|
||||||
|
return len(errctx, ndarray, dst_len);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_len64(ErrorContext* errctx, NDArray<int64_t>* ndarray,
|
||||||
|
SliceIndex* dst_len) {
|
||||||
|
return len(errctx, ndarray, dst_len);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_shape_no_negative(ErrorContext* errctx,
|
||||||
|
int32_t ndims,
|
||||||
|
int32_t* shape) {
|
||||||
|
util::assert_shape_no_negative(errctx, ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_util_assert_shape_no_negative64(ErrorContext* errctx,
|
||||||
|
int64_t ndims,
|
||||||
|
int64_t* shape) {
|
||||||
|
util::assert_shape_no_negative(errctx, ndims, shape);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_set_strides_by_shape(NDArray<int32_t>* ndarray) {
|
||||||
|
set_strides_by_shape(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_set_strides_by_shape64(NDArray<int64_t>* ndarray) {
|
||||||
|
set_strides_by_shape(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_ndarray_is_c_contiguous(NDArray<int32_t>* ndarray) {
|
||||||
|
return is_c_contiguous(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
bool __nac3_ndarray_is_c_contiguous64(NDArray<int64_t>* ndarray) {
|
||||||
|
return is_c_contiguous(ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_copy_data(NDArray<int32_t>* src_ndarray,
|
||||||
|
NDArray<int32_t>* dst_ndarray) {
|
||||||
|
copy_data(src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
|
||||||
|
void __nac3_ndarray_copy_data64(NDArray<int64_t>* src_ndarray,
|
||||||
|
NDArray<int64_t>* dst_ndarray) {
|
||||||
|
copy_data(src_ndarray, dst_ndarray);
|
||||||
|
}
|
||||||
|
}
|
|
@ -4,5 +4,6 @@
|
||||||
#include <irrt/core.hpp>
|
#include <irrt/core.hpp>
|
||||||
#include <irrt/error_context.hpp>
|
#include <irrt/error_context.hpp>
|
||||||
#include <irrt/int_defs.hpp>
|
#include <irrt/int_defs.hpp>
|
||||||
|
#include <irrt/ndarray/basic.hpp>
|
||||||
#include <irrt/ndarray/def.hpp>
|
#include <irrt/ndarray/def.hpp>
|
||||||
#include <irrt/utils.hpp>
|
#include <irrt/utils.hpp>
|
|
@ -5,8 +5,10 @@
|
||||||
#include <cstdio>
|
#include <cstdio>
|
||||||
#include <cstdlib>
|
#include <cstdlib>
|
||||||
#include <test/test_core.hpp>
|
#include <test/test_core.hpp>
|
||||||
|
#include <test/test_ndarray_basic.hpp>
|
||||||
|
|
||||||
int main() {
|
int main() {
|
||||||
test::core::run();
|
test::core::run();
|
||||||
|
test::ndarray_basic::run();
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
|
@ -0,0 +1,30 @@
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include <test/includes.hpp>
|
||||||
|
|
||||||
|
namespace test {
|
||||||
|
namespace ndarray_basic {
|
||||||
|
void test_calc_size_from_shape_normal() {
|
||||||
|
// Test shapes with normal values
|
||||||
|
BEGIN_TEST();
|
||||||
|
|
||||||
|
int32_t shape[4] = {2, 3, 5, 7};
|
||||||
|
assert_values_match(
|
||||||
|
210, ndarray::basic::util::calc_size_from_shape<int32_t>(4, shape));
|
||||||
|
}
|
||||||
|
|
||||||
|
void test_calc_size_from_shape_has_zero() {
|
||||||
|
// Test shapes with 0 in them
|
||||||
|
BEGIN_TEST();
|
||||||
|
|
||||||
|
int32_t shape[4] = {2, 0, 5, 7};
|
||||||
|
assert_values_match(
|
||||||
|
0, ndarray::basic::util::calc_size_from_shape<int32_t>(4, shape));
|
||||||
|
}
|
||||||
|
|
||||||
|
void run() {
|
||||||
|
test_calc_size_from_shape_normal();
|
||||||
|
test_calc_size_from_shape_has_zero();
|
||||||
|
}
|
||||||
|
} // namespace ndarray_basic
|
||||||
|
} // namespace test
|
|
@ -1,6 +1,8 @@
|
||||||
use crate::typecheck::typedef::Type;
|
use crate::typecheck::typedef::Type;
|
||||||
|
|
||||||
mod error_context;
|
mod error_context;
|
||||||
|
pub mod ndarray;
|
||||||
|
pub mod slice;
|
||||||
mod test;
|
mod test;
|
||||||
mod util;
|
mod util;
|
||||||
|
|
||||||
|
|
|
@ -0,0 +1,93 @@
|
||||||
|
use crate::codegen::model::*;
|
||||||
|
use crate::codegen::util::array_writer::ArrayWriter;
|
||||||
|
use crate::codegen::{structs::ndarray::NpArray, CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
use super::basic::{
|
||||||
|
call_nac3_ndarray_nbytes, call_nac3_ndarray_set_strides_by_shape,
|
||||||
|
call_nac3_ndarray_util_assert_shape_no_negative,
|
||||||
|
};
|
||||||
|
|
||||||
|
/**
|
||||||
|
Allocate an ndarray on the stack given its `ndims`.
|
||||||
|
|
||||||
|
`shape` and `strides` will be automatically allocated on the stack.
|
||||||
|
|
||||||
|
The returned ndarray's content will be:
|
||||||
|
- `data`: `nullptr`
|
||||||
|
- `itemsize`: **uninitialized** value
|
||||||
|
- `ndims`: initialized value, set to the input `ndims`
|
||||||
|
- `shape`: initialized pointer to an allocated stack with **uninitialized** values
|
||||||
|
- `strides`: initialized pointer to an allocated stack with **uninitialized** values
|
||||||
|
*/
|
||||||
|
pub fn alloca_ndarray<'ctx, G>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndims: SizeT<'ctx>,
|
||||||
|
name: &str,
|
||||||
|
) -> Result<Pointer<'ctx, StructModel<NpArray<'ctx>>>, String>
|
||||||
|
where
|
||||||
|
G: CodeGenerator + ?Sized,
|
||||||
|
{
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
let ndarray_model = StructModel(NpArray { sizet });
|
||||||
|
let ndarray_data_model = PointerModel(NIntModel(Byte));
|
||||||
|
|
||||||
|
// Allocate ndarray
|
||||||
|
let ndarray_ptr = ndarray_model.alloca(ctx, name);
|
||||||
|
|
||||||
|
// Set data to nullptr
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.data).store(ctx, ndarray_data_model.nullptr(ctx.ctx));
|
||||||
|
|
||||||
|
// Set ndims
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.ndims).store(ctx, ndims);
|
||||||
|
|
||||||
|
// Allocate and set shape
|
||||||
|
let shape_array = sizet.array_alloca(ctx, ndims, "shape");
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.shape).store(ctx, shape_array.pointer);
|
||||||
|
|
||||||
|
// Allocate and set strides
|
||||||
|
let strides_array = sizet.array_alloca(ctx, ndims, "strides");
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.strides).store(ctx, strides_array.pointer);
|
||||||
|
|
||||||
|
Ok(ndarray_ptr)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Initialize an ndarray's `shape` and asserts on.
|
||||||
|
/// `shape`'s values and prohibit illegal inputs like negative dimensions.
|
||||||
|
pub fn init_ndarray_shape<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
shape_writer: &ArrayWriter<'ctx, G, SizeTModel<'ctx>, SizeTModel<'ctx>>,
|
||||||
|
) -> Result<(), String> {
|
||||||
|
(shape_writer.write)(generator, ctx, &ndarray_ptr.shape_slice(ctx))?;
|
||||||
|
|
||||||
|
call_nac3_ndarray_util_assert_shape_no_negative(
|
||||||
|
generator,
|
||||||
|
ctx,
|
||||||
|
shape_writer.count,
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.shape).load(ctx, "shape"),
|
||||||
|
);
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Initialize an ndarray's `data` by allocating a buffer on the stack.
|
||||||
|
/// The allocated data buffer is considered to be *owned* by the ndarray.
|
||||||
|
///
|
||||||
|
/// `strides` of the ndarray will also be updated with `set_strides_by_shape`.
|
||||||
|
///
|
||||||
|
/// `shape` and `itemsize` of the ndarray ***must*** be initialized first.
|
||||||
|
pub fn init_ndarray_data_by_alloca<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) {
|
||||||
|
let ndarray_nbytes = call_nac3_ndarray_nbytes(generator, ctx, ndarray_ptr); // Needs `itemsize` initialized
|
||||||
|
|
||||||
|
let data_array = NIntModel(Byte).array_alloca(ctx, ndarray_nbytes, "data");
|
||||||
|
ndarray_ptr.gep(ctx, |f| f.data).store(ctx, data_array.pointer);
|
||||||
|
|
||||||
|
call_nac3_ndarray_set_strides_by_shape(generator, ctx, ndarray_ptr);
|
||||||
|
}
|
|
@ -0,0 +1,117 @@
|
||||||
|
use crate::codegen::irrt::error_context::{check_error_context, setup_error_context};
|
||||||
|
use crate::codegen::irrt::slice::SliceIndex;
|
||||||
|
use crate::codegen::irrt::util::get_sized_dependent_function_name;
|
||||||
|
use crate::codegen::model::*;
|
||||||
|
use crate::codegen::{structs::ndarray::NpArray, CodeGenContext, CodeGenerator};
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) -> SizeT<'ctx> {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
FunctionBuilder::begin(ctx, &get_sized_dependent_function_name(sizet, "__nac3_ndarray_size"))
|
||||||
|
.arg("ndarray", ndarray_ptr)
|
||||||
|
.returning("size", sizet)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) -> SizeT<'ctx> {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
FunctionBuilder::begin(ctx, &get_sized_dependent_function_name(sizet, "__nac3_ndarray_nbytes"))
|
||||||
|
.arg("ndarray", ndarray_ptr)
|
||||||
|
.returning("nbytes", sizet)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) -> NInt<'ctx, SliceIndex> {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
let slice_index_model = NIntModel(SliceIndex::default());
|
||||||
|
|
||||||
|
let dst_len = slice_index_model.alloca(ctx, "dst_len");
|
||||||
|
|
||||||
|
let errctx = setup_error_context(ctx);
|
||||||
|
FunctionBuilder::begin(ctx, &get_sized_dependent_function_name(sizet, "__nac3_ndarray_len"))
|
||||||
|
.arg("errctx", errctx)
|
||||||
|
.arg("ndarray", ndarray_ptr)
|
||||||
|
.arg("dst_len", dst_len)
|
||||||
|
.returning_void();
|
||||||
|
check_error_context(generator, ctx, errctx);
|
||||||
|
|
||||||
|
dst_len.load(ctx, "len")
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndims: SizeT<'ctx>,
|
||||||
|
shape_ptr: Pointer<'ctx, SizeTModel<'ctx>>,
|
||||||
|
) {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
let errctx = setup_error_context(ctx);
|
||||||
|
FunctionBuilder::begin(
|
||||||
|
ctx,
|
||||||
|
&get_sized_dependent_function_name(sizet, "__nac3_ndarray_util_assert_shape_no_negative"),
|
||||||
|
)
|
||||||
|
.arg("errctx", errctx)
|
||||||
|
.arg("ndims", ndims)
|
||||||
|
.arg("shape", shape_ptr)
|
||||||
|
.returning_void();
|
||||||
|
check_error_context(generator, ctx, errctx);
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
FunctionBuilder::begin(
|
||||||
|
ctx,
|
||||||
|
&get_sized_dependent_function_name(sizet, "__nac3_ndarray_set_strides_by_shape"),
|
||||||
|
)
|
||||||
|
.arg("ndarray", ndarray_ptr)
|
||||||
|
.returning_void();
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
ndarray_ptr: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) -> NInt<'ctx, Bool> {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
FunctionBuilder::begin(
|
||||||
|
ctx,
|
||||||
|
&get_sized_dependent_function_name(sizet, "__nac3_ndarray_is_c_contiguous"),
|
||||||
|
)
|
||||||
|
.arg("ndarray", ndarray_ptr)
|
||||||
|
.returning("is_c_contiguous", NIntModel(Bool))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
|
||||||
|
generator: &mut G,
|
||||||
|
ctx: &mut CodeGenContext<'ctx, '_>,
|
||||||
|
src_ndarray: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
dst_ndarray: Pointer<'ctx, StructModel<NpArray<'ctx>>>,
|
||||||
|
) -> NInt<'ctx, Bool> {
|
||||||
|
let sizet = generator.get_sizet(ctx.ctx);
|
||||||
|
|
||||||
|
FunctionBuilder::begin(
|
||||||
|
ctx,
|
||||||
|
&get_sized_dependent_function_name(sizet, "__nac3_ndarray_copy_data"),
|
||||||
|
)
|
||||||
|
.arg("src_ndarray", src_ndarray)
|
||||||
|
.arg("dst_ndarray", dst_ndarray)
|
||||||
|
.returning("is_c_contiguous", NIntModel(Bool))
|
||||||
|
}
|
|
@ -0,0 +1,2 @@
|
||||||
|
pub mod allocation;
|
||||||
|
pub mod basic;
|
|
@ -0,0 +1,3 @@
|
||||||
|
use crate::codegen::model::*;
|
||||||
|
|
||||||
|
pub type SliceIndex = Int32;
|
Loading…
Reference in New Issue