Intel Software Network articles feed

Redistributable libraries for the Intel(R) C++ and Visual Fortran Compiler for Windows

Wed, 14 Oct 2009 10:13:19 -0700

Overview

This article contains links to the redistributable installation packages for the Intel Compiler Professional Editions for Windows.

The redistributable packages are for the end users who use applications that are built with Intel Compilers. Please note that there is one redistributable package for every compiler update. Make sure you download and install the one recommended by the application vendor.

OS requirement for redistributable packages for Intel Compiler Professional Editions for Windows 11.1

The supported OS are: Windows XP*, Vista*, Windows Server 2003*, Windows Server 2008*, Windows HPC Server 2008*.

Installation instructions

The installation program of the redistributable package will guide you through the installation. You will need to accept the license and the installation will install all the libraries to the fixed directory.

For the redistributable package of Intel C++ Professional Compiler for Windows, the installation directory is
[Common Files]\Intel\Shared Files\cpp

For the redistributable package of the Intel Fortran Professional Compiler for Windows, the installation directory is
[Common Files]\Intel\Shared Files\Fortran

The installation will add the above directory to your environment variable "path" as well.

If you wish to install the redistributable package "silently", so that no output is presented to the user, run the executable with the following options added to the command line like:
>> w_cproc_p_11.1.04x_redist_xxx.exe /S /V/qn

Links to the redistributable packages

Intel C++ Compiler for Windows 11.1.048 (update 2 revised) • Redistributable library package for IA32 • Redistributable library package for Intel 64 • Redistributable library package for IA-64	Intel Visual Fortran Compiler for Windows 11.1.048 (update 3) • Redistributable library package for IA32 • Redistributable library package for Intel 64 • Redistributable library package for IA-64
Intel C++ Compiler for Windows 11.1.051 (update 3) • Redistributable library package for IA32 • Redistributable library package for Intel 64 • Redistributable library package for IA-64	Intel Visual Fortran Compiler for Windows 11.1.051 (update 3) • Redistributable library package for IA32 • Redistributable library package for Intel 64 • Redistributable library package for IA-64

References

Redistribution of Application Binaries Built for Microsoft* Windows

Building ACE/TAO with Intel(R) C++ Compiler for Windows XP 64-bit using Visual Studio

Tue, 08 Sep 2009 05:19:48 -0700

Introduction :
This document explains how to build ACE/TAO using Intel(R) C++ Compiler for Windows XP 64-bit. From the ACE/TAO web site:

ACE† is an open-source framework that provides many components and patterns for developing high-performance, distributed real-time and embedded systems. ACE provides powerful, yet efficient abstractions for sockets, demultiplexing loops, threads, synchronization primitives.

TAO† (The ACE ORB) is an open-source implementation of a CORBA Object Request Broker (ORB) built using components and patterns in the ACE framework.
Several companies provide commercial support for ACE/TAO, see http://www.cs.wustl.edu/~schmidt/commercial-support.html† for information.

Version :
The version of ACE/TAO used in this document is 5.7.2.
The 11.1.038 version of the Intel C++ compiler (Intel64) is used.

Obtaining Source Code :
The ACE/TAO source code was downloaded from http://download.dre.vanderbilt.edu/†.

Prerequisites :
- WinZIP or similar tool for extracting software archives
- Microsoft Visual Studio (2003, 2005 or 2008)

Configuration and Set-up information :

1. Extract the archive into a path with no spaces in the path name (e.g., C:\ACE_wrappers).

2. Set ACE_ROOT, TAO_ROOT, and PATH environment variables.

For example, if ACE/TAO is installed in C:\ACE_wrappers, the variables should look like this:
ACE_ROOT=C:\ACE_wrappers
TAO_ROOT=%ACE_ROOT%\TAO
The PATH variable should contain these directories: %ACE_ROOT%\bin;%ACE_ROOT%\lib

Please follow these steps to set the environment variables:

- Log into an account with Administrator privilege
- Open the Control panel
- Click System
- Click the Advanced tab and then click the Environment Variables button
- Add new ACE_ROOT and TAO_ROOT variables
- Edit PATH variable from the System variables list
- Click OK

