writer_field_manager_mod Module Reference

The writer field manager will manage aspects of the fields being provided to the writer federator. There are two major aspects to this, firstly extraction of fields from the data sent directly from MONC and then passed on if these fields are needed. Secondly, this will queue up the data to ensure that it is sent to the writer federator in strict order and that only one piece of a fields data is in the writer federator at any one time. More...

Data Types
type	field_ordering_type
type	field_ordering_value_type
interface	provide_field_to_writer_federator

Functions/Subroutines
subroutine, public	initialise_writer_field_manager (io_configuration, continuation_run)
	Initialises the writer field manager. More...
subroutine, public	finalise_writer_field_manager ()
	Finalises the writer field manager. More...
logical function, public	is_write_field_manager_up_to_date (timestep)
	Determines whether the state of the write field manager is up to date with respect to the timestep that has been provided, checks each entry to see if it is missing data or not. More...
subroutine, public	provide_monc_data_to_writer_federator (io_configuration, source, data_id, data_dump)
	Data communicated from MONC is provided to this write federator and then included if the configuration has selected to use that MONC field (as opposed to a field produced by the diagnostics federator) More...
type(data_values_type) function	get_value_from_monc_data (io_configuration, source, data_id, data_dump, field_name, field_namespace)
	Retrieves a value from the communicated MONC data. If this was an integer then converts to a real. More...
subroutine	get_type_of_field (fields, field_name, field_namespace, field_type, data_type)
	Retrieves the data type of a field or 0 if the field was not found. More...
subroutine	provide_field_to_writer_federator_rvalues_src (io_configuration, field_name, field_namespace, field_values, timestep, time, frequency, source)
subroutine	provide_field_to_writer_federator_rvalues_nosrc (io_configuration, field_name, field_namespace, field_values, timestep, time, frequency)
subroutine	provide_field_to_writer_federator_nosrc (io_configuration, field_name, field_namespace, field_values, timestep, time, frequency)
	Provides a field to the write federator with no source (a none collective diagnostic) More...
subroutine	provide_field_to_writer_federator_src (io_configuration, field_name, field_namespace, field_values, timestep, time, frequency, source, terminated_case)
	Provides a field to the write federator (a collective diagnostic or prognostic) More...
subroutine	process_queued_items (io_configuration, field_ordering)
	Processes queued up items for a specific field's ordering. This will send any available fields to the write federator with a guaranteed ordering and clean up the memory associated with them. More...
type(field_ordering_value_type) function, pointer	get_field_ordering_value_at_timestep (collection, timestep)
	Retrieves a specific field ordering value at the corresponding timestep or null if none is found. More...
type(field_ordering_value_type) function, pointer	generate_value_container (field_name, field_namespace, field_values, timestep, time, frequency, source)
	Generates the field value container which is then filled in with appropriate values and added into the overall field ordering data structure. More...
type(field_ordering_type) function, pointer	get_or_add_field_ordering (field_name, field_namespace, frequency, source)
	Retrieves or adds ordering for a specific field (and MONC source) More...
type(field_ordering_type) function, pointer	get_field_ordering (field_name, do_lock)
	Retrieves a field ordering based upon the name or null if none can be found. More...
integer(kind=8) function	prepare_to_serialise_field_manager_state ()
	Prepares to serialise the field manager state, both determines storage needed and also issues any locks. More...
subroutine	serialise_field_manager_state (byte_data)
	Serialises the current field manager, releases any locks issued during preparation. More...
subroutine	unserialise_field_manager_state (byte_data)
	Unserialses from some byte data into the state. More...
integer(kind=8) function	prepare_to_serialise_specific_field_ordering (specific_field_ordering)
	Prepares to serialise a specific field ordering, both determines storage size and issues locks. More...
subroutine	serialise_specific_field_ordering (specific_field_ordering, byte_data, current_data_point)
	Serialises a specific fields ordering and releases any locks issued during preparation. More...
type(field_ordering_type) function, pointer	unserialise_specific_field_ordering (byte_data)
	Unserialises some field ordering. More...
integer(kind=8) function	prepare_to_serialise_field_ordering_value (specific_field_value)
	Prepares to serialise a specific field ordering value, determines both the storage size and issues locks. More...
subroutine	serialise_field_ordering_value (specific_field_value, byte_data, current_data_point)
	Serialises a field ordering value and releases any issued locks. More...
type(field_ordering_value_type) function, pointer	unserialise_field_ordering_value (byte_data)
	Unseralises some field ordering from its byte representation. More...

Variables
integer, volatile	field_lock
type(hashmap_type), volatile	field_orderings

Detailed Description

