This product provides tools for Windows software developers to create applications that run at top speeds on all Intel® IA-32 processors and the Intel Itanium processors. Optimizations include support for Streaming SIMD Extensions 2 (SSE2) in the Intel Pentium 4 and Pentium M processors, Streaming SIMD Extensions 3 (SSE3) in the Intel Pentium 4 processors with SSE3 support, and software pipelining in the Intel Itanium 2 processor. Inter-procedural optimization (IPO) and profile-guided optimization (PGO) can provide greater application performance. Intel Compilers support multithreaded code development through auto parallelism and OpenMP support.

Tools provided include the Intel C++ Compiler 8.1 for Windows, the Intel Debugger 8.1, the Assembler 7.0 for Itanium-based systems and integration with Microsoft Visual Studio .NET 2002 & 2003 and Microsoft Visual C++ 6 (Visual Studio 98). This version of the compiler also includes two new tools, the Intel Compiler's code-coverage tool and the Intel Compiler's test-prioritization tool.

There are three variations of the Intel C++ Compiler for Windows:

• One compiler runs on IA-32 systems and produces applications that run on IA-32 systems.
• A second compiler runs on IA-32 systems but produces Itanium-based applications.
• The third compiler runs on Itanium-based systems and produced Itanium-based applications.

The Intel C++ Compiler provides integration into Microsoft's Integrated Development Environment (IDE) provided with Microsoft Visual C++ .NET 2002 and 2003 versions and Microsoft Visual C++ 6 on IA-32 systems. You should expect differences among the binaries to target each of these versions with the following command line options: /Qvc6, Qvc7, and Qvc7.1.

To download a free evaluation version of Intel C++ Compiler for Windows click link below.

Deliver outstanding performance on single and multiprocessor computers with advanced optimization techniques to keep your legacy code in shape.

Reduce time-to-market, optimize your code for Intel® architecture and leverage existing investments with the latest Intel Fortran Compiler 8.1 for Linux updates:

• Includes support for Intel® Extended Memory 64 Technology (Intel® EM64T) with features required to develop high performance applications using Intel EM64T.

Note: The Intel Fortran Compiler 8.1, Extended Memory 64 Technology Edition for Linux is a separate executable that is included with Intel Fortran Compiler 8.1 for Linux. Please check your Intel Premier Support account for specific download information.
• Simplifies compiler options, for example the -fast option combines the four existing compiler options /03, /Qipo, /static and /QxP into a single compiler option.
• Provides optimization support for the latest Intel Xeon® processors.
• Allows developers to profile applications given specific workloads with the Compiler Code-Coverage Tool.
• Automates selection and prioritization of application tests to save testing time using the Compiler Test-Prioritization Tool.

The flagship for HPC software, Intel® MKL is a set of highly optimized, thread-safe, mathematical functions for engineering, scientific, and financial applications requiring high performance.

To sign up for a free 30-day evaluation license, click link below.

Improve High-Performance Applications Using Intel® Cluster Tools

Create, analyze, and optimize high-performance applications on clusters of Intel® processor-based systems with the help of Intel® Cluster Tools.

• Multithreaded Application Support, including OpenMP and auto-parallelization for simple and efficient software threading. .
• Interprocedural Optimization (IPO) dramatically improves performance of small- or medium-sized functions that are used frequently, especially programs that contain calls within loops. .
• Profile-Guided Optimization (PGO) improves application performance by reducing instruction-cache thrashing, reorganizing code layout, shrinking code size, and reducing branch mispredictions. .
• Automatic Vectorizer parallelizes code and aligns data, including loop peeling to generate aligned loads and loop unrolling to match the prefetch of a full cache line.
• High-Level Optimization (HLO) delivers aggressive optimization with loop transformation and pre-fetching.
• Intel® Debugger improves the efficiency of the debugging process on code that has been optimized for Intel® architecture.

The new Intel® Cluster Toolkit 1.0 provides five software development solutions in one integrated bundle. This "one stop shop" supports all essential phases of the message-passing interface (MPI) application development process for Intel® processor-based cluster systems running Linux.

To sign up for a free 30-day evaluation license, click link below

Deliver outstanding performance on single and multiprocessor computers with advanced optimization techniques to keep your legacy code in shape, including support for multi-core processors, OpenMP support and auto-parallelization.

The Intel® Fortran Compiler for Linux* delivers rapid development and winning performance for the full range of Intel® processor-based platforms.

This compiler product automatically optimizes and parallelizes software to take best advantage of multi-core Intel processors. This compiler is also available as a separate product that incorporates Cluster OpenMP*. The Intel Fortran Compiler for Linux with Cluster OpenMP provides all the functionality of the Intel Fortran Compiler for Linux, plus a simple means of extending OpenMP parallelism to 64-bit Intel® architecture-based clusters.

To sign up for a free 30-day evaluation license, click link below

When using threading in a performance critical-application, it is possible for the overhead associated with thread creation and destruction to overwhelm the benefits of utilizing threads. One method to mitigate this problem is to use a thread pool. This document defines and provides examples of thread pools, as well as suggesting when and when not to use one and providing a sample implementation of a thread pool in C++. It does not show implementations in any other languages, although the concepts delineated here can be used with other languages.

Background
With the advent of Hyper-Threading technology, threading in applications is more important to fully utilize a modern processor. A thread pool, which consists of a group of threads that are pre-allocated near the beginning of program execution and re-used again and again, can help to avoid some of the overhead associated with creating and destroying threads.

There is no definitive rule to determine whether a thread pool will benefit an application. As a general guide, applications that use many threads or that continually create and destroy threads to do small amounts of work are good candidates for a thread pool. Unfortunately, the best way to know is to implement a thread pool and test its performance in an application. The overhead to the programmer of doing this can be minimized by using Classes that abstract the thread pool, thus allowing the programmer to write the code to implement a thread pool once and then to re-use it many times. The details of properly abstracting a thread-pool class are beyond the scope of this document.

Sample code
The source code included here contains a simple implementation of a thread pool. Its Main() routine compares three methods of thread control to do a trivial piece of work.

The first method utilizes the thread pool to do the work. Further discussion of how the thread pool implementation works is discussed later in this document. The second method creates four threads and waits for each thread to complete execution before looping and creating another four threads, which is repeated until all of the necessary work is completed. The third method simply creates threads as fast as it can with no bounds on the number of threads.

To run the example, you must first compile the source code. This code was written for Win32 using Microsoft Visual C++ 6.0. It may work with other compilers and operating systems with some modifications. After compiling, execute the generated .exe file.

Sample code result
Each method will execute in turn and print the runtime of that method in milliseconds. The output of the example will obviously vary, depending on the speed of the processor that it is executed on. In general, the thread-pool method should be the fastest. Although the difference in execution times is small in this example, one should expect to see significant time differences in a larger, real-life implementation (for example in a video encoder).