How to optimize a function and minimize allocations

Question

The following function generates primes up to N. For large N, this becomes quite slow, my Julia implementation is 5X faster for N = 10**7. I guess the creation of a large integer array and using pack to collect the result is the slowest part. I tried counting .true.s first, then allocating res(:) and populating it using a loop, but the speedup was negligible (4%) as I iterate the prims array twice in this case. In Julia, I used findall which does exactly what I did; iterating the array twice, first counting trues and allocationg result then populating it. Any ideas? Thank you.

Compiler: Intel(R) Visual Fortran Intel(R) 64 Compiler for applications running on Intel(R) 64, Version 18.0.3.210 Build 20180410 (on Windows 10)

Options: ifort -warn /O3 -heap-arrays:8000000

program main
    implicit none
    integer, allocatable :: primes(:) 
    integer :: t0, t1, count_rate, count_max

    call system_clock(t0, count_rate, count_max)
    primes = do_primes(10**7)
    call system_clock(t1)

    print '(a,f7.5,a)', 'Elapsed time: ', real(t1-t0)/count_rate, ' seconds'
    print *, primes(1:10)

contains 

    function do_primes(N) result (res)
        integer, allocatable :: res(:), array(:) 
        logical, allocatable :: prims(:)
        integer :: N, i, j

        allocate (prims(N))
        prims = .true.
        i = 3
        do while (i * i < N) 
            j = i 
            do while (j * i < N)
                prims(j*i) = .false.
                j = j + 2
            end do
            i = i + 2
        end do 
        prims(1) = .false.
        prims(2) = .true.
        do i = 4, N, 2  
            prims(i) = .false.
        end do

        allocate (array(N)) 
        do i = 1, N 
            array(i) = i 
        end do 
        res = pack(array, prims)
    end 
end 

Timing (147 runs):

Elapsed time: 0.14723 seconds

Edit:

I converted the do whiles to straight dos as per @IanBush comment like this, still no speedup:

do i = 3, sqrt(dble(N)), 2
    do j = i, N/i, 2
        prims(j*i) = .false.
    end do          
end do

The Julia implementation:

function do_primes(N)
    prims = trues(N)
    i = 3
    while i * i < N
        j = i 
        while j * i < N
            prims[j*i] = false
            j = j + 2
        end
        i = i + 2
    end 
    prims[1] = false
    prims[2] = true
    prims[4:2:N] .= false  
    return findall(prims) 
end

Timing:

using Benchmarktools 
@benchmark do_primes(10^7)
BenchmarkTools.Trial:
  memory estimate:  6.26 MiB
  allocs estimate:  5
  --------------
  minimum time:     32.227 ms (0.00% GC)
  median time:      32.793 ms (0.00% GC)
  mean time:        34.098 ms (3.92% GC)
  maximum time:     94.479 ms (65.46% GC)
  --------------
  samples:          147
  evals/sample:     1