New Vectorization Diagnostics starting from Intel® Fortran Compiler 15.0

Diagnostic 7617: This host associated object appears in a 'defining' context in a PURE procedure or in an internal procedure contained in a PURE procedure.

In Fortran, A PURE procedure has restrictions on side-effects that allow parallelization and better optimization. PURE procedures are not allowed to define or change the definition status of variables that are host or use associated, or in COMMON. In the following example, hostvar is host associated inside PURE subroutine puresub. When this source is compiled, the assignment to hostvar causes error 7617 to be reported.

program F7617
implicit none

integer hostvar

call puresub

contains

pure subroutine puresub
hostvar = 1
end subroutine puresub
end program F7617

Note that ELEMENTAL procedures are also PURE, unless they are also given the IMPURE prefix (a Fortran 2008 feature supported by Intel Fortran Compiler 16.0 and above.)

To resolve this error, do not use host associated variables in a definition context within a PURE procedure.

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options states that loop was vectorized:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

program f15300
  implicit none
  integer, parameter :: n=100
  real, dimension(n) :: x = (/(i, i=1,n)/)
  integer :: i

  do i = 1,n
    x(i) = x(i) * 10.
  enddo

end program f15300

ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f15300.f90

Begin optimization report for: F15300

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15300.f90(7,3)
   remark #15300: LOOP WAS VECTORIZED
LOOP END

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X: -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine add(k, a)  
  integer :: k  
  real :: a(20)
  
   DO i = 1, 20 
    a(i) = a(i+k) * 2.0 
     end do  
end subroutine add

$ ifort -c -qopt-report-file=stderr -qopt-report-phase=vec f15304.f90 

Begin optimization report for: ADD

    Report from: Vector optimizations [vec].

LOOP BEGIN at f15304.f90(6,5)
<Multiversioned v3>
   remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
LOOP END

Resolution: 

The compiler generates 3 loop versions, for k=0, k>0 and k<0. The version for k<0 cannot be safely vectorized because each later iteration may depend on the result of earlier iterations. You can override the compiler by inserting the !DIR$ IVDEP directive.The IVDEP directive tells the compiler it can safely ignore potential dependencies, so it does not need to generate special code for the case of K<0.

subroutine add(k, a)  
  integer :: k  
  real :: a(20)
!DIR$ IVDEP   
   DO i = 1, 20 
    a(i) = a(i+k) * 2.0 
     end do  
end subroutine add

$ ifort -c -qopt-report-file=stderr -qopt-report-phase=vec f15304.f90 

Begin optimization report for: ADD
    Report from: Vector optimizations [vec]

LOOP BEGIN at f15304.f90(6,5)

    remark #15300: LOOP WAS VECTORIZED

LOOP END

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

When the loop contains an assignment to a derived data type which is not directly vectorizable. The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

module my_mod
   integer, parameter :: N=1000
   type :: my_type
      integer :: c1
      real(8) :: c2
   end type my_type
   type(my_type), dimension(N) :: my_inst
end module my_mod

subroutine f15310(init_data)
   use my_mod
   implicit none
   integer :: i
   type(my_type), intent(in) :: init_data

   do i=1,N
      my_inst(i) = init_data
   enddo
end subroutine f15310

 ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15310.f90

Begin optimization report for: F15310

    Report from: Vector optimizations [vec].

LOOP BEGIN at f15310.f90(16,4)
remark #15310: loop was not vectorized: operation cannot be vectorized
LOOP END

Resolution: 

 The loop may be vectorized if an assignment operator is defined for the derived type.

Product Version:  Intel® Fortran Compiler 15.0 and above

Cause:

When using NOVECTOR directive in code, the vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
	implicit none
	integer, intent(in) :: n
	real, intent(inout) :: a(n) 
	real, intent(in)    :: b(n)
	
    integer :: i

!DEC$ NOVECTOR
    
       do i=1,n 
		     a(i)= b(i)+1
       end do
       
end subroutine foo 

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15319.f90

Begin optimization report for: FOO

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15319.f90(11,8)

   remark #15319: loop was not vectorized: novector directive used

LOOP END

Resolution:

There may be cases where you want to explicitly avoid vectorization of a loop; for example, if vectorization would result in a performance regression rather than an improvement. In these cases, you can use the NOVECTOR directive to disable vectorization of the loop. 

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

A vectorizable loop contains loads from memory locations that are not contiguous in memory (sometimes known as a “gather”). These may be indexed loads, as in the example below, or loads with non-unit stride. The compiler has emulated a hardware gather instruction by issuing individual loads for the different memory locations in software.

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options:

Windows* OS:  /O2  /Qopt-report:4  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report=4  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine gathr(n, a, b, index)
   implicit none
   integer, parameter :: RT=8
   integer,                intent(in)  :: n
   integer,  dimension(n), intent(in)  :: index
   real(RT), dimension(n), intent(in)  :: a
   real(RT), dimension(n), intent(out) :: b
   integer                             :: i
   
   do i=1,n
       b(i) = 1.0_RT + 0.1_RT*a(index(i))
   enddo
end subroutine gathr

$ ifort -c -qopt-report=4 -qopt-report-file=stdout gathr.f90  

When using Intel Fortran compiler version 16.0 the following remark is generated:

   [...]

remark #15328: vectorization support: gather was emulated for the variable a:  indirect access  [ gathr.f90(11,31) ]

    [...]

When using Intel Fortran compiler version 17.0 the following remark is generated:

   [...]

remark #15328: vectorization support: irregularly indexed load was emulated for the variable <a(index(i))>, part of index is read from memory   [ gathr.f90(11,31) ]

  [...]

The compiler has vectorized the loop by emulating a “gather” instruction in software.

The assembly code contains no gather instructions.

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

