registry_mod Module Reference

MONC component registry. More...

Data Types
type	group_descriptor_type
	Descriptor of a group. More...
type	pointer_wrapper_type
	Private helper type which wraps a procedure pointer. This is needed for storage in our collections_mod and allows us to associate additional information, such as number of times called, performance etc in future if we wanted to. More...

Functions/Subroutines
subroutine, public	init_registry (options_database)
	Initialises the registry with the provided configuration file. More...
subroutine, public	free_registry ()
	Will deregister all components and free up the registry data structures. This can either be called at the end of execution to clean memory up or used to clear the registry. More...
subroutine, public	register_component (options_database, descriptor)
	Will register a component and install the nescesary callback hooks. More...
logical function, public	is_component_field_available (name)
	Determines whether a specific published field is available or not. More...
type(component_field_value_type) function, public	get_component_field_value (current_state, name)
	Retrieves the value wrapper of a components published field. More...
type(component_field_information_type) function, public	get_component_field_information (current_state, name)
	Retrieves information about a components published field which includes its type and size. More...
type(list_type) function, public	get_all_component_published_fields ()
	Retrieves all of the published field information. More...
subroutine	load_published_fields (descriptor)
	Loads the published fields information for an entire component into the registry's definition list. More...
subroutine, public	deregister_component (name)
	Will deregister a component, remove all callback hooks and free registry specific memory allocated to the component. More...
type(component_descriptor_type) function, pointer, public	get_component_info (name)
	Retrieves detailed information about a specific component. More...
type(map_type) function, public	get_all_registered_components ()
	Returns a brief summary of all registered components. More...
subroutine, public	execute_initialisation_callbacks (current_state)
	Calls all initialisation callbacks with the specified state. More...
subroutine, public	execute_timestep_callbacks (current_state, group_id)
	Calls all timestep callbacks with the specified state. More...
subroutine, public	execute_finalisation_callbacks (current_state)
	Calls all finalisation callbacks with the specified state. More...
subroutine, public	order_all_callbacks ()
	Orders all callbacks in the prospective stages based upon the priorities of each descriptor. More...
type(map_type) function	order_grouped_timstep_callbacks (group_id)
logical function, public	is_component_enabled (options_database, component_name)
	Determines whether or not a specific component is registered and enabled. More...
subroutine, public	display_callbacks_in_order_at_each_stage ()
	Displays the registered callbacks of each stage in the order that they will be called. More...
subroutine, public	get_ordered_groups (ordered_groups)
	Orders all the groups (in the order that they will be called in) and returns an array with these in order. This is useful for prefetching the groups in order so that per timestep we can just iterate through the array which is O(n) More...
integer function	get_group_id (group_name)
	Given a group name this returns the id (i.e. order) of that group. More...
type(group_descriptor_type) function	get_group_descriptor_from_name (group_name)
	Given a group name this returns the group descriptor corresponding to that or an error if none is found. More...
type(group_descriptor_type) function	get_group_descriptor_from_id (group_id)
	Given the id of a group this will return the corresponding descriptor. More...
subroutine	display_callbacks_in_order (stage_callbacks, stagetitle)
	Displays the registered callbacks of a specific stage in the order that they will be called. More...
subroutine	read_initialisation_and_finalisation_orders (options_database)
subroutine	read_specific_orders (options_database, key, data_structure)
subroutine	read_group_configurations (options_database)
subroutine	remove_descriptor (descriptor)
	Will remove a specific descriptor from the registry table and uninstall the corresponding callback hooks for each state. More...
subroutine	unload_callback_hooks (descriptor, group_name)
	Will unload the callback hooks that have been installed for each state. More...
subroutine	load_callback_hooks (descriptor, group_name)
	Will install the callback hooks for each state. More...
subroutine	rebalance_callbacks (callbacks, priorities, stage_name)
integer function	get_highest_callback_priority (callbacks, priorities)
subroutine	execute_callbacks (callback_map, current_state)
	Will execute the appropriate callbacks in a specific map_type given the current state. More...
subroutine	add_callback (callback_map, name, procedure_pointer)
	Will install a specific callback hook into the specified map_type of existing hooks. More...

Variables
integer, parameter, public	group_type_whole =0
	Execute the callbacks in this group once per timestep. More...
integer, parameter, public	group_type_column =1
	Execute the callbacks in this group for each column per timestep. More...
type(list_type), save	field_information
integer, dimension(:), allocatable	group_types
	Group types. More...
character(len=string_length), dimension(:), allocatable	enabled_component_input_keys
	Temporary read array of component enable names. More...
