writer_types_mod Module Reference

Writer types which are shared across writing functionality. Also includes serialisation functionality for these types. More...

Data Types
type	collective_q_field_representation_type
type	netcdf_diagnostics_timeseries_type
type	netcdf_diagnostics_type
type	pending_write_type
type	write_field_collective_descriptor_type
type	write_field_collective_monc_info_type
type	write_field_collective_values_type
type	writer_field_type
type	writer_type

Functions/Subroutines
integer(kind=8) function, public	prepare_to_serialise_writer_type (writer_to_serialise)
	Prepares to serialise the writer type by issuing locks and determining the size of serialised bytes needed. More...
subroutine, public	serialise_writer_type (writer_to_serialise, byte_data)
	Serialises a specific writer type into byte data (for storage or transmission.) Releases any locks issued during preparation. More...
subroutine, public	unserialise_writer_type (writer_to_unserialise, byte_data)
	Unserialises some byte data into the writer in order to recreate the state of the writer. More...
integer(kind=8) function	prepare_to_serialise_writer_field_type (writer_field_to_serialise)
	Prepares to serialise a specific writer field, both determines the data size and issues any locks. More...
subroutine	serialise_writer_field_type (writer_field_to_serialise, byte_data, current_data_point)
	Serialises a specific writer field type for storage or transmission. This releases any locks issued during preparation. More...
subroutine	unserialise_writer_field_type (writer_field_to_unserialise, byte_data)
	Unserialises byte data into a writer field type. More...
integer(kind=8) function	prepare_to_serialise_collective_values_type (collective_values_to_serialise)
	Prepares to serialise a specific collective value, both determines the required byte storate size and issues any locks. More...
subroutine	serialise_collective_values_type (collective_values_to_serialise, byte_data, current_data_point)
	Serialises collective values. This releases any locks issued during preparation. More...
type(write_field_collective_values_type) function, pointer	unserialise_collective_values_type (byte_data)
	Unserialsies collective values contained in some data. More...
integer(kind=8) function, public	prepare_to_serialise_data_values_type (data_values_to_serialise)
	Prepares to serialise a specific data values type, both determines the byte size required and also issues any locks. More...
subroutine, public	serialise_data_values_type (data_values_to_serialise, byte_data, current_data_point)
	Serialises some data values to store or transmit. This releases any locks issued during preparation. More...
type(data_values_type) function, pointer, public	unserialise_data_values_type (byte_data)
	Unserialises some byte data into data values. More...
integer(kind=8) function	prepare_to_serialise_string_map (map_to_serialise)
	Prepares a map for serialisation, both determines the size of storage required and also issues any locks. More...
subroutine	serialise_string_map (map_to_serialise, byte_data, current_data_point)
	Serialises a string map, where the values are assumed to be strings. This releases any locks issued during preparation. More...
type(map_type) function, pointer	unserialise_string_map (byte_data)
	Inflates some byte data into a string map. More...

Detailed Description

Writer types which are shared across writing functionality. Also includes serialisation functionality for these types.

Function/Subroutine Documentation

prepare_to_serialise_collective_values_type()

integer(kind=8) function writer_types_mod::prepare_to_serialise_collective_values_type ( type(write_field_collective_values_type), intent(inout)  collective_values_to_serialise )

private

Prepares to serialise a specific collective value, both determines the required byte storate size and issues any locks.

Parameters

collective_values_to_serialise

The collective values to prepare for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 360 of file writer_types.F90.

    type(write_field_collective_values_type), intent(inout) :: collective_values_to_serialise
 
    class(*), pointer :: generic
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
 
    prepare_to_serialise_collective_values_type=kind(prepare_to_serialise_collective_values_type)
    if (c_size(collective_values_to_serialise%monc_values) .gt. 0) then
      iterator=c_get_iterator(collective_values_to_serialise%monc_values)
      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 (data_values_type)
            prepare_to_serialise_collective_values_type=prepare_to_serialise_collective_values_type+&
                 prepare_to_serialise_data_values_type(generic)+&
                 (kind(prepare_to_serialise_collective_values_type)*2)+len(trim(map_entry%key))         
          class default
            call log_log(log_error, "Unknown data type in collective values type")
          end select
        end if
      end do
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_data_values_type()

integer(kind=8) function, public writer_types_mod::prepare_to_serialise_data_values_type

(

type(data_values_type), intent(inout)

data_values_to_serialise

)

