ndarray.h Source File

ndarray.h Source File#

Runtime Library: ndarray.h Source File
Runtime Library v0.30
Mobilint SDK qb
// Copyright ⓒ 2019- Mobilint Inc. All rights reserved.
 
#ifndef MACCEL_NDARRAY_H_
#define MACCEL_NDARRAY_H_
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <numeric>
#include <utility>
#include <vector>
 
#include "maccel/export.h"
#include "maccel/status_code.h"
#include "maccel/type.h"
 
namespace mobilint {
namespace internal {
 
inline int64_t numel(const std::vector<int64_t>& shape) {
    return std::accumulate(shape.begin(), shape.end(), INT64_C(1), std::multiplies<>());
}
class MACCEL_EXPORT NDArrayData {
public:
    NDArrayData() = default;
    NDArrayData(int64_t bytesize, StatusCode& sc);
    explicit NDArrayData(std::shared_ptr<void> data)
        : mData(std::move(data)), mRawPtr(mData.get()) {}
    explicit NDArrayData(void* ptr) : mData{nullptr}, mRawPtr{ptr} {};
 
    NDArrayData(const NDArrayData& other) = default;
    NDArrayData(NDArrayData&& other) noexcept = default;
    NDArrayData& operator=(const NDArrayData& other);
    NDArrayData& operator=(NDArrayData&& other) noexcept = default;
 
    void* data() const { return mRawPtr; }
 
private:
    std::shared_ptr<void> mData = nullptr;  // Owned data
    void* mRawPtr = nullptr;                // A raw pointer, which is not owned
};
 
}  // namespace internal
template <typename T>
class NDArray {
public:
    using value_type = T;
    NDArray() = default;
    NDArray(const std::vector<int64_t>& shape, StatusCode& sc)
        : mSize(internal::numel(shape)), mData(sizeof(T) * mSize, sc), mShape(shape) {}
    NDArray(T* ptr, const std::vector<int64_t>& shape)
        : mSize(internal::numel(shape)), mData(ptr), mShape(shape) {}
    NDArray(T* ptr, const std::vector<int64_t>& shape, bool owner)
        : NDArray(ptr, shape) {}
    NDArray(std::shared_ptr<void> data, const std::vector<int64_t>& shape)
        : mSize(internal::numel(shape)), mData(std::move(data)), mShape(shape) {}
    T* data() const { return reinterpret_cast<T*>(mData.data()); }
    const std::vector<int64_t>& shape() const { return mShape; }
    std::size_t ndim() const { return mShape.size(); }
    int64_t size() const { return mSize; }
    T* begin() { return data(); }
    T* end() { return data() + mSize; }
    const T* begin() const { return data(); }
    const T* end() const { return data() + mSize; }
    T& operator[](size_t idx) { return data()[idx]; }
    T operator[](size_t idx) const { return data()[idx]; }
 
private:
    int64_t mSize = 0;
    internal::NDArrayData mData;
    std::vector<int64_t> mShape;
};
 
}  // namespace mobilint
 
#endif  // MACCEL_NDARRAY_H_