nm_examples_helper.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.
 */
 
#include <nm_public.h>
#include <nm_launcher_interface.h>
#include <nm_sendrecv_interface.h>
#include <nm_coll_interface.h>
 
 
/* ********************************************************* */
 
static int is_server = -1;
static nm_session_t p_session = NULL;
static nm_gate_t p_gate = NULL;
static nm_comm_t p_comm = NULL;
 
static const nm_tag_t data_tag = 0x01;
static const nm_tag_t sync_tag = 0x02;
 
enum nm_example_topo_e
  {
    NM_EXAMPLES_TOPO_RING,
    NM_EXAMPLES_TOPO_PAIRS,
    NM_EXAMPLES_TOPO_STAR
  };
 
static void nm_examples_init_topo(int*argc, char*argv[], enum nm_example_topo_e topo)
{
  int rank, size, peer;
  nm_launcher_init(argc, argv);
  nm_session_open(&p_session, "nm_example");
  nm_launcher_get_rank(&rank);
  nm_launcher_get_size(&size);
  switch(topo)
    {
    case NM_EXAMPLES_TOPO_RING:
      is_server = (rank == 0);
      peer = (rank + 1) % size;
      break;
    case NM_EXAMPLES_TOPO_PAIRS:
      if(size % 2 != 0)
        {
          fprintf(stderr, "%s: FATAL- needs an even number of nodes.\n", argv[0]);
          abort();
        }
      is_server = ((rank % 2) == 0);
      peer = is_server ? (rank + 1) : (rank - 1);
      break;
    case NM_EXAMPLES_TOPO_STAR:
      is_server = (rank == 0);
      peer = 0;
      break;
    default:
      abort();
      break;
    }
  nm_launcher_get_gate(peer, &p_gate);
  p_comm = nm_comm_world("nm_example");
}
 
/* barrier accross all nodes */
static inline void nm_examples_barrier(nm_tag_t tag)
{
  nm_coll_barrier(p_comm, tag);
}
 
static inline void nm_examples_init(int*argc, char*argv[])
{
  nm_examples_init_topo(argc, argv, NM_EXAMPLES_TOPO_RING);
}
 
static inline void nm_examples_exit(void)
{
  nm_examples_barrier(0xFFFF);
  if(p_comm)
    nm_comm_destroy(p_comm);
  nm_session_close(p_session);
  nm_launcher_exit();
}
 
 
/* ********************************************************* */
 
/* ** helpers for size iterators */
 
static inline nm_len_t _next(nm_len_t len, double multiplier, nm_len_t increment)
{
  nm_len_t next = len * multiplier + increment;
  if(next <= len)
    next++;
  return next;
}
 
/* ** helpers for buffers */
 
static inline char buffer_content(nm_len_t offset, int seed)
{
  return 'a' + ((seed + offset) % 26);
}
 
static inline void fill_buffer_seed(char*buffer, nm_len_t len, int seed) __attribute__((unused));
static inline void fill_buffer_seed(char*buffer, nm_len_t len, int seed)
{
  nm_len_t i = 0;
  for(i = 0; i < len; i++)
    {
      buffer[i] = buffer_content(i, seed);
    }
}
 
static inline void fill_buffer(char*buffer, nm_len_t len) __attribute__((unused));
static inline void fill_buffer(char*buffer, nm_len_t len)
{
  fill_buffer_seed(buffer, len , 0);
}
 
static inline void clear_buffer(char*buffer, nm_len_t len) __attribute__((unused));
static inline void clear_buffer(char*buffer, nm_len_t len)
{
  memset(buffer, 0, len);
}
 
static inline void control_buffer_seed(const char*buffer, nm_len_t len, int seed) __attribute__((unused));
static inline void control_buffer_seed(const char*buffer, nm_len_t len, int seed)
{
  nm_len_t i = 0;
  for(i = 0; i < len; i++)
    {
      const char expected = buffer_content(i, seed);
      if(buffer[i] != expected)
        {
          fprintf(stderr, "Bad data at byte %d: expected 0x%x (%c), received 0x%x (%c)\n",
                  (int)i, expected, expected, buffer[i], buffer[i]);
          abort();
        }
    }
}
 
static inline void control_buffer(const char*buffer, nm_len_t len) __attribute__((unused));
static inline void control_buffer(const char*buffer, nm_len_t len)
{
  control_buffer_seed(buffer, len, 0);
}
 
static inline void compute(unsigned usec)
{
  if(usec > 0)
    {
      puk_tick_t t1, t2;
      PUK_GET_TICK(t1);
      do
        {
          PUK_GET_TICK(t2);
        }
      while(PUK_TIMING_DELAY(t1,t2) < usec);
    }
}
 
#define check_rc(RC)                                            \
  if((RC) != NM_ESUCCESS)                                       \
    {                                                           \
      fprintf(stderr, "Error %d (%s) in %s line %d\n",          \
              (RC), nm_strerror(RC), __FILE__, __LINE__);       \
      abort();                                                  \
    }
 
static inline void fisher_yates_shuffle(int*p_array, size_t n)
{
  srand(n); /* ensure all nodes use the same seed */
  size_t i;
  for(i = 0; i < n - 1; i++)
    {
      const int r = rand() % (n - 1 - i);
      const int tmp = p_array[i];
      p_array[i] = p_array[i + r];
      p_array[i + r] = tmp;
    }
}
 
static inline struct nm_group_s*nm_examples_group_inorder(int n)
{
  nm_group_t p_group = nm_group_new();
  int i;
  for(i = 0; i < n; i++)
    {
      nm_group_add_node(p_group, nm_comm_get_gate(p_comm, i));
    }
  return p_group;
}
 
static inline struct nm_group_s*nm_examples_group_reverse(int n)
{
  nm_group_t p_group = nm_group_new();
  int i;
  for(i = n - 1; i >= 0; i--)
    {
      nm_group_add_node(p_group, nm_comm_get_gate(p_comm, i));
    }
  return p_group;
}
 
static inline struct nm_group_s*nm_examples_group_shuffled(int n)
{
  int*p_index = padico_malloc(sizeof(int) * n);
  int i;
  for(i = 0; i < n; i++)
    {
      p_index[i] = i;
    }
  fisher_yates_shuffle(p_index, n);
  nm_group_t p_group = nm_group_new();
  for(i = 0; i < n; i++)
    {
      nm_group_add_node(p_group, nm_comm_get_gate(p_comm, p_index[i]));
    }
  padico_free(p_index);
  return p_group;
}