io_server_state_writer_mod Module Reference

The IO server state module which will write out the current state of the IO server to a NetCDF file. More...

Data Types
interface	nc_def_dim
	ISO C binding interface for NetCDF dimension definition, needed to support 64 bit lengths. More...
interface	nc_def_var
	ISO C binding interface for NetCDF define variable, needed to support defining a long scalar variable. More...
interface	nc_put_var1_long
	ISO C binding interface for NetCDF put long scalar, needed to support putting longs into file. More...
interface	nc_put_vars_text
	ISO C binding interface for NetCDF put variable text, needed to support 64 bit starts, counts and strides. More...
interface	write_field_manager_determine_if_up_to_date
interface	writer_field_manager_prepare_to_serialise_state
interface	writer_field_manager_serialise_state

Functions/Subroutines
subroutine, public	set_serialise_write_field_manager_state (serialise_writer_field_manager_state_arg, prepare_to_serialise_writer_field_manager_state_arg, is_write_field_manager_up_to_date_arg)
	Sets the procedure to call for serialises the field manager state, this is handled in this manner due to the ordering dependencies between these modules. More...
logical function, public	is_io_server_state_writer_ready (timestep)
	Determines whether the IO server state writer is ready (i.e. state is at a specific level for the timestep) The timestep to check the IO server is up to date with. More...
subroutine	prepare_io_server_state_storage (io_configuration, writer_entries, time_points)
	Will determine the size of the package for different facets of the IO server state and kick off non-blocking collective calls to aggregate the sizes on each IO server process which is needed for the NetCDF dimension sizing and location in this. Note that during this certain locks are issued to ensure sizes don't change between this and physical packaging. More...
integer(kind=8) function	prepare_to_serialise_writer_entries_time_points (time_points)
	Prepares to serialise the writer entry time points. More...
subroutine	serialise_writer_entries_time_points (time_points, byte_data)
	Serialises the writer entry time points which are held in a hashmap. More...
subroutine, public	define_io_server_state_contributions (io_configuration, writer_entries, time_points, netcdf_file)
	Defines the dimensions and variables in a NetCDF file that consitute the IO server current state. This will call out to prepare all IO state for storage (determines the size of each byte code and issues locks for consistency.) More...
subroutine	define_state_storage (netcdf_file, entries_directory_dim_id, base_key, expected_global_entries)
	Defines some state storate for a specific facet of the IO server. This creates the directory (location for each IO server where to load their data), the dimension and the variable. Note this uses the ISO C bindings to NetCDF to support 64 bit dimension and field lengths. More...
subroutine, public	write_io_server_state (io_configuration, writer_entries, time_points, netcdf_file)
	Packags up and writes the actual IO server state into the NetCDF file. The act of serialisation will effectively unlock the IO server state locks that were issued in the preparation call (this is to ensure consistency between reported size and actual size when it comes time to package up.) More...
subroutine	write_state_storage (netcdf_file, writer_entry_start_point, my_io_rank, base_key, raw_byte_code)
	Writes out the state for a specific facet into the NetCDF file. Note that this uses the ISO C bindings into NetCDF to support 64 bit counts, starts and strides. More...

Variables
character, dimension(:), allocatable	serialised_writer_entries
character, dimension(:), allocatable	serialised_timeaveraged_manipulation_state
character, dimension(:), allocatable	serialised_instantaneous_manipulation_state
character, dimension(:), allocatable	serialised_writer_field_manager_state
character, dimension(:), allocatable	serialised_writer_entries_time_points
integer(kind=8), dimension(:), allocatable	global_writer_entry_byte_size
integer(kind=8), dimension(:), allocatable	my_writer_entry_start_point
integer(kind=8), dimension(:), allocatable	local_writer_entry_byte_size
integer	global_writer_entry_byte_size_request
integer	my_writer_entry_start_request
procedure(writer_field_manager_serialise_state), pointer	serialise_writer_field_manager_state
procedure(writer_field_manager_prepare_to_serialise_state), pointer	prepare_to_serialise_writer_field_manager_state
procedure(write_field_manager_determine_if_up_to_date), pointer	is_write_field_manager_up_to_date

Detailed Description

The IO server state module which will write out the current state of the IO server to a NetCDF file.

Function/Subroutine Documentation

define_io_server_state_contributions()