A vectorizable loop contains loads from memory locations that are not contiguous in memory (sometimes known as a “gather”). These may be indexed loads, as in the example below, or loads with non-unit stride. The compiler has emulated a hardware gather instruction by issuing individual loads for the different memory locations in software.

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine gathr(n, a, b, index)
   implicit none
   integer,                intent(in)  :: n
   integer,  dimension(n), intent(in)  :: index
   real(RT), dimension(n), intent(in)  :: a
   real(RT), dimension(n), intent(out) :: b
   integer                             :: i

   do i=1,n
       b(i) = 1.0_RT + 0.1_RT*a(index(i))
   enddo

end subroutine gathr

$ ifort -c -xcore-avx2 -qopt-report=4 -qopt-report-file=stdout gathr.F90 -DRT=8 -S | egrep 'gather|VECTORIZED'

   remark #15328: vectorization support: gather was emulated for the variable a:  indirect access    [ gathr.F90(10,29) ]

   remark #15300: LOOP WAS VECTORIZED

   remark #15458: masked indexed (or gather) loads: 1

   remark #15301: REMAINDER LOOP WAS VECTORIZED

The compiler has vectorized the loop by emulating a “gather” instruction in software.

The assembly code contains no gather instructions.

Compare to the behavior when compiling with -DRT=4  as described in the article for diagnostic #15415.

Product Version: Intel® Fortran Compiler 15.0 and above

Cause

When using Intel® Fortran Compiler's option /fp:precise (Linux OS and OS X syntax: -fp-model precise) the vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options ( /O2 /Qopt-report:2 /Qopt-report-phase:vec) includes non-vectorized loop instance.

Example

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
	implicit none
    integer, intent(in) :: n
	real, intent(inout) :: a(n)
	real, intent(out) :: b
	real :: x = 0
	integer :: i
       
	do i=1,n
			x = x + a(i)			
	end do
	
	b = x
	
end subroutine foo

ifort -c /fp:precise /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15331.f90

Begin optimization report for: FOO

Report from: Vector optimizations [vec]

LOOP BEGIN at f15331.f90(9,2)

remark #15331: loop was not vectorized: precise FP model implied by the command line or a directive prevents vectorization. Consider using fast FP model [f15331.f90(10,4)]

LOOP END

Resolution:

Using fast FP model (Windows OS: /fp:fast, Linux and OS X syntax: -fp-model fast) option which allows more aggressive optimizations on floating-point data will get this loop vectorized.

See also:

fp-model, fp

Product Version:  Intel® Fortran Compiler 15.0 and above 

Cause: 

The vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options  -O2 -Qvec-report2 -Qopt-report:2 states that loop was not vectorized: vectorization possible but seems inefficient.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real, intent(out)   :: b
    real :: x = 0
    integer :: i

    do i=1,n
            x = x + a(2*i)
    end do
    
    b = x
    
end subroutine foo

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15335.f90

 Report from: Vector optimizations [vec]

LOOP BEGIN at f15335.f90(9,5)

   remark #15335: loop was not vectorized: vectorization possible but seems inefficient. Use vector always directive or /Qvec-threshold0 to override
LOOP END

Resolution:

Using !DEC$ VECTOR ALWAYS directive in the code will vectorize the loop by overriding efficiency heuristics of the vectorizer.

See also:   
VECTOR and NOVECTOR

 Product Version:  Intel® Fortran Compiler 15.0 and above

Cause:

When  a loop contains a conditional statement which controls the assignment of a scalar value AND the scalar value is referenced AFTER the loop exits. The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following remark in optimization report:

subroutine f13379( a, b, n )  
  implicit none 
  integer, intent(in)               :: n
  integer, intent(in),  dimension(n) :: a
  integer, intent(out),dimension(n) :: b
   
  integer                           :: i, x=10  
   
!$omp simd  
  do i=1,n  
    if( a(i) > 0 ) then 
     x = i                    !...here is the scalar assignment 
    end if 
    b(i) = x  
  end do 
!... reference the scalar outside of the loop  
  write(*,*) "last value of x: ", x  
end subroutine f13379

$ ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f13379.f90

When using Intel Fortran Compiler version 16.0 the following remark is generated:

LOOP BEGIN at f13379.f90(8,3)

   remark #15336: simd loop was not vectorized: conditional assignment to a scalar   [ f13379.f90(10,8) ]

   remark #13379: loop was not vectorized with "simd"

LOOP END

When using Intel Fortran Compiler version 17.0 the following remark is generated:

LOOP BEGIN at  f15336.f90(12,3)
   remark #15316: simd loop was not vectorized: scalar assignment in simd loop is prohibited, consider private, lastprivate or reduction clauses  f15336.f90(10,6)
   remark #15552: loop was not vectorized with "simd"
LOOP END

Resolution:

Using !$omp simd lastprivate(x)  instead of !$omp simd will have x initialized for each subroutine in executable code.

Example

subroutine f13379( a, b, n )  
  implicit none 
  integer, intent(in)               :: n
  integer, intent(in),  dimension(n) :: a
  integer, intent(out),dimension(n) :: b
   
  integer                           :: i, x=10  
   
!$omp simd lastprivate(x)  
  do i=1,n  
    if( a(i) > 0 ) then 
     x = i                    !...here is the scalar assignment 
    end if 
    b(i) = x  
  end do 
!... reference the scalar outside of the loop  
  write(*,*) "last value of x: ", x  
end subroutine f13379

$ ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f13379.f90

Begin optimization report for: F13379

    Report from: Vector optimizations [vec]

LOOP BEGIN at f13379.f90(10,3)
   remark #15301: OpenMP SIMD LOOP WAS VECTORIZED
LOOP END

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

