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
 
 
/* ** 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);
 
 
/* ** Packet wrappers ************************************** */
 
PUK_LFQUEUE_TYPE(nm_pkt_wrap, struct nm_pkt_wrap_s*, NULL, 512);
 
 
/* ** 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);
 
 
#endif /* NM_CORE_TYPES_H */