Intel Software Network articles feed http://software.intel.com/en-us/articles/intel-c-compiler-for-mac-os-x-kb/performance-and-optimization/ en-us Performance Tools for Software Developers - Loop blocking Loop blocking is a combination of strip mining and loop interchange to enhance reuse of local data. It helps the nested loops that manipulate arrays and are too large to fit into the cache. The loop blocking allows reuse of the arrays by transforming the loops such that the transformed loops manipulate array strips that fit into the cache. In effect, a blocked loop uses array elements in sections that are optimally sized to fit in the cache.

 

Use cache blocking to arrange a loop so it will perform as many computations as possible on data already residing in cache. (The next block of data is not read into cache until computations using the first block are finished.)

The loop blocking optimization is part of HLO phase in Intel compiler and is available when using compiler option -O3. The compiler uses default heuristics for loop blocking. But you may also use /Qopt-block-factor:n in Windows or -opt-block-factor:n in Linux to specify loop blocking factor.

Data reuse:

Data reuse is important to understand blocking. There are two types of data reuse associated with loop blocking:

  • Spatial reuse
  • Temporal reuse

 

Spatial reuse

Spatial reuse uses data that was encached as a result of fetching another piece of data from memory. The data is fetched one cache lines at a time. This is 64 bytes for Intel(R) Core2 processors. If the requested data is located at the beginning of the cache line (aligned data), and the rest of the cache line contains subsequent array elements then for float array, this means the requested element and the seven following elements are cached on each fetch after the first. If any of these seven elements could then be used on any subsequent iterations of the loop, the loop would be exploiting spatial reuse. For loops with strides greater than one, spatial reuse can still occur. However, the cache lines contain fewer usable elements.

Temporal reuse

Temporal reuse uses the same data item in more than one iteration of the loop. If the loop uses the same element in subsequent loop iterations then loop exhibits temporal reuse in the context of the loop. The blocking exploits spatial reuse by ensuring that once fetched, cache lines are not overwritten until their spatial reuse is exhausted.

Example 1: Simple Loop Blocking

The following example demonstrates the simple loop blocking. The loop blocking allows arrays A and B to be blocked into smaller rectangular chunks so that the total combined size of two blocked (A and B) chunks is smaller than cache size, which can improve data reuse.

// before_loopblocking.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" before_loopblocking.cpp

*/

#include <time.h>

#include <stdio.h>

#define MAX 8000

