interp_operator_sum_mvp_at_tgt.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#include <string.h>
#include <yaxt.h>
 
#include "interpolation/operators/interp_operator_sum_mvp_at_tgt.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_tgt_is_source(
  struct yac_interp_operator * interp);
static int yac_interp_operator_sum_mvp_at_tgt_is_target(
  struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_tgt_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_tgt_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_tgt_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_tgt_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_tgt_execute_put_test(
    struct yac_interp_operator * interp);
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_tgt_execute_get_test(
    struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_tgt_execute_wait(
  struct yac_interp_operator * interp);
static struct yac_interp_operator * yac_interp_operator_sum_mvp_at_tgt_copy(
  struct yac_interp_operator * interp);
static void yac_interp_operator_sum_mvp_at_tgt_delete(
  struct yac_interp_operator * interp);
 
static struct yac_interp_operator_vtable const interpolation_sum_mvp_at_tgt_vtable = {
  .is_source         = yac_interp_operator_sum_mvp_at_tgt_is_source,
  .is_target         = yac_interp_operator_sum_mvp_at_tgt_is_target,
  .execute           = yac_interp_operator_sum_mvp_at_tgt_execute,
  .execute_put       = yac_interp_operator_sum_mvp_at_tgt_execute_put,
  .execute_get       = yac_interp_operator_sum_mvp_at_tgt_execute_get,
  .execute_get_async = yac_interp_operator_sum_mvp_at_tgt_execute_get_async,
  .execute_put_test  = yac_interp_operator_sum_mvp_at_tgt_execute_put_test,
  .execute_get_test  = yac_interp_operator_sum_mvp_at_tgt_execute_get_test,
  .execute_wait      = yac_interp_operator_sum_mvp_at_tgt_execute_wait,
  .copy              = yac_interp_operator_sum_mvp_at_tgt_copy,
  .delete            = yac_interp_operator_sum_mvp_at_tgt_delete,
};
 
struct yac_interp_operator_sum_mvp_at_tgt {
 
  struct yac_interp_operator_vtable const * vtable;
 
  struct yac_collection_selection * collection_selection;
  int with_frac_mask;
 
  /* data flow:
   *  put:
   *      I. source processes pack their source data into a buffer, in order
   *         to be able to asynchronously process the put operation
   *         - from buffer: src_fields (+src_frac_masks) provided by user
   *         - to buffer: src_send_buffer
   *     II. source processes send source data to target processes, such
   *         that each target process can compute its own target field
   *         - send buffer: src_send_buffer
   *         - recv buffer: src_recv_buffer
   *         - exchange: src2tgt
   *  get:
   *      I. target processes receive source data from source processes
   *         - send buffer: src_send_buffer
   *         - recv buffer: src_recv_buffer
   *         - exchange: src2tgt
   *     II. target process comput their target field
   *         - from buffer: src_recv_buffer
   *         - to buffer: tgt_field provied by the user
   */
 
  /*
   * The following arrays are shared between multiple copies of the same
   * interpolation operation and are only freed when the reference counter
   * reaches zero:
   *   - tgt_pos
   *   - src_idx
   *   - src_field_idx
   *   - weights
   *   - prefix_num_src_per_tgt
   *   - ref_count
   */
 
  struct yac_interpolation_buffer src_send_data;
  struct yac_interpolation_buffer src_recv_data;
  struct yac_interpolation_exchange * src2tgt;
 
  double *** src_fields;
  double *** src_frac_masks;
  double ** src_fields_buffer;
  size_t * tgt_pos;
  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 is_source; 
  int is_target; 
 
  int async_get_is_active;
 
  // pre-allocated buffer for tgt_field pointers during async get
  double ** tgt_field_buffer;
 
  // temporary data
  double ** tgt_field;
  double frac_mask_fallback_value;
  double scale_factor;
  double scale_summand;
 
  int * ref_count;
};
 
static int local_src_data_is_used(size_t count, size_t const * src_field_idx) {
 
  int contains_non_remote_src_data = 0;
  for (size_t i = 0; (i < count) && !contains_non_remote_src_data; ++i) {
    contains_non_remote_src_data = src_field_idx[i] != SIZE_MAX;
  }
  return contains_non_remote_src_data;
}
 
static struct yac_interp_operator * yac_interp_operator_sum_mvp_at_tgt_new_(
  struct yac_collection_selection const * collection_selection,
  struct yac_interpolation_buffer src_send_data,
  struct yac_interpolation_buffer src_recv_data,
  struct yac_interpolation_exchange * src2tgt,
  size_t * tgt_pos,  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_tgt * mvp_at_tgt =
    xmalloc(1 * sizeof(*mvp_at_tgt));
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(collection_selection);
 
  mvp_at_tgt->vtable = &interpolation_sum_mvp_at_tgt_vtable;
  mvp_at_tgt->collection_selection =
    yac_collection_selection_copy(collection_selection);
  mvp_at_tgt->with_frac_mask = with_frac_mask;
  mvp_at_tgt->src_send_data = src_send_data;
  mvp_at_tgt->src_recv_data = src_recv_data;
  mvp_at_tgt->src2tgt = src2tgt;
  mvp_at_tgt->src_fields =
    xmalloc(collection_size * sizeof(*(mvp_at_tgt->src_fields)));
  for (size_t i = 0; i < collection_size; ++i)
    mvp_at_tgt->src_fields[i] = mvp_at_tgt->src_send_data.buffer + i * num_src_fields;
  if (with_frac_mask) {
    mvp_at_tgt->src_frac_masks =
      xmalloc(collection_size * sizeof(*(mvp_at_tgt->src_frac_masks)));
    for (size_t i = 0; i < collection_size; ++i)
      mvp_at_tgt->src_frac_masks[i] =
        mvp_at_tgt->src_send_data.buffer + (collection_size + i) * num_src_fields;
  } else {
    mvp_at_tgt->src_frac_masks = NULL;
  }
  mvp_at_tgt->src_fields_buffer =
    xcalloc((with_frac_mask?2*collection_size:collection_size) *
            num_src_fields, sizeof(*(mvp_at_tgt->src_fields_buffer)));
  mvp_at_tgt->tgt_pos = tgt_pos;
  mvp_at_tgt->tgt_count = tgt_count;
  mvp_at_tgt->prefix_num_src_per_tgt = prefix_num_src_per_tgt;
  mvp_at_tgt->weights = weights;
  mvp_at_tgt->src_field_idx = src_field_idx;
  mvp_at_tgt->src_idx = src_idx;
  mvp_at_tgt->num_src_fields = num_src_fields;
  mvp_at_tgt->is_source =
    yac_interpolation_exchange_is_source(mvp_at_tgt->src2tgt) ||
    local_src_data_is_used(prefix_num_src_per_tgt[tgt_count], src_field_idx);
  mvp_at_tgt->is_target = tgt_count > 0;
  mvp_at_tgt->async_get_is_active = 0;
  mvp_at_tgt->tgt_field_buffer =
    xmalloc(collection_size * sizeof(*mvp_at_tgt->tgt_field_buffer));
 
  mvp_at_tgt->ref_count =
    (ref_count == NULL)?xcalloc(1, sizeof(*mvp_at_tgt->ref_count)):ref_count;
  ++*(mvp_at_tgt->ref_count);
 
  return (struct yac_interp_operator *)mvp_at_tgt;
}
 
struct yac_interp_operator * yac_interp_operator_sum_mvp_at_tgt_new(
  struct yac_collection_selection const * collection_selection,
  Xt_redist * src_redists, size_t * tgt_pos, 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, 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),
      "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]);
  }
 
  // in case a process is both source and target, the send buffer is also used
  // to copy the send field (and send_frac_mask) in the put for the get
  // --> we have to make sure that the buffer contains all locally required
  //     data
  size_t * min_buffer_sizes =
    xcalloc(num_src_fields, sizeof(*min_buffer_sizes));
  for (size_t i = 0, offset = 0; i < tgt_count; ++i) {
    size_t curr_num_src = num_src_per_tgt[i];
    for (size_t j = 0; j < curr_num_src; ++j, ++offset) {
      size_t curr_src_field_idx = src_field_idx[offset];
      if (curr_src_field_idx == SIZE_MAX) continue;
      size_t curr_src_extent = (src_idx[offset] + 1) * sizeof(double);
      if (min_buffer_sizes[curr_src_field_idx] < curr_src_extent)
        min_buffer_sizes[curr_src_field_idx] = curr_src_extent;
    }
  }
 
  struct yac_interp_operator * interp =
    yac_interp_operator_sum_mvp_at_tgt_new_(
      collection_selection,
      yac_interpolation_buffer_init_2(
        src_redists, min_buffer_sizes, num_src_fields,
        with_frac_mask?2*collection_size:collection_size, SEND_BUFFER),
      yac_interpolation_buffer_init(
        src_redists, num_src_fields,
        with_frac_mask?2*collection_size:collection_size, RECV_BUFFER),
      yac_interpolation_exchange_new(
        src_redists, num_src_fields,
        collection_size, with_frac_mask, "source to target"),
      COPY_DATA(tgt_pos, tgt_count), 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);
 
  free(min_buffer_sizes);
  return interp;
}
 
