comin_variable.F90

Go to the documentation of this file.

!> @file comin_variable.F90
!! @brief Functions to modify and retrieve Variable definition
!
!  @authors 08/2021 :: 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.
!
MODULE comin_variable
 
  USE iso_c_binding,           ONLY: c_int, c_ptr, c_loc, c_null_ptr, c_f_pointer, &
       &                             c_bool, c_funptr, c_funloc, c_int64_t, c_char
  USE comin_errhandler_types,  ONLY: comin_error_pointer_not_associated,                     &
    &                                comin_error_var_get_no_device,                          &
    &                                comin_error_var_get_outside_secondary_constructor,      &
    &                                comin_error_var_get_variable_not_found,                 &
    &                                comin_error_var_get_container_can_not_halo_synchronized, &
    &                                comin_error_var_get_irregular_var_can_not_halo_synchronized, &
    &                                comin_error_var_get_variable_wrong_type
  USE comin_errhandler,        ONLY: comin_error_set
  USE comin_setup_constants,   ONLY: ep_secondary_constructor,                              &
    &                                comin_flag_device, comin_flag_sync_halo, &
    &                                comin_var_datatype_double, comin_var_datatype_float, &
    &                                comin_var_datatype_int, comin_dim_semantics_undef
  USE comin_state,             ONLY: state, comin_current_get_ep, comin_current_get_plugin_id, &
    &                                comin_state_is_primary_done, comin_state_get_var_list
  USE comin_c_utils,           ONLY: convert_f_string
  USE comin_variable_types,    ONLY: t_comin_var_descriptor, t_comin_var_item, &
    &                                t_comin_var_descriptor_c, &
    &                                t_comin_var_handle, &
    &                                comin_var_sync_device_mem_fct, &
    &                                comin_var_sync_halo_fct, comin_var_ptr_init, comin_var_handle_set_cptr
 
  IMPLICIT NONE
 
  PRIVATE
 
  ! Public procedures, intention: called by host
  PUBLIC :: comin_var_list_finalize, comin_var_list_append
  ! Public procedures, intention: called by host and plugin
  PUBLIC :: comin_var_get_descr_list_head
  PUBLIC :: comin_var_descr_list_iterator_delete
  ! Public procedures, intention: called by plugin
  PUBLIC :: comin_var_get
  PUBLIC :: comin_var_get_descr_list_next, comin_var_get_descr_list_var_desc
  ! Public procedures, intention: for internal use
  PUBLIC :: comin_var_get_from_exposed
  PUBLIC :: comin_var_set_sync_device_mem
  PUBLIC :: comin_var_set_sync_halo
  ! PUBLIC procedures only exposed to host model
  PUBLIC :: comin_var_set_cptr
  PUBLIC :: comin_var_is_used
 
  PUBLIC :: comin_varmap_new
  PUBLIC :: comin_varmap_delete
  PUBLIC :: comin_varmap_clear
 
  PUBLIC :: comin_varmap_get
  PUBLIC :: comin_varmap_put
 
  PUBLIC :: comin_varmap_iterator_begin
  PUBLIC :: comin_varmap_iterator_delete
  PUBLIC :: comin_varmap_iterator_next
  PUBLIC :: comin_varmap_iterator_is_end
  PUBLIC :: comin_varmap_iterator_value
 
