Intel® Compilers Professional Editions

Intel® Compilers Professional Editions The Best C++ and Fortran Development Solutions for Today’s Multi-core World
Phil De La Zerda , Director
Intel Software Development Products
Intel Corporation
June 2007 CONTAINS EMBARGOED INFORMATION No public mention allowed of the new Intel Compiler 10.0 discussed in this disclosure until June 5

Multi-Core Processors Change the Rules Single Core Dual Core Quad Core Until recently…. Maximize Multi-Core Performance By Parallelizing Software Faster software came from faster processors Now performance will primarily come from multi-core processors Intel® Xeon® processor Dual-Core Intel® Xeon® processor 5100 series New Quad-Core Intel® Xeon® 5300 for 2006

Great Performance Performance Through Parallelism Help mainstream programmers to quickly develop quality code Educate Tomorrow’s Experts
Helped 45 universities add parallel programming courses
7500 students took them
2007 Goal: 400+ universities
Provide Tools Today Research Tomorrow’s Techniques Higher-Ed Outreach Architect, Thread, Debug & Tune Transactional Memory Speculative Multi- threading http:// www.intel.com /software/products ACCELERATE TRANSITION TO PARALLEL PROGRAMMING

New Usage Models, parallelism is key Terabytes TIPS Gigabytes MIPS Megabytes GIPS Performance Dataset Size Kilobytes KIPS Tera-scale Multi-core Single-core Multi- Media 3D & Video Text RMS Personal Media Creation and Management Learning & Travel Entertainment Health Source: electronic visualization lab University of Illinois

Worldwide Trends & The Opportunity

Key messages
Multi-core is here to stay
Hype to the contrary is noise
Multi-core is ubiquitous – for software developers: worth utilizing, dangerous to ignore
Intel has the best products to help developers with parallelism
Intel has rich innovations ahead to take us far into the future with multi-core, we are committed

“ THINK PARALLEL (or PERISH)” “ memo to self” software developers need to Multicore processing is the new normal. Utilizing parallelism is the best way to realize performance in the future

“ Everyone” need to harness parallelism … even more: they want “solutions” they want tools to help… Help me express parallelism Help me have confidence it will work Help me tune performance Help me: recommend what I do Help me with cluster programming (write, tune, debug) Pro

Thinking parallel 1-2-3
Start with libraries, use as much as they apply. Recommend OpenMP. We support libraries and OpenMP very well.
Recommend Intel Threading Building Blocks. Avoids leaping from step 1 to 3. New, exciting – and well supported by Intel. A focal point for energizing the industry.
Last resort: customer use MPI and/or hand threading. We support MPI and threading by hand, very well. (so, do not panic – many early adopters will hand thread, many cluster programmers will use MPI)

#2 – Intel Threading Building Blocks Which do you choose? Less work or More work?
C++ template-based runtime library
simplifies writing multi-threaded applications
high level programming paradigm
emphasizes scalability
pre-built and tested data structures & algorithms

