nm_pkt_wrap.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_PKT_WRAP_H
#define NM_PKT_WRAP_H
#include <sys/uio.h>
 
typedef uint32_t nm_pw_flag_t;
 
#define NM_PW_FLAG_NONE     ((nm_pw_flag_t)0x00u)
 
#define NM_PW_NOHEADER      ((nm_pw_flag_t)(0x1u << 0))
 
#define NM_PW_BUFFER        ((nm_pw_flag_t)(0x1u << 1))
 
#define NM_PW_GLOBAL_HEADER ((nm_pw_flag_t)(0x1u << 2))
 
#define NM_PW_DYNAMIC_V0    ((nm_pw_flag_t)(0x1u << 3))
 
#define NM_PW_FINALIZED     ((nm_pw_flag_t)(0x1u << 4))
 
#define NM_PW_PREFETCHING   ((nm_pw_flag_t)(0x1u << 5))
 
#define NM_PW_PREFETCHED    ((nm_pw_flag_t)(0x1u << 6))
 
#define NM_PW_POSTING       ((nm_pw_flag_t)(0x1u << 7))
 
#define NM_PW_POSTED        ((nm_pw_flag_t)(0x1u << 8))
 
#define NM_PW_COMPLETED     ((nm_pw_flag_t)(0x1u << 9))
 
#define NM_PW_SEND          ((nm_pw_flag_t)(0x1u << 10))
 
#define NM_PW_RECV          ((nm_pw_flag_t)(0x1u << 11))
 
#define NM_PW_DATA_COPY     ((nm_pw_flag_t)(0x1u << 12))
 
#define NM_PW_BUF_SEND      ((nm_pw_flag_t)(0x1u << 13))
 
#define NM_PW_BUF_RECV      ((nm_pw_flag_t)(0x1u << 14))
 
#define NM_PW_BUF_MIRROR    ((nm_pw_flag_t)(0x1u << 15))
 
#define NM_PW_CLOSED        ((nm_pw_flag_t)(0x1u << 16))
 
#define NM_PW_POLL_ANY      ((nm_pw_flag_t)(0x1u << 17))
 
#define NM_PW_CANCELED      ((nm_pw_flag_t)(0x1u << 18))
 
#define NM_PW_BLOCKING_CALL ((nm_pw_flag_t)(0x1u << 19))
 
#define NM_PW_RDV_READY     ((nm_pw_flag_t)(0x1u << 20))
 
#define NM_PW_DATA_IS_CUDA  ((nm_pw_flag_t)(0x1u << 21))
 
#define NM_PW_DATA_IS_HIP   ((nm_pw_flag_t)(0x1u << 22))
 
PUK_LIST_TYPE(nm_pw_pending_rtr,
              struct nm_gate_s*p_gate;
              struct nm_header_ctrl_rtr_s header;  
              void*p_payload;                      
              );
 
 
PUK_LIST_DECLARE_TYPE(nm_pkt_wrap);
 
#ifndef NMAD_PIOMAN
PUK_LIST_DECLARE_TYPE2(nm_pw_poll, struct nm_pkt_wrap_s);
#endif /* NMAD_PIOMAN */
 
struct nm_pkt_wrap_s
{
  /* ** links */
 
  PUK_LIST_LINK(nm_pkt_wrap);      
#ifndef NMAD_PIOMAN
  PUK_LIST_LINK(nm_pw_poll);       
#endif /* NMAD_PIOMAN */
  struct nm_core_task_s core_task; 
  /* ** scheduler fields */
 
#ifdef PIOMAN
  piom_ltask_t ltask;        
#endif /* PIOMAN */
  nm_drv_t p_drv;            
  nm_trk_id_t trk_id;        
  nm_gate_t p_gate;          
  struct nm_trk_s*p_trk;     
  /* ** packet / data description fields. */
 
  nm_pw_flag_t flags;        
  nm_len_t length;           
  nm_len_t max_len;          
  struct nm_data_s*p_data;   
  struct iovec*v;            
  int v_size;                
  int v_nb;                  
  __attribute__((aligned(16))) struct iovec prealloc_v[NM_PREALLOC_IOV_LEN];  
  nm_prio_t prio;            
  struct nm_pkt_s pkt;       
  /* ** lifecycle */
  struct nm_refcount_s refcount;                 
  void (*destructor)(struct nm_pkt_wrap_s*p_pw); 
  void*destructor_key;                           
  /* ** fields used when sending */
 