3. Create a file named config.h in %ACE_ROOT%\ace with the following contents:

#include "ace/config-win32.h"

4. Open the solution file that matches your version of Visual Studio.
For example, you could find following solution files:

%TAO_ROOT%\TAO_ACE.sln (Visual Studio 2003)
%TAO_ROOT%\TAO_ACE_vc8.sln (Visual Studio 2005)
%TAO_ROOT%\TAO_ACE_vc9.sln (Visual Studio 2008)

The projects in the TAO_ACE solution build the ACE and TAO libraries, TAO IDL compiler, gperf, ORB services
libraries and executables, and some common utilities. They do not include any examples, tests, or performance
tests. (Separate directories and solutions exist for them.) Libraries will be installed in %ACE_ROOT%\lib.
Some executables will be installed in %ACE_ROOT%\bin, others (the ORB services executables) will be installed
in their source directories.

5. It is necessary to update the solution to use the Intel(R) C++ Compiler.
In the Solution Explorer, select the solution and click the Use Intel C++ toolbar button.
Alternatively, select Intel C++ Compiler Pro > Use Intel C++ from the Visual Studio Project menu.
Click the OK button to continue.
The TAO_ACE solution constains many projects and it will take some time to update them to use Intel C++.

Finally, you should see the message in the output window with the list of the successfully updated projects.

6. Open Solution Properties and create a new platform configuration for x64 using the Configuration Manager.
Make sure, that current (target) configuration is Debug|x64 or Release|x64 and build solution (Build > Build Solution).

During building of the solution, go to the Output window to verify that the Intel C++ Compiler is used. If Intel C++ Compiler is used, you should see a message similar to the following:

Compiling with Intel(R) C++...[Intel(R) 64]... (Intel C++ Environment)

Verifying Correctness

There are many examples and tests included in ACE/TAO. Additional separate directories and solutions exist for them.
It is possible to compile all tests using corresponding test solution files from %ACE_ROOT%\tests folder.
There is one solution file for all tests (each for different versions of VS) there, however, it is also possible to compile each test separately.

For example, you could compile ACE_Test to verify the correctness of ACE compilation using following instructions:

1. Open ACE_Test project file from %ACE_ROOT%\tests folder (e.g.,ACE_Test_vc9.vcproj for VS2008).

2. It is necessary to update the solution to use the Intel(R) C++ Compiler. Please follow the same instructions as described previously in step 5. You will be also asked to save the solution.

3. Make sure, that current (target) configuration is Debug|x64 or Release|x64 (it should be the same with the compiled libraries) and build solution.

4. Run the test (F5 or Ctrl+F5).

5. You could check the logs in %ACE_ROOT%\tests\log folder (ACE_Test.log file). In case of normal execution the output looks like this:

Sep 08 15:52:11.103 2009@LM_DEBUG@(3820|5884) Starting ACE_Test test at Tue Sep 8 2009 15:52:11.103000
Sep 08 15:52:11.103 2009@LM_DEBUG@(3820|5884) Ending ACE_Test test at Tue Sep 8 2009 15:52:11.103000

Source Code Changes :
None required.

Related topics:
http://software.intel.com/en-us/articles/building-acetao-with-intelr-c-compiler-for-linux/

Known Issues or Limitations :
None. Please contact Intel® Premier Support website or Intel® User Forums if you encounter problems or want to provide feedback.

† This link will take you off of the Intel Web site. Intel does not control the content of the destination Web Site.

Message catalog file not opening in Russian Windows OS

Tue, 25 Aug 2009 23:00:51 -0700

Problem :

When compiling with Intel(R) C++ 11.1.035 [IA-32] using MS VS2008 IDE under Russian Windows XP OS, we get the following warning.
1>warning #13000: could not open message catalog file:
1>charstest.cpp
1>warning #13000: could not open message catalog file: diagscUI.dll
We could compile without this warning using Intel C++ compiler 11.0.074 and older.
Is 11.1 trying to automatically detect the locale language and select localized message catalog?

Environment :
Intel C++ compiler 11.1 for Windows, VS2008 English, Windows XP (Russian).