The writer field manager will manage aspects of the fields being provided to the writer federator. There are two major aspects to this, firstly extraction of fields from the data sent directly from MONC and then passed on if these fields are needed. Secondly, this will queue up the data to ensure that it is sent to the writer federator in strict order and that only one piece of a fields data is in the writer federator at any one time.

Function/Subroutine Documentation

finalise_writer_field_manager()

subroutine, public writer_field_manager_mod::finalise_writer_field_manager

(

)

Finalises the writer field manager.

Definition at line 72 of file writer_field_manager.F90.

    call check_thread_status(forthread_rwlock_destroy(field_lock))

Here is the call graph for this function:

Here is the caller graph for this function:

generate_value_container()

type(field_ordering_value_type) function, pointer writer_field_manager_mod::generate_value_container ( character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, type(data_values_type), intent(in)  field_values, integer, intent(in)  timestep, real(kind=default_precision), intent(in)  time, integer, intent(in)  frequency, integer, intent(in)  source  )

private

Generates the field value container which is then filled in with appropriate values and added into the overall field ordering data structure.

Parameters

field_name	The field name
field_values	The fields values
timestep	The corresponding MONC model timestep
time	The corresponding MONC model time
frequency	Configured sampling frequency
source	MONC source pid

Returns

A value container which can be added into the field ordering data structure

Definition at line 376 of file writer_field_manager.F90.

    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: timestep, frequency, source
    type(data_values_type), intent(in) :: field_values
    real(kind=DEFAULT_PRECISION), intent(in) :: time
    type(field_ordering_value_type), pointer :: generate_value_container

    allocate(generate_value_container)
    generate_value_container%field_name=field_name
    generate_value_container%field_namespace=field_namespace
    generate_value_container%timestep=timestep
    generate_value_container%frequency=frequency
    generate_value_container%time=time
    generate_value_container%source=source
    allocate(generate_value_container%field_values, source=field_values)

Here is the caller graph for this function:

get_field_ordering()

type(field_ordering_type) function, pointer writer_field_manager_mod::get_field_ordering ( character(len=*), intent(in)  field_name, logical, intent(in)  do_lock  )

private

Retrieves a field ordering based upon the name or null if none can be found.

Parameters

field_name	The name of the field to look up
do_lock	Whether to issue a read lock or not

Returns

The corresponding field ordering data structure or null if none is found

Definition at line 432 of file writer_field_manager.F90.

    character(len=*), intent(in) :: field_name
    logical, intent(in) :: do_lock
    type(field_ordering_type), pointer :: get_field_ordering

    class(*), pointer :: generic

    if (do_lock) call check_thread_status(forthread_rwlock_rdlock(field_lock))
    generic=>c_get_generic(field_orderings, field_name)
    if (do_lock) call check_thread_status(forthread_rwlock_unlock(field_lock))
    if (associated(generic)) then
      select type(generic)
        type is (field_ordering_type)
          get_field_ordering=>generic
      end select      
    else
      get_field_ordering=>null()
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

get_field_ordering_value_at_timestep()

type(field_ordering_value_type) function, pointer writer_field_manager_mod::get_field_ordering_value_at_timestep ( type(hashmap_type), intent(inout)  collection, integer, intent(in)  timestep  )

private

Retrieves a specific field ordering value at the corresponding timestep or null if none is found.

Parameters

collection	The map of timesteps to field ordering values that we are looking up
timestep	The timestep to look up

Returns

The corresponding field ordering or null if none is found

Definition at line 349 of file writer_field_manager.F90.

    type(hashmap_type), intent(inout) :: collection
    integer, intent(in) :: timestep
    type(field_ordering_value_type), pointer :: get_field_ordering_value_at_timestep

    class(*), pointer :: generic

    generic=>c_get_generic(collection, conv_to_string(timestep))
    if (associated(generic)) then
      select type(generic)
        type is (field_ordering_value_type)
          get_field_ordering_value_at_timestep=>generic
      end select      
    else
      get_field_ordering_value_at_timestep=>null()
    end if    

Here is the caller graph for this function:

get_or_add_field_ordering()

type(field_ordering_type) function, pointer writer_field_manager_mod::get_or_add_field_ordering ( character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, integer, intent(in)  frequency, integer, intent(in)  source  )

private

Retrieves or adds ordering for a specific field (and MONC source)

Parameters

field_name	The field name
frequency	The sampling frequency of this field
source	MONC source PID

Returns

Either the existing or a newly created field ordering

