collection_selection.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <stdlib.h>
#include <string.h>
 
#include "utils_core.h"
#include "collection_selection_internal.h"
#include "yac_mpi_internal.h"
 
struct yac_collection_selection {
  size_t collection_size;     //< Number of elements selected
  int is_contiguous;          //< 1 if indices are exactly 0..collection_size−1,
                              //< 0 otherwise
  size_t selection_indices[]; //< Explicit indices if non-contiguous
};
 
struct yac_collection_selection * yac_collection_selection_new(
  size_t collection_size,  size_t const * selection_indices) {
 
  // if empty collection selection
  if (collection_size == 0) return NULL;
 
  int is_contiguous = 1;
 
  // if the user provided selection indices
  if (selection_indices != NULL) {
 
    // check if the provided selection indices are actually contiguous
    for (size_t i = 0; (i < collection_size) && is_contiguous; ++i) {
      is_contiguous = selection_indices[i] == i;
    }
  }
 
  struct yac_collection_selection * collection_selection =
    xmalloc(
      sizeof(*collection_selection) +
      (is_contiguous?0:(collection_size * sizeof(*selection_indices))));
 
  collection_selection->collection_size = collection_size;
  collection_selection->is_contiguous = is_contiguous;
  if (!is_contiguous) {
    memcpy(
      collection_selection->selection_indices, selection_indices,
      collection_size * sizeof(*selection_indices));
  }
 
  return collection_selection;
}
 
struct yac_collection_selection * yac_collection_selection_copy(
  const struct yac_collection_selection * collection_selection) {
 
  if (!collection_selection) return NULL;
 
  size_t mem_size =
    sizeof(*collection_selection) +
      (collection_selection->is_contiguous ? 0 :
         (collection_selection->collection_size *
          sizeof(*collection_selection->selection_indices)));
 
  struct yac_collection_selection * copy = xmalloc(mem_size);
 
  memcpy(copy, collection_selection, mem_size);
 
  return copy;
}
 
void yac_collection_selection_delete(
  struct yac_collection_selection * collection_selection) {
 
  free(collection_selection);
}
 
int yac_collection_selection_is_contiguous(
  struct yac_collection_selection const * collection_selection) {
 
  return (collection_selection == NULL)?1:collection_selection->is_contiguous;
}
 
size_t yac_collection_selection_get_collection_size(
  struct yac_collection_selection const *collection_selection) {
 
  return (collection_selection == NULL)?0:collection_selection->collection_size;
}
 
size_t const * yac_collection_selection_get_indices(
  struct yac_collection_selection const * collection_selection) {
 
  if (!collection_selection) return NULL;
  return
    collection_selection->is_contiguous ?
      NULL : collection_selection->selection_indices;
}
 
 
size_t yac_collection_selection_get_max_index(
  struct yac_collection_selection const * selection) {
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(selection);
 
  size_t max_index;
 
  // if the collection size is empty
  if (collection_size == 0) {
 
    // dummy value
    max_index = SIZE_MAX;
 
  // if non-empty contiguous indices
  } else if (yac_collection_selection_is_contiguous(selection)) {
 
    // contiguous indices: 0 .. n-1
    return collection_size - 1;
 
  // if non-empty non-contiguous indices
  } else {
 
    size_t const * indices = yac_collection_selection_get_indices(selection);
 
    YAC_ASSERT(
      indices != NULL, "ERROR(yac_collection_selection_get_max_index): "
      "internal error");
 
    max_index = indices[0];
    for (size_t i = 1; i < collection_size; ++i) {
      if (indices[i] > max_index) {
          max_index = indices[i];
      }
    }
  }
 
  return max_index;
}
 
int yac_collection_selection_compare(
  struct yac_collection_selection const * a,
  struct yac_collection_selection const * b) {
 
  // Same pointer or both NULL
  int ret = (a == b);
  if (ret) return 0;
 
  // One is NULL, the other is not
  ret = (a == NULL) - (b == NULL);
  if (ret) return ret;
 
  size_t size_a = yac_collection_selection_get_collection_size(a);
  size_t size_b = yac_collection_selection_get_collection_size(b);
 
  // Different collection sizes
  ret = (size_a > size_b) - (size_a < size_b);
  if (ret) return ret;
 
  int contig_a = yac_collection_selection_is_contiguous(a);
  int contig_b = yac_collection_selection_is_contiguous(b);
 
  // Both are contiguous and same size
  if (contig_a && contig_b) return 0;
 
  // One is contiguous, the other is not
  ret = contig_a - contig_b;
  if (ret) return ret;
 
  // Both are non-contiguous, compare indices
  size_t const * indices_a = yac_collection_selection_get_indices(a);
  size_t const * indices_b = yac_collection_selection_get_indices(b);
 
  for (size_t i = 0; i < size_a; ++i) {
    ret = (indices_a[i] > indices_b[i]) - (indices_a[i] < indices_b[i]);
    if (ret) return ret;
  }
 
  return 0; // Equal
}
 