Resolution :

Yes. It seems that Intel C++ compiler 11.1 is trying to automatically detect the locale language and select localized message catalog. You may copy locale 1033 (English) catalog to 1049 (Russian locale) and compiler would not display the warning.

Intel thread affinity environment variable for OpenMP*

Mon, 24 Aug 2009 02:31:41 -0700

Problem :

I am using the Intel® compiler and openMP* to parallelize some work as follows:

#pragma omp parallel num_threads(4)
{
DoWork();
}

I would d like to experiment with Intel's thread affinity feature for OpenMP but I a unsure of exactly how to use the environment variable (for example, where do I place the environment statement in my code?).

Could you give a little example showing proper usage and where to place the statement ?

Environment :
Intel C++ compiler, Linux*, Mac OS* X, Windows*

Resolution :

Intel thread affinity environment variable KMP_AFFINITY for openMP is explained in Compiler Intel® compiler user guide topic “Thread Affinity Interface (Linux* and Windows*)”. You may review the topic for detailed information.

There are many ways to set the thread affinity using KMP_AFFINITY. I am providing an example below. In the example I am mapping OpenMP threads 0, 1, 2 and 3 to OS processor 3, 2, 1 and 0 respectively.

$ cat tstcase.cpp
// tstcase.cpp
// Thread afinity interface
//


#include 
#include 
using namespace std;

#define N 1000

int main ()
{
cout << "Starting openmp test." << endl;

int i;
float a[N], b[N], c[N], d[N];

/* Some initializations */
for (i=0; i < N; i++)
{
a[i] = i * 1.5;
b[i] = i + 22.35;
}

#pragma omp parallel shared(a,b,c,d) private(i)
{

#pragma omp sections nowait
{

// Section #1
//
#pragma omp section
{
cout << "Section #1." << endl;
for (i=0; i < N; i++)
c[i] = a[i] + b[i]; // End of section #1
a[0] = 3.45;
}

// Section #2
//
#pragma omp section
{
cout << "Section #2." << endl;
for (i=0; i < N; i++)
d[i] = a[i] * b[i]; // End of section #2
a[1] = 5.67;
}

} // End of sections

} // End of parallel

cout << "Exiting openmp test." << endl;
return 0;
}

$ icc -openmp tstcase.cpp
$ export KMP_AFFINITY="verbose,proclist=[3,2,1,0]"
$ ./a.out
OMP: Warning #63: KMP_AFFINITY: proclist specified, setting affinity type to "explicit".
Starting openmp test.
OMP: Info #149: KMP_AFFINITY: Affinity capable, using global cpuid instr info
OMP: Info #154: KMP_AFFINITY: Initial OS proc set respected: {0,1,2,3}
OMP: Info #156: KMP_AFFINITY: 4 available OS procs
OMP: Info #157: KMP_AFFINITY: Uniform topology
OMP: Info #159: KMP_AFFINITY: 2 packages x 2 cores/pkg x 1 threads/core (4 total cores)
OMP: Info #160: KMP_AFFINITY: OS proc to physical thread map ([] => level not in map):
OMP: Info #168: KMP_AFFINITY: OS proc 0 maps to package 0 core 0 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 2 maps to package 0 core 1 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 1 maps to package 3 core 0 [thread 0]
OMP: Info #168: KMP_AFFINITY: OS proc 3 maps to package 3 core 1 [thread 0]
OMP: Info #147: KMP_AFFINITY: Internal thread 0 bound to OS proc set {3}
OMP: Info #147: KMP_AFFINITY: Internal thread 1 bound to OS proc set {2}
OMP: Info #147: KMP_AFFINITY: Internal thread 2 bound to OS proc set {1}
OMP: Info #147: KMP_AFFINITY: Internal thread 3 bound to OS proc set {0}
Section #1.
Section #2.
Exiting openmp test.

How to Compile for Intel® AVX

Thu, 16 Jul 2009 16:34:04 -0700

Intel® AVX (Intel® Advanced Vector Extensions) is a 256 bit instruction set extension to Intel® SSE (Intel® Streaming SIMD Extensions) that was first announced in 2008. Further information about Intel AVX is available at http://software.intel.com/en-us/avx/ .

