nm_data.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2015-2025 (see AUTHORS file)
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or (at
 * your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULA R PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#ifndef NM_DATA_H
#define NM_DATA_H
 
#include <assert.h>
#include <string.h>
 
#include <Padico/Puk.h>
 
#include <nm_config.h>
 
/* ** Data descriptor ************************************** */
 
#define _NM_DATA_CONTENT_SIZE 64
#define _NM_DATA_GENERATOR_SIZE 64
 
#ifndef __ia64__
#ifdef _FORTIFY_SOURCE
#define NM_DATA_USE_UCONTEXT_SLICER
#else
#define NM_DATA_USE_COROUTINE_GENERATOR
#define NM_DATA_USE_COROUTINE_SLICER
#endif
#else
/* setjmp/longjmp is not properly supported on Itanium.
 * It works ok to unwind on the same stack but not for stack jumping.
 * (register stack is not saved/restored)
 */
#define NM_DATA_USE_UCONTEXT_GENERATOR
#endif
 
/* forward declaration so that operators declared inside struct nm_data_s may
 * take struct nm_data_s* as parameters
 */
struct nm_data_s;
 
typedef void (*nm_data_apply_t)(void*ptr, nm_len_t len, void*_context);
 
typedef void (*nm_data_traversal_t)(const void*_content, const nm_data_apply_t apply, void*_context);
 
struct nm_data_generator_s
{
  const struct nm_data_s*p_data;
  char _bytes[_NM_DATA_GENERATOR_SIZE]; 
};
 
typedef void (*nm_data_generator_init_t)(const struct nm_data_s*p_data, void*_generator);
struct nm_data_chunk_s
{
  void*ptr;     
  nm_len_t len; 
};
#define NM_DATA_CHUNK_NULL ((struct nm_data_chunk_s){ .ptr = NULL, .len = 0 })
static inline int nm_data_chunk_isnull(const struct nm_data_chunk_s*p_chunk)
{
  return (p_chunk->ptr == NULL);
}
 
typedef struct nm_data_chunk_s (*nm_data_generator_next_t)(const struct nm_data_s*p_data, void*_generator);
 
typedef void (*nm_data_generator_destroy_t)(const struct nm_data_s*p_data, void*_generator);
 
void                   nm_data_generator_coroutine_init(const struct nm_data_s*p_data, void*_generator);
struct nm_data_chunk_s nm_data_generator_coroutine_next(const struct nm_data_s*p_data, void*_generator);
void                   nm_data_generator_coroutine_destroy(const struct nm_data_s*p_data, void*_generator);
 
void                   nm_data_generator_generic_init(const struct nm_data_s*p_data, void*_generator);
struct nm_data_chunk_s nm_data_generator_generic_next(const struct nm_data_s*p_data, void*_generator);
 
#ifdef NM_DATA_USE_COROUTINE_GENERATOR
#define nm_data_generator_default_init    &nm_data_generator_coroutine_init
#define nm_data_generator_default_next    &nm_data_generator_coroutine_next
#define nm_data_generator_default_destroy &nm_data_generator_coroutine_destroy
#else /* NM_DATA_USE_COROUTINE_GENERATOR */
#define nm_data_generator_default_init    &nm_data_generator_generic_init
#define nm_data_generator_default_next    &nm_data_generator_generic_next
#define nm_data_generator_default_destroy NULL
#endif /* NM_DATA_USE_COROUTINE_GENERATOR */
 
struct nm_data_properties_s
{
  nm_len_t blocks; 
  nm_len_t size;   
  int is_contig;   
#ifdef NMAD_CUDA
  int is_cuda;     
#endif /* NMAD_CUDA */
#ifdef NMAD_HIP
  int is_hip;     
#endif /* NMAD_HIP */
};
 
typedef void (*nm_data_properties_compute_t)(struct nm_data_s*p_data);
 
struct nm_data_ops_s
{
  nm_data_traversal_t          p_traversal; 
  nm_data_generator_init_t     p_generator_init;    
  nm_data_generator_next_t     p_generator_next;    
  nm_data_generator_destroy_t  p_generator_destroy; 
  nm_data_properties_compute_t p_properties_compute; 
};
 
void nm_data_default_properties_compute(struct nm_data_s*p_data);
 
struct nm_data_s
{
  struct nm_data_ops_s ops;              
  struct nm_data_properties_s props;     
  char _content[_NM_DATA_CONTENT_SIZE];  
};
 
static inline void nm_data_propertie_gpu_preinit(struct nm_data_properties_s*p_props)
{
  (void) p_props;
#ifdef NMAD_CUDA
  p_props->is_cuda = -1;
#endif /* NMAD_CUDA */
#ifdef NMAD_HIP
  p_props->is_hip = -1;
#endif /* NMAD_HIP */
}
 
static inline void nm_data_propertie_gpu_postinit(const struct nm_data_properties_s*p_props)
{
  (void) p_props;
#ifdef NMAD_CUDA
  if(p_props->is_cuda == -1)
    {
      NM_FATAL("incorrect data properties: is_cuda = %d (should be either 0 or 1)\n", p_props->is_cuda);
    }
#endif /* NMAD_CUDA */
#ifdef NMAD_HIP
  if(p_props->is_hip == -1)
    {
      NM_FATAL("incorrect data properties: is_hip = %d (should be either 0 or 1)\n", p_props->is_hip);
    }
#endif /* NMAD_HIP */
}
 
#define NM_DATA_TYPE(ENAME, CONTENT_TYPE, OPS)                          \
  static inline void nm_data_##ENAME##_set(struct nm_data_s*p_data, CONTENT_TYPE value) \
  {                                                                     \
    p_data->ops = *(OPS);                                               \
    assert(p_data->ops.p_traversal != NULL);                            \
    if(p_data->ops.p_properties_compute == NULL)                        \
      {                                                                 \
        p_data->ops.p_properties_compute = nm_data_default_properties_compute; \
      }                                                                 \
    assert(sizeof(CONTENT_TYPE) <= _NM_DATA_CONTENT_SIZE);              \
    CONTENT_TYPE*p_content = (CONTENT_TYPE*)&p_data->_content[0];       \
    *p_content = value;                                                 \
    p_data->props.blocks = -1;                                          \
    nm_data_propertie_gpu_preinit(&p_data->props);                      \
    (*p_data->ops.p_properties_compute)(p_data);                        \
    nm_data_propertie_gpu_postinit(&p_data->props);                     \
    if(p_data->ops.p_generator_init == NULL)                            \
      {                                                                 \
        if(p_data->props.is_contig)                                     \
          {                                                             \
            /* use default generator for contig types- no need to create contexts since we know there is a single chunk */ \
            p_data->ops.p_generator_init    = &nm_data_generator_generic_init; \
            p_data->ops.p_generator_next    = &nm_data_generator_generic_next; \
            p_data->ops.p_generator_destroy = NULL;                     \
          }                                                             \
        else                                                            \
          {                                                             \
            p_data->ops.p_generator_init    = nm_data_generator_default_init; \
            p_data->ops.p_generator_next    = nm_data_generator_default_next; \
            p_data->ops.p_generator_destroy = nm_data_generator_default_destroy; \
          }                                                             \
      }                                                                 \
  }                                                                     \
  static inline CONTENT_TYPE*nm_data_##ENAME##_content(const struct nm_data_s*p_data) \
  {                                                                     \
    return (CONTENT_TYPE*)p_data->_content;                             \
  }
 
/* ** datav data (dynamic vector of nm_data)
 */
 
#define NM_DATAV_INIT_SIZE 4
 
struct nm_datav_s
{
  struct nm_data_s*p_data; 
  struct nm_data_s data[NM_DATAV_INIT_SIZE];  
  int n_data;             
  int allocated;          
  int commited;
};
 
static inline void nm_datav_init(struct nm_datav_s*p_datav);
static inline void nm_datav_destroy(struct nm_datav_s*p_datav);
static inline void nm_datav_add_chunk_data(struct nm_datav_s*p_datav, const struct nm_data_s*p_data);
static inline void nm_datav_add_chunk(struct nm_datav_s*p_datav, const void*ptr, nm_len_t len);
static inline nm_len_t nm_datav_size(struct nm_datav_s*p_datav);
static inline void nm_datav_uncommit(struct nm_datav_s*p_datav);
 
/* ** Built-in data types ********************************** */
 
struct nm_data_null_s
{
  int dummy; 
};
extern const struct nm_data_ops_s nm_data_ops_null;
NM_DATA_TYPE(null, struct nm_data_null_s, &nm_data_ops_null);
static inline void nm_data_null_build(struct nm_data_s*p_data)
{
  struct nm_data_null_s n = { 0 };
  nm_data_null_set(p_data, n);
}
static inline int nm_data_isnull(struct nm_data_s*p_data)
{
  return (p_data->ops.p_traversal == nm_data_ops_null.p_traversal);
}
 
struct nm_data_contiguous_s
{
  void*ptr;     
  nm_len_t len; 
};
extern const struct nm_data_ops_s nm_data_ops_contiguous;
NM_DATA_TYPE(contiguous, struct nm_data_contiguous_s, &nm_data_ops_contiguous);
 
static inline void nm_data_contiguous_build(struct nm_data_s*p_data, void*ptr, nm_len_t len)
{
  struct nm_data_contiguous_s dc;
  dc.ptr = ptr;
  dc.len = len;
  nm_data_contiguous_set(p_data, dc);
}
 
struct nm_data_iov_s
{
  const struct iovec*v;
  int n;
};
extern const struct nm_data_ops_s nm_data_ops_iov;
NM_DATA_TYPE(iov, struct nm_data_iov_s, &nm_data_ops_iov);
 
static inline void nm_data_iov_build(struct nm_data_s*p_data, const struct iovec*v, int n)
{
  struct nm_data_iov_s di;
  di.v = v;
  di.n = n;
  nm_data_iov_set(p_data, di);
}
 
struct nm_data_datav_s
{
  struct nm_datav_s*p_datav;
};
extern const struct nm_data_ops_s nm_data_ops_datav;
NM_DATA_TYPE(datav, struct nm_data_datav_s, &nm_data_ops_datav);
 
static inline void nm_data_datav_build(struct nm_data_s*p_datav_data, struct nm_datav_s*p_datav)
{
  p_datav->commited = 1;
  struct nm_data_datav_s dv;
  dv.p_datav = p_datav;
  nm_data_datav_set(p_datav_data, dv);
}
 
struct nm_data_excerpt_s
{
  nm_len_t chunk_offset;
  nm_len_t chunk_len;
  struct nm_data_s*p_data;
};
extern const struct nm_data_ops_s nm_data_ops_excerpt;
NM_DATA_TYPE(excerpt, struct nm_data_excerpt_s, &nm_data_ops_excerpt);
 
static inline void nm_data_excerpt_build(struct nm_data_s*p_data, struct nm_data_s*p_inner_data,
                                         nm_len_t chunk_offset, nm_len_t chunk_len)
{
  struct nm_data_excerpt_s de;
  de.chunk_offset = chunk_offset;
  de.chunk_len = chunk_len;
  de.p_data = p_inner_data;
  nm_data_excerpt_set(p_data, de);
}
 
 
/* ** Helper functions ************************************* */
 
static inline void nm_data_traversal_apply(const struct nm_data_s*p_data, nm_data_apply_t apply, void*_context)
{
  assert(p_data->ops.p_traversal != NULL);
  (*p_data->ops.p_traversal)((void*)p_data->_content, apply, _context);
}
 
/* ** helper functions for generator */
 
static inline void nm_data_generator_init(const struct nm_data_s*p_data, struct nm_data_generator_s*p_generator)
{
  assert(p_data->ops.p_generator_init != NULL);
  p_generator->p_data = p_data;
  (*p_data->ops.p_generator_init)(p_data, &p_generator->_bytes);
}
 
static inline struct nm_data_chunk_s nm_data_generator_next(struct nm_data_generator_s*p_generator)
{
  assert(p_generator->p_data->ops.p_generator_next != NULL);
  const struct nm_data_chunk_s chunk = (*p_generator->p_data->ops.p_generator_next)(p_generator->p_data, &p_generator->_bytes);
  return chunk;
}
 
static inline void nm_data_generator_destroy(struct nm_data_generator_s*p_generator)
{
  if(p_generator->p_data->ops.p_generator_destroy)
    (*p_generator->p_data->ops.p_generator_destroy)(p_generator->p_data, &p_generator->_bytes);
}
 
void nm_data_chunk_extractor_traversal(const struct nm_data_s*p_data, nm_len_t chunk_offset, nm_len_t chunk_len,
                                       nm_data_apply_t apply, void*_context);
 
void nm_data_aggregator_traversal(const struct nm_data_s*p_data, nm_data_apply_t apply, void*_context);
 
static inline const struct nm_data_properties_s*nm_data_properties_get(const struct nm_data_s*p_data)
{
  return &p_data->props;
}
 
static inline nm_len_t nm_data_size(const struct nm_data_s*p_data)
{
  const struct nm_data_properties_s*p_props = nm_data_properties_get((struct nm_data_s*)p_data);
  return p_props->size;
}
 
void*nm_data_baseptr_get(const struct nm_data_s*p_data);
 
void*nm_data_chunk_baseptr_get(const struct nm_data_s*p_data, nm_len_t chunk_offset, nm_len_t chunk_len);
 
void nm_data_chunk_properties_compute(const struct nm_data_s*p_data, nm_len_t chunk_offset, nm_len_t chunk_len,
                                      struct nm_data_properties_s*p_props);
 
uint32_t nm_data_checksum(const struct nm_data_s*p_data);
 
void nm_data_copy_from(const struct nm_data_s*p_data, nm_len_t offset, nm_len_t len, void*destbuf);
 
void nm_data_copy_to(const struct nm_data_s*p_data, nm_len_t offset, nm_len_t len, const void*srcbuf);
 
void nm_data_copy(struct nm_data_s*p_dest, struct nm_data_s*p_from);
 
/* ** Data slicer ****************************************** */
 
typedef enum
  {
    NM_DATA_SLICER_NONE = 0,
    NM_DATA_SLICER_GENERATOR, 
    NM_DATA_SLICER_COROUTINE, 
    NM_DATA_SLICER_UCONTEXT   
  } nm_data_slicer_kind_t;
 
typedef struct nm_data_slicer_s
{
  nm_data_slicer_kind_t kind;
  union
  {
    struct nm_data_slicer_generator_s*p_generator;
    struct nm_data_slicer_coroutine_s*p_coroutine;
    struct nm_data_slicer_ucontext_s*p_uslicer;
  };
} nm_data_slicer_t;
 
typedef enum nm_data_slicer_op_e
  {
    NM_SLICER_OP_NONE = 0,   
    NM_SLICER_OP_FORWARD,    
    NM_SLICER_OP_COPY_FROM,  
    NM_SLICER_OP_COPY_TO     
  } nm_data_slicer_op_t;
 
#define NM_DATA_SLICER_NULL ((struct nm_data_slicer_s){ .kind = NM_DATA_SLICER_NONE })
 
static inline int nm_data_slicer_isnull(const nm_data_slicer_t*p_slicer)
{
  return (p_slicer->kind == NM_DATA_SLICER_NONE);
}
 
void nm_data_slicer_coroutine_init(nm_data_slicer_t*p_slicer, const struct nm_data_s*p_data);
void nm_data_slicer_coroutine_op(nm_data_slicer_t*p_slicer, void*ptr, nm_len_t len, nm_data_slicer_op_t op);
void nm_data_slicer_coroutine_destroy(nm_data_slicer_t*p_slicer);
 
void nm_data_slicer_generator_init(nm_data_slicer_t*p_slicer, const struct nm_data_s*p_data);
void nm_data_slicer_generator_op(nm_data_slicer_t*p_slicer, void*ptr, nm_len_t slice_len, nm_data_slicer_op_t op);
void nm_data_slicer_generator_destroy(nm_data_slicer_t*p_slicer);
 
void nm_data_slicer_ucontext_init(nm_data_slicer_t*p_slicer, const struct nm_data_s*p_data);
void nm_data_slicer_ucontext_op(nm_data_slicer_t*p_slicer, void*ptr, nm_len_t len, nm_data_slicer_op_t op);
void nm_data_slicer_ucontext_destroy(nm_data_slicer_t*p_slicer);
 
void nm_data_slicer_init(nm_data_slicer_t*p_slicer, const struct nm_data_s*p_data);
void nm_data_slicer_op(nm_data_slicer_t*p_slicer, void*ptr, nm_len_t len, nm_data_slicer_op_t op);
void nm_data_slicer_copy_from(nm_data_slicer_t*p_slicer, void*dest_ptr, nm_len_t slice_len);
void nm_data_slicer_copy_to(nm_data_slicer_t*p_slicer, const void*src_ptr, nm_len_t slice_len);
void nm_data_slicer_forward(nm_data_slicer_t*p_slicer, nm_len_t offset);
void nm_data_slicer_destroy(nm_data_slicer_t*p_slicer);
 
 
/* ********************************************************* */
 
/* inline functions */
 
static inline void nm_datav_init(struct nm_datav_s*p_datav)
{
  p_datav->p_data = &p_datav->data[0];
  p_datav->n_data = 0;
  p_datav->allocated = 0;
  p_datav->commited = 0;
}
 
static inline void nm_datav_destroy(struct nm_datav_s*p_datav)
{
  assert(p_datav->p_data != NULL);
  if(p_datav->p_data != &p_datav->data[0])
   {
     padico_free(p_datav->p_data);
     p_datav->p_data = NULL;
   }
 }
 
static inline void nm_datav_add_chunk_data(struct nm_datav_s*p_datav, const struct nm_data_s*p_data)
{
  assert(!p_datav->commited); /* cannot modify datav once it is used as a nm_data */
  if(p_datav->n_data == NM_DATAV_INIT_SIZE)
    {
      assert(p_datav->p_data == &p_datav->data[0]);
      p_datav->allocated = NM_DATAV_INIT_SIZE * 2;
      p_datav->p_data = (struct nm_data_s*)padico_malloc(p_datav->allocated * sizeof(struct nm_data_s));
      memcpy(p_datav->p_data, &p_datav->data[0], p_datav->n_data * sizeof(struct nm_data_s));
    }
  else if((p_datav->n_data > NM_DATAV_INIT_SIZE) &&
          (p_datav->n_data > p_datav->allocated - 1))
    {
      assert(p_datav->p_data != &p_datav->data[0]);
      p_datav->allocated *= 2;
      p_datav->p_data = (struct nm_data_s*)padico_realloc(p_datav->p_data, p_datav->allocated * sizeof(struct nm_data_s));
    }
  p_datav->p_data[p_datav->n_data] = *p_data;
  p_datav->n_data++;
}
 
static inline void nm_datav_add_chunk(struct nm_datav_s*p_datav, const void*ptr, nm_len_t len)
{
  struct nm_data_s data;
  nm_data_contiguous_build(&data, (void*)ptr, len);
  nm_datav_add_chunk_data(p_datav, &data);
}
 
static inline nm_len_t nm_datav_size(struct nm_datav_s*p_datav)
{
  nm_len_t size = 0;
  int i;
  for(i = 0; i < p_datav->n_data; i++)
    {
      size += nm_data_size(&p_datav->p_data[i]);
    }
  return size;
}
 
static inline void nm_datav_uncommit(struct nm_datav_s*p_datav)
{
  assert(p_datav->commited);
  p_datav->commited = 0;
}
 
#endif /* NM_DATA_H */