void add(int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

add(A, B);

add(A, B);

add(A, B);

add(A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void add(int a[][MAX], int b[][MAX])

{

int i, j;

for(i=0;i<MAX;i++)

{

for(j=0; j<MAX;j++)

{

a[i][j] = a[i][j] + b[j][i]; //Adds two matrices

}

}

}

The above code is modified below to enhance reuse of the cached data:

// after_loopblocking.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" after_loopblocking.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 8000

#define BS 16 //Block size is selected as the loop-blocking factor.

void add(int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

add(A, B);

add(A, B);

add(A, B);

add(A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void add(int a[][MAX], int b[][MAX])

{

int i, j, ii, jj;

for(i=0;i<MAX;i+=BS)

{

for(j=0; j<MAX;j+=BS)

{

for(ii=i; ii<i+BS; ii++)//outer loop

{

for(jj=j; jj<j+BS; jj++)

{

//Array B experiences one cache miss

//for every iteration of outer loop

a[ii][jj] = a[ii][jj] + b[jj][ii]; }

}

}

}

}

Example 2: Complex Blocking

// matrixMul.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" matrixMul.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 800

void matmul(int c[][MAX], int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

int C[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

matmul(C, A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void matmul(int c[][MAX], int a[][MAX], int b[][MAX])

{

int i, j, k;

for(i=0;i<MAX;i++)

{

for(j=0; j<MAX;j++)

{

for(k=0; k < MAX; k++)

{

c[i][j] = c[i][j] + a[i][k] * b[k][j];

}

}

}

}

The above code is modified below to enhance spatial and temporal reuse of the cached data for array a, b and c:

// matrixMulBlk.cpp

/*

* icl /Qoption,link,"/STACK:1000000000" matrixMulBlk.cpp

*/

#include <stdio.h>

#include <time.h>

#define MAX 800

#define BS 16 //Block size is selected as the loop-blocking factor.

void matmul(int c[][MAX], int a[][MAX], int b[][MAX]);

int main()

{

int i, j;

int A[MAX][MAX];

int B[MAX][MAX];

int C[MAX][MAX];

clock_t before, after;

//Initialize array

for(i=0;i<MAX;i++)

{

for(j=0;j<MAX; j++)

{

A[i][j]=j;

B[i][j]=j;

}

}

before = clock();

matmul(C, A, B);

after = clock();

printf("\nTime taken to complete : %7.2lf secs\n", (float)(after - before)/ CLOCKS_PER_SEC); //List time taken to complete add function

}

void matmul(int c[][MAX], int a[][MAX], int b[][MAX])

{

int i, j, k, jj, kk;

for(j=0;j<MAX; j += BS)

{

for(k=0; k<MAX; k += BS)

{

for(i=0; i < MAX; i++)

{

for(kk=k; kk<k+BS; kk++)

{

for(jj=j; jj<j+BS; jj++)

{

c[i][jj] = (c[i][jj] + a[i][kk] * b[kk][jj]);

}

}

}

}

}

}

]]> http://software.intel.com/en-us/articles/performance-tools-for-software-developers-loop-blocking Mon, 13 Jul 2009 15:36:15 -0700 http://software.intel.com/en-us/articles/performance-tools-for-software-developers-loop-blocking#comments http://software.intel.com/en-us/articles/performance-tools-for-software-developers-loop-blocking Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Parallel Composer Knowledge Base Performance Tools for Software Developers - Auto parallelization and /Qpar-threshold

The auto-parallelization feature of the Intel C++ Compiler automatically translates serial portions of the input program into semantically equivalent multithreaded code. Automatic parallelization determines the loops that are good work sharing candidates, performs the dataflow analysis to verify correct parallel execution, and partitions the data for threaded code generation as is needed in programming with OpenMP directives. The OpenMP and Auto-parallelization applications provide the performance gains from shared memory on multiprocessor systems, IA-32, Intel 64 and Itanium processors.

The following table lists the options that enable Auto-parallelization:

/Qparallel:
Enables the auto-parallelizer to generate multithreaded code for loops that can be safely executed in parallel.

/Qpar-threshold:n
This option sets a threshold for the auto-parallelization of loops based on the probability of profitable execution of the loop in parallel. To use this option, you must also specify -parallel (Linux and Mac OS X) or /Qparallel (Windows). The default is /Qpar-threshold:100.

This option is useful for loops whose computation work volume cannot be determined at compile-time. The threshold is usually relevant when the loop trip count is unknown at compile-time.

The compiler applies a heuristic that tries to balance the overhead of creating multiple threads versus the amount of work available to be shared amongst the threads.

The n is an integer whose value is the threshold for the auto-parallelization of loops. Possible values are 0 through 100. If n is 0, loops get auto-parallelized always, regardless of computation work volume. If n is 100, loops get auto-parallelized when performance gains are predicted based on the compiler analysis data. Loops get auto-parallelized only if profitable parallel execution is almost certain. The intermediate 1 to 99 values represent the percentage probability for profitable speed-up. For example, n=50 directs the compiler to parallelize only if there is a 50% probability of the code speeding up if executed in parallel.

Also, to be "100%" sure that a loop will benefit from parallelization, the compiler needs to know the iteration count at compile time. For a "99%" or lower threshold, knowing the iteration count at compile time is not a requirement.

This leads to a big difference in the number of loops parallelized at 99% compared to 100%. For many apps, 99% is a better setting, but for some apps with a lot of short loops, 99% will slow them down.

The following example, int_sin.c, does not auto parallelize when we use /Qpar-threshold:100 using command line below :

C: >icl -c /Qparallel /Qpar-report3 /Qpar-threshold:100 int_sin.cquote>

If we use /Qpar-threshold:99 then it is parallelized.

Example:

// int_sin.c

// Intel C++ compiler sample program

 

#include<stdio.h>

#include<stdlib.h>

#include<time.h>

#include<mathimf.h>

 

// Function to be integrated

// Define and prototype it here

// | sin(x) |

#defineINTEG_FUNC(x) fabs(sin(x))

 

// Prototype timing function

doubledclock( void);

 

intmain( void)

{

// Loop counters and number of interior points

unsignedint i, j, N;

// Stepsize, independent variable x, and accumulated sum

double step, x_i, sum;

// Timing variables for evaluation

double start, finish, duration, clock_t;

// Start integral from

double interval_begin = 0.0;

// Complete integral at

double interval_end = 2.0 * 3.141592653589793238;

 

// Start timing for the entire application

start = clock();

 

printf( " ");

printf( " Number of | Computed Integral | ");

printf( " Interior Points | | ");

for (j=2;j<10;j++)

{

printf( "------------------------------------- ");

 

// Compute the number of (internal rectangles + 1)

N = 1 << j;

 

// Compute stepsize for N-1 internal rectangles

step = (interval_end - interval_begin) / N;

 

// Approx. 1/2 area in first rectangle: f(x0) * [step/2]

sum = INTEG_FUNC(interval_begin) * step / 2.0;

 

// Apply midpoint rule:

// Given length = f(x), compute the area of the

// rectangle of width step

// Sum areas of internal rectangle: f(xi + step) * step

 

for (i=1;i<N;i++)

{

x_i = i * step;

sum += INTEG_FUNC(x_i) * step;

}

 

// Approx. 1/2 area in last rectangle: f(xN) * [step/2]

sum += INTEG_FUNC(interval_end) * step / 2.0;

 

printf( " %10d | %14e | ", N, sum);

}

finish = clock();

duration = (finish - start);

printf( " ");

printf( " Application Clocks = %10e ", duration);

printf( " ");

}
]]> http://software.intel.com/en-us/articles/performance-tools-for-software-developers-auto-parallelization-and-qpar-threshold Mon, 13 Jul 2009 15:32:16 -0700 http://software.intel.com/en-us/articles/performance-tools-for-software-developers-auto-parallelization-and-qpar-threshold#comments http://software.intel.com/en-us/articles/performance-tools-for-software-developers-auto-parallelization-and-qpar-threshold Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Parallel Composer Knowledge Base OpenMP* Loops with Function Calls for Bounds May Not Parallelize
Reference Number :  DPD200110877


Version : 11.0, 11.1 or Intel® Parallel Composer


Operating System : Windows*, Linux*, Mac OS X*


Problem Description : The OpenMP* 3.0 standard now supports using STL iterators for OpenMP loop bounds.  However, the Intel® C++ Compiler does not parallelize code like the following:

#include <vector>

void iterator_example()
{
  std::vector<double> vec(23);
  std::vector<double>::iterator it;

#pragma omp parallel for default(none) shared(vec) 
  for (it = vec.begin(); it < vec.end(); it++)
  {
    *it = 1.0;// do work with *it //
  }
}


The compiler will not give an indication (as it should) that the loop was parallelized for OpenMP*.  If you examine the code, you will see that the compiler generates a serial version of the loop.  This is because of an issue with the compiler using function calls on loop bounds that are inlined causing the compiler to not recognize the loop as being a validly formed loop for parallelization.


Resolution Status : This will be resolved in an upcoming compiler update.



[DISCLAIMER: The information on this web site is intended for hardware system manufacturers and software developers. Intel does not warrant the accuracy, completeness or utility of any information on this site. Intel may make changes to the information or the site at any time without notice. Intel makes no commitment to update the information at this site. ALL INFORMATION PROVIDED ON THIS WEBSITE IS PROVIDED "as is" without any express, implied, or statutory warranty of any kind including but not limited to warranties of merchantability, non-infringement of intellectual property, or fitness for any particular purpose. Independent companies manufacture the third-party products that are mentioned on this site. Intel is not responsible for the quality or performance of third-party products and makes no representation or warranty regarding such products. The third-party supplier remains solely responsible for the design, manufacture, sale and functionality of its products. Intel and the Intel logo are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. *Other names and brands may be claimed as the property of others.]
]]> http://software.intel.com/en-us/articles/openmp-loops-with-function-calls-for-bounds-may-not-parallelize Thu, 12 Mar 2009 17:06:43 -0700 http://software.intel.com/en-us/articles/openmp-loops-with-function-calls-for-bounds-may-not-parallelize#comments http://software.intel.com/en-us/articles/openmp-loops-with-function-calls-for-bounds-may-not-parallelize Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Parallel Composer Knowledge Base Disable movbe to Test Intel® Atom™ Processor Targeted Code on non-Intel® Atom™ Processor Platforms The Intel® Compilers 11.0 allow you to target the Intel® Atom™ processor using the /QxSSE3_ATOM or -xSSE3_ATOM compiler options.  These options enable the generation of the movbe instruction which is unique to the Intel® Atom™ processor.  However, there is sometimes a need to run such codes on a different processor such as the Intel® Pentium® III processor (for example, for validation purposes where an Intel® Atom™ processor isn't available).  In these situations, the compiler provides the /Qinstruction:nomovbe (for Windows*) and -minstruction=nomovbe (for Linux*/Mac*) options to disable the generation of this instruction.

]]> http://software.intel.com/en-us/articles/disable-movbe-to-test-intel-atom-targeted-code-on-non-atom-platforms Fri, 20 Feb 2009 16:41:09 -0800 http://software.intel.com/en-us/articles/disable-movbe-to-test-intel-atom-targeted-code-on-non-atom-platforms#comments http://software.intel.com/en-us/articles/disable-movbe-to-test-intel-atom-targeted-code-on-non-atom-platforms Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Intel® Parallel Composer Knowledge Base Intel® Visual Fortran Compiler for Windows* Knowledge Base Intel® C++ Compiler - Consistent Use of Compiler Options in Compile/Link Phase

