comin_callback.cpp

Go to the documentation of this file.

// @file comin_callback.cpp
// @brief Callback list based on std::vector
//
// @authors 10/2025 :: ICON Community Interface  <comin@icon-model.org>
//
// SPDX-License-Identifier: BSD-3-Clause
//
// See LICENSES for license information.
// Where software is supplied by third parties, it is indicated in the
// headers of the routines.
 
#include "comin.h"
#include "comin_logging.hpp"
#include "comin_state.hpp"
#include "comin_variable.hpp"
#include <algorithm>
#include <array>
#include <string_view>
#include <vector>
 
extern "C" {

  void comin_callback_register(t_comin_entry_point entry_point,
                               t_comin_callback_function fct_ptr) {
 
    // adjust for C/C++ 0-based indexing.
    const int entry_point_slot = static_cast<int>(entry_point) - 1;
 
    auto& callback_list = comin::state.comin_callback_list_context;
 
    t_comin_callback_item item;
    item.plugin_id     = comin_current_get_plugin_id();
    item.entrypoint_id = entry_point;
    item.fct           = fct_ptr;
 
    // callbacks cannot be registered after primary constructor
    if (comin_state_is_primary_done()) {
      comin_error_set(COMIN_ERROR_CALLBACK_REGISTER_OUTSIDE_PRIMARYCONSTRUCTOR);
      return;
    }
 
    // first check if the entry point ID and the plugin ID are
    // already present in the array:
    auto& ep_callback_list = callback_list[entry_point_slot];
    const bool is_present =
        std::any_of(ep_callback_list.cbegin(), ep_callback_list.cend(),
                    [&](const t_comin_callback_item& existing_item) {
                      return existing_item.plugin_id == item.plugin_id;
                    });
    if (is_present) {
      const char* ep_name = comin_callback_get_ep_name(entry_point);
      comin::logging::message(12, "WARNING: Callback for plugin ID ",
                              item.plugin_id,
                              " already registered at entry point '", ep_name,
                              "' (ep: ", entry_point, ")!");
      return;
    }
 
    ep_callback_list.push_back(item);
 
    {
      const char* plugin_name = comin_current_get_plugin_name();
      const char* ep_name     = comin_callback_get_ep_name(entry_point);
      comin::logging::message(
          0, "    registration for '", ep_name, "' (ep: ", entry_point,
          ") associated for 3rd party plugin ", plugin_name, " successful.");
    }
  }
 
  // Thin wrapper because the integer type underlying a C enum is implementation
  // defined before C23.
  void comin_callback_register_f(int entry_point_ftn,
                                 t_comin_callback_function fct_ptr) {
    comin_callback_register(static_cast<t_comin_entry_point>(entry_point_ftn),
                            fct_ptr);
  }
 
  // Routine to find callback routine associated with current entry point
  void comin_callback_context_call(int entry_point_id, int domain_id,
                                   bool lacc) {
 
    const t_comin_entry_point entry_point =
        static_cast<t_comin_entry_point>(entry_point_id);
 
    // We can't call callbacks before the primary constructors are done
    if (!comin_state_is_primary_done()) {
      return;
    }
 
    const char* ep_name = comin_callback_get_ep_name(entry_point);
    comin::logging::message(12, "     CONTEXT ", ep_name);
 
    using comin::state;
    auto& callback_list = state.comin_callback_list_context;
 
    auto& ep_callback_list = callback_list[entry_point - 1];
 
    if (ep_callback_list.empty()) {
      comin::logging::message(12, "     no calls associated with entry point '",
                              ep_name, "' (ep: ", entry_point, ").");
      return;
    }
 
    // call callback functions in the order they were registered
    for (const auto& cl : ep_callback_list) {
 
      // set current plugin
      comin_current_set_plugin_id(cl.plugin_id);
 
      const char* plugin_name = comin_current_get_plugin_name();
      comin::logging::message(0, "     current ep '", ep_name,
                              "' (ep: ", cl.entrypoint_id,
                              ") for library: ", plugin_name);
 
      if (lacc) {
        comin_sync_vars_for_device(entry_point, cl.plugin_id, COMIN_FLAG_READ);
      } else {
        comin_check_var_no_device(entry_point, cl.plugin_id);
      }
 
      comin_sync_vars_for_halo_region(entry_point, cl.plugin_id,
                                      COMIN_FLAG_READ);
 
      // set current entry point
      state.current_ep = entry_point;
 
      // set current domain id
      state.current_domain_id = domain_id;
      // undefine domain id for the call of the ComIn destructor
      if (entry_point == EP_DESTRUCTOR)
        state.current_domain_id = DOMAIN_UNDEFINED;
 
      // call the callback function
      cl.fct();
 
      // reset current plugin
      comin_current_set_plugin_id(0);
 
      comin_sync_vars_for_halo_region(entry_point, cl.plugin_id,
                                      COMIN_FLAG_WRITE);
      if (lacc) {
        comin_sync_vars_for_device(entry_point, cl.plugin_id, COMIN_FLAG_WRITE);
      }
    }
  }
 
  const char* comin_ep_names[] = {"EP_SECONDARY_CONSTRUCTOR",
                                  "EP_ATM_YAC_DEFCOMP_BEFORE",
                                  "EP_ATM_YAC_DEFCOMP_AFTER",
                                  "EP_ATM_YAC_SYNCDEF_BEFORE",
                                  "EP_ATM_YAC_SYNCDEF_AFTER",
                                  "EP_ATM_YAC_ENDDEF_BEFORE",
                                  "EP_ATM_YAC_ENDDEF_AFTER",
                                  "EP_ATM_INIT_FINALIZE",
                                  "EP_ATM_TIMELOOP_BEFORE",
                                  "EP_ATM_TIMELOOP_START",
                                  "EP_ATM_TIMELOOP_END",
                                  "EP_ATM_TIMELOOP_AFTER",
                                  "EP_ATM_INTEGRATE_BEFORE",
                                  "EP_ATM_INTEGRATE_START",
                                  "EP_ATM_INTEGRATE_END",
                                  "EP_ATM_INTEGRATE_AFTER",
                                  "EP_ATM_WRITE_OUTPUT_BEFORE",
                                  "EP_ATM_WRITE_OUTPUT_AFTER",
                                  "EP_ATM_CHECKPOINT_BEFORE",
                                  "EP_ATM_CHECKPOINT_AFTER",
                                  "EP_ATM_ADVECTION_BEFORE",
                                  "EP_ATM_ADVECTION_AFTER",
                                  "EP_ATM_PHYSICS_BEFORE",
                                  "EP_ATM_PHYSICS_AFTER",
                                  "EP_ATM_NUDGING_BEFORE",
                                  "EP_ATM_NUDGING_AFTER",
                                  "EP_ATM_SURFACE_BEFORE",
                                  "EP_ATM_SURFACE_AFTER",
                                  "EP_ATM_TURBULENCE_BEFORE",
                                  "EP_ATM_TURBULENCE_AFTER",
                                  "EP_ATM_MICROPHYSICS_BEFORE",
                                  "EP_ATM_MICROPHYSICS_AFTER",
                                  "EP_ATM_CONVECTION_BEFORE",
                                  "EP_ATM_CONVECTION_AFTER",
                                  "EP_ATM_RADIATION_BEFORE",
                                  "EP_ATM_RADIATION_AFTER",
                                  "EP_ATM_RADHEAT_BEFORE",
                                  "EP_ATM_RADHEAT_AFTER",
                                  "EP_ATM_GWDRAG_BEFORE",
                                  "EP_ATM_GWDRAG_AFTER",
                                  "EP_FINISH",
                                  "EP_DESTRUCTOR"};
 
  const char* comin_callback_get_ep_name(t_comin_entry_point iep) {
    if (iep < 1 || iep > (sizeof(comin_ep_names) / sizeof(comin_ep_names[0]))) {
      comin_error_set(COMIN_ERROR_CALLBACK_EP_ID_UNKNOWN);
      return nullptr;
    }
    return comin_ep_names[iep - 1];
  }
 
} // extern "C"