suktmig2d_OpenMP.optrpt

Intel(R) Advisor can now assist with vectorization and show optimization
  report messages with your source code.
See "https://software.intel.com/en-us/intel-advisor-xe" for details.

Intel(R) C Intel(R) 64 Compiler for applications running on Intel(R) 64, Version 18.0.1.163 Build 20171018

Compiler options: -I/home/rprado/cwp/include -g -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -DCWP_LITTLE_ENDIAN -DSUXDR -D_BSD_SOURCE -D_POSIX_SOURCE -O3 -L/home/rprado/cwp/lib -lsu -lpar -lcwp -lm -qopenmp -xcore-avx2 -prec-div -no-fma -qopt-report-phase=vec,openmp -qopt-report=5 -o suktmig2d_OpenMP

Begin optimization report for: main(int, char **)

    Report from: OpenMP optimizations [openmp]

OpenMP Construct at suktmig2d_OpenMP.c(364,1) inlined into suktmig2d_OpenMP.c(302,3)
remark #16201: OpenMP DEFINED REGION WAS PARALLELIZED

    Report from: Vector optimizations [vec]


LOOP BEGIN at suktmig2d_OpenMP.c(181,2)
<Peeled loop for vectorization>
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(181,2)
   remark #15389: vectorization support: reference fc[i] has unaligned access   [ suktmig2d_OpenMP.c(182,3) ]
   remark #15381: vectorization support: unaligned access used inside loop body
   remark #15305: vectorization support: vector length 8
   remark #15399: vectorization support: unroll factor set to 2
   remark #15309: vectorization support: normalized vectorization overhead 0.171
   remark #15300: LOOP WAS VECTORIZED
   remark #15442: entire loop may be executed in remainder
   remark #15451: unmasked unaligned unit stride stores: 1 
   remark #15475: --- begin vector cost summary ---
   remark #15476: scalar cost: 34 
   remark #15477: vector cost: 4.750 
   remark #15478: estimated potential speedup: 5.700 
   remark #15486: divides: 1 
   remark #15487: type converts: 1 
   remark #15488: --- end vector cost summary ---
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(181,2)
<Remainder loop for vectorization>
   remark #15389: vectorization support: reference fc[i] has unaligned access   [ suktmig2d_OpenMP.c(182,3) ]
   remark #15381: vectorization support: unaligned access used inside loop body
   remark #15305: vectorization support: vector length 4
   remark #15309: vectorization support: normalized vectorization overhead 0.390
   remark #15301: REMAINDER LOOP WAS VECTORIZED
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(181,2)
<Remainder loop for vectorization>
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(199,3)
   remark #15521: loop was not vectorized: loop control variable was not identified. Explicitly compute the iteration count before executing the loop or try using canonical loop form from OpenMP specification
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(295,3)
   remark #15382: vectorization support: call to function efread(void *, size_t, size_t, FILE *) cannot be vectorized   [ suktmig2d_OpenMP.c(296,4) ]
   remark #15344: loop was not vectorized: vector dependence prevents vectorization
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(305,3)
   remark #15382: vectorization support: call to function efread(void *, size_t, size_t, FILE *) cannot be vectorized   [ suktmig2d_OpenMP.c(306,4) ]
   remark #15382: vectorization support: call to function ?1memcpy cannot be vectorized   [ suktmig2d_OpenMP.c(307,4) ]
   remark #15382: vectorization support: call to function fputtr(FILE *, segy *) cannot be vectorized   [ suktmig2d_OpenMP.c(310,4) ]
   remark #15344: loop was not vectorized: vector dependence prevents vectorization

   LOOP BEGIN at suktmig2d_OpenMP.c(307,4)
      remark #15398: loop was not vectorized: loop was transformed to memset or memcpy

      LOOP BEGIN at suktmig2d_OpenMP.c(307,4)
      <Multiversioned v2>
         remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(307,4)
      <Remainder, Multiversioned v2>
      LOOP END
   LOOP END
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(396,2) inlined into suktmig2d_OpenMP.c(302,3)
   remark #15542: loop was not vectorized: inner loop was already vectorized

   LOOP BEGIN at suktmig2d_OpenMP.c(406,3) inlined into suktmig2d_OpenMP.c(302,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(406,3) inlined into suktmig2d_OpenMP.c(302,3)
         remark #15389: vectorization support: reference rtin[it] has unaligned access   [ suktmig2d_OpenMP.c(407,4) ]
         remark #15389: vectorization support: reference *(*(*data+(imp+imp-1)*8)+(it-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(407,13) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 8
         remark #15309: vectorization support: normalized vectorization overhead 1.000
         remark #15300: LOOP WAS VECTORIZED
         remark #15450: unmasked unaligned unit stride loads: 1 
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 5 
         remark #15477: vector cost: 0.750 
         remark #15478: estimated potential speedup: 5.000 
         remark #15488: --- end vector cost summary ---
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(406,3) inlined into suktmig2d_OpenMP.c(302,3)
      <Remainder loop for vectorization>
      LOOP END
   LOOP END

   LOOP BEGIN at suktmig2d_OpenMP.c(411,3) inlined into suktmig2d_OpenMP.c(302,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(302,3)
      <Peeled loop for vectorization, Distributed chunk1>
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(302,3)
      <Distributed chunk1>
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(751,3) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 4
         remark #15399: vectorization support: unroll factor set to 2
         remark #15309: vectorization support: normalized vectorization overhead 1.833
         remark #15301: PARTIAL LOOP WAS VECTORIZED
         remark #15442: entire loop may be executed in remainder
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 32 
         remark #15477: vector cost: 0.750 
         remark #15478: estimated potential speedup: 26.590 
         remark #15488: --- end vector cost summary ---
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(302,3)
      <Remainder loop for vectorization, Distributed chunk1>
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(302,3)
      <Distributed chunk2>
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 4
         remark #15309: vectorization support: normalized vectorization overhead 0.049
         remark #15301: PARTIAL LOOP WAS VECTORIZED
         remark #15450: unmasked unaligned unit stride loads: 1 
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 401 
         remark #15477: vector cost: 86.750 
         remark #15478: estimated potential speedup: 4.610 
         remark #15482: vectorized math library calls: 1 
         remark #15487: type converts: 4 
         remark #15488: --- end vector cost summary ---

         LOOP BEGIN at suktmig2d_OpenMP.c(754,3) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15344: loop was not vectorized: vector dependence prevents vectorization
            remark #15346: vector dependence: assumed OUTPUT dependence between filter[i] (757:4) and filter[i] (757:4)
            remark #15346: vector dependence: assumed OUTPUT dependence between filter[i] (757:4) and filter[i] (757:4)
            remark #15548: loop was vectorized along with the outer loop
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(302,3)
      <Remainder loop for vectorization, Distributed chunk2>

         LOOP BEGIN at suktmig2d_OpenMP.c(754,3) inlined into suktmig2d_OpenMP.c(302,3)
            remark #25460: No loop optimizations reported
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(417,4) inlined into suktmig2d_OpenMP.c(302,3)
         remark #15382: vectorization support: call to function crmul(complex, float) cannot be vectorized   [ suktmig2d_OpenMP.c(418,27) ]
         remark #15344: loop was not vectorized: vector dependence prevents vectorization
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(422,4) inlined into suktmig2d_OpenMP.c(302,3)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(422,4) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15389: vectorization support: reference *(*(lowpass+ifc*8)+(it-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(423,5) ]
            remark #15389: vectorization support: reference rtout[it] has unaligned access   [ suktmig2d_OpenMP.c(423,23) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 1 
            remark #15451: unmasked unaligned unit stride stores: 1 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 5 
            remark #15477: vector cost: 0.750 
            remark #15478: estimated potential speedup: 5.000 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(422,4) inlined into suktmig2d_OpenMP.c(302,3)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END
   LOOP END

   LOOP BEGIN at suktmig2d_OpenMP.c(428,3) inlined into suktmig2d_OpenMP.c(302,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(439,8) inlined into suktmig2d_OpenMP.c(302,3)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(471,6) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15542: loop was not vectorized: inner loop was already vectorized

            LOOP BEGIN at suktmig2d_OpenMP.c(471,6) inlined into suktmig2d_OpenMP.c(302,3)
               remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(472,7) ]
               remark #15389: vectorization support: reference *(*(lowpass+nc*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(472,21) ]
               remark #15381: vectorization support: unaligned access used inside loop body
               remark #15305: vectorization support: vector length 8
               remark #15309: vectorization support: normalized vectorization overhead 1.000
               remark #15300: LOOP WAS VECTORIZED
               remark #15450: unmasked unaligned unit stride loads: 1 
               remark #15451: unmasked unaligned unit stride stores: 1 
               remark #15475: --- begin vector cost summary ---
               remark #15476: scalar cost: 4 
               remark #15477: vector cost: 0.750 
               remark #15478: estimated potential speedup: 4.000 
               remark #15488: --- end vector cost summary ---
            LOOP END

            LOOP BEGIN at suktmig2d_OpenMP.c(471,6) inlined into suktmig2d_OpenMP.c(302,3)
            <Remainder loop for vectorization>
            LOOP END
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(477,6) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(478,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(478,21) ]
            remark #15389: vectorization support: reference datahi[k-?] has unaligned access   [ suktmig2d_OpenMP.c(479,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(479,21) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 2 
            remark #15451: unmasked unaligned unit stride stores: 2 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 8 
            remark #15477: vector cost: 1.500 
            remark #15478: estimated potential speedup: 2.660 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(477,6) inlined into suktmig2d_OpenMP.c(302,3)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(488,4) inlined into suktmig2d_OpenMP.c(302,3)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(530,6) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15542: loop was not vectorized: inner loop was already vectorized

            LOOP BEGIN at suktmig2d_OpenMP.c(530,6) inlined into suktmig2d_OpenMP.c(302,3)
               remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(531,7) ]
               remark #15389: vectorization support: reference *(*(lowpass+nc*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(531,21) ]
               remark #15381: vectorization support: unaligned access used inside loop body
               remark #15305: vectorization support: vector length 8
               remark #15309: vectorization support: normalized vectorization overhead 1.000
               remark #15300: LOOP WAS VECTORIZED
               remark #15450: unmasked unaligned unit stride loads: 1 
               remark #15451: unmasked unaligned unit stride stores: 1 
               remark #15475: --- begin vector cost summary ---
               remark #15476: scalar cost: 4 
               remark #15477: vector cost: 0.750 
               remark #15478: estimated potential speedup: 4.000 
               remark #15488: --- end vector cost summary ---
            LOOP END

            LOOP BEGIN at suktmig2d_OpenMP.c(530,6) inlined into suktmig2d_OpenMP.c(302,3)
            <Remainder loop for vectorization>
            LOOP END
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(536,6) inlined into suktmig2d_OpenMP.c(302,3)
            remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(537,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+fplo*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(537,21) ]
            remark #15389: vectorization support: reference datahi[k-?] has unaligned access   [ suktmig2d_OpenMP.c(538,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(538,21) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 2 
            remark #15451: unmasked unaligned unit stride stores: 2 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 8 
            remark #15477: vector cost: 1.500 
            remark #15478: estimated potential speedup: 2.660 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(536,6) inlined into suktmig2d_OpenMP.c(302,3)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END
   LOOP END
LOOP END


Non-optimizable loops:


LOOP BEGIN at suktmig2d_OpenMP.c(194,2)
   remark #15533: loop was not vectorized: loop exceeds complexity limits. Consider overriding limits (-override-limits) or using simd directive.
LOOP END
===========================================================================

Begin optimization report for: migkt2d(float **, int, int, float, float, float, int, float, float, float *, int, int, int, int, float, float **, float **, int, int)

    Report from: OpenMP optimizations [openmp]

OpenMP Construct at suktmig2d_OpenMP.c(364,1)
remark #16201: OpenMP DEFINED REGION WAS PARALLELIZED

    Report from: Vector optimizations [vec]


LOOP BEGIN at suktmig2d_OpenMP.c(396,2)
   remark #15542: loop was not vectorized: inner loop was already vectorized

   LOOP BEGIN at suktmig2d_OpenMP.c(406,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(406,3)
         remark #15389: vectorization support: reference rtin[it] has unaligned access   [ suktmig2d_OpenMP.c(407,4) ]
         remark #15389: vectorization support: reference *(*(data+(imp+imp-1)*8)+(it-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(407,13) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 8
         remark #15309: vectorization support: normalized vectorization overhead 1.000
         remark #15300: LOOP WAS VECTORIZED
         remark #15450: unmasked unaligned unit stride loads: 1 
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 5 
         remark #15477: vector cost: 0.750 
         remark #15478: estimated potential speedup: 5.000 
         remark #15488: --- end vector cost summary ---
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(406,3)
      <Remainder loop for vectorization>
      LOOP END
   LOOP END

   LOOP BEGIN at suktmig2d_OpenMP.c(411,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(414,4)
      <Peeled loop for vectorization, Distributed chunk1>
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(414,4)
      <Distributed chunk1>
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(751,3) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 4
         remark #15399: vectorization support: unroll factor set to 2
         remark #15309: vectorization support: normalized vectorization overhead 1.833
         remark #15301: PARTIAL LOOP WAS VECTORIZED
         remark #15442: entire loop may be executed in remainder
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 32 
         remark #15477: vector cost: 0.750 
         remark #15478: estimated potential speedup: 26.590 
         remark #15488: --- end vector cost summary ---
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(414,4)
      <Remainder loop for vectorization, Distributed chunk1>
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(414,4)
      <Distributed chunk2>
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
         remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
         remark #15381: vectorization support: unaligned access used inside loop body
         remark #15305: vectorization support: vector length 4
         remark #15309: vectorization support: normalized vectorization overhead 0.049
         remark #15301: PARTIAL LOOP WAS VECTORIZED
         remark #15450: unmasked unaligned unit stride loads: 1 
         remark #15451: unmasked unaligned unit stride stores: 1 
         remark #15475: --- begin vector cost summary ---
         remark #15476: scalar cost: 401 
         remark #15477: vector cost: 86.750 
         remark #15478: estimated potential speedup: 4.610 
         remark #15482: vectorized math library calls: 1 
         remark #15487: type converts: 4 
         remark #15488: --- end vector cost summary ---

         LOOP BEGIN at suktmig2d_OpenMP.c(754,3) inlined into suktmig2d_OpenMP.c(414,4)
            remark #15344: loop was not vectorized: vector dependence prevents vectorization
            remark #15346: vector dependence: assumed OUTPUT dependence between filter[i] (757:4) and filter[i] (757:4)
            remark #15346: vector dependence: assumed OUTPUT dependence between filter[i] (757:4) and filter[i] (757:4)
            remark #15548: loop was vectorized along with the outer loop
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(750,2) inlined into suktmig2d_OpenMP.c(414,4)
      <Remainder loop for vectorization, Distributed chunk2>

         LOOP BEGIN at suktmig2d_OpenMP.c(754,3) inlined into suktmig2d_OpenMP.c(414,4)
            remark #25460: No loop optimizations reported
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(417,4)
         remark #15382: vectorization support: call to function crmul(complex, float) cannot be vectorized   [ suktmig2d_OpenMP.c(418,27) ]
         remark #15344: loop was not vectorized: vector dependence prevents vectorization
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(422,4)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(422,4)
            remark #15389: vectorization support: reference *(*(lowpass+ifc*8)+(it-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(423,5) ]
            remark #15389: vectorization support: reference rtout[it] has unaligned access   [ suktmig2d_OpenMP.c(423,23) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 1 
            remark #15451: unmasked unaligned unit stride stores: 1 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 5 
            remark #15477: vector cost: 0.750 
            remark #15478: estimated potential speedup: 5.000 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(422,4)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END
   LOOP END

   LOOP BEGIN at suktmig2d_OpenMP.c(428,3)
      remark #15542: loop was not vectorized: inner loop was already vectorized

      LOOP BEGIN at suktmig2d_OpenMP.c(439,8)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(471,6)
            remark #15542: loop was not vectorized: inner loop was already vectorized

            LOOP BEGIN at suktmig2d_OpenMP.c(471,6)
               remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(472,7) ]
               remark #15389: vectorization support: reference *(*(lowpass+nc*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(472,21) ]
               remark #15381: vectorization support: unaligned access used inside loop body
               remark #15305: vectorization support: vector length 8
               remark #15309: vectorization support: normalized vectorization overhead 1.000
               remark #15300: LOOP WAS VECTORIZED
               remark #15450: unmasked unaligned unit stride loads: 1 
               remark #15451: unmasked unaligned unit stride stores: 1 
               remark #15475: --- begin vector cost summary ---
               remark #15476: scalar cost: 4 
               remark #15477: vector cost: 0.750 
               remark #15478: estimated potential speedup: 4.000 
               remark #15488: --- end vector cost summary ---
            LOOP END

            LOOP BEGIN at suktmig2d_OpenMP.c(471,6)
            <Remainder loop for vectorization>
            LOOP END
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(477,6)
            remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(478,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(478,21) ]
            remark #15389: vectorization support: reference datahi[k-?] has unaligned access   [ suktmig2d_OpenMP.c(479,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(479,21) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 2 
            remark #15451: unmasked unaligned unit stride stores: 2 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 8 
            remark #15477: vector cost: 1.500 
            remark #15478: estimated potential speedup: 2.660 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(477,6)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END

      LOOP BEGIN at suktmig2d_OpenMP.c(488,4)
         remark #15542: loop was not vectorized: inner loop was already vectorized

         LOOP BEGIN at suktmig2d_OpenMP.c(530,6)
            remark #15542: loop was not vectorized: inner loop was already vectorized

            LOOP BEGIN at suktmig2d_OpenMP.c(530,6)
               remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(531,7) ]
               remark #15389: vectorization support: reference *(*(lowpass+nc*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(531,21) ]
               remark #15381: vectorization support: unaligned access used inside loop body
               remark #15305: vectorization support: vector length 8
               remark #15309: vectorization support: normalized vectorization overhead 1.000
               remark #15300: LOOP WAS VECTORIZED
               remark #15450: unmasked unaligned unit stride loads: 1 
               remark #15451: unmasked unaligned unit stride stores: 1 
               remark #15475: --- begin vector cost summary ---
               remark #15476: scalar cost: 4 
               remark #15477: vector cost: 0.750 
               remark #15478: estimated potential speedup: 4.000 
               remark #15488: --- end vector cost summary ---
            LOOP END

            LOOP BEGIN at suktmig2d_OpenMP.c(530,6)
            <Remainder loop for vectorization>
            LOOP END
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(536,6)
            remark #15389: vectorization support: reference datalo[k-?] has unaligned access   [ suktmig2d_OpenMP.c(537,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+fplo*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(537,21) ]
            remark #15389: vectorization support: reference datahi[k-?] has unaligned access   [ suktmig2d_OpenMP.c(538,7) ]
            remark #15389: vectorization support: reference *(*(lowpass+(fplo+1)*8)+(k+?-1)*4) has unaligned access   [ suktmig2d_OpenMP.c(538,21) ]
            remark #15381: vectorization support: unaligned access used inside loop body
            remark #15305: vectorization support: vector length 8
            remark #15309: vectorization support: normalized vectorization overhead 1.000
            remark #15300: LOOP WAS VECTORIZED
            remark #15450: unmasked unaligned unit stride loads: 2 
            remark #15451: unmasked unaligned unit stride stores: 2 
            remark #15475: --- begin vector cost summary ---
            remark #15476: scalar cost: 8 
            remark #15477: vector cost: 1.500 
            remark #15478: estimated potential speedup: 2.660 
            remark #15488: --- end vector cost summary ---
         LOOP END

         LOOP BEGIN at suktmig2d_OpenMP.c(536,6)
         <Remainder loop for vectorization>
         LOOP END
      LOOP END
   LOOP END
LOOP END
===========================================================================

Begin optimization report for: lpfilt(int, int, float, float, float *)

    Report from: Vector optimizations [vec]


LOOP BEGIN at suktmig2d_OpenMP.c(750,2)
<Peeled loop for vectorization, Distributed chunk1>
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(750,2)
<Distributed chunk1>
   remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(751,3) ]
   remark #15381: vectorization support: unaligned access used inside loop body
   remark #15305: vectorization support: vector length 4
   remark #15399: vectorization support: unroll factor set to 2
   remark #15309: vectorization support: normalized vectorization overhead 1.833
   remark #15301: PARTIAL LOOP WAS VECTORIZED
   remark #15442: entire loop may be executed in remainder
   remark #15451: unmasked unaligned unit stride stores: 1 
   remark #15475: --- begin vector cost summary ---
   remark #15476: scalar cost: 32 
   remark #15477: vector cost: 0.750 
   remark #15478: estimated potential speedup: 26.590 
   remark #15488: --- end vector cost summary ---
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(750,2)
<Remainder loop for vectorization, Distributed chunk1>
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(750,2)
<Distributed chunk2>
   remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
   remark #15389: vectorization support: reference filter[i] has unaligned access   [ suktmig2d_OpenMP.c(757,4) ]
   remark #15381: vectorization support: unaligned access used inside loop body
   remark #15305: vectorization support: vector length 4
   remark #15309: vectorization support: normalized vectorization overhead 0.049
   remark #15301: PARTIAL LOOP WAS VECTORIZED
   remark #15450: unmasked unaligned unit stride loads: 1 
   remark #15451: unmasked unaligned unit stride stores: 1 
   remark #15475: --- begin vector cost summary ---
   remark #15476: scalar cost: 401 
   remark #15477: vector cost: 86.750 
   remark #15478: estimated potential speedup: 4.610 
   remark #15482: vectorized math library calls: 1 
   remark #15487: type converts: 4 
   remark #15488: --- end vector cost summary ---

   LOOP BEGIN at suktmig2d_OpenMP.c(754,3)
      remark #15344: loop was not vectorized: vector dependence prevents vectorization
      remark #15346: vector dependence: assumed FLOW dependence between filter[i] (757:4) and filter[i] (757:4)
      remark #15346: vector dependence: assumed ANTI dependence between filter[i] (757:4) and filter[i] (757:4)
      remark #15548: loop was vectorized along with the outer loop
   LOOP END
LOOP END

LOOP BEGIN at suktmig2d_OpenMP.c(750,2)
<Remainder loop for vectorization, Distributed chunk2>

   LOOP BEGIN at suktmig2d_OpenMP.c(754,3)
      remark #25460: No loop optimizations reported
   LOOP END
LOOP END
===========================================================================