Intel Developer Zone - Main Articles Feed

Intel® MKL VML Training Material

mad\gfedorov — Tue, 10 Jul 2012 18:55:58 +0000

This article contains training material (in PDF format) on Intel® MKL Vector Math (VML), which includes details of VML features and performance, examples and its application in Finance. Please see the "Article Attachments" section below for a link to download the material.

intel math kernel library

Linux*

Microsoft Windows* (XP, Vista, 7)

C/C++

Intermediate

Intel® Composer XE

Intel® Math Kernel Library

PDF

Compiler Topics

Learning Lab

Intel® MKL with Numpy, Scipy, Matlab, C#, Python, NAG and more

mad\gfedorov — Tue, 08 May 2012 05:43:27 +0000

The following table lists links to the useful articles describing how Intel® Math Kernel Library (Intel® MKL) can be used with the third party libraries and applications.

Topics	Description	Third Party Application/Tool
Numpy/Scipy with Intel® MKL	This article intended to help current NumPy/SciPy users to take advantage of Intel® Math Kernel Library (Intel® MKL).	Numpy/Scipy
Using Intel® MKL in R	This article shows how to configure R to use the optimized BLAS and LAPACK in the Intel® Math Kernel Library (Intel® MKL).	R
Using Intel® MKL in Gromacs	This article helps the current Gromacs* users get better performance by utilizing the Intel® Math Kernel Library (Intel® MKL). It explains how to build 64-bit Gromacs* with Intel MKL for Intel® 64 based applications.	Gromacs*
Using Intel® MKL in GNU Octave	This article helps the current GNU Octave* users to incorporate the latest versions of the Intel® Math Kernel Library (Intel® MKL) on Linux* platforms on Intel® Xeon® *processor-based systems.	Octave*
Using Intel MKL BLAS and LAPACK with PETSc	This article describes how to build the Portable Extensible Toolkit for Scientific Computation (PETSc) with the Intel® Math Kernel Library (Intel® MKL) BLAS and LAPACK.	PETSc
Using Intel® MKL in your Python program	This article describes how to use the Intel® Math Kernel Library (Intel® MKL) from a Python* program	Python*
Performance hints for WRF on Intel® architecture	This article explains how to configure the Weather Research & Forecasting (WRF) run-time environment to achieve the best performance and scalability on Intel® architecture with Intel® software tools.	Weather Research & Forecasting (WRF) Application
• HPL application note • Use of Intel® MKL in High Performance Computing Challenge (HPCC) benchmark	These guides helps the current HPL (High Performance LINPACK) users get better benchmark performance by utilizing Intel® Math Kernel Library (Intel® MKL) BLAS	High Performance Computing Challenge benchmarks
• Using Intel MKL with MATLAB • Using Intel® MKL in MATLAB Executable (MEX) Files	These guides helps the Intel® Math Kernel Library (Intel® MKL) customers use the latest version of Intel® MKL for Windows* OS with the MathWorks* MATLAB*.	MATLAB*
Using Intel® MKL with IMSL* Fortran numerical library	This article explains how to use the latest version of the Intel® Math Kernel Library (Intel® MKL) with IMSL* Fortran Numerical Library Version 6.0.0 on Intel® architecture systems under Microsoft Windows* systems	IMSL* Fortran
Using Intel® MKL with the NAG* libraries	This article describes how to use the Intel® Math Kernel Library (Intel® MKL) with the NAG* libraries. Currently, Intel MKL is used for NAG's BLAS and LAPACK functionalities, with the addition of FFTs for NAG's Fortran SMP Libraries.	NAG* libraries
• Using Intel® MKL in your C# program • Some more additional tips "How to call MKL from your C# code"	These articles describe how to call and link the Intel® Math Kernel Library (Intel® MKL) functions from your C# code. Examples are provided for calling the BLAS, LAPACK, DFTI (the FFT interface), the PARDISO direct sparse solver, and the vector math library (VML).	C#
Using Intel® Math Kernel Library and Intel® Integrated Performance Primitives in the Microsoft* .NET* Framework	This document explains how to call the Intel® Math Kernel Library (Intel® MKL) and Intel® Integrated Performance Primitives (Intel® IPP) from .NET Framework languages such as C#.	.NET Framework
How do I use Intel® MKL with Java*?	The Intel® Math Kernel Library (Intel® MKL) package contains a set of examples that demonstrate the use of Intel MKL functions with Java*. The Java example set includes Java Native Interface (JNI) wrappers. These Java examples are intended for tutorial use only.	Java*
Building MPICH1 with GNU Fortran	MPICH1 does not work with GNU Fortran out-of-the-box - this article describes the modifications that must be made for it to work properly.	GNU Fortran
C++ template math libraries	This article provides information about existing high-level C++ APIs available to invoke MKL functionality.

scipy

numpy

matlab mkl

python mkl

C# mkl

java mkl

hpl mkl

nag mkl

hpcc mkl

imsl mkl

gromacs mkl

wrf mkl

intel math kernel library

Linux*

Microsoft Windows* (XP, Vista, 7)

Apple Mac OS X*

.NET*

C/C++

Fortran

Java*

Python*

Advanced

Beginner

Intermediate

Intel® Math Kernel Library

Development Tools

Open Source

Optimization

URL

Improving performance

Multithread development

Learning Lab

Intel® Cluster Studio XE works on Xeon® Phi coprocessor? OpenMP*? TBB? MPI?

mad\zwang14 — Thu, 16 May 2013 07:16:50 +0000

Intel(R) Cluster Studio XE 2013 is a powerful tool suite - which helps you to develop applications, with low latency Intel MPI library, high performance C++/FORTRAN compiler, native profiling component named VTune™ Amplifier XE 2013, node level analysis component named Intel® Trace Collector/Analyzer, Threading and memory correctness components named Inspector XE 2013.

Purposes of this article are:

Get familiarity of using Intel® Software Development Products on Intel® Xeon Phi™ Coprocessor
Know different usage modes of development
Get familiar with Intel® Trace Collector/Analyzer and VTune™ Amplifier XE

Note :

1. All demo code are attached in zip file, you can practise below demos

2. Use amplxe-gui to open vtune result. I showed some screen-shots in demos

