nm_sendrecv_private.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2006-2024 (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_SENDRECV_PRIVATE_H
#define NM_SENDRECV_PRIVATE_H
 
#include <nm_core_interface.h>
#include <nm_session_private.h>
#ifdef PIOMAN
#include <pioman.h>
#endif
#ifdef MARCEL
#include <marcel.h>
#endif
 
 
/* ** Events *********************************************** */
 
struct nm_sr_event_monitor_s
{
  nm_sr_event_t mask;               
  nm_sr_event_notifier_t notifier;  
};
#ifdef __cplusplus
#define NM_SR_EVENT_MONITOR_NULL ((struct nm_sr_event_monitor_s){ (nm_sr_event_t)NM_SR_EVENT_NONE, (nm_sr_event_notifier_t)NULL })
#else /* __cplusplus */
#define NM_SR_EVENT_MONITOR_NULL ((struct nm_sr_event_monitor_s){ .mask = NM_SR_EVENT_NONE, .notifier = NULL })
#endif /* __cplusplus */
 
/* ** Request ********************************************** */
 
struct nm_sr_request_s
{
  struct nm_req_s req;                  
  nm_session_t p_session;               
  struct nm_sr_event_monitor_s monitor; 
  void*ref;                             
};
 
#define NM_SR_REQUEST_NULL ((struct nm_sr_request_s){ .p_session = NULL, .monitor = NM_SR_EVENT_MONITOR_NULL, .ref = NULL})
 
/* ** Requests inline ************************************** */
 
static inline int nm_sr_request_isnull(nm_sr_request_t*p_request)
{
  return p_request->p_session == NULL;
}
 
static inline void*nm_sr_request_get_ref(nm_sr_request_t*p_request)
{
  return p_request->ref;
}
 
static inline nm_session_t nm_sr_request_get_session(nm_sr_request_t*p_request)
{
  return p_request->p_session;
}
 
static inline nm_tag_t nm_sr_request_get_tag(nm_sr_request_t*p_request)
{
  return nm_core_tag_get_tag(p_request->req.tag);
}
 
static inline nm_gate_t nm_sr_request_get_gate(nm_sr_request_t*p_request)
{
  return p_request->req.p_gate;
}
 
static inline int nm_sr_request_set_ref(nm_sr_request_t*p_request, void*ref)
{
  if(!p_request->ref)
    {
      p_request->ref = ref;
      return NM_ESUCCESS;
    }
  else
    return -NM_EALREADY;
}
 
static inline int nm_sr_request_get_size(nm_sr_request_t*p_request, nm_len_t*size)
{
  if(p_request->req.flags & NM_REQ_FLAG_PACK)
    {
      *size = p_request->req.pack.done;
      return NM_ESUCCESS;
    }
  else if(p_request->req.flags & NM_REQ_FLAG_UNPACK)
    {
      *size = p_request->req.unpack.cumulated_len;
      return NM_ESUCCESS;
    }
  else
    {
      *size = NM_LEN_UNDEFINED;
      return -NM_EINVAL;
    }
}
 
static inline int nm_sr_request_get_expected_size(nm_sr_request_t*p_request, nm_len_t*size)
{
  if(p_request->req.flags & NM_REQ_FLAG_PACK)
    {
      *size = p_request->req.pack.len;
      return NM_ESUCCESS;
    }
  else if(p_request->req.flags & NM_REQ_FLAG_UNPACK)
    {
      if(nm_status_test(&p_request->req, NM_STATUS_UNPACK_DATA_SIZE))
        {
          assert(p_request->req.unpack.expected_len != NM_LEN_UNDEFINED);
          *size = p_request->req.unpack.expected_len;
          return NM_ESUCCESS;
        }
      else
        {
          *size = NM_LEN_UNDEFINED;
          return -NM_EAGAIN;
        }
    }
  else
    {
      *size = NM_LEN_UNDEFINED;
      return -NM_EINVAL;
    }
}
 
static inline void nm_sr_request_wait_all(nm_sr_request_t**p_requests, int n)
{
  assert(n >= 1);
  const nm_sr_request_t*p_req = NULL;
  const uintptr_t offset = (uintptr_t)&p_req->req - (uintptr_t)p_req;  /* offset of 'req' in nm_sr_request_t */
  struct nm_core*p_core = nm_core_get_singleton();
  nm_status_wait_all((void**)p_requests, n, offset, NM_STATUS_FINALIZED, p_core);
}
static inline int nm_sr_request_test(nm_sr_request_t*p_request, nm_status_t status)
{
  return nm_status_test_allbits(&p_request->req, status);
}
static inline int nm_sr_request_get_error(nm_sr_request_t*p_request)
{
  return p_request->req.err;
}
static inline int nm_sr_rwait(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  return nm_sr_request_wait(p_request);
}
static inline int nm_sr_rwait_data(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_status_wait(&p_request->req, NM_STATUS_UNPACK_COMPLETED, p_core);
  return p_request->req.err;
}
static inline int nm_sr_swait(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  return nm_sr_request_wait(p_request);
}
 
/* ** Send inline ****************************************** */
 
static inline void nm_sr_send_init(nm_session_t p_session, nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_init(p_core, &p_request->req);
  p_request->monitor = NM_SR_EVENT_MONITOR_NULL;
  p_request->ref = NULL;
  p_request->p_session = p_session;
}
static inline void nm_sr_send_pack_data(nm_session_t p_session __attribute__((unused)),
                                        nm_sr_request_t*p_request, const struct nm_data_s*p_data)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_data(p_core, &p_request->req, p_data);
}
static inline void nm_sr_send_pack_contiguous(nm_session_t p_session, nm_sr_request_t*p_request,
                                              const void*ptr, nm_len_t len)
{
  struct nm_data_s data;
  nm_data_contiguous_build(&data, (void*)ptr, len);
  nm_sr_send_pack_data(p_session, p_request, &data);
}
static inline void nm_sr_send_pack_iov(nm_session_t p_session, nm_sr_request_t*p_request,
                                       const struct iovec*v, int n)
{
  struct nm_data_s data;
  nm_data_iov_build(&data, v, n);
  nm_sr_send_pack_data(p_session, p_request, &data);
}
 
