interp_operator_sum_mvp_at_src.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <string.h>
 
#include "interpolation/operators/interp_operator_sum_mvp_at_src.h"
#include "utils_core.h"
#include "interpolation/interpolation_utils.h"
#include "interpolation/interpolation_exchange.h"
#include "collection_selection_internal.h"
#include "interpolation/operators/interp_operator_internal.h"
 
static int yac_interp_operator_sum_mvp_at_src_is_source(
  struct yac_interp_operator * interp);
static int yac_interp_operator_sum_mvp_at_src_is_target(
  struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_src_execute(
  struct yac_interp_operator * interp,
  double *** src_fields, double *** src_frac_masks, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand);
static void yac_interp_operator_sum_mvp_at_src_execute_put(
  struct yac_interp_operator * interp,
  double *** src_fields, double *** src_frac_masks,
  int is_target, double frac_mask_fallback_value,
  double scale_factor, double scale_summand);
static void yac_interp_operator_sum_mvp_at_src_execute_get(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand);
static void yac_interp_operator_sum_mvp_at_src_execute_get_async(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand);
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_src_execute_put_test(
    struct yac_interp_operator * interp);
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_src_execute_get_test(
    struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_src_execute_wait(
  struct yac_interp_operator * interp);
static struct yac_interp_operator * yac_interp_operator_sum_mvp_at_src_copy(
  struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_src_delete(
  struct yac_interp_operator * interp);
 
static struct yac_interp_operator_vtable const interpolation_sum_mvp_at_src_vtable = {
  .is_source         = yac_interp_operator_sum_mvp_at_src_is_source,
  .is_target         = yac_interp_operator_sum_mvp_at_src_is_target,
  .execute           = yac_interp_operator_sum_mvp_at_src_execute,
  .execute_put       = yac_interp_operator_sum_mvp_at_src_execute_put,
  .execute_get       = yac_interp_operator_sum_mvp_at_src_execute_get,
  .execute_get_async = yac_interp_operator_sum_mvp_at_src_execute_get_async,
  .execute_put_test  = yac_interp_operator_sum_mvp_at_src_execute_put_test,
  .execute_get_test  = yac_interp_operator_sum_mvp_at_src_execute_get_test,
  .execute_wait      = yac_interp_operator_sum_mvp_at_src_execute_wait,
  .copy              = yac_interp_operator_sum_mvp_at_src_copy,
  .delete            = yac_interp_operator_sum_mvp_at_src_delete,
};
 
struct yac_interp_operator_sum_mvp_at_src {
 
  struct yac_interp_operator_vtable const * vtable;
 
  struct yac_collection_selection * collection_selection;
  int with_frac_mask;
 
  /* data flow:
   *  put:
   *      I. source processes collectively exchange data, such that each process
   *         can process its stencils
   *         - send buffer: src_fields (+src_frac_masks) provided by user
   *         - recv buffer: halo_data
   *         - exchange: src2halo
   *     II. all source processes process their stencils to compute the target
   *         field
   *         - from buffer: src_fields (+src_frac_masks) provided by user
   *                        halo_data
   *         - to buffer: result_data
   *    III. source processes send target field to target processes
   *         - send buffer: result_data
   *         - recv buffer: tgt_field provided by user
   *         - exchange: result2tgt
   *  get:
   *       I. target processes receive target field from source processes
   *         - send buffer: result_data
   *         - recv buffer: tgt_field provided by user
   *         - exchange: result2tgt
   */
 
  /*
   * The following arrays are shared between multiple copies of the same
   * interpolation operation and are only freed when the reference counter
   * reaches zero:
   *   - src_idx
   *   - src_field_idx
   *   - weights
   *   - prefix_num_src_per_tgt
   *   - ref_count
   */
 
  struct yac_interpolation_buffer halo_data;
  struct yac_interpolation_buffer result_data;
  struct yac_interpolation_exchange * src2halo;
  struct yac_interpolation_exchange * result2tgt;
 
  size_t tgt_count;
  size_t * prefix_num_src_per_tgt; 
  double * weights;
  size_t * src_field_idx;
  size_t * src_idx;
  size_t num_src_fields;
  double ** src_fields_buffer;
 
  int is_source; 
  int is_target; 
 
  int * ref_count;
};
 
static struct yac_interp_operator * yac_interp_operator_sum_mvp_at_src_new_(
  struct yac_collection_selection const * collection_selection,
  struct yac_interpolation_buffer halo_data,
  struct yac_interpolation_buffer result_data,
  struct yac_interpolation_exchange * src2halo,
  struct yac_interpolation_exchange * result2tgt,
  size_t tgt_count, size_t * prefix_num_src_per_tgt, double * weights,
  size_t * src_field_idx, size_t * src_idx, size_t num_src_fields,
  int with_frac_mask, int * ref_count) {
 
  struct yac_interp_operator_sum_mvp_at_src * mvp_at_src =
    xmalloc(1 * sizeof(*mvp_at_src));
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(collection_selection);
 
  mvp_at_src->vtable = &interpolation_sum_mvp_at_src_vtable;
  mvp_at_src->collection_selection =
    yac_collection_selection_copy(collection_selection);
  mvp_at_src->with_frac_mask = with_frac_mask;
  mvp_at_src->halo_data = halo_data;
  mvp_at_src->result_data = result_data;
  mvp_at_src->src2halo = src2halo;
  mvp_at_src->result2tgt = result2tgt;
  mvp_at_src->tgt_count = tgt_count;
  mvp_at_src->prefix_num_src_per_tgt = prefix_num_src_per_tgt;
  mvp_at_src->weights = weights;
  mvp_at_src->src_field_idx = src_field_idx;
  mvp_at_src->src_idx = src_idx;
  mvp_at_src->num_src_fields = num_src_fields;
  mvp_at_src->src_fields_buffer =
    xmalloc(
      (with_frac_mask?2*collection_size:collection_size) * num_src_fields *
      sizeof(*(mvp_at_src->src_fields_buffer)));
  mvp_at_src->is_source =
    yac_interpolation_exchange_is_source(mvp_at_src->src2halo) ||
    yac_interpolation_exchange_is_target(mvp_at_src->src2halo) ||
    yac_interpolation_exchange_is_source(mvp_at_src->result2tgt);
  mvp_at_src->is_target =
    yac_interpolation_exchange_is_target(mvp_at_src->result2tgt);
 
  mvp_at_src->ref_count =
    (ref_count == NULL)?xcalloc(1, sizeof(*mvp_at_src->ref_count)):ref_count;
  ++*(mvp_at_src->ref_count);
 
  return (struct yac_interp_operator *)mvp_at_src;
}
 
struct yac_interp_operator * yac_interp_operator_sum_mvp_at_src_new(
  struct yac_collection_selection const * collection_selection,
  Xt_redist * halo_redists, size_t tgt_count, size_t * num_src_per_tgt,
  double * weights, size_t * src_field_idx, size_t * src_idx,
  size_t num_src_fields, Xt_redist result_redist_, int with_frac_mask) {
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(collection_selection);
 
  size_t total_num_src = 0;
  size_t * prefix_num_src_per_tgt =
    xmalloc((tgt_count + 1) * sizeof(*prefix_num_src_per_tgt));
  for (size_t i = 0; i < tgt_count; ++i) {
    prefix_num_src_per_tgt[i] = total_num_src;
    total_num_src += num_src_per_tgt[i];
  }
  prefix_num_src_per_tgt[tgt_count] = total_num_src;
 
  // some consistency checking
  for (size_t i = 0; i < total_num_src; ++i) {
    YAC_ASSERT_F(
      (src_field_idx[i] == SIZE_MAX) || (src_field_idx[i] < num_src_fields),
      "ERROR(yac_interp_operator_sum_mvp_at_src_new): "
      "invalid src_field_idx value "
      "(has to be either SIZE_MAX or < num_src_fields(= %zu))"
      "src_field_idx[%zu] = %zu", num_src_fields, i, src_field_idx[i]);
  }
 
  return
    yac_interp_operator_sum_mvp_at_src_new_(
      collection_selection,
      yac_interpolation_buffer_init(
        halo_redists, num_src_fields,
        with_frac_mask?2*collection_size:collection_size, RECV_BUFFER),
      yac_interpolation_buffer_init(
        &result_redist_, 1, collection_size, SEND_BUFFER),
      yac_interpolation_exchange_new(
        halo_redists, num_src_fields,
        collection_size, with_frac_mask, "source to halo"),
      yac_interpolation_exchange_new(
        &result_redist_, 1, collection_size, 0, "result to target"),
      tgt_count, prefix_num_src_per_tgt,
      (weights != NULL)?COPY_DATA(weights, total_num_src):NULL,
      COPY_DATA(src_field_idx, total_num_src),
      COPY_DATA(src_idx, total_num_src),
      num_src_fields, with_frac_mask, NULL);
}
 
static int yac_interp_operator_sum_mvp_at_src_is_source(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src *)interp;
 
  return sum_mvp_at_src->is_source;
}
 
static int yac_interp_operator_sum_mvp_at_src_is_target(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src *)interp;
 
  return sum_mvp_at_src->is_target;
}
 
static void yac_interp_operator_sum_mvp_at_src_execute(
  struct yac_interp_operator * interp,
  double *** src_fields, double *** src_frac_masks, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src *)interp;
 
  // make sure that there are no open exchanges from a previous exchange
  yac_interpolation_exchange_wait(
    sum_mvp_at_src->result2tgt,
    "yac_interp_operator_sum_mvp_at_src_execute");
 
  double ** results = sum_mvp_at_src->result_data.buffer;
 
  if (sum_mvp_at_src->is_source) {
 
    int with_frac_mask = sum_mvp_at_src->with_frac_mask;
    CHECK_WITH_FRAC_MASK("yac_interp_operator_sum_mvp_at_src_execute")
 
    size_t collection_size =
      yac_collection_selection_get_collection_size(
        sum_mvp_at_src->collection_selection);
    size_t const * collection_indices =
      yac_collection_selection_get_indices(
        sum_mvp_at_src->collection_selection);
    size_t num_src_fields = sum_mvp_at_src->num_src_fields;
 
    // if the collection selection is not contiguous
    if (collection_indices != NULL) {
 
      double *** temp_src_fields =
        xmalloc(collection_size * sizeof(*temp_src_fields));
      temp_src_fields[0] =
        xmalloc(collection_size * num_src_fields * sizeof(**temp_src_fields));
      for (size_t i = 0; i < collection_size; ++i) {
        temp_src_fields[i] = temp_src_fields[0] + i * num_src_fields;
        for (size_t j = 0; j < num_src_fields; ++j)
          temp_src_fields[i][j] = src_fields[collection_indices[i]][j];
      }
      src_fields = temp_src_fields;
 
      if (src_frac_masks != NULL) {
        double *** temp_src_frac_masks =
          xmalloc(collection_size * sizeof(*temp_src_frac_masks));
        temp_src_frac_masks[0] =
          xmalloc(
            collection_size * num_src_fields * sizeof(**temp_src_frac_masks));
        for (size_t i = 0; i < collection_size; ++i) {
          temp_src_frac_masks[i] = temp_src_frac_masks[0] + i * num_src_fields;
          for (size_t j = 0; j < num_src_fields; ++j)
            temp_src_frac_masks[i][j] =
              src_frac_masks[collection_indices[i]][j];
        }
        src_frac_masks = temp_src_frac_masks;
      }
    }
 
    double ** temp_src_fields = sum_mvp_at_src->src_fields_buffer;
    double ** halo_buffers = sum_mvp_at_src->halo_data.buffer;
 
    for (size_t i = 0; i < collection_size; ++i)
      for (size_t j = 0; j < num_src_fields; ++j)
        temp_src_fields[i * num_src_fields + j] = src_fields[i][j];
    if (with_frac_mask)
      for (size_t i = 0; i < collection_size; ++i)
        for (size_t j = 0; j < num_src_fields; ++j)
          temp_src_fields[
            i * num_src_fields + j + collection_size * num_src_fields] =
              src_frac_masks[i][j];
 
    // do halo exchange
    yac_interpolation_exchange_execute(
      sum_mvp_at_src->src2halo, (double const **)temp_src_fields,
      halo_buffers, "yac_interp_operator_sum_mvp_at_src_execute");
 
    compute_tgt_field_wgt(
      (double const * restrict **)src_fields,
      (double const * restrict **)(with_frac_mask?src_frac_masks:NULL),
      (double const * restrict *)halo_buffers,
      (double const * restrict *)(
        with_frac_mask?(halo_buffers + collection_size * num_src_fields):NULL),
      results, NULL, sum_mvp_at_src->tgt_count,
      sum_mvp_at_src->prefix_num_src_per_tgt,
      sum_mvp_at_src->weights, sum_mvp_at_src->src_field_idx,
      sum_mvp_at_src->src_idx, num_src_fields, collection_size,
      frac_mask_fallback_value, scale_factor, scale_summand);
 
    if (sum_mvp_at_src->is_source && (collection_indices != NULL)) {
      free(src_fields[0]);
      free(src_fields);
      if (src_frac_masks != NULL) {
        free(src_frac_masks[0]);
        free(src_frac_masks);
      }
    }
  }
 
  // redistribute results
  yac_interpolation_exchange_execute(
    sum_mvp_at_src->result2tgt, (double const **)results, tgt_field,
    "yac_interp_operator_sum_mvp_at_src_execute");
}
 