Definition at line 398 of file writer_field_manager.F90.

    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: frequency, source
    type(field_ordering_type), pointer :: get_or_add_field_ordering

    class(*), pointer :: generic
    character(len=STRING_LENGTH) :: entry_key

    if (source .gt. -1) then
      entry_key=trim(field_name)//"#"//trim(field_namespace)//"#"//trim(conv_to_string(source))
    else
      entry_key=field_name
    end if

    get_or_add_field_ordering=>get_field_ordering(entry_key, .true.)
    if (.not. associated(get_or_add_field_ordering)) then
      call check_thread_status(forthread_rwlock_wrlock(field_lock))
      get_or_add_field_ordering=>get_field_ordering(entry_key, .false.)
      if (.not. associated(get_or_add_field_ordering)) then
        allocate(get_or_add_field_ordering)
        get_or_add_field_ordering%last_timestep_access=0
        get_or_add_field_ordering%frequency=frequency
        call check_thread_status(forthread_mutex_init(get_or_add_field_ordering%access_mutex, -1))
        generic=>get_or_add_field_ordering
        call c_put_generic(field_orderings, entry_key, generic, .false.)
      end if
      call check_thread_status(forthread_rwlock_unlock(field_lock))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

get_type_of_field()

subroutine writer_field_manager_mod::get_type_of_field ( type(io_configuration_field_type), dimension(:), intent(in)  fields, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, integer, intent(out)  field_type, integer, intent(out)  data_type  )

private

Retrieves the data type of a field or 0 if the field was not found.

Parameters

fields	Array of fields to search
field_name	The name of the field to locate

Returns

The data type of this field or 0 if the field was not found

Definition at line 204 of file writer_field_manager.F90.

    type(io_configuration_field_type), dimension(:), intent(in) :: fields
    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(out) :: field_type, data_type

    integer :: i

    do i=1, size(fields)
      if (fields(i)%name .eq. field_name .and. fields(i)%namespace .eq. field_namespace) then
        data_type=fields(i)%data_type
        field_type=fields(i)%field_type
        return
      end if      
    end do
    data_type=0
    field_type=0

Here is the caller graph for this function:

get_value_from_monc_data()

type(data_values_type) function writer_field_manager_mod::get_value_from_monc_data ( type(io_configuration_type), intent(inout)  io_configuration, integer, intent(in)  source, integer, intent(in)  data_id, character, dimension(:), intent(in), allocatable  data_dump, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace  )

private

Retrieves a value from the communicated MONC data. If this was an integer then converts to a real.

Parameters

io_configuration	Configuration of the IO server
source	The source PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	The data we have received from MONC
field_name	The field to retrieve

Returns

Data value wrapper containing the values and meta-data