character(len=string_length), dimension(:), allocatable	group_locations
	Provides an id to each group. More...
type(map_type), save	init_callbacks
	Callback hooks for the initialisation stage. More...
type(map_type), save	finalisation_callbacks
	Callback hooks for the finalisation stage. More...
type(map_type), save	component_descriptions
	Copies of component descriptors. More...
type(map_type), save	group_descriptors
	Group descriptors for each group, name->descriptor. More...
type(map_type), save	component_groups
type(map_type), save	init_orderings
type(map_type), save	finalisation_orderings
type(hashmap_type), save	field_procedure_retrievals
type(hashmap_type), save	field_procedure_sizings
type(map_type), dimension(:), allocatable	timestep_callbacks
	Callback hooks for the timestep stage. More...

Detailed Description

MONC component registry.

Supports management of components. Each stage is called via the registry which will execute the installed callback hooks for that stage in order.

Function/Subroutine Documentation

add_callback()

subroutine registry_mod::add_callback ( type(map_type), intent(inout)  callback_map, character(len=*), intent(in)  name, procedure(), pointer  procedure_pointer  )

private

Will install a specific callback hook into the specified map_type of existing hooks.

Parameters

callbackmap_type	The map_type of existing callbacks which we are going to install this one into
name	The name of the callback that we are installing
procedurePointer	Pointer to the procedure which implements the callback

Definition at line 646 of file registry.F90.

    type(map_type), intent(inout) :: callback_map
    procedure(), pointer :: procedure_pointer
    character(len=*), intent(in) :: name
 
    type(pointer_wrapper_type), pointer :: wrapper
    class(*), pointer :: genericwrapper
 
    allocate(wrapper) ! We allocate our own copy of the descriptor here to ensure the consistency of registry information
    wrapper%ptr => procedure_pointer
    genericwrapper=>wrapper
    call c_put_generic(callback_map, name, genericwrapper, .false.)

Here is the caller graph for this function:

deregister_component()

subroutine, public registry_mod::deregister_component

(

character(len=*), intent(in)

name

)

Will deregister a component, remove all callback hooks and free registry specific memory allocated to the component.

Parameters

name	The name of the component to de-register

Definition at line 225 of file registry.F90.

    character(len=*), intent(in) :: name
    class(*), pointer :: description_data
 
    description_data=>c_get_generic(component_descriptions, name)
    select type(description_data)
      type is (component_descriptor_type)
        call remove_descriptor(description_data)
    end select
    deallocate(description_data)  ! Is added as a clone of the original so free the memory

Here is the call graph for this function:

Here is the caller graph for this function:

display_callbacks_in_order()

subroutine registry_mod::display_callbacks_in_order ( type(map_type), intent(inout)  stage_callbacks, character(len=*), intent(in)  stagetitle  )

private

Displays the registered callbacks of a specific stage in the order that they will be called.

Parameters

stageCallbacks	The registered callbacks for a stage
stagetitle	The title of the stage - used for printing out information