static void yac_interp_operator_sum_mvp_at_src_execute_put(
  struct yac_interp_operator * interp,
  double *** src_fields, double *** src_frac_masks, int is_target,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  UNUSED(is_target);
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src *)interp;
 
  // If the local process sends target points in the results exchange
  // operation and a previous exchange is still active, wait until it is
  // completed. This ensures that the send buffers are free to use and
  // new target points can be sent.
  // It is possible that there is an open target point exchange operation
  // due to get_async being called beforehand. The if-condition avoids a
  // potential deadlock.
  if (yac_interpolation_exchange_is_source(sum_mvp_at_src->result2tgt) &&
      (yac_interpolation_exchange_status(
        sum_mvp_at_src->result2tgt,
        "yac_interp_operator_sum_mvp_at_src_execute_put") ==
       YAC_INTERP_EXCH_ACTIVE))
    yac_interpolation_exchange_wait(
      sum_mvp_at_src->result2tgt,
      "yac_interp_operator_sum_mvp_at_src_execute_put");
 
  int with_frac_mask = sum_mvp_at_src->with_frac_mask;
  CHECK_WITH_FRAC_MASK("yac_interp_operator_sum_mvp_at_src_execute_put")
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_src->collection_selection);
  size_t const * collection_indices =
    yac_collection_selection_get_indices(sum_mvp_at_src->collection_selection);
  size_t num_src_fields = sum_mvp_at_src->num_src_fields;
 
  // if the collection selection is not contiguous
  if (collection_indices != NULL) {
 
    double *** temp_src_fields =
      xmalloc(collection_size * sizeof(*temp_src_fields));
    temp_src_fields[0] =
      xmalloc(collection_size * num_src_fields * sizeof(**temp_src_fields));
    for (size_t i = 0; i < collection_size; ++i) {
      temp_src_fields[i] = temp_src_fields[0] + i * num_src_fields;
      for (size_t j = 0; j < num_src_fields; ++j)
        temp_src_fields[i][j] = src_fields[collection_indices[i]][j];
    }
    src_fields = temp_src_fields;
 
    if (src_frac_masks != NULL) {
      double *** temp_src_frac_masks =
        xmalloc(collection_size * sizeof(*temp_src_frac_masks));
      temp_src_frac_masks[0] =
        xmalloc(
          collection_size * num_src_fields * sizeof(**temp_src_frac_masks));
      for (size_t i = 0; i < collection_size; ++i) {
        temp_src_frac_masks[i] = temp_src_frac_masks[0] + i * num_src_fields;
        for (size_t j = 0; j < num_src_fields; ++j)
          temp_src_frac_masks[i][j] =
            src_frac_masks[collection_indices[i]][j];
      }
      src_frac_masks = temp_src_frac_masks;
    }
  }
 
  double ** temp_src_fields = sum_mvp_at_src->src_fields_buffer;
  double ** halo_buffers = sum_mvp_at_src->halo_data.buffer;
 
  for (size_t i = 0; i < collection_size; ++i)
    for (size_t j = 0; j < num_src_fields; ++j)
      temp_src_fields[i * num_src_fields + j] = src_fields[i][j];
  if (with_frac_mask) {
    for (size_t i = 0; i < collection_size; ++i)
      for (size_t j = 0; j < num_src_fields; ++j)
        temp_src_fields[
          i * num_src_fields + j + collection_size * num_src_fields] =
            src_frac_masks[i][j];
  }
 
  // do halo exchange
  yac_interpolation_exchange_execute(
    sum_mvp_at_src->src2halo, (double const **)temp_src_fields, halo_buffers,
    "yac_interp_operator_sum_mvp_at_src_execute_put");
 
  double ** results = sum_mvp_at_src->result_data.buffer;
 
  compute_tgt_field_wgt(
    (double const * restrict **)src_fields,
    (double const * restrict **)(with_frac_mask?src_frac_masks:NULL),
    (double const * restrict *)halo_buffers,
    (double const * restrict *)(
      with_frac_mask?(halo_buffers + collection_size * num_src_fields):NULL),
    results, NULL, sum_mvp_at_src->tgt_count,
    sum_mvp_at_src->prefix_num_src_per_tgt, sum_mvp_at_src->weights,
    sum_mvp_at_src->src_field_idx, sum_mvp_at_src->src_idx,
    num_src_fields, collection_size, frac_mask_fallback_value,
    scale_factor, scale_summand);
 
  if (collection_indices != NULL) {
    free(src_fields[0]);
    free(src_fields);
    if (src_frac_masks != NULL) {
      free(src_frac_masks[0]);
      free(src_frac_masks);
    }
  }
 
  yac_interpolation_exchange_execute_put(
    sum_mvp_at_src->result2tgt, (double const **)results,
    "yac_interp_operator_sum_mvp_at_src_execute_put");
}
 
