nm_core_types.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2006-2026 (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 PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */
 
#ifndef NM_CORE_TYPES_H
#define NM_CORE_TYPES_H
 
#include <stdatomic.h>
 
/* ** alignment ******************************************** */
 
#define NM_ALIGN_FRONTIER  sizeof(NM_ALIGN_TYPE)
#define nm_aligned(x)      nm_aligned_n((x), NM_ALIGN_FRONTIER)
 
static inline nm_len_t nm_aligned_n(nm_len_t v, nm_len_t a)
{
  return (v + a - 1) & ~(a - 1);
}
 
static inline void*nm_aligned_ptr(const void*p, nm_len_t a)
{
  return (void*)((uintptr_t)p & ~(a - 1));
}
 
#define nm_offset_of(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
#define nm_container_of(ptr, type, member) \
        ((type *)((char *)(__typeof__ (&((type *)0)->member))(ptr)- \
                  nm_offset_of(type,member)))
 
/* ** Threads ********************************************* */
 
#ifdef PIOMAN_MULTITHREAD
#define NM_IS_THREADED 1
#else
#define NM_IS_THREADED ((nm_core_get_thread_level(nm_core_get_singleton()) >= NM_THREAD_SERIALIZED) ? 1 : 0)
#endif
 
/* ** Allocators ****************************************** */
 
#define NM_ALLOCATOR_TYPE(ENAME, TYPE) PUK_ALLOCATOR_TYPE_EXT(ENAME, TYPE, !NM_IS_THREADED)
 
/* ** Requests ********************************************* */
 
PUK_LIST_CREATE_FUNCS(nm_req);
 
PUK_LIST_CREATE_FUNCS(nm_req_chunk);
 
NM_ALLOCATOR_TYPE(nm_req_chunk, struct nm_req_chunk_s);
 
/* ** Tracks *********************************************** */
 
#define NM_TRK_SMALL ((nm_trk_id_t)0)
#define NM_TRK_LARGE ((nm_trk_id_t)1)
#define NM_TRK_NONE  ((nm_trk_id_t)-1)
 
#define NM_MAX_TRACKS   2
 
/* ** Sequence numbers ************************************* */
 
#define NM_SEQ_FIRST ((nm_seq_t)1)
 
static inline nm_seq_t nm_seq_next(nm_seq_t seq)
{
  assert(seq != NM_SEQ_NONE);
  seq++;
  if(seq == NM_SEQ_NONE)
    seq++;
  return seq;
}
 
static inline int nm_seq_compare(nm_seq_t current, nm_seq_t seq1, nm_seq_t seq2)
{
  assert(seq1 != current);
  assert(seq2 != current);
  const nm_seq_t seq1_abs = (seq1 > current) ? (seq1 - current) : (seq1 - current - 1);
  const nm_seq_t seq2_abs = (seq2 > current) ? (seq2 - current) : (seq2 - current - 1);
  if(seq1_abs < seq2_abs)
    return -1;
  else if(seq1_abs > seq2_abs)
    return 1;
  else
    return 0;
}
 
static inline int nm_seq_fuzzy_compare(nm_seq_t seq1, nm_seq_t seq2)
{
  static const nm_seq_t seq_compare_threshold = NM_SEQ_MAX / 4;
  if(seq1 == seq2)
    return 0;
  else if((seq1 < seq2) && (seq2 - seq1 < seq_compare_threshold))
    return -1;
  else if((seq1 > seq2) && (seq1 - seq2 > 3 * seq_compare_threshold))
    return -1;
  else if((seq1 > seq2) && (seq1 - seq2 < seq_compare_threshold))
    return 1;
  else if((seq1 < seq2) && (seq2 - seq1 > 3 * seq_compare_threshold))
    return 1;
  else
    {
      NM_FATAL("cannot compare seq1 = %u; seq2=%u\n", seq1, seq2);
    }
}
 
/* ** Profiling ******************************************** */
 
#ifdef NMAD_PROFILE
#define nm_profile_add(COUNTER, VALUE) do { __sync_fetch_and_add(&COUNTER, VALUE); } while(0)
#else
#define nm_profile_add(COUNTER, VALUE) do {} while(0)
#endif
 
#define nm_profile_inc(COUNTER) nm_profile_add(COUNTER, 1)
 
/* ** init helper ****************************************** */
 
struct nm_lazy_initializer_s
{
  int init_done;    
  int initializing; 
};
 
#define NM_LAZY_INITIALIZER_INIT { .init_done = 0, .initializing = 0 }
 
#define NM_LAZY_INITIALIZER(ENAME, CTOR, DTOR)                          \
  static struct nm_lazy_initializer_s ENAME ## _lazy_initializer = NM_LAZY_INITIALIZER_INIT; \
                                                                        \
  static void ENAME ## _lazy_init(void)                                 \
  {                                                                     \
    if(ENAME##_lazy_initializer.init_done == 0)                         \
      {                                                                 \
        if(nm_atomic_inc(&ENAME##_lazy_initializer.initializing) == 0)  \
          {                                                             \
            (*CTOR)();                                                  \
            nm_atomic_inc(&ENAME##_lazy_initializer.init_done);         \
          }                                                             \
        else                                                            \
          {                                                             \
            while(!ENAME##_lazy_initializer.init_done)                  \
              {                                                         \
                sched_yield();                                          \
              }                                                         \
          }                                                             \
      }                                                                 \
    else if(ENAME##_lazy_initializer.init_done == -1)                   \
      {                                                                 \
        NM_FATAL("trying to use %s after detructor.\n", #ENAME);        \
      }                                                                 \
  }                                                                     \
  static void ENAME ## _lazy_destructor(void) __attribute__((destructor)); \
  static void ENAME ## _lazy_destructor(void)                           \
  {                                                                     \
    if(ENAME##_lazy_initializer.init_done > 0)                          \
      {                                                                 \
        (*DTOR)();                                                      \
      }                                                                 \
    ENAME##_lazy_initializer.init_done = -1;                            \
  }
 
 
/* ** Drivers ********************************************** */
 
 
/* ** Events *********************************************** */
 
PUK_VECT_TYPE(nm_core_monitor, struct nm_core_monitor_s*);
 
PUK_LIST_TYPE(nm_core_pending_event,
              struct nm_core_event_s event;             
              struct nm_core_monitor_s*p_core_monitor;  
              );
 
struct nm_core_dispatching_event_s
{
  struct nm_core_event_s event;
  struct nm_monitor_s*p_monitor;
  struct nm_req_s*p_req;
};
PUK_LFQUEUE_TYPE(nm_core_dispatching_event, struct nm_core_dispatching_event_s*, NULL, 1024);
NM_ALLOCATOR_TYPE(nm_core_dispatching_event, struct nm_core_dispatching_event_s);
 
/* ** Unexpected chunks ************************************ */
 
PUK_LIST_DECLARE_TYPE2(nm_unexpected_wildcard, struct nm_unexpected_s);
PUK_LIST_DECLARE_TYPE2(nm_unexpected_gtag,     struct nm_unexpected_s);
PUK_LIST_DECLARE_TYPE2(nm_unexpected_gate,     struct nm_unexpected_s);
PUK_LIST_DECLARE_TYPE2(nm_unexpected_tag,      struct nm_unexpected_s);
 
struct nm_in_chunk_s
{
  nm_gate_t p_gate;      
  nm_seq_t seq;          
  nm_core_tag_t tag;     
  nm_len_t chunk_offset; 
  nm_len_t chunk_len;    
  nm_proto_t flags;      
  nm_prio_t priority;    
};
 
struct nm_chunk_injector_s
{
  nm_injector_pull_data_t p_pull_data;      
  void*p_ref;                               
};
 
struct nm_unexpected_s
{
  PUK_LIST_LINK(nm_unexpected_wildcard);
  PUK_LIST_LINK(nm_unexpected_gtag);          
  PUK_LIST_LINK(nm_unexpected_gate);
  PUK_LIST_LINK(nm_unexpected_tag);
  const union nm_header_generic_s*p_header;   
  struct nm_pkt_wrap_s*p_pw;                  
  struct nm_in_chunk_s chunk;                 
  nm_len_t msg_len;                           
  struct nm_chunk_injector_s injector;        
  struct nm_matching_container_s matching;    
  int matched;                                
  struct nm_core_task_s core_task;            
};
 
PUK_LIST_CREATE_FUNCS(nm_unexpected_wildcard);
PUK_LIST_CREATE_FUNCS(nm_unexpected_gtag);
PUK_LIST_CREATE_FUNCS(nm_unexpected_gate);
PUK_LIST_CREATE_FUNCS(nm_unexpected_tag);
 
/* ** refcount ********************************************* */
 
PUK_LIST_TYPE(nm_refcount_holder,
              const void*p_holder; 
              const char*func;     
              const char*file;     
              int line;            
              );
 
struct nm_refcount_s
{
  atomic_int refcount;             
#ifdef NMAD_DEBUG
  char*object_id;                  
  nm_spinlock_t lock;              
  struct nm_refcount_holder_list_s holders; 
#endif /* NMAD_DEBUG */
};
 
static inline void nm_refcount_dump(struct nm_refcount_s*p_refcount __attribute__((unused)))
{
#ifdef NMAD_DEBUG
  nm_refcount_holder_itor_t i;
  puk_list_foreach(nm_refcount_holder, i, &p_refcount->holders)
    {
      NM_WARN("pending ref- object = %s; p_holder = %p; %s:%d %s()\n",
              p_refcount->object_id, i->p_holder, i->file, i->line, i->func);
    }
#endif /* NMAD_DEBUG */
}
 
static inline void nm_refcount_destroy(struct nm_refcount_s*p_refcount __attribute__((unused)))
{
#ifdef NMAD_DEBUG
  nm_refcount_dump(p_refcount);
  nm_spin_destroy(&p_refcount->lock);
  padico_free(p_refcount->object_id);
  nm_refcount_holder_list_destroy(&p_refcount->holders);
#endif /* NMAD_DEBUG */
}
 
static inline int nm_refcount_get(struct nm_refcount_s*p_refcount)
{
  return atomic_load(&p_refcount->refcount);
}
 
#define nm_refcount_inc(REFCOUNT, HOLDER)   \
  nm_refcount_inc_internal(REFCOUNT, HOLDER, __FUNCTION__, __FILE__, __LINE__)
 
#ifdef NMAD_DEBUG
static inline void nm_refcount_add_holder(struct nm_refcount_s*p_refcount, const void*p_holder,
                                          const char*func, const char*file, const int line)
{
  struct nm_refcount_holder_s*h = nm_refcount_holder_new();
  h->p_holder = p_holder;
  h->func = func;
  h->file = file;
  h->line = line;
  nm_refcount_holder_list_push_back(&p_refcount->holders, h);
}
 
static inline int nm_refcount_count_holder(struct nm_refcount_s*p_refcount, const void*p_holder)
{
  int count = 0;
  nm_refcount_holder_itor_t i;
  puk_list_foreach(nm_refcount_holder, i, &p_refcount->holders)
    {
      if(i->p_holder == p_holder)
        count++;
    }
  return count;
}
#endif /* NMAD_DEBUG */
 
static inline void nm_refcount_inc_internal(struct nm_refcount_s*p_refcount, const void*p_holder __attribute__((unused)),
                                            const char*func __attribute__((unused)),
                                            const char*file __attribute__((unused)),
                                            const int line __attribute__((unused)))
{
  assert(p_refcount->refcount >= 0);
  atomic_fetch_add(&p_refcount->refcount, 1);
#ifdef NMAD_DEBUG
  if(p_holder != NULL)
    {
      nm_spin_lock(&p_refcount->lock);
#if 0
      if(nm_refcount_count_holder(p_refcount, p_holder) > 0)
        {
          nm_refcount_holder_itor_t i;
          PUK_LIST_FIND(nm_refcount_holder, i, &p_refcount->holders, (i->p_holder == p_holder));
          NM_WARN("p_holder = %p already holding a ref to p_refcount = %p (%s)\n"
                  " new holder: %s:%d %s()\n"
                  " previous holder: %s:%d %s()\n",
                  p_holder, p_refcount, p_refcount->object_id,
                  file, line, func, i->file, i->line, i->func);
        }
#endif /* 0 */
      nm_refcount_add_holder(p_refcount, p_holder, func, file, line);
      nm_spin_unlock(&p_refcount->lock);
    }
#endif /* NMAD_DEBUG */
}
 
static inline int nm_refcount_dec(struct nm_refcount_s*p_refcount, const void*p_holder __attribute__((unused)))
{
  const int nb_ref = atomic_fetch_sub(&p_refcount->refcount, 1) - 1;
  assert(nb_ref >= 0);
#ifdef NMAD_DEBUG
  if(p_holder != NULL)
    {
      nm_spin_lock(&p_refcount->lock);
      const int count = nm_refcount_count_holder(p_refcount, p_holder);
      nm_refcount_holder_itor_t i;
      PUK_LIST_FIND(nm_refcount_holder, i, &p_refcount->holders, (i->p_holder == p_holder));
      if(i == NULL)
        {
          NM_FATAL("p_holder = %p not holding ref to p_refcount = %p (%s); cannot release\n",
                   p_holder, p_refcount, p_refcount->object_id);
        }
      else
        {
          nm_refcount_holder_list_remove(&p_refcount->holders, i);
          nm_refcount_holder_delete(i);
        }
      assert(nm_refcount_count_holder(p_refcount, p_holder) == count - 1);
      nm_spin_unlock(&p_refcount->lock);
    }
#endif /* NMAD_DEBUG */
  return nb_ref;
}
 
static inline void nm_refcount_init(struct nm_refcount_s*p_refcount, char*p_object_id, const void*p_init_holder)
{
  atomic_store(&p_refcount->refcount, 1);
#ifdef NMAD_DEBUG
  p_refcount->object_id = p_object_id;
  nm_spin_init(&p_refcount->lock);
  nm_refcount_holder_list_init(&p_refcount->holders);
  if(p_init_holder != NULL)
    {
      nm_refcount_add_holder(p_refcount, p_init_holder, __FUNCTION__, __FILE__, __LINE__);
    }
#else /* NMAD_DEBUG */
  if(p_object_id != NULL)
    padico_free(p_object_id); /* when not in debug, we won't use the object_id at all */
#endif /* NMAD_DEBUG */
}
 
 
 
#endif /* NM_CORE_TYPES_H */