comin_state.cpp

Go to the documentation of this file.

 
#include "comin_state.hpp"
#include "comin_logging.hpp"
 
#include <algorithm>
#include <cstring>
 
// Global state variable.
t_comin_state comin::state;
 
extern "C" {
 
  void comin_state_set_num_plugins(int num_plugins) {
    comin::state.num_plugins = num_plugins;
  }
 
  int comin_state_get_num_plugins() { return comin::state.num_plugins; }
 
  void comin_state_set_error_code(int errcode) {
    comin::state.errcode = errcode;
  }
 
  int comin_state_get_error_code() { return comin::state.errcode; }
 
  void comin_state_set_lstdout(bool lstdout) { comin::state.lstdout = lstdout; }
 
  bool comin_state_get_lstdout() { return comin::state.lstdout; }
 
  void comin_state_set_output_unit(int unit) {
    comin::state.output_unit = unit;
  }
 
  int comin_state_get_output_unit() { return comin::state.output_unit; }
 
  t_comin_var_map* comin_state_get_var_list() {
    return &comin::state.comin_var_list;
  }
 
  t_comin_var_request_list* comin_state_get_var_request_list() {
    return &comin::state.comin_var_request_list;
  }
 
  // sets verbosity level, related to ICON's `msg_level`.
  //  0 = silent
  void comin_setup_set_verbosity_level(int level) {
    comin::state.comin_iverbosity = level;
  }
 
  // get verbosity level
  int comin_setup_get_verbosity_level() {
    return comin::state.comin_iverbosity;
  }
 
  // Access information on the current entry point being processed by ComIn.
  // @ingroup fortran_interface
  t_comin_entry_point comin_current_get_ep() { return comin::state.current_ep; }
 
  // Access information on the current domain id being processed by ComIn.
  // @ingroup fortran_interface
  int comin_current_get_domain_id() { return comin::state.current_domain_id; }
 
  // Access information on the current simulation date-time stamp (ISO 8601)
  // @ingroup fortran_interface
  const char* comin_current_get_datetime() {
    return comin::state.current_datetime.c_str();
  }
 
  void comin_current_set_datetime(const char* datetime_c) {
    std::string datetime{datetime_c};
 
    if (datetime.size() > COMIN_MAX_DATETIME_STR_LEN) {
      comin_error_set(COMIN_ERROR_FATAL);
    } else {
      comin::state.current_datetime = std::move(datetime);
    }
  }
 
  void comin_current_set_plugin_id(int plugin_id) {
    comin::state.current_plugin_id = plugin_id;
  }
 
  int comin_current_get_plugin_id() { return comin::state.current_plugin_id; }
 
  bool comin_state_is_primary_done() { return comin::state.l_primary_done; }
 
  void comin_state_set_primary_done() { comin::state.l_primary_done = true; }
 
  void
  comin_state_set_sync_halo_fct(t_comin_var_sync_halo_fct_ptr sync_halo_fct) {
    comin::state.sync_halo_fct = sync_halo_fct;
  }
 
  void comin_state_set_sync_device_fct(
      t_comin_var_sync_device_fct_ptr sync_device_fct) {
    comin::state.sync_device_fct = sync_device_fct;
  }
 
  // Synchronize all variables requested for halo region synchronization.
  void comin_sync_vars_for_halo_region(t_comin_entry_point ep, int plugin_id,
                                       int rw_flag) {
    using comin::state;
    auto& context =
        state.comin_var_list_context[std::make_tuple(ep, plugin_id)];
    for (const t_comin_var_context& item : context) {
      if ((item.access_flag & rw_flag) &&
          (item.access_flag & COMIN_FLAG_SYNC_HALO)) {
        if (state.sync_halo_fct == nullptr) {
          comin_error_set(COMIN_ERROR_VAR_SYNC_HALO_NOT_ASSOCIATED);
          return;
        }
        state.sync_halo_fct(item.var_item->descriptor.id, item.var_item->cptr,
                            item.var_item->type_id, item.var_item->array_shape,
                            item.var_item->dim_semantics);
      }
    }
  }
 
  // Check if any variable was requested with device access at non-ported
  // entrypoints (`lacc == .false.`).
  void comin_check_var_no_device(t_comin_entry_point ep, int plugin_id) {
    auto& context =
        comin::state.comin_var_list_context[std::make_tuple(ep, plugin_id)];
    for (const t_comin_var_context& item : context) {
      if (item.access_flag & COMIN_FLAG_DEVICE) {
        const char* ep_name = comin_callback_get_ep_name(ep);
        comin::logging::message(
            1, "WARNING: Device access at a non-ported entrypoint (", ep_name,
            ") requested.");
      }
    }
  }
 
  // Synchronize all variables requested for device access.
  void comin_sync_vars_for_device(t_comin_entry_point ep, int plugin_id,
                                  int rw_flag) {
    using comin::state;
    auto& context = state.comin_var_list_context[{ep, plugin_id}];
 
    for (const t_comin_var_context& item : context) {
      if ((item.access_flag & rw_flag) &&
          (item.access_flag & COMIN_FLAG_SYNC_HALO)) {
        if (state.sync_device_fct == nullptr) {
          comin_error_set(COMIN_ERROR_VAR_SYNC_DEVICE_MEM_NOT_ASSOCIATED);
          return;
        }
        state.sync_device_fct(item.var_item->cptr, item.var_item->device_ptr,
                              item.var_item->type_id,
                              item.var_item->array_shape,
                              rw_flag == COMIN_FLAG_WRITE);
      }
    }
  }
  void comin_descrdata_set_fct_glb2loc_cell(
      t_comin_glb2loc_index_lookup_fct_ptr fct) {
    comin::state.comin_descrdata_fct_glb2loc_cell = fct;
    if (!comin::state.comin_descrdata_fct_glb2loc_cell) {
      comin_error_set(COMIN_ERROR_DESCRDATA_SET_FCT_GLB2LOC);
      return;
    }
  }
  void comin_descrdata_set_fct_glb2loc_edge(
      t_comin_glb2loc_index_lookup_fct_ptr fct) {
    comin::state.comin_descrdata_fct_glb2loc_edge = fct;
    if (!comin::state.comin_descrdata_fct_glb2loc_edge) {
      comin_error_set(COMIN_ERROR_DESCRDATA_SET_FCT_GLB2LOC);
      return;
    }
  }
  void comin_descrdata_set_fct_glb2loc_vert(
      t_comin_glb2loc_index_lookup_fct_ptr fct) {
    comin::state.comin_descrdata_fct_glb2loc_vert = fct;
    if (!comin::state.comin_descrdata_fct_glb2loc_vert) {
      comin_error_set(COMIN_ERROR_DESCRDATA_SET_FCT_GLB2LOC);
      return;
    }
  }
 
  int comin_descrdata_index_lookup_glb2loc_cell(int jg, int glb) {
    return comin::state.comin_descrdata_fct_glb2loc_cell(jg, glb);
  }
  int comin_descrdata_index_lookup_glb2loc_edge(int jg, int glb) {
    return comin::state.comin_descrdata_fct_glb2loc_edge(jg, glb);
  }
  int comin_descrdata_index_lookup_glb2loc_vert(int jg, int glb) {
    return comin::state.comin_descrdata_fct_glb2loc_vert(jg, glb);
  }
 
  void
  comin_state_set_host_errhandler_fct(t_comin_host_errhandler_fct_ptr fct) {
    comin::state.comin_host_errhandler_fct = fct;
  }
 
  bool comin_state_is_host_errhandler_set() {
    return comin::state.comin_host_errhandler_fct != nullptr;
  }
 
  void comin_descrdata_set_timesteplength(int jg, double dt) {
    auto& timesteplength = comin::state.comin_descrdata_timesteplength;
    if (timesteplength.size() < (size_t)jg) {
      timesteplength.resize(jg);
    }
    timesteplength[jg - 1] = dt;
  }
 
  double comin_descrdata_get_timesteplength(int jg) {
    auto& timesteplength = comin::state.comin_descrdata_timesteplength;
    if (timesteplength.size() < (size_t)jg) {
      comin_error_set(COMIN_ERROR_DESCRDATA_TIMESTEPLENGTH_NOT_SET);
      return 0.0;
    }
    return timesteplength[jg - 1];
  }
 
  void comin_state_set_simulation_interval(const char* exp_start,
                                           const char* exp_stop,
                                           const char* run_start,
                                           const char* run_stop) {
    comin::state.comin_descrdata_simulation_interval.exp_start = exp_start;
    comin::state.comin_descrdata_simulation_interval.exp_stop  = exp_stop;
    comin::state.comin_descrdata_simulation_interval.run_start = run_start;
    comin::state.comin_descrdata_simulation_interval.run_stop  = run_stop;
  }
 
  const char* comin_descrdata_get_simulation_interval_exp_start() {
    return comin::state.comin_descrdata_simulation_interval.exp_start.c_str();
  }
 
  const char* comin_descrdata_get_simulation_interval_exp_stop() {
    return comin::state.comin_descrdata_simulation_interval.exp_stop.c_str();
  }
 
  const char* comin_descrdata_get_simulation_interval_run_start() {
    return comin::state.comin_descrdata_simulation_interval.run_start.c_str();
  }
 
  const char* comin_descrdata_get_simulation_interval_run_stop() {
    return comin::state.comin_descrdata_simulation_interval.run_stop.c_str();
  }
}