Auto-vectorization has its limitations. The compiler must be conservative, and not make any assumptions or optimizations that could lead to different results from unoptimized code for any possible input data.

The auto-vectorizer can be more effective if the compiler is given hints through compiler directives, but whether or not a loop is vectorized still depends on the compiler’s internal analysis and the information available to it. Explicit Vector Programming is an attempt to remove that uncertainty: the programmer, using his knowledge of the application, can instruct the compiler to vectorize a loop.

The main features of explicit vector programming in Intel® Cilk™ Plus are array notation, SIMD enabled functions and the #pragma SIMD. OpenMP* 4.0 contains similar functionality, except for array notation.

To quickly learn Intel® Cilk™ Plus from a series of short videos, please see Vectorization Essentials. You may also find the article Explicit Vector Programming in Fortran useful.

• pragma SIMD and SIMD-enabled function samples
• Click on the sample name to see an in-depth description and source code.

  Sample Name	Program Domain/Area	Description	Target Platforms	OSes
  AOBench	Rendering	Approximates the reflection of light off non-reflective surfaces by ray-casting into the scene from the screen, and the once again from a collision point. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Binomial Lattice	Finance	Used to evaluate an American option, which can be redeemed any time between two dates. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Mandelbrot	Image Processing	A visually impressive iterative algorithm that checks the bounds of a complex (imaginary) number over iterations and plots the depth (number of iterations) on a complex plane. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  RTM Stencil	Stencil	Solve the wave equation using the finite difference method. This sample computes a 3-D 25-point stencil. Usage of Intel® Cilk™ Plus: cilk_spawn and #pragma simd	Desktop	Windows*; Linux*; OS X*

• Array notation samples
• Click on the sample name to see an in-depth description and source code.

  Sample Name	Program Domain/Area	Description	Target Platforms	OSes
  Averaging Filter	Image Processing	A commonly used filter in the field of image processing and is mainly used for removing any noise in a given image. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Black-Scholes Equation	Finance	Estimates the price of an option over time. Can be used to smartly hedge the option on its underlying assets, among many other applications. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Discrete Cosine Transforms (DCT)	Image Processing	DCT and Quantization are the first two steps in the JPEG compression standard. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Fluid Animate	Computational Fluid Dynamics	Simulate the flow of fluid in a container using the Smoothed-Particle Hydrodynamics model. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Monte Carlo	Finance	Utilizes Monte Carlo simulation to estimate the valuation of a swaption portfolio. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Sepia Filter	Image Processing	Converts a color image to a duotone image with a dark Brown-Gray color. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Shortest Path	Classic Algorithms	Dijkstra algorithm is a graph search algorithm that solves the single-source shortest path problem for a graph with non-negative edge path costs, producing a shortest path tree. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*

There are many features in the Intel Compilers, and we are only demonstrating the following features at the moment.

1. Automatic Vectorization
2. Profile-Guided Optimization (PGO)
3. Intel® Cilk™ Plus

Automatic Vectorization Samples

Profile-Guided Optimization (PGO) Samples

Intel® Cilk™ Plus Samples

Please check back frequently as more samples will be added in the future.

Hello,

I am trying to install the latest version of Intel Fortran on my brand new computer but the installer appears to get stuck at a point where it says "Starting pre_install.js". Any ideas? I have installed different versions of Intel Fortran many times in the past but never had this issue before. I have 64bit Windows 7 with Visual Studio 2010 Professional installed. I also installed .NET Framework 4.0 according to the installation instructions. I also have Java installed.

Thanks for any help.

Jon

I am having a problem when I try to test my fortran dll within the Visual Studio 2013 debugger.  My exe calls the dll, and the dll executes, but all of my breakpoints are ignored. So it is executing the code but I cannot debug the fortran code.  

My development environment has Visual Studio 2013 and Intel Parallel Studio XE 2015 installed.

The solution contains two projects.  Project 1 is a VC# application.  Project 2 is a Fortran dll.  I have tried identifying the startup Project as single startup and multiple startup (Project 1 action=start; Project 2 action=none) yet none of the changes have any effect on the recognition of the breakpoints within the dll.  I have tried placing the .pdb and .dll in the directory of the .exe; have tried placing the .pdb and .dll files within the project.  None of these approaches have worked.

I welcome your assistance.

thank you

Someone has asked me to write software for their MAC computer, and I dont know offhand whether I can find a debugger/compiler for that particular platform.

I was wondering if you know of any support for that situation.

BTW, when does my current license expire? I want to renew it before it does.

Intel® Cilk™ Plus is an extension to the C and C++ languages that supports both data and task parallelism. It uses an optimized work-stealing scheduler that provides efficient parallel task scheduling. It is very easy to learn with only 3 new keywords (cilk_spawn, cilk_sync, cilk_for) for task parallelism, #pragma simd, SIMD-enabled functions and array notation for data parallelism that utilizes SIMD hardware through vectorization. Intel® Cilk™ Plus is also supported by GNU* gcc, please visit https://www.cilkplus.org/ for detail information.

