Intel® - C++ Compiler, Professional and Standard Editions, for Mac OS*

	Intel® Software Development Products for Intel® Platforms and Technologies

Intel® C++ Compiler 10.1, Professional and Standard Editions for Mac OS* X

Overview	Features in Depth	System Requirements
Features	Compatability	Print
New in This Release	Technical Support

Overview

Intel® C++ Compiler Professional Edition offers the best support for creating multi-threaded applications. Only the Professional Edition offers the breadth of advanced optimization, multi-threading, and processor support that includes automatic processor dispatch, vectorization, auto-parallelization, OpenMP*, data prefetching, and loop unrolling, along with highly optimized C++ templates for parallelism, math processing, and multimedia libraries.

The Professional Edition combines a high performance compiler with Intel® Threading Building Blocks (Intel® TBB), Intel® Integrated Performance Primitives (Intel® IPP) and Intel® Math Kernel Library (Intel® MKL). While these libraries are available separately, the Professional Edition creates a strong foundation for building robust, high performance parallel code at significant price savings.

The Standard Edition compiler has the same performance and features as the Professional Edition compiler, but does not provide the multi-threaded libraries.

Product Brief [PDF 148KB]

Features

The Intel® C++ Compiler for Mac OS X delivers rapid development and winning performance for the full range of Intel processor-based platforms.

Automatically optimize and parallelize software to take best advantage of multi-core Intel processors, including dual-core mobile, desktop, and enterprise platforms.

Mac* and Multi-Core Capabilities

The following features specifically address the architecture capabilities of Intel® processor-based Macs:

	Multi-Threaded Application Support, including OpenMP* and auto-parallelization, allows you to take full advantage of multi-core technology like the Intel® Core™ microarchitecture.
	*Xcode Integration** allows developers to continue working with this familiar environment while benefiting from the advanced capabilities of the Intel® compiler.
	Includes Interoperability with GCC 4.0: excellent GCC source, binary, and command line compatibility.
	Support for Apple Frameworks puts this powerful Apple programming model to work on Intel Core microarchitecture-based platforms.

Performance

Consider the Intel® C++ Compiler Professional Edition to maximize performance on the latest multi-core processors. The built-in optimization technologies and multi-threading support help create code that runs best on the latest multi-core processors.

Advanced Optimization Features

Mac hardware based on Intel® processors can also benefit from advanced optimization features, a few of which are explained briefly here, with links to more complete descriptions.

	Auto-vectorization parallelizes code to utilize the Streaming SIMD Extensions (SSE) instruction set architectures (SSE, SSE2, SSE3, SSSE3, and SSE4) of our latest processors.
	High-Performance Parallel Optimizer (HPO)restructures and optimizes loops to ensure that auto-vectorization, OpenMP, or auto-parallelization best utilizes the processor’s capabilities for cache and memory accesses, SIMD instruction sets, and for multiple cores. This revolutionary capability, new in Version 10, combines vectorization, parallelization and loop transformations into a single pass which is faster, more effective and more reliable than prior discrete phases.
	Interprocedural Optimization (IPO)dramatically improves performance of small- or medium-sized functions that are used frequently, especially programs that contain calls within loops. The analysis capabilities of this optimizer can also give feedback on vulnerabilities and coding errors, such as uninitialized variables or OpenMP API issues, which cannot be detected as well by compilers which rely strictly on analysis by a compiler front-end.
	Profile-guided Optimization (PGO) improves application performance by reducing instruction-cache thrashing, reorganizing code layout, shrinking code size, and reducing branch mispredictions.
	Optimized Code Debugging with the Intel® Debugger improves the efficiency of the debugging process on code that has been optimized for Intel® architecture.

New in This Release

The Intel C++ Compiler for Mac OS X builds on a winning foundation. Position yourself to create next-generation software, for next-generation hardware. The following features are new since Version 9 of the compiler.

What's new

Benefit to you

Improved Performance and Threading

New Parallel/Loop Optimizer (HPO)

Better application performance for computationally intensive applications such as graphics/digital media, financial modeling, and high-performance computing for threaded and non-threaded applications. Our new High Performance Parallel Optimizer, HPO, offers an improved ability to analyze, optimize, and parallelize more loop nests.

Security Checking and Diagnostics

	GNU Mudflap
	Static Verifier for buffer overflow
	OpenMP* API verification

Ability to create code that is less susceptible to security vulnerabilities, such as buffer overflow. The diagnostics are very helpful for novice and expert users for catching common coding errors, from unitialized variables to mismatched dummy and actual arguments to OpenMP API coding issues.

64-bit Mac OS* X Support

Ability to create applications that take advantage of the addressing and performance capabilities enabled by Intel® 64 architecture-based processors used in the latest Apple Mac OS X systems.

Optimization Reports

More detailed optimization diagnostics for users who want to use our advanced optimizations to help the compiler do a better job at tuning their applications.

Options to enable more advanced optimizations for loop unrolling, streaming stores and pointer aliasing