size_t yac_collection_selection_get_pack_size(
  struct yac_collection_selection const * sel, MPI_Comm comm) {
 
  // set to dummy value if sel == NULL
  struct yac_collection_selection const empty_sel =
    {.collection_size = 0, .is_contiguous = 1};
  if (sel == NULL) sel = &empty_sel;
 
  int size_t_pack_size, int_pack_size, indices_pack_size = 0;
 
  // base fields
  yac_mpi_call(MPI_Pack_size(1, YAC_MPI_SIZE_T, comm, &size_t_pack_size), comm);
  yac_mpi_call(MPI_Pack_size(1, MPI_INT, comm, &int_pack_size), comm);
 
  // if the collection is non-empty and non-contiguous
  if (!sel->is_contiguous && sel->collection_size > 0) {
 
    YAC_ASSERT(sel->collection_size <= INT_MAX,
      "ERROR(yac_collection_selection_get_pack_size): collection too large");
 
    yac_mpi_call(
      MPI_Pack_size(
        (int)sel->collection_size, YAC_MPI_SIZE_T, comm, &indices_pack_size),
      comm);
  }
 
  return (size_t)size_t_pack_size +  // collection size
         (size_t)int_pack_size +     // is contiguous
         (size_t)indices_pack_size;  // indices, if applicable
}
 
void yac_collection_selection_pack(
  struct yac_collection_selection const * sel,
  void * buffer, int buffer_size, int * position, MPI_Comm comm) {
 
  // set to dummy value if sel == NULL
  struct yac_collection_selection const empty_sel =
    {.collection_size = 0, .is_contiguous = 1};
  if (sel == NULL) sel = &empty_sel;
 
  yac_mpi_call(
    MPI_Pack(
      &sel->collection_size, 1, YAC_MPI_SIZE_T,
      buffer, buffer_size, position, comm), comm);
 
  yac_mpi_call(
    MPI_Pack(
      &sel->is_contiguous, 1, MPI_INT,
      buffer, buffer_size, position, comm), comm);
 
  // if the collection is non-empty and non-contiguous
  if (!sel->is_contiguous && sel->collection_size > 0) {
 
    YAC_ASSERT(sel->collection_size <= INT_MAX,
      "ERROR(yac_collection_selection_pack): collection too large");
 
    yac_mpi_call(
      MPI_Pack(
        sel->selection_indices, (int)sel->collection_size,
        YAC_MPI_SIZE_T, buffer, buffer_size, position, comm), comm);
  }
}
 
struct yac_collection_selection * yac_collection_selection_unpack(
  void const * buffer, int buffer_size, int * position, MPI_Comm comm) {
 
  size_t collection_size;
  yac_mpi_call(
    MPI_Unpack(buffer, buffer_size, position,
               &collection_size, 1, YAC_MPI_SIZE_T, comm), comm);
 
  int is_contiguous;
  yac_mpi_call(
    MPI_Unpack(buffer, buffer_size, position,
               &is_contiguous, 1, MPI_INT, comm), comm);
 
  struct yac_collection_selection * sel = NULL;
 
  if (collection_size > 0) {
 
    sel = xmalloc(
      sizeof(*sel) +
      (is_contiguous?0:(collection_size * sizeof(sel->selection_indices[0]))));
 
    sel->collection_size = collection_size;
    sel->is_contiguous = is_contiguous;
 
    if (!is_contiguous && collection_size > 0) {
 
      YAC_ASSERT(collection_size <= INT_MAX,
        "ERROR(yac_collection_selection_unpack): collection too large");
 
      yac_mpi_call(
        MPI_Unpack(
          buffer, buffer_size, position, sel->selection_indices,
          (int)collection_size, YAC_MPI_SIZE_T, comm), comm);
    }
  }
 
  return sel;
}