To quickly learn the Intel® Cilk™ Plus from a series of short videos, please see Vectorization Essentials

• Intel® Cilk™ Plus samples
• Click on the sample name to see an in-depth description and source code.

  Sample Name	Program Domain/Area	Description	Target Platforms	OSes
  AOBench	Rendering	Approximates the reflection of light off non-reflective surfaces by ray-casting into the scene from the screen, and the once again from a collision point. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Averaging Filter	Image Processing	A commonly used filter in the field of image processing and is mainly used for removing any noise in a given image. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Binomial Lattice	Finance	Used to evaluate an American option, which can be redeemed any time between two dates. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Black-Scholes Equation	Finance	Estimates the price of an option over time. Can be used to smartly hedge the option on its underlying assets, among many other applications. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  CilkSamples	Classic Algorithms	Illustrates parallel processing techniques using Intel® Cilk™ Plus. Host OS: Windows*, OS X* Target OS: Android*	Mobile	Android*
  Discrete Cosine Transforms (DCT)	Image Processing	DCT and Quantization are the first two steps in the JPEG compression standard. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Fluid Animate	Computational Fluid Dynamics	Simulate the flow of fluid in a container using the Smoothed-Particle Hydrodynamics model. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Mandelbrot	Image Processing	A visually impressive iterative algorithm that checks the bounds of a complex (imaginary) number over iterations and plots the depth (number of iterations) on a complex plane. Usage of Intel® Cilk™ Plus: cilk_for and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Merge Sort	Classic Algorithms	Merge sort algorithm is a comparison-based sorting algorithm. In this sample, we use top-down implementation, which recursively splits list into two halves (called sublists) until size of list is 1. Then merge these two sublists and produce a sorted list. Usage of Intel® Cilk™ Plus: cilk_spawn	Desktop	Windows*; Linux*; OS X*
  Monte Carlo	Finance	Utilizes Monte Carlo simulation to estimate the valuation of a swaption portfolio. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  RTM Stencil	Stencil	Solve the wave equation using the finite difference method. This sample computes a 3-D 25-point stencil. Usage of Intel® Cilk™ Plus: cilk_spawn and #pragma simd	Desktop	Windows*; Linux*; OS X*
  Sepia Filter	Image Processing	Converts a color image to a duotone image with a dark Brown-Gray color. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*
  Shortest Path	Classic Algorithms	Dijkstra algorithm is a graph search algorithm that solves the single-source shortest path problem for a graph with non-negative edge path costs, producing a shortest path tree. Usage of Intel® Cilk™ Plus: cilk_for and Array Notation	Desktop	Windows*; Linux*; OS X*

Please check back frequently as more samples will be added in the future.

Today's CPUs are highly parallel processors with different levels of parallelism. You may find parallelism everywhere from the parallel execution units in a CPU core, up to the Intel® Streaming SIMD Extensions (Intel SSE, SSE2, SSE3 and SSE4), and the Supplemental Streaming SIMD Extensions (SSSE3) instruction sets, and the Intel Advanced Vector Extension (Intel AVX) instruction set and the parallel execution of multiple threads. The SIMD instructions operate on multiple data elements in one instruction and make use of the full SIMD registers.

The automatic vectorization (auto-vectorization) is one of the key features of the Intel® compiler. The Intel® Compiler can automatically generate SIMD instructions, and will look for vectorization opportunities whenever you compile at default optimization (-O2) or higher.

Please visit the Support page for some useful information about auto-vectorization.

• Automatic vectorization samples
• Click on the sample name to see an in-depth description and source code.

  Sample Name	Program Domain/Area	Description	Target Platforms	OSes
  VecSample	Matrix Multiplications	Illustrates Auto-vectorization feature for loops. Host OS: Windows*, OS X* Target OS: Android*	Mobile	Android*

Please check back frequently as more samples will be added in the future.

Profile-guided Optimization (PGO) improves application performance by re-ordering code layout to reduce instruction-cache problems, shrinking code size, and reducing branch mispredictions. PGO provides information to the compiler about areas of an application that are most frequently executed so the compiler is able to be more selective and specific in optimizing the application.

PGO consists of three phases or steps:

1. Instrument the program: build the program using the compiler flag -prof-gen or /Qprof-gen
2. Run the instrumented executable to gather profiling data with various input data or workloads
3. Re-build the program with the profiling data using flag -prof-use or /Qprof-use

See Profile-Guided Optimizations Overview section in the User and Reference Guide for some useful information about PGO.