Definition at line 159 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    integer, intent(in) :: source, data_id
    character, dimension(:), allocatable, intent(in) :: data_dump
    character(len=*), intent(in) :: field_name, field_namespace
    type(data_values_type) :: get_value_from_monc_data
    type(map_type) :: retrieved_map
    type(iterator_type) :: iterator
    type(mapentry_type) :: map_entry

    integer :: field_data_type, field_field_type, i
    integer, dimension(:), allocatable :: int_values

    call get_type_of_field(io_configuration%data_definitions(data_id)%fields, field_name, field_namespace, &
         field_field_type, field_data_type)
    if (field_data_type == 0) then
      call log_log(log_error, "No data type for field '"//trim(field_name)//"'")
    end if

    if (field_data_type == double_data_type) then
      get_value_from_monc_data%values=get_array_double_from_monc(io_configuration, source, data_id, data_dump, field_name)
      get_value_from_monc_data%data_type=double_data_type
    else if (field_data_type == integer_data_type) then
      get_value_from_monc_data%data_type=double_data_type
      int_values=get_array_integer_from_monc(io_configuration, source, data_id, data_dump, field_name)
      allocate(get_value_from_monc_data%values(size(int_values)))
      do i=1, size(int_values)
        get_value_from_monc_data%values(i)=conv_to_real(int_values(i))
      end do
      deallocate(int_values)
    else if (field_data_type == string_data_type) then
      get_value_from_monc_data%data_type=string_data_type
      if (field_field_type == scalar_field_type) then
        allocate(get_value_from_monc_data%string_values(1))
        get_value_from_monc_data%string_values(1)=get_string_from_monc(io_configuration, source, data_id, data_dump, field_name)
      else if (field_field_type == map_field_type) then        
        get_value_from_monc_data%map_values=get_map_from_monc(io_configuration, source, data_id, data_dump, field_name)        
      end if
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

initialise_writer_field_manager()

subroutine, public writer_field_manager_mod::initialise_writer_field_manager	(	type(io_configuration_type), intent(inout)	io_configuration,
		logical, intent(in)	continuation_run
	)

Initialises the writer field manager.

Parameters

io_configuration	Configuration of the IO server
continuation_run	Whether or not this is a continuation run

Definition at line 59 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    logical, intent(in) :: continuation_run

    call check_thread_status(forthread_rwlock_init(field_lock, -1))
    call set_serialise_write_field_manager_state(serialise_field_manager_state, prepare_to_serialise_field_manager_state, &
         is_write_field_manager_up_to_date)
    if (continuation_run) then
      call reactivate_writer_field_manager_state(io_configuration, unserialise_field_manager_state)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

is_write_field_manager_up_to_date()

logical function, public writer_field_manager_mod::is_write_field_manager_up_to_date

(

integer, intent(in)

timestep

)

Determines whether the state of the write field manager is up to date with respect to the timestep that has been provided, checks each entry to see if it is missing data or not.

Parameters

timestep

The timestep to check against

Returns

Whether the write field manager is up to date or not

Definition at line 80 of file writer_field_manager.F90.

    integer, intent(in) :: timestep

    type(iterator_type) :: iterator
    type(mapentry_type) :: mapentry
    class(*), pointer :: generic

    is_write_field_manager_up_to_date=.true.
    call check_thread_status(forthread_rwlock_rdlock(field_lock))
    iterator=c_get_iterator(field_orderings)
    do while (c_has_next(iterator))
      mapentry=c_next_mapentry(iterator)
      generic=>c_get_generic(mapentry)
      select type(generic)
        type is (field_ordering_type)
          if (generic%last_timestep_access .lt. timestep) then
            is_write_field_manager_up_to_date=.false.
            exit
          end if
      end select      
    end do    
    call check_thread_status(forthread_rwlock_unlock(field_lock))

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_field_manager_state()

integer(kind=8) function writer_field_manager_mod::prepare_to_serialise_field_manager_state ( )

private

Prepares to serialise the field manager state, both determines storage needed and also issues any locks.

Returns

The number of bytes needed to store the serialised state

Definition at line 454 of file writer_field_manager.F90.

    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    class(*), pointer :: generic

    call check_thread_status(forthread_rwlock_rdlock(field_lock))
    prepare_to_serialise_field_manager_state=kind(prepare_to_serialise_field_manager_state)

    iterator=c_get_iterator(field_orderings)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      generic=>c_get_generic(map_entry)
      if (associated(generic)) then
        select type(generic)
        type is (field_ordering_type)
          prepare_to_serialise_field_manager_state=prepare_to_serialise_field_manager_state+&
               prepare_to_serialise_specific_field_ordering(generic)+&
               (kind(prepare_to_serialise_field_manager_state)*2)+len(trim(map_entry%key))
        end select
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_field_ordering_value()

integer(kind=8) function writer_field_manager_mod::prepare_to_serialise_field_ordering_value ( type(field_ordering_value_type), intent(inout)  specific_field_value )

private

Prepares to serialise a specific field ordering value, determines both the storage size and issues locks.

Parameters

specific_field_value

The specific value to prepare for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 645 of file writer_field_manager.F90.

    type(field_ordering_value_type), intent(inout) :: specific_field_value

    prepare_to_serialise_field_ordering_value=prepare_to_serialise_data_values_type(specific_field_value%field_values)
    prepare_to_serialise_field_ordering_value=prepare_to_serialise_field_ordering_value+&
         (kind(specific_field_value%timestep) * 6) + len(trim(specific_field_value%field_name)) + &
         len(trim(specific_field_value%field_namespace)) + kind(specific_field_value%time)

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_specific_field_ordering()

integer(kind=8) function writer_field_manager_mod::prepare_to_serialise_specific_field_ordering ( type(field_ordering_type), intent(inout)  specific_field_ordering )

private

Prepares to serialise a specific field ordering, both determines storage size and issues locks.

Parameters

specific_field_ordering

The field ordering to prepare for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 542 of file writer_field_manager.F90.

    type(field_ordering_type), intent(inout) :: specific_field_ordering

    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    class(*), pointer :: generic

    call check_thread_status(forthread_mutex_lock(specific_field_ordering%access_mutex))

    prepare_to_serialise_specific_field_ordering=kind(prepare_to_serialise_specific_field_ordering) * 3

    iterator=c_get_iterator(specific_field_ordering%timestep_to_value)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      generic=>c_get_generic(map_entry)
      if (associated(generic)) then
        select type(generic)
        type is (field_ordering_value_type)
          prepare_to_serialise_specific_field_ordering=prepare_to_serialise_specific_field_ordering+&
               prepare_to_serialise_field_ordering_value(generic)+(kind(prepare_to_serialise_specific_field_ordering)*2)+&
               len(trim(map_entry%key))
        end select
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

process_queued_items()

subroutine writer_field_manager_mod::process_queued_items ( type(io_configuration_type), intent(inout)  io_configuration, type(field_ordering_type), intent(inout)  field_ordering  )

private

Processes queued up items for a specific field's ordering. This will send any available fields to the write federator with a guaranteed ordering and clean up the memory associated with them.

Parameters

io_configuration	The IO server configuration
field_ordering	The field ordering status associated with this field

Definition at line 316 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    type(field_ordering_type), intent(inout) :: field_ordering

    integer :: next_timestep
    type(field_ordering_value_type), pointer :: field_ordering_value_at_timestep

    do while (.not. c_is_empty(field_ordering%timestep_to_value))
      next_timestep=field_ordering%last_timestep_access + field_ordering%frequency
      if (c_contains(field_ordering%timestep_to_value, conv_to_string(next_timestep))) then
        field_ordering_value_at_timestep=>get_field_ordering_value_at_timestep(field_ordering%timestep_to_value, next_timestep)
        call c_remove(field_ordering%timestep_to_value, conv_to_string(next_timestep))
        field_ordering%last_timestep_access=next_timestep
        call provide_ordered_field_to_writer_federator(io_configuration, field_ordering_value_at_timestep%field_name, &
             field_ordering_value_at_timestep%field_namespace, field_ordering_value_at_timestep%field_values, &
             field_ordering_value_at_timestep%timestep, field_ordering_value_at_timestep%time, &
             field_ordering_value_at_timestep%source)
        if (allocated(field_ordering_value_at_timestep%field_values)) then
          if (allocated(field_ordering_value_at_timestep%field_values%values)) &
               deallocate(field_ordering_value_at_timestep%field_values%values)
          deallocate(field_ordering_value_at_timestep%field_values)
        end if
        deallocate(field_ordering_value_at_timestep)
      else
        exit
      end if
    end do

Here is the call graph for this function:

Here is the caller graph for this function:

provide_field_to_writer_federator_nosrc()

subroutine writer_field_manager_mod::provide_field_to_writer_federator_nosrc ( type(io_configuration_type), intent(inout)  io_configuration, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, type(data_values_type), intent(inout)  field_values, integer, intent(in)  timestep, real(kind=default_precision), intent(in)  time, integer, intent(in)  frequency  )

private

Provides a field to the write federator with no source (a none collective diagnostic)

Parameters

io_configuration	The IO server configuration
field_name	The field name
field_values	The fields values
timestep	The corresponding model timestep
time	Corresponding MONC model time
frequency	Configured sampling frequency

Definition at line 259 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: timestep, frequency
    type(data_values_type), intent(inout) :: field_values
    real(kind=DEFAULT_PRECISION), intent(in) :: time

    call provide_field_to_writer_federator_src(io_configuration, field_name, field_namespace, &
         field_values, timestep, time, frequency, -1)

Here is the call graph for this function:

provide_field_to_writer_federator_rvalues_nosrc()

subroutine writer_field_manager_mod::provide_field_to_writer_federator_rvalues_nosrc ( type(io_configuration_type), intent(inout)  io_configuration, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, real(kind=default_precision), dimension(:), intent(in)  field_values, integer, intent(in)  timestep, real(kind=default_precision), intent(in)  time, integer, intent(in)  frequency  )

private

Definition at line 240 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: timestep, frequency
    real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: field_values
    real(kind=DEFAULT_PRECISION), intent(in) :: time

    call provide_field_to_writer_federator_rvalues_src(io_configuration, field_name, field_namespace, &
         field_values, timestep, time, frequency, -1)

Here is the call graph for this function:

provide_field_to_writer_federator_rvalues_src()

subroutine writer_field_manager_mod::provide_field_to_writer_federator_rvalues_src ( type(io_configuration_type), intent(inout)  io_configuration, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, real(kind=default_precision), dimension(:), intent(in)  field_values, integer, intent(in)  timestep, real(kind=default_precision), intent(in)  time, integer, intent(in)  frequency, integer, intent(in)  source  )

private

Definition at line 223 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: timestep, frequency, source
    real(kind=DEFAULT_PRECISION), dimension(:), intent(in) :: field_values
    real(kind=DEFAULT_PRECISION), intent(in) :: time

    type(data_values_type) :: packaged_data
    
    allocate(packaged_data%values(size(field_values)))
    packaged_data%values=field_values
    packaged_data%data_type=double_data_type
    call provide_field_to_writer_federator_src(io_configuration, field_name, field_namespace, packaged_data, &
         timestep, time, frequency, source)

Here is the call graph for this function:

Here is the caller graph for this function:

provide_field_to_writer_federator_src()

subroutine writer_field_manager_mod::provide_field_to_writer_federator_src ( type(io_configuration_type), intent(inout)  io_configuration, character(len=*), intent(in)  field_name, character(len=*), intent(in)  field_namespace, type(data_values_type), intent(inout)  field_values, integer, intent(in)  timestep, real(kind=default_precision), intent(in)  time, integer, intent(in)  frequency, integer, intent(in)  source, logical, intent(in), optional  terminated_case  )

private

Provides a field to the write federator (a collective diagnostic or prognostic)

Parameters

io_configuration	The IO server configuration
field_name	The field name
field_values	The fields values
timestep	The corresponding model timestep
time	Corresponding MONC model time
frequency	Configured sampling frequency
source	The MONC source ID

Definition at line 279 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    character(len=*), intent(in) :: field_name, field_namespace
    integer, intent(in) :: timestep, frequency, source
    type(data_values_type), intent(inout) :: field_values
    real(kind=DEFAULT_PRECISION), intent(in) :: time
    logical, intent(in), optional :: terminated_case

    type(field_ordering_type), pointer :: field_ordering
    class(*), pointer :: generic
    logical :: this_is_termination

    if (present(terminated_case)) then
      this_is_termination=terminated_case
    else
      this_is_termination=.false.
    end if

    field_ordering=>get_or_add_field_ordering(field_name, field_namespace, frequency, source)
    call check_thread_status(forthread_mutex_lock(field_ordering%access_mutex))
    if (timestep == field_ordering%last_timestep_access + frequency .or. this_is_termination) then
      if (.not. this_is_termination) field_ordering%last_timestep_access=timestep
      call provide_ordered_field_to_writer_federator(io_configuration, field_name, field_namespace, &
           field_values, timestep, time, source)
      if (allocated(field_values%values)) deallocate(field_values%values)      
    else
      generic=>generate_value_container(field_name, field_namespace, field_values, timestep, time, frequency, source)
      call c_put_generic(field_ordering%timestep_to_value, conv_to_string(timestep), generic, .false.)
    end if
    call process_queued_items(io_configuration, field_ordering)
    call check_thread_status(forthread_mutex_unlock(field_ordering%access_mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

provide_monc_data_to_writer_federator()

subroutine, public writer_field_manager_mod::provide_monc_data_to_writer_federator	(	type(io_configuration_type), intent(inout)	io_configuration,
		integer, intent(in)	source,
		integer, intent(in)	data_id,
		character, dimension(:), intent(in), allocatable	data_dump
	)

Data communicated from MONC is provided to this write federator and then included if the configuration has selected to use that MONC field (as opposed to a field produced by the diagnostics federator)

Parameters

io_configuration	Configuration of the IO server
source	The source PID of the MONC process
data_id	The ID of the data definition that is represented by the dump
data_dump	The data we have received from MONC

Definition at line 110 of file writer_field_manager.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    integer, intent(in) :: source, data_id
    character, dimension(:), allocatable, intent(in) :: data_dump

    integer :: i, num_fields, timestep
    character(len=STRING_LENGTH) :: field_name, field_namespace
    real(kind=DEFAULT_PRECISION) :: time
    type(data_values_type) :: monc_value
    logical :: terminated_case

    if (is_field_present(io_configuration, source, data_id, "timestep") .and. &
         is_field_present(io_configuration, source, data_id, "time")) then
      timestep=get_scalar_integer_from_monc(io_configuration, source, data_id, data_dump, "timestep")
      time=get_scalar_real_from_monc(io_configuration, source, data_id, data_dump, "time")

      if (is_field_present(io_configuration, source, data_id, "terminated")) then
        terminated_case=get_scalar_logical_from_monc(io_configuration, source, data_id, data_dump, "terminated") .and. &
             io_configuration%data_definitions(data_id)%send_on_terminate
      else
        terminated_case=.false.
      end if

      num_fields=io_configuration%data_definitions(data_id)%number_of_data_fields

      do i=1, num_fields
        field_name=io_configuration%data_definitions(data_id)%fields(i)%name
        field_namespace=io_configuration%data_definitions(data_id)%fields(i)%namespace
        if (is_field_present(io_configuration, source, data_id, field_name) .and. &
             (is_field_used_by_writer_federator(field_name, field_namespace) .or. is_field_split_on_q(field_name))) then
          monc_value=get_value_from_monc_data(io_configuration, source, data_id, data_dump, field_name, field_namespace)
          call provide_field_to_writer_federator_src(io_configuration, field_name, field_namespace, monc_value, timestep, time, &
               io_configuration%data_definitions(data_id)%frequency, source, terminated_case)
          
          !deallocate(monc_value)
        end if
      end do
    else
      call log_log(log_warn, "Can not run pass MONC fields to writer federator without a time and timestep")
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_field_manager_state()

subroutine writer_field_manager_mod::serialise_field_manager_state ( character, dimension(:), intent(inout), allocatable  byte_data )

private

Serialises the current field manager, releases any locks issued during preparation.

Parameters

byte_data

Packaged field manager serialised state.

Definition at line 479 of file writer_field_manager.F90.

    character, dimension(:), allocatable, intent(inout) :: byte_data

    integer :: current_data_point, prev_pt
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    class(*), pointer :: generic
 
    current_data_point=1
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(field_orderings))

    iterator=c_get_iterator(field_orderings)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      generic=>c_get_generic(map_entry)
      if (associated(generic)) then
        select type(generic)
        type is (field_ordering_type)
          current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(map_entry%key)))
          byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1) = transfer(trim(map_entry%key), &
               byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1))
          current_data_point=current_data_point+len(trim(map_entry%key))

          prev_pt=current_data_point
          current_data_point=current_data_point+kind(current_data_point)
          call serialise_specific_field_ordering(generic, byte_data, current_data_point)          
          prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-kind(current_data_point))-prev_pt)
        end select
      end if
    end do    
    
    call check_thread_status(forthread_rwlock_unlock(field_lock))

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_field_ordering_value()