Intel® Xeon Phi™ coprocessor software configuration

Key features of the Intel® Xeon Phi™ Coprocessor:

50+ cores which run the Intel instruction set architecture
4 threads per physical core
512 bit registers for SIMD operations (vector operations)
512K L2 cache per core
High speed bi-directional ring connecting the 50+ cores

Getting Ready…

Ensure Xeon Phi™ coprocessor is running

Use “service mpss status” to check
Use “service mpss start” to invoke if it stops

Install Intel® Cluster Studio XE 2013
Install VTune™ Amplifier driver on Phi coprocessor

Check if driver is working on Phi coprocessor

# ssh mic0

# lsmod | grep sep3

e.g: sep3_8 45016 0

If the driver is not installed

# cd vtune_root/bin64/k1om/

# ./sep_micboot_install.sh

Use “service mpss restart” to restart mpss

Setting environment variables

source /opt/intel/composer_xe_2013.2.146/bin/compilervars.sh intel64
source /opt/intel/impi/4.1.0.024/bin64/mpivars.sh
source /opt/intel/vtune_amplifier_xe_2013/amplxe-vars.sh
source /opt/intel/itac/8.1.0.024/bin/itacvars.sh impi4
export I_MPI_MIC=1
export I_MPI_FABRICS=shm:tcp
export VT_LOGFILE_FORMAT=stfsingle
scp -r /opt/intel/composer_xe_2013.2.146/compiler/lib/mic/* mic0:/lib64/
scp -r /opt/intel/impi/4.1.0.024/mic/bin/* mic0:/bin/
scp -r /opt/intel/impi/4.1.0.024/mic/lib/* mic0:/lib64/
scp -r /opt/intel/composer_xe_2013.2.146/tbb/lib/mic/* mic0:/lib64

Demo #1, OpenMP* program on Xeon Phi coprocessor

1. Compile OpenMP code for Xeon Phi Coprocessor

# icc -g -O3 -mmic -openmp -openmp-report omp_pi.c -o omp_pi.MIC

omp_pi.c(16): (col. 1) remark: OpenMP DEFINED LOOP WAS PARALLELIZED.

2. Copy binary to the target device

# scp omp_pi.MIC mic0:/root

omp_pi.MIC 100% 20KB 19.7KB/s 00:00

3. Use VTune™ Amplifier XE to analyze

# amplxe-cl -collect knc-lightweight-hotspots --search-dir all:rp=./ -- ssh mic0 /root/omp_pi.MIC

Demo #2, Intel® TBB built program on Xeon Phi coprocessor

1. Compile TBB code for Xeon Phi Coprocessor

# icpc -g -O3 -mmic -DTBB_DEBUG -DTBB_USE_THREADING_TOOLS -std=c++0x /opt/intel/composer_xe_2013.2.146/tbb/lib/mic/libtbb_debug.so.2 tbb_pi.cpp -o tbb_pi.MIC -lpthread

2. Copy binary to the target device

# scp tbb_pi.MIC mic0:/root

tbb_pi.MIC 100% 91KB 90.8KB/s 00:00

3. Use VTune™ Amplifier XE to analyze

# amplxe-cl -collect knc-lightweight-hotspots --search-dir all:rp=./ -- ssh mic0 /root/tbb_pi.MIC

Demo #3, “Offload” program on Xeon Phi coprocessor

1. Compile “offload” code for Xeon Phi Coprocessor

# icc -g -O3 -openmp -openmp-report offload_pi.c -o offload_pi

offload_pi.c(18): (col. 9) remark: OpenMP DEFINED LOOP WAS PARALLELIZED.

offload_pi.c(18): (col. 9) remark: *MIC* OpenMP DEFINED LOOP WAS PARALLELIZED.

2. Use VTune™ Amplifier XE to analyze

# amplxe-cl -collect knc-lightweight-hotspots -- ./offload_pi

Demo #4, Use MPI built program on Xeon Phi coprocessor

1. Compile MPI code for Xeon and Xeon Phi Coprocessor

# mpiicc -g -openmp -O3 -o test-openmp test-openmp.c

# mpiicc -g -openmp -mmic -O3 -o test-openmp.MIC test-openmp.c

2. Copy binary to the target device

# scp test-openmp.MIC mic0:/root

test-openmp.MIC 100% 17KB 17.2KB/s 00:00

3. Run the Intel MPI tests before:

# mpirun -host `hostname` -n 2 ./test-openmp

# mpirun -env OMP_NUM_THREADS 4 -host mic0 -n 2 /root/test-openmp.MIC

4. Use MPI built program on Xeon Phi coprocessor – Hybrid mode

# mpirun -env OMP_NUM_THREADS 2 -host `hostname` -n 2 ./test-openmp : -env OMP_NUM_THREADS 4 -host mic0 -n 2 /root/test-openmp.MIC

Demo #5, Use VTune™ Amlipifier XE to analyze

1. Compile MPI code for Xeon Phi™ Coprocessor

# make clean | make MIC

2. Copy binary to the target device

# scp poisson.MIC mic0:/root

3. Run the Intel MPI tests:

# amplxe-cl -collect knc-general-exploration -cpu-mask=1-64 --search-dir all:rp=. -- ssh mic0 OMP_NUM_THREADS=64 /root/poisson.MIC -n 3500 -iter 10

Demo #6, Intel Trace Collector / Analyzer

1. Compile MPI code for Xeon Phi™ Coprocessor

# make clean | make

# make clean | make MIC

Note: there is “-tcollect” option in Makefile

2. Copy binary to the target device

# scp poisson.MIC mic0:/root

3. Run the Intel MPI tests before:

export VT_LOGFILE_FORMAT=stfsingle

# mpirun -env OMP_NUM_THREADS=1 -host `hostname` -n 2 ./poisson -n 3500 -iter 10 : -env OMP_NUM_THREADS=1 -host mic0 -n 6 /root/poisson.MIC -n 3500 -iter 10

traceanalyzer poisson.single.stf

Intel Cluster Studio MPI OpenMP TBB VTune Amplifier Inspector ITAC

Developers

Linux*

C/C++

Intermediate

Intel® Cluster Toolkit

Intel® Cluster Ready

Development Tools

URL

Code Sample

Compiler Topics

Getting started

Improving performance

Libraries

Memory Errors

What's new? Update 7 - Intel® VTune™ Amplifier XE 2013

mad\rvemuri1 — Thu, 16 May 2013 06:41:35 +0000

Intel® VTune™ Amplifier XE 2013

Intel® VTune™ Amplifier XE is an easy to use performance and thread profiler for C, C++, C#, Fortran, Java and MPI developers. No special recompiles are needed, just start profiling. Hotspots are highlighted on the source. A powerful timeline makes it easy to tune your application and scale performance on multicore processors.

New for Update 7!

Assembly grouping by RVA, basic blocks, and function ranges
Support for applications generated by MinGW/Cygwin GCC* (Windows* only)
Event summary for hardware event-based sampling analysis results in the command line reports
Highlighting performance issues based on filtered-in data
Bug fixes

Resources

Release Notes
Knowledgebase articles (Click on "Support" tab and select "Search Support Articles")
Training Videos (Click on "Learn" tab and select desired video)

File: vtune_amplifier_xe_2013_update7.tar.gz

Installer for Intel® Vtune™ Amplifier XE 2013 Update 7 for Linux*

File: VTune_Amplifier_XE_2013_update7_setup.exe

Installer for Intel® Vtune™ Amplifier XE 2013 Update 7 for Windows*

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

Microsoft, Windows, Visual Studio, Visual C++, and the Windows logo are trademarks, or registered trademarks of Microsoft Corporation in the United States and/or other countries.

Next: Update 6 What's new.

Developers

Linux*

Microsoft Windows* (XP, Vista, 7)

Microsoft Windows* 8

Unix*

Business Client

Server

.NET*

C/C++

Fortran

Java*

Advanced

Beginner

Intermediate

Intel® Fortran Composer XE

Intel® C++ Studio XE

Intel® Cluster Studio XE

Intel® Fortran Studio XE

Intel® Parallel Studio XE

Intel® VTune™ Amplifier XE

URL

A New User Interface for VTune Amplifier Search Directories

mad\rreed — Wed, 15 May 2013 23:38:32 +0000

With the recent updates to Intel’s VTune™ Amplifier XE 2013, the user interface for the symbol search directories has been streamlined. The new interface should facilitate faster symbol lookups and quicker finalization waits. You can find the new interface in the project properties dialog.

Where before there was a single tab, now there are two, separating source paths from binary and symbol paths. The recursive search flag has also been removed. In normal practice the files of interest are usually coalesced into just a few directories, which can be listed explicitly, and not having to do a recursive search through directory trees simplifies and speeds the lookup code.

The search tabs look much the same as before:

You can either click on the “Add new search location” and type in a path, or you can click on the ellipsis button on the right end to bring up a file browser

The Binary/Symbol search tab looks very similar:

Here you can enumerate the locations of various libraries that may be linked to your program. In this example the source path also contains binaries with symbols, so that path is replicated here. In addition, the path to expose the Intel^® Manycore Platform Software Stack (Intel^® MPSS), our name for the Linux kernel that comes with the Intel Xeon Phi™ coprocessor, is shown above. With this path added to the list, events accumulated in kernel functions will be listed by function in the resulting displays. And here are some other useful paths for providing symbols for common libraries used on the coprocessor:

Library	Path
Intel MPSS kernel	/lib/firmware/mic
Libc, libm, pthreads, etc.	/usr/linux-k1om-4.7/linux-k1om/lib64
Intel Compiler libraries: C, C++, Fortran, Intel Cilk Plus	/opt/intel/composerxe/lib/mic
Intel Threading Building Blocks	/opt/intel/composerxe/tbb/lib/mic
Intel Math Kernel Library	/opt/intel/composerxe/mkl/lib/mic
Intel Message Passing Interface (MPI)	/opt/intel/mpi-rt/4.1.0/mic

Intel VTune Amplifier XE

symbol resolution

search paths

finalization

Developers

Linux*

Beginner

Intel® VTune™ Amplifier XE

Development Tools

Intel® Many Integrated Core Architecture

URL

Beacon Mountain v0.5 – Frequently Asked Questions

mad\jgmottx — Wed, 15 May 2013 06:40:52 +0000

What is Beacon Mountain?
What are the key features of Beacon Mountain v0.5?
How can I obtain a copy of the tool?
What are the system hardware and software requirements to install and run the tool suite?
How do I receive licenses to the tools Beacon Mountain provides?
How do I receive updates to the tools Beacon Mountain provides?
How do I receive updates to Beacon Mountain?
What tools does Beacon Mountain provide access to?
There’s a tool I’d like Beacon Mountain to support. How do I share my feedback with Intel?
Is an Internet connection required to use Beacon Mountain?

What is Beacon Mountain?

Beacon Mountain is a code name for new Intel development environment for creating applications for Intel^® Atom™ and ARM processor-based devices running Android* operating systems.

What are the key features of Beacon Mountain v0.5?

Beacon Mountain v0.5 provides development environment setup and maintenance for 64-bit host development systems running Microsoft Windows* 7 and 8 with support for Apple OS X* systems targeted for release by the end of June.

The key features supported with this release are:

Installation of popular Intel® and third-party tools to create a development environment on the host system for creating Android applications.
Beacon Mountain installs the tools with a few clicks, allowing the developer to start coding right away.

How can I obtain a copy of the tool?

You can download Beacon Mountain v0.5, free of charge, at intel.com/software/BeaconMountain.

What are the system hardware and software requirements to install and run the tool suite?

Beacon Mountain runs on Windows 7 and 8 operating systems. Your system must have Intel® Virtualization Technology¹ enabled in BIOS in order for Intel® Hardware Accelerated Execution Manager (Intel® HAXM) to run.

How do I receive licenses to the tools Beacon Mountain provides?

Beacon Mountain prompts you to view and accept licenses of all tools the suite offers during installation.

How do I receive updates to the tools Beacon Mountain provides?

Beacon Mountain uses the Intel® Software Manager to check for software updates on a regular basis. Once a software update becomes available, you will be prompted to install it on your system.

How do I receive updates to Beacon Mountain?

When you run Beacon Mountain, it checks to make sure it is the current version. If there is an updated version available, Beacon Mountain will update itself.

What tools does Beacon Mountain provide access to?

Beacon Mountain installs popular Intel and third-party tools to create a development environment on the host system for creating Android applications.

Intel Tools:
- Intel Hardware Accelerated Execution Manager (Intel HAXM)
- Intel® Graphics Performance Analyzers System Analyzer
- Intel® Integrated Performance Primitives
- Intel® Threading Building Blocks
- Intel Software Manager
Third-Party Tools:
- Google Android SDK (ADT Bundle)
- Android NDK
- Eclipse* Integrated Development Environment
- Android Design
- Cygwin*

There’s a tool I’d like Beacon Mountain to support. How do I share my feedback with Intel?

Your feedback is important to us. Please use the feedback box on the Beacon Mountain product page and request inclusion of the tool(s) you’d like Beacon Mountain to support.

Is an Internet connection required to use Beacon Mountain?

Yes. If you have proxy settings, you need to set them first as well.

¹ Intel® Virtualization Technology requires a computer system with an enabled Intel® processor, BIOS, and virtual machine monitor (VMM). Functionality, performance or other benefits will vary depending on hardware and software configurations. Software applications may not be compatible with all operating systems. Consult your PC manufacturer. For more information, visit http://www.intel.com/go/virtualization.

Developers

Apple Mac OS X*

Microsoft Windows* (XP, Vista, 7)

Microsoft Windows* 8

Debugging

Development Tools

URL

An example of using VTune™ Amplifier XE to profile Java class called by C/C++ application (JNI)

mad\zwang14 — Wed, 15 May 2013 03:44:41 +0000

Article <Java support is back in VTune™ Amplifier XE> informs that VTune(TM) Amplifier XE 2013 already supports Java application, and Attaching to Java* processes for hardware event-based sampling is supported since VTune™ Amplifier XE 2013 Update 4.

The problem is that Java class may not be used directly in application. For example, Java application may work with Apache, Tomcat, Php and Mysql, etc. Sometime C/C++ code may call Java methods from class via JNI (Java Native Interface). This article educate to use JNI and how VTune Amplifier collects performance in Java class by JNI mode.

Steps:

1. Create a simple Java class, which has "calc" public method. See attached Demo.java file

2. Use Oracle* JDK 1.7 to compile Demo.java with "-g" option (generate symbol info in class file)

# ../../jdk1.7.0_11/bin/javac -g Demo.java

3. Run Demo class directly

# ../../jdk1.7.0_11/bin/java Demo

Note that “main” public method calls "calc" method in this case.

4. One important thing to be noted here is to specify the function signatures while obtaining the method IDs. To obtain the correct method signature, you can use the following Java comman:

# ../../jdk1.7.0_11/bin/javap -s -p Demo

Compiled from "Demo.java"

public class Demo {

public Demo();

Signature: ()V

public static void main(java.lang.String[]);

Signature: ([Ljava/lang/String;)V

public static void calc();

Signature: ()V

}

5. Create a test.cpp (see attached), which uses the signature of method "calc"

6. Compile C++ file to generate executable

g++ -g test.cpp -I/home/peter/jdk1.7.0_11/include -I/home/peter/jdk1.7.0_11/include/linux -L/home/peter/jdk1.7.0_11/jre/lib/amd64/server -ljvm -o test

7. Run C++ binary which calls public method “calc” from Demo class

First, you need to add JRE library into environment variable LD_LIBRARY_PATH

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/peter/jdk1.7.0_11/jre/lib/amd64/server

Then run "./test"

8. Now we can profile “calc” java method called by C++ built “test” application

# amplxe-cl -collect hotspots -mrte-mode=auto –duration 20 -- ./test

# amplxe-cl -report callstacks -r r000hs

# amplxe-cl -report callstacksamplxe: Using result path `/home/peter/jni_java/r003hs'

amplxe: Executing actions 50 % Generating a report

Function Call Stack Module CPU Time:Self

--------------------------- ------------------------------------ ---------------------------------- -------------

Demo::calc [Compiled Java code] 19.680

call_stub [Dynamic code] 16.960

JNIEnv_::CallStaticVoidMethod test 0

main test 0

__libc_start_main libc-2.12.so 0

9. Also you can attach the process which runs Java method

# ./test &

[1] 16801

# amplxe-cl -collect lightweight-hotspots -knob enable-stack-collection=true -knob enable-call-counts=true -mrte-mode=auto -target-pid 16801

# amplxe-cl -report callstacks

amplxe: Using result path `/home/peter/jni_java/r001lh'

amplxe: Executing actions 50 % Generating a report

Function Call Stack Module CPU Time:Self

----------------------------- ----------------------- ------------------ -------------

JNIEnv_::CallStaticVoidMethod test 20.023

main test 20.023

__libc_start_main libc-2.12.so 0

pthread_cond_timedwait libpthread-2.12.so 0.002

os::PlatformEvent::park libjvm.so 0.002

WatcherThread::run libjvm.so 0

java_start libjvm.so 0

start_thread libpthread-2.12.so 0

clone libc-2.12.so 0

VTune Java JNI

Developers

Linux*

C/C++

Java*

Beginner

Intel® VTune™ Amplifier XE

Development Tools

URL

Getting started

Tutorial: Creating an HTML5 app from a native iOS* project with Intel® HTML5 App Porter Tool – BETA

mad\pagarral — Tue, 14 May 2013 20:28:32 +0000

Download Sample App

(Version: 0.5.3407.54)

Introduction

The main goal of this tutorial is to help you use the Intel® HTML5 App Porter Tool – BETA to port a native iOS* app to HTML5. The Intel® HTML5 App Porter Tool – BETA will generate clean and easy to read code, keeping the auto-generated code as much alike the original as possible.

Objectives

With this document you will:

Learn how to configure the tool to get the best results possible
Understand the feedback provided by the tool
Learn how to finish the translation process by completing the portions of code that could not be translated by the tool

Tutorial Example - “Balloon Ninja”

Balloon Ninja is a mini game where you get points by popping balloons. The more balloons you pop in a minute, the more points you get. It uses JSONKit as third party API for persistence. It also uses NSFoundation, UIKit and Audio Toolbox as native API. For this tutorial app, the Intel® HTML5 App Porter Tool – BETA will have about 80% of API translation rate, as most common features in NSFoundation and UIKit are supported.

See a screenshot of the original application running in the iOS* simulator, below.

From iOS* to HTML5 in just 6 steps

This section shows the different steps that you need to follow to successfully run the Intel® HTML5 App Porter Tool – BETA, finish the porting process and get a translated HTML5 version of the sample app.

Step 1 - Setting the project and output paths

Select the project to translate, in this case Balloon Ninja, and the destination path. For the source path, select the .xcodeproj folder, otherwise you will get an error message saying “This is not a valid Xcode* Project”. Please, make sure that you have write permissions on both the source and destination folders.

Step 2 - Selecting the modules to be processed

In this step, unselect the JSONKit.m file to exclude it from the translation process. As JavaScript has a native support with JSON, the best approach here is not to translate that library altogether but to rewrite the JSON management using JavaScript support.

Note: Carefully selecting the classes to translate is a key step. As a general criteria, you should avoid translating any modules in the original app that implement a functionality that is already supported in JavaScript. Additionally, you may also avoid translating modules that are implemented using low level features of C or Objective-C* that may be translated to JavaScript rather unnaturally.

The checkbox on the bottom of the screen above allows you to add missing include folders or preprocessor directives, if necessary.

In this case, no additional configuration is necessary since the JSONKit sources are already included as a part of the project. However, if the parsing process fails, this is where you should add any API or framework headers that are not included on the project. These errors could be caused by a third party library outside the project folder or a missing preprocessor directive, such as preprocessor definitions for DEBUG or RELEASE, or any #define that should be set manually.

Step 3 - Parsing modules

During this step, Intel® HTML5 App Porter Tool – BETA attempts to parse the project and determines the part of the code that can be translated. If the tool is unable to parse a file, it will allow you to fix issues by editing the files that could not be parsed, as it is shown in the images below. Otherwise, you can choose to ignore (i.e., skip) the files that cannot be parsed. After editing or ignoring those files, you can continue to Step 4. In case that you encounter no parsing issues, you will see the sequence of screens, below.

Step 4 - Select the methods to be translated

Finally, after parsing and analyzing the entire project, the result is shown in a simple report. You will be able to decide which methods to translate based on the API coverage shown in the columns on the right.

Unselect the interface LeaderboardManager as JSON serialization will be re-done directly in JavaScript.

Step 5 - Reading the results

After the translation is completed, it is highly recommended to look into the "Translation Report" and the "ToDo Report" available on the final screen and also located in the TranslationReports folder of the translated application. The former shows some details of the translation itself, such as the mapping between .m and .js files. The latter provides the list of files that represent the template declarations for the APIs that were not mapped to equivalent HTML5 code. This reports should guide you on what you need to complete in order to have a working version of your HTML5 app.

Step 6 - Connecting the missing dots

The automatic translation phase performed by the tool is over. Now, you should complete the porting of those APIs and features that were not supported by the tool. Select Open Application to open Microsoft* Visual Studio* (if available, or open Open Project Folder, otherwise), then you will be able to edit the JavaScript files. If you look inside each ToDo JavaScript file, you will see methods throwing exceptions and comments about where that function is being called in the project. You need to complete the methods that the tool was unable to translate.

6.1. Disable exceptions thrown by API placeholders

Remove all the exceptions thrown in API placeholders by adding the following line in main.js.

APT.Global.THROW_IF_NOT_IMPLEMENTED = false;

6.2. Implement Audio APIs

Open todo_api_application_avaudioplayer.js. You will see 4 methods to implement, but you only need to implement initWithContentsOfURL_error and play methods. Copy the code below to complete the implementation of initWithContentsOfURL_error and play.

  
 play: function() {
  var that = this;
  setTimeout(function(){
   that._audio.play();
  }, 0);
 },
 
 initWithContentsOfURL_error: function(url1, arg2) {
  // parameter url1 is of type HTMLAnchorElement
  this._audio = new Audio(url1.href);
  return this;
 },

6.3. Implement JSON serialization

Because JavaScript provides native support to deal with JSON it is better to provide new implementations for serialization directly in JavaScript. Here we use HTML5 localStorage API to implement the persistence.

Open the file leaderboardmanager.js and replace the code for functions leaderboard, addScore_name, saveData and getData with the one provided below.

application.LeaderboardManager.leaderboard = function() {
    return application.LeaderboardManager.getData("leaderboard");
};
 
application.LeaderboardManager.addScore_name = function(score, name) {
    var leaderboard = application.LeaderboardManager.leaderboard();
    
    var scoreDic = new APT.Dictionary();
    scoreDic[new String("name")] = name;
    scoreDic[new String("score")] = score;
    leaderboard.push(scoreDic);
    
    leaderboard = leaderboard.sort(function (a, b) {
        if (a.score > b.score) return -1;
        if (a.score < b.score) return 1;
        return 0;
    });
    
    var leaderboardDictionary = { "leaderboard": leaderboard };
    var leaderboardString = JSON.stringify(leaderboardDictionary);
    application.LeaderboardManager.saveData("leaderboard", leaderboardString);
};
 
application.LeaderboardManager.saveData = function (name, data) {
    localStorage[name] = data;
    return true;
};
 
application.LeaderboardManager.getData = function (name) {
    var data = localStorage[name];
 
    if (data == null) {
        return new Array();
    }
    else {
        var jsonVar = JSON.parse(data);
        for (var i = 0; i < jsonVar.leaderboard.length; i++)
        {
            jsonVar.leaderboard[i] = new APT.Dictionary().initWithDictionary(jsonVar.leaderboard[i]);
        }
        return jsonVar.leaderboard;
    }
};

6.4. Re-factor dynamic calls

Open the file leaderboardviewcontroller.js and look into the function tableView_cellForRowAtIndexPath to remove the call integerValue() like in the code below.

/* call to 'integerValue()' removed */
cell.detailTextLabel().setText(APT.Global.sprintf(new String("%i"), scoreDic.objectFor(new String("score"))));

