nm_core_inline.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_INLINE_H
#define NM_CORE_INLINE_H
 
/* ** Driver management ************************************ */
 
static inline struct nm_trk_s*nm_gate_trk_get(nm_gate_t p_gate, nm_drv_t p_drv)
{
  assert(p_drv != NULL);
  int i;
  for(i = 0; i < p_gate->n_trks; i++)
    {
      if(p_gate->trks[i].p_drv == p_drv)
        return &p_gate->trks[i];
    }
  return NULL;
}
 
static inline struct nm_trk_s*nm_trk_get_by_index(nm_gate_t p_gate, int index)
{
  assert(p_gate->n_trks > 0);
  assert(index < p_gate->n_trks);
  assert(index >= 0);
  return &p_gate->trks[index];
}
 
static inline nm_len_t nm_drv_max_small(const struct nm_drv_s*const p_drv)
{
  const nm_len_t max_small = (NM_MAX_UNEXPECTED - NM_HEADER_DATA_SIZE - NM_ALIGN_FRONTIER);
  return (p_drv->props.capabilities.max_msg_size > max_small) ? max_small : p_drv->props.capabilities.max_msg_size;
}
 
static inline int nm_trk_can_recv(const struct nm_trk_s*p_trk)
{
  const int max_pkt_recvs = p_trk->p_drv->props.capabilities.max_pkt_recvs;
  const int cur = nm_pkt_wrap_list_size(&p_trk->active_pw_recv);
  assert(max_pkt_recvs >= 1);
  assert(cur >= 0);
  return (cur < max_pkt_recvs);
}
 
static inline int nm_trk_can_send(const struct nm_trk_s*p_trk)
{
  const int max_pkt_sends = p_trk->p_drv->props.capabilities.max_pkt_sends;
  const int cur = nm_pkt_wrap_list_size(&p_trk->active_pw_send);
  assert(max_pkt_sends >= 1);
  assert(cur >= 0);
  return (cur < max_pkt_sends);
}
 
/* ** Packet wrapper management **************************** */
 
static inline void nm_pw_assign(struct nm_pkt_wrap_s*p_pw, nm_trk_id_t trk_id, struct nm_drv_s*p_drv, nm_gate_t p_gate)
{
  p_pw->trk_id = trk_id;
  if(p_gate == NM_GATE_NONE)
    {
      assert(p_drv->p_pw_recv_any == NULL);
      assert(p_drv != NULL);
      p_drv->p_pw_recv_any = p_pw;
      p_pw->p_trk = NULL;
      p_pw->p_drv = p_drv;
    }
  else
    {
      assert(trk_id >= 0);
      assert(trk_id < p_gate->n_trks);
      p_pw->p_gate = p_gate;
      p_pw->p_trk = &p_gate->trks[trk_id];
      p_pw->p_drv = p_pw->p_trk->p_drv;
    }
}
 
#define nm_pw_ref_inc(P_PW, LABEL) nm_refcount_inc(&(P_PW)->refcount, (LABEL))
 
static inline void nm_pw_ref_dec(struct nm_pkt_wrap_s*p_pw, const char*label)
{
  nm_core_lock_assert(nm_core_get_singleton()); /* needed by nm_pw_free, check early for easier debug */
  const int count = nm_refcount_dec(&p_pw->refcount, label);
  assert(count >= 0);
  if(count == 0)
    {
      struct nm_core*p_core = nm_core_get_singleton();
      nm_pw_free(p_core, p_pw);
    }
}
static inline void nm_pw_ref_dec_free(struct nm_pkt_wrap_s*p_pw, const char*label)
{
  assert(nm_refcount_get(&p_pw->refcount) == 1);
  nm_pw_ref_dec(p_pw, label);
}
 
static inline void nm_header_global_finalize(struct nm_pkt_wrap_s*p_pw)
{
  struct nm_header_global_s*h = p_pw->v[0].iov_base;
  const int v0len = p_pw->v[0].iov_len;
  assert(p_pw->trk_id == NM_TRK_SMALL);
  assert(v0len <= UINT16_MAX);
  h->v0len = v0len;
}
 