subroutine writer_field_manager_mod::serialise_field_ordering_value ( type(field_ordering_value_type), intent(inout)  specific_field_value, character, dimension(:), intent(inout), allocatable  byte_data, integer, intent(inout)  current_data_point  )

private

Serialises a field ordering value and releases any issued locks.

Parameters

specific_field_value	The specific value to serialise
byte_data	Target byte data whihc is allocated here
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 658 of file writer_field_manager.F90.

    type(field_ordering_value_type), intent(inout) :: specific_field_value
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point

    integer :: prev_pt    
    
    current_data_point=pack_scalar_field(byte_data, current_data_point, specific_field_value%timestep)
    current_data_point=pack_scalar_field(byte_data, current_data_point, specific_field_value%frequency)
    current_data_point=pack_scalar_field(byte_data, current_data_point, specific_field_value%source)
    current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(specific_field_value%field_name)))
    byte_data(current_data_point:current_data_point+len(trim(specific_field_value%field_name))-1) = &
         transfer(trim(specific_field_value%field_name), byte_data(current_data_point:current_data_point+&
         len(trim(specific_field_value%field_name))-1))
    current_data_point=current_data_point+len(trim(specific_field_value%field_name))
    current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(specific_field_value%field_namespace)))
    byte_data(current_data_point:current_data_point+len(trim(specific_field_value%field_namespace))-1) = &
         transfer(trim(specific_field_value%field_namespace), byte_data(current_data_point:current_data_point+&
         len(trim(specific_field_value%field_namespace))-1))
    current_data_point=current_data_point+len(trim(specific_field_value%field_namespace))
    current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=specific_field_value%time)

    prev_pt=current_data_point
    current_data_point=current_data_point+kind(current_data_point)
    call serialise_data_values_type(specific_field_value%field_values, byte_data, current_data_point)    
    prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-kind(current_data_point))-prev_pt)

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_specific_field_ordering()

