Introduction

Nearly every class and function that we have added to Intel® Threading Building Blocks (Intel® TBB) since its first version have been designed to address users' needs. We actively work with our users via the forum and constantly incorporate suggestions for improvements made by our commercial customers and members of the Intel TBB open source community. We regularly publish Intel TBB non-commercial developer releases at www.threadingbuildingblocks.org and for several years this has served as a good way to get early feedback on new features we were introducing. In order to provide access to new features to a wider range of Intel TBB users, we are introducing a new class of features, called Community Preview (CP) features, which will be added to Intel TBB commercial product updates.

Definition of Community Preview (CP) features

The main idea with CP features is to provide a more responsive way to get early feedback on features by delivering them earlier to both commercial and open source users of Intel TBB). In general, a CP feature is a new, production-quality, and fully-tested capability that we add to the library (new class or a collection of classes, new function etc.) for all users of Intel TBB: commercial users get access to the CP features via regular product updates and members of the open source community get them via commercially-aligned open source releases that we publish around the official release of commercial update. The major difference between a CP feature from a regular Intel TBB feature is that the CP feature is not enabled by default and when developers are ready to try it out they will have to enable it manually either by defining a compiler macro or, in some cases, linking with a special library. For each particular CP feature we will publish enabling instructions in the product documentation where it is clearly marked as a CP feature.

Support Model for CP features

Each new release of Intel TBB is backward-compatible with the previous versions: the Intel TBB development team makes sure that interfaces implemented by the library stay unchanged and are committed to keeping Intel TBB backward-compatible. The nature and purpose of CP features is different from all other features of Intel TBB: we introduce CP features to gather early feedback from users and therefore we may need to change interfaces related to a CP feature based on users' feedback. Here is the summary of differences in support model for CP features:

• Documentation on a CP feature might be incomplete

• The implementation of a CP feature is separated from the rest of the library features (separate header file and/or additional library) and usage of a CP feature requires special enabling

• Backward-compatibility is not guaranteed for CP features: we might change interfaces or the entire implementation based on users' feedback

• Future support of each CP feature is not guaranteed: we might drop the feature entirely based on users' feedback

Due to the different support model for CP features, developers should not use them in their production code.

Conclusion

CP features are a new and, we believe, better way to communicate with users of Intel TBB: we deliver innovative features to developers faster and in a more convenient way than before. We hope users will follow announcements on new CP feature availability and use them: we look forward to your feedback and we are committed to improving interfaces and implementations of CP features based on your feedback and converting the most useful CP features into fully supported Intel TBB features.

Step 2 . Link IPP library in your application
From the Menu >> project (or right-click the Project in Solution Explorer) select Intel Parallel Composer 2011 » Select Build Components, Check the box Use IPP. The setting will link IPP dynamic library atomatically.  If your application is build sucessfully, you can run the exe. 

Note
1. If you'd like link the IPP static library, please download and install IPP static library first.  See Download IPP Static Libraries for Intel Parallel Studio. 
2. If you'd like link the IPP library and set IPP library path manually,  you may follow the steps on Compiling and Linking Intel® IPP with latest Intel® C++ Compilers
3. If you run into any IPP issues, please refer to the KB How to Build an Intel IPP Application => Troubleshooting - Compile and Linking Errors or report your issue to IPP forum.

1. Right click on the file (perf.cpp), select "Intel Parallel Composer 2011" or "Intel C++ Composer XE", then select "Use Intel C++ for selected file(s)"
   
2. Build the project

As you can see, it's just one STEP to build one hot-spot file with Intel C++ Compiler.

In the previous Intel Parallel Composer or Intel C++ Compiler for Windows 11.1, it takes several steps like below in order to build only one file in a project with Intel C++ Compiler:

1. Set the project to use Intel C++:
   • Right click on the project name
   • Select "Intel Parallel Composer" or "Intel C++ Composer XE" from the pop-up menu, then select "Use Intel C++"
2. Set the project to use Visual C++ compiler in project property dialog:
   • Open project property dialog, select "General" tab
   • in the "Compiler and Environment Settings" field Select "Microsoft Visual C++ Compiler"
3. Set the one hot-spot file (perf.cpp) to use Intel C++:
   • Open perf.cpp's property dialog, select "General" tab
   • in the "Compiler and Environment Settings" field Select "Intel C++ Compiler"
   • If the precompiled header file is used, turn it off.
4. Build the project.

