test_collection_selection.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <mpi.h>
 
#include "tests.h"
#include "test_common.h"
 
#include "collection_selection_internal.h"
 
static void utest_contiguous_with_indices_null(void);
static void utest_contiguous_with_explicit_contiguous_indices(void);
static void utest_single_with_explicit_zero_index(void);
static void utest_single_with_explicit_non_zero_index(void);
static void utest_noncontiguous(void);
static void utest_copy(void);
static void utest_zero_size(void);
static void test_compare(void);
static void utest_pack_unpack(void);
 
int main(void) {
 
  MPI_Init(NULL, NULL);
 
  utest_contiguous_with_indices_null();
  utest_contiguous_with_explicit_contiguous_indices();
  utest_noncontiguous();
  utest_single_with_explicit_zero_index();
  utest_single_with_explicit_non_zero_index();
  utest_copy();
  utest_zero_size();
  test_compare();
  utest_pack_unpack();
 
  MPI_Finalize();
 
  return TEST_EXIT_CODE;
}
 
static void utest_contiguous_with_indices_null(void) {
  size_t N = 5;
  struct yac_collection_selection *sel =
    yac_collection_selection_new(N, NULL);
 
  if (sel == NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != N)
      PUT_ERR("wrong collection_size");
  if (!yac_collection_selection_is_contiguous(sel))
    PUT_ERR("should be contiguous");
  if (yac_collection_selection_get_indices(sel) != NULL)
    PUT_ERR("indices should be NULL for contiguous");
  if (yac_collection_selection_get_max_index(sel) != (N - 1))
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void utest_contiguous_with_explicit_contiguous_indices(void) {
  size_t idxs[] = {0, 1, 2, 3};
  enum {N = sizeof(idxs) / sizeof(idxs[0])};
  struct yac_collection_selection *sel =
    yac_collection_selection_new(N, idxs);
 
  if (sel == NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != N)
    PUT_ERR("wrong collection_size");
  if (!yac_collection_selection_is_contiguous(sel))
    PUT_ERR("should be contiguous");
  if (yac_collection_selection_get_indices(sel) != NULL)
    PUT_ERR("indices should be NULL for contiguous");
  if (yac_collection_selection_get_max_index(sel) != (N - 1))
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void utest_noncontiguous(void) {
  size_t idxs[] = {0, 2, 3, 5};
  enum {N = sizeof(idxs) / sizeof(idxs[0])};
  struct yac_collection_selection *sel =
    yac_collection_selection_new(N, idxs);
 
  if (sel == NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != N)
    PUT_ERR("wrong collection_size");
  if (yac_collection_selection_is_contiguous(sel))
    PUT_ERR("should not be contiguous");
 
  size_t ref_max_index = 0;
  size_t const *got = yac_collection_selection_get_indices(sel);
  if (got == NULL) {
    PUT_ERR("indices should not be NULL for non-contiguous");
  } else {
    for (size_t i = 0; i < N; ++i) {
      if (got[i] != idxs[i]) PUT_ERR("wrong index value");
      if (ref_max_index < idxs[i]) ref_max_index = idxs[i];
    }
  }
 
  if (yac_collection_selection_get_max_index(sel) != ref_max_index)
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void utest_copy(void) {
 
  { /* test various collection selection configurations*/
    struct {
      size_t N;
      size_t * indices;
    } test_configs[] =
      {{.N = 3, .indices = (size_t[]){0, 2, 5}},
       {.N = 4, .indices = (size_t[]){0, 1, 2, 3}},
       {.N = 0, .indices = NULL},
       {.N = 5, .indices = NULL}};
    enum {NUM_TESTS = sizeof(test_configs) / sizeof(test_configs[0])};
 
    for (size_t t = 0; t < NUM_TESTS; ++t) {
 
      struct yac_collection_selection *orig =
        yac_collection_selection_new(test_configs[t].N, test_configs[t].indices);
      struct yac_collection_selection *copy =
        yac_collection_selection_copy(orig);
 
      if (yac_collection_selection_compare(orig, copy)) PUT_ERR("orig != copy");
 
      yac_collection_selection_delete(orig);
      yac_collection_selection_delete(copy);
    }
  }
 
  { /* NULL is a valid empty collection selection*/
 
    struct yac_collection_selection *orig = NULL;
    struct yac_collection_selection *copy =
      yac_collection_selection_copy(orig);
 
    if (copy != NULL) PUT_ERR("copy is not NULL");
  }
}
 
static void utest_zero_size(void) {
 
  struct yac_collection_selection *sel =
    yac_collection_selection_new(0, NULL);
 
  if (sel != NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != 0)
    PUT_ERR("wrong collection_size");
  if (!yac_collection_selection_is_contiguous(sel))
    PUT_ERR("zero-size should be contiguous");
  if (yac_collection_selection_get_indices(sel) != NULL)
    PUT_ERR("indices should be NULL for zero-size contiguous");
  if (yac_collection_selection_get_max_index(sel) != SIZE_MAX)
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void utest_single_with_explicit_zero_index(void) {
  size_t idxs[] = {0};
  enum {N = sizeof(idxs) / sizeof(idxs[0])};
  struct yac_collection_selection *sel =
    yac_collection_selection_new(N, idxs);
 
  if (sel == NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != N)
    PUT_ERR("wrong collection_size");
  if (!yac_collection_selection_is_contiguous(sel))
    PUT_ERR("index {0} should be treated as contiguous");
  if (yac_collection_selection_get_indices(sel) != NULL)
    PUT_ERR("indices should be NULL for contiguous");
  if (yac_collection_selection_get_max_index(sel) != idxs[0])
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void utest_single_with_explicit_non_zero_index(void) {
  size_t idxs[] = {7};
  enum {N = sizeof(idxs) / sizeof(idxs[0])};
  struct yac_collection_selection *sel =
    yac_collection_selection_new(N, idxs);
 
  if (sel == NULL) PUT_ERR("selection is NULL");
  if (yac_collection_selection_get_collection_size(sel) != N)
    PUT_ERR("wrong collection_size");
  if (yac_collection_selection_is_contiguous(sel))
    PUT_ERR("index {7} should not be contiguous");
 
  size_t const *indices = yac_collection_selection_get_indices(sel);
  if (indices == NULL) {
    PUT_ERR("indices should not be NULL for non-contiguous");
  } else if (indices[0] != 7) {
    PUT_ERR("wrong stored index value");
  }
  if (yac_collection_selection_get_max_index(sel) != idxs[0])
    PUT_ERR("wrong maximum index");
 
  yac_collection_selection_delete(sel);
}
 
static void test_compare(void) {
 
  // --- Case 1: both NULL
  if (yac_collection_selection_compare(NULL, NULL) != 0)
    PUT_ERR("yac_collection_selection_compare(NULL, NULL) failed");
 
  // --- Case 2: one NULL, one valid
  {
    struct yac_collection_selection * sel =
      yac_collection_selection_new(10, NULL);
    if (yac_collection_selection_compare(sel, NULL) == 0)
      PUT_ERR("yac_collection_selection_compare(sel, NULL)");
    if (+yac_collection_selection_compare(sel, NULL) !=
        -yac_collection_selection_compare(NULL, sel))
      PUT_ERR("yac_collection_selection_compare(NULL, sel)");
    yac_collection_selection_delete(sel);
  }
 
  // --- Case 3: two contiguous selections, same size
  {
    size_t indices[] = {0,1,2,3,4,5};
    enum {N = sizeof(indices) / sizeof(indices[0])};
    struct yac_collection_selection * sel_a =
      yac_collection_selection_new(N, indices);
    struct yac_collection_selection * sel_b =
      yac_collection_selection_new(N, NULL);
    if (yac_collection_selection_compare(sel_a, sel_b) != 0)
      PUT_ERR("identical contiguous selections should be equal");
    if (yac_collection_selection_compare(sel_b, sel_a) != 0)
      PUT_ERR("identical contiguous selections should be equal");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
 
  // --- Case 4: two contiguous selections, different sizes
  {
    struct yac_collection_selection *sel_a =
      yac_collection_selection_new(5, NULL);
    struct yac_collection_selection *sel_b =
      yac_collection_selection_new(6, NULL);
    if (yac_collection_selection_compare(sel_a, sel_b) == 0)
      PUT_ERR("different contiguous sizes should not be equal");
    if (+yac_collection_selection_compare(sel_b, sel_a) !=
        -yac_collection_selection_compare(sel_a, sel_b))
      PUT_ERR("different contiguous sizes should not be equal");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
 
  // --- Case 5: non-contiguous identical indices
  {
    size_t indices[] = {0, 2, 4, 6, 8};
    enum {N = sizeof(indices) / sizeof(indices[0])};
    struct yac_collection_selection *sel_a =
      yac_collection_selection_new(N, indices);
    struct yac_collection_selection *sel_b =
      yac_collection_selection_new(N, indices);
    if (yac_collection_selection_compare(sel_a, sel_b) != 0)
      PUT_ERR("identical non-contiguous selections should be equal");
    if (yac_collection_selection_compare(sel_b, sel_a) != 0)
      PUT_ERR("identical non-contiguous selections should be equal");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
 
  // --- Case 6: non-contiguous different indices
  {
    size_t indices_a[] = {0, 1, 2, 3, 4};
    enum {N_a = sizeof(indices_a) / sizeof(indices_a[0])};
    struct yac_collection_selection *sel_a =
      yac_collection_selection_new(N_a, indices_a);
    size_t indices_b[] = {0, 1, 3, 2, 4};
    enum {N_b = sizeof(indices_b) / sizeof(indices_b[0])};
    struct yac_collection_selection *sel_b =
      yac_collection_selection_new(N_b, indices_b);
    if (yac_collection_selection_compare(sel_a, sel_b) == 0)
      PUT_ERR("different non-contiguous selections should not be equal");
    if (+yac_collection_selection_compare(sel_b, sel_a) !=
        -yac_collection_selection_compare(sel_a, sel_b))
      PUT_ERR("different non-contiguous selections should not be equal");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
 
  // --- Case 7: contiguous with implicit indices vs.
  //             contiguous with explicit indices
  {
    size_t indices[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    enum {N = sizeof(indices) / sizeof(indices[0])};
    struct yac_collection_selection *sel_a =
      yac_collection_selection_new(N, indices);
    struct yac_collection_selection *sel_b =
      yac_collection_selection_new(N, NULL);
    if (yac_collection_selection_compare(sel_a, sel_b) != 0)
      PUT_ERR("contiguous and equivalent explicit list should be equal");
    if (yac_collection_selection_compare(sel_b, sel_a) != 0)
      PUT_ERR("contiguous and equivalent explicit list should be equal");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
 
  // --- Case 8: contiguous vs. non-matching non-contiguous with same size
  {
    size_t indices[] = {0, 1, 3, 4, 5, 6, 7, 8, 9, 10};
    enum {N = sizeof(indices) / sizeof(indices[0])};
    struct yac_collection_selection *sel_a =
      yac_collection_selection_new(N, indices);
    struct yac_collection_selection *sel_b =
      yac_collection_selection_new(N, NULL);
    if (yac_collection_selection_compare(sel_a, sel_b) == 0)
      PUT_ERR("contiguous and non-matching explicit list should differ");
    if (+yac_collection_selection_compare(sel_b, sel_a) !=
        -yac_collection_selection_compare(sel_a, sel_b))
      PUT_ERR("contiguous and non-matching explicit list should differ");
    yac_collection_selection_delete(sel_b);
    yac_collection_selection_delete(sel_a);
  }
}
 
static void utest_pack_unpack(void) {
 
  MPI_Comm comm = MPI_COMM_SELF;
 
  { /* test contiguous and non-contiguous selections */
    struct {
      size_t N;
      size_t * indices;
    } test_configs[] = {
      {.N = 3, .indices = (size_t[]){0, 2, 5}},   /* non-contiguous */
      {.N = 4, .indices = (size_t[]){0, 1, 2, 3}},/* contiguous */
      {.N = 0, .indices = NULL},                  /* empty contiguous */
      {.N = 5, .indices = NULL}                   /* contiguous 0..4 */
    };
    enum { NUM_TESTS = sizeof(test_configs) / sizeof(test_configs[0]) };
 
    for (size_t t = 0; t < NUM_TESTS; ++t) {
 
      struct yac_collection_selection * orig =
        yac_collection_selection_new(
          test_configs[t].N, test_configs[t].indices);
 
      size_t pack_size = yac_collection_selection_get_pack_size(orig, comm);
      YAC_ASSERT(pack_size > 0,
        "utest_pack_unpack: pack_size must be positive");
 
      void * buffer = xmalloc(pack_size);
      int position = 0;
 
      yac_collection_selection_pack(
        orig, buffer, (int)pack_size, &position, comm);
 
      // unpack into a new object
      int unpack_position = 0;
      struct yac_collection_selection *copy =
        yac_collection_selection_unpack(
          buffer, (int)pack_size, &unpack_position, comm);
 
      if (yac_collection_selection_compare(orig, copy))
        PUT_ERR("ERROR in pack/unpack");
 
      yac_collection_selection_delete(orig);
      yac_collection_selection_delete(copy);
      free(buffer);
    }
  }
 
  { /* test NULL selection (should behave as empty contiguous) */
    struct yac_collection_selection *orig = NULL;
 
    size_t pack_size = yac_collection_selection_get_pack_size(orig, comm);
    void * buffer = xmalloc(pack_size);
    int position = 0;
 
    yac_collection_selection_pack(
      orig, buffer, (int)pack_size, &position, comm);
 
    int unpack_position = 0;
    struct yac_collection_selection *copy =
      yac_collection_selection_unpack(
        buffer, (int)pack_size, &unpack_position, comm);
 
    if (copy != NULL)
      PUT_ERR("unpacked object from NULL should be NULL");
 
    free(buffer);
  }
}