This diagnostic message occurs when the parameters of the directive are contradictory.  The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options states that pragma supersedes previous setting:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

In the example below, the directive !dir$ loop count has two clauses, avg() and max(). Notice the contradiction in these two clauses: the max() parameter is lesser than the avg() clause value. The following example will generate this remark in optimization report:

subroutine f15340( A, n )
implicit none
real :: A(n)
integer :: n, i
!dir$ loop count avg(30), max(10)
do i=1,n
  A(i) = real(i)
end do
end subroutine f15340

 ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15340.f90

Begin optimization report for: F15340

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15340.f90(6,1
   remark #15340: pragma supersedes previous setting
   remark #15300: LOOP WAS VECTORIZED
LOOP END

Resolution: 

Make sure the max() clause is always greater than avg() clause value.  Notice that the loop does still vectorize, it simply ignores the avg(30) and uses max(10)

Product Version: Intel® Fortran Compiler 15.0 and above

Cause:

When using Intel® Fortran Compiler's optimization and vectorization report options  /O2 /Qopt-report:2 /Qopt-report-phase:vec the vectorization report generated states that loop was not vectorized due to vector dependence which prevents vectorization.  

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max 
    integer :: inx, i
    
    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i*i
        endif
    end do
    
    foo = inx
    
end function

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15344.f90

Report from: Vector optimizations [vec]

LOOP BEGIN at  f15344.f90(9,5)
   remark #15344: loop was not vectorized: vector dependence prevents vectorization. First dependence is shown below. Use level 5 report for details   [ f15344.f90(12,13) ]
   remark #15346: vector dependence: assumed ANTI dependence between  line 10 and  line 11   [ f15344.f90(12,13) ]
LOOP END

Resolution:

Rewriting the code as in the following example will resolve vector dependence and the loop will be vectorized

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max 
    integer :: inx, i
    
    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i
        endif
    end do
    
    foo = inx*inx
    
end function

​​​​​​

Product Version: Intel® Fortran Compiler 15.0 and above 

Cause:

When using Intel® Fortran Compiler's optimization and vectorization report options  /O2 /Qopt-report:2 /Qopt-report-phase:vec the vectorization report generated states that loop was not vectorized due to vector dependence which prevents vectorization.  

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max 
    integer :: inx, i
    
    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i*i
        endif
    end do
    
    foo = inx
    
end function

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15344.f90

Report from: Vector optimizations [vec]

LOOP BEGIN at  f15344.f90(9,5)
   remark #15344: loop was not vectorized: vector dependence prevents vectorization. First dependence is shown below. Use level 5 report for details   [ f15344.f90(12,13) ]
   remark #15346: vector dependence: assumed ANTI dependence between  line 10 and  line 11   [ f15344.f90(12,13) ]
LOOP END

Resolution:

Rewriting the code as in the following example will resolve vector dependence and the loop will be vectorized

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max 
    integer :: inx, i
    
    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i
        endif
    end do
    
    foo = inx*inx
    
end function

​​​​​​

The article you are looking for has been retired! Check out the FAQ Or ask in our Developer forums

Product Version: Intel® Fortran Compiler 15.0 and a later version  

Cause:

When code contains a loop or array syntax performing a simple initialization or a copy, the compiler may replace the loop with a function call to either set memory (memset) or copy memory (memcpy). The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec 

Example:

An example below will generate the following  remark in optimization report:

program f15398
implicit none
integer, parameter :: N=32
integer :: i,a(N)
  !...initialize array using DO
  do i=1,N
    a(i) = 0
  end do
  a = 0   !...same, with array syntax 
  print*, a(1)

end program f15398

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15398.f90
 
Begin optimization report for: F15398

    Report from: Vector optimizations [vec]
    
LOOP BEGIN at f15398.f90(6,3)
   remark #15398: loop was not vectorized: loop was transformed to memset or memcpy
LOOP END

LOOP BEGIN at f15398.f90(9,3)
   remark #15398: loop was not vectorized: loop was transformed to memset or memcpy
LOOP END

Product Version: Intel® Fortran Compiler 15.0 and above

Cause:

The vectorization report generated when using Intel® Fortran Compiler's optimization options (/O2 /Qopt-report:2) states that loop was not vectorized since loop body became empty after optimizations.

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, b, n) 
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a
    real, intent (in)   :: b
    integer :: i
    
    do i=1,n
           a = b + 1
    end do
    
    foo = a
    
end function 

ifort -c /O2 /Qopt-report:2 /Qopt-report-file:stdout f15414.f90

Report from: Interprocedural optimizations [ipo]

INLINING OPTION VALUES:

  -Qinline-factor: 100

  -Qinline-min-size: 30

  -Qinline-max-size: 230

  -Qinline-max-total-size: 2000

  -Qinline-max-per-routine: 10000

  -Qinline-max-per-compile: 500000

Begin optimization report for: FOO

    Report from: Interprocedural optimizations [ipo]

INLINE REPORT: (FOO) [1] f15414.f90(1,18)

Resolution:

In the example above, there is only one expression inside the loop. When moved outside the loop as a result of the compiler's optimization process there is nothing else left inside the loop to vectorize. 

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

A vectorizable loop contains loads from memory locations that are not contiguous in memory (sometimes known as a “gather”). These may be indexed loads, as in the example below, or loads with non-unit stride. The compiler has issued a hardware gather instruction for these loads.

(Note that for compiler versions 16.0.1 and earlier, the compiler may also emit this message when gather operations are emulated in software).

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine gathr(n, a, b, index)
   implicit none
   integer,                intent(in)  :: n
   integer,  dimension(n), intent(in)  :: index
   real(RT), dimension(n), intent(in)  :: a
   real(RT), dimension(n), intent(out) :: b
   integer                             :: i

   do i=1,n
       b(i) = 1.0_RT + 0.1_RT*a(index(i))
   enddo