1. Download the macro tool by clicking here (or download the attachment below) and extract the macro file "IntPkgMacros.vsmacros" to a location like [composer2011-install-dir]\Composer\VS Integration\C++
2. Open Visual Studio 2010 and load one of your application solution
3. Select menu "Tool -> Macros -> Load Macro Project" and select the above macro file
   
4. Open the Macro Explorer window from menu "View -> Other Windows -> Macro Explorer"
   1. in Macro Explorer, select IntPkgMacros -> ListProjectsUisngIntelc, right click on "ListIntelPrjsActiveCfg", select "Run"
      
   2. when the macro finished work, you will see something like below in the output window:
      

      Intel-specific projects for all configurations
      =================================================================
      forTest\pi [Debug|Win32] --> Intel Parallel Composer 2011
      forTest\pi [Release|Win32] --> Intel Parallel Composer 2011

      
      "forTest\pi" is the project "pi" under the folder "forTest".
      [Debug|Win32] or [Release|Win32] is configuration.

Features	Visual Studio 2005 or 2008	Visual Studio 2010
Toolbar: Intel Parallel Debugger Extension		Same as left
Toolbar: Intel C++		None
Icon for project using Intel C++ compiler		None Please see this article for alternative.
Project context menu	Or	Same as left except no "Select Build Components" menu item.
Set a solution or project to use Intel C++ from command line	>> ICProjConvert120 myProj.sln /IC >> ICProjConvert120 lib1.vcproj /IC	None
Set a solution or project to use Intel C++ within IDE	1. Select the solution or project or projects 2. Click on 2nd icon on 3. Or right click on the solution or selected project(s), select "Intel Parallel Composer 2011 -> Use Intel C++" from Context Menu 4. Or click menu "Project", select "Intel Parallel Composer 2011 -> Use Intel C++"	Same as left except #2 is not supported here.
Set only the hotspot file to use Intel C++ Note: if the source file is set to use Precompiled Headers, change to "Not Using Precompiled Headers" before compiling from the file's property page.	1. Right click on the source file name "hotspot.cpp" 2. Select "Intel Parallel Composer 2011 -> Use Intel C++ for Selected File(s)..." from Context Menu or	Same as left
Use Intel IPP and Intel TBB in a project	Click 4th icon on	1. Open project(s) property dialog 2. Select "Intel Performance Libraries" tab right above "VC++ Directories" tab ** See the tab with orange oval in the picture below
Set Intel C++ Compiler specific options	Look for "Intel Specific" on each property page:	Look for tab name with "Intel":
Support batch mode build	Yes >>Devenv.exe /rebuild "Debug|Win32" hello.sln /out "build.out" /IntelSpecific Intel "Intel(R) C++ 12.0.xxx"	No
Support MSBuild	No	Yes >>msbuild nq-serial.vcxproj /t:rebuild /p:configuration=release
Setting default options for all projects using Intel C++ compiler	From Tools Options dialog, select "Intel C++"	Similar to left, added "Convert" page with default settings for converting .icproj data created for VS2005/2008 project into .vcxproj for VS2010 project:
What happens when setting a project to use Intel C++	1. .sln is modifed to load the Intel C++ IDE packages. 2. .vcproj file is not modified. 3. A .icproj file is created for each .vcproj file to store Intel C++ specific options; if a .icproj already exists, it will be reused when switching to Intel C++.	1. .sln is not modified 2. .vcxproj is modified 3. The Intel C++ specific options are stored in .vcxproj file
What happens if you uninstalled Intel Parallel Composer 2011, but forgot to reset the project back to use Visual C++	1. The project can not be loaded. 2. You need to use "ICProjConvert120.exe" to reset from command line >> ICProjConvert120.exe hello.sln /VC	1. The project will load, but will not compile. 2. You just need to change the "Platform toolset" on the Project Property page to "v100"

The Intel® C++ Compiler 12.0 available in Intel® Parallel Composer 2011 and Intel® C++ Composer XE now supports the atomic data types.  These standard data types provide a standard way of implementing fine grained atomic locking in C and C++ which can be useful for many different parallel methodologies, from native threads to Intel® Threading Building Blocks to OpenMP* to Intel® Cilk™ Plus.  This article covers the basic syntax and how it works to ensure threadsafe accesses of shared data.

Atomics Requirements

• Intel® Parallel Composer 2011
• #include the <atomic> or <stdatomic.h> header files

atomic_flag

The atomic_flag data type is the basis for all atomic data types.  It provides two operations that can be done atomically - a test and set operation, and a clear operation.  The flag is a bool that is set to 0 when clear() is used.  For test_and_set, the current value of the bool is returned and then the flag is set to 1.