The call to integerValue() is not translated by the tool (in JavaScript is not needed) because it is a dynamic message to a generic Objective-C object. Current version of the tool does not support API translation of dynamic messages. Because of that, it is recommended to provide type information for all variables and temporal values in your original source code before running the translation.

6.5. Tweak CSS files

In the next step, you will change properties in generated CSS files. The tool generates a pair of .html and .css file for each view found in translated .xib files.

Current version of the tool does not support all of the properties or kind of values available in .xib files. For some labels, the sample use other color spaces that are not RGB. Those color properties are not translated and we need to update the generated code.

Open the file WriteScoreViewController_View_XXXXXX.css (the number at the end is not important) file and for each div#Label with a missing color: property add a new line "color: white;". See the example below.

div#Label_934540285
{
    text-align: right;
    width: 54px;
    height: 21px;
    position: absolute;
    left: 14px;
    opacity: 1;
    top: 116px;
 
    /* new attribute color added */
    color: white;
}
 
div#Label_760896869
{
    text-align: left;
    width: 105px;
    height: 23px;
    position: absolute;
    left: 168px;
    opacity: 1;
    top: 54px;
 
    /* new attribute color added */
    color: white;
}

To make the code more readable, you can change the 'id' attribute in the .html file. But take into account that you may also need to update the file xibboilerplatecode.js. The numbers in the id attribute, are numbers used internally by .xib files in the original application. In further updates of the tool you will see more user friendly ids.

