core/ndstrides: add basic ndarray IRRT functions

nac3core/irrt/irrt/ndarray/basic.hpp

@@ -0,0 +1,306 @@
+#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_exception(
+                errctx->exceptions->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_exception(
+            errctx->exceptions->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_exception(errctx->exceptions->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);
+}
+}

nac3core/irrt/irrt_everything.hpp

@@ -4,5 +4,6 @@
 #include <irrt/core.hpp>
 #include <irrt/error_context.hpp>
 #include <irrt/int_defs.hpp>
+#include <irrt/ndarray/basic.hpp>
 #include <irrt/ndarray/def.hpp>
 #include <irrt/utils.hpp>

nac3core/irrt/irrt_test.cpp

@@ -5,8 +5,10 @@
 #include <cstdio>
 #include <cstdlib>
 #include <test/test_core.hpp>
+#include <test/test_ndarray_basic.hpp>
 
 int main() {
     test::core::run();
+    test::ndarray_basic::run();
     return 0;
 }

nac3core/irrt/test/test_ndarray_basic.hpp

@@ -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

nac3core/src/codegen/irrt/mod.rs

@@ -1,6 +1,8 @@
 use crate::typecheck::typedef::Type;
 
 pub mod error_context;
+pub mod ndarray;
+pub mod slice;
 mod test;
 mod util;
 

nac3core/src/codegen/irrt/ndarray/allocation.rs

@@ -0,0 +1,83 @@
+use crate::codegen::model::*;
+use crate::codegen::util::array_writer::ArrayWriter;
+use crate::codegen::{structure::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: Int<'ctx, SizeT>,
+    name: &str,
+) -> Result<Ptr<'ctx, StructModel<NpArray>>, String>
+where
+    G: CodeGenerator + ?Sized,
+{
+    let tyctx = generator.type_context(ctx.ctx);
+
+    let sizet_model = IntModel(SizeT);
+    let ndarray_model = StructModel(NpArray);
+    let ndarray_data_model = PtrModel(IntModel(Byte));
+
+    // Setup ndarray
+    let ndarray_ptr = ndarray_model.alloca(tyctx, ctx, name);
+    let shape = sizet_model.array_alloca(tyctx, ctx, ndims.value, "shape");
+    let strides = sizet_model.array_alloca(tyctx, ctx, ndims.value, "strides");
+
+    ndarray_ptr.gep(ctx, |f| f.data).store(ctx, ndarray_data_model.nullptr(tyctx, ctx.ctx));
+    ndarray_ptr.gep(ctx, |f| f.ndims).store(ctx, ndims);
+    ndarray_ptr.gep(ctx, |f| f.shape).store(ctx, shape);
+    ndarray_ptr.gep(ctx, |f| f.strides).store(ctx, strides);
+
+    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, '_>,
+    pndarray: Ptr<'ctx, StructModel<NpArray>>,
+    shape_writer: &ArrayWriter<'ctx, G, SizeT, IntModel<SizeT>>,
+) -> Result<(), String> {
+    let tyctx = generator.type_context(ctx.ctx);
+    let shape = pndarray.gep(ctx, |f| f.shape).load(tyctx, ctx, "shape");
+    (shape_writer.write)(generator, ctx, shape)?;
+    call_nac3_ndarray_util_assert_shape_no_negative(generator, ctx, shape_writer.len, 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, '_>,
+    pndarray: Ptr<'ctx, StructModel<NpArray>>,
+) {
+    let tyctx = generator.type_context(ctx.ctx);
+    let ndarray_data_model = IntModel(Byte);
+
+    let nbytes = call_nac3_ndarray_nbytes(generator, ctx, pndarray);
+    let data = ndarray_data_model.array_alloca(tyctx, ctx, nbytes.value, "data");
+    pndarray.gep(ctx, |f| f.data).store(ctx, data);
+    call_nac3_ndarray_set_strides_by_shape(generator, ctx, pndarray);
+}

nac3core/src/codegen/irrt/ndarray/basic.rs

@@ -0,0 +1,135 @@
+use crate::codegen::irrt::error_context::{check_error_context, setup_error_context};
+use crate::codegen::irrt::slice::SliceIndex;
+use crate::codegen::irrt::util::function::CallFunction;
+use crate::codegen::irrt::util::get_sizet_dependent_function_name;
+use crate::codegen::model::*;
+use crate::codegen::structure::ndarray::NpArray;
+use crate::codegen::{CodeGenContext, CodeGenerator};
+
+pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray_ptr: Ptr<'ctx, StructModel<NpArray>>,
+) -> Int<'ctx, SizeT> {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__nac3_ndarray_size"),
+    )
+    .arg("ndarray", ndarray_ptr)
+    .returning("size")
+}
+
+pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray_ptr: Ptr<'ctx, StructModel<NpArray>>,
+) -> Int<'ctx, SizeT> {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__nac3_ndarray_nbytes"),
+    )
+    .arg("ndarray", ndarray_ptr)
+    .returning("nbytes")
+}
+
+pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndarray_ptr: Ptr<'ctx, StructModel<NpArray>>,
+) -> Int<'ctx, SliceIndex> {
+    let tyctx = generator.type_context(ctx.ctx);
+    let slice_index_model = IntModel(SliceIndex::default());
+
+    let dst_len = slice_index_model.alloca(tyctx, ctx, "dst_len");
+
+    let errctx = setup_error_context(tyctx, ctx);
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__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(tyctx, ctx, "len")
+}
+
+pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    ndims: Int<'ctx, SizeT>,
+    shape: Ptr<'ctx, IntModel<SizeT>>,
+) {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    let errctx = setup_error_context(tyctx, ctx);
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__nac3_ndarray_util_assert_shape_no_negative"),
+    )
+    .arg("errctx", errctx)
+    .arg("ndims", ndims)
+    .arg("shape", shape)
+    .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: Ptr<'ctx, StructModel<NpArray>>,
+) {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__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: Ptr<'ctx, StructModel<NpArray>>,
+) -> Int<'ctx, Bool> {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__nac3_ndarray_is_c_contiguous"),
+    )
+    .arg("ndarray", ndarray_ptr)
+    .returning("is_c_contiguous")
+}
+
+pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    src_ndarray: Ptr<'ctx, StructModel<NpArray>>,
+    dst_ndarray: Ptr<'ctx, StructModel<NpArray>>,
+) -> Int<'ctx, Bool> {
+    let tyctx = generator.type_context(ctx.ctx);
+
+    CallFunction::begin(
+        tyctx,
+        ctx,
+        &get_sizet_dependent_function_name(tyctx, "__nac3_ndarray_copy_data"),
+    )
+    .arg("src_ndarray", src_ndarray)
+    .arg("dst_ndarray", dst_ndarray)
+    .returning("is_c_contiguous")
+}

nac3core/src/codegen/irrt/ndarray/mod.rs

@@ -0,0 +1,2 @@
+pub mod allocation;
+pub mod basic;

nac3core/src/codegen/irrt/slice.rs

@@ -0,0 +1,3 @@
+use crate::codegen::model::*;
+
+pub type SliceIndex = Int32;