If you are compiling applications with a separate compile and link process, the optimization options in the compile/link phase should match, especially when using openmp, parallelization, vectorization or interprocedural optimizations. If options are not consistent, you may get missing symbols at link time, causing the link to fail.

Example 1:
In this example -xW is used in the compile phase, but it is missing from the link phase and results in an unresolved external symbol vmldExp2.  Correct this problem by linking with -xW option.
icpc -xW -c test1.cpp test2.cpp
icpc test1.o test2.o


Example 2:
In this example, -openmp is used in the compile phase but isn't used when linking. This results in unresolved errors when linking.  Correct this problem by linking with -openmp option.
icpc -openmp test1.cpp test2.cpp
icpc test1.obj test2.obj
]]> http://software.intel.com/en-us/articles/intel-c-compiler-consistent-use-of-compiler-options-in-compilelink-phase Fri, 19 Sep 2008 00:00:00 -0700 http://software.intel.com/en-us/articles/intel-c-compiler-consistent-use-of-compiler-options-in-compilelink-phase#comments http://software.intel.com/en-us/articles/intel-c-compiler-consistent-use-of-compiler-options-in-compilelink-phase Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® Fortran Compiler - Training courses

Intel offers training courses designed to help software developers become productive and to improve application performance with the Intel® C++ and Intel® Fortran Compilers for Windows*, Linux*, and Mac* OS environments. Focus is given to software optimization on a specific processor architecture.