static inline int nm_sr_send_dest(nm_session_t p_session, nm_sr_request_t*p_request,
                                  nm_gate_t p_gate, nm_tag_t tag)
{
  nm_core_t p_core = nm_core_get_singleton();
  const nm_core_tag_t core_tag = nm_core_tag_build(p_session->hash_code, tag);
  nm_core_pack_send(p_core, &p_request->req, core_tag, p_gate, 0);
  return NM_ESUCCESS;
}
 
static inline void nm_sr_send_set_priority(nm_session_t p_session __attribute__((unused)),
                                           nm_sr_request_t*p_request, nm_prio_t priority)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_set_priority(p_core, &p_request->req, priority);
}
 
static inline int nm_sr_send_header(nm_session_t p_session __attribute__((unused)),
                                    nm_sr_request_t*p_request, nm_len_t hlen)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_set_hlen(p_core, &p_request->req, hlen);
  return NM_ESUCCESS;
}
static inline int nm_sr_send_submit(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_submit(p_core, &p_request->req);
  return NM_ESUCCESS;
}
 
static inline int nm_sr_send_submit_chunks(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request,
                                           int n, const struct nm_chunk_s*p_chunks)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_pack_submit_chunks(p_core, &p_request->req, n, p_chunks);
  return NM_ESUCCESS;
}
 
static inline int nm_sr_send_isend(nm_session_t p_session, nm_sr_request_t*p_request,
                                   nm_gate_t p_gate, nm_tag_t tag)
{
  nm_sr_send_dest(p_session, p_request, p_gate, tag);
  nm_sr_send_submit(p_session, p_request);
  return NM_ESUCCESS;
}
static inline int nm_sr_send_issend(nm_session_t p_session, nm_sr_request_t*p_request,
                                    nm_gate_t p_gate, nm_tag_t tag)
{
  nm_core_t p_core = nm_core_get_singleton();
  const nm_core_tag_t core_tag = nm_core_tag_build(p_session->hash_code, tag);
  nm_core_pack_send(p_core, &p_request->req, core_tag, p_gate, NM_REQ_FLAG_PACK_SYNCHRONOUS);
  nm_core_pack_submit(p_core, &p_request->req);
  return NM_ESUCCESS;
}
static inline int nm_sr_send_rsend(nm_session_t p_session, nm_sr_request_t*p_request,
                                   nm_gate_t p_gate, nm_tag_t tag)
{
  nm_core_t p_core = nm_core_get_singleton();
  const nm_core_tag_t core_tag = nm_core_tag_build(p_session->hash_code, tag);
  nm_core_pack_send(p_core, &p_request->req, core_tag, p_gate, 0);
  nm_core_pack_submit(p_core, &p_request->req);
  return NM_ESUCCESS;
}
 
/* ** Recv inline ****************************************** */
 
static inline void nm_sr_recv_init(nm_session_t p_session, nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_unpack_init(p_core, &p_request->req);
  p_request->monitor = NM_SR_EVENT_MONITOR_NULL;
  p_request->ref = NULL;
  p_request->p_session = p_session;
}
 
