nm_coll_private.h

Go to the documentation of this file.

/*
 * NewMadeleine
 * Copyright (C) 2014-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_COLL_PRIVATE_H
#define NM_COLL_PRIVATE_H
 
#include <nm_public.h>
#include <nm_sendrecv_interface.h>
#include <nm_launcher_interface.h>
#include <nm_private.h>
#include <Padico/Puk.h>
 
#include "nm_coll_interface.h"
 
/* ********************************************************* */
 
#define NM_COLL_TAG_MASK_P2P      0x7FFFFFFF
#define NM_COLL_TAG_BASE          0xFF000000
#define NM_COLL_TAG_COMM_CREATE_1 ( NM_COLL_TAG_BASE | 0x04 )
#define NM_COLL_TAG_COMM_CREATE_2 ( NM_COLL_TAG_BASE | 0x05 )
 
/* ********************************************************* */
 
enum nm_coll_req_kind_e
  {
    NM_COLL_REQ_NONE = 0,
    NM_COLL_REQ_BARRIER_TREE,
    NM_COLL_REQ_BARRIER_BUTTERFLY,
    NM_COLL_REQ_BARRIER_BRUCK,
    NM_COLL_REQ_BCAST_TREE,
    NM_COLL_REQ_BCAST_PIPELINE,
    NM_COLL_REQ_BCAST_2TREES,
    NM_COLL_REQ_BCAST_TREEDRV, /* colldrv for intra-node, tree for inter-node */
    NM_COLL_REQ_SCATTER,
    NM_COLL_REQ_GATHER,
    NM_COLL_REQ_ALLGATHER_TREE,
    NM_COLL_REQ_ALLGATHER_BUTTERFLY,
    NM_COLL_REQ_ALLGATHER_BRUCK,
    NM_COLL_REQ_ALLGATHER_RBRUCK,
    NM_COLL_REQ_OTHER,   
    NM_COLL_REQ_COLLDRV, 
    NM_COLL_REQ_DEFAULT,
    _NM_COLL_REQ_KIND_MAX
  };
 
typedef enum nm_coll_req_kind_e nm_coll_req_kind_t;
 
typedef void (*nm_coll_req_destructor_t)(struct nm_coll_req_s*);
 
struct nm_coll_req_s
{
  nm_coll_req_kind_t kind;
  nm_coll_req_destructor_t p_destructor;
  nm_cond_status_t status;            
  nm_coll_req_notifier_t p_notify;    
  void*p_ref;                         
#ifdef NMAD_PROFILE
  struct
  {
    puk_tick_t start_time;
    struct nm_coll_profile_s*p_prof_local;
    struct nm_coll_profile_s*p_prof_global;
    nm_len_t bytes;
    int nodes;
  } profiling;
#endif /* NMAD_PROFILE */
  int _payload;                       
};
 
struct nm_coll_req_s*nm_coll_req_alloc(nm_len_t payload_size, nm_coll_req_kind_t kind,
                                       nm_coll_req_destructor_t p_destructor,
                                       nm_coll_req_notifier_t p_notify, void*p_ref);
 
static inline void*nm_coll_req_payload(struct nm_coll_req_s*p_coll_req)
{
  return (void*)&p_coll_req->_payload;
}
 
static inline struct nm_coll_req_s*nm_coll_req_container(void*p_payload)
{
  struct nm_coll_req_s*p_coll_req = puk_container_of(p_payload, struct nm_coll_req_s, _payload);
  return p_coll_req;
}
 
void nm_coll_req_signal(struct nm_coll_req_s*p_coll_req);
 
 
/* ********************************************************* */
 