static void yac_interp_operator_sum_mvp_at_src_execute_get(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  UNUSED(frac_mask_fallback_value);
  UNUSED(scale_factor);
  UNUSED(scale_summand);
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  yac_interpolation_exchange_execute_get(
    sum_mvp_at_src->result2tgt, tgt_field,
    "yac_interp_operator_sum_mvp_at_src_execute_get");
}
 
static void yac_interp_operator_sum_mvp_at_src_execute_get_async(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  UNUSED(frac_mask_fallback_value);
  UNUSED(scale_factor);
  UNUSED(scale_summand);
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  // wait until previous exchange is completed
  if (yac_interpolation_exchange_status(
        sum_mvp_at_src->result2tgt,
        "yac_interp_operator_sum_mvp_at_src_execute_get_async") ==
      YAC_INTERP_EXCH_ACTIVE)
    yac_interpolation_exchange_wait(
      sum_mvp_at_src->result2tgt,
      "yac_interp_operator_sum_mvp_at_src_execute_get_async");
 
  yac_interpolation_exchange_execute_get_async(
    sum_mvp_at_src->result2tgt, tgt_field,
    "yac_interp_operator_sum_mvp_at_src_execute_get_async");
}
 
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_src_execute_put_test(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  return
    (yac_interpolation_exchange_put_test(
       sum_mvp_at_src->result2tgt,
       "yac_interp_operator_sum_mvp_at_src_execute_put_test") ==
     YAC_INTERP_EXCH_COMPLETE)?YAC_INTERP_COMPLETE:YAC_INTERP_INCOMPLETE;
}
 
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_src_execute_get_test(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  return
    (yac_interpolation_exchange_get_test(
       sum_mvp_at_src->result2tgt,
       "yac_interp_operator_sum_mvp_at_src_execute_get_test") ==
     YAC_INTERP_EXCH_COMPLETE)?YAC_INTERP_COMPLETE:YAC_INTERP_INCOMPLETE;
}
 