Prepares to serialise a specific data values type, both determines the byte size required and also issues any locks.

Parameters

data_values_to_serialise

The data values to prepare for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 462 of file writer_types.F90.

    type(data_values_type), intent(inout) :: data_values_to_serialise
 
    integer :: values_size
 
    prepare_to_serialise_data_values_type=kind(prepare_to_serialise_data_values_type) * 8
    
    if (allocated(data_values_to_serialise%values)) then
      prepare_to_serialise_data_values_type=prepare_to_serialise_data_values_type+&
           (kind(data_values_to_serialise%values)*size(data_values_to_serialise%values))
    else if (allocated(data_values_to_serialise%string_values)) then
      prepare_to_serialise_data_values_type=prepare_to_serialise_data_values_type+&
           (size(data_values_to_serialise%string_values) * string_length)
    else
      prepare_to_serialise_data_values_type=prepare_to_serialise_data_values_type+&
           prepare_to_serialise_string_map(data_values_to_serialise%map_values)
    end if        

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_string_map()

integer(kind=8) function writer_types_mod::prepare_to_serialise_string_map ( type(map_type), intent(inout)  map_to_serialise )

private

Prepares a map for serialisation, both determines the size of storage required and also issues any locks.

Parameters

map_to_serialise

The map which will be prepared for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 561 of file writer_types.F90.

    type(map_type), intent(inout) :: map_to_serialise
 
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    character(len=STRING_LENGTH) :: str_value
 
    prepare_to_serialise_string_map=kind(prepare_to_serialise_string_map)
    iterator=c_get_iterator(map_to_serialise)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      str_value=c_get_string(map_entry)
      prepare_to_serialise_string_map=prepare_to_serialise_string_map+len(trim(map_entry%key)) + &
           len(trim(str_value)) + (kind(prepare_to_serialise_string_map) * 2)
    end do

Here is the caller graph for this function:

prepare_to_serialise_writer_field_type()

integer(kind=8) function writer_types_mod::prepare_to_serialise_writer_field_type ( type(writer_field_type), intent(inout)  writer_field_to_serialise )

private

Prepares to serialise a specific writer field, both determines the data size and issues any locks.

Parameters

writer_field_to_serialise

The writer field type to prepare for serialisation

Returns

The number of bytes needed to store the serialised state

Definition at line 237 of file writer_types.F90.

    type(writer_field_type), intent(inout) :: writer_field_to_serialise
 
    type(iterator_type) :: iterator
    class(*), pointer :: generic
    type(mapentry_type) :: map_entry
 
    call check_thread_status(forthread_mutex_lock(writer_field_to_serialise%values_mutex))
    prepare_to_serialise_writer_field_type=(kind(writer_field_to_serialise%latest_timestep_values) * 2) + &
         (kind(writer_field_to_serialise%previous_write_time) * 2)
 
    iterator=c_get_iterator(writer_field_to_serialise%values_to_write)
    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 (data_values_type)
          prepare_to_serialise_writer_field_type=prepare_to_serialise_writer_field_type+&
               prepare_to_serialise_data_values_type(generic)+&
               (kind(prepare_to_serialise_writer_field_type)*3)+len(trim(map_entry%key))          
        type is (write_field_collective_values_type)
          prepare_to_serialise_writer_field_type=prepare_to_serialise_writer_field_type+&
               prepare_to_serialise_collective_values_type(generic)+&
               (kind(prepare_to_serialise_writer_field_type)*3)+len(trim(map_entry%key))          
        class default
          call log_log(log_error, "Unknown data type in writer field type")
        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_writer_type()

integer(kind=8) function, public writer_types_mod::prepare_to_serialise_writer_type

(

type(writer_type), intent(inout)

writer_to_serialise

)

Prepares to serialise the writer type by issuing locks and determining the size of serialised bytes needed.

Parameters

writer_to_serialise

Writer type to serialise

Returns

The number of bytes needed to store the serialised state