The syntax for this is:

In short, void* (as atomic_address), bool (atomic_bool), and various char/integer types are supported.  These can also be alternatively declared in C++ using atomic<T> where T is void*, bool, or the char/int type.

atomic_bool supports the following operations:

bool load()
-- Atomically return the value of atomic_bool.  Can also happen when using the "=" assignment operator or during conversions.

void store(bool)
-- Atomically set the value of atomic_bool.  Can also happen when using the "=" assignment operator or during conversions.

bool exchange(bool)
-- Atomically swap the values of the current atomic_bool with the boolean input.  Return the old value of the atomic bool.

bool compare_exchange_weak(bool & expected, bool desired)
-- Atomically: compare the current value of atomic_bool with expected.  If equal, set atomic_bool value to value of desired and return true.  If not equal, set expected to desired value and return false.  Intended for use in loops.

bool compare_exchange_strong(bool & expected, bool desired)
-- Atomically: compare the current value of atomic_bool with expected. If equal, set atomic_bool value to value of desired and return true. If not equal, set expected to desired value and return false. Intended for use outside of loops.

atomic_address supports the above atomic_bool operations for void* types, and also the following:

Operator +=(void*)
-- Atomically increment the atomic_address by the input number of bytes and store

Operator -=(void*)
-- Atomically decrement the atomic_address by the input number of bytes and store

Other atomic types:

The other types that are supported:

• atomic_char16_t
• atomic_char32_t
• atomic_wchar_t
• atomic_char
• atomic_schar
• atomic_uchar
• atomic_short
• atomic_ushort
• atomic_int
• atomic_uint
• atomic_long
• atomic_ulong
• atomic_llong
• atomic_ullong

Technical Support

Visit our online Community Support User Forums and Knowledge Base to get all of the help you need from our own tools and parallelism experts, and your fellow developers. Go tohttp://software.intel.com/en-us/articles/intel-software-developer-support/to start your search.

The Intel® C/C++ Compiler version 11 also includes support for AES-NI, see How to Compile for the Intel® Core^TM i5 processor with AES-NI, as does Microsoft* Visual Studio* 2008 Service Pack 1 compiler and gcc version 4.4.

How to Download the Cryptography Library Add-on for the Intel IPP Library

The cryptography component of the IPP library is subject to US Export Administration Regulations and other US laws. To obtain the Intel IPP cryptography libraries, which must be downloaded separately, register for eligibility and follow the instructions you receive in the registration email. If you have additional questions review this knowledge base article on how to download the cryptography library component of the IPP library.

You must have a valid Intel IPP license key to install and use the Intel IPP libraries.

To see an advantage of AES-NI optimization in the crypto engine, refer to AES-NI demo. 

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

This article is intended to assist developers new to the Intel compilers on how to get maximum performance on IA-32, Intel® 64 and Itanium® processor platforms on the Microsoft Windows*, Linux*, and Mac OS* X operating systems.

Answers to common questions customers have about Intel compilers are provided. The following sections discuss how to use the compilers and what to do if you encounter problems, including some troubleshooting techniques. This article also presents a high-level discussion of some of the available optimizations with tips for improving performance.

First, see whether your source code will compile with the appropriate Intel compiler. On the Windows side, Intel® Parallel Composer and the Intel C++ Compiler for Windows* Professional Edition are source and object compatible with the Microsoft Visual C++* compiler, so they compile source code that the Microsoft Visual C++ compiler can compile. The Intel Visual Fortran Compiler for Windows is substantially source compatible with Compaq Visual Fortran* and conforms to the Fortran 95, Fortran 90, and Fortran 77 standards.

The Intel C++ Compilers for Linux and Mac OS X are object compatible with GNU* C and C++. The Intel Fortran Compilers for Linux and Mac OS X also conforms to the Fortran 95, Fortran 90, and Fortran 77 standards.

If the compile fails, check your source code for unsupported language extensions. For example, if you are compiling a file with a GNU gcc language extension - an extension the Intel compiler does not support - the compiler issues a syntax error. Similarly, for Fortran, if you are compiling code that violates the Fortran 95, Fortran 90, or Fortran 77 standards or contains language extensions the compiler doesn't recognize, the Intel compiler issues a syntax error. The best way to solve this type of problem is to rewrite the source code, so that it either conforms to the standards or doesn't contain unsupported extensions. Do note, the Intel compiler may give errors for non-compliant source code even in cases where it may be accepted by other compilers.

Once the application is built, typically the next step is to run it with a set of tests. The tests are run to ensure outputs are correct.