static int yac_interp_operator_sum_mvp_at_tgt_is_source(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt *)interp;
 
  return sum_mvp_at_tgt->is_source;
}
 
static int yac_interp_operator_sum_mvp_at_tgt_is_target(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt *)interp;
 
  return sum_mvp_at_tgt->is_target;
}
 
static void yac_interp_operator_sum_mvp_at_tgt_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_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt *)interp;
 
  yac_interp_operator_sum_mvp_at_tgt_execute_wait(interp);
 
  int with_frac_mask = sum_mvp_at_tgt->with_frac_mask;
  CHECK_WITH_FRAC_MASK()
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_tgt->collection_selection);
  size_t const * collection_indices =
    yac_collection_selection_get_indices(
      sum_mvp_at_tgt->collection_selection);
  size_t num_src_fields = sum_mvp_at_tgt->num_src_fields;
  double ** src_send_buffer = sum_mvp_at_tgt->src_fields_buffer;
  double ** src_recv_buffer = sum_mvp_at_tgt->src_recv_data.buffer;
 
  if (sum_mvp_at_tgt->is_source) {
 
    // 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;
      }
    }
 
    // copy src_field and src_frac_mask into a 2D buffer for communication
    for (size_t i = 0; i < collection_size; ++i)
      for (size_t j = 0; j < num_src_fields; ++j)
        src_send_buffer[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)
          src_send_buffer
            [i * num_src_fields + j + collection_size * num_src_fields] =
            src_frac_masks[i][j];
  }
 
  // send source points to targets
  yac_interpolation_exchange_execute(
    sum_mvp_at_tgt->src2tgt, (double const **)src_send_buffer,
    src_recv_buffer, "yac_interp_operator_sum_mvp_at_tgt_execute");
 
  compute_tgt_field_stencil(
    (double const * restrict **)src_fields,
    (double const * restrict **)(with_frac_mask?src_frac_masks:NULL),
    (double const * restrict *)src_recv_buffer,
    (double const * restrict *)(
      with_frac_mask?(src_recv_buffer + collection_size * num_src_fields):NULL),
    tgt_field, sum_mvp_at_tgt->tgt_pos, sum_mvp_at_tgt->tgt_count,
    sum_mvp_at_tgt->prefix_num_src_per_tgt, sum_mvp_at_tgt->weights,
    sum_mvp_at_tgt->src_field_idx, sum_mvp_at_tgt->src_idx,
    num_src_fields, collection_size, frac_mask_fallback_value,
    scale_factor, scale_summand);
 
  if (sum_mvp_at_tgt->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);
    }
  }
}
 