subroutine writer_field_manager_mod::serialise_specific_field_ordering ( type(field_ordering_type), intent(inout)  specific_field_ordering, character, dimension(:), intent(inout), allocatable  byte_data, integer, intent(inout)  current_data_point  )

private

Serialises a specific fields ordering and releases any locks issued during preparation.

Parameters

specific_field_ordering	The field ordering to serialise
byte_data	Byte data which contains the packaged state of the field ordering
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 572 of file writer_field_manager.F90.

    type(field_ordering_type), intent(inout) :: specific_field_ordering
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point

    integer :: prev_pt
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    class(*), pointer :: generic
    
    current_data_point=pack_scalar_field(byte_data, current_data_point, specific_field_ordering%last_timestep_access)
    current_data_point=pack_scalar_field(byte_data, current_data_point, specific_field_ordering%frequency)
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(specific_field_ordering%timestep_to_value))

    iterator=c_get_iterator(specific_field_ordering%timestep_to_value)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      generic=>c_get_generic(map_entry)
      if (associated(generic)) then
        select type(generic)
        type is (field_ordering_value_type)
          current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(map_entry%key)))
          byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1) = transfer(trim(map_entry%key), &
               byte_data(current_data_point:current_data_point+len(trim(map_entry%key))-1))
          current_data_point=current_data_point+len(trim(map_entry%key))

          prev_pt=current_data_point
          current_data_point=current_data_point+kind(current_data_point)
          call serialise_field_ordering_value(generic, byte_data, current_data_point)          
          prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-kind(current_data_point))-prev_pt)
        end select
      end if
    end do
    
    call check_thread_status(forthread_mutex_unlock(specific_field_ordering%access_mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

unserialise_field_manager_state()

subroutine writer_field_manager_mod::unserialise_field_manager_state ( character, dimension(:), intent(in)  byte_data )

private

Unserialses from some byte data into the state.

Parameters

byte_data

Serialised byte data to inflate and initialise from

Definition at line 515 of file writer_field_manager.F90.

    character, dimension(:), intent(in) :: byte_data

    integer :: current_data_point, number_of_entries, i, byte_size, key_size
    character(len=STRING_LENGTH) :: value_key
    class(*), pointer :: generic

    current_data_point=1
    number_of_entries=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)

    if (number_of_entries .gt. 0) then
      do i=1, number_of_entries
        key_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        value_key=transfer(byte_data(current_data_point:current_data_point+key_size-1), value_key)
        value_key(key_size+1:)=" "
        current_data_point=current_data_point+key_size
        byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)        
        generic=>unserialise_specific_field_ordering(byte_data(current_data_point:current_data_point+byte_size-1))
        call c_put_generic(field_orderings, value_key, generic, .false.)
        current_data_point=current_data_point+byte_size
      end do
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