static inline uint16_t nm_header_global_v0len(const struct nm_pkt_wrap_s*p_pw)
{
  assert(p_pw->flags & (NM_PW_GLOBAL_HEADER | NM_PW_BUFFER | NM_PW_BUF_SEND));
  const struct nm_header_global_s*h = p_pw->v[0].iov_base;
  return h->v0len;
}
 
/* ** Gate ************************************************* */
 
static inline int nm_gate_isactive(struct nm_gate_s*p_gate)
{
  return( (!nm_req_chunk_list_empty(&p_gate->req_chunk_list)) ||
          (!nm_ctrl_chunk_list_empty(&p_gate->ctrl_chunk_list)) ||
          (!nm_pkt_wrap_list_empty(&p_gate->pending_large_recv)));
}
 
static inline int nm_gate_is_in_active_list(struct nm_core*p_core, struct nm_gate_s*p_gate)
{
  return ((p_gate == nm_active_gate_list_begin(&p_core->active_gates)) ||
          (!nm_active_gate_list_cell_isnull(p_gate)));
}
 
static inline void nm_gate_set_active(struct nm_gate_s*p_gate)
{
  nm_core_lock_assert(p_gate->p_core);
  if( (!nm_gate_is_in_active_list(p_gate->p_core, p_gate)) &&
      nm_gate_isactive(p_gate))
    {
      assert(!nm_active_gate_list_contains(&p_gate->p_core->active_gates, p_gate));
      nm_active_gate_list_push_back(&p_gate->p_core->active_gates, p_gate);
      assert(nm_gate_is_in_active_list(p_gate->p_core, p_gate));
    }
}
 
/* ** Core tasks ******************************************* */
 
static inline void nm_core_task_enqueue(struct nm_core*p_core, int holding_lock, struct nm_core_task_s*p_core_task)
{
  assert(p_core_task->kind != NM_CORE_TASK_NONE);
  if(holding_lock)
    {
      nm_core_lock_assert(p_core);
    }
  else
    {
      nm_core_nolock_assert(p_core);
    }
  int rc;
  do
    {
#ifdef PIOMAN_MULTITHREAD
      rc = nm_core_task_lfqueue_enqueue(&p_core->pending_tasks, p_core_task);
#else
      rc = nm_core_task_lfqueue_enqueue_single_writer(&p_core->pending_tasks, p_core_task);
#endif /* PIOMAN_MULTITHREAD */
      if(rc)
        {
          if(holding_lock)
            {
              nm_core_task_flush(p_core);
            }
          else
            {
              if(nm_core_trylock(p_core))
                {
                  nm_core_task_flush(p_core);
                  nm_core_unlock(p_core);
                }
            }
        }
    }
  while(rc);
}
 
static inline void nm_pw_completed_enqueue(struct nm_core*p_core, struct nm_pkt_wrap_s*p_pw)
{
  nm_core_nolock_assert(p_core);
  assert(!(p_pw->flags & NM_PW_COMPLETED));
  p_pw->flags |= NM_PW_COMPLETED;
#ifdef PIOMAN
  piom_ltask_completed(&p_pw->ltask);
#else /* PIOMAN */
  nm_pw_poll_list_remove(&p_core->pw_poll_list, p_pw);
#endif /* PIOMAN */
  nm_pw_ref_inc(p_pw, nm_pw_refcount_completion); /* keep pw alive up to core_task completion */
  assert(p_pw->core_task.kind == NM_CORE_TASK_NONE);
  p_pw->core_task.kind = NM_CORE_TASK_COMPLETED_PW;
  p_pw->core_task.content.completed_pw.p_pw = p_pw;
  nm_core_task_enqueue(p_core, 0, &p_pw->core_task);
}
 
 
/* ** req chunks ******************************************* */
 