Definition at line 118 of file writer_types.F90.

    type(writer_type), intent(inout) :: writer_to_serialise
 
    integer :: i
 
    prepare_to_serialise_writer_type=(kind(writer_to_serialise%write_timestep) * 6) + &
         (kind(writer_to_serialise%previous_write_time) * 4) + &
         c_size(writer_to_serialise%pending_writes) * (kind(writer_to_serialise%write_timestep) + &
         kind(writer_to_serialise%previous_write_time))
 
    call check_thread_status(forthread_mutex_lock(writer_to_serialise%num_fields_to_write_mutex))
 
    if (size(writer_to_serialise%contents) .gt. 0) then
      do i=1, size(writer_to_serialise%contents)
        prepare_to_serialise_writer_type=prepare_to_serialise_writer_type+&
             prepare_to_serialise_writer_field_type(writer_to_serialise%contents(i))+kind(prepare_to_serialise_writer_type)
      end do
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_collective_values_type()

subroutine writer_types_mod::serialise_collective_values_type ( type(write_field_collective_values_type), intent(inout)  collective_values_to_serialise, character, dimension(:), intent(inout), allocatable  byte_data, integer, intent(inout)  current_data_point  )

private

Serialises collective values. This releases any locks issued during preparation.

Parameters

collective_values_to_serialise	The collective values to serialise
byte_data	The byte data which will be packed with the serialised byte code
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 391 of file writer_types.F90.

    type(write_field_collective_values_type), intent(inout) :: collective_values_to_serialise
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point
 
    integer :: prev_pt
    class(*), pointer :: generic
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
 
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(collective_values_to_serialise%monc_values))
 
    if (c_size(collective_values_to_serialise%monc_values) .gt. 0) then
      iterator=c_get_iterator(collective_values_to_serialise%monc_values)
      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 (data_values_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_data_values_type(generic, byte_data, current_data_point)            
            
            prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-kind(current_data_point))-prev_pt)
            class default
            call log_log(log_error, "Unknown data type in collective values type")
          end select
        end if
      end do
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_data_values_type()

subroutine, public writer_types_mod::serialise_data_values_type	(	type(data_values_type), intent(inout)	data_values_to_serialise,
		character, dimension(:), intent(inout), allocatable	byte_data,
		integer, intent(inout)	current_data_point
	)

Serialises some data values to store or transmit. This releases any locks issued during preparation.

Parameters

data_values_to_serialise	The data values to serialise
byte_data	The byte data which will be packaged with the serialised byte code
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 485 of file writer_types.F90.

    type(data_values_type), intent(inout) :: data_values_to_serialise
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point
 
    integer :: values_size, prev_pt
    character, dimension(:), allocatable :: dvt_byte_data, temp
 
    if (allocated(data_values_to_serialise%values)) then
      values_size=kind(data_values_to_serialise%values)*size(data_values_to_serialise%values)
    else if (allocated(data_values_to_serialise%string_values)) then
      values_size=size(data_values_to_serialise%string_values) * string_length
    else
      values_size=0
    end if
    
    current_data_point=pack_scalar_field(byte_data, current_data_point, data_values_to_serialise%data_type)
    current_data_point=pack_scalar_field(byte_data, current_data_point, data_values_to_serialise%dimensions)
    current_data_point=pack_array_field(byte_data, current_data_point, data_values_to_serialise%dim_sizes)
    if (allocated(data_values_to_serialise%values)) then
      current_data_point=pack_scalar_field(byte_data, current_data_point, 1)
      current_data_point=pack_scalar_field(byte_data, current_data_point, size(data_values_to_serialise%values))
      current_data_point=pack_array_field(byte_data, current_data_point, real_array_1d=data_values_to_serialise%values)
    else if (allocated(data_values_to_serialise%string_values)) then
      current_data_point=pack_scalar_field(byte_data, current_data_point, 2)
      current_data_point=pack_scalar_field(byte_data, current_data_point, &
           size(data_values_to_serialise%string_values) * string_length)
      byte_data(current_data_point:current_data_point+(size(data_values_to_serialise%string_values) * string_length)-1) = &
           transfer(data_values_to_serialise%string_values, &
           byte_data(current_data_point:current_data_point+(size(data_values_to_serialise%string_values) * string_length)-1))
    else
      current_data_point=pack_scalar_field(byte_data, current_data_point, 3)      
      call serialise_string_map(data_values_to_serialise%map_values, byte_data, current_data_point)      
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_string_map()

subroutine writer_types_mod::serialise_string_map ( type(map_type), intent(inout)  map_to_serialise, character, dimension(:), intent(inout), allocatable  byte_data, integer, intent(inout)  current_data_point  )

private

Serialises a string map, where the values are assumed to be strings. This releases any locks issued during preparation.

Parameters

