Skip to content
Snippets Groups Projects
Select Git revision
  • 4513c80d81d5797aba8572ccc899a370596d80ce
  • master default protected
2 results

fmpi_futhark.c

Blame
  • fmpi_futhark.c 11.78 KiB
    // SPDX-License-Identifier: 0BSD
    /*!
     * @file
     * @license{
     * BSD Zero Clause License
     *
     * Copyright (c) 2022 by Raphael Bach
     *
     * Permission to use, copy, modify, and/or distribute this software for any
     * purpose with or without fee is hereby granted.
     *
     * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
     * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
     * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
     * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
     * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
     * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
     * PERFORMANCE OF THIS SOFTWARE.
     * }
     */
    /*==============================================================================
        INCLUDE
    ==============================================================================*/
    // Own header
    #include "internal/fmpi_futhark.h"
    // C Standard Library
    #include <assert.h>
    #include <stdbool.h>
    #include <stdlib.h> // NULL, size_t, free(), malloc()
    // Internal
    #include "internal/fmpi_common.h"
    #include "internal/fmpi_error.h"
    #include "internal/fmpi_futhark_entry.h"
    #include "internal/fmpi_type.h"
    #include "internal/generic/fmpi_generic.h"
    /*==============================================================================
        STATIC
    ==============================================================================*/
    typedef void * (*fmpi_futhark_new_data_func)(
        const struct fmpi_futhark_ctx * ctx, const void * data,
        size_t x, size_t y, size_t z
    );
    static const fmpi_futhark_new_data_func fmpi_futhark_new_data_func_list[] = {
       FMPI_FUTHARK_FUNC_ENTRY_LIST(new, 1),
       FMPI_FUTHARK_FUNC_ENTRY_LIST(new, 2),
       FMPI_FUTHARK_FUNC_ENTRY_LIST(new, 3)
    };
    
    typedef int (*fmpi_futhark_free_data_func)(
        const struct fmpi_futhark_ctx * ctx, void * data
    );
    static const fmpi_futhark_free_data_func fmpi_futhark_free_data_func_list[] = {
       FMPI_FUTHARK_FUNC_ENTRY_LIST(free, 1),
       FMPI_FUTHARK_FUNC_ENTRY_LIST(free, 2),
       FMPI_FUTHARK_FUNC_ENTRY_LIST(free, 3)
    };
    
    typedef int (*fmpi_futhark_get_data_func)(
        const struct fmpi_futhark_ctx * ctx, void * in, void * out
    );
    static const fmpi_futhark_get_data_func fmpi_futhark_get_data_func_list[] = {
        FMPI_FUTHARK_FUNC_ENTRY_LIST(values, 1),
        FMPI_FUTHARK_FUNC_ENTRY_LIST(values, 2),
        FMPI_FUTHARK_FUNC_ENTRY_LIST(values, 3)
    };
    /*==============================================================================
        MACRO
    ==============================================================================*/
    #define FMPI_RAISE_FUTHARK_ERROR(ctx, ...) \
    do { \
        if((ctx)->err_handler.func != NULL) { \
            FMPI_RAISE_ERROR((ctx)->err_handler, "FUTHARK", __VA_ARGS__); \
        } \
    } while(0)
    /*==============================================================================
        PUBLIC FUNCTION DEFINITION
    ==============================================================================*/
    /*------------------------------------------------------------------------------
        fmpi_futhark_init()
    ------------------------------------------------------------------------------*/
    struct fmpi_futhark_ctx * fmpi_futhark_init(
        const struct fmpi_error_handler err_handler
    ){
        struct fmpi_futhark_ctx * ctx = malloc(sizeof(*ctx));
        if(ctx == NULL) {
            FMPI_RAISE_ERROR(err_handler, "FMPI", "malloc(fmpi_futhark_ctx) failed!");
            return NULL;
        }
        ctx->err_handler = err_handler;
        ctx->cfg = futhark_context_config_new();
        if(ctx->cfg == NULL) {
            FMPI_RAISE_FUTHARK_ERROR(ctx, "futhark_context_config_new() failed!");
            free(ctx);
            return NULL;
        }
        ctx->ctx = futhark_context_new(ctx->cfg);
        // The doc says in case of error futhark_context_free() should be called
        // anyway, implying that futhark_context_new() returns a non-null pointer
        // even on error.
        // The code generated by futhark 0.22 says otherwise by clearly returning
        // NULL if malloc() fails.
        if(ctx->ctx == NULL) {
            FMPI_RAISE_FUTHARK_ERROR(ctx, "futhark_context_new() failed!");
            futhark_context_config_free(ctx->cfg);
            free(ctx);
            return NULL;
        }
        if(fmpi_futhark_check_error(ctx, "futhark_context_new") != FMPI_SUCCESS) {
            if(fmpi_futhark_exit(&ctx) != FMPI_SUCCESS) {
                FMPI_RAISE_ERROR(err_handler, "FMPI", "fmpi_futhark_exit() failed!");
            }
            return NULL;
        }
        return ctx;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_exit()
    ------------------------------------------------------------------------------*/
    int fmpi_futhark_exit(struct fmpi_futhark_ctx ** const ctx)
    {
        assert(ctx != NULL);
        assert(*ctx != NULL);
    
        const int err = futhark_context_sync((*ctx)->ctx);
        futhark_context_free((*ctx)->ctx);
        futhark_context_config_free((*ctx)->cfg);
        free(*ctx); *ctx = NULL;
        if(err != FUTHARK_SUCCESS) {
            return FMPI_ERR_FUTHARK;
        }
        return FMPI_SUCCESS;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_sync()
    ------------------------------------------------------------------------------*/
    int fmpi_futhark_sync(const struct fmpi_futhark_ctx * const ctx)
    {
        assert(ctx != NULL);
        if(futhark_context_sync(ctx->ctx) != FUTHARK_SUCCESS) {
            return fmpi_futhark_check_error(ctx, "futhark_context_sync");
        }
        return FMPI_SUCCESS;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_check_error()
    ------------------------------------------------------------------------------*/
    int fmpi_futhark_check_error(
        const struct fmpi_futhark_ctx * const ctx, const char * const func
    ){
        assert(ctx != NULL);
        assert(func != NULL);
        char * err_str = futhark_context_get_error(ctx->ctx);
        if(err_str != NULL) {
            FMPI_RAISE_FUTHARK_ERROR(ctx, "%s() failed! %s", func, err_str);
            free(err_str);
            return FMPI_ERR_FUTHARK;
        }
        return FMPI_SUCCESS;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_new_data_sync()
    ------------------------------------------------------------------------------*/
    void * fmpi_futhark_new_data_sync(
        const struct fmpi_futhark_ctx * const ctx, const void * const data,
        const enum fmpi_type_base type, const size_t dim_cnt,
        const size_t x, const size_t y, const size_t z
    ){
        assert(ctx != NULL);
        assert(data != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        void * new_data = fmpi_futhark_new_data_func_list[idx](ctx, data, x, y, z);
        fmpi_futhark_sync(ctx);
        //! @todo Construct a proper string with dimension and type
        const int err = fmpi_futhark_check_error(ctx, "futhark_new_##T##_##D##");
        if(new_data == NULL || err != FMPI_SUCCESS) {
            return NULL;
        }
        return new_data;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_new_data_async()
    ------------------------------------------------------------------------------*/
    void * fmpi_futhark_new_data_async(
        const struct fmpi_futhark_ctx * const ctx, const void * const data,
        const enum fmpi_type_base type, const size_t dim_cnt,
        const size_t x, const size_t y, const size_t z
    ){
        assert(ctx != NULL);
        assert(data != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        return fmpi_futhark_new_data_func_list[idx](ctx, data, x, y, z);
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_free_data_sync()
    ------------------------------------------------------------------------------*/
    int fmpi_futhark_free_data_sync(
        const struct fmpi_futhark_ctx * const ctx, void * const data,
        const enum fmpi_type_base type, const size_t dim_cnt
    ){
        assert(ctx != NULL);
        assert(data != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        fmpi_futhark_free_data_func_list[idx](ctx, data);
        fmpi_futhark_sync(ctx);
        //! @todo Construct a proper string with dimension and type
        return fmpi_futhark_check_error(ctx, "futhark_free_##T##_##D##");
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_free_data_async()
    ------------------------------------------------------------------------------*/
    int fmpi_futhark_free_data_async(
        const struct fmpi_futhark_ctx * const ctx, void * const data,
        const enum fmpi_type_base type, const size_t dim_cnt
    ){
        assert(ctx != NULL);
        assert(data != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        return fmpi_futhark_free_data_func_list[idx](ctx, data);
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_get_data_sync()
    ------------------------------------------------------------------------------*/
    void * fmpi_futhark_get_data_sync(
        const struct fmpi_futhark_ctx * const ctx, void * const in, void * const out,
        const enum fmpi_type_base type, const size_t dim_cnt
    ){
        assert(ctx != NULL);
        assert(in != NULL);
        assert(out != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        fmpi_futhark_get_data_func_list[idx](ctx, in, out);
        fmpi_futhark_sync(ctx);
        if(fmpi_futhark_check_error(ctx, "futhark_values_##T##_##D##d") != FMPI_SUCCESS) {
            return NULL;
        }
        return out;
    }
    /*------------------------------------------------------------------------------
        fmpi_futhark_get_data_async()
    ------------------------------------------------------------------------------*/
    void * fmpi_futhark_get_data_async(
        const struct fmpi_futhark_ctx * const ctx, void * const in, void * const out,
        const enum fmpi_type_base type, const size_t dim_cnt
    ){
        assert(ctx != NULL);
        assert(in != NULL);
        assert(out != NULL);
        assert(dim_cnt <= FMPI_DIM_MAX);
        const size_t idx = FMPI_PRIV_FUTHARK_FUNC_IDX(dim_cnt, type);
        if(fmpi_futhark_get_data_func_list[idx](ctx, in, out) != FMPI_SUCCESS) {
            return NULL;
        }
        return out;
    }
    
    #define FMPI_FUTHARK_DEFINITION(D, T) \
    _Static_assert((D) > 0 && (D) <= FMPI_DIM_MAX, ""); \
    void * fmpi_futhark_new_##D##d_##T( \
        const struct fmpi_futhark_ctx * const ctx, const void * const data, \
        const size_t x, const size_t y, const size_t z \
    ){ \
        assert(ctx != NULL); \
        assert(data != NULL); \
        struct futhark_##T##_##D##d * new_data = FMPI_FUTHARK_NEW_##D(T, ctx->ctx, data, x, y, z); \
        if(new_data == NULL) { \
            FMPI_RAISE_FUTHARK_ERROR(ctx, CPL_STRINGIFY(futhark_new_##T##_##D##d)"() failed!"); \
        } \
        return new_data; \
    } \
    int fmpi_futhark_free_##D##d_##T( \
        const struct fmpi_futhark_ctx * const ctx, void * const data \
    ){ \
        assert(ctx != NULL); \
        assert(data != NULL); \
        if(futhark_free_##T##_##D##d(ctx->ctx, data) != FUTHARK_SUCCESS) { \
            FMPI_RAISE_FUTHARK_ERROR(ctx, CPL_STRINGIFY(futhark_free_##T##_##D##d)"() failed!"); \
            return FMPI_ERR_FUTHARK; \
        } \
        return FMPI_SUCCESS; \
    } \
    int fmpi_futhark_values_##D##d_##T( \
        const struct fmpi_futhark_ctx * const ctx, void * const in, void * const out \
    ){ \
        assert(ctx != NULL); \
        assert(in != NULL); \
        assert(out != NULL); \
        if(futhark_values_##T##_##D##d(ctx->ctx, in, out) != FUTHARK_SUCCESS) { \
            FMPI_RAISE_FUTHARK_ERROR(ctx, CPL_STRINGIFY(fmpi_futhark_values_##T##_##D##d)"() failed!"); \
            return FMPI_ERR_FUTHARK; \
        } \
        return FMPI_SUCCESS; \
    }
    
    FMPI_DEFINE_FUNCS_DT(FMPI_FUTHARK_DEFINITION, 1, FMPI_FUTHARK_TYPES)
    FMPI_DEFINE_FUNCS_DT(FMPI_FUTHARK_DEFINITION, 2, FMPI_FUTHARK_TYPES)
    FMPI_DEFINE_FUNCS_DT(FMPI_FUTHARK_DEFINITION, 3, FMPI_FUTHARK_TYPES)