static void yac_interp_operator_sum_mvp_at_src_execute_wait(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  yac_interpolation_exchange_wait(
    sum_mvp_at_src->result2tgt,
    "yac_interp_operator_sum_mvp_at_src_execute_wait");
}
 
static struct yac_interp_operator *
  yac_interp_operator_sum_mvp_at_src_copy(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_src->collection_selection);
 
  return
    yac_interp_operator_sum_mvp_at_src_new_(
      sum_mvp_at_src->collection_selection,
      yac_interpolation_buffer_copy(
        sum_mvp_at_src->halo_data, sum_mvp_at_src->num_src_fields,
        sum_mvp_at_src->with_frac_mask?2*collection_size:collection_size),
      yac_interpolation_buffer_copy(
        sum_mvp_at_src->result_data, 1, collection_size),
      yac_interpolation_exchange_copy(sum_mvp_at_src->src2halo),
      yac_interpolation_exchange_copy(sum_mvp_at_src->result2tgt),
      sum_mvp_at_src->tgt_count,
      sum_mvp_at_src->prefix_num_src_per_tgt, sum_mvp_at_src->weights,
      sum_mvp_at_src->src_field_idx, sum_mvp_at_src->src_idx,
      sum_mvp_at_src->num_src_fields,
      sum_mvp_at_src->with_frac_mask, sum_mvp_at_src->ref_count);
}
 