map_to_serialise	The map which will be serialised
byte_data	The byte data representation of this map, this 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 582 of file writer_types.F90.

    type(map_type), intent(inout) :: map_to_serialise
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point
 
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    character(len=STRING_LENGTH) :: str_value
 
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(map_to_serialise))
 
    iterator=c_get_iterator(map_to_serialise)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      str_value=c_get_string(map_entry)
            
      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))
      current_data_point=pack_scalar_field(byte_data, current_data_point, len(trim(str_value)))
      if (len(trim(str_value)) .gt. 0) then
        byte_data(current_data_point:current_data_point+len(trim(str_value))-1) = transfer(trim(str_value), &
             byte_data(current_data_point:current_data_point+len(trim(str_value))-1))
      end if
      current_data_point=current_data_point+len(trim(str_value))
    end do

Here is the caller graph for this function:

serialise_writer_field_type()

subroutine writer_types_mod::serialise_writer_field_type ( type(writer_field_type), intent(inout)  writer_field_to_serialise, character, dimension(:), intent(inout), allocatable  byte_data, integer, intent(inout)  current_data_point  )

private

Serialises a specific writer field type for storage or transmission. This releases any locks issued during preparation.

Parameters

writer_field_to_serialise	The writer field type to serialise
byte_data	The byte data to pack with the serialised data
current_data_point	The current write point in the byte data, is updated during call so represents next point on return

