broadcast_inter_io_mod Module Reference

Broadcast inter IO communication which sends a value from one IO server to all others. This tracks field name and timestep and only issues one call (and one results call to completion) for that combination. More...

Data Types
type	inter_io_broadcast
type	threaded_callback_parameters_type

Functions/Subroutines
subroutine, public	init_broadcast_inter_io (io_configuration)
	Initialises the broadcast inter IO functionality. More...
subroutine, public	finalise_broadcast_inter_io ()
	Finalises the broadcast inter IO functionality. More...
logical function, public	check_broadcast_inter_io_for_completion (io_configuration)
	Checks the statuses for broadcast completion and returns whether they are all finished or not. More...
subroutine	handle_recv_data_from_io_server (io_configuration, data_buffer, inter_io_index)
	Handles receiving data from another IO server and processing this. If the request has already been registered (with a callback) then this simply calls out. Otherwise it has to cache the data and awaits a thread calling the broadcast to call out to the callback. More...
subroutine, public	perform_inter_io_broadcast (io_configuration, field_values, field_size, field_name, root, timestep, completion_procedure)
	Performs an inter IO broadcast of data from the root to all other IO servers. Note that this is on the IO server (and not MONC level) so might require some translation between the user's logical view and this view. Broadcasts are only issued once for a specific field_name and timestep pair. More...
subroutine	issue_thread_call_to_completion (field_name, timestep, values, completion_procedure)
	Issues the call into the thread pool to call the completion procedure, this runs in a seperate thread and ensures the semantics of one IO server or many with message ordering are independent. More...
subroutine	thread_call_to_completion (arguments, data_buffer)
	Called by the thread pool, this will call onto the completion procedure before cleaning up Integer arguments, this is the ID of the entry in the state Unused here. More...
subroutine	clean_broadcast_progress_if_needed ()
	Calls out to do a broadcast progress clean if needed (i.e. every n steps.) More...
subroutine	clean_broadcast_progress ()
	Performs a clean of the broadcast progresses that no longer need to be stored. More...
type(inter_io_broadcast) function, pointer	find_or_add_broadcast_item (field_name, timestep, completion_procedure)
	Locates and returns or adds and returns a specific broadcast item representing a timestep and field. More...
type(inter_io_broadcast) function, pointer	find_broadcast_item (field_name, timestep, do_read_lock)
	Finds a specific broadcast item or null if none is found. More...
type(inter_io_broadcast) function, pointer	retrieve_broadcast_item (mapentry)
	Locates a broadcast item within a mapentry or null if none exists. More...

Variables
integer, parameter	my_inter_io_tag =2
integer, parameter	perform_clean_every =200
character(len= *), parameter	my_inter_io_name ="bcastinterio"
	Type keeping track of broadcast statuses. More...
type(io_configuration_type), pointer	stored_io_configuration
type(hashmap_type), volatile	broadcast_statuses
type(hashmap_type), volatile	thread_callback_params
integer, volatile	broadcast_statuses_rwlock
integer, volatile	inter_io_description_mutex
integer, volatile	clean_progress_mutex
integer, volatile	bcast_count_mutex
integer, volatile	bcast_clean_reduction_count
integer, volatile	bcast_count
integer, volatile	thread_callback_params_id
integer, volatile	thread_callback_params_mutex
logical, volatile	initialised =.false.

Detailed Description

Broadcast inter IO communication which sends a value from one IO server to all others. This tracks field name and timestep and only issues one call (and one results call to completion) for that combination.

Function/Subroutine Documentation

check_broadcast_inter_io_for_completion()

logical function, public broadcast_inter_io_mod::check_broadcast_inter_io_for_completion

(

type(io_configuration_type), intent(inout)

io_configuration

)

Checks the statuses for broadcast completion and returns whether they are all finished or not.

Parameters

io_configuration

The IO server configuration

Returns

Whether the broadcast inter IO has finished (i.e. no messages in transit)

Definition at line 110 of file broadcast-inter-io.F90.

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

    type(inter_io_broadcast), pointer :: broadcast_item
    type(iterator_type) :: iterator

    check_broadcast_inter_io_for_completion=.true.
    call check_thread_status(forthread_rwlock_rdlock(broadcast_statuses_rwlock))
    if (.not. c_is_empty(broadcast_statuses)) then
      iterator=c_get_iterator(broadcast_statuses)
      do while (c_has_next(iterator))
        broadcast_item=>retrieve_broadcast_item(c_next_mapentry(iterator))
        if (.not. broadcast_item%handled) then
          check_broadcast_inter_io_for_completion=.false.
          exit
        end if
      end do
    end if
    call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))

