《英特尔编译器套件 2013》(Intel Compiler Suite 2013)2013[光盘镜像]
![《英特尔编译器套件 2013》(Intel Compiler Suite 2013)2013[光盘镜像]](/Uploads/40/405/405565.jpg)
电驴资源
电驴资源简介
| 资源介绍 |
| 语言: 英文 |
| 地区: 美国 |
简介:  Great Application Performance, Serial or Parallel Intel Composer XE 2013 delivers outstanding performance for your applications as they run on systems using Intel® Core™ or Xeon® processors, including Intel® Xeon Phi™ coprocessors, and IA-compatible processors. It combines all the tools from Intel® C++ Composer XE 2013 with those from Intel® Fortran Composer XE 2013. Visual Studio* 2008, 2010 or 2012 is a prerequisite on Windows and the gnu tool chain is supported on Linux and OS X*. Performance tools included in Intel® Composer XE 2013 Intel® Cilk™ Plus Intel Cilk Plus is part of Intel C++ and is a powerful capability for increasing C++ application performance. It features array notation that simplifies vectorization, supports simplification of elemental functions declarations and extends the C++ language with 3 easy-to-use keywords to streamline task- and data-parallelism implementation. The benefit is that you save time in producing readable, maintainable, scalable code that delivers impressive performance benefits by taking advantage of underlying hardware features such as wider vectors and more processing cores. Intel Cilk Plus Array Notation The two boxes below show simple and more sophisticated examples of array notation. Each specifies an array section using a set of 3 numbers, either variable or literal, in an array syntax separated by colons. The first is the lower bound where the array section starts, the second is the length of the array, and the third is the stride used to select items from the array. The first example has a lower bound of 0, an array section length of N and an unspecified stride which defaults to 1. In this example, A0 is set to the product of B0 and C0, A1 is set to the product of B1 and C1, etc. Array notation showing simple vector multiplication. a[0:N] = b[0:N] * c[0:N]; The second shows a more sophisticated example in which the 10th item of the array X, up to X of 100, is assigned a sin of every other alternating item of the array Y from 20 to 40. More sophisticated example of array notation X[0:10:10] = sin(y[20:10:2]); In this example, the compiler knows that the call to the sin function can be done safely in parallel via vector operations. This enables the safe generation of vector code. Intel Cilk Plus Elemental Function Support If you have a function that consists of operations to scalar data that follow certain guidelines, you can declare it an elemental function using the __declspec vector function notation. Here’s an example: Example of elemental function syntax __declspec(vector) int foo(int x) { Return(x+1); } for(int I = 0; I < size; i++) array[i]=foo(array[i]); The Cilk Plus implementation makes it easy to consistently use the syntactic notation for the function definition and any function declaration. The example above shows how to use the Intel compiler so that it generates vector code to call multiple elements of foo in an array at a given point in time. The result? Improved performance Task and Data Parallelism: Intel Cilk Plus Keywords Intel Cilk Plus supports task and data parallelism, making it easier to take advantage of more processing power in multicore systems. The benefit is improved application performance that scales. Inserting keywords into existing code offers a simple, fast, readable, and maintainable way to take advantage of multi-core systems. For task parallelism, two keywords, as shown in the code sample below, tell the application where to start and end parallel functionality. Note that the sample code remains unchanged except for the insertion of the keywords. Serial code (left) made parallel with Intel Cilk Plus Keywords. No changes to original code. int fib (int n) { if (n <= 2) return n; else { int x,y; x = fib(n-1); y = fib(n-2); return x+y; } } int fib (int n) { if (n <= 2) return n; else { int x,y; x = _Cilk_spawn fib(n-1); y = fib(n-2); _Cilk_sync; return x+y; } } Intel® Performance Libraries Intel® Composer XE 2013 is a lot more than a Fortran and C++ compiler. It includes three powerful, function libraries that offer the easiest way in which to add parallelism-based performance to your application software. The three libraries are: Intel® Math Kernel Library, also known as Intel® MKL Intel® Integrated Performance Primitives, also known as Intel® IPP Intel® Threading Building Blocks, also known as Intel® TBB Intel® MKL Normal 0 false false false EN-US X-NONE X-NONE /* Style Definitions */ table.MsoNormalTable {mso-style-name:"Table Normal"; mso-tstyle-rowband-size:0; mso-tstyle-colband-size:0; mso-style-noshow:yes; mso-style-priority:99; mso-style-qformat:yes; mso-style-parent:""; mso-padding-alt:0in 5.4pt 0in 5.4pt; mso-para-margin:0in; mso-para-margin-bottom:.0001pt; mso-pagination:widow-orphan; font-size:11.0pt; mso-bidi-font-size:10.0pt; font-family:"Calibri","sans-serif"; mso-bidi-font-family:"Times New Roman";} Intel® Math Kernel Library (Intel® MKL) 11.0 is a computing math library of highly optimized, extensively threaded math routines for applications that require maximum performance. Core math functions include BLAS, LAPACK, ScaLAPACK1, sparse solvers, fast Fourier transforms, vector math, and more. Offering performance optimizations for current and next-generation Intel® processors, it includes improved integration with Microsoft Visual Studio*, Eclipse*, and XCode*. The Intel® MKL computing math library allows for full integration of the Intel® Compatibility OpenMP* runtime library for greater Windows*/Linux* cross-platform compatibility. Benefits Outstanding performance - multicore and multiprocessor ready Automatic parallelization Standard APIs in C and Fortran Royalty free redistribution World-class technical support, knowledge base, and active Intel® MKL forum Click here more details on Intel MKL. Intel® IPP Intel® Integrated Performance Primitives 7.1 is an extensive library of software functions to help you develop multimedia, data processing, and communications applications for Windows*, Linux*, and OS X* environments. Benefits Pre-optimized algorithmic primitives deliver time-to-market performance Future-proofs your code by receiving future processor optimizations by simply re-linking Thousands of algorithmic performance primitives covering many SW domains. Royalty free redistribution Source code samples to help jumpstart your application development IPP Performance Performance Comparison Details Click to enlarge ippiFilter Performance an order of magnitude faster than an optimized compiler with further improvements over multiple generations of SSE and AVX instruction sets. Click to enlarge ippsSqrt32f Intel® Compiler vectorization makes a major difference in Sqrt performance alone, but IPP provides a further 8x performance boost over the Intel® Compiler. Click here more details on Intel IPP. Intel® Threading Building Blocks (Intel® TBB) 4.1 Parallelize Applications for Performance Intel® Threading Building Blocks (Intel® TBB) 4.1 is a widely used, award-winning C++ template library for creating high performance, scalable parallel applications. Intel® TBB is the most proficient way to implement future-proof parallel applications to harness the power and performance of multicore and many-core hardware platforms. Benefits Enhance Productivity and Reliability - Rich set of components to efficiently implement higher-level, task-based parallelism Gain Performance Advantage Today and Tomorrow - Future-proof applications to tap multicore and many-core power Fits Within Your Environment - Compatible with multiple compilers and portable to various operating systems Click here more details on Intel® TBB. Intel Performance Features Common to Both Intel Fortran and Intel C++ The High Performance Parallel Optimizer (HPO) offers an improved ability to analyze, optimize, and parallelize more loop nests. This revolutionary capability combines vectorization, parallelization, and loop transformations into a single pass that is faster, more effective, and more reliable than prior discrete phases. Automatic Vectorization analyzes loops and determines when it is safe and effective to execute several iterations of the loop in parallel. Utilization of auto-vectorization/auto-parallelization depends on the structure of your application software but is broadly applicable and can deliver outstanding improvements in application performance. Guided Auto Parallelization (GAP) can come into play when you have code that will ‘almost’ vectorize or parallelize with the auto-vectorization and parallelism capabilities. Using GAP is like doing a build except the output is a report about your specific application in which suggestions are made, which, if implemented, could lead to improved performance. You retain complete control of your code as you implement suggestions, which you can verify are safe to do. High Performance Parallel Optimizer (HPO) offers an improved ability to analyze, optimize, and parallelize more loop nests. This revolutionary capability combines vectorization, parallelization, and loop transformations into a single pass that 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. Loop Profiler is part of the compiler and can be used to generate low overhead loop and function profiling to show hotspots and where to introduce threads. Profile-Guided Optimization (PGO) improves application performance by reducing instruction-cache thrashing, reorganizing code layout, shrinking code size, and reducing branch mispredictions. OpenMP 3.1 is supported to help simplify pragma-based development of parallelism in your C, C++ and Fortran applications. Intel C++ The Performance Guide is a Windows-based, interactive tool that helps you improve performance for your Windows-based C++ applications. It requires that you have Intel® VTune Amplifier XE 2013, or Intel® C++ Studio XE 2013, or the Intel® Parallel Studio XE 2013 also installed. The Performance Guild walks you through an easy to use workflow, telling you where you can apply Intel C++ performance techniques and quickly see the results. The two-fold benefit is great productivity in getting improved performance. The Performance Guide workflow window (below) shows the steps in the workflow and keeps track of completed steps. The Performance Guide window (bottom right) provides instructions for the current step. The Check Performance Measurements window (top right) shows how performance has improved after applying each of the Intel C++ performance techniques. The Performance Guide is a great way to add application performance and an excellent reason to consider the purchase of Intel C++ Studio XE 2013 or Intel® VTune™ Amplifier XE 2013. The Performance Guide makes suggestions that you implement by using your familiar Windows* Visual Studio* environment. There are no new tools to learn. Intel Fortran Intel Fortran includes a number of performance-oriented features which vectorize and parallelize code. The compiler also supports the wider vectors in the latest Intel Architecture and compatible processors. There is also GAP, which suggests ways to get more benefit from parallelization and vectorization while keeping you in control of your code. More info on performance options below! Performance Features, such as Automatic Vectorization are included in Intel Fortran Composer XE 2013 subroutine quad(len,a,b,c,x1,x2) real(4) a(len),b(len), c(len), x1(len), x2(len), s do i=1,len s = b(i)**2 - 4.*a(i)*c(i) if (s.ge.0.) then x1(i) = sqrt(s) x2(i) = (-x1(i) - b(i)) *0.5 / a(i) x1(i) = ( x1(i) - b(i)) *0.5 / a(i) else x2(i)=0. x1(i)=0. endif enddo end > ifort -c -vec-report2 quad.f90 quad.f90(4): (col. 3) remark: LOOP WAS VECTORIZED. Intel Fortran Composer XE 2013 delivers advanced capabilities for application performance optimization, including development of parallelism for the full range of systems based on IA-32 and Intel® 64 architecture processors (including compatible processors) as well as the Intel® Xeon Phi™ coprocessors. Intel Fortran Composer XE 2013 includes support for coarray Fortran on multi-cpu shared-memory nodes. Cluster support is available in Intel® Cluster Studio XE 2013. Other Fortran 2008 features include DO CONCURRENT, CONTIGUOUS, I/O enhancements, and intrinsic functions, a set of which includes matrix multiply intrinsic functions that support calls into Intel MKL. Fortran 2003 support also provides complete type-bound procedures such as GENERIC and OPERATOR. Support for Fortran 2003 features such as object-orientation, type-bound procedures and operators, and C++ interoperability continue to make it easier to develop mixed-language applications. Intel Fortran interacts nicely with C++11 and C99 features in the Intel® C++ Compiler. What’s New Performance Leadership: New Intel processor support – 3rd Generation Intel® Core™ Processors (Intel® microarchitecture code name Ivy Bridge) and Intel® microarchitecture code name Haswell. Intel® Xeon Phi™ coprocessor optimizations Innovative Intel® Cilk™ Plus now even more performance-oriented New Product Capabilities Latest OS: Windows* 8 Desktop, Linux* Standards: C99, selected parts of C++11, almost complete Fortran 2003 support and selected features from Fortran 2008, Open MP* 3.1 New Features: Pointer Checker: Memory debugging & security tool Performance Guide (C++ Windows only. Requires VTune Amplifier XE 2013 or Intel® C++ Studio XE 2013) Features Intel® Composer XE 2013 features the acclaimed Intel Fortran and C++ Compilers. These performance-oriented compilers can deliver a remarkable performance improvements with just a simple recompile. By using more features, such as the vectorization and parallelism features of Intel® Cilk™ Plus, you might get even more! Intel Fortran Composer XE 2013 includes support for co-array Fortran, providing support for single multi-cpu shared memory node. Cluster support is available in Intel® Cluster Studio XE 2013. Other Fortran 2008 features include DO CONCURRENT, CONTIGUOUS, I/O enhancements, and intrinsic functions, a set of which includes matrix multiply intrinsic functions that support calls into Intel® Math Kernel Library (Intel® MKL). is the easiest way to add parallelism to your C++ application components. It simplifies array notation, elemental function declaration and extends the Intel C++ compiler with 3 keywords that simplify implementing loop and task parallel functions. The benefit is that you save time in producing readable, maintainable, scalable code for IA-32 architecture, Intel® 64 architecture, compatible AMD processors, and, on Linux, the Intel® MIC architecture that delivers impressive performance benefits by taking advantage of underlying hardware features such as wider vectors and more processing cores. Intel® Threading Building Blocks (Intel® TBB) 4.1 is a widely used, award-winning C++ template library for creating high performance, scalable parallel applications. It includes scalable memory allocation, load-balancing, work-stealing task scheduling, a thread-safe pipeline and concurrent containers, high-level parallel algorithms, and numerous synchronization primitives. Intel® Integrated Performance Primitives (Intel® IPP) 7.1 is an extensive library of software functions to help you develop multimedia, data processing, and communications applications for Windows*, Linux*, and OS X* environments. Intel® Math Kernel Libraries (Intel® MKL) 11.0 is a computing math library of highly optimized, extensively threaded math routines for applications that require maximum performance. Core math functions include BLAS, LAPACK, ScaLAPACK1, sparse solvers, fast Fourier transforms, vector math, and more. Intel Compilers support OpenMP*. Developers using C or C++ can create and manage portable, shared-memory parallelism in their applications by coding in OpenMP directives. If source code is compiled later using compilers that do not support OpenMP, the directives are ignored and the code is compiled for conventional, serial execution. Every purchase of an Intel® Software Development Products includes one year of support services, which provides access to Intel® Premier Support and all product updates during that time. Intel Premier Support gives you online access to technical notes, application notes, and documentation. You can also take advantage of Intel Support Forums (Intel® Visual Fortran for Windows, Fortran for Linux and OS X*, C++.) Join the community—contribute, learn, or just browse! Research and Development. Intel is have been expanding practical application of parallelism development tools and technology for years. And we will continue to do so. For a view into some promising technology, take a look at our What If Experimental Software site. ----------------------------------------------------------------------------------------------------------------------- 说实话，Intel 编译器套件是每年VC上大家期待的内容，可是现在VC的软件板块上面发的尽是垃圾小软件，真正大家需要的大型商业软件都不更新了，我实在是看不下去了，所以把Intel的全套软件都更新了！！！ 本人在研究所，内网，估计速度有点慢，不过我会在实验室的服务器上不断供源的！！大家多挂些日子吧！！！ 下面是Intel公司官方给出的性能测试对比： 
|
| 中文名: 英特尔编译器套件 2013 |
| 发行时间: 2012年9月23日 |
| 英文名: Intel Compiler Suite 2013 |
| 资源格式: 光盘镜像 |
| 版本: 2013 |