static void yac_interp_operator_sum_mvp_at_tgt_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);
  UNUSED(scale_factor);
  UNUSED(scale_summand);
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt *)interp;
 
  // wait until previous exchange is completed
  // (except for when there is an open get operation, which matches this put)
  if (yac_interpolation_exchange_status(
        sum_mvp_at_tgt->src2tgt,
        "yac_interp_operator_sum_mvp_at_tgt_execute_put") !=
      YAC_INTERP_EXCH_WAIT_GET)
    yac_interp_operator_sum_mvp_at_tgt_execute_wait(interp);
 
  double ** src_send_buffer = NULL;
 
  // if source data from the local process is being used for the interpolation
  // of target points
  if (sum_mvp_at_tgt->is_source) {
 
    int with_frac_mask = sum_mvp_at_tgt->with_frac_mask;
    CHECK_WITH_FRAC_MASK()
 
    size_t collection_size =
      yac_collection_selection_get_collection_size(
        sum_mvp_at_tgt->collection_selection);
    size_t const * collection_indices =
      yac_collection_selection_get_indices(sum_mvp_at_tgt->collection_selection);
    size_t num_src_fields = sum_mvp_at_tgt->num_src_fields;
    size_t * src_send_buffer_sizes = sum_mvp_at_tgt->src_send_data.buffer_sizes;
    src_send_buffer = sum_mvp_at_tgt->src_send_data.buffer;
 
    // if collection selection is contiguous
    if (collection_indices == NULL) {
      for (size_t i = 0; i < collection_size; ++i)
        for (size_t j = 0; j < num_src_fields; ++j)
          memcpy(src_send_buffer[i * num_src_fields + j], src_fields[i][j],
                src_send_buffer_sizes[j]);
      if (with_frac_mask) {
          for (size_t i = 0; i < collection_size; ++i)
            for (size_t j = 0; j < num_src_fields; ++j)
              memcpy(
                src_send_buffer
                  [i * num_src_fields + j + collection_size * num_src_fields],
                  src_frac_masks[i][j], src_send_buffer_sizes[j]);
      }
    } else {
      for (size_t i = 0; i < collection_size; ++i)
        for (size_t j = 0; j < num_src_fields; ++j)
          memcpy(
            src_send_buffer[i * num_src_fields + j],
            src_fields[collection_indices[i]][j],
            src_send_buffer_sizes[j]);
      if (with_frac_mask) {
          for (size_t i = 0; i < collection_size; ++i)
            for (size_t j = 0; j < num_src_fields; ++j)
              memcpy(
                src_send_buffer
                  [i * num_src_fields + j + collection_size * num_src_fields],
                src_frac_masks[collection_indices[i]][j],
                src_send_buffer_sizes[j]);
      }
    }
  }
 
  yac_interpolation_exchange_execute_put(
    sum_mvp_at_tgt->src2tgt, (double const **)src_send_buffer,
    "yac_interp_operator_sum_mvp_at_tgt_execute_put");
}
 
