interp_method_check.c

Go to the documentation of this file.

// Copyright (c) 2024 The YAC Authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifdef HAVE_CONFIG_H
// Get the definition of the 'restrict' keyword.
#include "config.h"
#endif
 
#include <string.h>
 
#include "interpolation/methods/interp_method_internal.h"
#include "interpolation/methods/interp_method_config_internal.h"
#include "parameter/param_str.h"
#include "parameter/param_struct.h"
#include "utils_core.h"
#include "ensure_array_size.h"
#include "interpolation/methods/interp_method_check.h"
#include "instrument_internal.h"
#include "yac_mpi_common.h"
#include "yac_mpi_internal.h"
 
static size_t do_search_check(struct interp_method * method,
                              struct yac_interp_grid * interp_grid,
                              size_t * tgt_points, size_t count,
                              struct yac_interp_weights * weights,
                              int * interpolation_complete);
static void delete_check(struct interp_method * method);
 
static struct interp_method_vtable
  interp_method_check_vtable = {
    .do_search = do_search_check,
    .delete = delete_check};
 
struct interp_method_check {
 
  struct interp_method_vtable * vtable;
  func_do_search do_search_callback;
  void * do_search_user_data;
};
 
static size_t do_search_check (struct interp_method * method,
                               struct yac_interp_grid * interp_grid,
                               size_t * tgt_points, size_t count,
                               struct yac_interp_weights * weights,
                               int * interpolation_complete) {
 
  UNUSED(weights);
  UNUSED(interpolation_complete);
 
  YAC_INSTRUMENT_START(YAC_INSTR_INTERP_SEARCH_CHECK);
 
  struct interp_method_check * method_check =
    (struct interp_method_check *)method;
 
  yac_int * tgt_global_ids = xmalloc(count * sizeof(*tgt_global_ids));
  yac_coordinate_pointer tgt_coordinates =
    xmalloc(count * sizeof(*tgt_coordinates));
 
  yac_interp_grid_get_tgt_global_ids(
    interp_grid, tgt_points, count, tgt_global_ids);
  yac_interp_grid_get_tgt_coordinates(
    interp_grid, tgt_points, count, tgt_coordinates);
 
  if (method_check->do_search_callback != NULL)
    method_check->do_search_callback(
      tgt_global_ids, (yac_const_coordinate_pointer)tgt_coordinates, count,
      method_check->do_search_user_data);
 
  free(tgt_coordinates);
  free(tgt_global_ids);
 
  YAC_INSTRUMENT_STOP(YAC_INSTR_INTERP_SEARCH_CHECK);
 
  return 0;
}
 
struct interp_method * yac_interp_method_check_new(
  func_constructor constructor_callback,
  void * constructor_user_data,
  func_do_search do_search_callback,
  void * do_search_user_data) {
 
  struct interp_method_check * method = xmalloc(1 * sizeof(*method));
 
  method->vtable = &interp_method_check_vtable;
  method->do_search_callback = do_search_callback;
  method->do_search_user_data = do_search_user_data;
 
  if (constructor_callback != NULL)
    constructor_callback(constructor_user_data);
 
  return (struct interp_method*)method;
}
 
static void delete_check(struct interp_method * method) {
  free(method);
}
 
//------------------------------------------------------------------------------
// Structures and routines for callback function pointer handling
//------------------------------------------------------------------------------
 
enum callback_type {
  CONSTRUCTOR, 
  DO_SEARCH    
};
 
typedef union {
  func_constructor constructor; 
  func_do_search do_search;     
  void *ptr;                    
} callback_union;
 
static struct {
  struct {
    callback_union callback; 
    void * user_data;        
  } value;
  enum callback_type type;   
  char * key;                
} * callback_lookup_table = NULL;
static size_t callback_lookup_table_array_size = 0;
static size_t callback_lookup_table_size = 0;
 