end subroutine gathr

$ ifort -c -xcore-avx2 -qopt-report=4 -qopt-report-file=stdout gathr.F90 -DRT=4 -S | egrep 'gather|VECTORIZED'

   remark #15415: vectorization support: gather was generated for the variable a:  indirect access    [ gathr.F90(10,29) ]

   remark #15300: LOOP WAS VECTORIZED

   remark #15458: masked indexed (or gather) loads: 1

   remark #15301: REMAINDER LOOP WAS VECTORIZED

$ egrep gather gathr.s

        vgatherdps %ymm4, -4(%r8,%ymm3,4), %ymm5                #10.29

        vgatherdps %ymm7, -4(%r8,%ymm6,4), %ymm8                #10.29

        vgatherdps %ymm3, -4(%r8,%ymm2,4), %ymm4                #10.29

$

The compiler has vectorized the loop using a “gather” instruction from Intel® Advanced Vector Extensions 2 (Intel® AVX2).

Compare to the behavior when compiling with -DRT=8  as described in the article for diagnostic #15328.

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

The Intel® Fortran Compiler will not vectorize a loop when it knows the loop has only one iteration. If the user requires vectorization by using a SIMD directive, the compiler emits a warning diagnostic.

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine f15423( a, b, n ) 
  implicit none
  real, dimension(*) :: a, b
  integer            :: i, n
  
  n=1
 
!$omp simd
  do i=1,n 
     b(i) = 1. - a(i)**2
  end do
   
end subroutine f15423

$ ifort -c -qopenmp-simd f15423.f90

f15423.f90(8): (col. 7) remark: simd loop has only one iteration

f15423.f90(8): (col. 7) warning #13379:  was not vectorized with "simd"

Resolution:

If the loop really has only one iteration, don’t use a SIMD directive or don’t code a loop.

If the statement  n=1  was inserted unintentionally, remove it and the loop will vectorize.

Product Version: Intel® Fortran Compiler 15.0 and a later version  

Cause:

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine f15516(a,b,n)
   implicit none
   complex(8), dimension(n), intent(in ) :: a
   complex(8), dimension(n), intent(out) :: b
   integer,                  intent(in ) :: n
   integer                               :: i 
   
   do i=1,n
      b(i) = 1. / sqrt(1.+a(i)**2)
   enddo
   
end subroutine f15516

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15516.f90
 
Begin optimization report for: F15516

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15516.f90(8,4)
   remark #15516: loop was not vectorized: cost model has chosen vectorlength of 1 -- maybe possible to override via pragma/directive with vectorlength clause
LOOP END

Resolution: 

The article you are looking for has been retired! Check out the FAQ Or ask in our Developer forums

Product Version: Intel® Fortran Compiler 15.0 and a later version 

Cause:

The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance because of the inherent potential for an early exit from the loop.:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following  remark in optimization report:

subroutine f15520(a,b,c,n)
  implicit none
  real, intent(in ), dimension(n) :: a, b
  real, intent(out), dimension(n) :: c
  integer, intent(in)             :: n
  integer                         :: i

  do i=1,n
     if(a(i).lt.0.) exit
     c(i) = sqrt(a(i)) * b(i)
  enddo
end subroutine f15520

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15520.f90
 
Begin optimization report for: F15520

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15520.f90(8,3)
   remark #15520: loop was not vectorized: loop with early exits cannot be vectorized unless it meets search loop idiom criteria
 LOOP END

Resolution: 

A loop with two exits can only be vectorized if it is a very simple search loop. Rewriting the above example as follows will get it vectorized:

 subroutine f15520(a,b,c,n) 
  implicit none 
  real, intent(in ), dimension(n) :: a, b 
  real, intent(out), dimension(n) :: c 
  integer, intent(in)             :: n 
  integer                         :: i, j 
  
  do i=1,n 
     if(a(i).lt.0.) exit
  enddo
  
  do j=1,i-1 
     c(j) = sqrt(a(j)) * b(j) 
  enddo 

end subroutine f15520

ifort -c -qopt-report-file=stderr -qopt-report-phase=vec f15520b.f90
…
LOOP BEGIN at f15520b.f90(8,3)
   remark #15300: LOOP WAS VECTORIZED
LOOP END
…
LOOP BEGIN at f15520b.f90(12,3)
   remark #15300: LOOP WAS VECTORIZED
LOOP END

In this case, the first loop is recognized as a pure search loop (searching for the first value of a that is less than zero).

Product Version: Intel® Fortran Compiler 15.0 and above

Cause:

When using Intel® Fortran Compiler's optimization options:

/O3 /Qopt-report:2 /Qopt-report-phase:vec

The vectorization report generated by the compiler states that the loop was not vectorized since the loop count could not be computed before executing the loop.

Example:

An example below will generate the following remark in optimization report:

integer function  foo
implicit none 
   
  foo = 1
  do while (foo < 10000)  
     foo = foo + foo**2
  end do 
  
end  function foo

ifort -c /O3 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15521.f90

Begin optimization report for: FOO

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15521.f90(5,3)
   remark #15521: loop was not vectorized: explicitly compute the iteration count before executing the loop or try using canonical loop form
LOOP END

Product Version: Intel® Fortran Compiler 15.0 and above 

Cause:

The vectorization report generated when using Intel® Fortran Compiler's optimization options (/O3 /Qopt-report:2 /Qopt-report-phase:vec) states that loop was not vectorized since loop control flow is too complex.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, n)
    implicit none
    integer, intent(in) :: n
    double precision, intent(inout) :: a(n,n)
       integer :: bar
       integer :: i
       integer :: j
       
200   CONTINUE
       i=0