Improved application performance.

Option to select alternate algorithms for malloc

Increased flexibility when allocating memory.

Support for the Latest Multi-Core Processors
The Intel C++ Compiler provides optimization support for the very latest multi-core processors, including:

	Intel® Core™2 Duo processor
	Intel® Core™2 Quad processor
	Quad-Core Intel® Xeon® processor 5300 series
	Dual-Core Intel® Xeon® processor 3000 series
	Dual-Core Intel® Xeon® processor 5000 series
	Dual-Core Intel® Xeon® processor 7000 series
	Dual-Core Intel® Itanium 2 processor

Intel® compilers future-proof your investment with assurance of world-class support for each successive generation of processors. That's a key advantage in a world where new hardware platforms come to market with awesome speed.

Support for auto-parallelization and OpenMP enable you to create optimized, multithreaded applications that take full advantage of multi-core processing features to deliver outstanding performance.

Professional Edition

Includes not only the advanced capabilities of the compiler, but also Intel® Threading Building Blocks, Intel® Integrated Performance Primitives, and Intel® Math Kernel Library with highly optimized functions for threading, math processing, and multimedia.

Advanced Optimization Features in Depth

This section gives detailed descriptions of the compiler’s advanced optimization features.

Multi-Threaded Application Support

OpenMP and auto-parallelization help convert serial applications into parallel applications, allowing you to take full advantage of multi-core technology like the Intel® Core™ Duo processor and Dual-Core Intel® Itanium® 2 processor, as well as symmetric multi-processing systems:

	OpenMP* is the industry standard for portable multithreaded application development. It is effective at fine-grain (loop-level) and large-grain (function-level) threading. OpenMP directives are an easy and powerful way to convert serial applications into parallel applications, enabling potentially big performance gains from parallel execution on multi-core and symmetric multiprocessor systems.
	Auto Parallelization improves application performance on multiprocessor systems by means of automatic threading of loops. This option detects parallel loops capable of being executed safely in parallel and automatically generates multithreaded code. Automatic parallelization relieves the user from having to deal with the low-level details of iteration partitioning, data sharing, thread scheduling, and synchronizations. It also provides the performance benefits available from multiprocessor systems and systems that support Hyper-Threading Technology.
For more information on multi-threaded application support, visit Intel's Threading Developer Center.

High Performance, Parallel Optimizer (HPO)

This revolutionary capability, new in Version 10, combines vectorization, parallelization and loop transformations into a single pass which is faster, more effective and more reliable than prior discrete phases.

HPO optimizes and restructures program loops to ensure that auto-parallelization, OpenMP, and auto-vectorization occur smoothly in conjunction with each other. HPO’s optimization technology utilizes a unique cost-benefit analysis to make the right optimization decisions for the given program and loop structure. It will perform many transformations such as loop unrolling, peeling, interchange, splitting, etc., as well as other optimizations to ensure the processor’s cache architecture, SIMD instruction set, and multiple cores are well utilized.

Automatic Vectorizer

Vectorization automatically parallelizes code to maximize underlying processor capabilities. This advanced optimization analyzes loops and determines when it is safe and effective to execute several iterations of the loop in parallel by utilizing MMX™, SSE, SSE2, SSE3, SSSE3, and SSE4 instructions. Figure 1 is a graphical representation of a vectorized loop that shows four iterations computed with one SSE2 operation.		Figure 1. The Vectorizer in action
Use vectorization to optimize your application code and take advantage of these new extensions when running on Intel® processors. Features include support for advanced, dynamic data alignment strategies, including loop peeling to generate aligned loads and loop unrolling to match the prefetch of a full cache line.

Interprocedural Optimization (IPO)

Interprocedural optimization (IPO) can dramatically improve application performance in programs that contain many small- or medium-sized functions that are frequently used, especially for programs that contain calls within loops. This set of techniques, which can be enabled for automatic operation in the Intel® compilers, uses multiple files or whole programs to detect and perform optimizations, rather than focusing within individual functions.

Figure 1. The interprocedural optimization process

Figure 2. The interprocedural optimization process

The IPO process, shown in Figure 2, first requires that source files are compiled with the IPO option, creating object (.o) files that contain the intermediate language (IL) used by the compiler. Upon linking, the compiler combines all of the IL information and analyzes it for optimization opportunities. Typical optimizations made as part of the IPO process include procedure inlining and re-ordering, eliminating dead (unreachable) code, and constant propagation, or the substitution of known values for constants. IPO enables more aggressive optimization than what is available at the intra-procedural level, since the added context of multiple procedures makes those more-aggressive optimizations safe.

The analysis capabilities of IPO can also give feedback on vulnerabilities and coding errors, such as uninitialized variables, which cannot be detected as well by compilers which rely strictly on analysis by a compiler front-end. back to top

Profile-Guided Optimization (PGO)