Definition at line 435 of file registry.F90.

    type(map_type), intent(inout) :: stage_callbacks
    character(len=*), intent(in) :: stagetitle
 
    integer :: i, entries
 
    entries = c_size(stage_callbacks)
    do i=1,entries
      call log_master_log(log_info, "Stage: "//stagetitle//" at: "//trim(conv_to_string(i))//"  "//c_key_at(stage_callbacks, i))
    end do

Here is the caller graph for this function:

display_callbacks_in_order_at_each_stage()

subroutine, public registry_mod::display_callbacks_in_order_at_each_stage

Displays the registered callbacks of each stage in the order that they will be called.

Definition at line 347 of file registry.F90.

    integer :: i
    type(group_descriptor_type) :: group_descriptor
 
    call display_callbacks_in_order(init_callbacks, "init")
    do i=1,size(timestep_callbacks)
      group_descriptor=get_group_descriptor_from_id(i)
      call display_callbacks_in_order(timestep_callbacks(i), "timestep group '"//trim(group_descriptor%name)//"'")
    end do    
    call display_callbacks_in_order(finalisation_callbacks, "finalisation")

Here is the call graph for this function:

Here is the caller graph for this function:

execute_callbacks()

subroutine registry_mod::execute_callbacks ( type(map_type), intent(inout)  callback_map, type(model_state_type), intent(inout)  current_state  )

private

Will execute the appropriate callbacks in a specific map_type given the current state.

Parameters

callbackmap_type	The map_type of callback hooks to execute
currentState	The model state which may be (and likely is) modified in callbacks

Definition at line 625 of file registry.F90.

    type(map_type), intent(inout) :: callback_map
    type(model_state_type), intent(inout) :: current_state
 
    class(*), pointer :: data
    type(iterator_type) :: iterator
 
    iterator=c_get_iterator(callback_map)
    do while (c_has_next(iterator))
      data=>c_get_generic(c_next_mapentry(iterator))
      select type(data)
        type is (pointer_wrapper_type)
        call data%ptr(current_state)
      end select
    end do

Here is the caller graph for this function:

execute_finalisation_callbacks()

subroutine, public registry_mod::execute_finalisation_callbacks

(

type(model_state_type), intent(inout)

current_state

)

Calls all finalisation callbacks with the specified state.

Parameters

currentState

The current model state which may (and often is) modified

Definition at line 293 of file registry.F90.

    type(model_state_type), intent(inout) :: current_state
 
    call execute_callbacks(finalisation_callbacks, current_state)

Here is the call graph for this function:

Here is the caller graph for this function:

execute_initialisation_callbacks()

subroutine, public registry_mod::execute_initialisation_callbacks

(

type(model_state_type), intent(inout)

current_state

)

Calls all initialisation callbacks with the specified state.

Parameters

currentState

The current model state which may (and often is) modified

Definition at line 274 of file registry.F90.

    type(model_state_type), intent(inout) :: current_state
 
    call execute_callbacks(init_callbacks, current_state)

Here is the call graph for this function:

Here is the caller graph for this function:

execute_timestep_callbacks()

subroutine, public registry_mod::execute_timestep_callbacks	(	type(model_state_type), intent(inout)	current_state,
		integer	group_id
	)

Calls all timestep callbacks with the specified state.

Parameters

currentState

The current model state which may (and often is) modified

Definition at line 282 of file registry.F90.

    type(model_state_type), intent(inout) :: current_state
    integer :: group_id
 
    if (.not. c_is_empty(timestep_callbacks(group_id))) then
      call execute_callbacks(timestep_callbacks(group_id), current_state)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

free_registry()

subroutine, public registry_mod::free_registry

Will deregister all components and free up the registry data structures. This can either be called at the end of execution to clean memory up or used to clear the registry.

Definition at line 76 of file registry.F90.

    integer :: i, entries
   
    entries = c_size(component_descriptions)
    do i=1, entries
      ! Key de registering key at element one as each deregister removes elements from map_type
      call deregister_component(c_key_at(component_descriptions, 1))
    end do
 
    call c_free(init_callbacks)
    do i=1,size(timestep_callbacks)
      call c_free(timestep_callbacks(i))
    end do
    deallocate(timestep_callbacks)
    call c_free(finalisation_callbacks)
    call c_free(component_descriptions)
    call c_free(component_groups)
    call c_free(init_orderings)
    call c_free(finalisation_orderings)

Here is the call graph for this function:

Here is the caller graph for this function:

get_all_component_published_fields()

type(list_type) function, public registry_mod::get_all_component_published_fields

Retrieves all of the published field information.

Returns

The list of published fields

Definition at line 184 of file registry.F90.

    type(list_type) :: get_all_component_published_fields
 
    get_all_component_published_fields=field_information

get_all_registered_components()

type(map_type) function, public registry_mod::get_all_registered_components

Returns a brief summary of all registered components.

Returns

A map_type where the keys are the component names and value the corresponding version number

Definition at line 257 of file registry.F90.

    integer :: i, number_of_components
    class(*), pointer :: description_data
    type(iterator_type) :: iterator
 
    iterator=c_get_iterator(component_descriptions)
    do while (c_has_next(iterator))
      description_data=>c_get_generic(c_next_mapentry(iterator))
      select type(description_data)
        type is(component_descriptor_type)
          call c_put_real(get_all_registered_components, description_data%name, description_data%version)
      end select
    end do    

Here is the caller graph for this function:

get_component_field_information()

type(component_field_information_type) function, public registry_mod::get_component_field_information	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name
	)

Retrieves information about a components published field which includes its type and size.

Parameters

name	The name of the field to look up

Returns

The value wrapper that is associated with this field

Definition at line 164 of file registry.F90.

    type(model_state_type), target, intent(inout) :: current_state
    character(len=*), intent(in) :: name
    type(component_field_information_type) :: get_component_field_information
 
    class(*), pointer :: data
 
    if (c_contains(field_procedure_retrievals, name)) then
      data=>c_get_generic(field_procedure_sizings, name)
      select type(data)
      type is (pointer_wrapper_type)
        call data%ptr(current_state, name, get_component_field_information)
      end select
    else
      call log_master_log(log_error, "Published field '"//trim(name)//"' is not found in any enabled components")
    end if

Here is the call graph for this function:

get_component_field_value()

type(component_field_value_type) function, public registry_mod::get_component_field_value	(	type(model_state_type), intent(inout), target	current_state,
		character(len=*), intent(in)	name
	)

Retrieves the value wrapper of a components published field.

Parameters

name	The name of the field to look up

Returns

The value wrapper that is associated with this field

Definition at line 143 of file registry.F90.

    type(model_state_type), target, intent(inout) :: current_state
    character(len=*), intent(in) :: name
    type(component_field_value_type) :: get_component_field_value
 
    class(*), pointer :: data
 
    if (c_contains(field_procedure_retrievals, name)) then
      data=>c_get_generic(field_procedure_retrievals, name)
      select type(data)
      type is (pointer_wrapper_type)
        call data%ptr(current_state, name, get_component_field_value)
      end select
    else
      call log_master_log(log_error, "Published field '"//trim(name)//"' is not found in any enabled components")
    end if

Here is the call graph for this function:

get_component_info()

type(component_descriptor_type) function, pointer, public registry_mod::get_component_info

(

character(len=*), intent(in)

name

)

Retrieves detailed information about a specific component.

Parameters

name	The name of the component to retrieve information for

Returns

The registry's copy of the component descriptor or null if it does not exist

Definition at line 240 of file registry.F90.

    character(len=*), intent(in) :: name
    type(component_descriptor_type), pointer :: get_component_info
    class(*), pointer :: description_data
 
    get_component_info => null()
    description_data => c_get_generic(component_descriptions, name)
    if (associated(description_data)) then
      select type(description_data)
        type is (component_descriptor_type)
        get_component_info => description_data
      end select
    end if

Here is the caller graph for this function:

get_group_descriptor_from_id()

type(group_descriptor_type) function registry_mod::get_group_descriptor_from_id ( integer, intent(in)  group_id )

private

Given the id of a group this will return the corresponding descriptor.

Parameters

group_id

Id of the group to find

Returns

The descriptor that has the correct id number

Definition at line 411 of file registry.F90.

    integer, intent(in) :: group_id
 
    type(iterator_type) :: iterator
    class(*), pointer :: generic
 
    iterator=c_get_iterator(group_descriptors)
    do while (c_has_next(iterator))
      generic=>c_get_generic(c_next_mapentry(iterator))
       if (associated(generic)) then
        select type(generic)
        type is(group_descriptor_type)
          if (generic%id == group_id) then
            get_group_descriptor_from_id=generic
            return
          end if
        end select
      end if
    end do     

Here is the caller graph for this function:

get_group_descriptor_from_name()

type(group_descriptor_type) function registry_mod::get_group_descriptor_from_name ( character(len=*), intent(in)  group_name )

private

Given a group name this returns the group descriptor corresponding to that or an error if none is found.

Parameters

group_name

Name of the group to look up

Returns

Descriptor of the corresponding group

Definition at line 392 of file registry.F90.

    character(len=*), intent(in) :: group_name
 
    class(*), pointer :: generic       
 
    generic=>c_get_generic(group_descriptors, group_name)
    if (associated(generic)) then
      select type(generic)
        type is(group_descriptor_type)
          get_group_descriptor_from_name=generic
      end select      
    else
      call log_master_log(log_error, "No configuration specified for group "//group_name)
    end if    

Here is the caller graph for this function:

get_group_id()

integer function registry_mod::get_group_id ( character(len=*), intent(in)  group_name )

private

Given a group name this returns the id (i.e. order) of that group.

Parameters

group_name

The group name to look up

Returns

The id (also order) of the group

Definition at line 380 of file registry.F90.

    character(len=*), intent(in) :: group_name
 
    type(group_descriptor_type) :: descriptor
 
    descriptor=get_group_descriptor_from_name(group_name)
    get_group_id=descriptor%id

Here is the call graph for this function:

Here is the caller graph for this function:

get_highest_callback_priority()

integer function registry_mod::get_highest_callback_priority ( type(map_type), intent(inout)  callbacks, type(map_type), intent(inout)  priorities  )

private

Definition at line 599 of file registry.F90.

    type(map_type), intent(inout) :: callbacks, priorities
 
    integer :: i, entries_in_list, min_priority, min_location, priority
    character(len=STRING_LENGTH) :: key
 
    min_location=0
    min_priority=1000
 
    entries_in_list=c_size(callbacks)
    do i=1, entries_in_list
      key=c_key_at(callbacks, i)
      if (c_contains(priorities, key)) then
        priority=c_get_integer(priorities, key)
        if (priority .lt. min_priority) then
          min_priority=priority
          min_location=i
        end if      
      end if
    end do
    get_highest_callback_priority=min_location

Here is the caller graph for this function:

get_ordered_groups()

subroutine, public registry_mod::get_ordered_groups

(

type(group_descriptor_type), dimension(:), allocatable

ordered_groups

)

Orders all the groups (in the order that they will be called in) and returns an array with these in order. This is useful for prefetching the groups in order so that per timestep we can just iterate through the array which is O(n)

Returns

An array of groups in the order that they will be executed in

Definition at line 362 of file registry.F90.

    type(group_descriptor_type), dimension(:), allocatable :: ordered_groups
 
    integer :: i
 
    allocate(ordered_groups(c_size(group_descriptors)))
    do i=1,c_size(group_descriptors)
      ordered_groups(i)=get_group_descriptor_from_id(i)
    end do    

Here is the call graph for this function:

Here is the caller graph for this function:

init_registry()

subroutine, public registry_mod::init_registry

(

type(hashmap_type), intent(inout)

options_database

)

Initialises the registry with the provided configuration file.

Parameters

configurationFileName

The filename of the configuration file to parse

Definition at line 66 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
 
    call read_group_configurations(options_database)
    call read_initialisation_and_finalisation_orders(options_database)
    allocate(timestep_callbacks(c_size(group_descriptors)))

Here is the call graph for this function:

Here is the caller graph for this function:

is_component_enabled()

logical function, public registry_mod::is_component_enabled	(	type(hashmap_type), intent(inout)	options_database,
		character(len=*), intent(in)	component_name
	)

Determines whether or not a specific component is registered and enabled.

Parameters

component_name

The name of the component to check for

Definition at line 333 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
    character(len=*), intent(in) :: component_name
    
    if (c_contains(component_descriptions, component_name)) then
      if (options_has_key(options_database, trim(component_name)//"_enabled")) then
        is_component_enabled=options_get_logical(options_database, trim(component_name)//"_enabled")
        return
      end if
    end if
    is_component_enabled=.false.

Here is the caller graph for this function:

is_component_field_available()

logical function, public registry_mod::is_component_field_available

(

character(len=*), intent(in)

name

)

Determines whether a specific published field is available or not.

Parameters

name	The name of the field to search for

Returns

Whether this field is found

Definition at line 134 of file registry.F90.

    character(len=*), intent(in) :: name
 
    is_component_field_available=c_contains(field_procedure_retrievals, name)

load_callback_hooks()

subroutine registry_mod::load_callback_hooks ( type(component_descriptor_type), intent(in)  descriptor, character(len=*), intent(in), optional  group_name  )

private

Will install the callback hooks for each state.

Parameters

descriptor

The component descriptor which is to be installed

Definition at line 555 of file registry.F90.

    type(component_descriptor_type), intent(in) :: descriptor
    character(len=*), intent(in), optional :: group_name
 
    if (associated(descriptor%initialisation)) call add_callback(init_callbacks, descriptor%name, descriptor%initialisation)
    if (associated(descriptor%timestep)) then
      if (present(group_name)) then
        call add_callback(timestep_callbacks(get_group_id(group_name)), descriptor%name, descriptor%timestep)
      else
        call log_master_log(log_error, "In the configuration you must provide a group for component "&
             //trim(descriptor%name)//" which has a timestep callback")
      end if
    end if
    if (associated(descriptor%finalisation)) call add_callback(finalisation_callbacks, descriptor%name, descriptor%finalisation)

Here is the call graph for this function:

Here is the caller graph for this function:

load_published_fields()

subroutine registry_mod::load_published_fields ( type(component_descriptor_type), intent(in)  descriptor )

private

Loads the published fields information for an entire component into the registry's definition list.

Parameters

descriptor

The field descriptor to load in

Definition at line 192 of file registry.F90.

    type(component_descriptor_type), intent(in) :: descriptor
 
    integer :: i
    class(*), pointer :: field_generic_description
    type(pointer_wrapper_type), pointer :: wrapper
    class(*), pointer :: genericwrapper
 
    if (associated(descriptor%published_fields) .and. associated(descriptor%field_value_retrieval) .and. &
         associated(descriptor%field_information_retrieval)) then
      do i=1, size(descriptor%published_fields)
        field_generic_description=>descriptor%published_fields(i)
        call c_add_generic(field_information, field_generic_description, .false.)
        allocate(wrapper) ! We allocate our own copy of the descriptor here to ensure the consistency of registry information
        wrapper%ptr => descriptor%field_value_retrieval
        genericwrapper=>wrapper
        call c_put_generic(field_procedure_retrievals, descriptor%published_fields(i), genericwrapper, .false.)
        allocate(wrapper)
        wrapper%ptr => descriptor%field_information_retrieval
        genericwrapper=>wrapper
        call c_put_generic(field_procedure_sizings, descriptor%published_fields(i), genericwrapper, .false.)
      end do
 
      else if (associated(descriptor%published_fields) .or. associated(descriptor%field_value_retrieval) .or. &
         associated(descriptor%field_information_retrieval)) then
        call log_master_log(log_warn, "Component "//trim(descriptor%name)//&
             " has provided incomplete configuration for published fields, therefore ignoring these")
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

order_all_callbacks()

subroutine, public registry_mod::order_all_callbacks

Orders all callbacks in the prospective stages based upon the priorities of each descriptor.

Note that this is an expensive operation as it involves multiple searches of the component list_types so should be called sparingly. When two priorities are equal then the order depends upon which one was registered first.

Definition at line 304 of file registry.F90.

    integer :: i
    type(map_type) :: specific_ts
 
    call rebalance_callbacks(init_callbacks, init_orderings, "initialisation")
    do i=1,size(timestep_callbacks)
      specific_ts=order_grouped_timstep_callbacks(i)
      call rebalance_callbacks(timestep_callbacks(i), specific_ts, "time stepping")
      call c_free(specific_ts)
    end do    
    call rebalance_callbacks(finalisation_callbacks, finalisation_orderings, "finalisation")

Here is the call graph for this function:

Here is the caller graph for this function:

order_grouped_timstep_callbacks()

type(map_type) function registry_mod::order_grouped_timstep_callbacks ( integer, intent(in)  group_id )

private

Definition at line 317 of file registry.F90.

    integer, intent(in) :: group_id
    
    integer :: group_size, i
 
    type(group_descriptor_type) :: descriptor
 
    descriptor=get_group_descriptor_from_id(group_id)
    group_size=descriptor%number_of_members
    do i=1, group_size
      call c_put_integer(order_grouped_timstep_callbacks, trim(descriptor%group_members(i)), i)
    end do    

Here is the call graph for this function:

Here is the caller graph for this function:

read_group_configurations()

subroutine registry_mod::read_group_configurations ( type(hashmap_type), intent(inout)  options_database )

private

Definition at line 469 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
 
    integer :: group_elements, i, j
    class(*), pointer :: generic_to_add
    type(group_descriptor_type) :: group_description
    character(len=STRING_LENGTH) :: group_type
 
    group_elements=options_get_array_size(options_database, "group_names")
    if (group_elements .lt. 1) call log_master_log(log_error, "You must provide some group definitions")
    do i=1, group_elements
      group_description%name=trim(options_get_string(options_database, "group_names", i))
      if (options_has_key(options_database, trim(group_description%name)//"_group_type")) then
        group_type=trim(options_get_string(options_database, trim(group_description%name)//"_group_type"))
        if (trim(group_type) .eq. "entire") then
          group_description%type=0
        else if (trim(group_type) .eq. "column") then
          group_description%type=1
        else if (trim(group_type) .eq. "slice") then
          group_description%type=2
        else
          call log_master_log(log_error, "Group type "//trim(group_type)//" for group "&
               //trim(group_description%name)//" not understood")
        end if
      else
        call log_master_log(log_error, "No group type for group "//trim(group_description%name))
      end if
      group_description%id=i
      if (.not. options_has_key(options_database, trim(group_description%name)//"_group_contents")) then
        call log_master_log(log_error, "No component contents specified for group "//trim(group_description%name))
      end if
      group_description%number_of_members=options_get_array_size(options_database, &
           trim(group_description%name)//"_group_contents")    
      if (group_description%number_of_members == 0 .or. .not. options_has_key(options_database, &
           trim(group_description%name)//"_group_contentsa_size")) then
        if (options_has_key(options_database, trim(group_description%name)//"_group_contents")) then
          group_description%number_of_members=1
          group_description%group_members(1)=trim(options_get_string(options_database, &
                 trim(group_description%name)//"_group_contents"))
          call c_put_string(component_groups, trim(group_description%group_members(1)), group_description%name)
        else
          call log_master_log(log_error, "No contents specified for group "//trim(group_description%name))
        end if
      else
        do j=1, group_description%number_of_members
          group_description%group_members(j)=trim(options_get_string(options_database, &
               trim(group_description%name)//"_group_contents", j))
          call c_put_string(component_groups, trim(group_description%group_members(j)), group_description%name)
        end do
      end if
      allocate(generic_to_add, source=group_description)
      call c_put_generic(group_descriptors, group_description%name, generic_to_add, .false.)
    end do    

Here is the caller graph for this function:

read_initialisation_and_finalisation_orders()

subroutine registry_mod::read_initialisation_and_finalisation_orders ( type(hashmap_type), intent(inout)  options_database )

private

Definition at line 447 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
 
    call read_specific_orders(options_database, "initialisation_stage_ordering", init_orderings)
    call read_specific_orders(options_database, "finalisation_stage_ordering", finalisation_orderings)

Here is the call graph for this function:

Here is the caller graph for this function:

read_specific_orders()

subroutine registry_mod::read_specific_orders ( type(hashmap_type), intent(inout)  options_database, character(len=*)  key, type(map_type), intent(inout)  data_structure  )

private

Definition at line 454 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
    type(map_type), intent(inout) :: data_structure
    character(len=*) :: key
 
    integer :: number_of_elements, i
    character(len=STRING_LENGTH) :: component_name
 
    number_of_elements=options_get_array_size(options_database, key)
    do i=1, number_of_elements
      component_name=options_get_string(options_database, key, i)
      call c_put_integer(data_structure, trim(component_name), i)
    end do

Here is the caller graph for this function:

rebalance_callbacks()

subroutine registry_mod::rebalance_callbacks ( type(map_type), intent(inout)  callbacks, type(map_type), intent(inout)  priorities, character(len=*), intent(in)  stage_name  )

private

Definition at line 571 of file registry.F90.

    type(map_type), intent(inout) :: callbacks, priorities
    character(len=*), intent(in) :: stage_name
 
    type(map_type) :: ordered_callbacks
    integer :: i, entries_in_list, current_item
    class(*), pointer :: generic
    
    entries_in_list=c_size(callbacks)
    do i=1, entries_in_list
      current_item=get_highest_callback_priority(callbacks, priorities)
      if (current_item .ge. 1) then
        generic=>c_generic_at(callbacks, current_item)
        call c_put_generic(ordered_callbacks, c_key_at(callbacks, current_item), generic, .false.)
        call c_remove(callbacks, c_key_at(callbacks, current_item))
      end if
    end do
 
    entries_in_list=c_size(callbacks)
    do i=1, entries_in_list
      generic=>c_generic_at(callbacks, i)
      call c_put_generic(ordered_callbacks, c_key_at(callbacks, i), generic, .false.)
      call log_master_log(log_warn, "Run order callback for component "//trim(c_key_at(callbacks, i))//&
           " at stage "//stage_name//" not specified")
    end do
    callbacks=ordered_callbacks

Here is the call graph for this function:

Here is the caller graph for this function:

register_component()

subroutine, public registry_mod::register_component	(	type(hashmap_type), intent(inout)	options_database,
		type(component_descriptor_type), intent(in)	descriptor
	)

Will register a component and install the nescesary callback hooks.

Parameters

descriptor

The component descriptor and a separate copy of this it stored as reference

Definition at line 99 of file registry.F90.

    type(hashmap_type), intent(inout) :: options_database
    type(component_descriptor_type), intent(in) :: descriptor
 
    type(component_descriptor_type), pointer :: registry_descriptor
    class(*), pointer :: description_data
    character(len=STRING_LENGTH) :: group_name
    logical :: component_enabled
 
    allocate(registry_descriptor, source=descriptor) ! Make copy of the descriptor (which registry might modify)
 
    if (options_has_key(options_database, trim(descriptor%name)//"_enabled")) then
      component_enabled=options_get_logical(options_database, trim(descriptor%name)//"_enabled")
    else
      component_enabled=.false.
      call log_master_log(log_warn, "No enabled configuration for component "//trim(descriptor%name)//" therefore disabling this")
    end if
 
    if (component_enabled) then
      if (c_contains(component_groups, trim(descriptor%name))) then
        group_name=c_get_string(component_groups, trim(descriptor%name))
        call load_callback_hooks(registry_descriptor, group_name)
      else
        call load_callback_hooks(registry_descriptor)
      end if
      call load_published_fields(descriptor)
    end if    
 
    description_data => registry_descriptor
    call c_put_generic(component_descriptions, descriptor%name, description_data, .false.)

Here is the call graph for this function:

Here is the caller graph for this function:

remove_descriptor()

subroutine registry_mod::remove_descriptor ( type(component_descriptor_type), intent(inout)  descriptor )

private

Will remove a specific descriptor from the registry table and uninstall the corresponding callback hooks for each state.

Parameters

descriptor

The component descriptor which is to be removed

Definition at line 527 of file registry.F90.

    type(component_descriptor_type), intent(inout) :: descriptor
 
    character(len=STRING_LENGTH) :: group_name
 
    if (c_contains(component_groups, trim(descriptor%name))) then
      group_name=c_get_string(component_groups, trim(descriptor%name))
      call unload_callback_hooks(descriptor, group_name)
    else
      call unload_callback_hooks(descriptor)
    end if
    call c_remove(component_descriptions, descriptor%name)

Here is the call graph for this function:

Here is the caller graph for this function:

unload_callback_hooks()

subroutine registry_mod::unload_callback_hooks ( type(component_descriptor_type), intent(in)  descriptor, character(len=*), intent(in), optional  group_name  )

private

Will unload the callback hooks that have been installed for each state.

Parameters

descriptor

The component descriptor which is to be unloaded

Definition at line 543 of file registry.F90.

    type(component_descriptor_type), intent(in) :: descriptor
    character(len=*), intent(in), optional :: group_name
 
    if (associated(descriptor%initialisation)) call c_remove(init_callbacks, descriptor%name)
    if (associated(descriptor%timestep) .and. present(group_name)) &
         call c_remove(timestep_callbacks(get_group_id(group_name)), descriptor%name)    
    if (associated(descriptor%finalisation)) call c_remove(finalisation_callbacks, descriptor%name)

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

component_descriptions

type(map_type), save registry_mod::component_descriptions

private

Copies of component descriptors.

Definition at line 47 of file registry.F90.

component_groups

type(map_type), save registry_mod::component_groups

private

Definition at line 47 of file registry.F90.

enabled_component_input_keys

character(len=string_length), dimension(:), allocatable registry_mod::enabled_component_input_keys

private

Temporary read array of component enable names.

Definition at line 28 of file registry.F90.

  character(len=STRING_LENGTH), dimension(:), allocatable :: enabled_component_input_keys,& !< Temporary read array of component enable names
       group_locations

field_information

type(list_type), save registry_mod::field_information

private

Definition at line 25 of file registry.F90.

  type(list_type), save :: field_information

field_procedure_retrievals

type(hashmap_type), save registry_mod::field_procedure_retrievals

private

Definition at line 52 of file registry.F90.

  type(hashmap_type), save :: field_procedure_retrievals, field_procedure_sizings

field_procedure_sizings

type(hashmap_type), save registry_mod::field_procedure_sizings

private

Definition at line 52 of file registry.F90.

finalisation_callbacks

type(map_type), save registry_mod::finalisation_callbacks

private

Callback hooks for the finalisation stage.

Definition at line 47 of file registry.F90.

finalisation_orderings

type(map_type), save registry_mod::finalisation_orderings

private

Definition at line 47 of file registry.F90.

group_descriptors

type(map_type), save registry_mod::group_descriptors

private

Group descriptors for each group, name->descriptor.

Definition at line 47 of file registry.F90.

group_locations

character(len=string_length), dimension(:), allocatable registry_mod::group_locations

private

Provides an id to each group.

Definition at line 28 of file registry.F90.

group_type_column

integer, parameter, public registry_mod::group_type_column =1

Execute the callbacks in this group for each column per timestep.

Definition at line 22 of file registry.F90.

group_type_whole

integer, parameter, public registry_mod::group_type_whole =0

Execute the callbacks in this group once per timestep.

Definition at line 22 of file registry.F90.

  integer, parameter :: GROUP_TYPE_WHOLE=0, & !< Execute the callbacks in this group once per timestep
       group_type_column=1 

group_types

integer, dimension(:), allocatable registry_mod::group_types

private

Group types.

Definition at line 27 of file registry.F90.

  integer, dimension(:), allocatable :: group_types

init_callbacks

type(map_type), save registry_mod::init_callbacks

private

Callback hooks for the initialisation stage.

Definition at line 47 of file registry.F90.

  type(map_type), save :: init_callbacks,&     !< Callback hooks for the initialisation stage       
                    finalisation_callbacks,&   !< Callback hooks for the finalisation stage
                    component_descriptions,&   !< Copies of component descriptors
                    group_descriptors,&        !< Group descriptors for each group, name->descriptor     
                    component_groups, init_orderings, finalisation_orderings

init_orderings

type(map_type), save registry_mod::init_orderings

private

Definition at line 47 of file registry.F90.

timestep_callbacks

type(map_type), dimension(:), allocatable registry_mod::timestep_callbacks

private

Callback hooks for the timestep stage.

Definition at line 54 of file registry.F90.

  type(map_type), dimension(:), allocatable :: timestep_callbacks