static void compute_tgt(
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt) {
 
  int with_frac_mask = sum_mvp_at_tgt->with_frac_mask;
  double frac_mask_fallback_value =
    sum_mvp_at_tgt->frac_mask_fallback_value;
  CHECK_WITH_FRAC_MASK()
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_tgt->collection_selection);
  size_t num_src_fields = sum_mvp_at_tgt->num_src_fields;
  double ** src_recv_buffer = sum_mvp_at_tgt->src_recv_data.buffer;
 
  compute_tgt_field_stencil(
    (double const * restrict **)(sum_mvp_at_tgt->src_fields),
    (double const * restrict **)(
      with_frac_mask?sum_mvp_at_tgt->src_frac_masks:NULL),
    (double const * restrict *)src_recv_buffer,
    (double const * restrict *)(
      with_frac_mask?
        (src_recv_buffer + collection_size * num_src_fields):NULL),
    sum_mvp_at_tgt->tgt_field,
    sum_mvp_at_tgt->tgt_pos,
    sum_mvp_at_tgt->tgt_count,
    sum_mvp_at_tgt->prefix_num_src_per_tgt,
    sum_mvp_at_tgt->weights,
    sum_mvp_at_tgt->src_field_idx,
    sum_mvp_at_tgt->src_idx,
    num_src_fields, collection_size, frac_mask_fallback_value,
    sum_mvp_at_tgt->scale_factor,
    sum_mvp_at_tgt->scale_summand);
 
  sum_mvp_at_tgt->async_get_is_active = 0;
}
 