The Profile-guided optimization (PGO) compilation process enables the Intel C++ Compiler to take better advantage of the processor microarchitecture, more effectively use instruction paging and cache memory, and make better branch predictions. It improves application performance by reorganizing code layout to reduce instruction-cache thrashing, shrinking code size, and reducing branch mispredictions.

PGO is a three-stage process, as shown in Figure 3. Those steps include 1) a compile of the application with instrumentation added, 2) a profile-generation phase, where the application is executed and monitored, and 3) a recompile where the data collected during the first run aids optimization. A description of several code size influencing profile-guided optimizations follows:

	Basic block and function ordering — Place frequently-executed blocks and functions together to take advantage of instruction-cache locality.
	Aid inlining decisions — Inline frequently-executed functions so the increase in code size is paid in areas of highest performance impact.
	Aid vectorization decisions — Vectorize high trip count and frequently-executed loops so the increase in code size is mitigated by the increase in performance.

Figure 3. Profile-guided optimization

Optimized Code Debugging with the Intel® Debugger

The Intel® Debugger enables optimized code debugging (i.e., debugging code that has been significantly transformed for optimal execution on a specific hardware architecture). The Intel compilers produce standards-compliant debug information for optimized code debugging that is available to all debuggers that support Intel compilers. The Intel Debugger supports multi-core architectures by enabling debugging of multithreaded applications, providing the following related capabilities:

	An all-stop/all-go execution model (i.e., all threads are stopped when one is stopped, and all threads are resumed when one is resumed).
	List all created threads.
	Switch focus between threads.
	Examine detailed thread state.
	Set breakpoints (including all stop, trace, and watch variations) and display a back-trace of the stack for all threads or for a subset of threads.
	The built-in GUI provides a Thread panel (on the Current Source pane) that activates when a thread is created, and that allows an operator to select thread focus and display related details.
The recently enhanced GNU Project Debugger (GDB debugger) can also be used for parallel applications. For additional information, please refer to the Intel Debugger Technical White Paper (PDF 210KB).

Compatibility and Flexibility

Xcode Integration

The Intel C++ Compiler is compatible with Xcode*, enabling developers to work with a popular IDE while also taking advantage of advanced optimization features from Intel.

Xcode 2.2 Integration Generate C/C++ Universal Binaries from the Xcode environment using the Intel C++ Compiler and GCC for PowerPC*, retaining compatibility with GCC 4.0. Universal Binaries are designed to ease the transition between PowerPC and Intel® architecture by combining native code for both architectures in a single compiled package.

High-level code that contains no processor dependencies requires few if any changes to create a Universal Binary. Lower-level code that contains hardware dependencies presents a greater challenge.

GCC 4.0 Interoperability

GCC 4.0 Interoperability GNU C/C++ compatibility features enable you to gain source- and object-code compatibility with GNU C. The Intel C++ Compiler has GCC-extension support to help ease application porting, so you can recompile existing software to get improved application performance. Alternatively, rather than switching compilers completely, build applications by compiling specific modules with the Intel C++ Compiler for Mac OS X and link them with modules compiled with GNU C. Additionally, the Intel C++ Compiler for Mac OS X complies with the C++ ABI standard, which enables stronger binary compatibility with GCC 4.0.

Support for Apple Frameworks

Apple frameworks are a special type of bundle used to distribute shared resources, including library code, resource files, header files, and reference documentation. They offer flexibility that is often preferable to using dynamic shared libraries.

For more information on Apple frameworks, please visit Apple’s website*.

Standards Compliance

	ANSI C/C++ standard
	ISO C/C++ standard
	GNU inline assembly
	C++ ABI object model

Technical Support

With the purchase of Intel C++ Compiler, you will receive one year of technical support and product updates from Intel® Premier Support, our interactive issue management and communication web site. This premium support service allows you to submit questions, download product updates, and access technical notes, application notes, and other documentation. For more information, visit the Intel® Registration Center.

System Requirements

Host System

Hardware

	Intel® processor-based Apple* Mac* system
	512MB RAM minimum, 1GB RAM recommended
	100 MB of disk space, plus an additional 200 MB during installation for the download and temporary files

Software

	Mac OS* X developers tools including Xcode* 2.4.1 or 2.5
	Mac OS X 10.4. 10
	GCC 4.0

Notes:
Advanced optimization options or very large programs may require additional resources such as memory and disk space.

Intel provides both the tools and support to enhance the performance, functionality, and efficiency of software applications.

Compatible with leading Windows* and Linux* development environments, Intel® Software Development Products are the fastest and easiest way to take advantage of the latest features of Intel processors. Intel Software Development Products are designed for use in the full development cycle, and include Intel® Performance Libraries, Intel® Compilers (C++, Fortran for Windows, Linux, and Mac OS* X), Intel® VTune™ Analyzer, Intel® Threading Tools and Intel® Cluster Tools.

The Intel® Premier Support Web site provides expert technical support for all Intel software products, product updates and related downloads. For additional product information visit: www.intel.com/software/products.

Intel, the Intel logo, and VTune are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

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