Приложение выдает ошибку сегментации через некоторое время при вызове процедуры (содержащей локальные массивы) в цикле

Наблюдения:

Если я изменю код так, чтобы он имел производный тип с выделяемым компонентом, и использую его для создания комассива в подпрограмме, код будет выполняться немного дольше, но в конце концов завершится с ошибкой. Далее идет модификация:

module mod_coarray_error
    implicit none

    type :: int_t
        integer, allocatable, dimension(:) :: var
    end type int_t

    contains
        subroutine Aldeal_type( width )
            integer, intent(in) :: width

            type(int_t), allocatable, codimension[:] :: int_t_Co

            allocate( int_t_Co[*] )

            allocate( int_t_Co%var(width) )
            sync all

            ! deallocate( int_t_Co%var )
            deallocate( int_t_Co )

            return
        end subroutine Aldeal_type
end module mod_coarray_error


program main
    use, intrinsic :: iso_fortran_env, only : input_unit, output_unit, error_unit
    use :: mod_coarray_error

    implicit none

    ! Variable declaration.
    integer :: me, ti
    integer :: GHOST_WIDTH, TSTART, TSTEPS, SAVET

    sync all

    ! Initialize.
    GHOST_WIDTH = 3
    TSTART = 0
    TSTEPS = 100000
    SAVET = 1000
    me = this_image()

    ! Iterate.
    do ti = TSTART + 1, TSTART + TSTEPS
        sync all
        call Aldeal_type( GHOST_WIDTH )
        if ( mod( ti, SAVET ) == 0 ) then
            if ( me == 1 ) write( output_unit, * ) ti
        end if
    end do

    sync all

    if ( me == 1 ) write( output_unit, * ) "All done!"
end program main

Кроме того, этот код отлично работает до конца при компиляции в Windows.

Теперь, если я добавлю параметр компилятора heap-arrays 0, код будет работать до конца даже в Linux.

Пробовал увеличивать количество циклов, т.е. TSTEPS в коде до 1e7. Даже тогда он успешно работает до конца. Но я наблюдаю следующие эффекты:

1. Код становится медленнее по мере увеличения числа циклов, т. е. требуется больше времени для выполнения от ti = 1e6 до ti = 2e6, чем время, необходимое для выполнения от ti = 1 до ti = 1e6.
2. Память, используемая программой, продолжает увеличиваться, т. е. каждое изображение, которое потребляет 2GB в начале выполнения программы, потребляет 3.5GB в ti = 2e6, 4.7GB в ti = 4e6 и 6GB в ti = 6e6.
3. Память, используемая программой, относительно меньше при работе в Windows, но она продолжает увеличиваться по мере увеличения количества циклов. Например, каждое изображение, которое потребляет 100MB при запуске, потребляет 1.5GB при ti = 2e6, 2.5GB при ti = 4e6 и 3.5GB при ti = 6e6.
4. Использование опции компилятора /heap-arrays0 в Windows никак не влияет ни на прогон (так как он и без него успешно запускался), ни на количество потребляемой памяти при запуске.
5. Исходный код, размещенный в вопросе, по-прежнему выдает ошибку даже при компиляции с использованием вышеуказанного параметра компилятора. В винде вроде тоже не запускается.

В конце концов, я все еще не понимаю, что происходит.

P.S. Я разместил вопрос на форуме Intel, но пока не получил ответа.