static void yac_interp_operator_sum_mvp_at_tgt_execute_get(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  // wait until previous exchange is completed
  if (yac_interpolation_exchange_status(
        sum_mvp_at_tgt->src2tgt,
        "yac_interp_operator_sum_mvp_at_tgt_execute_get") !=
      YAC_INTERP_EXCH_WAIT_PUT)
    yac_interp_operator_sum_mvp_at_tgt_execute_wait(interp);
 
  // receive source field data
  yac_interpolation_exchange_execute_get(
    sum_mvp_at_tgt->src2tgt, sum_mvp_at_tgt->src_recv_data.buffer,
    "yac_interp_operator_sum_mvp_at_tgt_execute_get");
 
  sum_mvp_at_tgt->tgt_field = tgt_field;
  sum_mvp_at_tgt->frac_mask_fallback_value = frac_mask_fallback_value;
  sum_mvp_at_tgt->scale_factor = scale_factor;
  sum_mvp_at_tgt->scale_summand = scale_summand;
 
  compute_tgt(sum_mvp_at_tgt);
}
 
static void yac_interp_operator_sum_mvp_at_tgt_execute_get_async(
  struct yac_interp_operator * interp, double ** tgt_field,
  double frac_mask_fallback_value, double scale_factor, double scale_summand) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  // wait until previous get operation is completed
  if (yac_interp_operator_sum_mvp_at_tgt_execute_get_test(interp) ==
      YAC_INTERP_INCOMPLETE)
    yac_interp_operator_sum_mvp_at_tgt_execute_wait(interp);
 
  sum_mvp_at_tgt->async_get_is_active = 1;
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_tgt->collection_selection);
  for (size_t i = 0; i < collection_size; ++i)
    sum_mvp_at_tgt->tgt_field_buffer[i] = tgt_field[i];
  sum_mvp_at_tgt->tgt_field = sum_mvp_at_tgt->tgt_field_buffer;
  sum_mvp_at_tgt->frac_mask_fallback_value = frac_mask_fallback_value;
  sum_mvp_at_tgt->scale_factor = scale_factor;
  sum_mvp_at_tgt->scale_summand = scale_summand;
 
  // receive source field data
  yac_interpolation_exchange_execute_get_async(
    sum_mvp_at_tgt->src2tgt,
    sum_mvp_at_tgt->src_recv_data.buffer,
    "yac_interp_operator_sum_mvp_at_tgt_execute_get");
}
 
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_tgt_execute_put_test(
    struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  enum YAC_INTERP_EXCH_TEST_STATUS result =
    yac_interpolation_exchange_put_test(
      sum_mvp_at_tgt->src2tgt,
      "yac_interp_operator_sum_mvp_at_tgt_execute_put_test");
 
  // if the source to target exchange has been completed and there still was
  // an open asynchronous get operation --> use received source data to compute
  // target points
  if ((result == YAC_INTERP_EXCH_COMPLETE) &&
      sum_mvp_at_tgt->async_get_is_active)
    compute_tgt(sum_mvp_at_tgt);
 
  return
    (result == YAC_INTERP_EXCH_COMPLETE)?
      YAC_INTERP_COMPLETE:YAC_INTERP_INCOMPLETE;
}
 