Next, open the file BalloonNinjaViewController_View_XXXXX.css and add properties to label's CSS selectors to make the font bold and bigger.

div#Label_88872199
{
    text-align: center;
    width: 55px;
    height: 37px;
    position: absolute;
    left: 133px;
    opacity: 1;
    top: 7px;
    color: rgba(255,246,6,1);
    
    /* change the font to be bold and 16pt*/
    font-weight: bold;
    font-size: 16pt;    
}
   
div#Label_397160484
{
    text-align: center;
    width: 114px;
    height: 37px;
    position: absolute;
    left: 206px;
    opacity: 1;
    top: 7px;
    color: rgba(0,255,74,1);
    
    /* change the font to be bold and 16pt*/
    font-weight: bold;
    font-size: 16pt;
}

The last file that you need to update is LeaderBoardViewController_View_XXXXX.css. Open that file and set the TableView's property background-color to transparent color like shown below.

div#TableView_91620652
{
    /* change background color to transparent */
    background-color: transparent;
   
    /* and change width from fixed size to relative */
    width: 80%;
    height: 283px;
    position: absolute;
    left: 54px;
    opacity: 1;
    top: 80px;
}

Now, you are ready to test your new HTML5 application by running the project in the Windows 8* emulator.

To register for the beta program and download the Intel® HTML5 App Porter Tool – BETA click the button below.