For course and registration information, visit the Intel® Software College.

]]> http://software.intel.com/en-us/articles/intel-fortran-compiler-training-courses Fri, 19 Sep 2008 00:00:00 -0700 http://software.intel.com/en-us/articles/intel-fortran-compiler-training-courses#comments http://software.intel.com/en-us/articles/intel-fortran-compiler-training-courses Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® C++ Compiler for Windows* Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Intel® Visual Fortran Compiler for Windows* Knowledge Base Performance Tools for Software Developers - How to generate optimal code for Intel® processors running Mac OS* X?

The Intel® Compilers 10.0 for Mac OS* X running on systems with IA-32 architecture will include the option -xP at default optimization to automatically vectorize code and generate SSE3, SSE2, and SSE instructions for Intel processors and it can optimize for processors based on Intel® Core™ microarchitecture like Intel® Core™ Duo processors.

The Intel® Compilers 10.0 for Mac OS* X running on systems using Intel® 64 architecture will include the option -xT at default optimization to automatically vectorize code and generate SSSE3, SSE3, SSE2, and SSE instructions for Intel processors, and it can optimize for the Intel® Core™2 Duo processor family.

In addition, -ipo (inter-procedural optimization), -prof_use (profile-guided optimization or PGO) and -O3 (high-level loop/memory optimizations) can add additional performance for many types of applications.

