dart_types.h

Go to the documentation of this file.

#ifndef DART_TYPES_H_INCLUDED
#define DART_TYPES_H_INCLUDED

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

#ifdef __cplusplus
extern "C" {
#endif

#define DART_INTERFACE_ON

typedef enum
{
  DART_OK           =   0,
  DART_PENDING      =   1,
  DART_ERR_INVAL    =   2,
  DART_ERR_NOTFOUND =   3,
  DART_ERR_NOTINIT  =   4,
  DART_ERR_NOMEM    =   5,
  DART_ERR_OTHER    = 999
} dart_ret_t;


enum {
  DART_EXIT_SUCCESS = EXIT_SUCCESS,
  DART_EXIT_ABORT   = EXIT_FAILURE,
  DART_EXIT_ASSERT  = -6
};


enum
{
  DART_OP_UNDEFINED = 0,
  DART_OP_MIN,
  DART_OP_MAX,
  DART_OP_MINMAX,
  DART_OP_SUM,
  DART_OP_PROD,
  DART_OP_BAND,
  DART_OP_LAND,
  DART_OP_BOR,
  DART_OP_LOR,
  DART_OP_BXOR,
  DART_OP_LXOR,
  DART_OP_REPLACE,
  DART_OP_NO_OP,
  DART_OP_LAST
};

typedef uintptr_t dart_operation_t ;

#define DART_OP_MINMAX_MIN 0

#define DART_OP_MINMAX_MAX 1

typedef intptr_t dart_datatype_t;

#define DART_TYPE_UNDEFINED    (dart_datatype_t)(0)
#define DART_TYPE_BYTE         (dart_datatype_t)(1)
#define DART_TYPE_SHORT        (dart_datatype_t)(2)
#define DART_TYPE_INT          (dart_datatype_t)(3)
#define DART_TYPE_UINT         (dart_datatype_t)(4)
#define DART_TYPE_LONG         (dart_datatype_t)(5)
#define DART_TYPE_ULONG        (dart_datatype_t)(6)
#define DART_TYPE_LONGLONG     (dart_datatype_t)(7)
#define DART_TYPE_ULONGLONG    (dart_datatype_t)(8)
#define DART_TYPE_FLOAT        (dart_datatype_t)(9)
#define DART_TYPE_DOUBLE       (dart_datatype_t)(10)
#define DART_TYPE_LONG_DOUBLE  (dart_datatype_t)(11)
#define DART_TYPE_LAST         (dart_datatype_t)(12)


#if (UINT32_MAX == SIZE_MAX)
#  define DART_TYPE_SIZET DART_TYPE_ULONG
#elif (UINT64_MAX == SIZE_MAX)
#  define DART_TYPE_SIZET DART_TYPE_ULONGLONG
#else
#  error "Cannot determine DART type for size_t!"
#endif

typedef int32_t dart_unit_t;

#define DART_UNDEFINED_UNIT_ID ((dart_unit_t)(-1))

typedef struct dart_global_unit {
#ifdef __cplusplus
  constexpr dart_global_unit() : id(DART_UNDEFINED_UNIT_ID) { }
  constexpr dart_global_unit(dart_unit_t uid) : id(uid) { }
#endif
  dart_unit_t id;
} dart_global_unit_t;


typedef struct dart_local_unit {
#ifdef __cplusplus
  constexpr dart_local_unit() : id(DART_UNDEFINED_UNIT_ID) { }
  constexpr dart_local_unit(dart_unit_t uid) : id(uid) { }
#endif
  dart_unit_t id;
} dart_team_unit_t;

static inline
dart_team_unit_t dart_create_team_unit(dart_unit_t unit)
{
  dart_team_unit_t tmp = {unit};
  return tmp;
}

#define DART_TEAM_UNIT_ID(__u) (dart_create_team_unit(__u))


static inline
dart_global_unit_t dart_create_global_unit(dart_unit_t unit)
{
  dart_global_unit_t tmp = {unit};
  return tmp;
}

#define DART_GLOBAL_UNIT_ID(__u) (dart_create_global_unit(__u))

#define DART_UNDEFINED_TEAM_UNIT_ID DART_TEAM_UNIT_ID(DART_UNDEFINED_UNIT_ID)

#define DART_UNDEFINED_GLOBAL_UNIT_ID DART_GLOBAL_UNIT_ID(DART_UNDEFINED_UNIT_ID)

typedef int16_t dart_team_t;

#define DART_UNDEFINED_TEAM_ID ((dart_team_t)(-1))


typedef enum
{
  DART_THREAD_SINGLE = 0,
  DART_THREAD_MULTIPLE = 10
} dart_thread_support_level_t;

typedef enum
{
  DART_LOCALITY_SCOPE_UNDEFINED  =   -1,
  DART_LOCALITY_SCOPE_GLOBAL     =    0,
  DART_LOCALITY_SCOPE_GROUP      =    1,
  DART_LOCALITY_SCOPE_NETWORK    =   50,
  DART_LOCALITY_SCOPE_NODE       =  100,
  DART_LOCALITY_SCOPE_MODULE     =  200,
  DART_LOCALITY_SCOPE_NUMA       =  300,
  DART_LOCALITY_SCOPE_UNIT       =  400,
  DART_LOCALITY_SCOPE_PACKAGE    =  500,
  DART_LOCALITY_SCOPE_UNCORE     =  510,
  DART_LOCALITY_SCOPE_CACHE      =  530,
  DART_LOCALITY_SCOPE_CORE       =  550,
  DART_LOCALITY_SCOPE_CPU        =  600
}
dart_locality_scope_t;

#if defined(HOST_NAME_MAX)
  #define DART_LOCALITY_HOST_MAX_SIZE      (HOST_NAME_MAX)
#elif defined(_POSIX_HOST_NAME_MAX)
  #define DART_LOCALITY_HOST_MAX_SIZE      (_POSIX_HOST_NAME_MAX)
#else
  #define DART_LOCALITY_HOST_MAX_SIZE     ((int)(256))
#endif

#define DART_LOCALITY_DOMAIN_TAG_MAX_SIZE ((int)(32))

#define DART_LOCALITY_MAX_DOMAIN_SCOPES   ((int)(12))

#define DART_LOCALITY_UNIT_MAX_CPUS       ((int)(64))

#define DART_LOCALITY_MAX_NUMA_ID         ((int)(16))

#define DART_LOCALITY_MAX_CACHE_LEVELS    ((int)( 5))

typedef struct {
    dart_locality_scope_t           scope;
    int                             index;
}
dart_locality_scope_pos_t;

typedef struct
{
    char  host[DART_LOCALITY_HOST_MAX_SIZE];

    int   num_cores;

    int   num_numa;

    int   numa_id;

    int   num_sockets;

    int   core_id;
    int   cpu_id;

    int   min_cpu_mhz;
    int   max_cpu_mhz;

    int   cache_sizes[DART_LOCALITY_MAX_CACHE_LEVELS];
    int   cache_line_sizes[DART_LOCALITY_MAX_CACHE_LEVELS];
    int   cache_ids[DART_LOCALITY_MAX_CACHE_LEVELS];

    int   min_threads;
    int   max_threads;

    int   max_shmem_mbps;

    int   system_memory_bytes;

    int   numa_memory_bytes;

    dart_locality_scope_pos_t scopes[DART_LOCALITY_MAX_DOMAIN_SCOPES];

    int   num_scopes;
}
dart_hwinfo_t;

typedef struct
{
    char  host[DART_LOCALITY_HOST_MAX_SIZE];

    char  module[DART_LOCALITY_HOST_MAX_SIZE];

    dart_locality_scope_pos_t pos;
}
dart_module_location_t;

struct dart_domain_locality_s
{
    char host[DART_LOCALITY_HOST_MAX_SIZE];

    char domain_tag[DART_LOCALITY_DOMAIN_TAG_MAX_SIZE];

    struct dart_domain_locality_s ** aliases;

    int                              num_aliases;

    dart_locality_scope_t            scope;
    int                              level;

    int                              global_index;
    int                              relative_index;

    struct dart_domain_locality_s  * parent;

    int                              num_domains;
    struct dart_domain_locality_s ** children;

    int                              is_symmetric;

    dart_team_t                      team;
    int                              num_units;
    dart_global_unit_t             * unit_ids;

    /* The number of compute nodes in the domain. */
    int                              num_nodes;
    /* Node (machine) index of the domain or -1 if domain contains
     * multiple compute nodes. */
    int                              node_id;

    /* Number of cores in the domain. Cores may be heterogeneous unless
     * `is_symmetric` is different from 0. */
    int                              num_cores;

    /* The minimum size of the physical or logical shared memory
     * accessible by all units in the domain.
     */
    int                              shared_mem_bytes;
};
struct dart_domain_locality_s;
typedef struct dart_domain_locality_s
    dart_domain_locality_t;

typedef struct {
    dart_team_unit_t         unit;

    dart_team_t              team;

    dart_hwinfo_t            hwinfo;

    char                     domain_tag[DART_LOCALITY_DOMAIN_TAG_MAX_SIZE];
}
dart_unit_locality_t;

typedef struct
{
  int log_enabled;
}
dart_config_t;

dart_ret_t
dart_type_create_strided(
  dart_datatype_t   basetype,
  size_t            stride,
  size_t            blocklen,
  dart_datatype_t * newtype);


dart_ret_t
dart_type_create_indexed(
  dart_datatype_t   basetype,
  size_t            count,
  const size_t      blocklen[],
  const size_t      offset[],
  dart_datatype_t * newtype);


dart_ret_t
dart_type_create_custom(
  size_t            num_bytes,
  dart_datatype_t * newtype);

dart_ret_t
dart_type_destroy(dart_datatype_t *dart_type);

typedef void (*dart_operator_t)(
  const void   * invec,
        void   * inoutvec,
        size_t   len,
        void   * user_data);

dart_ret_t
dart_op_create(
  dart_operator_t    op,
  void             * userdata,
  bool               commute,
  dart_datatype_t    dtype,
  bool               dtype_is_tmp,
  dart_operation_t * new_op);

dart_ret_t
dart_op_destroy(dart_operation_t *op);

#define DART_INTERFACE_OFF

#ifdef __cplusplus
}
#endif

#endif /* DART_TYPES_H_INCLUDED */