100   CONTINUE
       
       a(i,j)= 0
       i=i+1
       if (i .lt. bar()) goto 100
       j=j+1
       goto 200
     	
end subroutine foo 

ifort -c /O3 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15522.f90

Report from: Vector optimizations [vec]

  LOOP BEGIN at f1552.f90(10,8)

     remark #15522: loop was not vectorized: loop control flow is too complex.  remark #15522: loop was not vectorized: loop control flow is too complex. Try using canonical loop form..
 
  LOOP END

Resolution:

 -goto statements prevent vectorization, rewriting the code using canonical loops such as 'do - end do' loops will get this loop vectorized.

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O3 /Qopt-report:2 /Qopt-report-phase:vec ) states that loop was not vectorized since loop iteration count cannot be computed before the loop is executed.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, n)
    
       implicit none
       integer, intent(in) :: n
       double precision, intent(inout) :: a(n)
       integer :: bar
       integer :: i
       
       i=0
 100   CONTINUE
       a(i)=0
       i=i+1
       if (i .lt. bar()) goto 100
       
  end subroutine foo

ifort -c /O3 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15523.f90

Begin optimization report for: FOO

Report from: Vector optimizations [vec]

  LOOP BEGIN at f15523.f90(9,8)

  LOOP BEGIN  
      remark #15523: loop was not vectorized: loop control variable I was found, but loop iteration count cannot be computed before executing the loop.
 
  LOOP END

Resolution:

 -goto statements prevent vectorization. Rewriting the code using 'do - end do'' loops where iteration count is computed before execution of the loop will get this loop vectorized. 

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O2  /Qopt-report:2 Qopt-report-phase:vec ) states that loop was not vectorized since all memory references cannot be an aligned vector load.

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, n) 

       implicit none
       integer, intent(in) :: n
       real, intent(inout) :: a(n) 
       integer :: i 
       
       do i=1,n   
         if (a(2*i) .eq. 0) goto 100 
       end do
       
100    CONTINUE 
       foo = i
       
end function foo

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15524.f90

Report from: Vector optimizations [vec]

 LOOP BEGIN at f15524.f90(8,8)

   remark #15524: loop was not vectorized: search loop cannot be vectorized unless all memory references can be aligned vector load. 

LOOP END

Resolution:

 In search loop vectorization if a “vector load” fits entirely within a cache line, and if such a vector load has one non-speculatively accessed  element, it is safe for the compiler to speculatively load all other elements (within the same cache line) in such a vector load. 
Rewriting the code and avoiding GOTO statements will get this loop vectorized.

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O2 /Qopt-report:2 /Qopt-report-phase:vec ) states that loop was not vectorized since loop with function call cannot be vectorized.

Example:

An example below will generate the following remark in optimization report:

subroutine bar(a) 
    implicit none
    include 'omp_lib.h' 
    
    integer (kind=omp_lock_kind) a 
    call omp_init_lock(a) 
end subroutine bar
 
subroutine foo(a,n) 
       include 'omp_lib.h' 
       integer (kind=omp_lock_kind) a(n)

       do i=1,n
        call bar (a(i))
       end do
end subroutine foo

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15527.f90

Report from: Vector optimizations [vec]

 LOOP BEGIN at f15527.f90(14,8)

   f15527.f90(6,10):remark #15527: simd loop was not vectorized: function call to omp_init_lock cannot be vectorized

LOOP END

Resolution:

In order for the loop to be vectorized there should be no special operators and no function or subroutine calls, unless these are inlined, either manually or automatically by the compiler, or they are SIMD (vectorized) functions.

Product Version: Intel® Fortran Compiler 15.0 and a later version  

Cause:

When a code contains a variable which is declared as VOLATILE, the vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec 

Example:

An example below will generate the following  remark in optimization report:

PROGRAM LOOP
  IMPLICIT NONE
  INTEGER, PARAMETER :: N=100000
  INTEGER            :: I
  REAL,DIMENSION(N)  :: E, B = (/(I, I=1,N)/)
  REAL, VOLATILE     :: D = 2.

  DO I=1,N 
     E(I) = D*SIN(B(I))
  ENDDO

  PRINT *, E(N)
END PROGRAM LOOP

ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f15529.f90
 

Begin optimization report for: LOOP

    Report from: Vector optimizations [vec]

Non-optimizable loops:

LOOP BEGIN at f15529.f90(10,3)
   remark #15529: loop was not vectorized: volatile assignment was not vectorized. Try using non-volatile assignment.[f15529.f90(9,6)]
LOOP END

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O2  /Qopt-report:2 ) states that compile time constraints prevent optimization.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, n)
    
       implicit none
       integer, intent(in) :: n
       double precision, intent(inout) :: a(n)
       integer :: bar
       integer :: i
       
       i=0
 100   CONTINUE
       a(i)=0
       i=i+1
       if (i .lt. bar()) goto 100
       
  end subroutine foo

Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]

  LOOP BEGIN  
      remark #15532: loop was not vectorized: compile time constraints prevent loop optimization. Consider using -O3.
 
  LOOP END

Resolution:

GOTO statements prevent vectorization since loop iteration count cannot be computed.

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O3 or /O2  /Qopt-report:2 ) states that loop was not vectorized since loop contains GOTO statement.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n) 
      implicit none 
      integer, intent(in)    :: n 
      real,    intent(inout) :: a(n) 
      integer, intent(in)    :: b(n) 
      integer:: i 
        
      do 500 i=1,n 
        goto (100,200,300,400,100,200) b(i) 
100     a(i) = 1. + a(i)**4 
        go to 500  
200     a(i) = 1. + log(a(i))
        go to 500
300     a(i) = 2. * a(i) 
        go to 500
400     a(i) = 1. - sin(a(i))**2
500   continue 