Here is the call graph for this function:

clean_broadcast_progress()

subroutine broadcast_inter_io_mod::clean_broadcast_progress ( )

private

Performs a clean of the broadcast progresses that no longer need to be stored.

Definition at line 292 of file broadcast-inter-io.F90.

    type(inter_io_broadcast), pointer :: specific_broadcast_item_at_index
    integer :: completion_flag, ierr, num_to_remove, have_lock
    character(len=STRING_LENGTH) :: entry_key
    type(list_type) :: entries_to_remove
    logical :: destroy_lock
    type(iterator_type) :: iterator
    type(mapentry_type) :: mapentry
    class(*), pointer :: generic

    have_lock=forthread_mutex_trylock(clean_progress_mutex)
    if (have_lock==0) then
      call check_thread_status(forthread_rwlock_rdlock(broadcast_statuses_rwlock))
      iterator=c_get_iterator(broadcast_statuses)
      do while (c_has_next(iterator))
        destroy_lock=.false.
        mapentry=c_next_mapentry(iterator)
        specific_broadcast_item_at_index=>retrieve_broadcast_item(mapentry)
        call check_thread_status(forthread_mutex_lock(specific_broadcast_item_at_index%mutex))
        if (allocated(specific_broadcast_item_at_index%send_requests)) then
          call lock_mpi()
          call mpi_testall(size(specific_broadcast_item_at_index%send_requests), specific_broadcast_item_at_index%send_requests, &
               completion_flag, mpi_statuses_ignore, ierr)
          call unlock_mpi()
          if (completion_flag == 1) then
            deallocate(specific_broadcast_item_at_index%send_requests)
            if (allocated(specific_broadcast_item_at_index%send_buffer)) deallocate(specific_broadcast_item_at_index%send_buffer)
            call c_add_string(entries_to_remove, mapentry%key)
            destroy_lock=.true.
          end if
        else
          if (specific_broadcast_item_at_index%handled) then
            if (allocated(specific_broadcast_item_at_index%cached_values)) then
              deallocate(specific_broadcast_item_at_index%cached_values)
            end if
            call c_add_string(entries_to_remove, mapentry%key)
            destroy_lock=.true.
          end if
        end if
        call check_thread_status(forthread_mutex_unlock(specific_broadcast_item_at_index%mutex))
        if (destroy_lock) call check_thread_status(forthread_mutex_destroy(specific_broadcast_item_at_index%mutex))
      end do      
      call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))

      if (.not. c_is_empty(entries_to_remove)) then
        call check_thread_status(forthread_rwlock_wrlock(broadcast_statuses_rwlock))
        iterator=c_get_iterator(entries_to_remove)
        do while (c_has_next(iterator))
          entry_key=c_next_string(iterator)
          generic=>c_get_generic(broadcast_statuses, entry_key)
          call c_remove(broadcast_statuses, entry_key)
          deallocate(generic)
        end do
        call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))
      end if
      call c_free(entries_to_remove)
      call check_thread_status(forthread_mutex_unlock(clean_progress_mutex))
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

clean_broadcast_progress_if_needed()

subroutine broadcast_inter_io_mod::clean_broadcast_progress_if_needed ( )

private

Calls out to do a broadcast progress clean if needed (i.e. every n steps.)

Definition at line 279 of file broadcast-inter-io.F90.

    call check_thread_status(forthread_mutex_lock(bcast_count_mutex))
    bcast_count=bcast_count+1
    if (bcast_clean_reduction_count + perform_clean_every .lt. bcast_count) then
      bcast_clean_reduction_count=bcast_count
      call check_thread_status(forthread_mutex_unlock(bcast_count_mutex))   
      call clean_broadcast_progress()
    else
      call check_thread_status(forthread_mutex_unlock(bcast_count_mutex))   
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

finalise_broadcast_inter_io()

subroutine, public broadcast_inter_io_mod::finalise_broadcast_inter_io

(

)

Finalises the broadcast inter IO functionality.

Definition at line 77 of file broadcast-inter-io.F90.

    type(inter_io_broadcast), pointer :: broadcast_item
    type(iterator_type) :: iterator

    if (initialised) then
      call check_thread_status(forthread_rwlock_rdlock(broadcast_statuses_rwlock))
      if (.not. c_is_empty(broadcast_statuses)) then
        iterator=c_get_iterator(broadcast_statuses)
        do while (c_has_next(iterator))
          broadcast_item=>retrieve_broadcast_item(c_next_mapentry(iterator))
          call check_thread_status(forthread_mutex_lock(broadcast_item%mutex))
          if (allocated(broadcast_item%send_requests)) then
            call waitall_for_mpi_requests(broadcast_item%send_requests, size(broadcast_item%send_requests))
            deallocate(broadcast_item%send_requests)
            if (allocated(broadcast_item%send_buffer)) deallocate(broadcast_item%send_buffer)
          end if
          call check_thread_status(forthread_mutex_unlock(broadcast_item%mutex))
          call check_thread_status(forthread_mutex_destroy(broadcast_item%mutex))
        end do
      end if
      call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))
      call check_thread_status(forthread_rwlock_destroy(broadcast_statuses_rwlock))
      call check_thread_status(forthread_mutex_destroy(inter_io_description_mutex))
      call check_thread_status(forthread_mutex_destroy(thread_callback_params_mutex))
      call check_thread_status(forthread_mutex_destroy(clean_progress_mutex))
      call check_thread_status(forthread_mutex_destroy(bcast_count_mutex))
      initialised=.false.
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

find_broadcast_item()

type(inter_io_broadcast) function, pointer broadcast_inter_io_mod::find_broadcast_item ( character(len=*), intent(in)  field_name, integer, intent(in)  timestep, logical, intent(in)  do_read_lock  )

private

Finds a specific broadcast item or null if none is found.

Parameters

field_name	Corresponding field name to find
timestep	Corresponding timestep to find
do_read_lock	Whether to issue a read lock or not

Returns

The corresponding broadcast status item or null if none is found

Definition at line 390 of file broadcast-inter-io.F90.

    character(len=*), intent(in) :: field_name
    integer, intent(in) :: timestep
    logical, intent(in) :: do_read_lock
    type(inter_io_broadcast), pointer :: find_broadcast_item

    class(*), pointer :: generic

    if (do_read_lock) call check_thread_status(forthread_rwlock_rdlock(broadcast_statuses_rwlock))
    generic=>c_get_generic(broadcast_statuses, trim(field_name)//"#"//conv_to_string(timestep))
    if (do_read_lock) call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))

    if (associated(generic)) then
      select type(generic)
        type is (inter_io_broadcast)
          find_broadcast_item=>generic
      end select
    else
      find_broadcast_item=>null()
    end if    

Here is the call graph for this function:

Here is the caller graph for this function:

find_or_add_broadcast_item()

type(inter_io_broadcast) function, pointer broadcast_inter_io_mod::find_or_add_broadcast_item ( character(len=*), intent(in)  field_name, integer, intent(in)  timestep, procedure(handle_completion), optional  completion_procedure  )

private

Locates and returns or adds and returns a specific broadcast item representing a timestep and field.

Parameters

field_name	The field name this represents
timestep	The timestep this represents
completion_procedure	The (optional) completion procedure which is called once values are received

Returns

The existing or new broadcast item