The Intel C/C++ and Fortran Compilers, version 11.1, support the building of applications for Intel AVX. On Windows*, use the command line switch /QxAVX. On Linux*, use –xavx. The switches /QaxAVX (Windows) and –axavx (Linux) may be used to build applications that will take advantage of AVX instructions on Intel systems that support these, but will use only SSE instructions on other systems.

Both C/C++ and Fortran compilers support automatic vectorization of floating-point loops using AVX instructions. The C/C++ compiler also supports AVX-based intrinsics (via the header file immintrin.h) and inline assembly. Intel AVX allows the vectorization of a wider variety of floating point loops than Intel SSE, with a greater potential performance gain due to the greater width of the SIMD registers. The vectorizer is enabled automatically by the switches listed above. To see which loops have been vectorized, use the switch /Qvec-report1 (windows) or –vec-report1 (Linux).

Pending availability of processors supporting Intel AVX, the Intel® Software Development Emulator (Intel® SDE) is available for testing programs built for Intel AVX. See http://software.intel.com/en-us/articles/intel-software-development-emulator/ .
Further general information about the Intel Compilers for C/C++ and Fortran is available at http://software.intel.com/en-us/intel-compilers/ . Further information about compiler support for Intel AVX may be found in the Intel C++ Compiler User and Reference Guides, for example in the section 'Intrinsics for Advanced Vector Extensions', accessible online at http://software.intel.com/sites/products/documentation/hpc/compilerpro/en-us/cpp/win/compiler_c/index.htm .

Different result of Volatile variables between icc and vc

Mon, 13 Jul 2009 23:20:19 -0700

Problem :

We used keyword "volatile" as below when defining a variable,:

volatile int i=5;

The volatile has multiple meanings. To a compiler writer it means to take no code generation shortcuts when accessing such an object. "Volatile" is reminder to compiler to not suppose or guess some conditions when optimized, the variable could be change by some unexpected elements anytime.

So, the variable i should be stored in SRAM, every time we used it, we read it from SRAM.

Let's see a simple case:

// tstcase.c
include
include

void foo()
{
volatile int i=1, j=1;
i=(i++)+(j++)+2;
j=i=i++;
printf("i=%d,j=%d\n",i,j);

}

Using Intel C++ compiler, result is:

i=3,j=2 (same result with gcc)

Using VC compiler, result is

i=6,j=5

I thinks that i=(i++)+(j++)+2 was translated to:

Intel C++ compiler:

t=t+t1+2; (t is equal to 4)
t++; (t is equal to 1, then execute t++, t is equal to 2)
t1++; (t1 is equal to 2)
Then, j=i=i++;
Output is i=3,j=2

Microsoft C++ compiler :

t=t+t1+2; (t is equal to 4)
t++; (t is equal to 5)
t1++; (t1 is equal to 2)
Then, j=i=i++;
Output is i=6,j=5.

If we did not use Volatile, we got same result(i=6,j=5) no matter which compiler used. If integrated Intel C++ compiler to VS2008, compiled both with VC and icl , we got different result.

Environment :
Windows, Linux , Intel C++ compiler, Microsoft C++ compiler, gcc

Root Cause :
The statements use language constructs that have undefined behaviour according to C/C++ standard:

Resolution :

The test uses language constructs that have undefined behaviour according to C/C++ standard:

>>> i=(i++)+(j++)+2;
>>> j=i=i++;

The value of i is being modified more than once between two sequence points. Refer to the rules for expressions (section 5, paragraph 4 of the ISO C++ standard):

"Except where noted, the order of evaluation of operands of
individual operators and subexpressions of individual
expressions, and the order in which side effects take place,
is unspecified. Between the previous and next sequence
point a scalar object shall have its stored value modified at
most once by the evaluation of an expression. Furthermore,
the prior value shall be accessed only to determine the value
to be stored. The requirements of this paragraph shall be met
for each allowable ordering of the subexpressions of a full
expression; otherwise the behavior is undefined.