static enum YAC_INTERP_TEST_STATUS
  yac_interp_operator_sum_mvp_at_tgt_execute_get_test(
    struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  enum YAC_INTERP_EXCH_TEST_STATUS result =
    yac_interpolation_exchange_get_test(
      sum_mvp_at_tgt->src2tgt,
      "yac_interp_operator_sum_mvp_at_tgt_execute_get_test");
 
  if ((result == YAC_INTERP_EXCH_COMPLETE) &&
      sum_mvp_at_tgt->async_get_is_active)
    compute_tgt(sum_mvp_at_tgt);
 
  return
    (result == YAC_INTERP_EXCH_COMPLETE)?
      YAC_INTERP_COMPLETE:YAC_INTERP_INCOMPLETE;
}
 
static void yac_interp_operator_sum_mvp_at_tgt_execute_wait(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  yac_interpolation_exchange_wait(
    sum_mvp_at_tgt->src2tgt,
    "yac_interp_operator_sum_mvp_at_tgt_execute_wait");
 
  if (sum_mvp_at_tgt->async_get_is_active)
    compute_tgt(sum_mvp_at_tgt);
}
 
static struct yac_interp_operator * yac_interp_operator_sum_mvp_at_tgt_copy(
  struct yac_interp_operator * interp) {
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  size_t collection_size =
    yac_collection_selection_get_collection_size(
      sum_mvp_at_tgt->collection_selection);
 
  return
    yac_interp_operator_sum_mvp_at_tgt_new_(
      sum_mvp_at_tgt->collection_selection,
      yac_interpolation_buffer_copy(
        sum_mvp_at_tgt->src_send_data, sum_mvp_at_tgt->num_src_fields,
        sum_mvp_at_tgt->with_frac_mask?2*collection_size:collection_size),
      yac_interpolation_buffer_copy(
        sum_mvp_at_tgt->src_recv_data, sum_mvp_at_tgt->num_src_fields,
        sum_mvp_at_tgt->with_frac_mask?2*collection_size:collection_size),
      yac_interpolation_exchange_copy(sum_mvp_at_tgt->src2tgt),
      sum_mvp_at_tgt->tgt_pos,  sum_mvp_at_tgt->tgt_count,
      sum_mvp_at_tgt->prefix_num_src_per_tgt, sum_mvp_at_tgt->weights,
      sum_mvp_at_tgt->src_field_idx, sum_mvp_at_tgt->src_idx,
      sum_mvp_at_tgt->num_src_fields, sum_mvp_at_tgt->with_frac_mask,
      sum_mvp_at_tgt->ref_count);
}
 
static void yac_interp_operator_sum_mvp_at_tgt_delete(
  struct yac_interp_operator * interp) {
 
  if (interp == NULL) return;
 
  struct yac_interp_operator_sum_mvp_at_tgt * sum_mvp_at_tgt =
    (struct yac_interp_operator_sum_mvp_at_tgt*)interp;
 
  free(sum_mvp_at_tgt->src_fields);
  if (sum_mvp_at_tgt->src_frac_masks != NULL)
    free(sum_mvp_at_tgt->src_frac_masks);
  yac_interpolation_exchange_delete(
    sum_mvp_at_tgt->src2tgt, "yac_interp_operator_sum_mvp_at_tgt_delete");
  yac_interpolation_buffer_free(&(sum_mvp_at_tgt->src_send_data));
  yac_interpolation_buffer_free(&(sum_mvp_at_tgt->src_recv_data));
  free(sum_mvp_at_tgt->src_fields_buffer);
  free(sum_mvp_at_tgt->tgt_field_buffer);
 
  if (!--(*(sum_mvp_at_tgt->ref_count))) {
    free(sum_mvp_at_tgt->tgt_pos);
    free(sum_mvp_at_tgt->src_idx);
    free(sum_mvp_at_tgt->src_field_idx);
    free(sum_mvp_at_tgt->weights);
    free(sum_mvp_at_tgt->prefix_num_src_per_tgt);
    free(sum_mvp_at_tgt->ref_count);
  }
  yac_collection_selection_delete(sum_mvp_at_tgt->collection_selection);
  free(sum_mvp_at_tgt);
}