subroutine, public io_server_state_writer_mod::define_io_server_state_contributions	(	type(io_configuration_type), intent(inout)	io_configuration,
		type(writer_type), dimension(:), intent(inout), volatile	writer_entries,
		type(hashmap_type), intent(inout), volatile	time_points,
		type(netcdf_diagnostics_type), intent(inout)	netcdf_file
	)

Defines the dimensions and variables in a NetCDF file that consitute the IO server current state. This will call out to prepare all IO state for storage (determines the size of each byte code and issues locks for consistency.)

Parameters

io_configuration	IO server configuration
netcdf_file	The NetCDF file state

Definition at line 214 of file io_state_writer.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    type(writer_type), volatile, dimension(:), intent(inout) :: writer_entries
    type(hashmap_type), volatile, intent(inout) :: time_points
    type(netcdf_diagnostics_type), intent(inout) :: netcdf_file
    
    integer :: ncdf_dimid, ncdf_varid, current_index, i
    character, dimension(:), allocatable :: byte

    call prepare_io_server_state_storage(io_configuration, writer_entries, time_points)
    
    call lock_mpi()    
    call check_netcdf_status(nf90_def_dim(netcdf_file%ncid, "io_configuration_dim", &
         size(io_configuration%text_configuration), ncdf_dimid))
    call c_put_integer(netcdf_file%dimension_to_id, "io_configuration_dim", ncdf_dimid)

    call check_netcdf_status(nf90_def_var(netcdf_file%ncid, "io_configuration", nf90_char, ncdf_dimid, ncdf_varid))
    call c_put_integer(netcdf_file%variable_to_id, "io_configuration", ncdf_varid)

    call check_netcdf_status(nf90_def_dim(netcdf_file%ncid, "entries_directory_dim", io_configuration%number_of_io_servers, &
         ncdf_dimid))
    call unlock_mpi()
    call c_put_integer(netcdf_file%dimension_to_id, "entries_directory_dim", ncdf_dimid)

    call wait_for_mpi_request(global_writer_entry_byte_size_request)

    current_index=1
    do i=1, size(writer_entries)
      if (writer_entries(i)%include_in_io_state_write) then
        call define_state_storage(netcdf_file, ncdf_dimid, "serialised_writer_entry_"//trim(conv_to_string(i)), &
             global_writer_entry_byte_size(current_index))
        current_index=current_index+1
      end if
    end do        
    
    call define_state_storage(netcdf_file, ncdf_dimid, "serialised_timeaveraged_manipulation", &
         global_writer_entry_byte_size(current_index))
    call define_state_storage(netcdf_file, ncdf_dimid, "serialised_instantaneous_manipulation", &
         global_writer_entry_byte_size(current_index+1))
    call define_state_storage(netcdf_file, ncdf_dimid, "serialised_writer_manager", global_writer_entry_byte_size(current_index+2))
    call define_state_storage(netcdf_file, ncdf_dimid, "serialised_timepoints", global_writer_entry_byte_size(current_index+3))

Here is the call graph for this function:

Here is the caller graph for this function:

define_state_storage()

subroutine io_server_state_writer_mod::define_state_storage ( type(netcdf_diagnostics_type), intent(inout)  netcdf_file, integer, intent(in)  entries_directory_dim_id, character(len=*), intent(in)  base_key, integer(kind=8), intent(in)  expected_global_entries  )

private

Defines some state storate for a specific facet of the IO server. This creates the directory (location for each IO server where to load their data), the dimension and the variable. Note this uses the ISO C bindings to NetCDF to support 64 bit dimension and field lengths.

Parameters

netcdf_file	The NetCDF file state
entries_directory_dim_id	NetCDF dimension ID for the directory entries
base_key	The base key for this storage
expected_global_entries	The number of expected global entries that will be stored