[Example:
i = v[i++]; // the behavior is unspecified
i = 7, i++, i++; // i becomes 9
i = ++i + 1; // the behavior is unspecified
i = i + 1; // the value of i is incremented
-end example]"

Intel® C++ Compiler for Windows* - Building FFTW with the Intel® compilers

Mon, 06 Jul 2009 10:48:32 -0700

Introduction
Version information
Application notes
Obtaining the source code
Obtaining the latest version of the Intel® compilers
Prerequisites
Configuration and set-up information
Source code changes
Building PGPLOT
Building FFTW as a DLL
Running FFTW
Verifying correctness
Benefits
Known issues and limitations

Introduction

This guide is intended to help Intel® C++ Compiler for Windows* customers build the FFTW* library. The FFTW library is used for high performance computation of the Discrete Fourier Transform (DFT).

Version information

This guide applies to FFTW* version 3.1.2 and the Intel® C++ Compiler for Windows* version 11.1.035.

Application notes

FFTW* is a portable open source library for computing DFTs and is one of the fastest such libraries available. In addition to the library, FFTW also includes a benchmark application. Though FFTW can be used on many platforms, this particular guide is intended for Windows*. FFTW can compute DFTs in multiple dimensions and with arbitrary sizes, using either real or complex data. More information about FFTW can be found at:

http://fftw.org†

Obtaining the source code

The project files for Microsoft Visual Studio* 2008 can be downloaded here†:

Currently, the source files are distributed with project files for Microsoft Visual Studio .NET* 2003, but they should work on the newer versions of Visual Studio as well. Here is a direct link to that file:

ftp://ftp.fftw.org/pub/fftw/fftw-3.1.2-vs2003.zip†

Obtaining the latest version of the Intel® compilers

Licensed users of the Intel compilers may download the most recent versions of the compiler from the Intel download center which is accessed by logging into your account at the Intel® Registration Center .

Evaluation versions of the Intel compilers may be found at the Intel® Evaluation Software Center.

Prerequisites

Hardware: This note has been tested on Intel® Core® 2 Quad and Pentium® M processors.

Software: This note applies to use of version 11.1.035 of the Intel® C++ Compiler for Windows*. It is assumed that the reader will be using Microsoft Visual Studio* .NET* 2003 or above to build FFTW. This note has been tested with Microsoft Visual Studio 2008 Professional Edition.

Configuration and set-up information

In order to use the provided project files you will need Microsoft Visual Studio* version .NET* 2003 or later and have the Intel® C++ Compiler installed. To ensure that the Intel compiler works properly within Visual Studio, the Intel compiler should be installed after Visual Studio. The project files provided are already configured to use the Intel® Compiler. The examples and screen captures shown in this document reflect the Visual Studio 2008 environment.

Source code changes

No source code changes are required to build FFTW* with the Intel compiler.

Building FFTW

After you download the source code and Microsoft Visual Studio* project files, extract the files. Windows* does not support .tar.gz files natively, so you may need a program like WinZip* that can handle that type of file. The files should be extracted by default to a directory named fftw-3.1.2. Inside that directory, open the win32 directory and open the bench.sln solution file. That solution file contains all of the FFTW projects.

If you are using a version of Microsoft Visual Studio newer than the .NET* 2003 edition and using the projects for .NET 2003 supplied with the source, it will tell you that it needs to convert the project files from the older version. Just follow the onscreen wizard with the default options and the project should convert without any problems.

There are several different configurations to choose from in the solution. Perhaps the most relevant one is the Release SSE2 configuration, which uses double precision floats and Intel® Streaming SIMD Extensions 2 (SSE2) instructions. To build FFTW*, just select a configuration and then click Build Solution in the Build menu.

You may encounter one of these two errors when building the solution:

Command-line error: cannot open precompiled header input file .\bench___Win32_Release_SSE2\bench.pchi<

or

Project : error PRJ0019: A tool returned an error code from "Performing Post-Build Event..."
LINK : fatal error LNK1181: cannot open input file 'libfftw.lib'

If so, please refer to the Known Issues and Limitations section at the bottom of this document.