static inline void nm_req_chunk_submit(struct nm_core*p_core, struct nm_req_chunk_s*p_req_chunk)
{
  nm_core_nolock_assert(p_core);
  assert(p_req_chunk->p_req != NULL);
  assert(p_req_chunk->core_task.kind == NM_CORE_TASK_NONE);
  p_req_chunk->core_task.kind = NM_CORE_TASK_PACK_SUBMISSION;
  p_req_chunk->core_task.content.pack_submission.p_req_chunk = p_req_chunk;
  nm_core_task_enqueue(p_core, 0, &p_req_chunk->core_task);
}
 
static inline void nm_req_chunk_destroy(struct nm_core*p_core, struct nm_req_chunk_s*p_req_chunk)
{
  struct nm_req_s*p_pack = p_req_chunk->p_req;
  nm_req_chunk_list_check_null(p_req_chunk);
#ifdef NMAD_DEBUG
  p_req_chunk->chunk_len = NM_LEN_UNDEFINED;
  p_req_chunk->chunk_offset = NM_LEN_UNDEFINED;
#endif
  if(p_req_chunk != &p_pack->req_chunk)
    {
      nm_req_chunk_free(&p_core->req_chunk_allocator, p_req_chunk);
    }
  else
    {
      p_pack->req_chunk.p_req = NULL;
    }
}
 
static inline struct nm_req_chunk_s*nm_req_chunk_alloc(struct nm_core*p_core)
{
  struct nm_req_chunk_s*p_req_chunk = nm_req_chunk_malloc(&p_core->req_chunk_allocator);
  nm_req_chunk_list_cell_init(p_req_chunk);
  return p_req_chunk;
}
 
static inline void nm_req_chunk_init(struct nm_req_chunk_s*p_req_chunk, struct nm_req_s*p_req,
                                     nm_len_t chunk_offset, nm_len_t chunk_len)
{
  nm_req_chunk_list_cell_init(p_req_chunk);
  p_req_chunk->core_task.kind = NM_CORE_TASK_NONE;
  p_req_chunk->p_req        = p_req;
  p_req_chunk->chunk_offset = chunk_offset;
  p_req_chunk->chunk_len    = chunk_len;
  p_req_chunk->proto_flags  = 0;
  assert(chunk_offset + chunk_len <= p_req->pack.len);
  if(chunk_offset + chunk_len == p_req->pack.len)
    {
      p_req_chunk->proto_flags |= NM_PROTO_FLAG_LASTCHUNK;
    }
  if(p_req->flags & NM_REQ_FLAG_PACK_SYNCHRONOUS)
    {
      p_req_chunk->proto_flags |= NM_PROTO_FLAG_ACKREQ;
    }
  nm_data_chunk_properties_compute(&p_req->data, chunk_offset, chunk_len, &p_req_chunk->chunk_props);
}
 
static inline void nm_req_chunk_update(struct nm_req_chunk_s*p_req_chunk)
{
  assert(p_req_chunk->chunk_offset + p_req_chunk->chunk_len <= p_req_chunk->p_req->pack.len);
  if(p_req_chunk->chunk_offset + p_req_chunk->chunk_len == p_req_chunk->p_req->pack.len)
    {
      p_req_chunk->proto_flags |= NM_PROTO_FLAG_LASTCHUNK;
    }
  else
    {
      p_req_chunk->proto_flags &= ~NM_PROTO_FLAG_LASTCHUNK;
    }
  nm_data_chunk_properties_compute(&p_req_chunk->p_req->data, p_req_chunk->chunk_offset, p_req_chunk->chunk_len, &p_req_chunk->chunk_props);
}
 
static inline void nm_core_post_req_chunk(nm_core_t p_core, nm_gate_t p_gate, struct nm_req_chunk_s*p_req_chunk)
{
  nm_core_lock_assert(p_core);
  nm_req_chunk_list_push_back(&p_gate->req_chunk_list, p_req_chunk);
  nm_gate_set_active(p_gate);
}
 