Definition at line 273 of file writer_types.F90.

    type(writer_field_type), intent(inout) :: writer_field_to_serialise
    character, dimension(:), allocatable, intent(inout) :: byte_data
    integer, intent(inout) :: current_data_point
 
    integer :: prev_pt, byte_size, entry_type
    class(*), pointer :: generic
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
        
    current_data_point=pack_scalar_field(byte_data, current_data_point, writer_field_to_serialise%latest_timestep_values)
    current_data_point=pack_scalar_field(byte_data, current_data_point, &
         single_real_value=writer_field_to_serialise%previous_write_time)
    current_data_point=pack_scalar_field(byte_data, current_data_point, &
         single_real_value=writer_field_to_serialise%previous_tracked_write_point)
    
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(writer_field_to_serialise%values_to_write))
 
    iterator=c_get_iterator(writer_field_to_serialise%values_to_write)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      generic=>c_get_generic(map_entry)
      if (associated(generic)) then
        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)*2)
        select type(generic)
        type is (data_values_type)
          call serialise_data_values_type(generic, byte_data, current_data_point)
          entry_type=1
        type is (write_field_collective_values_type)
          call serialise_collective_values_type(generic, byte_data, current_data_point)
          entry_type=2
        class default
          call log_log(log_error, "Unknown data type in writer field type")
        end select        
        prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-(kind(current_data_point)*2)) - prev_pt)
        prev_pt=pack_scalar_field(byte_data, prev_pt, entry_type)        
      end if
    end do
    call check_thread_status(forthread_mutex_unlock(writer_field_to_serialise%values_mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

serialise_writer_type()

subroutine, public writer_types_mod::serialise_writer_type	(	type(writer_type), intent(inout)	writer_to_serialise,
		character, dimension(:), intent(inout), allocatable	byte_data
	)

Serialises a specific writer type into byte data (for storage or transmission.) Releases any locks issued during preparation.

Parameters

writer_to_serialise	The writer type to serialise
byte_data	The byte data which will be packed with the serialised data

Definition at line 141 of file writer_types.F90.

    type(writer_type), intent(inout) :: writer_to_serialise
    character, dimension(:), allocatable, intent(inout) :: byte_data
 
    integer :: prev_pt, i, current_data_point
 
    type(iterator_type) :: iterator
    class(*), pointer :: generic
 
    current_data_point=1
 
    current_data_point=pack_scalar_field(byte_data, current_data_point, writer_to_serialise%write_timestep)
    current_data_point=pack_scalar_field(byte_data, current_data_point, writer_to_serialise%num_fields_to_write)
    call check_thread_status(forthread_mutex_unlock(writer_to_serialise%num_fields_to_write_mutex))
    current_data_point=pack_scalar_field(byte_data, current_data_point, writer_to_serialise%previous_write_timestep)
    current_data_point=pack_scalar_field(byte_data, current_data_point, writer_to_serialise%latest_pending_write_timestep)
    current_data_point=pack_scalar_field(byte_data, current_data_point, single_real_value=writer_to_serialise%previous_write_time)
    current_data_point=pack_scalar_field(byte_data, current_data_point, &
         single_real_value=writer_to_serialise%latest_pending_write_time)
    current_data_point=pack_scalar_field(byte_data, current_data_point, single_real_value=writer_to_serialise%write_time)
    current_data_point=pack_scalar_field(byte_data, current_data_point, single_real_value=writer_to_serialise%defined_write_time)
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(writer_to_serialise%pending_writes))
    current_data_point=pack_scalar_field(byte_data, current_data_point, size(writer_to_serialise%contents))
 
    if (c_size(writer_to_serialise%pending_writes) .gt. 0) then
      iterator=c_get_iterator(writer_to_serialise%pending_writes)
      do while (c_has_next(iterator))
        generic=>c_next_generic(iterator)
        select type(generic)
          type is (pending_write_type)
            current_data_point=pack_scalar_field(byte_data, current_data_point, generic%timestep)
            current_data_point=pack_scalar_field(byte_data, current_data_point, single_real_value=generic%write_time)
        end select        
      end do
    end if
    
    if (size(writer_to_serialise%contents) .gt. 0) then
      do i=1, size(writer_to_serialise%contents)
        prev_pt=current_data_point
        current_data_point=current_data_point+kind(current_data_point)
        call serialise_writer_field_type(writer_to_serialise%contents(i), byte_data, current_data_point)
        prev_pt=pack_scalar_field(byte_data, prev_pt, (current_data_point-prev_pt)-kind(current_data_point))
      end do
    end if   

Here is the call graph for this function:

Here is the caller graph for this function:

unserialise_collective_values_type()

type(write_field_collective_values_type) function, pointer writer_types_mod::unserialise_collective_values_type ( character, dimension(:), intent(in)  byte_data )

private

Unserialsies collective values contained in some data.

Parameters

byte_data

The byte data to unserialise

Returns

The collective values type which represents this byte data

Definition at line 432 of file writer_types.F90.

    character, dimension(:), intent(in) :: byte_data
    type(write_field_collective_values_type), pointer :: unserialise_collective_values_type
 
    integer :: current_data_point, number_entries, i, key_size, byte_size
    character(len=STRING_LENGTH) :: value_key
    class(*), pointer :: generic
 
    allocate(unserialise_collective_values_type)
    
    current_data_point=1
    number_entries=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
 
    if (number_entries .gt. 0) then
      do i=1, number_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_data_values_type(byte_data(current_data_point:current_data_point+byte_size-1))
        call c_put_generic(unserialise_collective_values_type%monc_values, 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_data_values_type()

type(data_values_type) function, pointer, public writer_types_mod::unserialise_data_values_type

(

character, dimension(:), intent(in)

byte_data

)

Unserialises some byte data into data values.

Parameters

byte_data

The byte data which is read from

Returns

The unserialised and allocated data values

Definition at line 524 of file writer_types.F90.

    character, dimension(:), intent(in) :: byte_data
    type(data_values_type), pointer :: unserialise_data_values_type
 
    integer :: current_data_point, i, values_size, byte_size, values_type
 
    allocate(unserialise_data_values_type)
    current_data_point=1
    unserialise_data_values_type%data_type=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    unserialise_data_values_type%dimensions=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    do i=1, 4
      unserialise_data_values_type%dim_sizes(i)=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    end do
    values_type=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    if (values_type == 1) then
      values_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
      allocate(unserialise_data_values_type%values(values_size))
      byte_size=values_size*kind(unserialise_data_values_type%values)
      unserialise_data_values_type%values=transfer(byte_data(current_data_point:current_data_point+byte_size-1), &
           unserialise_data_values_type%values)
    else if (values_type == 2) then
      values_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
      allocate(unserialise_data_values_type%string_values(values_size))
      byte_size=values_size*string_length
      unserialise_data_values_type%string_values=transfer(byte_data(current_data_point:current_data_point+byte_size-1), &
           unserialise_data_values_type%string_values)              
    else if (values_type == 3) then
      byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
      unserialise_data_values_type%map_values=unserialise_string_map(byte_data(current_data_point:current_data_point+byte_size-1))
    else
      call log_log(log_error, "Unknown values type in data values serialisation bytes")
    end if      

Here is the call graph for this function:

Here is the caller graph for this function:

unserialise_string_map()

type(map_type) function, pointer writer_types_mod::unserialise_string_map ( character, dimension(:), intent(in)  byte_data )

private

Inflates some byte data into a string map.

Parameters

byte_data

The byte data to unserialise

Returns

The inflated map representation

Definition at line 614 of file writer_types.F90.

    character, dimension(:), intent(in) :: byte_data
    type(map_type), pointer :: unserialise_string_map
 
    integer :: current_data_point, number_entries, i, key_size, value_size
    character(len=STRING_LENGTH) :: value_key, value_value
 
    allocate(unserialise_string_map)
    current_data_point=1
    number_entries=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
 
    if (number_entries .gt. 0) then
      do i=1, number_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
        value_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        if (value_size .gt. 0) then
          value_value=transfer(byte_data(current_data_point:current_data_point+value_size-1), value_value)
        else
          value_value=""
        end if
        current_data_point=current_data_point+value_size
        call c_put_string(unserialise_string_map, value_key, value_value)
      end do
    end if

Here is the caller graph for this function:

unserialise_writer_field_type()

subroutine writer_types_mod::unserialise_writer_field_type ( type(writer_field_type), intent(inout)  writer_field_to_unserialise, character, dimension(:), intent(in)  byte_data  )

private

Unserialises byte data into a writer field type.

Parameters

writer_field_to_unserialise	The writer field to fill in
byte_data	The raw byte data to read from

Definition at line 322 of file writer_types.F90.

    type(writer_field_type), intent(inout) :: writer_field_to_unserialise
    character, dimension(:), intent(in) :: byte_data
 
    integer :: current_data_point, number_values_stored, i, byte_size, key_size, entry_type
    character(len=STRING_LENGTH) :: value_key
    class(*), pointer :: generic
 
    current_data_point=1
    writer_field_to_unserialise%latest_timestep_values=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)    
    writer_field_to_unserialise%previous_write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    writer_field_to_unserialise%previous_tracked_write_point=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    number_values_stored=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
 
    if (number_values_stored .gt. 0) then
      do i=1, number_values_stored
        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)
        entry_type=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)      
        if (entry_type == 1) then
          generic=>unserialise_data_values_type(byte_data(current_data_point:current_data_point+byte_size-1))
        else if (entry_type == 2) then
          generic=>unserialise_collective_values_type(byte_data(current_data_point:current_data_point+byte_size-1))
        else
          call log_log(log_error, "Unknown entry type in writer field type serialisation bytes")
        end if
        call c_put_generic(writer_field_to_unserialise%values_to_write, 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_writer_type()

subroutine, public writer_types_mod::unserialise_writer_type	(	type(writer_type), intent(inout)	writer_to_unserialise,
		character, dimension(:), intent(in)	byte_data
	)

Unserialises some byte data into the writer in order to recreate the state of the writer.

Parameters

writer_to_unserialise	The writer to unserialise and fill in
byte_data	The raw byte data to read from

Definition at line 190 of file writer_types.F90.

    type(writer_type), intent(inout) :: writer_to_unserialise
    character, dimension(:), intent(in) :: byte_data
 
    integer :: current_data_point, byte_size, expected_pending_writes, expected_contents, i
    type(pending_write_type), pointer :: pwt
    class(*), pointer :: generic
 
    current_data_point=1
    writer_to_unserialise%write_timestep=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%num_fields_to_write=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%previous_write_timestep=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%latest_pending_write_timestep=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%previous_write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%latest_pending_write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    writer_to_unserialise%defined_write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
    expected_pending_writes=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
    expected_contents=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
 
    if (expected_contents .ne. size(writer_to_unserialise%contents)) then
      call log_log(log_error, "Expected number of writer entry fields in the checkpoint does not match the configured number")
    end if
 
    if (expected_pending_writes .gt. 0) then
      do i=1, expected_pending_writes
        allocate(pwt)        
        pwt%timestep=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        pwt%write_time=unpack_scalar_real_from_bytedata(byte_data, current_data_point)
        generic=>pwt
        call c_push_generic(writer_to_unserialise%pending_writes, generic, .false.)
      end do      
    end if    
 
    if (expected_contents .gt. 0) then
      do i=1, expected_contents
        byte_size=unpack_scalar_integer_from_bytedata(byte_data, current_data_point)
        call unserialise_writer_field_type(writer_to_unserialise%contents(i), &
             byte_data(current_data_point:current_data_point+byte_size-1))
        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: