checkpoint_linear.f90

 
!
 
submodule(state_recover_checkpoint) checkpoint_linear
  use num_types, only: dp
  use simulation, only: simulation_step, simulation_restart
  use time_step_controller, only: time_step_controller_t
  use profiler, only: profiler_start_region, profiler_end_region
 
contains
 
  module subroutine checkpoint_save_linear(this)
    class(state_recover_checkpoint_t), intent(inout) :: this
    integer :: index, tstep, counter, n_total
    real(kind=rp) :: time, start_time, end_time, dt
 
    time = this%neko_case%time%t
    dt = this%neko_case%time%dt
    tstep = this%neko_case%time%tstep
    start_time = this%neko_case%time%start_time
    end_time = this%neko_case%time%end_time
 
    ! We save to disc only every n_saves_memory time steps
    index = modulo(tstep, this%n_saves_memory)
    if (index .eq. 0 .or. tstep .le. this%first_valid_timestep) then
       this%loaded_checkpoint = tstep
 
       counter = determine_counter(tstep, this%n_saves_memory, &
            this%first_valid_timestep)
 
       call this%chkp_output%set_counter(counter)
       call profiler_start_region("Checkpoint write to disk")
       call this%chkp_output%sample(time)
       call profiler_end_region("Checkpoint write to disk")
       this%n_saves_disc = this%n_saves_disc + 1
    end if
 
    ! Only save to RAM from the last disc checkpoint to the end of the forward
    ! simulation. With fixed timesteps, the total count and the last disc-save
    ! timestep are known from the time object.
    ! Note: the plus 0.5 is to round up to the next integer, as the division can
    ! be slightly smaller than the actual number of steps due to floating point
    ! errors.
    n_total = int(((end_time - start_time) / dt) + 0.5_rp)
    if (tstep .ge. n_total - modulo(n_total, this%n_saves_memory)) then
       call this%save_data(index + 1)
    end if
 
  end subroutine checkpoint_save_linear
 
  module subroutine checkpoint_restore_linear(this, tstep)
    class(state_recover_checkpoint_t), intent(inout) :: this
    integer, intent(in) :: tstep
    type(time_step_controller_t) :: dt_controller
    real(kind=dp) :: loop_start
    integer :: k, previous_save, next_save, local_idx, counter
 
    loop_start = mpi_wtime()
 
    ! Determine the nearest save states on both sides
    previous_save = tstep - modulo(tstep, this%n_saves_memory)
    next_save = previous_save + this%n_saves_memory
 
    ! Before the first valid state we always load from disc and we do not step
    ! forward in time.
    if (tstep .lt. this%first_valid_timestep) then
       previous_save = tstep
       next_save = previous_save + 1
    else if (previous_save .lt. this%first_valid_timestep) then
       previous_save = this%first_valid_timestep
    end if
 
    ! Load a new batch of checkpoints if needed
    if (this%loaded_checkpoint .ne. previous_save) then
 
       ! Restart the simulation form the checkpoint file
       counter = determine_counter(previous_save, this%n_saves_memory, &
            this%first_valid_timestep)
       call this%chkp_output%set_counter(counter)
       call profiler_start_region("Checkpoint read from disk")
       call this%chkp_output%file_%read(this%neko_case%chkp)
       call profiler_end_region("Checkpoint read from disk")
       call simulation_restart(this%neko_case, this%neko_case%chkp)
 
       ! Initialize the time step controller and set the time step
       call dt_controller%init(this%neko_case%params)
       this%neko_case%time%tstep = previous_save
       this%loaded_checkpoint = this%neko_case%time%tstep
 
       call profiler_start_region("Checkpoint recompute")
       ! Step through the simulation and store field states in memory
       do k = previous_save, min(next_save - 1, this%get_n_timesteps())
 
          ! Do not run simulation step on the first iteration
          if (k .ne. previous_save) then
             if (this%neko_case%time%t .ge. this%neko_case%time%end_time) exit
             call simulation_step(this%neko_case, dt_controller, loop_start)
          end if
 
          ! Save the restored state in memory
          local_idx = modulo(k, this%n_saves_memory) + 1
          call this%save_data(local_idx)
       end do
       call profiler_end_region("Checkpoint recompute")
    end if
 
    ! Restore the required time step from memory
    local_idx = modulo(tstep, this%n_saves_memory) + 1
    call this%load_data(local_idx)
  end subroutine checkpoint_restore_linear
 
  pure function determine_counter(tstep, n_memory, first) result(counter)
    integer, intent(in) :: tstep, n_memory, first
    integer :: counter
 
    if (tstep .le. first) then
       counter = tstep
    else
       counter = first + tstep / n_memory
    end if
 
  end function determine_counter
 
end submodule checkpoint_linear