Requires Windows* 8 and Microsoft* Visual Studio* 2012

Developers

HTML5

URL

Measuring performance in HPC

StarSely — Tue, 14 May 2013 09:24:48 +0000

This is the first article in a series of articles about High Performance Computing with the Intel Xeon Phi. The Intel Xeon Phi is the first commercial product of Intel to incorporate the Many Integrated Core architecture. In this article I will present the basics of the Xeon Phi architecture, the programming models and what we can do to measure the performance in cycles for micro benchmarks.

The Intel Xeon Phi

The Intel Xeon Phi is the first commercially available product of the Intel MIC architecture. It was codenamed Intel Knights Corner (KNC) and is the successor of Knights Ferry (KNF). It has 60 cores and runs at a fixed clock speed of 1.053 GHz. It contains 8 GB of GDDR5 random access memory with a bandwidth of 320 GB/s. On the cache side we have 32KB for instructions and 32KB for data in L1 (each 8-way, with 64B line size). The L2 consist of 512KB slices per core, but can also be thought of as a fully coherent cache, with a total size equal to the sum of the slices. Information can be copied to each core that uses it to provide the fastest possible local access, or a single copy can be present for all cores to provide maximum cache capacity. The L2 cache contains both instructions and data (again 8-way and 64B line size).

It is important to know that the instruction set of the Intel MIC is quite special. While the instruction set is based on x86, we have a special set of vector instructions, which make use of the very big vector unit. This allows us to use SIMD programming very efficiently. The CPU also does FMA instructions, which one should try to optimize for, since each thread can only execute instructions every other cycle.

