/*

* Copyright ironArray SL 2021.

*

* All rights reserved.

*

* This software is the confidential and proprietary information of ironArray SL

* ("Confidential Information"). You shall not disclose such Confidential

* Information and shall use it only in accordance with the terms of the license agreement.

*

*/

#include "iarray_private.h"

#include <libiarray/iarray.h>

#include "iarray_constructor.h"

INA_API(ina_rc_t) iarray_container_dtshape_equal(iarray_dtshape_t *a, iarray_dtshape_t *b)

{

if (a->dtype != b->dtype) {

IARRAY_TRACE1(iarray.error, "The data types are not equal");

return INA_ERROR(IARRAY_ERR_INVALID_DTYPE);

}

if (a->ndim != b->ndim) {

IARRAY_TRACE1(iarray.error, "The dimensions are not equal");

return INA_ERROR(IARRAY_ERR_INVALID_NDIM);

}

for (int i = 0; i < CATERVA_MAX_DIM; ++i) {

if (a->shape[i] != b->shape[i]) {

IARRAY_TRACE1(iarray.error, "The shapes are not equal\n");

return INA_ERROR(IARRAY_ERR_INVALID_SHAPE);

}

}

return INA_SUCCESS;

}

ina_rc_t

iarray_container_new(iarray_context_t *ctx, iarray_dtshape_t *dtshape, iarray_storage_t *storage,

iarray_container_t **container)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(dtshape);

INA_VERIFY_NOT_NULL(storage);

INA_VERIFY_NOT_NULL(container);

return _iarray_container_new(ctx, dtshape, storage, container);

}

INA_API(ina_rc_t) iarray_container_save(iarray_context_t *ctx,

iarray_container_t *container,

char *urlpath) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

INA_VERIFY_NOT_NULL(urlpath);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Container must be stored on a blosc schunk and must not be a "

"view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

if (container->catarr->sc->storage->urlpath != NULL) {

IARRAY_TRACE1(iarray.error, "Container is already on disk");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

} else {

blosc2_storage storage = {.cparams = NULL,

.dparams = NULL,

.contiguous = true,

.urlpath = urlpath};

blosc2_schunk *sc = blosc2_schunk_copy(container->catarr->sc, &storage);

blosc2_schunk_free(sc);

}

return INA_SUCCESS;

}

ina_rc_t _iarray_container_load(iarray_context_t *ctx, char *urlpath, bool contiguous,

iarray_container_t **container)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(urlpath);

INA_VERIFY_NOT_NULL(container);