#include "comin_global.inc"
 
  INTERFACE
    !> Append variable item to context list (ie. the list of variable accesses for each entry point).
    SUBROUTINE comin_var_list_context_append(ep, plugin_id, var_item, access_flag) BIND(C)
      USE iso_c_binding
      IMPLICIT NONE
      INTEGER(c_int), VALUE :: ep
      INTEGER(c_int), VALUE :: plugin_id
      TYPE(C_PTR), VALUE :: var_item
      INTEGER(C_INT), VALUE :: access_flag
    END SUBROUTINE comin_var_list_context_append
 
    !> Check if a variable is actually used by any comin plugin.
    FUNCTION comin_var_is_used_c(var_descriptor) BIND(C,name="comin_var_is_used")
      IMPORT c_bool, t_comin_var_descriptor_c
      TYPE(t_comin_var_descriptor_c), INTENT(IN) :: var_descriptor
      LOGICAL(C_BOOL) :: comin_var_is_used_c
    END FUNCTION comin_var_is_used_c
 
    !> Get first element of variable descriptor list.
    !! Returns a C-pointer that can be evaluated with
    !! the auxiliary function `comin_var_get_descr_list_var_desc`.
    !! @ingroup fortran_interface
    FUNCTION comin_var_get_descr_list_head() RESULT(ptr_c) BIND(C)
      IMPORT c_ptr
      TYPE(c_ptr) :: ptr_c
    END FUNCTION comin_var_get_descr_list_head
 
    !> Get next element of variable descriptor list.
    !! Returns a C-pointer that can be evaluated with
    !! the auxiliary function `comin_var_get_descr_list_var_desc`.
    !! Returns null pointer if end of list has been reached.
    !! @ingroup fortran_interface
    FUNCTION comin_var_get_descr_list_next(current) RESULT(ptr_c) BIND(C)
      IMPORT c_ptr
      TYPE(c_ptr), INTENT(IN), VALUE :: current
      TYPE(c_ptr) :: ptr_c
    END FUNCTION comin_var_get_descr_list_next
 
    !> Delete list iterator.
    !! @ingroup fortran_interface
    SUBROUTINE comin_var_descr_list_iterator_delete(it) BIND(C)
      IMPORT c_ptr
      TYPE(c_ptr), INTENT(INOUT) :: it
    END SUBROUTINE comin_var_descr_list_iterator_delete
 
    !> Auxiliary function: Evaluates a list iterator of the
    !! variable descriptor list and returns the corresponding
    !! variable descriptor.
    !!
    !! This is the C-variant of the subroutine.
    SUBROUTINE comin_var_get_descr_list_var_desc_c(it, var_desc_out) BIND(C, name="comin_var_get_descr_list_var_desc")
      IMPORT c_ptr, t_comin_var_descriptor_c
      TYPE(c_ptr), INTENT(IN), VALUE :: it
      TYPE(t_comin_var_descriptor_c), INTENT(INOUT) :: var_desc_out
    END SUBROUTINE comin_var_get_descr_list_var_desc_c
 
    SUBROUTINE comin_state_set_sync_device_fct_c(sync_device_fct) &
      BIND(C, name="comin_state_set_sync_device_fct")
      IMPORT c_funptr
      TYPE(c_funptr), VALUE, INTENT(IN) :: sync_device_fct
    END SUBROUTINE comin_state_set_sync_device_fct_c
 
    SUBROUTINE comin_state_set_sync_halo_fct_c(sync_halo_fct) &
      BIND(C, name="comin_state_set_sync_halo_fct")
      IMPORT c_funptr
      TYPE(c_funptr), VALUE, INTENT(IN) :: sync_halo_fct
    END SUBROUTINE comin_state_set_sync_halo_fct_c
 
    FUNCTION comin_construct_metadata() RESULT(metadata_ptr) &
         & BIND(C)
      IMPORT c_ptr
      TYPE(c_ptr) :: metadata_ptr
    END FUNCTION comin_construct_metadata
 
    SUBROUTINE comin_destruct_metadata(metadata_ptr) &
         & BIND(C)
      IMPORT c_ptr
      TYPE(c_ptr), VALUE, intent(in) :: metadata_ptr
    END SUBROUTINE comin_destruct_metadata
  END INTERFACE
 
  ! Varmap functions
  INTERFACE
    SUBROUTINE comin_varmap_new(map) bind(C, name='comin_varmap_new_c')
      IMPORT c_ptr
      TYPE(c_ptr), INTENT(OUT) :: map
    END SUBROUTINE
    SUBROUTINE comin_varmap_delete(map) bind(C, name='comin_varmap_delete_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE :: map
    END SUBROUTINE
    SUBROUTINE comin_varmap_clear(map) bind(C, name='comin_varmap_clear_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE :: map
    END SUBROUTINE
    TYPE(c_ptr) FUNCTION comin_varmap_get_c (map, name, len, id) BIND(C)
      IMPORT c_ptr, c_int64_t, c_char, c_int
      TYPE(c_ptr), VALUE, INTENT(IN) :: map
      INTEGER(c_int64_t), VALUE, INTENT(IN) :: len
      CHARACTER(kind=c_char), INTENT(IN) :: name(len)
      INTEGER(c_int), VALUE, INTENT(IN) :: id
    END FUNCTION
    SUBROUTINE comin_varmap_put_c (map, name, len, id, ptr) BIND(C)
      IMPORT c_ptr, c_int64_t, c_char, c_int, t_comin_var_item
      TYPE(c_ptr), VALUE :: map
      INTEGER(c_int64_t), VALUE, INTENT(IN) :: len
      CHARACTER(kind=c_char), INTENT(IN) :: name(len)
      INTEGER(c_int), VALUE, INTENT(IN) :: id
      TYPE(t_comin_var_item), INTENT(IN) :: ptr
    END SUBROUTINE
    SUBROUTINE comin_varmap_iterator_begin (map, it) bind(C, name='comin_varmap_iterator_begin_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE :: map
      TYPE(c_ptr), INTENT(OUT) :: it
    END SUBROUTINE
    SUBROUTINE comin_varmap_iterator_delete (it) bind(C, name='comin_varmap_iterator_delete_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE :: it
    END SUBROUTINE
    SUBROUTINE comin_varmap_iterator_next (it) bind(C, name='comin_varmap_iterator_next_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE :: it
    END SUBROUTINE
    LOGICAL(c_bool) FUNCTION comin_varmap_iterator_is_end (map, it) bind(C, name='comin_varmap_iterator_is_end_c')
      IMPORT c_ptr, c_bool
      TYPE(c_ptr), VALUE, INTENT(IN) :: map
      TYPE(c_ptr), VALUE, INTENT(IN) :: it
    END FUNCTION
    SUBROUTINE comin_varmap_iterator_value (it, ptr) bind(C, name='comin_varmap_iterator_value_c')
      IMPORT c_ptr
      TYPE(c_ptr), VALUE, INTENT(IN) :: it
      TYPE(c_ptr), INTENT(OUT) :: ptr
    END SUBROUTINE
  END INTERFACE
 
CONTAINS
 
  !> Auxiliary function: Evaluates a list iterator of the
  !! variable descriptor list and returns the corresponding
  !! variable descriptor.
  !! @ingroup fortran_interface
  SUBROUTINE comin_var_get_descr_list_var_desc(it, var_desc_out)
    TYPE(c_ptr), INTENT(IN), VALUE :: it
    TYPE(t_comin_var_descriptor), INTENT(INOUT) :: var_desc_out
    !
    TYPE(t_comin_var_descriptor_c) :: var_desc_c
 
    CALL comin_var_get_descr_list_var_desc_c(it, var_desc_c)
 
    var_desc_out = t_comin_var_descriptor(var_desc_c)
  END SUBROUTINE comin_var_get_descr_list_var_desc
 
  !> Append item to variable list.
  SUBROUTINE comin_var_list_append(var_descr, cptr, device_ptr, &
    & array_shape, type_id, &
    & dim_semantics, &
    & lcontainer, ncontained, &
    & var_handle)
    TYPE(t_comin_var_descriptor), INTENT(IN) :: var_descr
    TYPE(c_ptr), INTENT(IN)                  :: cptr, device_ptr
    INTEGER, INTENT(IN)                      :: array_shape(5), type_id
    INTEGER, INTENT(IN)                      :: dim_semantics(5)
    LOGICAL, INTENT(IN)                      :: lcontainer
    INTEGER, INTENT(IN)                      :: ncontained
    TYPE(t_comin_var_handle), INTENT(OUT)    :: var_handle
    !
    TYPE(t_comin_var_item) :: var_item
 
    TYPE(c_ptr) :: var_list
 
    var_list = comin_state_get_var_list()
 
    ! add an entry to the other (internal) list of variables
    ! which contains a pointer to the above descriptor
    var_item%descriptor = t_comin_var_descriptor_c(var_descr)
    var_item%cptr = cptr
    var_item%device_ptr = device_ptr
    var_item%array_shape = array_shape
    var_item%type_id = type_id
    var_item%dim_semantics = dim_semantics
    var_item%lcontainer = lcontainer
    var_item%ncontained = ncontained
    var_item%metadata = comin_construct_metadata()
    CALL comin_varmap_put(var_list, var_descr%name, var_descr%id, var_item)
 
    var_handle = comin_var_ptr_init(comin_varmap_get(var_list, var_descr%name, var_descr%id))
 
  END SUBROUTINE comin_var_list_append
 
  !> Destruct variable list, deallocate memory.
  SUBROUTINE comin_var_list_finalize()
    ! local
    TYPE(c_ptr) :: it, cptr, var_list
    TYPE(t_comin_var_item), POINTER :: item
 
    var_list = comin_state_get_var_list()
 
    CALL comin_varmap_iterator_begin(var_list, it)
    DO WHILE (.NOT. comin_varmap_iterator_is_end(var_list, it))
      CALL comin_varmap_iterator_value(it, cptr)
      CALL c_f_pointer(cptr, item)
 
      CALL comin_destruct_metadata(item%metadata)
      item%metadata = c_null_ptr
      CALL comin_varmap_iterator_next(it)
    END DO
    CALL comin_varmap_iterator_delete(it)
    CALL comin_varmap_clear(var_list)
  END SUBROUTINE comin_var_list_finalize
 
  FUNCTION comin_var_get_c(context_len, context, var_descriptor, flag) &
    & result(var_pointer) &
    & BIND(C, name="comin_var_get")
    INTEGER(c_int),VALUE,           INTENT(IN) :: context_len
    INTEGER(c_int),                 INTENT(IN) :: context(context_len)
    TYPE(t_comin_var_descriptor_c), VALUE, INTENT(IN) :: var_descriptor
    INTEGER(c_int), VALUE,          INTENT(IN) :: flag
    TYPE(c_ptr)                                :: var_pointer
    TYPE(t_comin_var_item), POINTER            :: var_item => null()
 
    TYPE(t_comin_var_descriptor) :: var_descriptor_fortran
 
    var_pointer = c_null_ptr
 
    var_descriptor_fortran = t_comin_var_descriptor(var_descriptor)
 
    CALL comin_var_get_internal(context, var_descriptor_fortran, flag, var_item)
    IF(ASSOCIATED(var_item)) var_pointer = c_loc(var_item)
  END FUNCTION comin_var_get_c
 
  FUNCTION comin_var_get_ptr(handle) &
    & result(dataptr)                          &
    & BIND(C, NAME="comin_var_get_ptr")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: dataptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    IF (.NOT. ASSOCIATED(p)) THEN
      dataptr = c_null_ptr
    ELSE
      dataptr  = p%cptr
    END IF
  END FUNCTION comin_var_get_ptr
 
  FUNCTION comin_var_get_ptr_double(handle) &
    & result(dataptr)                    &
    & BIND(C, NAME="comin_var_get_ptr_double")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: dataptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    dataptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_double) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      dataptr  = p%cptr
    END IF
  END FUNCTION comin_var_get_ptr_double
 
  FUNCTION comin_var_get_ptr_float(handle) &
    & result(dataptr)                 &
    & BIND(C, NAME="comin_var_get_ptr_float")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: dataptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    dataptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_float) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      dataptr  = p%cptr
    END IF
  END FUNCTION comin_var_get_ptr_float
 
  FUNCTION comin_var_get_ptr_int(handle) &
    & result(dataptr)                 &
    & BIND(C, NAME="comin_var_get_ptr_int")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: dataptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    dataptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_int) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      dataptr  = p%cptr
    END IF
  END FUNCTION comin_var_get_ptr_int
 
  FUNCTION comin_var_get_device_ptr(handle)          &
    & result(device_ptr)                          &
    & BIND(C, NAME="comin_var_get_device_ptr")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: device_ptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    device_ptr = p%device_ptr
  END FUNCTION comin_var_get_device_ptr
 
  FUNCTION comin_var_get_device_ptr_double(handle)          &
    & result(device_ptr)                          &
    & BIND(C, NAME="comin_var_get_device_ptr_double")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: device_ptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
 
    device_ptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_double) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      device_ptr = p%device_ptr
    ENDIF
  END FUNCTION comin_var_get_device_ptr_double
 
  FUNCTION comin_var_get_device_ptr_float(handle)          &
    & result(device_ptr)                          &
    & BIND(C, NAME="comin_var_get_device_ptr_float")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: device_ptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
 
    device_ptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_float) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      device_ptr = p%device_ptr
    ENDIF
  END FUNCTION comin_var_get_device_ptr_float
 
  FUNCTION comin_var_get_device_ptr_int(handle)          &
    & result(device_ptr)                          &
    & BIND(C, NAME="comin_var_get_device_ptr_int")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(c_ptr)                       :: device_ptr
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
 
    device_ptr = c_null_ptr
    CALL c_f_pointer(handle, p)
    IF (ASSOCIATED(p)) THEN
      IF(p%type_id /= comin_var_datatype_int) THEN
        CALL comin_error_set(comin_error_var_get_variable_wrong_type); RETURN
      ENDIF
      device_ptr = p%device_ptr
    ENDIF
  END FUNCTION comin_var_get_device_ptr_int
 
  SUBROUTINE comin_var_get_shape(handle, data_shape) &
    & BIND(C, NAME="comin_var_get_shape")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    INTEGER(C_INT), INTENT(INOUT)       :: data_shape(5)
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    IF (.NOT. ASSOCIATED(p)) THEN
      CALL comin_error_set(comin_error_pointer_not_associated); RETURN
    ELSE
      data_shape = p%array_shape
    END IF
  END SUBROUTINE comin_var_get_shape
 
  SUBROUTINE comin_var_get_dim_semantics(handle, dim_semantics) &
    & BIND(C, NAME="comin_var_get_dim_semantics")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    INTEGER(C_INT), INTENT(OUT)       :: dim_semantics(5)
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    IF (.NOT. ASSOCIATED(p)) THEN
      CALL comin_error_set(comin_error_pointer_not_associated); RETURN
    ELSE
      dim_semantics = p%dim_semantics
    END IF
  END SUBROUTINE comin_var_get_dim_semantics
 
  SUBROUTINE comin_var_get_ncontained(handle, ncontained) &
    & BIND(C, NAME="comin_var_get_ncontained")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    INTEGER(C_INT), INTENT(OUT)       :: ncontained
    !
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    IF (.NOT. ASSOCIATED(p)) THEN
      CALL comin_error_set(comin_error_pointer_not_associated); RETURN
    ELSE
      ! Convert to C dimension index
      ncontained = p%ncontained - 1
    END IF
  END SUBROUTINE comin_var_get_ncontained
 
  SUBROUTINE comin_var_get_descriptor(handle, descr) &
    & BIND(C, NAME="comin_var_get_descriptor")
    TYPE(c_ptr),    INTENT(IN), VALUE :: handle
    TYPE(t_comin_var_descriptor_c), INTENT(INOUT) :: descr
 
    TYPE(t_comin_var_item), POINTER :: p => null()
    CALL c_f_pointer(handle, p)
    IF (.NOT. ASSOCIATED(p)) THEN
      CALL comin_error_set(comin_error_pointer_not_associated); RETURN
    ELSE
      descr = p%descriptor
    END IF
  END SUBROUTINE comin_var_get_descriptor
 
  !> Request a pointer to an ICON variable in context(s).
  !! @ingroup fortran_interface
  SUBROUTINE comin_var_get(context, var_descriptor, flag, var_ptr)
    INTEGER,                      INTENT(IN)  :: context(:)
    TYPE(t_comin_var_descriptor), INTENT(IN)  :: var_descriptor
    INTEGER,                      INTENT(IN)  :: flag
    TYPE(t_comin_var_handle),        INTENT(OUT) :: var_ptr
    ! local
    TYPE(t_comin_var_item), POINTER          :: var_item => null()
 
    CALL comin_var_get_internal(context, var_descriptor, flag, var_item)
    var_ptr = comin_var_ptr_init(var_item)
  END SUBROUTINE comin_var_get
 
  !> get pointer to a variable exposed by ICON
  FUNCTION comin_var_get_from_exposed(var_descriptor)  RESULT(comin_get_var)
    TYPE(t_comin_var_item), POINTER :: comin_get_var
    TYPE (t_comin_var_descriptor), INTENT(IN) :: var_descriptor
    !
    TYPE(c_ptr) :: var_list
 
    var_list = comin_state_get_var_list()
    comin_get_var => comin_varmap_get(var_list, var_descriptor%name, var_descriptor%id)
  END FUNCTION comin_var_get_from_exposed
 
  !> C wrapper: should be removed once the variable list moves to C++
  FUNCTION comin_var_get_from_exposed_c(var_descriptor) &
       & result(var_item_ptr) &
       & BIND(C, name="comin_var_get_from_exposed")
    TYPE (t_comin_var_descriptor_c), VALUE, INTENT(IN) :: var_descriptor
    TYPE (c_ptr) :: var_item_ptr
    !
    TYPE (t_comin_var_descriptor) :: var_descriptor_fortran
    TYPE(c_ptr) :: var_list
    TYPE(t_comin_var_item), POINTER :: var_item_ptr_f
 
    var_list = comin_state_get_var_list()
    var_descriptor_fortran = t_comin_var_descriptor(var_descriptor)
    var_item_ptr_f => comin_varmap_get(var_list, var_descriptor_fortran%name, var_descriptor_fortran%id)
    var_item_ptr = c_loc(var_item_ptr_f)
  END FUNCTION comin_var_get_from_exposed_c
 
  SUBROUTINE comin_var_set_sync_device_mem(sync_device_mem)
    PROCEDURE(comin_var_sync_device_mem_fct) :: sync_device_mem
    TYPE(c_funptr) :: ptr
    ptr = c_funloc(sync_device_mem)
    CALL comin_state_set_sync_device_fct_c(ptr)
  END SUBROUTINE comin_var_set_sync_device_mem
 
  SUBROUTINE comin_var_set_sync_halo(sync_halo)
    PROCEDURE(comin_var_sync_halo_fct) :: sync_halo
    TYPE(c_funptr) :: ptr
    ptr = c_funloc(sync_halo)
    CALL comin_state_set_sync_halo_fct_c(ptr)
  END SUBROUTINE comin_var_set_sync_halo
 
  SUBROUTINE comin_var_get_internal(context, var_descriptor, flag, var_item)
    INTEGER,                      INTENT(IN) :: context(:)
    TYPE(t_comin_var_descriptor), INTENT(IN) :: var_descriptor
    INTEGER,                      INTENT(IN) :: flag
    TYPE(t_comin_var_item), POINTER :: var_item
    ! local
    INTEGER :: ic
    INTEGER(C_INT) :: plugin_id
    plugin_id = comin_current_get_plugin_id()
 
    ! Routine should only be called during secondary constructor
    IF ((.NOT. comin_state_is_primary_done()) .OR. &
      &   comin_current_get_ep() > ep_secondary_constructor) THEN
      CALL comin_error_set(comin_error_var_get_outside_secondary_constructor); RETURN
    END IF
 
    ! device pointers can only be accessed if a device is available
    IF ((.NOT. state%comin_descrdata_global_data%has_device) .AND. &
         & iand(flag, comin_flag_device) /= 0) THEN
      CALL comin_error_set(comin_error_var_get_no_device); RETURN
    ENDIF
    ! first find the variable in list of all ICON variables and set the pointer
    var_item => comin_var_get_from_exposed(var_descriptor)
    IF (.NOT. ASSOCIATED(var_item)) THEN
      CALL comin_error_set(comin_error_var_get_variable_not_found); RETURN
    ENDIF
    ! a container can not halo synchronized
    IF ((var_item%lcontainer) .AND. &
      & iand(flag, comin_flag_sync_halo) /= 0) THEN
      CALL comin_error_set(comin_error_var_get_container_can_not_halo_synchronized); RETURN
    ENDIF
    ! an irregular var can not be halo synchronized
    IF ((any(var_item%dim_semantics == comin_dim_semantics_undef)) .AND. &
      & iand(flag, comin_flag_sync_halo) /= 0) THEN
      CALL comin_error_set(comin_error_var_get_irregular_var_can_not_halo_synchronized); RETURN
    ENDIF
 
    DO ic = 1, SIZE(context)
      ! ignore EP_SECONDARY_CONSTRUCTOR for var_list
      IF (context(ic) == ep_secondary_constructor) cycle
      CALL comin_var_list_context_append(context(ic), plugin_id, c_loc(var_item), flag)
    END DO
  END SUBROUTINE comin_var_get_internal
 
  SUBROUTINE comin_var_set_cptr(var, cptr)
    TYPE(t_comin_var_handle), INTENT(INOUT) :: var
    TYPE(c_ptr), INTENT(IN)               :: cptr
    CALL comin_var_handle_set_cptr(var, cptr)
  END SUBROUTINE comin_var_set_cptr
 
  !> Check if a variable is actually used by any comin plugin.
  LOGICAL FUNCTION comin_var_is_used(var_descriptor)
    TYPE(t_comin_var_descriptor), INTENT(IN) :: var_descriptor
    TYPE(t_comin_var_descriptor_c) :: var_descriptor_c
    var_descriptor_c%id = var_descriptor%id
    CALL convert_f_string(var_descriptor%name, var_descriptor_c%name)
    comin_var_is_used = comin_var_is_used_c(var_descriptor_c)
  END FUNCTION comin_var_is_used
 
  SUBROUTINE comin_varmap_put (map, name, id, var_item)
    TYPE(c_ptr), INTENT(INOUT) :: map
    CHARACTER(kind=c_char, len=*), INTENT(IN) :: name
    INTEGER(c_int), INTENT(IN) :: id
    TYPE(t_comin_var_item), INTENT(IN) :: var_item
 
    CALL comin_varmap_put_c(map, name, len(name, kind=c_int64_t), id, var_item)
  END SUBROUTINE
 
  FUNCTION comin_varmap_get (map, name, id)
    TYPE(t_comin_var_item), POINTER :: comin_varmap_get
    TYPE(c_ptr), INTENT(IN) :: map
    CHARACTER(kind=c_char, len=*), INTENT(IN) :: name
    INTEGER(c_int), INTENT(IN) :: id
    TYPE(c_ptr) :: tmp_ptr
 
    tmp_ptr = comin_varmap_get_c(map, name, len(name, kind=c_int64_t), id)
    CALL c_f_pointer(tmp_ptr, comin_varmap_get)
  END FUNCTION
 
END MODULE comin_variable