After the solution builds successfully, both the benchmark executable and the FFTW static library will placed in the fftw-3.1.2 directory. The names of the files depend on the configuration that is used, but for the Release SSE2 configuration, the benchmark is called bench_sse2.exe and the static library is called libfftw_sse2.lib.

Building FFTW as a DLL

The FFTW* library normally compiles as a static library (.lib file), but can be compiled as a dynamic library (.dll file) as well. Follow the procedure from above for building as a static library, but with the following modifications.

Before building the solution, you will need to change some of the settings for the libfftw project. Right-click the libfftw project in the Solution Explorer and click Properties. On the General page (top level), change the Configuration Type to Dynamic Library (.dll).

Next, on the Preprocessor page under the C/C++ section, add FFTW_DLL to the Preprocessor Definitions, so that it reads:

WIN32;NDEBUG;_WINDOWS;HAVE_SSE2;FFTW_DLL

Now the FFTW library should build as a DLL. The resulting file will be called libfftw.dll and will be placed in the libfftw___Win32_Release_SSE2 (for the Release SSE2 configuration). Although the library will build successfully, the benchmark executable will try to link to the static library, so building the bench project will either fail (if the static library doesn’t exist) or use a previously built static library. This is not really a problem unless you need to build the benchmark and don’t want to keep switching between building the library statically and dynamically. The most elegant solution would be to create a separate project or configuration for building the library as a DLL. However, that goes beyond the scope of this document.

Running FFTW

Since FFTW* is a library, it cannot be run independently. It must be linked with an executable. However, there is a benchmark executable that uses FFTW which can be used for testing. The benchmark can be run from the Windows command line. Here is an example:

bench_sse2.exe -opatient 512 1024 2048 4096<

The –opatient switch is recommended for benchmarking. The numbers listed are the problem sizes that should be run in each trial. In the example shown, we are running four problems of sizes 512, 1024, 2048, and 4096. The number of trials and problem sizes chosen in this example are arbitrary. Also, problem sizes can be repeated in the list for multiple trials of the same problem size.

Verifying correctness

To verify that the results are being computed correctly, you can use the benchmark executable as you normally would, but with the --verify switch. For example, you could execute the following command on the Windows* command prompt from the fftw-3.1.2 directory:

bench_sse2.exe --verify 4096<

If the results were correct, no output will be shown. Otherwise, there will be an error message.

Benefits

This note demonstrates the use of FFTW* with the latest version 11.1.035 Intel® C++ Compiler technology. Following this method will produce object files and libraries that are compatible with the latest Intel compilers.

Known issues and limitations

#1. When building the solution, you may encounter an error in the output window that says:

Command-line error: cannot open precompiled header input file .\bench___Win32_Release_SSE2\bench.pchi

This issue can be resolved by disabling precompiled headers in the bench project. As shown below, this option can be accessed in the properties page of the bench project. Right-click the bench project in the solution explorer and click Properties. Then, select the Precompiled Headers page under the C/C++ section. Change the Create/UsePrecompiled Header option to Not Using Precompiled Headers and click OK. The project should now build successfully.

#2. When building the solution, you may encounter an error in the output window that says:

Project : error PRJ0019: A tool returned an error code from "Performing Post-Build Event..."
LINK : fatal error LNK1181: cannot open input file 'libfftw.lib'

You can fix the error by:

- Go to the properties for libfftw.
- Go to Configuration Properties->Build Events->Post-Build Event as shown below, and open the Command Line.

- Surround the following code in quotations: "$(OutDir)\$(ProjectName).lib"
- Within the bench project, use this same method to also surround "$(OutDir)\$(ProjectName).exe" in quotations.

^† This link will take you off of the Intel Web site. Intel does not control the content of the destination Web Site.

Abstract class type not allowed as a type for parameter

Sun, 14 Jun 2009 23:02:04 -0700

Problem :
I encounter an error when compiling "parameter of abstract class type "type" is not allowed", as described in http://software.intel.com/en-us/articles/cdiag646/. Does anybody know why and how to fix it?

Environment :
Windows, Linux, Mac and Intel C++ compiler.

Resolution :

The problem is you are trying to declare a parameter that has the type of an abstract base class.