Definition at line 264 of file io_state_writer.F90.

    type(netcdf_diagnostics_type), intent(inout) :: netcdf_file
    integer, intent(in) :: entries_directory_dim_id
    integer(kind=8), intent(in) :: expected_global_entries
    character(len=*), intent(in) :: base_key

    integer :: ncdf_varid
    integer :: ncdf_dimid
    integer(kind=c_int) :: cncid, cdimid, cvarid, cxtype, cnvdims
    integer(kind=c_int) :: cvdims(1)

    cncid = netcdf_file%ncid
    cnvdims=1
    cvdims(1)=entries_directory_dim_id-1
    
    cxtype=10 ! NC_INT64 type, note that this is signed as Fortran doesn't really like unsigned integers
    call lock_mpi()
    call check_netcdf_status(nc_def_var(cncid, trim(base_key)//"_directory"//c_null_char, cxtype, &
         cnvdims, cvdims, cvarid))
    ncdf_varid=cvarid+1

    call c_put_integer(netcdf_file%variable_to_id, trim(base_key)//"_directory", ncdf_varid)
  
    call check_netcdf_status(nc_def_dim(cncid, trim(base_key)//"_dim"//c_null_char, &
         int(expected_global_entries, c_size_t), cdimid))
    ncdf_dimid=cdimid+1
    call c_put_integer(netcdf_file%dimension_to_id,  trim(base_key)//"_dim", ncdf_dimid)
    call check_netcdf_status(nf90_def_var(netcdf_file%ncid, trim(base_key), nf90_char, ncdf_dimid, ncdf_varid))
    call c_put_integer(netcdf_file%variable_to_id, trim(base_key), ncdf_varid)
    call unlock_mpi()

Here is the call graph for this function:

Here is the caller graph for this function:

is_io_server_state_writer_ready()

logical function, public io_server_state_writer_mod::is_io_server_state_writer_ready

(

integer, intent(in)

timestep

)

Determines whether the IO server state writer is ready (i.e. state is at a specific level for the timestep) The timestep to check the IO server is up to date with.

Returns

Whether the IO server is ready or not

Definition at line 123 of file io_state_writer.F90.

    integer, intent(in) :: timestep

    is_io_server_state_writer_ready=is_write_field_manager_up_to_date(timestep)

prepare_io_server_state_storage()

subroutine io_server_state_writer_mod::prepare_io_server_state_storage ( type(io_configuration_type), intent(inout)  io_configuration, type(writer_type), dimension(:), intent(inout), volatile  writer_entries, type(hashmap_type), intent(inout), volatile  time_points  )

private

Will determine the size of the package for different facets of the IO server state and kick off non-blocking collective calls to aggregate the sizes on each IO server process which is needed for the NetCDF dimension sizing and location in this. Note that during this certain locks are issued to ensure sizes don't change between this and physical packaging.

Parameters

io_configuration	IO server configuration
writer_entries	The writer entries that we are going to store

Definition at line 134 of file io_state_writer.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    type(writer_type), volatile, dimension(:), intent(inout) :: writer_entries
    type(hashmap_type), volatile, intent(inout) :: time_points

    integer :: i, current_data_point, number_writer_entries_included, ierr, current_index
    character, dimension(:), allocatable :: dvt_byte_data, temp

    number_writer_entries_included=0
    do i=1, size(writer_entries)
      if (writer_entries(i)%include_in_io_state_write) number_writer_entries_included=number_writer_entries_included+1
    end do

    allocate(local_writer_entry_byte_size(number_writer_entries_included+4), &
         global_writer_entry_byte_size(number_writer_entries_included+4), &
         my_writer_entry_start_point(number_writer_entries_included+4))

    current_index=1
    do i=1, size(writer_entries)
      if (writer_entries(i)%include_in_io_state_write) then
        local_writer_entry_byte_size(current_index)=prepare_to_serialise_writer_type(writer_entries(i))
        current_index=current_index+1
      end if
    end do

    local_writer_entry_byte_size(current_index)=prepare_to_serialise_time_averaged_state()
    local_writer_entry_byte_size(current_index+1)=prepare_to_serialise_instantaneous_state()
    local_writer_entry_byte_size(current_index+2)=prepare_to_serialise_writer_field_manager_state()
    local_writer_entry_byte_size(current_index+3)=prepare_to_serialise_writer_entries_time_points(time_points)
    
    global_writer_entry_byte_size=local_writer_entry_byte_size
    my_writer_entry_start_point=local_writer_entry_byte_size
    call lock_mpi()
    call mpi_iallreduce(mpi_in_place, global_writer_entry_byte_size, size(global_writer_entry_byte_size), mpi_long_long_int, &
         mpi_sum, io_configuration%io_communicator, global_writer_entry_byte_size_request, ierr)
    call mpi_iscan(mpi_in_place, my_writer_entry_start_point, size(my_writer_entry_start_point), mpi_long_long_int, &
         mpi_sum, io_configuration%io_communicator, my_writer_entry_start_request, ierr)
    call unlock_mpi()

Here is the call graph for this function:

Here is the caller graph for this function:

prepare_to_serialise_writer_entries_time_points()

integer(kind=8) function io_server_state_writer_mod::prepare_to_serialise_writer_entries_time_points ( type(hashmap_type), intent(inout), volatile  time_points )

private

Prepares to serialise the writer entry time points.

Parameters

time_points

Hashmap of the timepoints that will need to be serialised

Returns

The byte size required for this serialisation

Definition at line 177 of file io_state_writer.F90.

    type(hashmap_type), volatile, intent(inout) :: time_points

    real(kind=DEFAULT_PRECISION) :: r_value

    prepare_to_serialise_writer_entries_time_points=kind(prepare_to_serialise_writer_entries_time_points) + &
         ((kind(prepare_to_serialise_writer_entries_time_points) + kind(r_value)) * c_size(time_points))

Here is the caller graph for this function:

serialise_writer_entries_time_points()

subroutine io_server_state_writer_mod::serialise_writer_entries_time_points ( type(hashmap_type), intent(inout), volatile  time_points, character, dimension(:), intent(inout), allocatable  byte_data  )

private

Serialises the writer entry time points which are held in a hashmap.

Parameters

time_points	The input time points which are to be serialised
byte_data	Allocated byte data which will hold the serialised values

Definition at line 189 of file io_state_writer.F90.

    type(hashmap_type), volatile, intent(inout) :: time_points
    character, dimension(:), allocatable, intent(inout) :: byte_data

    integer :: key, current_data_point
    type(mapentry_type) :: map_entry
    type(iterator_type) :: iterator
    real(kind=DEFAULT_PRECISION) :: r_value
        
    current_data_point=1
    current_data_point=pack_scalar_field(byte_data, current_data_point, c_size(time_points))
    iterator=c_get_iterator(time_points)
    do while (c_has_next(iterator))
      map_entry=c_next_mapentry(iterator)
      key=conv_to_integer(map_entry%key)
      r_value=c_get_real(map_entry)
      current_data_point=pack_scalar_field(byte_data, current_data_point, key)
      current_data_point=pack_scalar_field(byte_data, current_data_point, double_real_value=r_value)
    end do    

Here is the call graph for this function:

Here is the caller graph for this function:

set_serialise_write_field_manager_state()

subroutine, public io_server_state_writer_mod::set_serialise_write_field_manager_state	(	procedure(writer_field_manager_serialise_state)	serialise_writer_field_manager_state_arg,
		procedure(writer_field_manager_prepare_to_serialise_state)	prepare_to_serialise_writer_field_manager_state_arg,
		procedure(write_field_manager_determine_if_up_to_date)	is_write_field_manager_up_to_date_arg
	)

Sets the procedure to call for serialises the field manager state, this is handled in this manner due to the ordering dependencies between these modules.

Parameters

serialise_writer_field_manager_state_arg	The procedure to call for serialising the field manager state
prepare_to_serialise_writer_field_manager_state_arg	Preparation of field manager state procedure
is_write_field_manager_up_to_date_arg	Procedure to determine whether field manager is up to date

Definition at line 103 of file io_state_writer.F90.

    procedure(writer_field_manager_serialise_state) :: serialise_writer_field_manager_state_arg
    procedure(writer_field_manager_prepare_to_serialise_state) :: prepare_to_serialise_writer_field_manager_state_arg
    procedure(write_field_manager_determine_if_up_to_date) :: is_write_field_manager_up_to_date_arg

    integer(kind=c_size_t) :: size_t_test
    
    serialise_writer_field_manager_state=>serialise_writer_field_manager_state_arg
    prepare_to_serialise_writer_field_manager_state=>prepare_to_serialise_writer_field_manager_state_arg
    is_write_field_manager_up_to_date=>is_write_field_manager_up_to_date_arg

    if (c_sizeof(size_t_test) .lt. 8) then
      call log_master_log(log_warn, &
           "Your system's size_t is not 64 bit, this will limit the size of IO server state storage to 4GB")
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

write_io_server_state()

subroutine, public io_server_state_writer_mod::write_io_server_state	(	type(io_configuration_type), intent(inout)	io_configuration,
		type(writer_type), dimension(:), intent(inout), volatile	writer_entries,
		type(hashmap_type), intent(inout), volatile	time_points,
		type(netcdf_diagnostics_type), intent(inout)	netcdf_file
	)

Packags up and writes the actual IO server state into the NetCDF file. The act of serialisation will effectively unlock the IO server state locks that were issued in the preparation call (this is to ensure consistency between reported size and actual size when it comes time to package up.)

Parameters

io_configuration	IO server configuration
writer_entries	The writer types which need to be serialised
time_points	The time points that need to be serialised
netcdf_file	The NetCDF file state

Definition at line 303 of file io_state_writer.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    type(writer_type), volatile, dimension(:), intent(inout) :: writer_entries
    type(hashmap_type), volatile, intent(inout) :: time_points
    type(netcdf_diagnostics_type), intent(inout) :: netcdf_file

    integer :: field_id, var_id, current_index, i
    character, dimension(:), allocatable :: serialised_bytes

    field_id=c_get_integer(netcdf_file%variable_to_id, "io_configuration")

    if (io_configuration%my_io_rank == 0) then
      call lock_mpi()
      call check_netcdf_status(nf90_put_var(netcdf_file%ncid, field_id, io_configuration%text_configuration, &
           count=(/size(io_configuration%text_configuration)/)))
      call unlock_mpi()
    end if
    call wait_for_mpi_request(my_writer_entry_start_request)

    current_index=1
    do i=1, size(writer_entries)
      if (writer_entries(i)%include_in_io_state_write) then
        allocate(serialised_bytes(local_writer_entry_byte_size(current_index)))
        call serialise_writer_type(writer_entries(i), serialised_bytes)
        call write_state_storage(netcdf_file, my_writer_entry_start_point(current_index), io_configuration%my_io_rank, &
             "serialised_writer_entry_"//trim(conv_to_string(i)), serialised_bytes)
        deallocate(serialised_bytes)
        current_index=current_index+1
      end if
    end do

    allocate(serialised_bytes(local_writer_entry_byte_size(current_index)))
    call serialise_time_averaged_state(serialised_bytes)
    call write_state_storage(netcdf_file, my_writer_entry_start_point(current_index), io_configuration%my_io_rank, &
         "serialised_timeaveraged_manipulation", serialised_bytes)
    deallocate(serialised_bytes)

    allocate(serialised_bytes(local_writer_entry_byte_size(current_index+1)))
    call serialise_instantaneous_state(serialised_bytes)
    call write_state_storage(netcdf_file, my_writer_entry_start_point(current_index+1), io_configuration%my_io_rank, &
         "serialised_instantaneous_manipulation", serialised_bytes)
    deallocate(serialised_bytes)

    allocate(serialised_bytes(local_writer_entry_byte_size(current_index+2)))
    call serialise_writer_field_manager_state(serialised_bytes)
    call write_state_storage(netcdf_file, my_writer_entry_start_point(current_index+2), io_configuration%my_io_rank, &
         "serialised_writer_manager", serialised_bytes)
    deallocate(serialised_bytes)

    allocate(serialised_bytes(local_writer_entry_byte_size(current_index+3)))
    call serialise_writer_entries_time_points(time_points, serialised_bytes)
    call write_state_storage(netcdf_file, my_writer_entry_start_point(current_index+3), io_configuration%my_io_rank, &
         "serialised_timepoints", serialised_bytes)
    deallocate(serialised_bytes)

    deallocate(local_writer_entry_byte_size, global_writer_entry_byte_size, my_writer_entry_start_point)

Here is the call graph for this function:

Here is the caller graph for this function:

write_state_storage()

subroutine io_server_state_writer_mod::write_state_storage ( type(netcdf_diagnostics_type), intent(inout)  netcdf_file, integer(kind=8), intent(in)  writer_entry_start_point, integer, intent(in)  my_io_rank, character(len=*), intent(in)  base_key, character, dimension(:), intent(in)  raw_byte_code  )

private

Writes out the state for a specific facet into the NetCDF file. Note that this uses the ISO C bindings into NetCDF to support 64 bit counts, starts and strides.

Parameters

netcdf_file	The NetCDF file state
writer_entry_start_point	The start point, this is uncorrected so it is actually the end point
my_io_rank	My IO server rank
base_key	The base key to use for look up
raw_byte_code	The raw byte code to write

Definition at line 368 of file io_state_writer.F90.

    type(netcdf_diagnostics_type), intent(inout) :: netcdf_file
    integer, intent(in) :: my_io_rank
    integer(kind=8), intent(in) :: writer_entry_start_point 
    character(len=*), intent(in) :: base_key
    character, dimension(:), intent(in) :: raw_byte_code

    integer(kind=c_int) :: cncid, cvarid, cndims, cstat1, cstatus
    integer(kind=c_size_t), target :: cstart(1), ccounts(1)
    integer(kind=c_ptrdiff_t), target :: cstrides(1)
    integer(kind=c_long) :: c_writer_corrected_start_point
    type(c_ptr) :: cstartptr, ccountsptr, cstridesptr

    cncid=netcdf_file%ncid
    cstart(1)=my_io_rank
    cvarid=c_get_integer(netcdf_file%variable_to_id, trim(base_key)//"_directory")-1
    c_writer_corrected_start_point=(writer_entry_start_point-size(raw_byte_code))+1

    ccounts(1)=size(raw_byte_code)
    cstrides(1)=1

    cstartptr=c_loc(cstart)
    ccountsptr=c_loc(ccounts)
    cstridesptr=c_loc(cstrides)
    
    call lock_mpi()
    call check_netcdf_status(nc_put_var1_long(cncid, cvarid, cstartptr, c_writer_corrected_start_point))
    cvarid=c_get_integer(netcdf_file%variable_to_id, trim(base_key))-1
    cstart(1)=c_writer_corrected_start_point-1    
    call check_netcdf_status(nc_put_vars_text(cncid, cvarid, cstartptr, ccountsptr, cstridesptr, raw_byte_code))
    call unlock_mpi()

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

global_writer_entry_byte_size

integer(kind=8), dimension(:), allocatable io_server_state_writer_mod::global_writer_entry_byte_size

private

Definition at line 85 of file io_state_writer.F90.

  integer(kind=8), dimension(:), allocatable :: global_writer_entry_byte_size, my_writer_entry_start_point, &
       local_writer_entry_byte_size

global_writer_entry_byte_size_request

integer io_server_state_writer_mod::global_writer_entry_byte_size_request

private

Definition at line 87 of file io_state_writer.F90.

  integer :: global_writer_entry_byte_size_request, my_writer_entry_start_request

is_write_field_manager_up_to_date

procedure(write_field_manager_determine_if_up_to_date), pointer io_server_state_writer_mod::is_write_field_manager_up_to_date

private

Definition at line 90 of file io_state_writer.F90.

  procedure(write_field_manager_determine_if_up_to_date), pointer :: is_write_field_manager_up_to_date

local_writer_entry_byte_size

integer(kind=8), dimension(:), allocatable io_server_state_writer_mod::local_writer_entry_byte_size

private

Definition at line 85 of file io_state_writer.F90.

my_writer_entry_start_point

integer(kind=8), dimension(:), allocatable io_server_state_writer_mod::my_writer_entry_start_point

private

Definition at line 85 of file io_state_writer.F90.

my_writer_entry_start_request

integer io_server_state_writer_mod::my_writer_entry_start_request

private

Definition at line 87 of file io_state_writer.F90.

prepare_to_serialise_writer_field_manager_state

procedure(writer_field_manager_prepare_to_serialise_state), pointer io_server_state_writer_mod::prepare_to_serialise_writer_field_manager_state

private

Definition at line 89 of file io_state_writer.F90.

  procedure(writer_field_manager_prepare_to_serialise_state), pointer :: prepare_to_serialise_writer_field_manager_state

serialise_writer_field_manager_state

procedure(writer_field_manager_serialise_state), pointer io_server_state_writer_mod::serialise_writer_field_manager_state

private

Definition at line 88 of file io_state_writer.F90.

  procedure(writer_field_manager_serialise_state), pointer :: serialise_writer_field_manager_state

serialised_instantaneous_manipulation_state

character, dimension(:), allocatable io_server_state_writer_mod::serialised_instantaneous_manipulation_state

private

Definition at line 83 of file io_state_writer.F90.

serialised_timeaveraged_manipulation_state

character, dimension(:), allocatable io_server_state_writer_mod::serialised_timeaveraged_manipulation_state

private

Definition at line 83 of file io_state_writer.F90.

serialised_writer_entries

character, dimension(:), allocatable io_server_state_writer_mod::serialised_writer_entries

private

Definition at line 83 of file io_state_writer.F90.

  character, dimension(:), allocatable :: serialised_writer_entries, serialised_timeaveraged_manipulation_state, &
       serialised_instantaneous_manipulation_state, serialised_writer_field_manager_state, serialised_writer_entries_time_points

serialised_writer_entries_time_points

character, dimension(:), allocatable io_server_state_writer_mod::serialised_writer_entries_time_points

private

Definition at line 83 of file io_state_writer.F90.

serialised_writer_field_manager_state

character, dimension(:), allocatable io_server_state_writer_mod::serialised_writer_field_manager_state

private

Definition at line 83 of file io_state_writer.F90.