dpu.h

Go to the documentation of this file.

/* Copyright 2020 UPMEM. All rights reserved.
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef DPU_H
#define DPU_H

#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

// IWYU pragma: begin_exports
#include <dpu_checkpoint.h>
#include <dpu_error.h>
#include <dpu_types.h>
#include <dpu_macro_utils.h>
#include <dpu_fifo.h>
#include <dpu_bank_interface_pmc.h>
// IWYU pragma: end_exports

typedef enum _dpu_launch_policy_t {
    DPU_ASYNCHRONOUS,
    DPU_SYNCHRONOUS,
} dpu_launch_policy_t;

typedef enum _dpu_xfer_t {
    DPU_XFER_TO_DPU,
    DPU_XFER_FROM_DPU,
} dpu_xfer_t;

typedef enum _dpu_xfer_flags_t {
    DPU_XFER_DEFAULT = 0,
    DPU_XFER_NO_RESET = 1 << 0,
    DPU_XFER_ASYNC = 1 << 1,
    DPU_XFER_PARALLEL = 1 << 2,
} dpu_xfer_flags_t;

typedef enum _dpu_sg_xfer_flags_t {
    DPU_SG_XFER_DEFAULT = 0,
    DPU_SG_XFER_ASYNC = 1 << 1,
    DPU_SG_XFER_DISABLE_LENGTH_CHECK = 1 << 2,

} dpu_sg_xfer_flags_t;

typedef enum _dpu_callback_flags_t {
    DPU_CALLBACK_DEFAULT = 0,
    DPU_CALLBACK_ASYNC = 1 << 0,
    DPU_CALLBACK_NONBLOCKING = 1 << 1,
    DPU_CALLBACK_SINGLE_CALL = 1 << 2,
    DPU_CALLBACK_PARALLEL = 1 << 3,
} dpu_callback_flags_t;

#define DPU_CHECK(statement, on_error)                                                                                           \
    do {                                                                                                                         \
        dpu_error_t __error = (statement);                                                                                       \
        if (__error != DPU_OK) {                                                                                                 \
            char *__error_string = dpu_error_to_string(__error);                                                                 \
            fprintf(stderr, "%s:%d(%s): DPU Error (%s)\n", __FILE__, __LINE__, __func__, __error_string);                        \
            free(__error_string);                                                                                                \
            on_error;                                                                                                            \
        }                                                                                                                        \
    } while (0)

#define DPU_ASSERT(statement) DPU_CHECK(statement, exit(EXIT_FAILURE))

#define DPU_ALLOCATE_ALL (UINT_MAX)

dpu_error_t
dpu_alloc(uint32_t nr_dpus, const char *profile, struct dpu_set_t *dpu_set);

dpu_error_t
dpu_alloc_ranks(uint32_t nr_ranks, const char *profile, struct dpu_set_t *dpu_set);

dpu_error_t
dpu_free(struct dpu_set_t dpu_set);

dpu_error_t
dpu_get_nr_ranks(struct dpu_set_t dpu_set, uint32_t *nr_ranks);

dpu_error_t
dpu_get_nr_dpus(struct dpu_set_t dpu_set, uint32_t *nr_dpus);

#define DPU_RANK_FOREACH(set, ...) _CONCAT(_DPU_RANK_FOREACH_, _DPU_FOREACH_VARIANT(set, ##__VA_ARGS__))(set, ##__VA_ARGS__)

#define _DPU_RANK_FOREACH_X(set, rank)                                                                                           \
    for (struct dpu_set_rank_iterator_t __rank_it = dpu_set_rank_iterator_from(&set); rank = __rank_it.next, __rank_it.has_next; \
         dpu_set_rank_iterator_next(&__rank_it))

#define _DPU_RANK_FOREACH_I(set, rank, i)                                                                                        \
    for (struct dpu_set_rank_iterator_t __rank_it = dpu_set_rank_iterator_from(&set);                                            \
         i = __rank_it.count, rank = __rank_it.next, __rank_it.has_next;                                                         \
         dpu_set_rank_iterator_next(&__rank_it))

#define DPU_FOREACH(set, ...) _CONCAT(_DPU_FOREACH_, _DPU_FOREACH_VARIANT(set, ##__VA_ARGS__))(set, ##__VA_ARGS__)

#define _DPU_FOREACH_X(set, dpu)                                                                                                 \
    for (struct dpu_set_dpu_iterator_t __dpu_it = dpu_set_dpu_iterator_from(&set); dpu = __dpu_it.next, __dpu_it.has_next;       \
         dpu_set_dpu_iterator_next(&__dpu_it))

#define _DPU_FOREACH_I(set, dpu, i)                                                                                              \
    for (struct dpu_set_dpu_iterator_t __dpu_it = dpu_set_dpu_iterator_from(&set);                                               \
         i = __dpu_it.count, dpu = __dpu_it.next, __dpu_it.has_next;                                                             \
         dpu_set_dpu_iterator_next(&__dpu_it))

struct dpu_set_rank_iterator_t {
    struct dpu_set_t *set;
    uint32_t count;
    uint32_t next_idx;
    bool has_next;
    struct dpu_set_t next;
};

struct dpu_set_dpu_iterator_t {
    struct dpu_set_rank_iterator_t rank_iterator;
    uint32_t count;
    uint32_t next_idx;
    bool has_next;
    struct dpu_set_t next;
};

struct dpu_set_rank_iterator_t
dpu_set_rank_iterator_from(struct dpu_set_t *set);

void
dpu_set_rank_iterator_next(struct dpu_set_rank_iterator_t *iterator);

struct dpu_set_dpu_iterator_t
dpu_set_dpu_iterator_from(struct dpu_set_t *set);

void
dpu_set_dpu_iterator_next(struct dpu_set_dpu_iterator_t *iterator);

dpu_error_t
dpu_load_from_memory(struct dpu_set_t dpu_set, uint8_t *buffer, size_t buffer_size, struct dpu_program_t **program);

dpu_error_t
dpu_load_from_incbin(struct dpu_set_t dpu_set, struct dpu_incbin_t *incbin, struct dpu_program_t **program);

dpu_error_t
dpu_load(struct dpu_set_t dpu_set, const char *binary_path, struct dpu_program_t **program);

dpu_error_t
dpu_get_symbol(struct dpu_program_t *program, const char *symbol_name, struct dpu_symbol_t *symbol);

dpu_error_t
dpu_launch(struct dpu_set_t dpu_set, dpu_launch_policy_t policy);

dpu_error_t
dpu_status(struct dpu_set_t dpu_set, bool *done, bool *fault);

dpu_error_t
dpu_sync(struct dpu_set_t dpu_set);

dpu_error_t
dpu_copy_to(struct dpu_set_t dpu_set, const char *symbol_name, uint32_t symbol_offset, const void *src, size_t length);

dpu_error_t
dpu_copy_from(struct dpu_set_t dpu_set, const char *symbol_name, uint32_t symbol_offset, void *dst, size_t length);

dpu_error_t
dpu_copy_to_symbol(struct dpu_set_t dpu_set, struct dpu_symbol_t symbol, uint32_t symbol_offset, const void *src, size_t length);

dpu_error_t
dpu_copy_from_symbol(struct dpu_set_t dpu_set, struct dpu_symbol_t symbol, uint32_t symbol_offset, void *dst, size_t length);

dpu_error_t
dpu_prepare_xfer(struct dpu_set_t dpu_set, void *buffer);

struct sg_block_info {
    uint8_t *addr;
    uint32_t length;
};

typedef bool (*get_block_func_t)(struct sg_block_info *out, uint32_t dpu_index, uint32_t block_index, void *args);

typedef struct get_block_t {
    get_block_func_t f;
    void *args;
    size_t args_size;
} get_block_t;

dpu_error_t
dpu_push_sg_xfer(struct dpu_set_t dpu_set,
    dpu_xfer_t xfer,
    const char *symbol_name,
    uint32_t symbol_offset,
    size_t length,
    get_block_t *get_block_info,
    dpu_sg_xfer_flags_t flags);

dpu_error_t
dpu_push_sg_xfer_symbol(struct dpu_set_t dpu_set,
    dpu_xfer_t xfer,
    struct dpu_symbol_t symbol,
    uint32_t symbol_offset,
    size_t length,
    get_block_t *get_block_info,
    dpu_sg_xfer_flags_t flags);

dpu_error_t
dpu_push_xfer(struct dpu_set_t dpu_set,
    dpu_xfer_t xfer,
    const char *symbol_name,
    uint32_t symbol_offset,
    size_t length,
    dpu_xfer_flags_t flags);

dpu_error_t
dpu_push_xfer_symbol(struct dpu_set_t dpu_set,
    dpu_xfer_t xfer,
    struct dpu_symbol_t symbol,
    uint32_t symbol_offset,
    size_t length,
    dpu_xfer_flags_t flags);

dpu_error_t
dpu_broadcast_to(struct dpu_set_t dpu_set,
    const char *symbol_name,
    uint32_t symbol_offset,
    const void *src,
    size_t length,
    dpu_xfer_flags_t flags);

dpu_error_t
dpu_broadcast_to_symbol(struct dpu_set_t dpu_set,
    struct dpu_symbol_t symbol,
    uint32_t symbol_offset,
    const void *src,
    size_t length,
    dpu_xfer_flags_t flags);

dpu_error_t
dpu_fifo_prepare_xfer(struct dpu_set_t dpu_set, struct dpu_fifo_link_t *fifo_link, void *buffer);

dpu_error_t
dpu_fifo_push_xfer(struct dpu_set_t dpu_set, struct dpu_fifo_link_t *fifo_link, dpu_xfer_flags_t flags);

dpu_error_t
dpu_callback(struct dpu_set_t dpu_set,
    dpu_error_t (*callback)(struct dpu_set_t, uint32_t, void *),
    void *args,
    dpu_callback_flags_t flags);

/* clang-format off */
#define DPU_INCBIN(name, file)                                                     \
    __asm__(".pushsection .rodata.dpu_incbin\n"                                    \
            ".global dpu_incbin_" _STR(name) "\n"                                  \
            ".type dpu_incbin_" _STR(name) ", @object\n"                           \
            "dpu_incbin_" _STR(name) ":\n"                                         \
            ".incbin \"" file "\"\n"                                               \
                                                                                   \
            ".size dpu_incbin_" _STR(name) ", .-dpu_incbin_" _STR(name) "\n"       \
            ".global dpu_incbin_" _STR(name) "_size\n"                             \
            "dpu_incbin_"  _STR(name) "_size = . - dpu_incbin_" _STR(name) "\n"    \
            ".popsection\n"                                                        \
    );                                                                             \
    extern const void *dpu_incbin_ ## name;                                        \
    extern const void *dpu_incbin_ ## name ## _size;                               \
    struct dpu_incbin_t name = {.buffer = (uint8_t *)&dpu_incbin_ ## name ,        \
                                .size = (size_t)&dpu_incbin_ ## name ## _size,     \
                                .path = file };
/* clang-format on */

dpu_error_t
dpu_log_read(struct dpu_set_t set, FILE *stream);

#endif // DPU_H