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 <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; 
};
 
struct nm_minidriver_capabilities_s
{
  nm_len_t max_msg_size; 
  int supports_data;     
  int supports_send_prefetch; 
  int supports_recv_prefetch; 
  int supports_buf_send; 
  int supports_buf_recv; 
  int supports_recv_any; 
  int supports_wait_any; 
  int supports_recv_wait; 
  int prefers_wait_any;  
  int prefers_send_wait; 
  int prefers_recv_wait; 
  int supports_iovec;    
  int max_iovecs;        
  int supports_cuda;     
  int supports_hip;      
  int max_pkt_sends;     
  int max_pkt_recvs;     
  int min_period;        
  int trk_rdv;           
  int no_send_poll;      
  int self;              
};
 
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
  {
    int sender_is_contig; 
  } 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 */