test_interpolation_gen_config.c

Go to the documentation of this file.

// Copyright (c) 2025 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <mpi.h>
#include <string.h>
 
#include "tests.h"
#include "test_common.h"
 
#include "interpolation/interpolation_gen_config_internal.h"
#include "collection_selection_internal.h"
 
static void utest_default_values(void);
static void utest_setters_and_getters(void);
static void utest_copy(void);
static void utest_delete_null(void);
static void utest_compare(void);
static void utest_pack_unpack(void);
 
int main(void) {
 
  MPI_Init(NULL, NULL);
 
  utest_default_values();
  utest_setters_and_getters();
  utest_copy();
  utest_delete_null();
  utest_compare();
  utest_pack_unpack();
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_default_values(void) {
 
  struct yac_interpolation_gen_config *gen_config =
    yac_interpolation_gen_config_new();
 
  if (gen_config == NULL) PUT_ERR("config is NULL after construction");
 
  if (yac_interpolation_gen_config_get_reorder(gen_config) != YAC_MAPPING_ON_SRC)
    PUT_ERR("default reorder should be YAC_MAPPING_ON_SRC");
 
  /* collection_selection has to be explicitly set -> no default value*/
 
  if (yac_interpolation_gen_config_get_frac_mask_fallback_value(gen_config) !=
      YAC_FRAC_MASK_NO_VALUE)
    PUT_ERR("wrong default frac_mask_fallback_value");
 
  if (yac_interpolation_gen_config_get_scaling_factor(gen_config) != 1.0)
    PUT_ERR("wrong default scaling_factor");
 
  if (yac_interpolation_gen_config_get_scaling_summand(gen_config) != 0.0)
    PUT_ERR("wrong default scaling_summand");
 
  if (yac_interpolation_gen_config_get_yaxt_exchanger_name(gen_config) != NULL)
    PUT_ERR("default exchanger name should be NULL");
 
  yac_interpolation_gen_config_delete(gen_config);
}
 
static void utest_setters_and_getters(void) {
 
  struct yac_interpolation_gen_config *gen_config =
    yac_interpolation_gen_config_new();
 
  /* reorder */
  yac_interpolation_gen_config_set_reorder(gen_config, YAC_MAPPING_ON_TGT);
  if (yac_interpolation_gen_config_get_reorder(gen_config) != YAC_MAPPING_ON_TGT)
    PUT_ERR("set/get reorder failed");
 
  /* contiguous collection selection*/
  struct yac_collection_selection * cont_coll_sel =
    yac_collection_selection_new(5, NULL);
  yac_interpolation_gen_config_set_collection_size(gen_config, 5);
  if (yac_collection_selection_compare(
        yac_interpolation_gen_config_get_collection_selection(gen_config),
        cont_coll_sel))
    PUT_ERR("set collection_size failed");
  yac_collection_selection_delete(cont_coll_sel);
 
  /* non-contiguous collection selection*/
  struct yac_collection_selection * non_cont_coll_sel =
    yac_collection_selection_new(3, (size_t[]){2, 3, 1});
  yac_interpolation_gen_config_set_collection_selection(
    gen_config, non_cont_coll_sel);
  if (yac_collection_selection_compare(
        yac_interpolation_gen_config_get_collection_selection(gen_config),
        non_cont_coll_sel))
    PUT_ERR("set/get collection_selection failed");
  yac_collection_selection_delete(non_cont_coll_sel);
 
 
  /* frac_mask_fallback_value */
  yac_interpolation_gen_config_set_frac_mask_fallback_value(gen_config, 0.75);
  if (yac_interpolation_gen_config_get_frac_mask_fallback_value(gen_config) != 0.75)
    PUT_ERR("set/get frac_mask_fallback_value failed");
 
  /* scaling_factor */
  yac_interpolation_gen_config_set_scaling_factor(gen_config, 2.0);
  if (yac_interpolation_gen_config_get_scaling_factor(gen_config) != 2.0)
    PUT_ERR("set/get scaling_factor failed");
 
  /* scaling_summand */
  yac_interpolation_gen_config_set_scaling_summand(gen_config, -0.5);
  if (yac_interpolation_gen_config_get_scaling_summand(gen_config) != -0.5)
    PUT_ERR("set/get scaling_summand failed");
 
  /* exchanger name */
  const char *name = "custom_exchanger";
  yac_interpolation_gen_config_set_yaxt_exchanger_name(gen_config, name);
  if (strcmp(
       yac_interpolation_gen_config_get_yaxt_exchanger_name(gen_config), name))
    PUT_ERR("set/get yaxt_exchanger_name failed");
 
  yac_interpolation_gen_config_delete(gen_config);
}
 
static void utest_copy(void) {
 
  struct yac_interpolation_gen_config *orig =
    yac_interpolation_gen_config_new();
 
  yac_interpolation_gen_config_set_reorder(orig, YAC_MAPPING_ON_TGT);
  yac_interpolation_gen_config_set_collection_size(orig, 42);
  yac_interpolation_gen_config_set_frac_mask_fallback_value(orig, 0.5);
  yac_interpolation_gen_config_set_scaling_factor(orig, 3.14);
  yac_interpolation_gen_config_set_scaling_summand(orig, -7.5);
  const char *name = "copy_exchanger";
  yac_interpolation_gen_config_set_yaxt_exchanger_name(orig, name);
 
  struct yac_interpolation_gen_config *copy =
    yac_interpolation_gen_config_copy(orig);
 
  if (copy == NULL)
    PUT_ERR("copy is NULL");
 
  if (yac_interpolation_gen_config_get_reorder(copy) !=
      yac_interpolation_gen_config_get_reorder(orig))
    PUT_ERR("reorder mismatch in copy");
 
  if (yac_collection_selection_compare(
        yac_interpolation_gen_config_get_collection_selection(copy),
        yac_interpolation_gen_config_get_collection_selection(orig)))
    PUT_ERR("collection_selection mismatch in copy");
 
  if (yac_interpolation_gen_config_get_frac_mask_fallback_value(copy) !=
      yac_interpolation_gen_config_get_frac_mask_fallback_value(orig))
    PUT_ERR("frac_mask_fallback_value mismatch in copy");
 
  if (yac_interpolation_gen_config_get_scaling_factor(copy) !=
      yac_interpolation_gen_config_get_scaling_factor(orig))
    PUT_ERR("scaling_factor mismatch in copy");
 
  if (yac_interpolation_gen_config_get_scaling_summand(copy) !=
      yac_interpolation_gen_config_get_scaling_summand(orig))
    PUT_ERR("scaling_summand mismatch in copy");
 
  if (strcmp(
        yac_interpolation_gen_config_get_yaxt_exchanger_name(copy),
        yac_interpolation_gen_config_get_yaxt_exchanger_name(orig)))
    PUT_ERR("yaxt_exchanger_name pointer mismatch in copy");
 
  yac_interpolation_gen_config_delete(orig);
  yac_interpolation_gen_config_delete(copy);
 
  /* NULL is a valid input */
  struct yac_interpolation_gen_config *null_copy =
    yac_interpolation_gen_config_copy(NULL);
 
  if (null_copy != NULL)
    PUT_ERR("copy of NULL config should be NULL");
}
 
static void utest_delete_null(void) {
  /* should not crash */
  yac_interpolation_gen_config_delete(NULL);
}
 
static void utest_compare(void) {
 
  { // both are NULL
    if (yac_interpolation_gen_config_compare(NULL, NULL) != 0)
      PUT_ERR("yac_interpolation_gen_config_compare(NULL, NULL) failed");
  }
 
  { // One is NULL, the other is not
    struct yac_interpolation_gen_config * a =
      yac_interpolation_gen_config_new();
    if (yac_interpolation_gen_config_compare(a, NULL) == 0)
      PUT_ERR("yac_interpolation_gen_config_compare(a, NULL) failed");
    if (+yac_interpolation_gen_config_compare(a, NULL) !=
        -yac_interpolation_gen_config_compare(NULL, a))
      PUT_ERR("yac_interpolation_gen_config_compare(a, NULL) failed");
    yac_interpolation_gen_config_delete(a);
  }
 
  { // Both are different
 
    struct yac_interpolation_gen_config * a =
      yac_interpolation_gen_config_new();
    struct yac_interpolation_gen_config * b =
      yac_interpolation_gen_config_new();
 
    enum yac_interp_weights_reorder_type reorder_types[] = {
      YAC_MAPPING_ON_SRC, YAC_MAPPING_ON_TGT};
    enum {NUM_REORDER_TYPES = sizeof(reorder_types) / sizeof(reorder_types[0])};
 
    size_t collection_sizes[] = {1,3};
    enum {
      NUM_COLLECTION_SIZES =
      sizeof(collection_sizes) / sizeof(collection_sizes[0])};
 
    double frac_mask_values[] = {0.0, NAN};
    enum {NUM_FRAC_MASK_VALUES =
      sizeof(frac_mask_values) / sizeof(frac_mask_values[0])};
 
    double scaling_factors[] = {-1.0, 1.0};
    enum {NUM_SCALING_FACTORS =
      sizeof(scaling_factors) / sizeof(scaling_factors[0])};
 
    double scaling_summands[] = {0.0, 1.0};
    enum {NUM_SCALING_SUMMANDS =
      sizeof(scaling_summands) / sizeof(scaling_summands[0])};
 
    const char *exchanger_names[] = {NULL, "irecv_isend"};
    enum {NUM_EXCHANGER_NAMES =
      sizeof(exchanger_names) / sizeof(exchanger_names[0])};
 
    for (size_t reorder_a = 0; reorder_a < NUM_REORDER_TYPES; ++reorder_a) {
      yac_interpolation_gen_config_set_reorder(a, reorder_types[reorder_a]);
 
      for (size_t reorder_b = 0; reorder_b < NUM_REORDER_TYPES; ++reorder_b) {
        yac_interpolation_gen_config_set_reorder(b, reorder_types[reorder_b]);
 
        for (size_t col_a = 0; col_a < NUM_COLLECTION_SIZES; ++col_a) {
          yac_interpolation_gen_config_set_collection_size(
            a, collection_sizes[col_a]);
 
          for (size_t col_b = 0; col_b < NUM_COLLECTION_SIZES; ++col_b) {
            yac_interpolation_gen_config_set_collection_size(
              b, collection_sizes[col_b]);
 
            for (size_t frac_a = 0; frac_a < NUM_FRAC_MASK_VALUES; ++frac_a) {
              yac_interpolation_gen_config_set_frac_mask_fallback_value(
                a, frac_mask_values[frac_a]);
 
              for (size_t frac_b = 0; frac_b < NUM_FRAC_MASK_VALUES; ++frac_b) {
                yac_interpolation_gen_config_set_frac_mask_fallback_value(
                  b, frac_mask_values[frac_b]);
 
                for (size_t scale_a = 0; scale_a < NUM_SCALING_FACTORS; ++scale_a) {
                  yac_interpolation_gen_config_set_scaling_factor(
                    a, scaling_factors[scale_a]);
 
                  for (size_t scale_b = 0; scale_b < NUM_SCALING_FACTORS; ++scale_b) {
                    yac_interpolation_gen_config_set_scaling_factor(
                      b, scaling_factors[scale_b]);
 
                    for (size_t sum_a = 0; sum_a < NUM_SCALING_SUMMANDS; ++sum_a) {
                      yac_interpolation_gen_config_set_scaling_summand(
                        a, scaling_summands[sum_a]);
 
                      for (size_t sum_b = 0; sum_b < NUM_SCALING_SUMMANDS; ++sum_b) {
                        yac_interpolation_gen_config_set_scaling_summand(
                          b, scaling_summands[sum_b]);
 
                        for (size_t exch_a = 0; exch_a < NUM_EXCHANGER_NAMES; ++exch_a) {
                          yac_interpolation_gen_config_set_yaxt_exchanger_name(
                            a, exchanger_names[exch_a]);
 
                          for (size_t exch_b = 0; exch_b < NUM_EXCHANGER_NAMES; ++exch_b) {
                            yac_interpolation_gen_config_set_yaxt_exchanger_name(
                              b, exchanger_names[exch_b]);
 
                            int cmp = yac_interpolation_gen_config_compare(a, b);
                            int cmp_rev = yac_interpolation_gen_config_compare(b, a);
 
                            int identical =
                              (reorder_a == reorder_b) &&
                              (col_a == col_b) &&
                              (frac_a == frac_b) &&
                              (scale_a == scale_b) &&
                              (sum_a == sum_b) &&
                              (exch_a == exch_b);
 
                            if (identical) {
                              if (cmp != 0)
                                PUT_ERR("identical configurations compare nonzero");
                            } else {
                              if (cmp == 0)
                                PUT_ERR("different configurations compare equal");
                              if (cmp != -cmp_rev)
                                PUT_ERR("antisymmetry property failed");
                            }
 
                          } // exch_b
                        } // exch_a
                      } // sum_b
                    } // sum_a
                  } // scale_b
                } // scale_a
              } // frac_b
            } // frac_a
          } // col_b
        } // col_a
      } // reorder_b
    } // reorder_a
 
    // cleanup
    yac_interpolation_gen_config_delete(b);
    yac_interpolation_gen_config_delete(a);
  }
}
 
static void utest_pack_unpack(void) {
 
  MPI_Comm comm = MPI_COMM_SELF;
 
  struct {
    enum yac_interp_weights_reorder_type reorder;
    double frac_mask_fallback_value;
    double scaling_factor;
    double scaling_summand;
    size_t collection_size;
    const char * yaxt_exchanger_name;
  } test_cases[] =
    {{.reorder = YAC_MAPPING_ON_SRC,
      .frac_mask_fallback_value = 1.0,
      .scaling_factor = 1.0,
      .scaling_summand = 0.0,
      .collection_size = 3,
      .yaxt_exchanger_name = NULL},
     {.reorder = YAC_MAPPING_ON_SRC,
      .frac_mask_fallback_value = 1.0,
      .scaling_factor = 1.0,
      .scaling_summand = 0.0,
      .collection_size = 5,
      .yaxt_exchanger_name = "irecv_isend"}};
  enum { NUM_TESTS = sizeof(test_cases) / sizeof(test_cases[0]) };
 
  struct yac_interpolation_gen_config * orig =
    yac_interpolation_gen_config_new();
 
  for (size_t t = 0; t < NUM_TESTS; ++t) {
 
    yac_interpolation_gen_config_set_reorder(
      orig, test_cases[t].reorder);
    yac_interpolation_gen_config_set_collection_size(
      orig, test_cases[t].collection_size);
    yac_interpolation_gen_config_set_frac_mask_fallback_value(
      orig, test_cases[t].frac_mask_fallback_value);
    yac_interpolation_gen_config_set_scaling_factor(
      orig, test_cases[t].scaling_factor);
    yac_interpolation_gen_config_set_scaling_summand(
      orig, test_cases[t].scaling_summand);
    yac_interpolation_gen_config_set_yaxt_exchanger_name(
      orig, test_cases[t].yaxt_exchanger_name);
 
    size_t pack_size = yac_interpolation_gen_config_get_pack_size(orig, comm);
    YAC_ASSERT(
      pack_size > 0, "utest_pack_unpack_config: pack_size must be positive");
 
    void *buffer = xmalloc(pack_size);
    int position = 0;
 
    yac_interpolation_gen_config_pack(
      orig, buffer, (int)pack_size, &position, comm);
 
    int unpack_position = 0;
    struct yac_interpolation_gen_config * copy =
      yac_interpolation_gen_config_unpack(
        buffer, (int)pack_size, &unpack_position, comm);
 
    if (yac_interpolation_gen_config_compare(orig, copy))
      PUT_ERR("error pack/unpack");
 
    // cleanup
    yac_interpolation_gen_config_delete(copy);
    free(buffer);
  }
 
  yac_interpolation_gen_config_delete(orig);
}