• Profile-guided optimization (PGO) samples
• Click on the sample name to see an in-depth description and source code.

  Sample Name	Program Domain/Area	Description	Target Platforms	OSes
  Fluid Animate with Profile Guided Optimization (PGO)	Computational Fluid Dynamics	Simulate the flow of fluid in a container using the Smoothed-Particle Hydrodynamics model. Usage of Intel® C++ compiler PGO optimization Usage of Intel® Cilk™ Plus: Array Notation	Desktop	Windows*; Linux*; OS X*

Please check back frequently as more samples will be added in the future.

This page contains all the samples sorted by sample name. Click on the sample name to see an in-depth description and source code.

In my code, there is a data container module that includes allocatable arrays. 

The main subroutine, calls a subroutine to initialize the arrays. Both main subroutine and initialize subroutines, use the data_container module. 

The problem is that after the arrays are initialized, the main subruotine, does not see the initialization of the array:

module data_container
real (8), dimension (:), allocatable:: A
end module data_container

subroutine initialize
use data_container
allocate (A(10))
end subroutine initialize

recursive subroutine main_subroutine
use data_container
call initialize

end subroutine main_subroutine

The real program is more complicated and the array is a complex data type. 

Thanks,

Alireza

It looks like the VS is tying up the EXE longer than it need to - - 

Error    1     general error c101008d: Failed to write the updated manifest to the resource of file "d:\william data\my documents\visual studio 2010\Projects\ransk\Debug\ransk.exe". The process cannot access the file because it is being used by another process.    mt.exe  

I was used a Intel Visual Fortran 11.1 until December 31st.
but I can't start it at January 2nd.
When I start Microsoft Visual Studio 2010 Shell, there comes an error message saying " Invalid license data. Reinstall is required"

Please find out why.

Hi.

I'm trying to install Fortran 6.0 on win XP 32 bit. At the end of the installation it says that it cannot create the folder"Comaq visual fortran 6" and the installation stops.

I tried, then, to create the folder manually as it suggests but the same problem persists.

What can I do?

This routine was (until I fixed it) was generating a breakpoint when it read a line from LGU 3.

It did tell me where the breakpoint was in the output file, but the debug arrow pointed to somewhere else in the program

that didn't even any I/O statements. In fact it pointed to the END of a routine that had nothing to do with this one at all.

also when it generates the breakpoint, it will not identify any symbols within this routine when I put the cursor on them.

Apparently the debugger does not generate the correct info regarding WHERE the breakpoint occurred, even though

the output file DOES have the correct information.

Any clues as to why this might occur? Apparently the interaction between the I/O library and the debugger is messed up.

If I need to upload the whole program to isolate this, I can do so.

I stopped getting e-mail with these posts on Dec 2, so haven't kept track

of what is going on. But here is an ICE--maybe submitted previously.

ifort -c int*

Intel(R) Visual Fortran Intel(R) 64 Compiler XE for applications running on Intel(R) 64, Version 15.

0.1.148 Build 20141023

Copyright (C) 1985-2014 Intel Corporation.  All rights reserved.

intel_bug.f90(32): error #5276: Unbalanced parentheses

   x = line_type(0.0, 1.0, 0.0, 1.0))

------------------------------------^

intel_bug.f90(32): error #5082: Syntax error, found ')' when expecting one of: <END-OF-STATEMENT> ;

   x = line_type(0.0, 1.0, 0.0, 1.0))

------------------------------------^

intel_bug.f90(32): error #8726: There may be at most one type parameter spec corresponding to each p

arameter of the type.   [0.0]

   x = line_type(0.0, 1.0, 0.0, 1.0))

-----------------^

fortcom: Fatal: There has been an internal compiler error (C0000005).

compilation aborted for intel_bug.f90 (code 1)

======================

module m

   implicit none

   private

   type, public :: line_type

      real :: x1, x2, y1, y2

   contains

      procedure, public :: length

   end type line_type

contains

function length(ab) result(length_result)

   class(line_type), intent(in) :: ab

   real :: length_result

   length_result = 1.1

end function length

end module m

program p

   use m

   implicit none

   class(line_type), allocatable :: x

! Note extra paren at end

   x = line_type(0.0, 1.0, 0.0, 1.0))

   print *, x%length() 

end program p

I’m OS X user. I installed fgsl by homebrew. I succeed to compile fgsl example file by gnu compiler. but, fail to do by intel compiler. 

error message: 

error #7013: This module file was not generated by any release of this compiler.   [FGSL]

  use fgsl

Is there anyone who knows it? 

With ifort 15.0.0 for Linux, I've encountered an issue where images >= 2 are
unable to access (read) a coarray with cosubscript 1 until image 1 encounters
a subsequent image control statement. Since I'm quite new to coarrays, I'd
like to know if I'm misunderstanding a subtlety regarding possible coarray
behavior, or if this behavior is unexpected:

The following program demonstrates the issue:

program test_coarray
   implicit none
   integer :: i, X(2,2)[*]
   double precision :: time, val = 1.0

   if (THIS_IMAGE() == 1) then
      X = 1
      SYNC IMAGES(*)
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': after first sync', time
      do i = 1,2**30
         val = val + COS(DBLE(i))
      end do
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': before second sync', time
      SYNC IMAGES(*)
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': after second sync', time
   else
      SYNC IMAGES(1)
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': after first sync', time
      X = X[1]
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': before second sync', time
      SYNC IMAGES(1)
      call CPU_TIME(time)
      write (*,*) THIS_IMAGE(), ': after second sync', time
   end if
   call cpu_time(time)
   write (*,*) THIS_IMAGE(), 'finished:', time, 'result:', SUM(X)+val

end program test_coarray

Images 2-4 apparenlty don't complete the read of X[1] until after image 1 has
reached the second SYNC IMAGES:

$ ifort -coarray=shared -coarray-num-images=4 test_coarray.f90
$ ./a.out
           1 : after first sync  9.998000000000000E-003
           2 : after first sync  1.099700000000000E-002
           3 : after first sync  1.099700000000000E-002
           4 : after first sync  1.099700000000000E-002
           1 : before second sync   14.7887510000000
           1 : after second sync   14.7887510000000
           2 : before second sync   14.7897500000000
           2 : after second sync   14.7897500000000
           2 finished:   14.7897500000000      result:   5.00000000000000
           3 : before second sync   14.7907500000000
           3 : after second sync   14.7907500000000
           4 : before second sync   14.7897500000000
           4 : after second sync   14.7897500000000
           4 finished:   14.7897500000000      result:   5.00000000000000
           1 finished:   14.7887510000000      result:   4.32834934995579
           3 finished:   14.7907500000000      result:   5.00000000000000

My program calls an external subroutine with a single argument of type derived. There is no explicit interface. The declaration of the actual argument in the program is identical to the declaration of the dummy argument in the subroutine. Nevertheless, the compiler gives an error "The type of the actual argument does not match the type of the dummy argument" when /warn:interfaces is in effect (as it is by default). Why? Is this expected? It does not happen when the argument is a simple variable.

I can get around this by providing an explicit interface, or putting the subroutine in a module, but there may be reasons to prefer the more primitive traditional form. I would like to better understand why the compiler behavior is different when the argument is of a derived type. Is it documented?

The following code is generating a segmentation fault during the call to QSORT.  It appears QSORT is calling the routine COMPARE without assigning a value to arg1. I tried adding USE IFPORT to the main routine but this did not solve the problem.  This identical code worked without errors on another UNIX system.  I have compiled the code using Intel Compiler Version 2013 SP1 Update 4 and Intel Compiler Version 2015 Update 1 without success. I am running on RHEL 6.6.  Any ideas?   Thanks...

      SUBROUTINE BuildArray(array_values,number_values,min_value,max_value,delta_value,special_array,n_special_array)

      IMPLICIT NONE
C     ..
C     .. Scalar Arguments ..
      DOUBLE PRECISION min_value,max_value,delta_value
      INTEGER number_values,n_special_array
C     ..
C     .. Array Arguments ..
      DOUBLE PRECISION array_values(2000),special_array(10)
C     ..
C     .. Local Scalars ..
      INTEGER J,K
C     ..
C     .. External Functions ..
      EXTERNAL QSORT,Compare
      INTEGER*2 Compare
C     ..
C     .. Executable Statements ..

      number_values = (INT((max_value - min_value) / delta_value) + 1)

      DO J=1,number_values
          array_values(J) = min_value + DBLE(J-1) * delta_value
      END DO

      DO J=1,n_special_array
         K = number_values + J
         array_values(K) = special_array(J)
      END DO

      number_values = number_values + n_special_array

      CALL QSORT(array_values,number_values,8,Compare)

      RETURN
      END
      INTEGER*2 FUNCTION Compare(arg1,arg2)

      IMPLICIT NONE
C     ..
C     .. Scalar Arguments ..
      DOUBLE PRECISION arg1,arg2
C     ..
C     .. Executable Statements ..
C
      IF(arg1.LT.arg2) THEN
          Compare = -1
      ELSE IF(arg1.EQ.arg2) THEN
          Compare = 0
      ELSE IF(arg1.GT.arg2) THEN
          Compare = 1
      ENDIF

      RETURN
      END

Hi all,

Is there any intel® fortran composer xe for linux* for non-commercial use available for registration and download now? I am a graduate student and have recently installed my new computer with fedora 20. We have been using the intel® fortran composer xe 2013 version for old computers but the registration is no longer valid now.

Please advise!

Thanks!

Best regards,

Elizabeth