Abstract classes are designed to be only interfaces to real classes because they have one or
more pure virtual functions, i.e.:
class abstract {
virtual void foo() = 0; // pure virtual function since it is declared with = 0
};
void foo(abstract); // not allowed since the class is abstract

The workaround would be to only use pointers or references to the abstract class as parameters, or change the type to a non-abstract class that is derived from the abstract class or change the class so it is no longer abstract, i.e. define the virtual functions instead of declaring them pure virtual.

ISO/IEC Standards language conformance for Intel C++ compiler

Thu, 04 Jun 2009 02:01:38 -0700

The Intel C++ compiler option /Qstd=val or –std=val could be used to get the specific version of ISO/IEC standards language conformance for the compiler.

The possible values are for “val” are given below:

c89 - Conforms to the ISO/IEC 9899:1990 International Standard.

c99 - Conforms to The ISO/IEC 9899:1999 International Standard.

gnu89 - Conforms to ISO C90 plus GNU* extensions.

gnu++98 - Conforms to the 1998 ISO C++ standard plus GNU extensions.

c++0x - Enable support for the following C++0x features. Please refer to Intel C++ compiler documentation for details.

The default for Intel C++ compiler 11.0 are as given below:

-std=gnu89 - default for C, Conforms to ISO C90 plus GNU extensions.
-std=gnu++98 - default for C++, Conforms to the 1998 ISO C++ standard plus GNU* extensions.
/Qstd=c89 - Conforms to the ISO/IEC 9899:1990 International Standard.

Redistributing libraries and dlls of Intel C++ compiler for Windows

Thu, 21 May 2009 22:42:00 -0700

Problem :
We have developed a multilevel iterative solver that we would like to distribute as a DLL and LIB on Windows to students at our university and also to project partners.

The iterative solver needs optimized BLAS and LAPACK kernels and we recently purchased a Intel professional compiler suite that includes the MKL. I have compiled the solver using icl and ifort. We need the MKL library on Windows and as far as I understand, we have included the MKL in our DLL, but only our symbol iterative_solver can be used by the project partners.

My question is whether the Intel licensing conditions allows me to redistribute our DLLs and the libraries to our project partners.

Environment :
Intel C++ Compiler for Windows

Resolution :

You may provide the "Redistributables" from Intel C++ compiler Professional Edition as part of your product. The "Redistributables" are the files listed in the following text files that may be included in the Materials for the applicable Intel Software Development Product: clredist.txt, credist.txt, fredist.txt, redist.txt.

Intel grants to you a non-exclusive, non-assignable copyright license to distribute (except under an Evaluation License as specified below) the Redistributables, or any portions thereof, as part of the product or application you developed using the Materials. If such application is a software development library, then attribution, as specified in the product release notes of the corresponding Materials, shall be displayed prominently in that application's product documentation and on the application's product web site.

For example, you may find the files that list the redistributables at following location in the default installation of Intel ®C++ compiler 11.0.074 Professional for Windows:

C:\Program Files (x86)\Intel\Compiler\11.0\074\cpp\Documentation\en_US\credist.txt.
C:\Program Files (x86)\Intel\Compiler\11.0\074\cpp\doc\redist.txt
C:\Program Files (x86)\Intel\Compiler\11.0\074\cpp\Documentation\tbb\redist.txt
C:\Program Files (x86)\Intel\Compiler\11.0\074\cpp\ipp\em64t\redist.txt

For the Intel C++ Compiler 11.1.035 Professional for Windows:
C:\Program Files\Intel\Compiler\11.1\035\Documentation\en_US\credist.txt

Please refer the End User License Agreement of the product on this for further details.

The 11.x Intel® C++ Compiler Professional Edition for Windows* product includes the Intel® C++ Compiler, the Intel® Math Kernel Library, the Intel® Integrated Performance Primitives, and the Intel® Threading Building Blocks products. The Knowledge Base article at the following link includes information on redistributable libraries for all the component products included with Intel C++ Compiler Professional Editions for Microsoft Windows*.

http://software.intel.com/en-us/articles/redistribution-of-application-binaries-built-for-microsoft-windows/