static inline void nm_coll_datav_descendants(const struct nm_coll_tree_info_s*p_tree,
                                             struct nm_datav_s*p_datav, struct nm_data_s*p_data, nm_len_t data_size,
                                             int*p_descendants, int child, int child_weight)
{
  assert(child_weight > 0);
  if(p_descendants == NULL)
    {
      if(child + child_weight <= p_tree->n)
        {
          /* contig */
          nm_datav_add_chunk_excerpt(p_datav, p_data, data_size * child, data_size * child_weight);
        }
      else
        {
          /* wrap-around */
          const int w2 = child + child_weight - p_tree->n;
          const int w1 = child_weight - w2;
          nm_datav_add_chunk_excerpt(p_datav, p_data, data_size * child, data_size * w1);
          nm_datav_add_chunk_excerpt(p_datav, p_data, 0, data_size * w2);
        }
    }
  else
    {
      int start_index = p_descendants[0];
      int span = 1;
      int k;
      for(k = 1; k < child_weight; k++)
        {
          const int index = p_descendants[k];
          if(index == start_index + span)
            {
              span++;
            }
          else
            {
              nm_datav_add_chunk_excerpt(p_datav, p_data, data_size * start_index, data_size * span);
              start_index = index;
              span = 1;
            }
        }
      nm_datav_add_chunk_excerpt(p_datav, p_data, data_size * start_index, data_size * span);
    }
}
 
/* ** profiling ******************************************** */
 
struct nm_coll_profile_s
{
  unsigned long long n;           
  unsigned long long total_bytes; 
  unsigned long long total_nodes; 
  double total_time_usecs;
};
 
#ifdef NMAD_PROFILE
 
static inline void nm_coll_profile_add(struct nm_coll_profile_s*p_prof_local, struct nm_coll_profile_s*p_prof_global,
                                       nm_len_t bytes, int nodes, puk_tick_t start_time)
{
  puk_tick_t end_time;
  PUK_GET_TICK(end_time);
  const double tdiff = PUK_TIMING_DELAY(start_time, end_time);
  if(p_prof_local != NULL)
    {
      nm_profile_inc(p_prof_local->n);
      nm_profile_add(p_prof_local->total_bytes, bytes);
      nm_profile_add(p_prof_local->total_nodes, nodes);
      p_prof_local->total_time_usecs += tdiff;
    }
  if(p_prof_global != NULL)
    {
      nm_profile_inc(p_prof_global->n);
      nm_profile_add(p_prof_global->total_bytes, bytes);
      nm_profile_add(p_prof_global->total_nodes, nodes);
      p_prof_global->total_time_usecs += tdiff;
    }
}
 
static inline void nm_coll_profile_def(struct nm_coll_profile_s*p_profile, const char*name)
{
  puk_profile_var_defx(unsigned_long_long, counter, &p_profile->n, 0,
                       "total number of this coll op",
                       "nm_coll.%s.n", name);
  puk_profile_var_defx(unsigned_long_long, aggregate, &p_profile->total_bytes, 0,
                       "total number of bytes sent through this coll op",
                       "nm_coll.%s.total_bytes", name);
  puk_profile_var_defx(unsigned_long_long, aggregate, &p_profile->total_nodes, 0,
                       "total number of nodes involved in this coll op",
                       "nm_coll.%s.total_nodes", name);
  puk_profile_var_defx(double, timer, &p_profile->total_time_usecs, 0.0,
                       "total time spent in this coll op",
                       "nm_coll.%s.total_time_usecs", name);
}
 
static inline void nm_coll_req_set_profile(struct nm_coll_req_s*p_coll_req,
                                           struct nm_coll_profile_s*p_prof_local, struct nm_coll_profile_s*p_prof_global,
                                           nm_len_t bytes, int nodes)
{
  PUK_GET_TICK(p_coll_req->profiling.start_time);
  p_coll_req->profiling.p_prof_local = p_prof_local;
  p_coll_req->profiling.p_prof_global = p_prof_global;
  p_coll_req->profiling.bytes = bytes;
  p_coll_req->profiling.nodes = nodes;
}
 
#endif /* NMAD_PROFILE */
 
#endif /* NM_COLL_PRIVATE_H */