nm_minidriver.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2013-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_MINIDRIVER_H
#define NM_MINIDRIVER_H
 
#include <stdint.h>
#include <stdbool.h>
#include <nm_data.h>
 
#include <nm_public.h>
#include <Padico/Puk.h>
#ifdef NMAD_HWLOC
#include <hwloc.h>
#endif
#include <sys/uio.h>
#include <string.h>
 
struct nm_drv_profile_s
{
#ifdef NMAD_HWLOC
  hwloc_cpuset_t cpuset;  
#endif /* NMAD_HWLOC */
  int latency;   
  int bandwidth; 
};
 
enum nm_minidriver_reentrance_e
  {
    nm_minidriver_reentrance_full = -1, 
    nm_minidriver_reentrance_pkt = 0,   
    nm_minidriver_reentrance_trk_dir,   
    nm_minidriver_reentrance_trk,       
    nm_minidriver_reentrance_hybrid,    
    nm_minidriver_reentrance_drv_dir,   
    nm_minidriver_reentrance_drv        
  };
 
struct nm_minidriver_capabilities_s
{
  nm_len_t max_msg_size;       
  bool supports_data;          
  bool supports_send_prefetch; 
  bool supports_recv_prefetch; 
  bool supports_buf_send;      
  bool supports_buf_recv;      
  bool supports_recv_any;      
  bool supports_wait_any;      
  bool supports_recv_wait;     
  bool prefers_wait_any;       
  bool prefers_send_wait;      
  bool prefers_recv_wait;      
  bool supports_iovec;         
  int max_iovecs;              
  bool supports_cuda;          
  bool supports_hip;           
  int max_pkt_sends;           
  int max_pkt_recvs;           
  int min_period;              
  bool trk_rdv;                
  bool no_send_poll;           
  bool self;                   
  enum nm_minidriver_reentrance_e reentrance; 
};
 
struct nm_minidriver_hints_s
{
  nm_trk_kind_t kind;
};
 
struct nm_minidriver_properties_s
{
  struct nm_drv_profile_s profile;
  struct nm_minidriver_capabilities_s capabilities;
  struct nm_minidriver_hints_s hints;
  const char*nickname;    
};
 
#define NM_RDV_DATA_SIZE (4 * sizeof(uint64_t))
 
struct nm_pkt_s
{
  /* if a data representation is not available, its pointer is NULL
   */
  struct
  {
    void*p_buf;
    nm_len_t len;
  } buf;           
  struct
  {
    struct iovec*v;
    int n;
  } iov;           
  struct
  {
    struct nm_data_s*p_data;
    nm_len_t chunk_offset;
    nm_len_t chunk_len;
    struct nm_data_properties_s chunk_props; 
  } data;          
  struct
  {
    nm_len_t size;
    void*p_content; 
  } rdv_data;      
  struct
  {
    void*p_ptr;
  } driver_data;   
  struct
  {
    void*p_entry;  
  } send_prefetch;
  struct
  {
    void*p_entry;  
  } recv_prefetch;
  struct
  {
    bool sender_is_contig; 
    nm_prio_t prio;       
  } flags;
};
 
static inline void nm_pkt_init(struct nm_pkt_s*p_pkt)
{
  memset(p_pkt, 0, sizeof(struct nm_pkt_s));
}
 
struct nm_minidriver_iface_s
{
  /* ** driver init; applied to context before/after instantiation */
 
  void (*getprops)(puk_context_t context, struct nm_minidriver_properties_s*props);
  void (*init)(puk_context_t context, const void**drv_url, size_t*url_size);
  void (*close)(puk_context_t context);
 
  /* ** connection establishment */
 
  void (*connect_async)(void*_status, const void*remote_url, size_t url_size);
  void (*connect_wait)(void*_status);
  void (*disconnect)(void*_status);
 
  /* ** send pkt-based functions */
 
  int (*send_pkt_buf_get)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*send_pkt_post)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*send_pkt_poll)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*send_pkt_wait)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
 
  /* ** recv pkt-based functions */
 
  int (*recv_pkt_post)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*recv_pkt_poll)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*recv_pkt_buf_release)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*recv_pkt_wait)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
  int (*recv_pkt_cancel)(void*_status, struct nm_pkt_s*p_pkt) __attribute__ ((warn_unused_result));
 
  /* ** recv any functions */
 
  int (*recv_probe_any)(puk_context_t p_context, void**_status) __attribute__ ((warn_unused_result));
  int (*recv_wait_any)(puk_context_t p_context, void**_status) __attribute__ ((warn_unused_result));
  int (*recv_cancel_any)(puk_context_t p_context) __attribute__ ((warn_unused_result));
 
  /* ** prefetch */
 
  void (*send_pkt_prefetch)(void*_status, struct nm_pkt_s*p_pkt);
  void (*send_pkt_unfetch)(void*_status, struct nm_pkt_s*p_pkt);
  void (*recv_pkt_prefetch)(puk_context_t p_context, struct nm_pkt_s*p_pkt);
  void (*recv_pkt_unfetch)(puk_context_t p_context, struct nm_pkt_s*p_pkt);
 
};
PUK_IFACE_TYPE(NewMad_minidriver, struct nm_minidriver_iface_s);
 
static inline void nm_minidriver_properties_init(struct nm_minidriver_properties_s*p_props)
{
  memset(p_props, 0, sizeof(struct nm_minidriver_properties_s));
}
static inline void nm_minidriver_properties_normalize(struct nm_minidriver_properties_s*p_props)
{
  assert(p_props->capabilities.max_pkt_sends > 0);
  assert(p_props->capabilities.max_pkt_recvs > 0);
  if(p_props->capabilities.max_iovecs == 0)
    {
      if(p_props->capabilities.supports_iovec)
        {
          p_props->capabilities.max_iovecs = INT_MAX;
        }
      else
        {
          p_props->capabilities.max_iovecs = 1;
        }
    }
  if(p_props->capabilities.max_msg_size == 0)
    {
      p_props->capabilities.max_msg_size = NM_LEN_MAX;
    }
}
 
#endif /* NM_MINIDRIVER_H */