end subroutine foo

$ ifort -c -xavx f15534a.f90 -qopt-report-file=stderr -qopt-report-phase=vec

Report from: Vector optimizations [vec]

Non-optimizable loops:

LOOP BEGIN at f15534a.f90(8,10)

   remark #15534: loop was not vectorized: loop contains arithmetic if or computed goto. Consider using if-then-else statement.    [ f15534a.f90(9,9) ]

LOOP END

Resolution:

Complex flow control can prevent vectorization; rewriting the code using IF statements instead of a computed GO TO will get this loop vectorized:”

subroutine foo(a, b, n) 
      implicit none 
      integer, intent(in)    :: n 
      real,    intent(inout) :: a(n) 
      integer, intent(in)    :: b(n) 
      integer:: i 
        
      do i=1,n 
        if(b(i).eq.1 .or. b(I).eq.5) a(i) = 1. + a(i)**4 
        if(b(i).eq.2 .or. b(i).eq.6) a(i) = 1. + log(a(i))
        if(b(i).eq.3)                a(i) = 2. * a(i)
        if(b(i).eq.4)                a(i) = 1. - sin(a(i))**2           
      end do 

end subroutine foo

$ ifort -c -xavx f15534b.f90 -qopt-report-file=stderr -qopt-report-phase=vec

…

LOOP BEGIN at f15534b.f90(8,7)

<Peeled loop for vectorization>

LOOP END

LOOP BEGIN at f15534b.f90(8,7)

   remark #15300: LOOP WAS VECTORIZED

LOOP END

LOOP BEGIN at f15534b.f90(8,7)

<Remainder loop for vectorization>

LOOP END

The article you are looking for has been retired! Check out the FAQ Or ask in our Developer forums

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version  

Cause:

The vectorization report generated when using Visual Fortran Compiler's  flags and optimization options (/O2 /fpe:0 /Qopt-report:2) states that loop was not vectorized due to floating-point exception handling .

Example:

An example below will generate the following remark in optimization report:

subroutine foo (a, l, n)
       implicit none
       integer, intent(in) :: n
       double precision, intent(inout) :: a(n)
       integer :: l(n)
       integer :: i
       
       do i=1,n
           l(i) = mod(a(i), 1.0)
       end do
end subroutine foo

ifort -c /O2 /fpe:0 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15537.f90

(ifort -c -O2 -fpe=0 -qopt-report2  f15537.f90 for Linux)

 
Begin optimization report for: FOO

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15537.f90(8,8)
   remark #15537: loop was not vectorized: implied FP exception model prevents usage of SVML library needed for truncation or integer divide/remainder. Consider changing compiler flags and/or directives in the source to enable fast FP model and to mask FP exceptions   [ f15537.f90(9,19) ]
LOOP END

Resolution:

Masking FP exceptions /fpe:1 and setting a threshold for the vectorization of loops to 0  /Qvec-threshold:0 will get the loop vectorized:

ifort -c /O2 /fpe:1 /Qvec-threshold:0 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15537.f90

(ifort -c -O2 -fpe=1 -vec-threshold=0  -qopt-report2  f15537.f90 for Linux)

LOOP BEGIN  f15537.f90(8,8)

    remark #15300: LOOP WAS VECTORIZED
LOOP END

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options ( /O2 /Qopt-report:2 /Qopt-report-phase:vec ) states that loop was not vectorized due to vector dependence - outer loop depends on inner loop.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, n1, n)
        implicit none
        integer :: n, n1
        integer :: i, j
	real :: a(n,n1)
      
        do i=1,n
            a(j,i) = a(j-1,i)+1 
			  
            do j=1,n
                a(j,i) = a(j-1,i)+1       
            end do
        end do
end subroutine foo

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15541.f90

(ifort -c -O2 -qopt-report2  f15541.f90 for Linux)

Begin optimization report for: FOO

    Report from: Interprocedural optimizations [ipo]

INLINE REPORT: (FOO) [1] f15541.f90(1,12)

    Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]

LOOP BEGIN at f15541.f90(7,9)
   remark #15541: outer loop was not auto-vectorized: consider using SIMD directive

   LOOP BEGIN at f15541.f90(10,13)
   <Multiversioned v1>
      remark #25228: Loop multiversioned for Data Dependence
      remark #15344: loop was not vectorized: vector dependence prevents vectorization. First dependence is shown below. Use level 5 report for details
      remark #15346: vector dependence: assumed FLOW dependence between  line 11 and  line 11
      remark #25439: unrolled with remainder by 2
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 3
   LOOP END

   LOOP BEGIN at f15541.f90(10,13)
   <Remainder, Multiversioned v1>
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 1
   LOOP END

   LOOP BEGIN at f15541.f90(10,13)
   <Multiversioned v2>
      remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
      remark #25439: unrolled with remainder by 2
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 3
   LOOP END

   LOOP BEGIN at f15541.f90(10,13)
   <Remainder, Multiversioned v2>
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 1
   LOOP END
LOOP END

Resolution:

Using !DIR$ SIMD directive results in outer loop being vectorized, as shown:

subroutine foo(a, n1, n)
        implicit none
        integer :: n, n1
        integer :: i, j
	real :: a(n,n1)
      !DIR$ SIMD  
        do i=1,n
	  a(j,i) = a(j-1,i)+1 
			  
            do j=1,n
                a(j,i) = a(j-1,i)+1       
            end do
        end do
end subroutine foo

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15541.f90
(ifort -c -O2 -qopt-report2  f15541.f90 for Linux)

Begin optimization report for: FOO

    Report from: Interprocedural optimizations [ipo]

INLINE REPORT: (FOO) [1] f15541.f90(1,12)

    Report from: Loop nest, Vector & Auto-parallelization optimizations [loop, vec, par]