  struct nm_req_chunk_list_s req_chunks;         
  struct nm_pw_pending_rtr_list_s pending_rtrs;  
  /* ** fields used when receiving */
 
  struct nm_req_s*p_unpack;               
  /* ** fields used only for large messages */
  nm_len_t chunk_offset;                  
  struct nm_data_properties_s data_props; 
#if defined(NMAD_PROFILE) || defined(NMAD_SAMPLING)
  puk_tick_t start_transfer_time;         
#endif /* NMAD_PROFILE || NMAD_SAMPLING */
#ifdef PIO_OFFLOAD
  int data_to_offload;
  piom_ltask_t offload_ltask;
#endif /* PIO_OFFLOAD */
 
  /* The following field MUST be the LAST within the structure */
  NM_ALIGN_TYPE buf[1];
};
 
PUK_LIST_CREATE_FUNCS(nm_pkt_wrap);
#ifndef NMAD_PIOMAN
PUK_LIST_CREATE_FUNCS(nm_pw_poll);
#endif /* NMAD_PIOMAN */
 
/* tokens for ref-counting
 * refcount debug may track holders of counters; to do so, the refcount
 * increment and decrement must pass the same variable (an identical
 * string is not enough; the pointer must be the same). Hence we define
 * a variable for each case.
 */
extern const char nm_pw_refcount_core[];
extern const char nm_pw_refcount_completion[];
extern const char nm_pw_refcount_unexpected[];
extern const char nm_pw_refcount_prefetch[];
extern const char nm_pw_refcount_pioman[];
 
PUK_ALLOCATOR_TYPE_SINGLE(nm_pw_nohd, struct nm_pkt_wrap_s);
 
struct nm_pw_buf_s
{
  struct nm_pkt_wrap_s pw;
  char buf[NM_MAX_UNEXPECTED];
};
PUK_ALLOCATOR_TYPE_SINGLE(nm_pw_buf, struct nm_pw_buf_s);
 
#define INITIAL_PKT_NUM 16
 
struct nm_pkt_wrap_s*nm_pw_alloc_buffer(struct nm_core*p_core);
 
struct nm_pkt_wrap_s*nm_pw_alloc_noheader(struct nm_core*p_core);
 
struct nm_pkt_wrap_s*nm_pw_alloc_global_header(struct nm_core*p_core, struct nm_trk_s*p_trk);
 
void nm_pw_free(struct nm_core*p_core, struct nm_pkt_wrap_s*p_pw);
 
void nm_pw_split(struct nm_core*p_core, struct nm_pkt_wrap_s*p_pw, struct nm_pkt_wrap_s**pp_pw2, nm_len_t offset);
 
void nm_pw_add_req_chunk(struct nm_pkt_wrap_s*p_pw, struct nm_req_chunk_s*p_req_chunk, nm_req_chunk_flag_t flags);
 
void nm_pw_add_data_in_header(struct nm_pkt_wrap_s*p_pw, nm_core_tag_t tag, nm_seq_t seq,
                              struct nm_data_s*p_data, nm_len_t len, nm_len_t chunk_offset, nm_proto_t proto_flags);
 
void nm_pw_set_data_raw(struct nm_pkt_wrap_s*p_pw, struct nm_data_s*p_data, nm_len_t chunk_len, nm_len_t chunk_offset,
                        const struct nm_data_properties_s*p_props);
 
struct iovec*nm_pw_grow_iovec(struct nm_pkt_wrap_s*p_pw);
 
void nm_pw_data_to_iovec(struct nm_pkt_wrap_s*p_pw);
 
/* forward declaration to resolve dependancy */
union nm_header_ctrl_generic_s;
 
int nm_pw_add_control(struct nm_pkt_wrap_s*p_pw, const union nm_header_ctrl_generic_s*p_ctrl, const void*p_payload);
 
int nm_pw_finalize(struct nm_pkt_wrap_s *p_pw);
 
static inline nm_len_t nm_pw_remaining_buf(struct nm_pkt_wrap_s*p_pw)
{
  assert(p_pw->max_len != NM_LEN_UNDEFINED);
  assert(p_pw->length <= p_pw->max_len);
  return p_pw->max_len - p_pw->length;
}
 
 
#endif /* NM_PKT_WRAP_H */