static void yac_interp_operator_sum_mvp_at_src_delete(
  struct yac_interp_operator * interp) {
 
  if (interp == NULL) return;
 
  struct yac_interp_operator_sum_mvp_at_src * sum_mvp_at_src =
    (struct yac_interp_operator_sum_mvp_at_src*)interp;
 
  yac_interpolation_exchange_delete(
    sum_mvp_at_src->result2tgt, "yac_interp_operator_sum_mvp_at_src_delete");
  yac_interpolation_buffer_free(&(sum_mvp_at_src->result_data));
  yac_interpolation_exchange_delete(
    sum_mvp_at_src->src2halo, "yac_interp_operator_sum_mvp_at_src_delete");
  yac_interpolation_buffer_free(&(sum_mvp_at_src->halo_data));
  free(sum_mvp_at_src->src_fields_buffer);
 
  if (!--(*(sum_mvp_at_src->ref_count))) {
    free(sum_mvp_at_src->prefix_num_src_per_tgt);
    free(sum_mvp_at_src->src_idx);
    free(sum_mvp_at_src->src_field_idx);
    free(sum_mvp_at_src->weights);
    free(sum_mvp_at_src->ref_count);
  }
  yac_collection_selection_delete(sum_mvp_at_src->collection_selection);
  free(sum_mvp_at_src);
}