LOOP BEGIN at f15541.f90(7,9)
   remark #15301: SIMD LOOP WAS VECTORIZED

   LOOP BEGIN at f15541.f90(10,13)
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 1
   LOOP END
LOOP END

LOOP BEGIN at f15541.f90(7,9)
<Remainder loop for vectorization>

   LOOP BEGIN at f15541.f90(10,13)
      remark #25456: Number of Array Refs Scalar Replaced In Loop: 2
   LOOP END
LOOP END

Product Version: Intel® Visual Fortran Compiler XE 15.0 or a later version 

Cause:

When using Visual Fortran Compiler's optimization options ( /O2 /Qopt-report:2 /Qopt-report-phase:vec ) the vectorization report indicates that the outer loop was not vectorized since the inner loop was vectorized.

Example:

An example below will generate the following remark in optimization report:

program f15542
implicit none
integer, parameter :: N=25
real :: a(N,N)=1.0, b(N) 
integer :: i, j 

do j=1,N 
  do i=1,N 
     a(i,j) = a(i,j) * i 
  end do 
  b(j) = 1.0 
end do

print*, a(3,3), b(3) 
end program f15542 

ifort -c /O2 /Qopt-report:2 /Qopt-report-phase:vec /Qopt-report-file:stdout f15542.f90

(ifort -c -O2 -qopt-report2  f15542.f90 for Linux)

Begin optimization report for: F15542

    Report from: Vector optimizations [vec]

LOOP BEGIN at f15542.f90(7,1)
   remark #15542: loop was not vectorized: inner loop was already vectorized

   LOOP BEGIN at f15542.f90(8,3)
      remark #15300: LOOP WAS VECTORIZED
   LOOP END

LOOP END

Cause:

A function call inside the loop is preventing auto-vectorization.

Example:

Program foo 
    implicit none
    integer, parameter  :: nx = 100000000
    real(8)             :: x, xp, sumx
    integer             :: i
    interface
       real(8) function bar(x, xp) 
          real(8), intent(in) :: x, xp
       end
    end interface 
  
    sumx = 0.
    xp   = 1.

    do i = 1,nx
       x = 1.D-8*real(i,8)
       sumx = sumx + bar(x,xp)
    enddo

    print *, 'Sum =',sumx
      
end


real(8) function bar(x, xp) 
  implicit none
  real(8), intent(in) :: x, xp

  bar = 1. - 2.*(x-xp) + 3.*(x-xp)**2 - 1.5*(x-xp)**3  + 0.2*(x-xp)**4
  bar = bar / sqrt(x**2 + xp**2)
  
end  

> ifort -qopt-report-phase=vec -qopt-report-file=stderr  bar.f90 foo.f90

(  ifort /Qopt-report-phase:vec /Qopt-report-file:stderr  bar.f90 foo.f90  on  Windows*)

Non-optimizable loops:

LOOP BEGIN at foo.f90(18,5)
   remark #15543: loop was not vectorized: loop with function call not considered an optimization candidate.   [ foo.f90(17,22) ]
LOOP END

Resolution:

The loop and function call can be vectorized using the explicit vector programming capabilities of OpenMP 4.0 or Intel® Cilk™ Plus.

For example, adding an OpenMP DECLARE SIMD directive to the function bar() and compiling with -qopenmp-simd allows the compiler to generate a SIMD (vectorized) version of  bar() as well as a scalar version.  The same OpenMP directive must be added to the interface block for bar() inside program foo. The UNIFORM clause specifies that xp is a non-varying argument, i.e., it has the same value for each iteration of the loop in the caller that is being vectorized; thus x is the only vector argument. Without UNIFORM, the compiler would have to take account that xp could also be a vector argument.

real(8) function bar(x, xp) 
!$OMP DECLARE SIMD (bar) UNIFORM(xp)
  implicit none
  real(8), intent(in) :: x, xp

  bar = 1. - 2.*(x-xp) + 3.*(x-xp)**2 - 1.5*(x-xp)**3  + 0.2*(x-xp)**4
  bar = bar / sqrt(x**2 + xp**2)
  
end  

> ifort -qopenmp-simd -qopt-report-phase=vec -qopt-report-file=stderr bar.f90 foo.f90
...

remark #15301: FUNCTION WAS VECTORIZED   [ bar.f90(1,18) ]

Begin optimization report for: FOO

...

LOOP BEGIN at foo.f90(16,5)

   remark #15344: loop was not vectorized: vector dependence prevents vectorization. First dependence is shown below. Use level 5 report for details
   remark #15346: vector dependence: assumed OUTPUT dependence between  line 17 and  line 18
LOOP END

A vectorized version (actually, two) of function bar() has been generated; however, the loop inside foo has still not been vectorized. This is because the compiler sees dependencies between loop iterations carried by both x and sumx. The compiler could figure out unaided how to autovectorize a loop with just these dependencies, or a loop with just the function call, but not everything at once. We can instruct the compiler to vectorize the loop by providing a SIMD directive that specifies the properties of x and sumx:

Program foo 
    implicit none
    integer, parameter  :: nx = 100000000
    real(8)             :: x, xp, sumx
    integer             :: i

    interface
       real(8) function bar(x, xp) 
       !$OMP DECLARE SIMD (bar) UNIFORM(xp)
          real(8), intent(in) :: x, xp
       end
    end interface 
  
    sumx = 0.
    xp   = 1. 

    !$OMP SIMD  private(x)  reduction(+:sumx)
    do i = 1,nx
       x = 1.D-8*real(i,8)
       sumx = sumx + bar(x,xp)
    enddo

    print *, 'Sum =',sumx
      
end  

> ifort -qopenmp-simd -qopt-report-phase=vec -qopt-report-file=stderr bar.f90 foo.f90
...