static void interp_method_check_add_callback(
  callback_union callback, enum callback_type type, void * user_data,
  char const * key) {
 
  // ensure that the lookup table does not already contain an entry with the
  // same key and type
  for (size_t i = 0; i < callback_lookup_table_size; ++i)
    YAC_ASSERT_F(
      strcmp(callback_lookup_table[i].key, key) ||
      (callback_lookup_table[i].type != type),
      "key \"%s\" has been set for the same callback type (%d)",
      key, (int)type)
 
  ENSURE_ARRAY_SIZE(callback_lookup_table, callback_lookup_table_array_size,
                    callback_lookup_table_size + 1);
 
  callback_lookup_table[callback_lookup_table_size].key =
    xmalloc((strlen(key)+1) * sizeof(*key));
  strcpy(callback_lookup_table[callback_lookup_table_size].key, key);
  callback_lookup_table[callback_lookup_table_size].type = type;
  callback_lookup_table[callback_lookup_table_size].value.callback = callback;
  callback_lookup_table[callback_lookup_table_size].value.user_data = user_data;
  callback_lookup_table_size++;
}
 
static void interp_method_get_callback(
  char const * key, callback_union * callback, enum callback_type type,
  void ** user_data) {
 
  // initialise return values
  callback->ptr = NULL;
  *user_data = NULL;
 
  // for all lookup table entries or until a match was found
  for (size_t i = 0;
      (i < callback_lookup_table_size) &&
      (callback->ptr == NULL) && (*user_data == NULL); ++i) {
 
    // if we found a matching lookup table entry
    // (matching key and callback type)
    if ((!strcmp(callback_lookup_table[i].key, key)) &&
        (callback_lookup_table[i].type == type)) {
 
      *callback = callback_lookup_table[i].value.callback;
      *user_data = callback_lookup_table[i].value.user_data;
    }
  }
}
 
void yac_interp_method_check_add_constructor_callback(
  func_constructor constructor_callback, void * user_data, char const * key) {
 
  callback_union cb;
  cb.constructor = constructor_callback;
  interp_method_check_add_callback(cb, CONSTRUCTOR, user_data, key);
}
 
void yac_interp_method_check_get_constructor_callback(
  char const * key, func_constructor * constructor_callback,
  void ** user_data) {
 
  callback_union cb;
  interp_method_get_callback(key, &cb, CONSTRUCTOR, user_data);
  *constructor_callback = cb.constructor;
}
 
void yac_interp_method_check_add_do_search_callback(
  func_do_search do_search_callback, void * user_data, char const * key) {
 
  callback_union cb;
  cb.do_search = do_search_callback;
  interp_method_check_add_callback(cb, DO_SEARCH, user_data, key);
}
 
void yac_interp_method_check_get_do_search_callback(
  char const * key, func_do_search * do_search_callback, void ** user_data) {
 
  callback_union cb;
  interp_method_get_callback(key, &cb, DO_SEARCH, user_data);
  *do_search_callback = cb.do_search;
}
 
void yac_interp_method_check_buf_free() {
 
  for (size_t i = 0; i < callback_lookup_table_size; ++i)
    free(callback_lookup_table[i].key);
  free(callback_lookup_table);
  callback_lookup_table = NULL;
  callback_lookup_table_array_size = 0;
  callback_lookup_table_size = 0;
}
 
// --- Modular config struct and vtable for CHECK method ---
 
struct yac_interp_method_config_check {
  struct yac_interp_method_config base;
  struct yac_interp_method_check_config config;
};
 
static void config_check_delete(
  struct yac_interp_method_config *config) {
  struct yac_interp_method_config_check *config_check =
    (struct yac_interp_method_config_check *)config;
  free(config_check->config.constructor_key);
  free(config_check->config.do_search_key);
  free(config);
}
 
static struct yac_interp_method_config * config_check_copy(
  const struct yac_interp_method_config *config) {
  DEF_INTERP_METHOD_CONFIG_TYPE(check)
  struct yac_interp_method_config_check *copy = xmalloc(sizeof(*copy));
  copy->base.vtable = config_check->base.vtable;
  copy->base.root_param_cache = NULL;
  copy->config.constructor_key = xstrdup(config_check->config.constructor_key);
  copy->config.do_search_key = xstrdup(config_check->config.do_search_key);
  return (struct yac_interp_method_config *)copy;
}
 
static int config_check_compare(
  void const *a_, void const *b_) {
  DEF_INTERP_METHOD_CONFIG_COMPARE_TYPE(check)
  // Compare check method configuration:
  // 1. constructor_key: identifies the constructor callback
  CHECK_STRING(config.constructor_key);
  // 2. do_search_key: identifies the do_search callback
  CHECK_STRING(config.do_search_key);
  return 0;
}
 
