Intel® C++ Compiler 16.0 Update 4 for Windows* Release Notes for Intel® Parallel Studio XE 2016

ID 788301
Updated 9/14/2016



This document provides a summary of new and changed product features and includes notes about features and problems not described in the product documentation. 

Please see the licenses included in the distribution as well as the Disclaimer and Legal Information section of these release notes for details. Please see the following links for information on this release of the Intel® C++ Compiler 16.0 Update 4.

Change History

Changes in Update 4 (Intel® C++ Compiler 16.0.4)

  • Support for Microsoft Visual Studio 2015 Update 3
  • Fixes for reported problems

Changes in Update 3 (Intel® C++ Compiler 16.0.3)

Changes in Update 2 (Intel® C++ Compiler 16.0.2)

Changes in Update 1 (Intel® C++ Compiler 16.0.1)


Changes since Intel® C++ Compiler 15.0 (New in Intel® C++ Compiler 16.0.0)

Back to top

System Requirements

  • A PC based on an IA-32 or Intel® 64 architecture processor supporting the Intel® Streaming SIMD Extensions 2 (Intel® SSE2) instructions (Intel® Pentium® 4 processor or later, or compatible non-Intel processor)
  • 2GB of RAM (4GB recommended)
  • 4GB free disk space for all features
  • For Intel® MIC Architecture development/testing:
  • For offload to or native support for Intel® Graphics Technology development/testing
    • The following processor models are supported: 
      • Intel® Xeon® Processor E3-1285 v3 and E3-1285L v3 (Intel® C226 Chipset) with Intel® HD Graphics P4700 
      • 5th Generation Intel® Core™ Processors with Intel® Iris™ Pro Graphics, Intel® HD Graphics
      • 4th Generation Intel® Core™ Processors with Intel® Iris™ Pro Graphics, Intel® Iris™ Graphics or Intel® HD Graphics 4200+ Series 
      • 3rd Generation Intel® Core™ Processors with Intel® HD Graphics 4000/2500 

        Please note: Intel® Xeon® processors are only supported with the chipsets listed. Intel® Xeon® configurations with other chipsets are not supported. Previous generations of Intel® Core™ processors are not supported. Intel® Celeron and Intel® Atom™ processors are also not compatible.
    • The latest 32-bit or 64-bit graphics driver with support for Intel® Graphics Technology (available at the Intel® Download Center
    • A version of binutils (specifically for Windows (available at
      • Note that after installing binutils, you will need to set your PATH to include the directory containing ld.exe.
  • Microsoft Windows 7*, Microsoft Windows 8*, Microsoft Windows 8.1*, Microsoft Windows 10*, Microsoft Windows Server 2008* SP2 (IA-32 only), Microsoft Windows Server 2008 (R2 SP1), Microsoft Windows HPC Server 2008*, or Microsoft Windows Server 2012* (embedded editions not supported) [3]
    • On Microsoft Windows 8, Microsoft Windows 8.1, and Microsoft Windows Server 2012, the product installs into the “Desktop” environment. Development of “Windows 8 UI” applications is not supported. [4]
  • To use the Microsoft Visual Studio development environment or command-line tools to build IA-32[2] or Intel® 64 architecture applications, one of:
    • Microsoft Visual Studio 2015* Professional Edition (or higher edition) with 'Common Tools for Visual C++ 2015' component installed [5]
    • Microsoft Visual Studio Community 2015* with 'Common Tools for Visual C++ 2015' component installed [5]
    • Microsoft Visual Studio 2013* Professional Edition (or higher edition) with C++ component installed
    • Microsoft Visual Studio Community 2013* with C++ component installed
    • Microsoft Visual Studio 2012* Professional Edition (or higher edition) with C++  component installed
    • Microsoft Visual Studio 2010* Professional Edition (or higher edition) with C++ and “X64 Compiler and Tools” components installed [1]
  • To use command-line tools only to build IA-32[2] architecture applications, one of:
    • Microsoft Visual C++ Express 2013 for Windows Desktop*
    • Microsoft Visual C++ Express 2012 for Windows Desktop*
    • Microsoft Visual C++ 2010* Express Edition
  • To use command-line tools only to build Intel® 64 architecture applications, one of:
    • Microsoft Visual C++ Express 2013 for Windows Desktop*
    • Microsoft Visual C++ Express 2012 for Windows Desktop*
    • Microsoft Windows* Software Development Kit for Windows 8*
  • To read the on-disk documentation, Adobe Reader* 7.0 or later


  1. Microsoft Visual Studio 2010* includes x64 support by default. 
  2. The default for the Intel® compilers is to build IA-32 architecture applications that require a processor supporting the Intel® SSE2 instructions - for example, the Intel® Pentium® 4 processor. A compiler option is available to generate code that will run on any IA-32 architecture processor.  
  3. Applications can be run on the same Windows versions as specified above for development. Applications may also run on non-embedded 32-bit versions of Microsoft Windows earlier than Windows XP, though Intel does not test these for compatibility.  Your application may depend on a Win32 API routine not present in older versions of Windows.  You are responsible for testing application compatibility. You may need to copy certain run-time DLLs onto the target system to run your application.
  4. The Intel® C++ Compiler does not support development of Windows 8* UI apps.  We are always interested in your comments and suggestions.  For example, if you want to use the Intel® C++ Compiler or other Intel software development capabilities in Windows 8 UI apps, please file a request at the Intel® Online Service Center.
  5. To use the Intel® C++ Compiler with Microsoft Visual Studio 2015*, it is necessary to install the 'Common Tools for Visual C++ 2015' component from Visual Studio.  This article explains how.

Intel® Manycore Platform Software Stack (Intel® MPSS)

The Intel® Manycore Platform Software Stack (Intel® MPSS) may be installed before or after installing the Intel® C++ Compiler.
Using the latest version of Intel® MPSS available is recommended. It is available from the Intel® Software Development Products Registration Center at as part of your Intel® Parallel Studio XE for Windows* registration.
Refer to the Intel® MPSS documentation for the necessary steps to install the user space and kernel drivers. 

Back to top

How to use the Intel® C++ Compiler

The Getting Started Guide at <install-dir>\documentation_2016\ps2016\getstart_comp_wc.htm. contains information on how to use the Intel® C++ Compiler from the command line and from Microsoft Visual Studio*.

Back to top


Product documentation is linked from <install-dir>\documentation_2016\en\ps2016\getstart_comp_wc.htm.

Online Help format in Microsoft Visual Studio*
The online help format is browser-based. When you view Intel documentation from the Microsoft Visual Studio* Help menu, or when you view context-sensitive help using F1 or a help button in a dialog box or other GUI element, your default browser shows the corresponding help topic. You may encounter some minor functionality issues depending on your default browser. Known issues include: 

  • When Set Help Preference is set to Launch in Browser and you hit F1 in Tools>Options>F# Tools or Tools>Options>Intellitrace, the browser appears twice.
  • Chrome*: When arriving at a topic from Search or Index, the Table of Contents (TOC) does not sync, nor does the Sync TOC link work. 
  • Firefox*: The TOC loses context easily. Search is case sensitive.
  • Safari*: Response on Windows* is slow.

Documentation Viewing Issue with Microsoft Internet Explorer* 10 and Windows Server* 2012
If on Windows Server 2012 you find that you cannot display help or documentation from within Internet Explorer 10, modifying a security setting for Microsoft Internet Explorer* usually corrects the problem. From Tools > Internet Options > Security, add “about:internet” to the list of trusted sites. Optionally, you can remove “about:internet” from the list of trusted sites after you finish viewing the documentation.

Documentation viewing Issue with Microsoft Visual Studio 2012 and Windows Server 2012
If on Windows Server 2012* you find that you cannot display help or documentation from within Visual Studio 2012, modifying a security setting for Microsoft Internet Explorer* usually corrects the problem.  From Tools > Internet Options > Security, change the settings for Internet Zone to allow “MIME Sniffing” and “Active Scripting”.

Intel-provided debug solutions

Back to top


Product samples can be located in the <install-dir>\samples_2016\en\compiler_c\psxe directory.

Back to top

Technical Support

If you did not register your compiler during installation, please do so at the Intel® Software Development Products Registration Center at Registration entitles you to free technical support, product updates and upgrades for the duration of the support term.

For information about how to find Technical Support, Product Updates, User Forums, FAQs, tips and tricks, and other support information, please visit: 
Note: If your distributor provides technical support for this product, please contact them for support rather than Intel.

Back to top

New and Changed Features

The following features are new or significantly enhanced in this version.  For more information on these features, please refer to the documentation.


Intrinsics for the Short Vector Random Number Generator (SVRNG) Library

  • The Short Vector Random Number Generator (SVRNG) library provides intrinsics for the IA-32 and Intel® 64 architectures running on supported operating systems.  The SVRNG library partially covers both standard C++ and the random number generation functionality of the Intel® Math Kernel Library (Intel® MKL).  Complete documentation may be found in the Intel® C++ Compiler 16.0 User and Reference Guide.
  • Note: The SVRNG feature should not be used to target an Intel® Many Integrated Core Architecture (Intel® MIC Architecture) Intel® Advanced Vector Extensions 512 (Intel® AVX-512) CPU (second generation Intel® Xeon Phitm  processor code name Knights Landing).  Support is in Intel® C++ Compiler 16.0 Update 3.

Support for new features in OpenMP* 4.5 Specification


  • Support for #pragma omp simd simdlen(n)
  • Support for #pragma omp ordered simd
  • Intel® processor clause extension added to #pragma omp declare simd (proposed; not officially part of OpenMP* 4.5)
  • The linear clause on the #pragma omp declare simd directive is extended with new modifiers:
    • linear (linear-list [ : linear-step]) where linear-list is one of:
      • list
      • modifier (list) where modifier is one of ref, val, or uval
    • All list items must be arguments of the function that will be invoked on each SIMD lane
    • If no modifier is specified, or if the val or uval modifier is specified, the value of each list item on each lane corresponds to the value of the list item upon entry to the function plus the logical number of lanes times linear-step
    • If the uval modifier is specified, each invocation uses the same storage location for each SIMD lane; this storage location is updated with the final value of the logically last lane
    • If the ref modifier is specified, the storage location of each list item on each lane corresponds to an array at the storage location upon entry to the function indexed by the logical number of the lane times linear-step

Intel® C++ Compiler SIMD Data Layout Templates (SDLT)

  • SDLT is a library that helps you leverage SIMD hardware and compilers without having to be a SIMD vectorization expert.
  • SDLT can be used with any compiler supporting ISO C++11, Intel® Cilktm Plus SIMD extensions, and #pragma ivdep
  • Intel® C++ Compiler SIMD Data Layout Templates:
    • Enable you to program in an AOS style while data layout is SOA for vectorization
    • Target effective SIMD vectorization for performance
    • Are compatible with other explicit SIMD programming models
  • For SDLT to generate efficient SIMD code, the following compiler options are required or recommended:
    • C++11 support
      • /Qstd:c11 (Windows*) or -std=c11 (Linux*)
    • Code optimization level of 2 or higher
      • /O2 or /O3 (Windows*) or -O2 or -O3 (Linux*)
    • ANSI aliasing rules in optimizations
      • /Qansi-alias (Windows*) or -ansi-alias (Linux*)
    • Optionally tell the compiler which processor features it may target
      • /Qxcode (Windows*) or -xcode (Linux*)
    • Optionally tell the compiler to generate multiple, feature-specific auto-dispatch code paths for Intel® processors if there is a performance benefit
  • GCC 4.7 or later is required for SDLT to work on Linux* due to C++11 dependencies.  GCC 4.8 or later is recommended for using SDLT with STL algorithms.
  • Microsoft Visual Studio* 2012 or later is required for SDLT to work on Windows* due to C++11 dependencies

Enable OpenMP Offloading Compilation (/Qopenmp-offload[:mic|gfx|host]

  • Visual Studio* IDE integration properties 'Enable OpenMP Offloading Compilation' and 'Target Device for OpenMP Offloading Compilation' have been combined into a single property, 'Enable OpenMP Offloading Compilation and Specify Target Device'.  The new option enables or disables OpenMP offloading compilation for target pragmas and specifies the target device.  The default target device is mic.  Property 'Target Device for OpenMP Offloading Compilation' is deprecated and will be removed in a future release.

Support for additional OpenMP* 4.0 features

  • Support for #pragma omp declare reduction to define user-defined reductions
  • Support for #pragma omp simd collapse(n)

Decimal floating point now supported on C++ Windows*

Decimal floating point as defined in IEEE Standard 754-2008 has been supported for both C/C++ on Linux* and for C only on Windows. C++ support has been added as described in ISO/IEC TR 24733:2011.

Intel(R) Math Kernel Library (Intel(R) MKL) with Intel(R) Threading Building Blocks (Intel(R) TBB) Threading Layer supported

The Intel(R) C++ Compiler adds support for using the Intel MKL threading layer support for Intel TBB. These libraries will be used when both /Qmkl and /Qtbb (Windows*) or -mkl and -tbb (Linux* / OS X*) are specified and /Qopenmp, -qopenmp, or -fopenmp are not specified. If OpenMP* is required, but you want to utilize the Intel MKL libraries that use Intel TBB, you will need to explicitly specify the libraries at link time.

API to query Intel(R) Graphics Technology capabilities at runtime added
The APIS _GFX_get_device_platform(void), _GFX_get_device_sku(void), _GFX_get_device_hardware_thread_count(void), _GFX_get_device_min_frequency(void), _GFX_get_device_mas_frequency(void), and _GFX_get_device_current_frequency(void) have been added to provide a source-level method of obtaining hardware information about the Intel Graphics Technology at runtime. 

API to set thread space configuration at runtime added 
The API _GFX_set_thread_space_config(int, int, int, int) has been added to allow the application to programmatically control the thread space and thread group height and width at runtime.
The runtime environment variables GFX_THREAD_SPACE_WIDTH and GFX_THREAD_SPACE_HEIGHT have been added to allow the application to programmatically control the thread space width and height at runtime. These are in addition to the GFX_THREAD_GROUP_WIDTH and GFX_THREAD_GROUP_HEIGHT environment variables for controlling the thread group width and height.

New targetptr and preallocated offload modifiers for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)

The offload syntax will be extended with two new modifiers: targetptr and preallocated. Use of these modifiers permits allocating Intel® MIC Architecture-only memory through #pragma offload (targetptr) or by the user in his offload code (preallocated targetptr)).

New offload streams support to offload multiple concurrent computations to Intel® Many Integrated Core Architecture (Intel® MIC Architecture) from a single CPU thread

New APIs (_Offload_stream_handle, _Offload_stream_completed, _Offload_device_streams_completed) and additional offload pragma clauses (stream, signal) are now available to implement offloading multiple computations to Intel® MIC Architecture to be executed in parallel on the target device.  See the Intel® C++ Compiler 16.0 User’s Guide for further details on the offload streams API.

To use offload streams, it is necessary to set the following environment variables as follows:

  • MIC_KMP_AFFINITY=norespect,none
  • OFFLOAD_STREAM_AFFINITY={compact | scatter}

gfx_sys_check utility to validate support for offloading to Intel® Graphics Technology

A utility, gfx_sys_check, is now provided to confirm a platform’s support for offloading to Intel® Graphics Technology. The utility also provides extra details relevant to Intel Graphics Technology.

Shared local memory support for Intel® Graphics Technology

A new _Thread_group clause for cilk_for loops, a new __thread_group_local variable attribute, and a new API _gfx_gpgpu_thread_barrier() are now provided to enable sharing local memory between threads on Intel® Graphics Technology to reduce RAM traffic and improve performance.

cilk_for loops now accepted with #pragma simd
C/C++ for loops parallelized using the Intel® Cilk™ Plus cilk_for keyword can now also be targeted for explicit vectorization using either #pragma simd or the _Simd keyword.

Enable respect for parentheses when determining order of operations in expressions
The /Qprotect-parens (Windows*) and -fprotect-parens (Linux*/OS X*) require the compiler optimizer to honor parentheses when evaluation expressions and to not reassociate operations. For example, when these options are used, the compiler would no longer be free to convert:

double y = (a + b) + c;


double y = a + (b + c);

These options are not enabled by default, and their use may negatively impact performance.

C++14 features supported
The Intel® C++ Compiler 16.0 supports the following features under the /Qstd:c++14 (Windows*) or -std=c++14 (Linux*/OS X*) options:

C11 features supported

The Intel® C++ Compiler 16.0 supports the following features under the /Qstd:c11 (Windows*) or -std=c11 (Linux*/OS X*) options:

Compiler intrinsic functions now defined internally
To improve compilation time, the Intel® C++ Compiler 16.0 no longer checks header files for intrinsic function declarations. This can impact type-checking, so to add the function prototypes for this purpose, add the compiler option -D__INTEL_COMPILER_USE_INTRINSIC_PROTOTYPES.

BLOCK_LOOP and NOBLOCK_LOOP pragmas and private clause for unroll_and_jam pragma added
New and updated pragmas have been added to provide loop blocking information to the compiler. This includes new pragmas #pragma BLOCK_LOOP [clause[[,] clause...] ] and #pragma NOBLOCK_LOOP. This also includes the addition of a private(var list) clause to the #pragma unroll_and_jam. See the Intel® C++ Compiler User’s Guide for details.

New and Changed Compiler Options
For details on these and all compiler options, see the Compiler Options section of the Intel® C++ Compiler 16.0 User's Guide.

  • /Qdaal[: lib]           Tells the compiler to link certain libraries in the Intel® Data Analytics Acceleration Library (Intel® DAAL)
  • /Qoffload-svm       Determines whether the compiler uses Shared Virtual Memory (SVM) mode.  This option only applies to Intel®  Graphics Technology
  • /Qopt-prefetch-issue-excl-hint   Supports the prefetchW instruction in Intel® microarchitecture code name Broadwell and later

For a list of deprecated compiler options, see the Compiler Options section of the Intel® C++ Compiler 16.0 User's Guide.

Back to top

Support Deprecated

Microsoft Visual Studio 2010* deprecated
Support for Microsoft Visual Studio 2010* is deprecated in this release and will be removed in a future version.


IA-32 host installation support deprecated

Support for installation on IA-32 hosts is deprecated and will be removed in a future release.

GFX offload support for 3rd Generation Intel® Core™ Processors is deprecated

GFX offload support to processor graphics for 3rd Generation Intel® Core™ Processors is deprecated and will be removed in Intel® C++ Compiler 17.0.

_GFX_enqueue  is deprecated

_GFX_enqueue is deprecated and should be replaced with _GFX_offload 

Support Removed

Static Analysis is not supported
Support for Static Analysis is no longer supported. If you have concerns or feedback, please comment.

Microsoft Visual Studio 2008* not supported
Support for Microsoft Visual Studio 2008* is removed in this release.

Back to top

Known Limitations

Pointer Checker requires a dynamic runtime library

When using the /Qcheck-pointers option, the runtime library libchkp.dll must be linked in. When using options like /MD with /Qcheck-pointers, be aware that this dynamic library will be linked in regardless of your settings. See the article at for more information.

Intel® Compiler Help Documentation fails to launch from IDE when installed on Japanese version of Windows*

In some cases, custom installations of Intel(R) Parallel Studio XE 2016 on Japanese versions of Windows will cause Intel compiler Help documentation to fail to launch from the Microsoft Visual Studio* IDE. Details describing this issue can be found here.

Mixed Microsoft* / Intel compilation of 256 vector bit type parameters may generate code that causes an access violation at runtime

A general protection fault caused by an unaligned data access may occur when an application is built using two different compilers - the Microsoft Visual C++ 2013* compiler and the Intel® C++ Compiler 15.0 or above. The problem may arise when 256 vector bit type parameters are passed by reference in a call, when the caller is built with Visual C++*, and the parameters are accessed by functions built with the Intel C++ Compiler.

The problem arises due to a mismatch in the alignment of the 256 vector bit type parameters. 

This problem will not occur when the /Qx<code> compiler option is used with <code> equal to AVX or with a newer code value, such as CORE-AVX-I, CORE-AVX2, etc., due to the fact that unaligned access instructions are used in these instances unless  __mm256_stream_*  (non-temporal data load/store intrinsics)  are used explicitly in the application source code.  

Visual Studio Known Issues

  • C++ Project fails to build using Visual Studio* 2015 Update 2 if Intel® C++ is used for a 32-bit target and the Base Platform Toolset is set to v140_xp

    The error message is “LINK : fatal error LNK1158: cannot run 'rc.exe'”  To work around this issue:
  1.  Select the project in Solution Explorer
  2.  Open project properties
  3.  Choose “Configuration Properties -> VC++ Directories” category
  4. Select “Executable Directories” property and add macros “$(WindowsSdk_71A_ExecutablePath)“ to the property value.
  5. Rebuild the project
  • Using Intel C++ Projects with a Source Control System

    If your Microsoft Visual Studio* project is managed under a source control system, for example, Microsoft Visual Source Safe* or Microsoft Visual Studio Team Foundation Server*, there are additional steps you must follow in order to use the Intel C++ project system with your project.  A detailed article on this topic is available at 
  • MSVCP90D.dll (or other Microsoft runtime DLL) is missing

    There are situations where the sample projects provided (or any Microsoft Visual C++* project potentially) could run into a runtime System Error where the application cannot find a Microsoft Visual Studio* runtime DLL.  This is related to manifest files and SXS assemblies potentially missing.  The simplest solution is to go to your redist directory for the version of Microsoft Visual Studio* you are using (default location would be c:\program files[ (x86)]\Microsoft Visual Studio X.X\VC\redist).  There will be several subdirectories under this location, sorting files out by amd64, x86 or Debug_NonRedist (if you have D in the runtime name, this usually indicates a Debug library found in this folder).  Find the appropriate folder that contains the runtime you are looking for, and then copy the entire contents of that folder (including a .manifest file) to the directory where the .exe you are trying to run is located.
  • Visual Studio 2010 sets default of /fp:precise

    A project created in or converted to Visual Studio 2010 will have the command line option /fp:precise set by default. This option sets the “floating point model” to improve consistency for floating point operations by disabling certain optimizations, reducing performance. To set the option back to the Intel default of /fp:fast, change the project property C++ > Optimization > Floating Point Model to Fast
  • Language packs of Visual Studio 2010 

    If you install a new language pack of Visual Studio 2010 after installing the Intel® C++ Compiler, you may not see the Intel C++ Compiler specific options in the Project Property dialog. Please try the following to fix the issue: 
  1. If directory “<program files> \MSBuild\Microsoft.Cpp\v4.0\Platforms\[Win32|x64]\PlatformToolsets\Intel C++ Compiler XE 15.0\1033" exists, copy all files to “<program files>\MSBuild\Microsoft.Cpp\v4.0\Platforms\[Win32|x64]\PlatformToolsets\Intel C++ Compiler XE 15.0\<locale-ID>”.
  2. If directory "<program files> \MSBuild\Microsoft.Cpp\v4.0\Platforms\[Win32|x64]\PlatformToolsets\v100\1033\" exists, copy all files to “<program files> \MSBuild\Microsoft.Cpp\v4.0\Platforms\[Win32|x64]\PlatformToolsets\v100\<locale-ID>”.

    * The <locale-ID> is the language pack.

    Another method is to uninstall and then reinstall the Intel C++ Compiler.
  • Context sensitive (F1) Help issue with Microsoft* Edge*
  • If Microsoft* Edge* is set as the default browser for Microsoft* Visual Studio*, context-sensitive (also known as F1) calls to a specific feature/function will open the title page of the corresponding document instead of the topic related to the feature/function description.  Allow correct behavior by changing Microsoft* Visual Studio* settings to use a different default browser.
  • The Intel® C++ Compiler IDE integration into Visual Studio 2015* update 1 has an issue with the link to the Code Coverage report in the output window.  Only the part before the first space in the path is included in the link:
  • Code Coverage log was saved at  "file:\\C:\Users\Documents\Visual Studio 2015\Projects\ConsoleApplication6\ConsoleApplication1\x64\Release\CCovLog.html"
  • To work around this issue, copy the link from the output window and open it on the file system.

Known Issues with Intel® Many Integrated Core Architecture (Intel® MIC Architecture)

  • Limitations of _Cilk_shared
    • A virtual base class may not have the _Cilk_shared attribute 
    • A class with the _Cilk_shared attribute may not be derived from multiple base classes (multiple inheritance is disallowed) 
    • A class with the _Cilk_shared attribute may not define a virtual destructor 
    • A class with the _Cilk_shared attribute, if used as a base class of another _Cilk_shared class, must be rounded up to be a multiple of 8 in size by the programmer (by adding dummy fields as needed)
    • _Cilk_offload may not be used in a program that uses shared libraries (DLLs)
  • Using offload code in shared libraries requires main program to be linked with /Qoffload=mandatory or /Qoffload=optional option

    There is initialization required for offload that can only be done in the main program. For offload code in shared libraries, this means that the main program must also be linked for offload so that the initialization happens. This will happen automatically if the main code or code statically linked with the main program contains offload constructs. If that is not the case, you will need to link the main program with the /Qoffload=mandatory or /Qoffload=optional compiler options.
  • Missing symbols not detected at link time for the offload compilation model

    /Qoffload-option,mic,compiler,"-z defs" is no longer needed to detect missing symbols at link time.
  • *MIC* tag added to compile-time diagnostics

    The compiler diagnostics infrastructure is modified to add an additional offload *MIC* tag to the output message to allow differentiation from the target (Intel® MIC Architecture) and the host CPU compilations. The additional tag appears only in the target compilation diagnostics issued when compiling with offload extensions for Intel® MIC Architecture.

    In the examples below the sample source programs trigger identical diagnostics during both the host CPU and Target Intel® MIC Architecture compilations; however, some programs will generate different diagnostics during these two compilations. The new tag permits easier association with either the CPU or Target compilation

    $ icl -c sample.c

    sample.c(1): warning #1079: *MIC* return type of function "main" must be "int;
    void main()
    sample.c(5): warning #120: *MIC* return value type does not match the function type
      return 0;
    sample.c(1): warning #1079: return type of function "main" must be "int"
     void main()
    sample.c(5): warning #120: return value type does not match the function type
      return 0;

  • Runtime Type Information (RTTI) not supported

    Runtime Type Information (RTTI) is not supported under the Virtual-Shared memory programming method; specifically, use of dynamic_cast<> and typeid() is not supported.
  • Direct (native) mode requires transferring runtime libraries like to coprocessor

    The Intel® Manycore Platform Software Stack (Intel® MPSS) no longer includes Intel compiler libraries under /lib, for example the OpenMP* library,

    When running OpenMP* applications in direct mode (i.e. on the coprocessor card), users must first upload (via scp) a copy of the Intel® MIC Architecture OpenMP* library (<install_dir>\compilers_and_libraries_2016\windows\lib\mic\ to the card (device names will be of the format micN, where the first card will be named mic0, the second mic1, and so on) before running their application.

    Failure to make this library available will result in a run-time failure like:

    /libexec/ Shared object "" not found, required by "sample"

    This can also apply to other compiler runtimes like The required libraries will depend on the application and how it’s built.
  • Calling exit() from an offload region

    When calling exit() from within an offload region, the application terminates with an error diagnostic “offload error: process on the device 0 unexpectedly exited with code 0

Known issues for offload to Intel® Graphics Technology

  • gfx_linker: : error : command 'ld.exe' exited with non-zero exit code -107374170

    When offloading code to Intel® Graphics Technology in an x64 project, you may get a linker error with the ld.exe provided by binutils. To resolve this problem, add the binutils bin directory for the 64-bit linker to your PATH environment variable and then restart Microsoft Visual Studio*.
  • Host-side execution of offload code is not parallelized

    The compiler will generate both a target and host version of the parallel loop under #pragma offload. The host version is executed when the offload cannot be performed (usually when the target system does not have a unit with Intel® Graphics Technology enabled).The parallel loop must be specified using the parallel syntax of cilk_for or an Array Notation statement, which has parallel semantics for offload. The target version of the loop will be parallelized for target execution, but there is a current limitation where the host-side back-up version of the parallel loop will not be parallelized. Please be aware this can affect the performance of the back-up code execution significantly when offload execution does not happen in the case of cilk_for use. Array notation does not currently generate parallel code on the host, so performance should not differ here in that case. This is a known issue that may be resolved in a future product release.
  • Other known limitations with offload to Intel® Graphics Technology
    • On Windows 7*, for offloading to happen, the display cannot be locked. An active display is required.
    • In the offloaded code, the following are not allowed:
      • Exception handling
      • RTTI
      • longjmp/setjmp
      • VLA
      • Variable parameter lists
      • Virtual functions, function pointers, or other indirect calls or jumps
      • Shared virtual memory
      • Data structures containing pointers, such as arrays or structs
      • Globals with pointer or reference type
      • OpenMP*
      • cilk_spawn or cilk_sync
      • Intel® Cilk™ Plus reducers
      • ANSI C runtime library calls (with the exception of SVML, math.h, and mathimf.h calls and a few others)
    • 64-bit float and integer operations are inefficient

Intel® Cilk™ Plus Known Issues

  • Microsoft C++ Structured Exception Handling (SEH) will fail if an SEH exception is thrown after a steal occurs and before the corresponding _Cilk_sync

Guided Auto-Parallel Known Issues

  • Guided Auto Parallel (GAP) analysis for single file, function name or specific range of source code does not work when Whole Program Interprocedural Optimization (/Qipo) is enabled

Spurious error when a call to a template dependent function is made in a decltype expression in an out-of-line definition for a late-specified return type

  • This is a known regression in Intel® C++ Compiler 16.0 Update 2.  An example is:
  • template <class T>
    struct C {
      int then(int*,int*);
      template <class T2>
      auto then(T2 arg) -> decltype(this->then(&arg, &arg));
    template <class T>
    template <class T2>
    auto C<T>::then(T2 arg) -> decltype(this->then(&arg, &arg)) { return 0; }
    void foo() {
       C<int> f;
    To work around this problem, the definition can be moved inline, or the use of a late-specified return type should be avoided (by explicitly declaring the return type). 

Back to top

Disclaimer and Legal Information

Optimization Notice
Intel's compilers may or may not optimize to the same degree for non-Intel microprocessors for optimizations that are not unique to Intel microprocessors. These optimizations include SSE2, SSE3, and SSSE3 instruction sets and other optimizations. Intel does not guarantee the availability, functionality, or effectiveness of any optimization on microprocessors not manufactured by Intel. Microprocessor-dependent optimizations in this product are intended for use with Intel microprocessors. Certain optimizations not specific to Intel microarchitecture are reserved for Intel microprocessors. Please refer to the applicable product User and Reference Guides for more information regarding the specific instruction sets covered by this notice. Notice revision #20110804


Intel may make changes to specifications and product descriptions at any time, without notice. Designers must not rely on the absence or characteristics of any features or instructions marked "reserved" or "undefined." Intel reserves these for future definition and shall have no responsibility whatsoever for conflicts or incompatibilities arising from future changes to them. The information here is subject to change without notice. Do not finalize a design with this information.

The products described in this document may contain design defects or errors known as errata which may cause the product to deviate from published specifications. Current characterized errata are available on request.

Contact your local Intel sales office or your distributor to obtain the latest specifications and before placing your product order.

Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or go to: 

Intel processor numbers are not a measure of performance. Processor numbers differentiate features within each processor family, not across different processor families. Go to:

The Intel® C++ Compiler is provided under Intel’s End User License Agreement (EULA). 

Please consult the licenses included in the distribution for details.

Intel, Intel logo, Pentium, Core, Atom, Iris, Xeon, Xeon Phi, and Cilk are trademarks of Intel Corporation in the U.S. and other countries.

* Other names and brands may be claimed as the property of others.

Copyright © 2016 Intel Corporation. All Rights Reserved.

Back to top

For more complete information about compiler optimizations, see our Optimization Notice.