The Xeon Phi co-processor utilizes multi-threading on each core as a key to masking the latencies inherent in an in-order micro-architecture. This should not be confused with hyper-threading on Xeon processors that exists primarily to more fully feed a dynamic execution engine. In HPC workloads, very often hyper-threading may be ignored or even turned off without degrading effects on performance. This is not true of Xeon Phi co-processor hardware threads, where multi-threading of programs should not be ignored and hardware threads cannot be turned off.

The Intel Xeon Phi co-processor offers four hardware threads per core with sufficient memory capabilities and floating-point capabilities to make it generally impossible for a single thread per core to approach either limit. Highly tuned kernels of code may reach saturation with two threads, but generally applications need a minimum of three or four active threads per core to access all that the co-processor can offer. For this reason, the number of threads per core utilized should be a tunable parameter in an application and be set based on experience in running the application.

Programming the Xeon Phi

Given that we know how to program the Intel Xeon processors in the host system, the question that arises is how to involve the Intel Xeon Phi co-processor in an application. There are two major approaches:

The processor centric "offload" model where the program is viewed as running on processors and offloading select work to co-processors.
The "native" model where the program runs natively on processors and co-processors which may communicate with each other by various methods.

An MPI program can be structured using either model, e.g. a program with ranks only on processors may employ offload to access the performance of the co-processors or a program may run in a native mode with ranks on both processors and co-processors. There is really no machine "mode" in either case, only a programming style that can be intermingled in a single application if desired.

Offload is generally used for finer grained parallelism and as such generally involves localized changes to a program. MPI is more often done in a coarse grained manner often requiring more scattered changes in a program in order to add MPI calls. Intel MPI is tuned for both processors and co-processors, so can exploit hardware features like remote direct memory access (RDMA).

Let's first have a look at the "offload" model.

Programming with the offload model