Less code to achieve parallelism Example: 2D Ray Tracing Application Thread Setup and Initialization CRITICAL_SECTION MyMutex, MyMutex2, MyMutex3; int get_num_cpus (void) { SYSTEM_INFO si; GetSystemInfo(&si); return (int)si.dwNumberOfProcessors;} int nthreads = get_num_cpus (); HANDLE *threads = (HANDLE *) alloca (nthreads * sizeof (HANDLE)); InitializeCriticalSection (&MyMutex); InitializeCriticalSection (&MyMutex2); InitializeCriticalSection (&MyMutex3); for (int i = 0; i < nthreads; i++) { DWORD id; &threads[i] = CreateThread (NULL, 0, parallel_thread, i, 0, &id);} for (int i = 0; i < nthreads; i++) { WaitForSingleObject (&threads[i], INFINITE); } Parallel Task Scheduling and Execution const int MINPATCH = 150; const int DIVFACTOR = 2; typedef struct work_queue_entry_s { patch pch; struct work_queue_entry_s *next; } work_queue_entry_t; work_queue_entry_t *work_queue_head = NULL; work_queue_entry_t *work_queue_tail = NULL; void generate_work (patch* pchin) { int startx, stopx, starty, stopy; int xs,ys; startx=pchin->startx; stopx= pchin->stopx; starty=pchin->starty; stopy= pchin->stopy; if(((stopx-startx) >= MINPATCH) || ((stopy-starty) >= MINPATCH)) { int xpatchsize = (stopx-startx)/DIVFACTOR + 1; int ypatchsize = (stopy-starty)/DIVFACTOR + 1; for (ys=starty; ys<=stopy; ys+=ypatchsize) for (xs=startx; xs<=stopx; xs+=xpatchsize) { patch pch; pch.startx = xs; pch.starty = ys; pch.stopx = MIN(xs+xpatchsize-1,stopx); pch.stopy = MIN(ys+ypatchsize-1,stopy); generate_work (&pch);} } else { /* just trace this patch */ work_queue_entry_t *q = (work_queue_entry_t *) malloc (sizeof (work_queue_entry_t)); q->pch.starty = starty; q->pch.stopy = stopy; q->pch.startx = startx; q->pch.stopx = stopx; q->next = NULL; Thread Setup and Initialization #include "tbb/task_scheduler_init.h" #include "tbb/spin_mutex.h" tbb::task_scheduler_init init; tbb::spin_mutex MyMutex, MyMutex2; Parallel Task Scheduling and Execution #include "tbb/parallel_for.h" #include "tbb/blocked_range2d.h" class parallel_task { public: void operator() (const tbb::blocked_range2d<int> &r) const { for (int y = r.rows().begin(); y != r.rows().end(); ++y) { for (int x = r.cols().begin(); x != r.cols().end(); x++) { render_one_pixel (x, y); } } if (scene.displaymode == RT_DISPLAY_ENABLED) { tbb::spin_mutex::scoped_lock lock (MyMutex2); for (int y = r.rows().begin(); y != r.rows().end(); ++y) { GraphicsDrawRow(startx-1, y-1, totalx, (unsigned char *) &global_buffer[(y-starty)*totalx*3]); } } } parallel_task () {} }; parallel_for (tbb::blocked_range2d<int> (starty, stopy + 1, grain_size, startx, stopx + 1, grain_size), parallel_task ()); Windows Threads Intel® Threading Building Blocks Intel® Threading Building Blocks offers platform portability on Windows*, Linux*, and Mac OS* through its cross-platform API. This code comparison shows the additional code needed to make a 2D ray tracing program, Tacheon, correctly threaded. This allows the application to take advantage of current and future multi-core hardware. if (work_queue_head == NULL) { work_queue_head = q; } else { work_queue_tail->next = q; } work_queue_tail = q; } } void generate_worklist (void) { patch pch; pch.startx = startx; pch.stopx = stopx; pch.starty = starty; pch.stopy = stopy; generate_work (&pch); } bool schedule_thread_work (patch &pch) { EnterCriticalSection (&MyMutex3); work_queue_entry_t *q = work_queue_head; if (q != NULL) { pch = q->pch; work_queue_head = work_queue_head->next; } LeaveCriticalSection (&MyMutex3); return (q != NULL); } generate_worklist (); void parallel_thread (void *arg) { patch pch; while (schedule_thread_work (pch)) { for (int y = pch.starty; y <= pch.stopy; y++) { for (int x=pch.startx; x<=pch.stopx; x++) { render_one_pixel (x, y);}} if (scene.displaymode == RT_DISPLAY_ENABLED) { EnterCriticalSection (&MyMutex3); for (int y = pch.starty; y <= pch.stopy; y++) { GraphicsDrawRow(pch.startx-1, y-1, pch.stopx-pch.startx+1, (unsigned char *) &global_buffer[((y-starty)*totalx+(pch.startx-startx))*3]); } LeaveCriticalSection (&MyMutex3); } } } This example includes software developed by John E. Stone. Focus on work to do, not “how” (thread control) to manage threads

Less code to achieve parallelism Example: 2D Ray Tracing Application Thread Setup and Initialization CRITICAL_SECTION MyMutex, MyMutex2, MyMutex3; int get_num_cpus (void) { SYSTEM_INFO si; GetSystemInfo(&si); return (int)si.dwNumberOfProcessors;} int nthreads = get_num_cpus (); HANDLE *threads = (HANDLE *) alloca (nthreads * sizeof (HANDLE)); InitializeCriticalSection (&MyMutex); InitializeCriticalSection (&MyMutex2); InitializeCriticalSection (&MyMutex3); for (int i = 0; i < nthreads; i++) { DWORD id; &threads[i] = CreateThread (NULL, 0, parallel_thread, i, 0, &id);} for (int i = 0; i < nthreads; i++) { WaitForSingleObject (&threads[i], INFINITE); } Parallel Task Scheduling and Execution const int MINPATCH = 150; const int DIVFACTOR = 2; typedef struct work_queue_entry_s { patch pch; struct work_queue_entry_s *next; } work_queue_entry_t; work_queue_entry_t *work_queue_head = NULL; work_queue_entry_t *work_queue_tail = NULL; void generate_work (patch* pchin) { int startx, stopx, starty, stopy; int xs,ys; startx=pchin->startx; stopx= pchin->stopx; starty=pchin->starty; stopy= pchin->stopy; if(((stopx-startx) >= MINPATCH) || ((stopy-starty) >= MINPATCH)) { int xpatchsize = (stopx-startx)/DIVFACTOR + 1; int ypatchsize = (stopy-starty)/DIVFACTOR + 1; for (ys=starty; ys<=stopy; ys+=ypatchsize) for (xs=startx; xs<=stopx; xs+=xpatchsize) { patch pch; pch.startx = xs; pch.starty = ys; pch.stopx = MIN(xs+xpatchsize-1,stopx); pch.stopy = MIN(ys+ypatchsize-1,stopy); generate_work (&pch);} } else { /* just trace this patch */ work_queue_entry_t *q = (work_queue_entry_t *) malloc (sizeof (work_queue_entry_t)); q->pch.starty = starty; q->pch.stopy = stopy; q->pch.startx = startx; q->pch.stopx = stopx; q->next = NULL; Thread Setup and Initialization #include "tbb/task_scheduler_init.h" #include "tbb/spin_mutex.h" tbb::task_scheduler_init init; tbb::spin_mutex MyMutex, MyMutex2; Parallel Task Scheduling and Execution #include "tbb/parallel_for.h" #include "tbb/blocked_range2d.h" class parallel_task { public: void operator() (const tbb::blocked_range2d<int> &r) const { for (int y = r.rows().begin(); y != r.rows().end(); ++y) { for (int x = r.cols().begin(); x != r.cols().end(); x++) { render_one_pixel (x, y); } } if (scene.displaymode == RT_DISPLAY_ENABLED) { tbb::spin_mutex::scoped_lock lock (MyMutex2); for (int y = r.rows().begin(); y != r.rows().end(); ++y) { GraphicsDrawRow(startx-1, y-1, totalx, (unsigned char *) &global_buffer[(y-starty)*totalx*3]); } } } parallel_task () {} }; parallel_for (tbb::blocked_range2d<int> (starty, stopy + 1, grain_size, startx, stopx + 1, grain_size), parallel_task ()); Windows Threads Intel® Threading Building Blocks offers platform portability on Windows*, Linux*, and Mac OS* through its cross-platform API. This code comparison shows the additional code needed to make a 2D ray tracing program, Tacheon, correctly threaded. This allows the application to take advantage of current and future multi-core hardware. if (work_queue_head == NULL) { work_queue_head = q; } else { work_queue_tail->next = q; } work_queue_tail = q; } } void generate_worklist (void) { patch pch; pch.startx = startx; pch.stopx = stopx; pch.starty = starty; pch.stopy = stopy; generate_work (&pch); } bool schedule_thread_work (patch &pch) { EnterCriticalSection (&MyMutex3); work_queue_entry_t *q = work_queue_head; if (q != NULL) { pch = q->pch; work_queue_head = work_queue_head->next; } LeaveCriticalSection (&MyMutex3); return (q != NULL); } generate_worklist (); void parallel_thread (void *arg) { patch pch; while (schedule_thread_work (pch)) { for (int y = pch.starty; y <= pch.stopy; y++) { for (int x=pch.startx; x<=pch.stopx; x++) { render_one_pixel (x, y);}} if (scene.displaymode == RT_DISPLAY_ENABLED) { EnterCriticalSection (&MyMutex3); for (int y = pch.starty; y <= pch.stopy; y++) { GraphicsDrawRow(pch.startx-1, y-1, pch.stopx-pch.startx+1, (unsigned char *) &global_buffer[((y-starty)*totalx+(pch.startx-startx))*3]); } LeaveCriticalSection (&MyMutex3); } } } This example includes software developed by John E. Stone . Focus on work to do, not “how” (thread control) to manage threads Just say ‘NO’ to explicit thread management Not because you can’t do it – because it isn’t a good use of time developing and maintaining Intel® Threading Building Blocks

Thinking parallel 1-2-3
Start with libraries, use as much as they apply. Recommend OpenMP. We support libraries and OpenMP very well.
Recommend Intel Threading Building Blocks. Avoids leaping from step 1 to 3. New, exciting – and well supported by Intel. A focal point for energizing the industry.
Last resort: customer use MPI and/or hand threading. We support MPI and threading by hand, very well. (so, do not panic – many early adopters will hand thread, many cluster programmers will use MPI)

Scalability – competitive advantage for software excellent ideal good fair poor Performance “ Scaling” 1 2 4 8 DESIGN FOR SCALING For excellent scaling – use Intel tools 1X 2X 4X 8X Scalability Correctness Maintainability

Introducing Scalability: Libraries, OpenMP, MPI, and Intel Threading Building Blocks Scalable & High Performance By focusing on the work to do, not “how” (thread control) to manage threads, we rely on the Intel Threading Building Blocks to manage thread better and we get better scalability and performance. Linux* Windows*

Intel ® Threading Building Blocks (TBB) 2.0 Open Source
TBB 2.0 announcement extends TBB by:
Buildable for more OSes, more processors Now more than Linux, Mac OS X, and Windows. Now more than IA32, IA64 and Intel 64 processors.
Creation of open source project http://threadingbuildingblocks. org
Source code available (GPL v2 with runtime exception)
Commercial Product continues http://threadingbuildingblocks.com
Separately – this month…
O’Reilly Nutshell book

Introducing: Intel Compilers 10.0 Professional Editions Compilers and Libraries tuned for Multi-core Processors Featuring Intel’s Revolutionary New Optimizer
Intel® C++ Compiler 10.0 Professional Edition
Intel® C++ Compiler
Intel® Math Kernel Library
Intel® Integrated Performance Primitives
Intel® Threading Building Blocks
Intel® Fortran Compiler 10.0 Professional Edition
Intel® Fortran Compilers
Intel® Math Kernel Library
and on Windows only: Microsoft* Visual Studio is included
Versions for: Windows* Linux* Mac OS* X

Breakthrough Optimizer Design Uniquely Blends Parallelism Optimizations for SSE and MC to Achieve New Levels of Optimization
Single cohesive system to combine essential functions required to optimized multi-core performance.
Vectorization – ensures performance optimization of software with complex media demands such as 3D and video.
Parallelization – maximizes multi-core processors by automatically generating multi-threaded code.
Loop Transformations – enable vectors and threaded code to automatically be transformed within a single framework.
Parallelism can be exploited in two ways: vectors (SSE) and Multi-core this optimizes our automatic exploitation of them together.

Combining vectorization, parallelization and loop transformation into a single transform delivers results
Our Goal:
Compiler Professional Edition was the result of three years of development with the ultimate goal to make it easy for developers to advance parallelism without changing code or throwing fancy compiler switches.
Customer experience :
“ In applications involving calculations on huge amounts of continuous memory, Intel C++ 10.0 compiler s significantly faster than 9.1. In certain stand-alone tests, such as linear algebra matrix multiplication, 10.0 is up to 4 times faster than 9.1, due to improved automatic parallelization and automatic vectorization with “unroll and jam” that fits hand in glove with Intel Core 2 micro-architecture.”
Gunnar Staff & Lars Petter Endreen SPT Group

Helping developers scale, correct and maintain applications for multicore performance
Multi-core Highlights
Intel ® Threading Building Blocks
Parallelism for C++
A standard part of Intel C++
OpenMP*: C and Fortran
Now with API checking
Auto-parallelization
Intel ® Math Kernel Library (MKL):
New threaded scientific routines
Intel ® Integrated Performance Primitives (IPP):
New threaded multimedia acceleration and 64 bit support – all compilers and libraries
Multi-threading for multicore has never been easier. Intel C++ Compiler Professional Edition

Intel® Compiler Vulnerability Diagnostics STRONG COMMITMENT TO HELP DEVELOPERS FIND VULNERABILITIES Intel Compilers have a powerful and flexible diagnostic reporting facility that allows such things as changing individual, groups of diagnostics, or all diagnostics from warnings to errors, and from remarks to warnings. Controlling Compiler Diagnostics Detects various defects and doubtful or inconsistent uses of language features in user code at compile/link time for an entire application. The Static Verifier understands C/C++ and Fortran, including OpenMP*, and can analyze mixed C/C++/Fortran applications. Static Verifier Detects certain types of memory corruption on Linux. Mudflap Support (Linux* only) Diagnostics based on C++ usage developed by Scott Meyer in his “Effective C++” books. Improving C++ Source Code Using "Effective C++" Diagnostics Various ANSI/ISO Compliance options can help identify non-portable language usage. Porting To/From Other Compilers Generates diagnostics warning of potential problems when porting legacy applications to 64-bits. Porting from 32 to 64-bits Intel® C++ Compilers have unique diagnostic capabilities that can enhance the quality of threaded code and help when introducing threads to legacy applications. Assisting Developing and Debugging Threaded Applications Identify incorrect function declarations that can corrupt the x87 floating point stack corruption and generate incorrect numerical results. Detecting x87 Floating Point Stack Corruption Run-time detection of stack corruption, helps detect commonly used security vulnerabilities. Enabling Stack Checking Run-time detection of buffer overflows, helps prevent commonly used security vulnerabilities. Detecting Buffer Overflow BENEFIT FEATURE

B E N C H M A R K S

Better Performance on Windows*, Linux* and Mac OS* X Competition is not standing still, neither are we. We continue to deliver on our goal to BE THE BEST. Persistent leadership.

Competitive Performance on AMD Processors We continue to deliver on our goal to BE THE BEST. With effort (many switches) and without (-O2). Intel libraries and compilers continue to support a wide range of processors with optimized software performance for multiple processors in the same binary. Intel’s patented CPU-dispatch logic, available since 2000, is used by Intel compilers and libraries to offer sophisticated support for multiple processors in a single binary.

Better Performance on Multi-Core Processors Optimized code is the first step to best usage of multi-core. Multiple optimized programs run better than multiple unoptimized programs.

Better OpenMP Performance on Multi-Core Processors OpenMP and libraries are the easiest, and best way, to tap into multi-core performance (when they apply, of course). Customers have converted hand threaded programs to OpenMP –they gained performance and scalability and portability and made their program simpler all at once .

Standalone Intel Visual Fortran for Windows*
Intel® Visual Fortran for Windows now includes Microsoft* Visual Studio*
Great news for Compaq Visual Fortran users, and others, who do not have the Microsoft Visual Studio development environment
… .and we brought back the COM Server Wizard too!

T H E L I B R A R I E S

Intel® Math Kernel Library 9.1 Flagship math processing library
Improved Functionality
Multi-core ready
Extensively threaded math functions with excellent scaling
Automatic runtime processor detection ensures great performance on whatever processor your application is running on.
Support for C and Fortran
What’s New
Optimizations for latest Intel processors including Quad-core Clovertown (Xeon® 5300 series) and Dual-core Woodcrest (Xeon® 5100 series)
LAPACK 3.1 Support
New Threading in Vector Math Functions
Support for 64-bit and 32-bit applications on Mac OS* X

Intel® Integrated Performance Primitives 5.2 Highly optimized multimedia functions
Rapid Application Development
Cross-platform Compatibility & Code Re-Use
Outstanding Performance
What’s New
New data compression functions and code samples for full compatibility with zlib and libbzip2
Improved data compression performance
Support for new VC-1 and H.264 High profile video codecs
Support for 64-bit and 32-bit applications on Mac OS* X
Additional optimizations for Quad-Core processors, and 64-bit applications

Intel® Threading Building Blocks 1.1 Extends C++ for Parallelism
A C++ runtime library that uses familiar task patterns, not threads
A high level abstraction requiring less code for threading without sacrificing performance
Appropriately scales to the number of cores available
The thread library API is portable across Linux, Windows, or Mac OS platforms
Works with all C++ compilers (i.e. Microsoft, GNU and Intel)
What’s New (TBB 1.1 was launched in April 2007)
Auto_partitioner for better parallel algorithms
Microsoft Vista* support
Full, native 64 bit support for Mac OS X*

Intel® C++ Compiler Professional Edition Most Mac OS* X developers preferred the Intel C++ Compiler with our libraries Profession edition NOW available for Windows* and Linux* too

Intel® Fortran Compiler Professional Edition Most Mac OS* X developers preferred the Intel Fortran compiler with our MKL library Profession edition NOW available for Windows* and Linux* too The IMSL library is available in a “Professional with IMSL” version (Windows only)

Thank you!

Backup Foils

P R I C I N G

Professional Edition Pricing and Availability
Available June 5 th , 2007
Licensing:
Single User Licenses: CD-ROM and ESD
Floating Licenses: ESD only
No Node Locked Licenses
$699 Intel® Fortran Compiler Professional Edition for Mac OS X $899 Intel® Fortran Compiler Professional Edition for Linux $1599 Intel® Fortran Compiler Professional Edition + ISML* for Windows $699 Intel® Fortran Compiler Professional Edition for Windows $599 Intel® C++ Compiler Professional Edition for Windows*, Linux*, Mac OS* X MSRP PRODUCTS (Single User)

Standard Edition Pricing and Availability
Available June 5 th , 2007
Licensing:
Single User Licenses: CD-ROM and ESD
Floating Licenses: ESD only
No Node Locked Licenses
$449 Intel® C++ Compiler Standard Edition for Windows*, Linux*, Mac OS* X $299 Intel® Threading Building Blocks for Windows, Linux, Mac OS X $199 Intel® Integrated Performance for Windows, Linux, Mac OS X $399 Intel® Math Kernel Library for Windows, Linux, Mac OS X $549 Intel® Fortran Compiler Standard Edition for Mac OS X $749 Intel® Fortran Compiler Standard Edition for Linux $599 Intel® Fortran Compiler Standard Edition for Windows MSRP PRODUCTS (Single User)

New Student Package Supporting new programmers
Opportunity to LEARN using the latest versions of Intel Software Development Products.
Full functional versions with our standard full year of updates and support.
$49 (MSRP) for Mac OS* X:
Intel® C++ Professional Edition for Mac OS* X
Intel® Fortran Professional Edition for Mac OS* X
(2 compilers, 2 performance libraries and Intel Threading Building Blocks)
$129 (MSRP) for Windows*:
Intel® C++ Professional Edition for Windows
Intel® Fortran Professional Edition for Windows
Intel® VTune™ Analyzer for Windows
Intel® Thread Profiler for Windows
Intel® Thread Checker for Windows
(2 compilers, 2 performance libraries and Intel Threading Building Blocks
and 3 great analysis tools)
$129 (MSRP) for Linux*:
Intel® C++ Professional Edition for Linux
Intel® Fortran Professional Edition for Linux
Intel® VTune™ Analyzer for Linux
Intel® Thread Checker for Linux
(2 compilers, 2 performance libraries and Intel Threading Building Blocks
and 2 great analysis tools)
Available only through resellers worldwide. Downloads only (no CD).
06/21/10

resellers also offer academic versions & student packages to qualified buyers evaluations available www.intel.com/software/products Intel C++ Compiler 10.0 Professional Edition: C++ & MKL & IPP & TBB Intel Fortran Compiler 10.0 Professional Edition: Fortran & MKL $699 Intel® Fortran Compiler Professional Edition for Mac OS X $899 Intel® Fortran Compiler Professional Edition for Linux $1,599 Intel® Fortran Compiler Professional Edition + ISML * for Windows $699 Intel® Fortran Compiler Professional Edition for Windows $599 Intel® C++ Compiler Professional Edition for Windows*, Linux*, Mac OS* X MSRP PRODUCTS (Single User)

D E T A I L S (warning: deep dive) On some of the really cool features…

Static Verifier (SV) in 10.0 Compilers
Static verifier detects many defects and inconsistent use of language features in user code at compile/link time for the whole application
Helps C++ and Fortran users develop and debug for memory access, buffer overflow, and OpenMP* usage errors
Finds OpenMP* API and data dependency errors
$ cat -n main.cpp 1 #include <iostream> 2 int foo(const char *); 3 int main() { 4 char * y=NULL; 5 std::cout << foo(y); 6 return(0); 7 } $ cat -n test.cpp 1 #include <string> 2 int foo(const char * widget) { 3 return(std::strlen(widget)); 4 } $ icc -diag-enable sv3 main.cpp test.cpp main.cpp(5): error #12143: [SV] "y" is uninitialized test.cpp(3): warning #12086: [SV] header-file containing the declaration of intrinsic "strlen" should be included or forward declaration is wrong
Benefits less experienced users:
Detects 200+ kinds of potential coding errors;
Can help to “teach” users to correctly use certain features of C/C++ and Fortran languages (for example, OpenMP directives)
Benefits experienced users & QA:
It detects rather hard to find errors (for example typos or uninitialized variables)
Detects inconsistent objects declarations in different program units (for example different types of dummy and actual arguments)

Mudflap support in 10.0 Compilers
Risky pointer operations are instrumented by the compiler to prevent buffer overflows and invalid heap use.
$ icc –o t-mudflap of-calc.c of-main.c -fmudflap –lmudflap $ ./t-mudflap ******* mudflap violation 1 (check/write): time=1177545175.621017 ptr=0x7fff5bc461d0 size=8 pc=0x2aaaaaae74a1 location=`of-calc.c:4 (calcSqrt)' /usr/lib64/libmudflap.so.0(__mf_check+0x41) [0x2aaaaaae74a1] ./t-mudflap(calcSqrt+0x8a) [0x40187c] ./t-mudflap(main+0x3b5) [0x401c5d] Nearby object 1: checked region begins 1B after and ends 8B after mudflap object 0x136ad320: name=`of-main.c:4 (main) a‘ bounds=[0x7fff5bc46180,0x7fff5bc461cf] size=80 area=stack check=0r/10w liveness=10 alloc time=1177545175.621003 pc=0x2aaaaaae6fc1 $ cat -n of-calc.c 1 #include <math.h> 2 void calcSqrt(double *a, int N){ 3 for (int i=1;i<N;i++) 4 a[i]=sqrt( (double)i ); 5 return; 6 } $ cat -n of-main.c 1 #include <stdio.h> 2 void calcSqrt(double *a, int N); 3 int main() { 4 double a[10]; 5 for (int i=0;i<10;i++) { 6 a[i] = (double) i; 7 } 8 calcSqrt(a,11); 9 return 0; 10 }

HPO – High Performance Parallel Optimizer
New parallelizer and vectorizer structure for IA32/Intel®64/ IA64
Enabled by
-O3 –Q[a]x[P,T,N..]
-parallel –O3
Revolutionary new design – Vectorizer now after HLO ( loop optimizations like “loop distribution”)
Enable loop transformations then vectorization on IA32 and Intel 64 or Load Pair generation on IPF
Better interaction among optimizations
Parallelization on top of optimized serial code
More efficient multi-threaded code
Enhanced loop transformations
Unified cost model for vectorization and parallelization
HPO improves performance, particularly for loops for serial and parallel execution

HPO Example
subroutine matmul(a,b,c,n)
real(8), dimension(n,n) :: a,b,c
c=0.d0 ! 4
!$omp parallel do ! 5
do i=1,n ! 6
do j=1,n ! 7
do k=1,n ! 8
c(j,i)=c(j,i)+a(k,i)*b(j,k)
enddo
enddo
enddo
end
matmul.f90(5): (col. 7) : OpenMP DEFINED LOOP WAS PARALLELIZED
High Level Optimizer Report (matmul_)
matmul.f90(4): (col. 1) : LOOP WAS VECTORIZED.
matmul.f90(7): (col. 3) : PERMUTED LOOP WAS VECTORIZED.
LOOP INTERCHANGE in loops at line: 7 8
Loopnest permutation ( 1 2 3 ) --> ( 1 3 2 )
Block, Unroll, Jam Report:
(loop line numbers, unroll factors and type of transformation)
Loop at line 7 blocked by 111
Loop at line 6 unrolled and jammed by 4
Loop at line 8 unrolled and jammed by 4
Optimization report (abridged)

New C++ Exception Handling Revolutionary new design
Simplified internal presentation provides more opportunities for optimization:
Improved EH representation
Improved in-lining in the presence of EH
Improved EH control flow model
Improved optimization opportunities where opts were previously disabled, such as const propagation
Improved code size/data size vs gcc* for C++
More opportunity for parallelization
New options: -f[no-]exceptions
Accepted as a ‘dummy’ switch

Fortran – 2003 new features
C Interoperability (Intrinsic module ISO_C_BINDING and BIND(C) attribute) - Enables building portable, mixed-language apps
ISO_FORTRAN_ENV intrinsic module
Helps write portable code
Asynchronous I/O
Improves run-time performance for reads, writes of unformatted data
std03 default option
Diagnose Fortran 2003 standards exceptions
Additional features for enhancing programmer productivity

Intel ® C++ and Fortran Compilers optimization reports
Gives developers the information they need to diagnose quickly and accurately:
Explains when the compiler was or wasn’t able to performance a selected advance optimization.
Identifies areas to improves the application run-time performance
Highlight messages regarding hot spots in the code with Intel® VTune™ Analyzer for Linux*

VTune™ Analyzer for Linux* Shows what the Compiler Knows
Compile with the Intel compiler
Find your hotspot using Intel® VTune™ analyzer
Select the hot lines of code in the source view
Click the circled icon to see the compiler's opt report
The report tells you that the compiler didn't parallelize your critical loop because of an assumed dependency
You know there is no dependency and insert an OpenMP statement
You have faster parallel software
Check the logic with Intel® Thread Checker

Intel Compilers 10.0
Windows*, Linux* and Mac OS* X
Compilers and libraries together – each tuned for multi-core parallelism and vector (SSE) parallelism
Revolutionary optimizer
boosts compilers and libraries
libraries and compilers continue leadership
C++ Parallelism: Intel Threading Building Blocks now a standard part of our C++ offering
Fortran: Significant new features
Numerous vulnerability detection features
available from Intel and resellers worldwide now
try before you buy – www.intel.com/software/products

Intel® C++ Compiler Professional Edition Most Mac OS* X developers preferred the Intel C++ Compiler with our libraries Profession Edition NOW available for Windows* and Linux* too

Intel® Fortran Compiler Professional Edition Most Mac OS* X developers preferred the Intel Fortran compiler with our MKL library Profession edition NOW available for Windows* and Linux* too The IMSL library is available in the Intel® Fortran Compiler Professional Edition with IMSL (Windows only)

Intel® Compilers Professional Editions

by Rozy65

Accessibility

Categories

Upload Details

Usage Rights

Statistics