if (access( urlpath, 0) == -1) {

IARRAY_TRACE1(iarray.error, "File not exists");

return INA_ERROR(INA_ERR_FILE_OPEN);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

blosc2_btune iabtune = {0};

btune_config iabtune_config = {0};

memcpy(&iabtune_config, &BTUNE_CONFIG_DEFAULTS, sizeof(btune_config));

switch(ctx->cfg->compression_favor) {

case IARRAY_COMPRESSION_FAVOR_CRATIO:

iabtune_config.comp_mode = BTUNE_COMP_HCR;

break;

case IARRAY_COMPRESSION_FAVOR_SPEED:

iabtune_config.comp_mode = BTUNE_COMP_HSP;

break;

default:

iabtune_config.comp_mode = BTUNE_COMP_BALANCED;

}

if (ctx->cfg->btune) {

iabtune.btune_config = &iabtune_config;

iabtune.btune_init = (void (*)(void *, blosc2_context*, blosc2_context*)) iabtune_init;

iabtune.btune_next_blocksize = iabtune_next_blocksize;

iabtune.btune_next_cparams = iabtune_next_cparams;

iabtune.btune_update = iabtune_update;

iabtune.btune_free = iabtune_free;

cfg.udbtune = &iabtune;

}

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

if (cat_ctx == NULL) {

IARRAY_TRACE1(iarray.error, "Error allocating the caterva context");

return INA_ERROR(IARRAY_ERR_CATERVA_FAILED);

}

caterva_array_t *catarr_aux;

IARRAY_ERR_CATERVA(caterva_open(cat_ctx, urlpath, &catarr_aux));

caterva_array_t *catarr;

// Create new caterva ctx from opened array.

caterva_ctx_free(&cat_ctx);

IARRAY_ERR_CATERVA(caterva_ctx_new(catarr_aux->cfg, &cat_ctx));

caterva_storage_t cat_storage = {0};

cat_storage.urlpath = NULL;

cat_storage.contiguous = catarr_aux->sc->storage->contiguous;

for (int i = 0; i < catarr_aux->ndim; ++i) {

cat_storage.chunkshape[i] = catarr_aux->chunkshape[i];

cat_storage.blockshape[i] = catarr_aux->blockshape[i];

}

if (contiguous) {

IARRAY_ERR_CATERVA(caterva_copy(cat_ctx, catarr_aux, &cat_storage, &catarr));

caterva_free(cat_ctx, &catarr_aux);

} else {

catarr = catarr_aux;

}

if (catarr == NULL) {

IARRAY_TRACE1(iarray.error, "Error creating the caterva array from a file");

return INA_ERROR(IARRAY_ERR_CATERVA_FAILED);

}

uint8_t *smeta;

int32_t smeta_len;

if (blosc2_meta_get(catarr->sc, "iarray", &smeta, &smeta_len) < 0) {

IARRAY_TRACE1(iarray.error, "Error getting a blosc metalayer");

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

iarray_data_type_t dtype;

if (_iarray_deserialize_meta(smeta, smeta_len, &dtype) != 0) {

IARRAY_TRACE1(iarray.error, "Error deserializing a sframe");

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

*container = (iarray_container_t*)ina_mem_alloc(sizeof(iarray_container_t));

(*container)->catarr = catarr;

// Build the dtshape

(*container)->dtshape = (iarray_dtshape_t*)ina_mem_alloc(sizeof(iarray_dtshape_t));

iarray_dtshape_t* dtshape = (*container)->dtshape;

dtshape->dtype = dtype;

IARRAY_RETURN_IF_FAILED(iarray_set_dtype_size(dtshape));

dtshape->ndim = (int8_t)catarr->ndim;

for (int i = 0; i < catarr->ndim; ++i) {

dtshape->shape[i] = catarr->shape[i];

}

// Build the auxshape

(*container)->auxshape = (iarray_auxshape_t*)ina_mem_alloc(sizeof(iarray_auxshape_t));

iarray_auxshape_t* auxshape = (*container)->auxshape;

for (int8_t i = 0; i < catarr->ndim; ++i) {

auxshape->index[i] = i;

auxshape->offset[i] = 0;

auxshape->shape_wos[i] = catarr->shape[i];

auxshape->chunkshape_wos[i] = catarr->chunkshape[i];

auxshape->blockshape_wos[i] = catarr->blockshape[i];

}

(*container)->storage = ina_mem_alloc(sizeof(iarray_storage_t));

if ((*container)->storage == NULL) {

IARRAY_TRACE1(iarray.error, "Error allocating the store parameter");

return INA_ERROR(INA_ERR_FAILED);

}

(*container)->storage->urlpath = urlpath;

(*container)->storage->contiguous = catarr->sc->storage->contiguous;

for (int i = 0; i < catarr->ndim; ++i) {

(*container)->storage->chunkshape[i] = catarr->chunkshape[i];

(*container)->storage->blockshape[i] = catarr->blockshape[i];

}

(*container)->container_viewed = NULL;

(*container)->transposed = false;

free(smeta);

caterva_ctx_free(&cat_ctx);

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_container_load(iarray_context_t *ctx, char *urlpath,

iarray_container_t **container)

{

return _iarray_container_load(ctx, urlpath, true, container);

}

INA_API(ina_rc_t) iarray_container_open(iarray_context_t *ctx,

char *urlpath,

iarray_container_t **container)

{

return _iarray_container_load(ctx, urlpath, false, container);

}

INA_API(ina_rc_t) iarray_container_remove(char *urlpath)

{

if (blosc2_remove_urlpath(urlpath) != 0) {

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_to_cframe(iarray_context_t *ctx,

iarray_container_t *src,

uint8_t **frame,

int64_t *frame_len,

bool *needs_free) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(frame);

INA_VERIFY_NOT_NULL(frame_len);

INA_VERIFY_NOT_NULL(src);

INA_VERIFY_NOT_NULL(needs_free);

*frame_len = blosc2_schunk_to_buffer(src->catarr->sc, frame, needs_free);

if (*frame_len <= 0) {

IARRAY_TRACE1(iarray.error, "iarray array can not be serialized");

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_from_cframe(iarray_context_t *ctx,

uint8_t *frame,

int64_t frame_len,

bool copy,

iarray_container_t **container) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(frame);

INA_VERIFY_NOT_NULL(container);

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

blosc2_btune iabtune = {0};

btune_config iabtune_config = {0};

memcpy(&iabtune_config, &BTUNE_CONFIG_DEFAULTS, sizeof(btune_config));

switch(ctx->cfg->compression_favor) {

case IARRAY_COMPRESSION_FAVOR_CRATIO:

iabtune_config.comp_mode = BTUNE_COMP_HCR;

break;

case IARRAY_COMPRESSION_FAVOR_SPEED:

iabtune_config.comp_mode = BTUNE_COMP_HSP;

break;

default:

iabtune_config.comp_mode = BTUNE_COMP_BALANCED;

}

if (ctx->cfg->btune) {

iabtune.btune_config = &iabtune_config;

iabtune.btune_init = (void (*)(void *, blosc2_context*, blosc2_context*)) iabtune_init;

iabtune.btune_next_blocksize = iabtune_next_blocksize;

iabtune.btune_next_cparams = iabtune_next_cparams;

iabtune.btune_update = iabtune_update;

iabtune.btune_free = iabtune_free;

cfg.udbtune = &iabtune;

}

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

if (cat_ctx == NULL) {

IARRAY_TRACE1(iarray.error, "Error allocating the caterva context");

return INA_ERROR(IARRAY_ERR_CATERVA_FAILED);

}

caterva_array_t *catarr;

IARRAY_ERR_CATERVA(caterva_from_cframe(cat_ctx, frame, frame_len, copy, &catarr));

caterva_storage_t cat_storage = {0};

cat_storage.urlpath = NULL;

cat_storage.contiguous = catarr->sc->storage->contiguous;

for (int i = 0; i < catarr->ndim; ++i) {

cat_storage.chunkshape[i] = catarr->chunkshape[i];

cat_storage.blockshape[i] = catarr->blockshape[i];

}

if (catarr == NULL) {

IARRAY_TRACE1(iarray.error, "Error creating the caterva array from a file");

return INA_ERROR(IARRAY_ERR_CATERVA_FAILED);

}

uint8_t *smeta;

int32_t smeta_len;

if (blosc2_meta_get(catarr->sc, "iarray", &smeta, &smeta_len) < 0) {

IARRAY_TRACE1(iarray.error, "Error getting a blosc metalayer");

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

iarray_data_type_t dtype;

if (_iarray_deserialize_meta(smeta, smeta_len, &dtype) != 0) {

IARRAY_TRACE1(iarray.error, "Error deserializing a sframe");

return INA_ERROR(IARRAY_ERR_BLOSC_FAILED);

}

*container = (iarray_container_t*)ina_mem_alloc(sizeof(iarray_container_t));

(*container)->catarr = catarr;

// Build the dtshape

(*container)->dtshape = (iarray_dtshape_t*)ina_mem_alloc(sizeof(iarray_dtshape_t));

iarray_dtshape_t* dtshape = (*container)->dtshape;

dtshape->dtype = dtype;

IARRAY_RETURN_IF_FAILED(iarray_set_dtype_size(dtshape));

dtshape->ndim = (int8_t)catarr->ndim;

for (int i = 0; i < catarr->ndim; ++i) {

dtshape->shape[i] = catarr->shape[i];

}

// Build the auxshape

(*container)->auxshape = (iarray_auxshape_t*)ina_mem_alloc(sizeof(iarray_auxshape_t));

iarray_auxshape_t* auxshape = (*container)->auxshape;

for (int8_t i = 0; i < catarr->ndim; ++i) {

auxshape->index[i] = i;

auxshape->offset[i] = 0;

auxshape->shape_wos[i] = catarr->shape[i];

auxshape->chunkshape_wos[i] = catarr->chunkshape[i];

auxshape->blockshape_wos[i] = catarr->blockshape[i];

}

(*container)->storage = ina_mem_alloc(sizeof(iarray_storage_t));

if ((*container)->storage == NULL) {

IARRAY_TRACE1(iarray.error, "Error allocating the store parameter");

return INA_ERROR(INA_ERR_FAILED);

}

(*container)->storage->urlpath = NULL;

(*container)->storage->contiguous = catarr->sc->storage->contiguous;

for (int i = 0; i < catarr->ndim; ++i) {

(*container)->storage->chunkshape[i] = catarr->chunkshape[i];

(*container)->storage->blockshape[i] = catarr->blockshape[i];

}

(*container)->container_viewed = NULL;

(*container)->transposed = false;

free(smeta);

caterva_ctx_free(&cat_ctx);

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_slice(iarray_context_t *ctx,

iarray_container_t *src,

const int64_t *start,

const int64_t *stop,

bool view,

iarray_storage_t *storage,

iarray_container_t **container)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(src);

INA_VERIFY_NOT_NULL(start);

INA_VERIFY_NOT_NULL(stop);

INA_VERIFY_NOT_NULL(container);

int8_t ndim = src->dtshape->ndim;

int64_t *offset = src->auxshape->offset;

int8_t *index = src->auxshape->index;

int64_t start_[IARRAY_DIMENSION_MAX];

int64_t stop_[IARRAY_DIMENSION_MAX];

for (int i = 0; i < src->catarr->ndim; ++i) {

start_[i] = 0 + offset[i];

stop_[i] = 1 + offset[i];

}

for (int i = 0; i < ndim; ++i) {

if (start[i] < 0) {

start_[index[i]] += start[i] + src->dtshape->shape[i];

} else{

start_[index[i]] += (int64_t) start[i];

}

if (stop[i] < 0) {

stop_[index[i]] += stop[i] + src->dtshape->shape[i] - 1;

} else {

stop_[index[i]] += (int64_t) stop[i] - 1;

}

}

if (src->transposed) {

int64_t start_trans[IARRAY_DIMENSION_MAX];

int64_t stop_trans[IARRAY_DIMENSION_MAX];

for (int i = 0; i < ndim; ++i) {

start_trans[i] = start_[ndim - 1 - i];

stop_trans[i] = stop_[ndim - 1 - i];

}

for (int i = 0; i < ndim; ++i) {

start_[i] = start_trans[i];

stop_[i] = stop_trans[i];

}

}

for (int i = 0; i < src->dtshape->ndim; ++i) {

if (start_[i] > stop_[i]) {

IARRAY_TRACE1(iarray.error, "Start is bigger than stop");

return INA_ERROR(INA_ERR_INVALID_ARGUMENT);

}

if (!view) {

if (storage->chunkshape[i] > stop_[i] - start_[i]) {

IARRAY_TRACE1(iarray.error, "The chunkshape is bigger than shape");

return INA_ERROR(IARRAY_ERR_INVALID_CHUNKSHAPE);

}

}

}

iarray_dtshape_t dtshape;

dtshape.ndim = src->dtshape->ndim;

dtshape.dtype = src->dtshape->dtype;

for (int i = 0; i < dtshape.ndim; ++i) {

dtshape.shape[i] = stop_[i] - start_[i];

}

if (view) {

IARRAY_RETURN_IF_FAILED(iarray_set_dtype_size(&dtshape));

IARRAY_RETURN_IF_FAILED(_iarray_view_new(ctx, src, &dtshape, start_, container));

} else {

IARRAY_RETURN_IF_FAILED(iarray_container_new(ctx, &dtshape, storage, container));

caterva_config_t cat_cfg = {0};

iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cat_cfg);

caterva_ctx_t *cat_ctx;

caterva_ctx_new(&cat_cfg, &cat_ctx);

caterva_params_t cat_params = {0};

iarray_create_caterva_params(&dtshape, &cat_params);

caterva_storage_t cat_storage = {0};

iarray_create_caterva_storage(&dtshape, storage, &cat_storage);

IARRAY_ERR_CATERVA(caterva_get_slice(cat_ctx, src->catarr, start_, stop_, &cat_storage, &(*container)->catarr));

free(cat_storage.metalayers[0].sdata);

free(cat_storage.metalayers[0].name);

caterva_ctx_free(&cat_ctx);

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_set_slice(iarray_context_t *ctx,

iarray_container_t *container,

const int64_t *start,

const int64_t *stop,

iarray_container_t *slice)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

INA_VERIFY_NOT_NULL(start);

INA_VERIFY_NOT_NULL(stop);

INA_VERIFY_NOT_NULL(slice);

uint8_t *buffer = NULL;

if (container->dtshape->dtype != slice->dtshape->dtype) {

IARRAY_TRACE1(iarray.error, "The data types are different");

return INA_ERROR(IARRAY_ERR_INVALID_DTYPE);

}

if (container->dtshape->ndim != slice->dtshape->ndim) {

IARRAY_TRACE1(iarray.error, "The dimensions are different");

return INA_ERROR(IARRAY_ERR_INVALID_NDIM);

}

int typesize = slice->catarr->itemsize;

int64_t buflen = slice->catarr->nitems;

buffer = ina_mem_alloc(buflen * typesize);

IARRAY_RETURN_IF_FAILED(iarray_to_buffer(ctx, slice, buffer, buflen * typesize));

IARRAY_RETURN_IF_FAILED(iarray_set_slice_buffer(ctx, container, start, stop, buffer, buflen * typesize));

INA_MEM_FREE_SAFE(buffer);

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_slice_buffer(iarray_context_t *ctx,

iarray_container_t *container,

const int64_t *start,

const int64_t *stop,

void *buffer,

int64_t buflen)

{

int64_t size = 1;

for (int i = 0; i < container->dtshape->ndim; ++i) {

size *= container->dtshape->shape[i];

}

if (size == 0) {

return INA_SUCCESS;

}

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(start);

INA_VERIFY_NOT_NULL(stop);

INA_VERIFY_NOT_NULL(buffer);

int64_t start_[IARRAY_DIMENSION_MAX];

int64_t stop_[IARRAY_DIMENSION_MAX];

int64_t shape_[IARRAY_DIMENSION_MAX];

for (int i = 0; i < container->dtshape->ndim; ++i) {

if (start[i] < 0) {

start_[i] = start[i] + container->dtshape->shape[i];

} else{

start_[i] = start[i];

}

if (stop[i] < 0) {

stop_[i] = stop[i] + container->dtshape->shape[i];

} else {

stop_[i] = stop[i];

}

shape_[i] = stop_[i] - start_[i];

}

IARRAY_RETURN_IF_FAILED(_iarray_get_slice_buffer(ctx, container, start, stop, shape_, buffer, buflen));

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_set_slice_buffer(iarray_context_t *ctx,

iarray_container_t *container,

const int64_t *start,

const int64_t *stop,

void *buffer,

int64_t buflen)

{

// TODO: make use of buflen so as to avoid exceeding the buffer boundaries

INA_UNUSED(ctx);

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

INA_VERIFY_NOT_NULL(start);

INA_VERIFY_NOT_NULL(stop);

INA_VERIFY_NOT_NULL(buffer);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Can not set data in a view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

int8_t ndim = container->dtshape->ndim;

int64_t *offset = container->auxshape->offset;

int8_t *index = container->auxshape->index;

int64_t start_[IARRAY_DIMENSION_MAX];

int64_t stop_[IARRAY_DIMENSION_MAX];

for (int i = 0; i < container->catarr->ndim; ++i) {

start_[i] = 0 + offset[i];

stop_[i] = 1 + offset[i];

}

for (int i = 0; i < ndim; ++i) {

if (start[i] < 0) {

start_[index[i]] += start[i] + container->dtshape->shape[i];

} else{

start_[index[i]] += (int64_t) start[i];

}

if (stop[i] < 0) {

stop_[index[i]] += stop[i] + container->dtshape->shape[i] - 1;

} else {

stop_[index[i]] += (int64_t) stop[i] - 1;

}

}

for (int i = 0; i < container->catarr->ndim; ++i) {

if (start_[i] < 0) {

IARRAY_TRACE1(iarray.error, "Start is negative");

return INA_ERROR(INA_ERR_INVALID_ARGUMENT);

}

if (stop_[i] < start_[i]) {

IARRAY_TRACE1(iarray.error, "Start is larger than stop");

return INA_ERROR(INA_ERR_INVALID_ARGUMENT);

}

if (container->catarr->shape[i] < stop_[i]) {

IARRAY_TRACE1(iarray.error, "Stop is larger than the container shape");

return INA_ERROR(INA_ERR_INVALID_ARGUMENT);

}

}

int64_t chunksize = 1;

int64_t shape_[IARRAY_DIMENSION_MAX];

for (int i = 0; i < container->catarr->ndim; ++i) {

shape_[i] = stop_[i] - start_[i];

chunksize *= shape_[i];

}

if (chunksize * (int64_t)container->dtshape->dtype_size > buflen) {

IARRAY_TRACE1(iarray.error, "The buffer size is not enough");

return INA_ERROR(IARRAY_ERR_TOO_SMALL_BUFFER);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_set_slice_buffer(cat_ctx, buffer, shape_, buflen, start_, stop_, container->catarr));

IARRAY_ERR_CATERVA(caterva_ctx_free(&cat_ctx));

return INA_SUCCESS;

}

ina_rc_t _iarray_get_slice_buffer(iarray_context_t *ctx,

iarray_container_t *container,

const int64_t *start,

const int64_t *stop,

const int64_t *chunkshape,

void *buffer,

int64_t buflen)

{

int8_t ndim = container->dtshape->ndim;

int64_t *offset = container->auxshape->offset;

int8_t *index = container->auxshape->index;

int64_t start_[IARRAY_DIMENSION_MAX];

int64_t stop_[IARRAY_DIMENSION_MAX];

int64_t chunkshape_[IARRAY_DIMENSION_MAX];

for (int i = 0; i < container->catarr->ndim; ++i) {

start_[i] = 0 + offset[i];

stop_[i] = 1 + offset[i];

chunkshape_[i] = 1;

}

for (int i = 0; i < ndim; ++i) {

if (start[i] < 0) {

start_[index[i]] += start[i] + container->dtshape->shape[i];

} else{

start_[index[i]] += start[i];

}

if (stop[i] < 0) {

stop_[index[i]] += stop[i] + container->dtshape->shape[i] - 1;

} else {

stop_[index[i]] += stop[i] - 1;

}

chunkshape_[index[i]] += chunkshape[i] - 1;

}

if (container->transposed) {

int64_t start_trans[IARRAY_DIMENSION_MAX];

int64_t stop_trans[IARRAY_DIMENSION_MAX];

int64_t chunkshape_trans[IARRAY_DIMENSION_MAX];

for (int i = 0; i < ndim; ++i) {

start_trans[i] = start_[ndim - 1 - i];

stop_trans[i] = stop_[ndim - 1 - i];

chunkshape_trans[i] = chunkshape_[ndim - 1 - i];

}

for (int i = 0; i < ndim; ++i) {

start_[i] = start_trans[i];

stop_[i] = stop_trans[i];

chunkshape_[i] = chunkshape_trans[i];

}

}

for (int i = 0; i < container->dtshape->ndim; ++i) {

if (start_[i] > stop_[i]) {

IARRAY_TRACE1(iarray.error, "Start is bigger than stop");

return INA_ERROR(INA_ERR_INVALID_ARGUMENT);

}

}

int64_t chunksize = 1;

for (int i = 0; i < container->catarr->ndim; ++i) {

chunksize *= chunkshape_[i];

}

if (chunksize * (int64_t) container->dtshape->dtype_size > buflen) {

IARRAY_TRACE1(iarray.error, "The buffer size is not enough\n");

return INA_ERROR(IARRAY_ERR_TOO_SMALL_BUFFER);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

if(container->transposed) {

uint8_t *buffer_aux = malloc(chunksize * container->catarr->itemsize);

IARRAY_ERR_CATERVA(caterva_get_slice_buffer(cat_ctx, container->catarr, start_,

stop_, buffer_aux, chunkshape_,

chunksize * container->catarr->itemsize));

char ordering = 'R';

char trans = 'T';

int rows = (int)chunkshape_[0];

int cols = (int)chunkshape_[1];

uint8_t *src = buffer_aux;

int src_ld = cols;

uint8_t *dst = buffer;

int dst_ld = rows;

switch (container->dtshape->dtype) {

case IARRAY_DATA_TYPE_DOUBLE:

mkl_domatcopy(ordering, trans, rows, cols, 1., (double *) src, src_ld,

(double *) dst, dst_ld);

break;

case IARRAY_DATA_TYPE_FLOAT:

mkl_somatcopy(ordering, trans, rows, cols, 1.f, (float *) src, src_ld,

(float *) dst, dst_ld);

break;

default:

return INA_ERROR(IARRAY_ERR_INVALID_DTYPE);

}

free(buffer_aux);

} else {

IARRAY_ERR_CATERVA(caterva_get_slice_buffer(cat_ctx, container->catarr, start_, stop_,

buffer, chunkshape_, buflen));

}

IARRAY_ERR_CATERVA(caterva_ctx_free(&cat_ctx));

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_type_view(iarray_context_t *ctx,

iarray_container_t *src,

iarray_data_type_t view_dtype,

iarray_container_t **container) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(src);

INA_VERIFY_NOT_NULL(container);

int8_t ndim = src->dtshape->ndim;

int64_t *offset = src->auxshape->offset;

iarray_dtshape_t dtshape;

dtshape.ndim = ndim;

dtshape.dtype = view_dtype;

for (int i = 0; i < dtshape.ndim; ++i) {

dtshape.shape[i] = src->dtshape->shape[i];

}

IARRAY_RETURN_IF_FAILED(iarray_set_dtype_size(&dtshape));

IARRAY_RETURN_IF_FAILED(_iarray_view_new(ctx, src, &dtshape, offset, container));

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_container_resize(iarray_context_t *ctx,

iarray_container_t *container,

int64_t *new_shape,

int64_t *start) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Can not resize a view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_resize(cat_ctx, container->catarr, new_shape, start));

// Update iarray params

for (int i = 0; i < container->dtshape->ndim; ++i) {

container->dtshape->shape[i] = new_shape[i];

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_container_insert(iarray_context_t *ctx,

iarray_container_t *container,

void *buffer,

int64_t buffersize,

const int8_t axis,

int64_t insert_start) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

INA_VERIFY_NOT_NULL(buffer);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Can not insert data in a view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_insert(cat_ctx, container->catarr, buffer, buffersize, axis, insert_start));

// Update iarray params

for (int i = 0; i < container->dtshape->ndim; ++i) {

container->dtshape->shape[i] = container->catarr->shape[i];

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_container_append(iarray_context_t *ctx,

iarray_container_t *container,

void *buffer,

int64_t buffersize,

const int8_t axis) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

INA_VERIFY_NOT_NULL(buffer);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Can not append data in a view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_append(cat_ctx, container->catarr, buffer, buffersize, axis));

// Update iarray params

for (int i = 0; i < container->dtshape->ndim; ++i) {

container->dtshape->shape[i] = container->catarr->shape[i];

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_container_delete(iarray_context_t *ctx,

iarray_container_t *container,

const int8_t axis,

int64_t delete_start,

int64_t delete_len) {

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

if (container->container_viewed != NULL) {

IARRAY_TRACE1(iarray.error, "Can not delete data in a view");

return INA_ERROR(IARRAY_ERR_INVALID_STORAGE);

}

caterva_config_t cfg = {0};

IARRAY_RETURN_IF_FAILED(iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg));

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_delete(cat_ctx, container->catarr, axis, delete_start, delete_len));

// Update iarray params

for (int i = 0; i < container->dtshape->ndim; ++i) {

container->dtshape->shape[i] = container->catarr->shape[i];

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_squeeze_index(iarray_context_t *ctx,

iarray_container_t *container,

bool *index)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

if (container->container_viewed == NULL) {

caterva_config_t cfg = {0};

iarray_create_caterva_cfg(ctx->cfg, ina_mem_alloc, ina_mem_free, &cfg);

caterva_ctx_t *cat_ctx;

IARRAY_ERR_CATERVA(caterva_ctx_new(&cfg, &cat_ctx));

IARRAY_ERR_CATERVA(caterva_squeeze_index(cat_ctx, container->catarr, index));

IARRAY_ERR_CATERVA(caterva_ctx_free(&cat_ctx));

uint8_t inc = 0;

if (container->dtshape->ndim != container->catarr->ndim) {

container->dtshape->ndim = (int8_t) container->catarr->ndim;

for (int i = 0; i < container->catarr->ndim; ++i) {

if (index[i]) {

inc ++;

}

container->dtshape->shape[i] = container->catarr->shape[i];

container->storage->chunkshape[i] = container->catarr->chunkshape[i];

container->storage->blockshape[i] = container->catarr->blockshape[i];

container->auxshape->shape_wos[i] = container->catarr->shape[i];

container->auxshape->chunkshape_wos[i] = container->catarr->chunkshape[i];

container->auxshape->blockshape_wos[i] = container->catarr->blockshape[i];

container->auxshape->offset[i] = container->auxshape->offset[i + inc];

}

}

} else {

int8_t inc = 0;

for (int i = 0; i < container->dtshape->ndim; ++i) {

if (index[i]) {

inc ++;

} else {

container->dtshape->shape[i - inc] = container->dtshape->shape[i];

container->auxshape->index[i - inc] = (int8_t) i;

}

}

container->dtshape->ndim -= inc;

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_squeeze(iarray_context_t *ctx,

iarray_container_t *container)

{

INA_VERIFY_NOT_NULL(ctx);

INA_VERIFY_NOT_NULL(container);

bool index[IARRAY_DIMENSION_MAX] = {0};

for (int i = 0; i < container->dtshape->ndim; ++i) {

if (container->dtshape->shape[i] == 1) {

index[i] = true;

}

}

IARRAY_RETURN_IF_FAILED(iarray_squeeze_index(ctx, container, index));

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_dtshape(iarray_context_t *ctx,

iarray_container_t *c,

iarray_dtshape_t *dtshape)

{

INA_UNUSED(ctx);

INA_VERIFY_NOT_NULL(c);

INA_VERIFY_NOT_NULL(dtshape);

dtshape->ndim = c->dtshape->ndim;

dtshape->dtype = c->dtshape->dtype;

dtshape->dtype_size = c->dtshape->dtype_size;

for (int i = 0; i < c->dtshape->ndim; ++i) {

dtshape->shape[i] = c->dtshape->shape[i];

}

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_storage(iarray_context_t *ctx,

iarray_container_t *c,

iarray_storage_t *storage)

{

INA_UNUSED(ctx);

INA_VERIFY_NOT_NULL(c);

INA_VERIFY_NOT_NULL(storage);

ina_mem_cpy(storage, c->storage, sizeof(iarray_storage_t));

return INA_SUCCESS;

}

INA_API(ina_rc_t) iarray_get_cfg(iarray_context_t *ctx,

iarray_container_t *c,

iarray_config_t *cfg) {

INA_VERIFY_NOT_NULL(c);

INA_VERIFY_NOT_NULL(cfg);

uint8_t *blosc_filters = c->catarr->sc->filters;

uint8_t *blosc_filters_meta = c->catarr->sc->filters_meta;

cfg->filter_flags = 0;

cfg->fp_mantissa_bits = 0;

for (int i = 0; i < BLOSC2_MAX_FILTERS; ++i) {

switch (blosc_filters[i]) {

case BLOSC_SHUFFLE:

cfg->filter_flags |= IARRAY_COMP_SHUFFLE;

break;

case BLOSC_BITSHUFFLE:

cfg->filter_flags |= IARRAY_COMP_BITSHUFFLE;

break;

case BLOSC_DELTA:

cfg->filter_flags |= IARRAY_COMP_DELTA;

break;

case BLOSC_TRUNC_PREC:

cfg->filter_flags |= IARRAY_COMP_TRUNC_PREC;

cfg->fp_mantissa_bits = blosc_filters_meta[i];