Operating System:

Mac OS*
]]> http://software.intel.com/en-us/articles/performance-tools-for-software-developers-how-to-generate-optimal-code-for-intel-processors-running-mac-os-x Fri, 19 Sep 2008 00:00:00 -0700 http://software.intel.com/en-us/articles/performance-tools-for-software-developers-how-to-generate-optimal-code-for-intel-processors-running-mac-os-x#comments http://software.intel.com/en-us/articles/performance-tools-for-software-developers-how-to-generate-optimal-code-for-intel-processors-running-mac-os-x Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® Fortran Compiler for Mac OS X* Knowledge Base Performance Tools for Software Developers - Some Applications Built with -xP or /QxP Optimizations May Produce Runtime Error

Symptom(s):

The following message may be displayed when a program built with the switches "-xP" (on Linux*) or "/QxP" (on Windows*) is run on a system with an Intel® Core™ 2 Duo processor or an Intel® Xeon® processor 5100 series.

"Fatal Error: This program was not built to run on the processor in your system."

In addition, the program may not take the optimal execution path when it is built with the switches "-axP" (on Linux) or "/QaxP" (on Windows).

Solution:

This problem has been seen in cases where the application has been compiled with one of the following Intel® Compilers:

  • Intel Compilers for Intel® 64-based Applications
  • Intel® C++ Compiler 9.0 for Linux* with Package ID l_cc_c_9.0.027 or older
  • Intel® C++ Compiler 8.1 for Linux* with Package ID l_cce_pc_8.1.032 or older
  • Intel® Fortran Compiler 9.0 for Linux* with Package ID l_fc_pc_9.0.028 or older
  • Intel® Fortran Compiler 8.1 for Linux* with Package ID l_fce_pc_8.1.034 or older
  • Intel® C++ Compiler 9.0 for Windows* with Package ID W_CC_C_9.0.025 or older
  • Intel® C++ Compiler 8.1 for Windows* with Package ID W_CCE_PC_8.1.026 or older
  • Intel® Fortran Compiler 9.0 for Windows* with Package ID W_FC_C_9.0.025 or older
  • Intel® Fortran Compiler 8.1 for Windows* with Package ID W_FCE_PC_8.1.023 or older
  • Intel Compilers for IA32-based Applications
  • Intel® C++ Compiler 8.1 for Linux* with Package ID l_cc_c_8.1.028 or older
  • Intel® Fortran Compiler 8.1 for Linux* with Package ID l_fc_c_8.1.024 or older
  • Intel® C++ Compiler 8.1 for Windows* with Package ID W_CC_PC_8.1.022 or older
  • Intel® Fortran Compiler 8.1 for Windows* with Package ID W_FC_PC_8.1.033 or older