The offload model for Intel Xeon Phi is quite rich. The syntax and semantics of the Intel Language Extensions for Offload includes capabilities not present in some other offload models including OpenACC (since OpenACC is limited by GPU compatibility). This provides greater interoperability with OpenMP, along with the ability to manage multiple Xeon Phi cards, and the ability to offload complex program components that the Intel Xeon Phi can process but that a GPU could not.

void doMult(int size, float (* restrict A)[size], float (* restrict B)[size], float (* restrict C)[size]) 
{
#pragma offload target(mic:MIC_DEV) 
                in(A:length(size*size)) in( B:length(size*size))    
                out(C:length(size*size))
  {
    // Zero the C matrix
#pragma omp parallel for default(none) shared(C,size)
    for (int i = 0; i < size; ++i)
      for (int j = 0; j < size; ++j)
        C[i][j] =0.f;
     
    // Compute matrix multiplication.
#pragma omp parallel for default(none) shared(A,B,C,size)
    for (int i = 0; i < size; ++i)
      for (int k = 0; k < size; ++k)
        for (int j = 0; j < size; ++j)
          C[i][j] += A[i][k] * B[k][j];
  }
}

The offload pragma (as shown above) provides additional annotation so the compiler can correctly move data to and from the external Xeon Phi. We should note that multiple OpenMP loops can be contained within the scope of the offload directive. We will now discuss a little bit the different clauses.

The offload pragma keyword specifies that the following clauses contain information relevant to offloading to the target device. Here target(mic:MIC_DEV) is the target clause that tells the compiler to generate code for both the host processor and the specified offload device. In the example, the target will be a Xeon Phi card associated with the number specified by the constant MIC_DEV.

The in(var-list modifiersopt) clause explicitly copies data from the host to the co-processor. By default, memory will be allocated on the device and deallocated on exiting the scope of the directive. The alloc_if(condition) and free_if(condition) modifiers can change this behavior.

The out(var-list modifiersopt) clause explicitly copies data from the coprocessor to the host. Again by default, the specified memory will be deallocated on exiting the scope of the directive. The free_if(condition) modifier can be used to change the default behavior.

Finally we also want to have a look at the native model.

Programming with the native model

In total there are three different programming model. We already touched the offload model briefly, where the host processor runs the application and offloads compute intensive code and associated data to the device as specified by the programmer via pragmas in the source code. Another possibility would be to run the code as a traditional OpenMP application on the host. This is quite uninteresting, since we do not need a Xeon Phi card for this. The opposite of this called host model is the native programming model: Here the entire application runs on the Phi card.

The most comfortable way to use the native programming is to consider writing a program for a processor consisting of many cores. We do not care about being on the Phi card. The only difference is that in the end we will compile our code for the MIC and execute it on the device. This transfer could either by done by hand (transfer everything per scp, connect per ssh and run it) or by using a utility like micnativeloadex. It is important to note that possible dependencies have to be resolved on the Phi as well, i.e. environment variables might need to be set accordingly for programs to execute successfully.

#include <stdio.h>

void say_hello()
{
  #ifdef __MIC__
    printf("Hello, I am MIC!n");
  #else
    printf("We are still on the host!n");
  #endif
}

int main(int argc, char **argv)
{
  say_hello();
  return 0;
}

Now we need to compile this, e.g. with "icc -mmic -o hello-mic hello-mic.c". Executing with the micnativeloadex utility works by calling "micnativeloadex hello-mic".

The difference to building offload applications is that we use the mmic flag for compiling. Offload applications have to be compiled using the offload-build flag instead. Also programs using the offload programming model have the previously introduced pragmas included.

We will learn more about programming for the Xeon Phi in the next articles.

Measuring performance

There are several ways to measure the time of something in seconds, milliseconds or even microseconds, however, measuring the time in cycles (or nanoseconds) is not so straight forward. Of course one could always count instructions in the assembly code, but this requires understanding of how long certain operations take and does not take any overhead into account. Additionally we want to gather real world data, and not just theoretical calculations, which is why we need to take measurements with cycle precision.

Luckily there is something build into the CPU: the so-called Time Stamp Counter (TSC), which is a 64-bit register present on all x86 processors. It counts the number of cycles since reset. The corresponding assembly instruction is called RDTSC (RD means read) and returns the TSC in EDX:EAX.

The RDTSC has been an excellent high-resolution, low-overhead way of getting CPU timing information. With the advent of multi-core/hyper-threaded CPUs, systems with multiple CPUs, and hibernating operating systems, the TSC cannot be relied on to provide accurate results in general. There is no promise that the RDTSC in case of multiple CPUs on a single motherboard is synchronized, even though great care might be taken.

In case of the Intel MIC we can just assume all counters to be about equal. The clock-rate is also equal. The much bigger problem is that modern CPUs support out-of-order execution, where instructions are not necessarily performed in the order they appear in the executable. The solution is an instruction called RDTSCP, where the additional P means "and processor ID". This is a hint that this version is serialized, i.e. the order is guaranteed.

The bad news is that the Intel MIC does not support the RDTSCP instruction, however, we can just write the code for ourselves. The offset of each core's counter could be different, however, since this remains a constant offset we could (in most measurements) neglect it or set up the experiment in such a way where the offset of each counter is dropping out.

In C/C++ we can create the following function:

static inline unsigned long rdtsc()
{
	unsigned int hi, lo;

	__asm volatile (
		"xorl %%eax, %%eax nt"
		"cpuid             nt"
		"rdtsc             nt"
		:"=a"(lo), "=d"(hi)
		:
		:"%ebx", "%ecx"
	);
	return ((unsigned long)hi << 32) | lo;
}

This is a serialized version of the RDTSC instruction, since it reads out the processor ID as well. The first thing we might want to measure using this piece of code is the precision / overhead of the time measurement.

static int tsc_overhead()
{
    unsigned long t0, t1;
    t0 = rdtsc();
    t1 = rdtsc();
    return (int)(t1 - t0);
}

Usually the overhead is O(100) cycles or about 0.1 µs (depending on the clock frequency) precision. So even for an operation that just takes 1 cycle we will measure at least O(100) cycles.

Conclusion

In this article we have seen the basic architecture and the available programming models for the Intel Xeon Phi. We also had a short look at measuring execution time. Even though we have access to a high performance counter, we still need to keep some rules in mind. We should only measure many repetitions of a reasonable small count of instructions to get meaningful numbers. We also have to keep in mind that a certain offset might be present which is unique for each core.