unserialise_field_ordering_value()

type(field_ordering_value_type) function, pointer writer_field_manager_mod::unserialise_field_ordering_value ( character, dimension(:), intent(in)  byte_data )

private

Unseralises some field ordering from its byte representation.

Parameters

byte_data

The serialised representation

Returns

The corresponding initialised and completed ordering value

Definition at line 689 of file writer_field_manager.F90.

    character, dimension(:), intent(in) :: byte_data
    type(field_ordering_value_type), pointer :: unserialise_field_ordering_value

    integer :: current_data_point, byte_size, str_size

    allocate(unserialise_field_ordering_value)
    current_data_point=1
    unserialise_field_ordering_value%timestep=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_field_ordering_value%frequency=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_field_ordering_value%source=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    str_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_field_ordering_value%field_name=transfer(byte_data(current_data_point:current_data_point+str_size-1), &
         unserialise_field_ordering_value%field_name)
    unserialise_field_ordering_value%field_name(str_size+1:)=" "
    current_data_point=current_data_point+str_size
    str_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_field_ordering_value%field_namespace=transfer(byte_data(current_data_point:current_data_point+str_size-1), &
         unserialise_field_ordering_value%field_namespace)
    unserialise_field_ordering_value%field_namespace(str_size+1:)=" "
    current_data_point=current_data_point+str_size
    unserialise_field_ordering_value%time=unpack_scalar_dp_real_from_bytedata(byte_data, current_data_point)
    byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)        
    unserialise_field_ordering_value%field_values=unserialise_data_values_type(byte_data(current_data_point:&
         current_data_point+byte_size-1))