static inline void nm_core_post_ctrl(nm_gate_t p_gate, nm_header_ctrl_generic_t*p_header,
                                     const void*p_payload, nm_len_t payload_size)
{
  struct nm_core*p_core = p_gate->p_core;
  nm_core_lock_assert(p_core);
  struct nm_ctrl_chunk_s*p_ctrl_chunk = nm_ctrl_chunk_malloc(&p_core->ctrl_chunk_allocator);
  nm_ctrl_chunk_list_cell_init(p_ctrl_chunk);
  p_ctrl_chunk->ctrl = *p_header;
  p_ctrl_chunk->p_gate = p_gate;
  p_ctrl_chunk->p_payload = p_payload;
  p_ctrl_chunk->size = payload_size;
  nm_ctrl_chunk_list_push_back(&p_gate->ctrl_chunk_list, p_ctrl_chunk);
  nm_gate_set_active(p_gate);
}
 
static inline void nm_core_post_rtr(nm_gate_t p_gate,  nm_core_tag_t tag, nm_seq_t seq,
                                    nm_trk_id_t trk_id, nm_len_t chunk_offset, nm_len_t chunk_len,
                                    const void*p_rdv_data, nm_len_t size)
{
  nm_header_ctrl_generic_t h;
  if(chunk_len == 0)
    {
      NM_FATAL("trying to post RTR with chunk_offset = %llu; chunk_len = %llu\n", (unsigned long long)chunk_offset, (unsigned long long)chunk_len);
    }
  nm_header_init_rtr(&h, tag, seq, trk_id, chunk_offset, chunk_len, size);
  nm_core_post_ctrl(p_gate, &h, p_rdv_data, size);
}
 
static inline void nm_core_post_ack(nm_gate_t p_gate, nm_core_tag_t tag, nm_seq_t seq)
{
  nm_header_ctrl_generic_t h;
  nm_header_init_ack(&h, tag, seq);
  nm_core_post_ctrl(p_gate, &h, NULL, 0);
}
 
static inline void nm_core_post_msg(nm_gate_t p_gate, nm_core_tag_t tag, nm_seq_t seq, nm_len_t msg_len)
{
  nm_header_ctrl_generic_t h;
  nm_header_init_msg(&h, tag, seq, msg_len);
  nm_core_post_ctrl(p_gate, &h, NULL, 0);
}
 
static inline void nm_core_polling_level(struct nm_core*p_core)
{
  nm_core_lock_assert(p_core);
  assert(p_core->n_packs >= 0);
  assert(p_core->n_unpacks >= 0);
#ifdef PIOMAN
  const int high =
    (p_core->n_packs > 0) ||
    (p_core->n_unpacks > 0) ||
    (!nm_core_task_lfqueue_empty(&p_core->pending_tasks));
  piom_ltask_poll_level_set(high);
#endif /* PIOMAN */
}
 
/* ** Tags & matching ************************************** */
 
static inline struct nm_matching_wildcard_s*nm_matching_wildcard_bytag(struct nm_core*p_core, nm_core_tag_t core_tag)
{
  const nm_core_tag_t session_tag = nm_core_tag_build(nm_core_tag_get_hashcode(core_tag), 0);
  struct nm_matching_wildcard_s*p_wildcard = nm_matching_wildcard_get(&p_core->wildcard_table, session_tag);
  return p_wildcard;
}
 
static inline struct nm_matching_gsession_s*nm_matching_gsession_bytag(struct nm_gate_s*p_gate, nm_core_tag_t core_tag)
{
  const nm_core_tag_t session_tag = nm_core_tag_build(nm_core_tag_get_hashcode(core_tag), 0);
  struct nm_matching_gsession_s*p_gsession = nm_matching_gsession_get(&p_gate->gsessions, session_tag);
  return p_gsession;
}
 
 
#endif /* NM_CORE_INLINE_H */