// Gets interpolation method typed_config_hcsbb_get_type(
static enum yac_interpolation_list config_check_get_type() {
  return YAC_CHECK;
}
 
static struct interp_method * config_check_generate(
  struct yac_interp_method_config const *config) {
  const struct yac_interp_method_config_check *config_check =
    (const struct yac_interp_method_config_check *)config;
  func_constructor constructor_callback = NULL;
  void *constructor_user_data = NULL;
  func_do_search do_search_callback = NULL;
  void *do_search_user_data = NULL;
  yac_interp_method_check_get_constructor_callback(
    config_check->config.constructor_key,
    &constructor_callback, &constructor_user_data);
  yac_interp_method_check_get_do_search_callback(
    config_check->config.do_search_key,
    &do_search_callback, &do_search_user_data);
  return yac_interp_method_check_new(
    constructor_callback, constructor_user_data,
    do_search_callback, do_search_user_data);
}
 
static struct yac_param *config_check_get_param(
  struct yac_interp_method_config const *config) {
  struct yac_interp_method_config_check *config_check =
    (struct yac_interp_method_config_check *)config;
 
  enum {
    CONSTRUCTOR_KEY_ALLOW_NULL = 1,
    CONSTRUCTOR_KEY_ALLOW_EMPTY = 1,
    CONSTRUCTOR_KEY_HAS_DEFAULT = 1,
    CONSTRUCTOR_KEY_IS_DEFINED = 1,
    DO_SEARCH_KEY_ALLOW_NULL = 1,
    DO_SEARCH_KEY_ALLOW_EMPTY = 1,
    DO_SEARCH_KEY_HAS_DEFAULT = 1,
    DO_SEARCH_KEY_IS_DEFINED = 1,
  };
 
  struct yac_param *param_constructor_key =
    yac_param_str_new(
      "constructor_key",
      &config_check->config.constructor_key,
      YAC_INTERP_CHECK_CONSTRUCTOR_KEY_DEFAULT,
      CONSTRUCTOR_KEY_ALLOW_NULL, CONSTRUCTOR_KEY_ALLOW_EMPTY,
      YAC_MAX_ROUTINE_NAME_LENGTH - 1, CONSTRUCTOR_KEY_HAS_DEFAULT,
      CONSTRUCTOR_KEY_IS_DEFINED);
 
  struct yac_param *param_do_search_key =
    yac_param_str_new(
      "do_search_key",
      &config_check->config.do_search_key,
      YAC_INTERP_CHECK_DO_SEARCH_KEY_DEFAULT,
      DO_SEARCH_KEY_ALLOW_NULL, DO_SEARCH_KEY_ALLOW_EMPTY,
      YAC_MAX_ROUTINE_NAME_LENGTH - 1, DO_SEARCH_KEY_HAS_DEFAULT,
      DO_SEARCH_KEY_IS_DEFINED);
 
  struct yac_param *root_param_array[] = {
    param_constructor_key,
    param_do_search_key
  };
  enum {
    ROOT_PARAM_ARRAY_SIZE =
      sizeof(root_param_array) / sizeof(root_param_array[0])
  };
 
  return yac_param_struct_new(
    "check", root_param_array, ROOT_PARAM_ARRAY_SIZE);
}
 
static struct yac_interp_method_config_vtable yac_interp_method_config_vtable_check = {
  .delete = config_check_delete,
  .copy = config_check_copy,
  .compare = config_check_compare,
  .get_type = config_check_get_type,
  .generate = config_check_generate,
  .get_param = config_check_get_param
};
 
struct yac_interp_method_config *yac_interp_method_config_default_check_new(void) {
  struct yac_interp_method_config_check *config_check =
    xmalloc(sizeof(*config_check));
  config_check->base.vtable = &yac_interp_method_config_vtable_check;
  config_check->base.root_param_cache = NULL;
  config_check->config.constructor_key =
    xstrdup(YAC_INTERP_CHECK_CONSTRUCTOR_KEY_DEFAULT);
  config_check->config.do_search_key =
    xstrdup(YAC_INTERP_CHECK_DO_SEARCH_KEY_DEFAULT);
  return (struct yac_interp_method_config *)config_check;
}