In the next article we will walk through some of the available threading models, namely pThreads / C++11 Threads, Intel Cilk Plus, OpenMP and Intel TBB.

References

MIC

Xeon

Phi

performance

timing

threading

offload

native

Developers

Professors

Students

Linux*

C/C++

Intermediate

Intel® C++ Compiler

Intel® C++ Compiler and Performance Library for QNX* Neutrino* RTOS

Intel® C++ Composer XE

Intel® Cilk™ Plus

Intel® Composer XE

Intel® Math Kernel Library

OpenMP*

Debugging

Intel® Many Integrated Core Architecture

Optimization

Parallel Computing

Threading

Vectorization

Server

URL

Code Sample

Multithread development

Intel® HTML5 App Porter Tool - BETA - Release Notes version 0.5.3407.54

mad\pagarral — Fri, 10 May 2013 22:26:24 +0000

February 2013 - version 0.5.3407.54

1 Introduction

This is the first, early release of the Intel® HTML5 App Porter Tool – BETA. It is a standalone development tool that helps mobile app developers to migrate native iOS* applications to HTML5 technologies. This tool translates the source code of the original application into a new one using only HTML5 technologies. Intel® HTML5 App Porter Tool – BETA currently supports Microsoft* Windows* 8 and generates a Microsoft* Visual Studio* 2012 project (where available).

2 Operating System and Hardware Requirements

Supported Operating System

Systems running any version of Microsoft* Windows* 8 and Microsoft* Visual Studio* 2012 (where available).

Minimum Hardware Requirements

4GB of RAM memory.
200 MB free disk space required for the product installation in all architectures.

The free disk space required for execution depends on the size of the original application.

3 Installation Notes

Please, see http://software.intel.com/en-us/html5 for download and installations instructions.

Changing, Updating and Removing the Product

If you want to add components or remove them, open the Control Panel and select the Add or Remove Programs applet, select “Intel® HTML5 App Porter Tool – BETA” and click Change. To remove the product, select Remove.

4 Supported APIs

iOS* SDK API calls translation support: This version mainly supports API calls translation for UIKit and NSFoundation frameworks. See the Technical Reference guide for further details.
Xcode* Interface Builder files (.xib files) support: This version supports the translation of a subset of the properties and features of the supported API calls (i.e., translation of UIKit API calls). See the Technical Referenceguide for further details.

5 Known Issues and Limitations

Objective-C++* support: This version does supports the translation C++ or Objective-C++* files. Please, do not include them as input or strip the C++ code from those files, if possible.
Storyboard support: The tool supports the translation of views on XIB files. However, XIB using storyboards are not supported.
Pointers and numeric type: Pointer arithmetic is not supported and data types such as C long long, Complex, and unsigned are all translated into JavaScript numbers.
Functions with variable number of arguments: The translations of C functions with a variable number of arguments is not supported and it may generate a processing error.
For each: The use of for each construct with some types such as NSSet, may generate JavaScript code with errors.
@synchronize support: The @synchronize construct is not supported and does not implement any synchronization mechanisms in the generated code.
@try @catch support: The @try @catch constructs with multiple @catch are not supported.
Categories on unsupported APIs: User-created categories on classes that are not supported by the API translation and it may generate code that contains errors.
Objective-C* literals: the use of Objective-C* literals (http://clang.llvm.org/docs/ObjectiveCLiterals.html) is not supported.
@synthetize support: The use of customized synthetized variable names is not supported and may generate code with errors.

6 Documentation

To learn more about this product visit our:

On-line documentation and tutorials at http://software.intel.com/en-us/html5.
Documentation, help, and samples in the Intel® HTML5 App Porter Tool – BETA Documentation item in the Start menu program folder.
Technical support forum at: http://software.intel.com/en-us/forums/html5-application-development.

Developers

URL

Intel Developer Zone - Main Articles Feed

Intel® MKL VML Training Material

Intel® MKL with Numpy, Scipy, Matlab, C#, Python, NAG and more

Intel® Cluster Studio XE works on Xeon® Phi coprocessor? OpenMP*? TBB? MPI?

What's new? Update 7 - Intel® VTune™ Amplifier XE 2013

New for Update 7!

Resources

Contents

A New User Interface for VTune Amplifier Search Directories

Library

Path

Related Taxonomy:

Beacon Mountain v0.5 – Frequently Asked Questions

Table of Contents

What is Beacon Mountain?

What are the key features of Beacon Mountain v0.5?

How can I obtain a copy of the tool?

What are the system hardware and software requirements to install and run the tool suite?

How do I receive licenses to the tools Beacon Mountain provides?

How do I receive updates to the tools Beacon Mountain provides?

How do I receive updates to Beacon Mountain?

What tools does Beacon Mountain provide access to?

There’s a tool I’d like Beacon Mountain to support. How do I share my feedback with Intel?

Is an Internet connection required to use Beacon Mountain?

An example of using VTune™ Amplifier XE to profile Java class called by C/C++ application (JNI)

Tutorial: Creating an HTML5 app from a native iOS* project with Intel® HTML5 App Porter Tool – BETA

(Version: 0.5.3407.54)

Introduction

Objectives

Tutorial Example - “Balloon Ninja”

From iOS* to HTML5 in just 6 steps

Step 1 - Setting the project and output paths

Step 2 - Selecting the modules to be processed

Step 3 - Parsing modules

Step 4 - Select the methods to be translated

Step 5 - Reading the results

Step 6 - Connecting the missing dots

6.1. Disable exceptions thrown by API placeholders

6.2. Implement Audio APIs

6.3. Implement JSON serialization

6.4. Re-factor dynamic calls

6.5. Tweak CSS files

Measuring performance in HPC

The Intel Xeon Phi

Programming the Xeon Phi

Programming with the offload model

Programming with the native model

Measuring performance

Conclusion

References

Intel® HTML5 App Porter Tool - BETA - Release Notes version 0.5.3407.54

Contents:

1 Introduction

2 Operating System and Hardware Requirements

3 Installation Notes

4 Supported APIs

5 Known Issues and Limitations

6 Documentation