Intel® INDE 2015: Getting Started with the Compiler on Windows* Hosts for Android* Targets

Prerequisites

Set up the Intel compiler environment for 32-bit targets with the following command:

"<compiler-install_dir>\bin\compilervars.bat ia32"

ia32 sets up the environment for 32-bit targets. Use intel64 for 64-bit targets.

For details on compilervars, refer to Using compilervars File in the User and Reference Guide for the Intel® C++ Compiler 15.0.

Using the Compiler with Eclipse* 

This section explains how to configure Eclipse and Eclipse projects to use and build with icc. When you select the option to use the Eclipse integration during installation, Intel® INDE installs all necessary software, including the Android Developer Kit (ADT) and the Android NDK. The ADT includes SDK components and a version of the Eclipse IDE with built-in Android Developer Tools. For more information on ADT, see http://developer.android.com/tools/help/adt.html.

1. Start Eclipse from Start> Intel® INDE> Eclipse for Android ADT .

2. Configure Eclipse to use the NDK plugin. Select Window> Preferences .

3. In the Preferences window, select Android> NDK . Enter the NDK path in the NDK Location text box and click OK.

4. Create a new project from the NDK samples. Select File> New> Project… . The New Project dialog box appears.

5. Select Android Project from Existing Code and click Next.

   The Import Project window opens.

6. Browse to hello-jni in the NDK samples directory. The default installation path is C:\Intel\INDE\IDEintegration\NDK\samples\hello-jni. Confirm the project you want to load, check Copy projects into workspace, and then click Finish.

   The newly created project opens in the Project Explorer.

7. Configure the project to include Native Support, which adds Java and C/C++ support:

   1. Right-click on the project name in the Project Explorer window and select Android Tools> Add native Support... .

   2. A dialog opens asking for the Library Name. Set the library name to hello-jni and click Finish.

8. Create a new file named Application.mk in the jni folder with the following lines:

   • For 32-bit targets:

     APP_ABI:=x86
     NDK_TOOLCHAIN:=x86-icc

   • For 64-bit targets:

     APP_ABI:=x86_64
     NDK_TOOLCHAIN:=x86_64-icc

9. To build your project, right-click on the project name in the Project Explorer and select Build Project.

You can test the application on any Intel architecture-based Android device including an Android Virtual Device.

Using the Compiler with vs-android in Visual Studio* 

The Intel® product installation integrates the Intel® compiler with vs-android, so you can use Visual Studio* to build your Android applications immediately.

1. Create a Visual C++ project, or open an existing project.

2. In Solution Explorer, select a project to build with the Intel® C++ Compiler.

3. Select Project> Properties to open the Property Pages.

4. Select Configuration Properties> General . Under Platform Toolset, select one of the available x86 icc toolchains.

   Notice that the list of available toolsets contains a corresponding toolset for each installed Intel® C++ Compiler.

5. Under the Project Defaults property list, change Target Architecture to x86 Architecture (x86).

6. Click OK to save and close the Property Pages.

Selecting this toolset ensures that Intel® C++ Compiler is used for building your projects. Check the display of Intel-specific property pages and properties.

You can now proceed to use the Intel® Compiler to build Android* applications with Microsoft Visual Studio*. For details, check Visual Studio* documentation on www.microsoft.com.

Using the Command Line 

You can build applications for Intel architecture-based Android devices in two ways. You can enable the icc toolchain with the Android NDK build system or you can use the icc toolchain as a standalone compiler. The following sections provide general guidelines for each method.

When you install the Intel® C++ Compiler, the installation program integrates the compiler into the Android NDK build system automatically. icc is the default compiler for Intel architecture-based targets for NDK revisions 9, 9b, 9c and 9d.

The Android NDK ships with sample applications that can be found in the samples directory in the Android NDK installation directory.

>>cd %NDK_DIR%\samples\hello-jni\jni>>icc -c hello-jni.c>>icc -shared -o libhello-jni.so hello-jni.o

Building an Application for Release 

By default, the NDK is configured to build an application for debugging, and all optimizations are turned off within Eclipse*. When you are ready to deploy, compile it for performance:

1. Open the file Application.mk.

2. To switch to the release mode, add the following line:

   APP_OPTIM:=release

3. To target a specific processor, for example, to build application to run on the Intel® Atom™ processor, add the following line:

   APP_CFLAGS:=-xATOM_SSSE3

4. To enable advanced optimizations, such as increasing the optimization level, add the following line:

   APP_CFLAGS:=-xATOM_SSSE3 -O3

5. To enable interprocedural optimizations, add:

   APP_CFLAGS:=-xATOM_SSSE3 -O3 -ipo

6. Build the application.

You can pass APP_OPTIM and APP_CFLAGS as arguments when building from the command line. For example:

%NDK_DIR%\ndk-build V=1 -B APP_ABI=x86 NDK_TOOLCHAIN:=x86-icc APP_OPTIM=release APP_CFLAGS="-xATOM_SSSE3 -O3 -ipo"

For details, refer to High-Level Optimizations (HLO) and Interprocedural Optimization (IPO) in the User and Reference Guide for the Intel® C++ Compiler 15.0.