This is due to problems with runtime checks that the compiler generates to determine the type of processor on which the application is being run to ascertain what instruction set (such as SSE, SSE2, SSE3, and new instructions in Intel® Core™ 2 Duo processors) can be utilized.

To resolve the problem recompile the application with the newer Intel Compilers listed below:

  • Intel Compilers for Intel® 64-based Applications
  • Intel C++ Compiler 9.1 for Linux with Package ID l_cc_p_9.1.038 or higher
  • Intel C++ Compiler 9.0, for Linux with Package ID l_cc_c_9.0.030 or higher
  • Intel C++ Compiler 8.1, for Linux with Package ID l_cce_pc_8.1.036 or higher
  • Intel Fortran Compiler 9.1, for Linux with Package ID l_fc_p_9.1.032 or higher
  • Intel Fortran Compiler 9.0, for Linux with Package ID l_fc_c_9.0.031 or higher
  • In tel Fortran Compiler 8.1, for Linux with Package ID l_fce_pc_8.1.036 or higher
  • Intel C++ Compiler 9.1, for Windows with Package ID W_CC_P_9.1.022 or higher
  • Intel C++ Compiler 9.0, for Windows with Package ID W_CC_C_9.0.028 or higher
  • Intel C++ Compiler 8.1, for Windows with Package ID W_CCE_PC_8.1.028 or higher
  • Intel Fortran Compiler 9.1, for Windows with Package ID W_FC_C_9.1.024 or higher
  • Intel Fortran Compiler 9.0, for Windows with Package ID W_FC_C_9.0.028 or higher
  • Intel Fortran Compiler 8.1, for Windows with Package ID W_FCE_PC_8.1.025 or higher
  • Intel Compilers for IA32-based Applications
  • Intel C++ Compiler 9.1 for Linux with Package ID l_cc_p_9.1.038 or higher
  • Intel C++ Compiler 9.0 for Linux with Package ID l_cc_c_9.0.032 or higher
  • Intel C++ Compiler 8.1 for Linux with Package ID l_cc_pc_8.1.037 or higher
  • Intel Fortran Compiler 9.1 for Linux with Package ID l_fc_c_9.1.032 or higher
  • Intel Fortran Compiler 9.0 for Linux with Package ID l_fc_c_9.0.033 or higher
  • Intel Fortran Compiler 8.1 for Linux with Package ID l_fc_pc_8.1.033 or higher
  • Intel C++ Compiler 9.1 for Windows with Package ID W_CC_P_9.1.022 or higher
  • Intel C++ Compiler 9.0 for Windows with Package ID W_CC_C_9.0.030 or higher
  • Intel C++ Compiler 8.1 for Windows with Package ID W_CC_PC_8.1.036 or higher
  • Intel Fortran Compiler 9.1 for Windows with Package ID W_FC_C_9.1.024 or higher
  • Intel Fortran Compiler 9.0 for Windows with Package ID W_FC_C_9.0.030 or higher
  • Intel Fortran Compiler 8.1 for Windows with Package ID W_FC_PC_8.1.040 or higher
]]> http://software.intel.com/en-us/articles/performance-tools-for-software-developers-some-applications-built-with-xp-or-qxp-optimizations-may-produce-runtime-error Fri, 19 Sep 2008 00:00:00 -0700 http://software.intel.com/en-us/articles/performance-tools-for-software-developers-some-applications-built-with-xp-or-qxp-optimizations-may-produce-runtime-error#comments http://software.intel.com/en-us/articles/performance-tools-for-software-developers-some-applications-built-with-xp-or-qxp-optimizations-may-produce-runtime-error Intel® C++ Compiler for Linux* Knowledge Base Intel® C++ Compiler for Mac OS X* Knowledge Base Intel® Fortran Compiler for Linux* Knowledge Base Intel® Visual Fortran Compiler for Windows* Knowledge Base