Here is the call graph for this function:

Here is the caller graph for this function:

unserialise_specific_field_ordering()

type(field_ordering_type) function, pointer writer_field_manager_mod::unserialise_specific_field_ordering ( character, dimension(:), intent(in)  byte_data )

private

Unserialises some field ordering.

Parameters

byte_data

The serialised representation which we work from

Returns

The initialised field ordering represented by the provided byte data

Definition at line 612 of file writer_field_manager.F90.

    character, dimension(:), intent(in) :: byte_data
    type(field_ordering_type), pointer :: unserialise_specific_field_ordering

    integer :: current_data_point, number_of_values, byte_size, i, key_size
    character(len=STRING_LENGTH) :: value_key
    class(*), pointer :: generic

    allocate(unserialise_specific_field_ordering)
    
    current_data_point=1
    unserialise_specific_field_ordering%last_timestep_access=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_specific_field_ordering%frequency=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    number_of_values=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)

    if (number_of_values .gt. 0) then
      do i=1, number_of_values
        key_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        value_key=transfer(byte_data(current_data_point:current_data_point+key_size-1), value_key)
        value_key(key_size+1:)=" "
        current_data_point=current_data_point+key_size
        byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        generic=>unserialise_field_ordering_value(byte_data(current_data_point:current_data_point+byte_size-1))
        call c_put_generic(unserialise_specific_field_ordering%timestep_to_value, value_key, generic, .false.)
        current_data_point=current_data_point+byte_size
      end do
    end if
    call check_thread_status(forthread_mutex_init(unserialise_specific_field_ordering%access_mutex, -1))

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

field_lock

integer, volatile writer_field_manager_mod::field_lock

private

Definition at line 48 of file writer_field_manager.F90.

  integer, volatile :: field_lock

field_orderings

type(hashmap_type), volatile writer_field_manager_mod::field_orderings

private

Definition at line 49 of file writer_field_manager.F90.

  type(hashmap_type), volatile :: field_orderings