remark #15301: FUNCTION WAS VECTORIZED   [ bar.f90(1,18) ]

...

LOOP BEGIN at foo.f90(17,5)
   remark #15301: OpenMP SIMD LOOP WAS VECTORIZED
LOOP END

The loop is now vectorized successfully; running and timing the program shows a speedup.

Note that if the DECLARE SIMD directive is omitted, the !$OMP SIMD directive will still cause the remaining parts of the loop in foo to be vectorized, but the call to bar() will be serialized, so any performance gain is likely to be small. In either case, the private and reduction clauses of this directive are mandatory; without them, the compiler will assume no loop-carried dependencies and results may be incorrect.

For small functions such as bar(), inlining may be a simpler and more efficient way to achieve vectorization of loops containing function calls. When the caller and callee are in separate source files, as above, the application should be built with interprocedural optimization (-ipo or /Qipo). When caller and callee are in the same source file, inlining of small functions is enabled by default at optimization levels of -O2 and above.

ifort -ipo -qopt-report-phase=vec -qopt-report-file=stderr  bar.f90 foo.f90

...

LOOP BEGIN at foo.f90(17,5)
   remark #15300: LOOP WAS VECTORIZED
LOOP END

Updated9/13/2018

Product Version:  Intel® Fortran Compiler 15.0 and above

Cause:

When a loop contains a conditional statement that controls the assignment of a scalar value AND the scalar value is referenced AFTER the loop exits. The vectorization report generated using Intel® Fortran Compiler's optimization and vectorization report options includes non-vectorized loop instance:

Windows* OS:  /O2  /Qopt-report:2  /Qopt-report-phase:vec    

Linux OS or OS X:  -O2 -qopt-report2  -qopt-report-phase=vec

Example:

An example below will generate the following remark in the optimization report:

subroutine f13379( a, b, n )  
  implicit none 
  integer, intent(in)               :: n
  integer, intent(in),  dimension(n) :: a
  integer, intent(out),dimension(n) :: b
   
  integer                           :: i, x=10  
   
!$omp simd  
  do i=1,n  
    if( a(i) > 0 ) then 
     x = i                    !...here is the scalar assignment 
    end if 
    b(i) = x  
  end do 
!... reference the scalar outside of the loop  
  write(*,*) "last value of x: ", x  
end subroutine f13379

$ ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f13379.f90

…

LOOP BEGIN at f13379.f90(12,3)

   remark #15316:simd loop was not vectorized: scalar assignment in simd loop is prohibited, consider private, lastprivate or reduction clauses 

   remark #15552: loop was not vectorized with "simd"

LOOP END

…

Resolution:

Using !$omp simd lastprivate(x)  instead of !$omp simd will have x initialized for each subroutine in executable code.

Example

subroutine f13379( a, b, n )  
  implicit none 
  integer, intent(in)               :: n
  integer, intent(in),  dimension(n) :: a
  integer, intent(out),dimension(n) :: b
   
  integer                           :: i, x=10  
   
!$omp simd lastprivate(x)  
  do i=1,n  
    if( a(i) > 0 ) then 
     x = i                    !...here is the scalar assignment 
    end if 
    b(i) = x  
  end do 
!... reference the scalar outside of the loop  
  write(*,*) "last value of x: ", x  
end subroutine f13379

$ ifort -c  -O2 -qopt-report2 -qopenmp-simd -qopt-report-file=stderr -qopt-report-phase=vec f13379.f90

Begin optimization report for: F13379

    Report from: Vector optimizations [vec]

LOOP BEGIN at f13379.f90(10,3)
   remark #15301: SIMD LOOP WAS VECTORIZED
LOOP END

The article you are looking for has been retired! Check out the FAQ Or ask in our Developer forums

The Intel® C++ Compiler and Intel® Fortran Compiler contain certain internal limits intended to prevent excessive memory usage or compile times for very large and/or complex compilation units. When such a limit is exceeded, some optimizations are skipped to reduce the memory footprint and compile time. In such cases, for the version 15.0 update 1 and later compilers, one of the following diagnostic remarks may be printed at the head of the optimization report:

remark #25463: Optimization for this routine was skipped to constrain compile time. Consider overriding limits (-qoverride-limits).

remark #25464: Some optimizations were skipped to constrain compile time. Consider overriding limits (-qoverride-limits).

Skipping some optimizations later in the optimization sequence will typically have less impact on performance than skipping optimization for an entire function. If memory footprint and compilation time are not a concern, or if you wish to make tests, the compiler may be asked to ignore the internal limits and continue optimizing by adding the command line switch -qoverride-limits (Linux* or OS X*) or /Qoverride-limits (Windows*). This may substantially increase compile time and/or memory usage. It is the user's responsibility to ensure that sufficient memory is available. This is not a general optimization switch; it should only be used where there is a specific need and is not recommended for inexperienced users.

Other possible ways to avoid restricting optimization due to internal limits include:

• Splitting up very large functions that trigger the diagnostic into two or more smaller functions;
• Reducing the number of functions with a single source file;
• Restricting the amount of interprocedural optimization (including inlining) between source files or within a source file;
• Disabling bounds checking. (Note that bounds checking is enabled by default for debug builds within Intel Visual Fortran). 
• Reducing the optimization level (e.g. from -O3 to -O2) either for the whole source file, or, by using the "optimize" pragma or directive, for the particular function within a source file. (See the compiler user and reference guide). 

Compiler versions earlier than 15.0 update 1 accept the -qoverride-limits (/Qoverride-limits) switch, but they do not print diagnostic remarks 25463 and 25464. 15.0 update 1 and later compilers print these remarks only if the optimization report is enabled, e.g. with -qopt-report or /Qopt-report.