If some tests fail, try compiling the files of the application being tested using /Od (Windows) or -O0 (Linux/Mac) to turn off the optimizer. Optimizations are discussed below.

If the test still fails using /Od, there likely is a problem in the source code. It is also possible that the compiler is generating incorrect code. Should that happen, please report the problem to Intel.

The basic optimization switches of the Intel compilers are:

• -Od or -O0 (no optimizations)
• -O1 (optimize for speed while focusing on code size)
• -O2 (optimize for speed)
• -O3 (optimize for speed and perform aggressive optimizations).

It is recommended that you use -O2 optimizations if possible. The Intel compilers default to use -O2. Using -O3, the compiler performs aggressive optimizations, so make sure to run your application tests to ensure all your tests pass at -O3.

Refer to the article at http://software.intel.com/en-us/articles/performance-tools-for-software-developers-intel-compiler-options-for-sse-generation-and-processor-specific-optimizations/

Interprocedural optimizations (-ipo and /Qipo) improve performance within a file and across a multi-file program. The optimizations performed include function inlining, interprocedural constant propagation, dead code elimination, and others.

Profile guided optimizations (-prof_use and /Qprof_use) can be used to improve the performance of a program by passing run-time information back to the compiler. This can be used to improve branch prediction, cache utilization, and make better choices of functions to inline.

It is always a good practice to test your application when using aggressive compiler optimizations like Interprocedural Optimizations and Profile Guided Optimizations. Issues with these optimizations are more difficult to debug than those with standard optimizations.

If your program runs successfully with /Od but fails with /O2, the next step is to determine which files are causing the problem. Problematic files can then be compiled with -Od. A divide-and-conquer strategy would be beneficial here. First, compile half the files (for example files that start with a-m) with /O2 and the rest with /Od. If the program passes the tests, then the problem is somewhere in the files starting with n-z, and files a-m can be compiled with /O2. See the next section,"Should I worry about precision?"

When the optimizer is turned on, there may be a minor loss or gain of precision. For example, on IA-32, a double-precision floating-point value is stored as 80 bits in the x87 FPU registers, and intermediate calculations are carried out to this precision. When a value is stored to memory from the x87 FPU registers, it is rounded to declared precision. If your code is sensitive to slight variations in precision, its behavior may change under optimization. You can either add the -fp-model precise (in Linux/Mac) or /fp:precise (in Windows) switches to enforce IEEE precision, or you can rewrite the code. These switches may have a performance impact on your application. For more details please see the article, Consistency of Floating Point Results using the Intel(R) Compiler.

The software version of the "80/20 rule" is that 80% of a program is spent in 20 %of the code. It is recommended that you obtain a performance analysis tool that will show you where exactly your program spends its time. Intel offers the VTune™ Performance Analyzer and Intel® Parallel Amplifier tools for this purpose. The analysis shows you exactly which lines of your program are taking most of the execution time and provides you with tips for improving your code.

Intel wants you to be successful in your use of its compilers. We encourage you to submit any questions or issues in the appropriate compiler User Forum.  However, if you believe you have a technical issue or need 1:1 attention, a year of product support through Intel Premier Support is included with all purchases, and Intel Premier Support is also provided as part of the 30-day evaluation process. Please register for support here, then once you have registered, please login here and submit your issue. A developer support engineer will get back to you within one business day.

When submitting a compile time problem, please submit a test case with your issue. In the case of a C++ issue, submit a pre-processed file using the /P (Windows) or -E (Linux/Mac OS X) options. Note that a preprocessed file will contain any code in your source file and also any included header files that's not eliminated by #if processing.  If you don't submit a test case, we will attempt, where feasible, to construct one with the symptoms you provide, but reproducing these is often difficult. When submitting a run-time issue, it is preferred that you send us the function in your program that is failing along with a driver that calls the function and demonstrates the failure.

For performance related issues, wherever possible, please determine the source of the problem using a performance analyzer like the VTune Performance Analyzer. One thing to keep in mind: in general, the smaller the test case you submit the more quickly a support engineer and the engineering team will be able to address your problem.

In all cases, please give us your complete compiler options used or Visual Studio project, and linker options and runtime arguments/environment settings if applicable.

• Evaluate the Intel Compilers for free.
• Get more information about Intel Compilers, Intel® Parallel Composer, VTune™ Performance Analyzer and Intel® Parallel Amplifier Information available includes product overviews, case studies, getting started guides, and compatibility information.
• Join our developer community at the User Forums.
• Explore our Knowledge Base.