Definition at line 357 of file broadcast-inter-io.F90.

    character(len=*), intent(in) :: field_name
    integer, intent(in) :: timestep
    procedure(handle_completion), optional :: completion_procedure
    type(inter_io_broadcast), pointer :: find_or_add_broadcast_item

    class(*), pointer :: generic

    find_or_add_broadcast_item=>find_broadcast_item(field_name, timestep, .true.)
    if (.not. associated(find_or_add_broadcast_item)) then
      call check_thread_status(forthread_rwlock_wrlock(broadcast_statuses_rwlock))
      find_or_add_broadcast_item=>find_broadcast_item(field_name, timestep, .false.)
      if (.not. associated(find_or_add_broadcast_item)) then
        allocate(find_or_add_broadcast_item)
        if (present(completion_procedure)) then
          find_or_add_broadcast_item%completion_procedure=>completion_procedure
        else
          find_or_add_broadcast_item%completion_procedure=>null()
        end if
        find_or_add_broadcast_item%handled=.false.
        call check_thread_status(forthread_mutex_init(find_or_add_broadcast_item%mutex, -1))
        generic=>find_or_add_broadcast_item
        call c_put_generic(broadcast_statuses, trim(field_name)//"#"//conv_to_string(timestep), generic, .false.)
      end if
      call check_thread_status(forthread_rwlock_unlock(broadcast_statuses_rwlock))
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

handle_recv_data_from_io_server()

subroutine broadcast_inter_io_mod::handle_recv_data_from_io_server ( type(io_configuration_type), intent(inout)  io_configuration, character, dimension(:), intent(inout)  data_buffer, integer, intent(in)  inter_io_index  )

private

Handles receiving data from another IO server and processing this. If the request has already been registered (with a callback) then this simply calls out. Otherwise it has to cache the data and awaits a thread calling the broadcast to call out to the callback.

Parameters

io_configuration	The IO server configuration
data_buffer	Data received from other IO server
inter_io_index	Index of the inter IO communication description

Definition at line 137 of file broadcast-inter-io.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    character, dimension(:), intent(inout) :: data_buffer
    integer, intent(in) :: inter_io_index    

    type(inter_io_broadcast), pointer :: broadcast_item
    real(kind=DEFAULT_PRECISION), dimension(:), allocatable :: data_values
    character(len=STRING_LENGTH) :: field_name
    integer :: timestep

    call unpackage_inter_io_communication_message(data_buffer, field_name, timestep, data_values)

    broadcast_item=>find_or_add_broadcast_item(field_name, timestep)
    
    if (associated(broadcast_item%completion_procedure)) then
      call check_thread_status(forthread_mutex_lock(broadcast_item%mutex))
      broadcast_item%handled=.true.
      call check_thread_status(forthread_mutex_unlock(broadcast_item%mutex))
      call issue_thread_call_to_completion(field_name, timestep, data_values, broadcast_item%completion_procedure)
    else
      call check_thread_status(forthread_mutex_lock(broadcast_item%mutex))
      allocate(broadcast_item%cached_values(size(data_values)), source=data_values)
      broadcast_item%cached_values=data_values
      call check_thread_status(forthread_mutex_unlock(broadcast_item%mutex))
    end if
    if (allocated(data_values)) deallocate(data_values)

Here is the call graph for this function:

Here is the caller graph for this function:

init_broadcast_inter_io()

subroutine, public broadcast_inter_io_mod::init_broadcast_inter_io

(

type(io_configuration_type), intent(inout), target

io_configuration

)

Initialises the broadcast inter IO functionality.

Parameters

io_configuration

The IO server configuration

Definition at line 58 of file broadcast-inter-io.F90.

    type(io_configuration_type), intent(inout), target :: io_configuration

    if (.not. initialised) then
      stored_io_configuration=>io_configuration
      initialised=.true.
      bcast_count=0
      thread_callback_params_id=0
      bcast_clean_reduction_count=0
      call check_thread_status(forthread_rwlock_init(broadcast_statuses_rwlock, -1))
      call check_thread_status(forthread_mutex_init(inter_io_description_mutex, -1))
      call check_thread_status(forthread_mutex_init(thread_callback_params_mutex, -1))
      call check_thread_status(forthread_mutex_init(clean_progress_mutex, -1))
      call check_thread_status(forthread_mutex_init(bcast_count_mutex, -1))
      call register_inter_io_communication(io_configuration, my_inter_io_tag, handle_recv_data_from_io_server, my_inter_io_name)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

issue_thread_call_to_completion()

subroutine broadcast_inter_io_mod::issue_thread_call_to_completion ( character(len=*), intent(in)  field_name, integer, intent(in)  timestep, real(default_precision), dimension(:), intent(in)  values, procedure(handle_completion)  completion_procedure  )

private

Issues the call into the thread pool to call the completion procedure, this runs in a seperate thread and ensures the semantics of one IO server or many with message ordering are independent.

Parameters

field_name	The name of the field
timestep	The timestep
values	Data values
completion_procedure	The completion procedure to call

Definition at line 226 of file broadcast-inter-io.F90.

    integer, intent(in) :: timestep
    character(len=*), intent(in) :: field_name
    real(DEFAULT_PRECISION), dimension(:), intent(in) :: values
    procedure(handle_completion) :: completion_procedure

    type(threaded_callback_parameters_type), pointer :: threaded_callback_state
    class(*), pointer :: generic

    allocate(threaded_callback_state)

    threaded_callback_state%field_name=field_name
    threaded_callback_state%timestep=timestep
    allocate(threaded_callback_state%values(size(values)), source=values)
    threaded_callback_state%completion_procedure=>completion_procedure

    call check_thread_status(forthread_mutex_lock(thread_callback_params_mutex))
    generic=>threaded_callback_state
    call c_put_generic(thread_callback_params, trim(conv_to_string(thread_callback_params_id)), generic, .false.)
    thread_callback_params_id=thread_callback_params_id+1
    call check_thread_status(forthread_mutex_unlock(thread_callback_params_mutex))

    call threadpool_start_thread(thread_call_to_completion, (/ thread_callback_params_id-1 /))

Here is the call graph for this function:

Here is the caller graph for this function:

perform_inter_io_broadcast()

subroutine, public broadcast_inter_io_mod::perform_inter_io_broadcast	(	type(io_configuration_type), intent(inout)	io_configuration,
		real(kind=double_precision), dimension(:)	field_values,
		integer, intent(in)	field_size,
		character(len=*), intent(in)	field_name,
		integer, intent(in)	root,
		integer, intent(in)	timestep,
		procedure(handle_completion)	completion_procedure
	)

Performs an inter IO broadcast of data from the root to all other IO servers. Note that this is on the IO server (and not MONC level) so might require some translation between the user's logical view and this view. Broadcasts are only issued once for a specific field_name and timestep pair.

Parameters

io_configuration	Configuration of the IO server
field_values	The values to communicate
field_size	Number of elements to communicate
field_name	Field name that the reduction will be performed over
root	The root IO server process
timestep	The timestep this is issued at
completion_procedure	Callback completion procedure

Definition at line 176 of file broadcast-inter-io.F90.

    type(io_configuration_type), intent(inout) :: io_configuration
    real(kind=DOUBLE_PRECISION), dimension(:) :: field_values
    integer, intent(in) :: field_size, root, timestep    
    character(len=*), intent(in) :: field_name
    procedure(handle_completion) :: completion_procedure
    
    type(inter_io_broadcast), pointer :: broadcast_item
    integer :: inter_io_comm_index, i, ierr

    call clean_broadcast_progress_if_needed()
    inter_io_comm_index=find_inter_io_from_name(io_configuration, my_inter_io_name)
    broadcast_item=>find_or_add_broadcast_item(field_name, timestep, completion_procedure)    
    
    call check_thread_status(forthread_mutex_lock(broadcast_item%mutex))
    if (io_configuration%my_io_rank == root .and. .not. broadcast_item%handled) then
      broadcast_item%handled=.true.

      allocate(broadcast_item%send_requests(io_configuration%number_of_io_servers))
      broadcast_item%send_buffer=package_inter_io_communication_message(field_name, timestep, field_values)

      do i=0, io_configuration%number_of_io_servers-1
        if (i .ne. io_configuration%my_io_rank) then
          call lock_mpi()
          call mpi_isend(broadcast_item%send_buffer, size(broadcast_item%send_buffer), mpi_byte, i, &
               io_configuration%inter_io_communications(inter_io_comm_index)%message_tag, &
               io_configuration%io_communicator, broadcast_item%send_requests(i+1), ierr)
          call unlock_mpi()
        else
          broadcast_item%send_requests(i+1)=mpi_request_null
        end if
      end do
      ! Still call the completion procedure on the root
      call issue_thread_call_to_completion(field_name, timestep, field_values, completion_procedure)
    else
      if (allocated(broadcast_item%cached_values) .and. .not. broadcast_item%handled) then
        broadcast_item%handled=.true.
        call issue_thread_call_to_completion(field_name, timestep, broadcast_item%cached_values, completion_procedure)
        if (allocated(broadcast_item%cached_values)) deallocate(broadcast_item%cached_values)
      end if
    end if
    call check_thread_status(forthread_mutex_unlock(broadcast_item%mutex))

Here is the call graph for this function:

Here is the caller graph for this function:

retrieve_broadcast_item()

type(inter_io_broadcast) function, pointer broadcast_inter_io_mod::retrieve_broadcast_item ( type(mapentry_type), intent(in)  mapentry )

private

Locates a broadcast item within a mapentry or null if none exists.

Parameters

mapentry

The map entry to use for this retrieval

Returns

The broadcast status or null if none exists

Definition at line 415 of file broadcast-inter-io.F90.

    type(mapentry_type), intent(in) :: mapentry
    type(inter_io_broadcast), pointer :: retrieve_broadcast_item

    class(*), pointer :: generic

    generic=>c_get_generic(mapentry)

    if (associated(generic)) then
      select type(generic)
        type is (inter_io_broadcast)
          retrieve_broadcast_item=>generic
      end select
    else
      retrieve_broadcast_item=>null()
    end if    

Here is the caller graph for this function:

thread_call_to_completion()

subroutine broadcast_inter_io_mod::thread_call_to_completion ( integer, dimension(:), intent(in)  arguments, character, dimension(:), intent(inout), optional, allocatable  data_buffer  )

private

Called by the thread pool, this will call onto the completion procedure before cleaning up Integer arguments, this is the ID of the entry in the state Unused here.

Definition at line 254 of file broadcast-inter-io.F90.

    integer, dimension(:), intent(in) :: arguments
    character, dimension(:), allocatable, intent(inout), optional :: data_buffer

    class(*), pointer :: generic
    type(threaded_callback_parameters_type), pointer :: threaded_callback_state

    call check_thread_status(forthread_mutex_lock(thread_callback_params_mutex))
    generic=>c_get_generic(thread_callback_params, trim(conv_to_string(arguments(1))))
    select type(generic)
    type is (threaded_callback_parameters_type)
      threaded_callback_state=>generic
      call c_remove(thread_callback_params, trim(conv_to_string(arguments(1))))
    end select
    call check_thread_status(forthread_mutex_unlock(thread_callback_params_mutex))

    if (associated(threaded_callback_state)) then
      call threaded_callback_state%completion_procedure(stored_io_configuration, threaded_callback_state%values, &
           threaded_callback_state%field_name, threaded_callback_state%timestep)
      deallocate(threaded_callback_state%values)
      deallocate(threaded_callback_state)
    end if

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

bcast_clean_reduction_count

integer, volatile broadcast_inter_io_mod::bcast_clean_reduction_count

private

Definition at line 48 of file broadcast-inter-io.F90.

bcast_count

integer, volatile broadcast_inter_io_mod::bcast_count

private

Definition at line 48 of file broadcast-inter-io.F90.

bcast_count_mutex

integer, volatile broadcast_inter_io_mod::bcast_count_mutex

private

Definition at line 48 of file broadcast-inter-io.F90.

broadcast_statuses

type(hashmap_type), volatile broadcast_inter_io_mod::broadcast_statuses

private

Definition at line 47 of file broadcast-inter-io.F90.

  type(hashmap_type), volatile :: broadcast_statuses, thread_callback_params

broadcast_statuses_rwlock

integer, volatile broadcast_inter_io_mod::broadcast_statuses_rwlock

private

Definition at line 48 of file broadcast-inter-io.F90.

  integer, volatile :: broadcast_statuses_rwlock, inter_io_description_mutex, clean_progress_mutex, &
       bcast_count_mutex, bcast_clean_reduction_count, bcast_count, thread_callback_params_id, thread_callback_params_mutex

clean_progress_mutex

integer, volatile broadcast_inter_io_mod::clean_progress_mutex

private

Definition at line 48 of file broadcast-inter-io.F90.

initialised

logical, volatile broadcast_inter_io_mod::initialised =.false.

private

Definition at line 50 of file broadcast-inter-io.F90.

  logical, volatile :: initialised=.false.

inter_io_description_mutex

integer, volatile broadcast_inter_io_mod::inter_io_description_mutex

private

Definition at line 48 of file broadcast-inter-io.F90.

my_inter_io_name

character(len=*), parameter broadcast_inter_io_mod::my_inter_io_name ="bcastinterio"

private

Type keeping track of broadcast statuses.

Definition at line 26 of file broadcast-inter-io.F90.

  character(len=*), parameter :: my_inter_io_name="bcastinterio"

my_inter_io_tag

integer, parameter broadcast_inter_io_mod::my_inter_io_tag =2

private

Definition at line 25 of file broadcast-inter-io.F90.

  integer, parameter :: my_inter_io_tag=2, perform_clean_every=200

perform_clean_every

integer, parameter broadcast_inter_io_mod::perform_clean_every =200

private

Definition at line 25 of file broadcast-inter-io.F90.

stored_io_configuration

type(io_configuration_type), pointer broadcast_inter_io_mod::stored_io_configuration

private

Definition at line 46 of file broadcast-inter-io.F90.

  type(io_configuration_type), pointer :: stored_io_configuration

thread_callback_params

type(hashmap_type), volatile broadcast_inter_io_mod::thread_callback_params

private

Definition at line 47 of file broadcast-inter-io.F90.

thread_callback_params_id

integer, volatile broadcast_inter_io_mod::thread_callback_params_id

private

Definition at line 48 of file broadcast-inter-io.F90.

thread_callback_params_mutex

integer, volatile broadcast_inter_io_mod::thread_callback_params_mutex

private

Definition at line 48 of file broadcast-inter-io.F90.