static inline void nm_sr_recv_unpack_data(nm_session_t p_session __attribute__((unused)),
                                          nm_sr_request_t*p_request, const struct nm_data_s*p_data)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_unpack_data(p_core, &p_request->req, p_data);
}
 
static inline void nm_sr_recv_unpack_contiguous(nm_session_t p_session, nm_sr_request_t*p_request,
                                                void*ptr, nm_len_t len)
{
  struct nm_data_s data;
  nm_data_contiguous_build(&data, ptr, len);
  nm_sr_recv_unpack_data(p_session, p_request, &data);
}
 
static inline void nm_sr_recv_unpack_iov(nm_session_t p_session, nm_sr_request_t*p_request,
                                         const struct iovec*v, int n)
{
  struct nm_data_s data;
  nm_data_iov_build(&data, v, n);
  nm_sr_recv_unpack_data(p_session, p_request, &data);
}
 
static inline int nm_sr_recv_irecv(nm_session_t p_session, nm_sr_request_t*p_request,
                                   nm_gate_t p_gate, nm_tag_t tag, nm_tag_t mask)
{
  nm_sr_recv_match(p_session, p_request, p_gate, tag, mask);
  return nm_sr_recv_post(p_session, p_request);
}
 
static inline void nm_sr_recv_match(nm_session_t p_session, nm_sr_request_t*p_request,
                                    nm_gate_t p_gate, nm_tag_t tag, nm_tag_t mask)
{
  nm_core_t p_core = nm_core_get_singleton();
  const nm_core_tag_t core_tag = nm_core_tag_build(p_session->hash_code, tag);
  const nm_core_tag_t core_mask = nm_core_tag_build(NM_CORE_TAG_HASH_FULL, mask);
  nm_core_unpack_match_recv(p_core, &p_request->req, p_gate, core_tag, core_mask);
}
 
static inline void nm_sr_recv_match_event(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request,
                                          const nm_sr_event_info_t*p_event)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_unpack_match_event(p_core, &p_request->req, p_event->recv_unexpected.p_core_event);
}
 
static inline int nm_sr_recv_post(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_unpack_submit(p_core, &p_request->req, NM_REQ_FLAG_NONE);
  return NM_ESUCCESS;
}
 
static inline int nm_sr_recv_peek(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request,
                                  const struct nm_data_s*p_data)
{
  nm_core_t p_core = nm_core_get_singleton();
  int err = nm_core_unpack_peek(p_core, &p_request->req, p_data, 0, nm_data_size(p_data));
  return err;
}
 
static inline int nm_sr_recv_peek_offset(nm_session_t p_session  __attribute__((unused)), nm_sr_request_t*p_request,
                                         const struct nm_data_s*p_data, nm_len_t peek_offset, nm_len_t peek_len)
{
  nm_core_t p_core = nm_core_get_singleton();
  int err = nm_core_unpack_peek(p_core, &p_request->req, p_data, peek_offset, peek_len);
  return err;
}
 
static inline void nm_sr_recv_offset(nm_session_t p_session __attribute__((unused)),
                                     nm_sr_request_t*p_request, nm_len_t offset)
{
  nm_core_t p_core = nm_core_get_singleton();
  nm_core_unpack_offset(p_core, &p_request->req, offset);
}
 
static inline int nm_sr_recv_iprobe(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  int err = nm_core_unpack_iprobe(p_core, &p_request->req);
  return err;
}
 
static inline void nm_sr_recv_data_wait(nm_session_t p_session __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  assert(nm_status_test(&p_request->req, NM_STATUS_UNPACK_POSTED));
  nm_status_wait(&p_request->req, NM_STATUS_UNPACK_DATA0, p_core);
}
 
static inline void nm_sr_recv_data_size_wait(nm_session_t p_session  __attribute__((unused)), nm_sr_request_t*p_request)
{
  nm_core_t p_core = nm_core_get_singleton();
  assert(nm_status_test(&p_request->req, NM_STATUS_UNPACK_POSTED));
  nm_status_wait(&p_request->req, NM_STATUS_UNPACK_DATA_SIZE, p_core);
}
 
static inline int nm_sr_recv_data_test(nm_session_t p_session, nm_sr_request_t*p_request)
{
  assert(nm_status_test(&p_request->req, NM_STATUS_UNPACK_POSTED));
  if(nm_status_test(&p_request->req, NM_STATUS_UNPACK_DATA0))
    {
      return NM_ESUCCESS;
    }
  else
    {
      nm_sr_progress(p_session);
      return -NM_EAGAIN;
    }
}
 
#endif /* NM_SENDRECV_PRIVATE_H*/