Introduction

     This article explains how to set up IoT developer kit and enable Bluetooth SPP and make the Yocto application which getting data from buffer of the pipe which used by BT-DBUS API and control the GPIO to turn on / off LED in the Intel(R) Edison. As you do follow the step by step guide below, you may easily have set-up of the Intel(R) Edision Developer environment with Bluetooth as well as can understand well the Intel(R) Edison hardware and software.

This article based on 2 articles and 1 Intel Edison getting started example.

• Connecting the Intel® Edison board to your Android* Phone with Serial Port Profile (SPP)

https://software.intel.com/en-us/articles/connecting-the-intel-edison-board-to-your-android-phone-with-serial-port-profile-spp\

• Communicate to Arduino code with your Android* Phone by Bluetooth Serial Port Profile (SPP) on Intel® Edison

https://software.intel.com/en-us/blogs/2015/05/19/communicate-to-arduino-code-with-your-android-phone-by-bluetooth-serial-port

• Blinking an LED with the Eclipse* IDE on the Intel® Edison board

https://software.intel.com/en-us/blinking-led-with-eclipse-ide-on-intel-edison-board

<fig. The structure of system with an application>

Prerequisite

• Hardware
  • Laptop (Windows 7 or 8.1 is preferred)
  • Android Smartphone or Tablet with Android BT app (Bluetooth SPP tools pro)
  • Intel(R) Edison Arduino board

• Install IoT Dev Kit (IDE -> Eclipse*) - If you don't have Intel Edison yet.

(1)        Go to the https://software.intel.com/iot/downloads

(2)        Please select Eclipse and Windows.

(3)        Unzip the iotdk-ide.win.7z

(4)        Run the devkit-launcher.bat (You may need to download JRE-64bit.)

(5)        Eclipse should be launched.

Step by step guide

1.Connect and assemble

More details: https://software.intel.com/en-us/assembling-intel-edison-board-with-arduino-expansion-board

2.Install Device Driver

https://software.intel.com/iot/hardware/edison/downloads

Windows Standalone Driver 1.2.1 (8.97 MB, .exe)

You need to check the installed device driver in your host PC with connected Intel(R) Edison.

3. Connect to your Intel® Edison board using Ethernet over USB

Please refer: https://software.intel.com/en-us/connecting-to-intel-edison-board-using-ethernet-over-usb

• Create Target Connection (Ignore lib and target image update warning, if any.)

(1)   Run the devkit-launcher.bat

(2)   Select the ‘Create Target Connection’

(3)   Enter connection name: Edison / IP address: 192.168.2.15

(4)   Go to ‘Target SSH Connections’ and right click and select ‘Connect’

(5)   Wait a minute till connection.

(6)   You can launch terminal by right click in the ‘Target SSH Connections’

(7)   Login ID is ‘root’ , if needed.

4. Blinking an LED with the Eclipse* IDE on the Intel® Edison board

Please refer: https://software.intel.com/en-us/blinking-led-with-eclipse-ide-on-intel-edison-board

5. Enable Edison Bluetooth and SPP

(1)   Change Bluetooth device name

root@edison:~# rfkill list

root@edison:~# rfkill unblock Bluetooth

root@edison:~#bluetoothctl

[bluetooth]# scan on

[bluetooth]# discoverable on

[bluetooth]# exit

root@edison:~#vi /var/lib/bluetooth/XX:XX:XX:XX:XX:XX/settings

Add the line: Alias=MyName-edison

root@edison:~#shutdown –r now

(2)  Upload Python script of SPP test-profile via DBUS API

Run FTP client in the host PC with Host: 192.168.2.15 / Protocol: SFTP (SSH FTP).

Upload “SPP-pipe-out.py”.

(3) Add test-profile for SPP

root@edison:~# vi /etc/dbus-1/system.d/bluetooth.conf

If the bluetooth.conf file  doesn’t have the line <allow send_interface="org.bluez.Profile1"/>, add this line and save the file.

root@edison:~#shutdown –r now

(4)  Turning on and BT pairing (in the terminals)

root@edison:~# python SPP-pipe-out.py &

root@edison:~#rfkill unblock bluetooth

root@edison:~#bluetoothctl

[bluetooth]# show                 ← to make sure of the Serial Port Profile

[bluetooth]# scan on

[bluetooth]# pair 40:E2:30:21:64:18     ← enter the MAC of your android device

In Android device, select ‘pair’ in the pop-up.

[bluetooth]# discoverable on             ← to connect it in the Android

[bluetooth]# trust 40:E2:30:21:64:18     ← enter the MAC of your android device

(5) Run BT app in the Android device and connect by SPP

In Android device, run “bluetooth spp pro” → scan → select your edison → connect → CMD line mode

6. Intel(R) Edison BT SPP application

(1) Copy 2 files to your eclipse workspace ‘on board LED blinking C++’ application’s source folder. (e.g. \workspace\ble-spp-led-test1\src)

                          Intel_Edison_BT_SPP.cpp

                          Intel_Edison_BT_SPP.hpp 

(2) Press F5 (Refresh) in the Project Explorer of eclipse.

(3) Add and modify codes in your main() of  'LED blinking C++ applications' by referring the ble-spp-test.cpp.

                          ble-spp-test.cpp

7. Turn on / off on board LED via BT SPP from the Android device.

(1) Turn on and BT pairing / Run BT app → see the procedure “5. Enable Edison Bluetooth and SPP (4) and (5)” above.

(2) Build and run the BT SPP application in the eclipse. (Please make sure the connection of Edison in the Target SSH Connections of eclipse.)

(3) Send ‘on’ or ‘off’ in the BT SPP Pro of Android device and check the on board LED.

8. Terms 

9. References

Intel(R) Edison Bluetooth Guide Document.

Connecting the Intel® Edison board to your Android* Phone with Serial Port Profile (SPP)

https://software.intel.com/en-us/articles/connecting-the-intel-edison-board-to-your-android-phone-with-serial-port-profile-spp\

Communicate to Arduino code with your Android* Phone by Bluetooth Serial Port Profile (SPP) on Intel® Edison

https://software.intel.com/en-us/blogs/2015/05/19/communicate-to-arduino-code-with-your-android-phone-by-bluetooth-serial-port

Blinking an LED with the Eclipse* IDE on the Intel® Edison board

https://software.intel.com/en-us/blinking-led-with-eclipse-ide-on-intel-edison-board

The Intel Hardware Accelerated Execution Manager (Intel® HAXM) is a hardware-assisted virtualization engine (hypervisor) that uses Intel Virtualization Technology (Intel® VT) to speed up Android app emulation on a host machine. In combination with Android x86 emulator images provided by Intel and the official Android SDK Manager, HAXM allows for faster Android emulation on Intel VT enabled systems.

Intel HAXM is a feature of Intel® Integrated Native Developer Experience (Intel® INDE)

The following platforms are supported by the Intel HAXM:

By Marc Saltzman

Imagine one day you’re being rehabilitated after an orthopedic procedure, perhaps to repair a repetitive strain injury in your wrist. Instead of wearing sensors to monitor your progress – which are cumbersome, expensive and limited – you simply move your fingers in front of what looks like a webcam and the physician or physiotherapist gleans a more accurate reading.

Or on a more recreational note, envision yourself sitting down to play a game in front of your laptop, desktop or tablet. No controller? No problem. With hands outstretched, you perform minute gestures in the air to manipulate onscreen content – be it dangling your fingers to make it rain, punching forward to break through rocks or extending a forefinger to draw an object in the virtual sand.

Both of these scenarios summarize the grand prize-winning entries in the Intel® RealSense™ App Challenge, the third annual call to developers to create next-generation experiences using an Intel® RealSense™ 3D Camera and the Intel® RealSense™ Software Development Kit (SDK) for Windows*.

“Orthosense” by David Schnare, and the game “Seed” by Alexandre Ribeiro da Silva, took top spots out of the thousands of entries from 37 countries -- up from 19 last year. With an incentive like a cash prize pool of $465,000 awarded to 21 of the winners, developers were challenged to blur the lines between human and computer interaction with a camera similar to the one already embedded in many of today’s devices, including the HP Envy* laptop and Lenovo B50 All-in-One desktop.

Utilizing a best-in-class three-dimensional depth sensor, Intel® RealSense™ technology enables new ways to interact, including 22-point hand and finger tracking and gesture recognition, facial detection and tracking, speech recognition, and even background subtraction to create a kind of green screen – without needing a green screen.

Think of it as Kinect* on steroids.

“As rapidly and profoundly as technology continues to advance, one thing remains constant: the need for more human and intuitive ways to interact with it,” says Scott Steinberg, a leading analyst, futurist, and author of Make Change Work for You. “Whether scanning in favorite objects, like children’s toys, and reprinting them on demand at grandma’s house, navigating through 3D models of homes or tradeshow floors with the wave of a hand, or using gesture controls to flip through your music collection, it’s only natural for software and hardware developers alike to look to technology solutions such as this that provide more user-friendly and accessible controls.”

In the same way Microsoft's Kinect made it possible to engage with video games, films and TV shows with the flick of a wrist, Intel RealSense technology takes it to the next level for a variety of business, health, social, family and communications-related applications, adds Steinberg.

Dean Takahashi, lead writer for GamesBeat at VentureBeat, says he’s glad to see Intel “is seeding developers to make creative demos that take gaming in a new direction,” and the company is “walking a fine line between making a cool technology that has precise controls and delivering a solution that is affordable to everyone.”

Winners of the Intel RealSense App Challenge submitted entries in one of five categories: Collaboration, Open Innovation, Learning, Interact Naturally, and Gaming.

To learn more, please visit the Winner’s Showcase website.

A brief look at some highlights:

Orthosense

A collaborative effort between the UK and Canada, Orthosense uses Intel RealSense technology to identify, calculate and record hand and wrist range movements for orthopedic specialists and surgeons. The goal is to measure range of movement of patients as they rehabilitate from hand and wrist problems. With greater accuracy, comfort and speed, both patient and practitioner receive objective data to measure progress.

“Orthosense algorithms provided the positions of the joints and calculated the exact angle of any given joints at any given time,” explains Kinetisense Inc. chief officer David Schnare. “No need to use plain-old tools or expensive wearable equipment [as] the patient simply places their hand in front of the sensor and all the necessary calculations are performed with remarkable accuracy and speed.”

“The best part,” Schnare continues, “is the fact the range of motion identification is performed in less than half a second. The patient simply places their hand in front of the sensor and all the necessary calculations are performed with remarkable accuracy and speed.”

Schnare says the company’s goal is to take advantage of “the affordable Intel RealSense camera to produce affordable human movement analysis software that’s widely adopted by practitioners.”

Orthosense was awarded Grand Prize in the Open Innovation category.

Seed

Grand Prize winner in the Gaming category, Seed challenges players to help guide a floating seed though it’s journey to reforest a devastated land. Fitting, perhaps, as the developer is based in Brazil, which has one of the highest deforestation rates in the world.

Using intuitive gestures in front of the 3D camera, players control the environment to help the seed along, such as removing obstacles and making it rain.

“Intel RealSense technology gives a certain ‘magic’ feeling to the game since the player’s hand movements produce an instant response in the seed,” explains Alexandre Ribeiro, co-founder of AnimaGames. “Using the hand and fingers position detection system, we could develop the game’s core mechanic that works as a ‘guessing game,’ where the player has to think and perform a gesture that matches the required action.”

Virtual 3D Video Maker

First place winner in the Collaboration category, Virtual 3D Video Maker – as the name suggests – lets you record yourself as a 3D hologram for a more immersive communication experience. Along with playing it back in front of a number of digitally imported scenes of your choosing, you can also change the camera position over the course of the playback to add an extra dimension to your video blogs, messages or even real-time chats.

“I used both face direction and voice recognition to create a context-based, hands-free interface,” says Lee Bamber, CEO of The Game Creators in North Wales, UK. “I also used the real-time depth data from the camera to create a 3D representation of the user and store this data along with the real-time audio to create a true 3D recording that can be played back from different angles.”

About the Author

Marc Saltzman is one of North America's most recognizable and trusted tech experts, specializing in consumer electronics, business technology, interactive entertainment and Internet trends. Marc has authored 15 books since 1996 and currently contributes to nearly 50 high-profile publications in North America, including USA Today, MSN, Yahoo!, Costco Connection, Toronto Star, Movie Entertainment, TheLoop.ca, Telus Talks Business and Rogers Connected. Marc hosts various video segments, including "Gear Guide" (seen at Cineplex movie theaters and sister chains across Canada) and is a regular guest on CNN, CNN International and CTV's Canada AM. Marc also hosts "Tech Talk," a radio show on Montreal’s CJAD 800, part of Bell Media.

Follow Marc on Twitter: @marc_saltzman.

Find everything you need to know about how to develop Intel® RealSense™ applications at the Intel® Developer Zone.

Some users may experience a problem where installing Intel Parallel Studio XE 2015 Composer Edition for Windows Update 4 exits the installer after clicking Next on the first install screen. This is most likely to occur if the system also has Intel VTune Amplifier XE or Intel Advisor XE installed.

The problem will be fixed in Update 5. A workaround is as follows:

• Save the attached file composer_xe_2015_common.zip and unpack it to your desktop, creating composer_xe_2015_common.js
• Run the Update 4 installer - uncheck the box for removing the installer files. Note the location where it is unpacking the files, for example, C:\Program Files (x86)\Intel\Download\w_fcompxe_2015.4.221. This will be referred to as <unpack-location> below.
• Once the installer finishes unpacking the files and shows the initial "splash screen", cancel the install.
• Copy the composer_xe_2015_common.js file from the ZIP archive to <unpack-location>\config\PreRequisites This will require administrator privilege.
• Open a command prompt window and "cd <unpack-location>" 
• Type "setup.exe -nsev"

The install should now complete.

An alternative workaround is to download and run the installer for Update 4 of the Professional or Cluster Edition, if your license provides access to that.

This article makes available third-party libraries, executables and sources that were used in the creation of Intel® Software Development Products or are required for operation of those. Intel provides this software pursuant to their applicable licenses.

Required for Operation of Intel® Software Development Products

The following products require additional third-party software for operation.

Intel® Parallel Studio XE 2015 Composer Edition for C++ Windows* and
Intel® System Studio 2015 Composer Edition for Windows*:
The following binutils package is required for operation with Intel® Graphics Technology:
DownloadDownload
Please see Release Notes of the product for detailed instructions on using the binutils package.

The above binutils package is subject to various licenses. Please see the corresponding sources for more information:
DownloadDownload
 

Used within Intel® Software Development Products

The following products contain Intel® Application Debugger, Intel® Many Integrated Core Architecture Debugger and/or Intel® JTAG Debugger tools which are using third party libraries as listed below.

Products and Versions:

Intel® System Studio 2016 Beta

Intel® Composer XE 2015 for Linux*

• Intel® C++ Composer XE 2015 for Linux*/Intel® Fortran Composer XE 2015 for Linux*
  (Initial Release and higher)

Intel® Composer XE 2013 SP1 for Linux*

• Intel® C++ Composer XE 2013 SP1 for Linux*/Intel® Fortran Composer XE 2013 SP1 for Linux*
  (Initial Release and higher; 13.0 Intel® Application Debugger)

Intel® Composer XE 2013 for Linux*

• Intel® C++ Composer XE 2013 for Linux*/Intel® Fortran Composer XE 2013 for Linux*
  (Initial Release and higher; 13.0 Intel® Application Debugger)

Intel® Composer XE 2011 for Linux*

• Intel® C++ Composer XE 2011 for Linux*/Intel® Fortran Composer XE 2011 for Linux*
  (Update 6 and higher; 12.1 Intel® Application Debugger)
• Intel® C++ Composer XE 2011 for Linux*/Intel® Fortran Composer XE 2011 for Linux*
  (Initial Release and up to Update 5; 12.0 Intel® Application Debugger)

Intel® Compiler Suite Professional Edition for Linux*

• Intel® C++ Compiler for Linux* 11.1/Intel® Fortran Compiler for Linux* 11.1
• Intel® C++ Compiler for Linux* 11.0/Intel® Fortran Compiler for Linux* 11.0
• Intel® C++ Compiler for Linux* 10.1/Intel® Fortran Compiler for Linux* 10.1

Intel® Embedded Software Development Tool Suite for Intel® Atom™ Processor:

• Version 2.3 (Initial Release and up to Update 2)
• Version 2.2 (Initial Release and up to Update 2)
• Version 2.1
• Version 2.0

Intel® Application Software Development Tool Suite for Intel® Atom™ Processor:

• Version 2.2 (Initial Release and up to Update 2)
• Version 2.1
• Version 2.0

Intel® C++ Software Development Tool Suite for Linux* OS supporting Mobile Internet Devices (Intel® MID Tools):

• Version 1.1
• Version 1.0

Intel AppUp™ SDK Suite for MeeGo*

• Initial Release (Version 1.0)

Used third-party libraries:
Please see the attachments for a complete list of third-party libraries.

Note: The packages posted here are unmodified copies from the respective distributor/owner and are made available for ease of access. Download or installation of those is not required to operate any of the Intel® Software Development Products. The packages are provided as is, without warranty or support.

One of the cool new features announced for the upcoming WIndows10 is Windows Hello.

It's essentially a new way to login in the system with an exclusive face recognition feature that auto log the user when it come in front of its PC.

How it works

This magic feature is based on a magic technology that tag a face and can recognize it back securely.

The recognition is done using two type of camera in cooperation; the first is a classical HD camera and the second is a depth camera (infrared) for 3D an temperature scanning.

The system recognize and match a lot of point describing specific target of the face, the eyes, the lips, the nose etc; describing a precise path different for each person and assigning to this array of points a specific and unique tag.

When the system come in non-logged state it automatically try to recognize the face coming behind it and matching with the one archived for the local Windows Hello, if a match is done it auto log to the corresponding user profile.

On the Windows10 side the game is done by Passport that log you to the system (using the PIN password) only when the biometric device (in this case the camera) acknowledge the recognition of you face; it works essentially in the same manner on all the device with a fingerprint reader embedded. The system already manage also the retina scan login, but you will obviously need a specific retina scan device.

Obviously it doesn't work with photo, or miniature of the face.....

What whe need to get it work

Actually there's only one standalone device certified for Windows hello, the Intel Realsense camera F200.

It's a 3D camera part of a Intel Dev Kit Developed by Intel named Realsense SDK: this SDK is a big set o free library to enable feature like Face recognition, face detection, object tracking, gesture recognition, speech synthesys and speech recognition. You can freely download it from this link.

Otherwise you need a device with a Realsense camera onboard (click here for a full list).

You  only need a device running Windows 10 (the Insider Technical preview also).

How to do it

Connect the camera to you Win 10 device, the system will automatically recognize some new devices

In order to install the new available driver and eventualy update the formware of the camera we need to download and install  the "Intel RealSense Depth Camera Manager (DCM)" software from Intel at this link.

After the download install and run it, follow instruction to update driver and firmware of the camera.

For the next step go to Windows 10 Settings/Accounts/Sign In options and define PIN password.

Once defined it close and reopen Settings /Accounts/Sign-in options you'll see also a Windows Hello option!

Click on Set Up, press Get Started, the system will ask for you PIN password, enter it and a preview of the image captured from the F200 camera will appear.

Once the operation end succesfully the system will show the message AllSet!

Close the window and try immediately to sign out from actual session.

When the system return to the login page will immediately recognize you (if you are still in front of your PC obviously) and auto login in your profile.

Thats it!

Enjoy

This page provides the current Release Notes for the Debug Solutions from Intel® Parallel Studio XE 2016 Composer Edition for Fortran Linux*, Windows* and OS X* products.

To get product updates, log in to the Intel® Software Development Products Registration Center.

For questions or technical support, visit Intel® Software Products Support.

For the top-level Release Notes, visit:

• Intel Visual Fortran Compiler XE 16.0 Beta for Windows* Release Notes (for Intel Parallel Studio XE 2016 Beta)
• Intel Fortran Compiler XE 16.0 Beta for Linux* Release Notes (for Intel Parallel Studio XE 2016 Beta)
• Intel Fortran Compiler XE 16.0 Beta for OS X* Release Notes (for Intel Parallel Studio XE 2016 Beta)

Table of Contents:

• Change History
• Product Contents
• GNU* GDB
• Intel® Debugger Extension for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)
• Fortran Expression Evaluator (FEE) for debugging Fortran applications with Microsoft Visual Studio*
• Attributions
• GNU* Free Documentation License
• Disclaimer and Legal Information

Change History

This section highlights important from the previous product version and changes in product updates.

Changes since Intel® Parallel Studio XE 2015 Composer Edition

• Support for additional Fortran intrinsics added to GNU* GDB
• Improved display of OpenMP* tasks with GNU* GDB

Product Contents

• Linux*:
  • GNU* Project Debugger (GDB) 7.8:
    Command line for host CPU and Intel® Xeon Phi™ coprocessor, and Eclipse* IDE plugin for offload enabled applications.
• OS X*:
  • GNU* Project Debugger (GDB) 7.8:
    Command line for CPU only.
• Windows*:
  • Intel® Debugger Extension for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)
  • Fortran Expression Evaluator (FEE) as extension to debugger of Microsoft Visual Studio*

GNU* GDB

Features

• Intel® Processor Trace (Intel® PT) support for 5th generation Intel® Core™ Processors:
  (gdb) record btrace pt
• Support for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)
• Support for Intel® Transactional Synchronization Extensions (Intel® TSX) (Linux & OSX)
• Register support for Intel® Memory Protection Extensions (Intel® MPX) and Intel® Advanced Vector Extensions 512 (Intel® AVX-512)
• Data Race Detection (pdbx):
  Detect and locate data races for applications threaded using POSIX* thread (pthread) or OpenMP* models
• Branch Trace Store (btrace):
  Record branches taken in the execution flow to backtrack easily after events like crashes, signals, exceptions, etc.

Using GNU* GDB

• IA-32/Intel® 64 debugger:
  Debug applications natively on IA-32 or Intel® 64 systems with gdb-ia on the command line.
  A standard Eclipse* IDE can be used for this as well if a graphical user interface is desired.
• Intel® Xeon Phi™ coprocessor debugger (only for Linux*):
  Debug applications remotely on Intel® Xeon Phi™ coprocessor systems. The debugger will run on a host system and a debug agent (gdbserver) on the coprocessor.
  There are two options:
  • Use the command line version of the debugger with gdb-mic.
    This only works for native Intel® Xeon Phi™ coprocessor applications.
    A standard Eclipse* IDE can be used for this as well if a graphical user interface is desired.
  • Use an Eclipse* IDE plugin shipped with Intel® Parallel Studio XE 2016 Composer Edition.
    This works only for offload enabled Intel® Xeon Phi™ coprocessor applications. Instructions on how to use GNU* GDB can be found in the Documentation section.

<install-dir>/documentation_2016/en/debugger/gdb-ia/gdb.pdf<install-dir>/documentation_2016/en/debugger/gdb-mic/gdb.pdf<install-dir>/documentation_2016/en/debugger/ps2016/gs_gdb_ps_lin.htm

<install-dir>\documentation_2016\en\debugger\ps2016\gs_gdb_ps_win.htm

IDF Date: Aug 18 - Aug 20, 2015

Can’t attend IDF in person this year?  We have you covered.  Selected software sessions will be webcasted which will give you the opportunity to join our experts live.  See the schedule below and register now:

Cross-Platform Mobile App Development With Native Performance Using Intel® Integrated Native Developer Experience

Abstract: With native look and feel, performance and portability across multiple target mobile OS and architectures, Intel® Integrated Native Developer Experience (Intel® INDE)
is a one-stop productivity suite that brings together a great arsenal of application development tools and libraries to expose advanced platform capabilities.
Come to this session to see:
• Intel INDE in action developing Android* and cross-OS apps with rich media experience
• Live demos showcasing apps built with innovative SDKs and tools included in Intel INDE
• How companies such as Open Labs*, Audible Magic* and 23Snaps* are using Intel INDE to develop native applications for multiple platforms that stand out in the marketplace

Register

Parallel Programming Pearls: Inspired by Intel® Xeon Phi™ Products

Abstract: This session dives into real-world parallel programming optimization examples, from around the world, through the eyes and wit of enthusiast, author, editor and evangelist James Reinders.
This session will explore:
• Concrete real world examples of how Intel® Xeon Phi™ products extend parallel programming seamlessly from a few cores to many-cores (over 60) with the same programming models
• Examples from the newly released book, “High Performance Parallelism Pearls Volume 2”, will be highlighted with source code for all examples freely available.

Register

Intel® XDK HTML5 Cross-Platform Development Environment - Building Cordova Apps with Crosswalk Project

Abstract: Join Paul Fischer as he discusses how the Intel® XDK HTML5 Cross-Platform Development Environment enables developers to create mobile Cordova apps for Android*, iOS* and Windows* phones and tablets. With the Intel® XDK HTML5 Cross-Platform Development Tools and Crosswalk Project runtime, high-performance apps can be easily debugged and profiled in real-time, directly on-device. By providing a complete set of tools to create, build, test and debug mobile apps, the Intel® XDK helps speed the development cycle for HTML5 apps, by enabling developers to quickly and easily create apps for multiple app stores, across diverse devices.

In this session you will hear about:
• Finding performance and memory bottlenecks in Crosswalk Project HTML5 apps
• Improving app quality with real-time on-device debug and test
• Enhancing performance, especially for games and interactive applications
• Taming the Android native Webview problem with a modern Blink Webview

Register

Coding for Maximum Utilization of Next Generation Intel® Processors in the IoT Era

Abstract: Join Noah Clemons as he leads a discussion with a variety of Intel® Architecture based system optimization experts from Intel together to address the following:
• System-on-chip complexity – new features on System-on-Chips (SoCs)
• Application of those features to several different IoT domains
• Fastest ways to maximize new SoC features through software
• In-depth system-wide tracing, debugging, performance and power analysis
• Tools eco-system to support the latest and next generation Intel® Architecture based SoCs

Register

Principal Investigator:

Srinivas Aluru is a professor in the School of Computational Science and Engineering within the College of Computing at Georgia Institute of Technology. He serves as a co-director of the Georgia Tech Strategic Initiative in Data Engineering and Science. Aluru conducts research in high performance computing, bioinformatics, systems biology, and combinatorial scientific computing. He pioneered the development of parallel methods in computational genomics and systems biology. He is a Fellow of the American Association for the Advancement of Science (AAAS) and the Institute of Electrical and Electronic Engineers (IEEE).

Description:

The Intel® Parallel Computing Center (Intel® PCC) on Big Data in Biosciences and Public Health is focused on developing and optimizing parallel algorithms and software on Intel® Xeon® Processor and Intel® Xeon Phi™ Coprocessor systems for handling high-throughput DNA sequencing data and gene expression data. Advances in high-throughput sequencing technologies permit massively parallel sequencing of DNA at a low cost, leading to the creation of big data sets even in routine investigations by small research laboratories. Rapid analysis of such large-scale data is of critical importance in many applications, and is the foundation of modern genomics. This is currently an area underserved by high performance computing, but has great economic potential and societal prominence.

Research under this Intel® PCC will be focused on two large-scale projects: The first project is a comprehensive effort to identify core index structures and fundamental building blocks for the numerous applications of high-throughput DNA sequencing, develop parallel algorithms for them, and release them as software libraries to enable application parallelization. The Intel® PCC will support development of novel algorithms optimized for the Intel® Xeon Phi™ coprocessors, and development and release of software libraries specifically optimized for Intel® Xeon® processors and Intel® Xeon Phi™ coprocessors. The second project concerns the development of systems biology tools for biological researchers. Under the Intel® PCC, two objectives will be pursued: Large-scale Intel based clusters and supercomputers will be used to build whole-genome networks for important model organisms and make them widely available to researchers. A second objective is to put mid-scale network capabilities in the hands of individual biology researchers. The project will leverage other collaborative projects that support experimental research, allowing direct experimental verification of some of the tools generated under the Intel® PCC.

The work will lead to the release of open source software optimized for Intel® Xeon® processors and Intel® Xeon Phi™ coprocessors in the important areas of computational genomics and systems biology. These will be used in applications with the potential to impact many important fields including viral and microbial genomics, agricultural biotechnology, and precision medicine. The research is expected to inform future Intel architectural designs regarding suitability in the important area of bioinformatics.

Related websites:

www.cc.gatech.edu/~saluru

Q1: How do I set app orientation?

If you are using Cordova* 3.X build options (Crosswalk* for Android*, Android*, iOS*, etc.), you can set the orientation under the Projects panel > Select your project > Cordova* 3.X Hybrid Mobile App Settings - Build Settings. Under the Build Settings, you can set the Orientation for your desired mobile platform.  

If you are using the Legacy Hybrid Mobile App Platform build options (Android*, iOS* Ad Hoc, etc.), you can set the orientation under the Build tab > Legacy Hybrid Mobile App Platforms Category- <desired_mobile_platform> - Step 2 Assets tab. 

[iPad] Create a plugin (directory with one file) that only has a config xml that includes the following: 

<config-file target="*-Info.plist" parent="UISupportedInterfaceOrientations~ipad" overwrite="true"><string></string></config-file><config-file target="*-Info.plist" parent="UISupportedInterfaceOrientations~ipad" overwrite="true"><array><string>UIInterfaceOrientationPortrait</string></array></config-file> 

Add the plugin on the build settings page. 

Alternatively, you can use this plugin: https://github.com/yoik/cordova-yoik-screenorientation. You can import it as a third-party Cordova* plugin using the Cordova* registry notation:

• net.yoik.cordova.plugins.screenorientation (includes latest version at the time of the build)
• net.yoik.cordova.plugins.screenorientation@1.3.2 (specifies a version)

Or, you can reference it directly from the GitHub repo: 

• github.com/yoik/cordova-yoik-screenorientation.git
• github.com/yoik/cordova-yoik-screenorientation.git#06b93e6

The second reference provides the git commit referenced here (we do not support pulling from the PhoneGap registry).

Q2: Is it possible to create a background service using Intel XDK?

Background services require the use of specialized Cordova* plugins that need to be created specifically for your needs. Intel XDK does not support development or debug of plugins, only the use of them as "black boxes" with your HTML5 app. Background services can be accomplished using Java on Android or Objective C on iOS. If a plugin that backgrounds the functions required already exists (for example, this plugin for background geo tracking), Intel XDK’s build system will work with it.

Q3: How do I send an email from my App?

You can use the Cordova* email plugin or use web intent - PhoneGap* and Cordova* 3.X.

Q4: How do you create an offline application?

You can use the technique described here by creating an offline.appcache file and then setting it up to store the files that are needed to run the program offline. Note that offline applications need to be built using the Cordova* or Legacy Hybrid build options.

Q5: How do I work with alarms and timed notifications?

Unfortunately, alarms and notifications are advanced subjects that require a background service. This cannot be implemented in HTML5 and can only be done in native code by using a plugin. Background services require the use of specialized Cordova* plugins that need to be created specifically for your needs. Intel XDK does not support the development or debug of plugins, only the use of them as "black boxes" with your HTML5 app. Background services can be accomplished using Java on Android or Objective C on iOS. If a plugin that backgrounds the functions required already exists (for example, this plugin for background geo tracking) the Intel XDK’s build system will work with it. 

Q6: How do I get a reliable device ID? 

You can use the Phonegap/Cordova* Unique Device ID (UUID) plugin for Android*, iOS* and Windows* Phone 8. 

Q7: How do I implement In-App purchasing in my app?

There is a Cordova* plugin for this. A tutorial on its implementation can be found here. There is also a sample in Intel XDK called ‘In App Purchase’ which can be downloaded here.

Q8: How do I install custom fonts on devices?

Fonts can be considered as an asset that is included with your app, not shared among other apps on the device just like images and CSS files that are private to the app and not shared. It is possible to share some files between apps using, for example, the SD card space on an Android* device. If you include the font files as assets in your application then there is no download time to consider. They are part of your app and already exist on the device after installation.

Q9: How do I access the device’s file storage?

You can use HTML5 local storage and this is a good article to get started with. Alternatively, there is a Cordova* file plugin for that.

Q10: Why isn't AppMobi* push notification services working?

This seems to be an issue on AppMobi’s end and can only be addressed by them. PushMobi is only available in the "legacy" container. AppMobi* has not developed a Cordova* plugin, so it cannot be used in the Cordova* build containers. Thus, it is not available with the default build system. We recommend that you consider using the Cordova* push notification plugin instead.

Q11: How do I configure an app to run as a service when it is closed?

If you want a service to run in the background you'll have to write a service, either by creating a custom plugin or writing a separate service using standard Android* development tools. The Cordova* system does not facilitate writing services.

Q12: How do I dynamically play videos in my app?

1) Download the Javascript and CSS files from https://github.com/videojs

2) Add them in the HTML5 header. 

<config-file target="*-Info.plist" parent="UISupportedInterfaceOrientations~ipad" overwrite="true"><string></string></config-file><config-file target="*-Info.plist" parent="UISupportedInterfaceOrientations~ipad" overwrite="true"><array><string>UIInterfaceOrientationPortrait</string></array></config-file> 

 3) Add a panel ‘main1’ that will be playing the video. This panel will be launched when the user clicks on the video in the main panel.

<div class=”panel” id=”main1” data-appbuilder-object=”panel” style=””><video id=”example_video_1” class=”video-js vjs-default-skin” controls=”” preload=”auto” width=”200” poster=”camera.png” data-setup=”{}”><source src=”JAIL.mp4” type=”video/mp4”><p class=”vjs-no-js”>To view this video please enable JavaScript*, and consider upgrading to a web browser that <a href=http://videojs.com/html5-video-support/ target=”_blank”>supports HTML5 video</a></p></video><a onclick=”runVid3()” href=”#” class=”button” data-appbuilder-object=”button”>Back</a></div>

 4) When the user clicks on the video, the click event sets the ‘src’ attribute of the video element to what the user wants to watch. 

Function runVid2(){

      Document.getElementsByTagName(“video”)[0].setAttribute(“src”,”appdes.mp4”);

      $.ui.loadContent(“#main1”,true,false,”pop”);

}

 5) The ‘main1’ panel opens waiting for the user to click the play button.

Note: The video does not play in the emulator and so you will have to test using a real device. The user also has to stop the video using the video controls. Clicking on the back button results in the video playing in the background.

Q13: How do I design my Cordova* built Android* app for tablets?

This page lists a set of guidelines to follow to make your app of tablet quality. If your app fulfills the criteria for tablet app quality, it can be featured in Google* Play's "Designed for tablets" section.

Q14: How do I resolve icon related issues with Cordova* CLI build system?

Ensure icon sizes are properly specified in the intelxdk.config.additions.xml. For example, if you are targeting iOS 6, you need to manually specify the icons sizes that iOS* 6 uses. 

<icon platform="ios" src="images/ios/72x72.icon.png" width="72" height="72" /><icon platform="ios" src="images/ios/57x57.icon.png" width="57" height="57" />

These are not required in the build system and so you will have to include them in the additions file. 

For more information on adding build options using intelxdk.config.additions.xml, visit: /en-us/html5/articles/adding-special-build-options-to-your-xdk-cordova-app-with-the-intelxdk-config-additions-xml-file

Q15: Is there a plugin I can use in my App to share content on social media?

Yes, you can use the PhoneGap Social Sharing plugin for Android*, iOS* and Windows* Phone.

Q16: Iframe does not load in my app. Is there an alternative?

Yes, you can use the inAppBrowser plugin instead.

Q17: Why are intel.xdk.istablet and intel.xdk.isphone not working?

Those properties are quite old and is based on the legacy AppMobi* system. An alternative is to detect the viewport size instead. You can get the user’s screen size using screen.width and screen.height properties (refer to this article for more information) and control the actual view of the webview by using the viewport meta tag (this page has several examples). You can also look through this forum thread for a detailed discussion on the same.

Q18: How do I work with the App Security plugin on Intel XDK?

Select the App Security plugin on the plugins list of the Project tab and build your app as a Cordova Hybrid app. Building it as a Legacy Hybrid app has been known to cause issues when compiled and installed on a device.

Q19: Why does my build fail with Admob plugins? Is there an alternative?

Intel XDK does not support the library project that has been newly introduced in the com.google.playservices@21.0.0 plugin. Admob plugins are dependent on "com.google.playservices", which adds Google* play services jar to project. The "com.google.playservices@19.0.0" is a simple jar file that works quite well but the "com.google.playservices@21.0.0" is using a new feature to include a whole library project. It works if built locally with Cordova CLI, but fails when using Intel XDK.

To keep compatible with Intel XDK, the dependency of admob plugin should be changed to "com.google.playservices@19.0.0".

Q20: Why does the intel.xdk.camera plugin fail? Is there an alternative?

There seem to be some general issues with the camera plugin on iOS*. An alternative is to use the Cordova camera plugin, instead and change the version to 0.3.3.

Q21: How do I resolve Geolocation issues with Cordova?

Give this app a try, it contains lots of useful comments and console log messages. However, use Cordova 0.3.10 version of the geo plugin instead of the Intel XDK geo plugin. Intel XDK buttons on the sample app will not work in a built app because the Intel XDK geo plugin is not included. However, they will partially work in the Emulator and Debug. If you test it on a real device, without the Intel XDK geo plugin selected, you should be able to see what is working and what is not on your device. There is a problem with the Intel XDK geo plugin. It cannot be used in the same build with the Cordova geo plugin. Do not use the Intel XDK geo plugin as it will be discontinued.

Geo fine might not work because of the following reasons:

1. Your device does not have a GPS chip
2. It is taking a long time to get a GPS lock (if you are indoors)
3. The GPS on your device has been disabled in the settings

Geo coarse is the safest bet to quickly get an initial reading. It will get a reading based on a variety of inputs, but is usually not as accurate as geo fine but generally accurate enough to know what town you are located in and your approximate location in that town. Geo coarse will also prime the geo cache so there is something to read when you try to get a geo fine reading. Ensure your code can handle situations where you might not be getting any geo data as there is no guarantee you'll be able to get a geo fine reading at all or in a reasonable period of time. Success with geo fine is highly dependent on a lot of parameters that are typically outside of your control.

Q22: Is there an equivalent Cordova* plugin for intel.xdk.player.playPodcast? If so, how can I use it?

Yes, there is and you can find the one that best fits the bill from the Cordova* plugin registry.

To make this work you will need to do the following:

• Detect your platform (you can use uaparser.js or you can do it yourself by inspecting the user agent string)
• Include the plugin only on the Android* platform and use <video> on iOS*.
• Create conditional code to do what is appropriate for the platform detected 

You can force a plugin to be part of an Android* build by adding it manually into the additions file. To see what the basic directives are to include a plugin manually:

1. Include it using the "import plugin" dialog, perform a build and inspect the resulting intelxdk.config.android.xml file.
2. Then remove it from your Project tab settings, copy the directive from that config file and paste it into the intelxdk.config.additions.xml file. Prefix that directive with <!-- +Android* -->. 

More information is available here and this is what an additions file can look like:

<preference name="debuggable" value="true" /><preference name="StatusBarOverlaysWebView" value="false" /><preference name="StatusBarBackgroundColor" value="#000000" /><preference name="StatusBarStyle" value="lightcontent" /><!-- -iOS* --><intelxdk:plugin intelxdk:value="nl.nielsad.cordova.wifiscanner" /><!-- -Windows*8 --><intelxdk:plugin intelxdk:value="nl.nielsad.cordova.wifiscanner" /><!-- -Windows*8 --><intelxdk:plugin intelxdk:value="org.apache.cordova.statusbar" /><!-- -Windows*8 --><intelxdk:plugin intelxdk:value="https://github.com/EddyVerbruggen/Flashlight-PhoneGap-Plugin" />

This sample forces a plugin included with the "import plugin" dialog to be excluded from the platforms shown. You can include it only in the Android* platform by using conditional code and one or more appropriate plugins.

Q23: How do I display a webpage in my app without leaving my app?

The most effective way to do so is by using inAppBrowser.

Q24: Does Cordova* media have callbacks in the emulator?

While Cordova* media objects have proper callbacks when using the debug tab on a device, the emulator doesn't report state changes back to the Media object. This functionality has not been implemented yet. Under emulation, the Media object is implemented by creating an <audio> tag in the program under test. The <audio> tag emits a bunch of events, and these could be captured and turned into status callbacks on the Media object.

Q25: Why does the Cordova version not match between the Projects tab Build Settings, Emulate tab, App Preview and my built app?

This is due to the difficulty in keeping different components in sync and is compounded by the version convention that the Cordova project uses to distinguish build tools (the CLI version) from frameworks (the Cordova version) and plugins.

The CLI version you specify in the Projects tab Build Settings section is the "Cordova CLI" version that the build system will use to build your app. Each version of the Cordova CLI tools come with a set of "pinned" Cordova framework versions, which vary as a function of the target platform. For example, the Cordova CLI 5.0 platformsConfig file is "pinned" to the Android Cordova framework version 4.0.0, the iOS Cordova framework version 3.8.0 and the Windows 8 Cordova framework version 3.8.1 (among other targets). The Cordova CLI 4.1.2 platformsConfig file is "pinned" to Android Cordova 3.6.4, iOS Cordova 3.7.0 and Windows 8 Cordova 3.7.1.

This means that the Cordova framework version you are using "on device" with a built app will not equal the version number that is in the CLI field that you specified in the Build Settings section of the Projects tab when you built your app. Technically, the target-specific Cordova frameworks can be updated [independently] within a given version of CLI tools, but our build system always uses the Cordova framework versions that were "pinned" to the CLI when it was released (that is, the Cordova framework versions specified in the platformsConfig file).

The reason you may see Cordova framework version differences between the Emulate tab, App Preview and your built app is:

• The Emulate tab has one specific Cordova framework version it is built against. We try to make that version of the Cordova framework match as closely the default Intel XDK version of Cordova CLI.
• App Preview is released independently of the Intel XDK and, therefore, may support a different version than what you will see reported by the Emulate tab and your built app. Again, we try to release App Preview so it matches the version of the Cordova framework that is the default version of the Intel XDK at the time App Preview is released; but since the various tools are not released in perfect sync, that is not always possible.
• Your app always uses the Cordova framework version that is determined by the Cordova CLI version you specified in the Projects tab's Build Settings section, when you built your app.
• BTW: the version of the Cordova framework that is built into Crosswalk is determined by the Crosswalk project, not by the Intel XDK build system. There is some customization the Crosswalk project team must do to the Cordova framework to include Cordova as part of the Crosswalk runtime engine. The Crosswalk project team generally releases each Crosswalk version with the then current version of the Android Cordova framework. Thus, the version of the Android Cordova framework that is included in your Crosswalk build is determined by the version of Crosswalk you choose to build against.

Do these Cordova framework version numbers matter? Not that much. There are some issues that come up that are related to the Cordova framework version, but they tend to be few and far between. The majority of the bugs and compatibility issues you will experience in your app have more to do with the versions and mix of Cordova plugins you choose and the specific webview present on your test devices. See this blog for more details about what a webview is and why the webview matters to your app: When is an HTML5 Web App a WebView App?.

p.s. The "default version" of the CLI that the Intel XDK uses is rarely the most recent version of the Cordova CLI tools distributed by the Cordova project. There is always a lag between Cordova project releases and our ability to incorporate those releases into our build system and the various Intel XDK components. Also, we are unable to implement every release that is made by the Cordova project; thus the reason why we do not support every Cordova release that is available to Cordova CLI users.

Q26: How do I add a third party plugin?

Please follow the instructions on this doc page to add a third-party plugin: Adding Plugins to Your Intel® XDK Cordova* App -- this plugin is not being included as part of your app. You will see it in the build log if it was successfully added to your build.

Q27: How do I make an AJAX call that works in my browser work in my app?

Please follow the instructions in this article: Cordova CLI 4.1.2 Domain Whitelisting with Intel XDK for AJAX and Launching External Apps.

Q28: I get an "intel is not defined" error, but my app works in Test tab, App Preview and Debug tab. What's wrong?

When your app runs in the Test tab, App Preview or the Debug tab the intel.xdk and core Cordova functions are automatically included for easy debug. That is, the plugins required to implement those APIs on a real device are already included in the corresponding debug modules.

When you build your app you must include the plugins that correspond to the APIs you are using in your build settings. This means you must enable the Cordova and/or XDK plugins that correspond to the APIs you are using. Go to the Projects tab and insure that the plugins you need are selected in your project's plugin settings. See Adding Plugins to Your Intel® XDK Cordova* App for additional details.

Q29: How do I target my app for use only on an iPad or only on an iPhone?

There is an undocumented feature in Cordova that should help you (the Cordova project provided this feature but failed to document it for the rest of the world). If you use the appropriate preference in the intelxdk.config.additions.xml file you should get what you need:

<preference name="target-device" value="tablet" />     <!-- Installs on iPad, not on iPhone --><preference name="target-device" value="handset" />    <!-- Installs on iPhone, iPad installs in a zoomed view and doesn’t fill the entire screen --><preference name="target-device" value="universal" />  <!-- Installs on iPhone and iPad correctly -->

If you need info regarding the additions.xml file, see the blank template or this doc file: Adding Intel® XDK Cordova Build Options Using the Additions File.

Q30: Why does my build fail when I try to use the Cordova* Capture Plugin?

The Cordova* Capture plugin has a dependency on the File Plugin. Please make sure you both plugins selected on the projects tab.

Q31: How can I pinch and zoom in my Cordova* app?

For now, using the viewport meta tag is the only option to enable pinch and zoom. However, its behavior is unpredictable in different webviews. Testing a few samples apps has led us to believe that this feature is better on Crosswalk for Android. You can test this by building the Hello Cordova sample app for Android and Crosswalk for Android. Pinch and zoom will work on the latter only though they both have:

.

Please visit the following pages to get a better understanding of when to build with Crosswalk for Android:

http://blogs.intel.com/evangelists/2014/09/02/html5-web-app-webview-app/

https://software.intel.com/en-us/xdk/docs/why-use-crosswalk-for-android-builds

Another device oriented approach is to enable it by turning on Android accessibility gestures.

Q32: How do I make my Android application use the fullscreen so that the status and navigation bars disappear?

The Cordova* fullscreen plugin can be used to do this. For example, in your initialization code, include this function AndroidFullScreen.immersiveMode(null, null);.

You can get this third-party plugin from here https://github.com/mesmotronic/cordova-fullscreen-plugin

Q33: How do I add XXHDPI and XXXHDPI icons to my Android or Crosswalk application?

The Cordova CLI 4.1.2 build system will support this feature, but our 4.1.2 build system (and the 2170 version of the Intel XDK) does not handle the XX and XXX sizes directly. Use this workaround until these sizes are supported directly:

• copy your XX and XXX icons into your source directory (usually named www)
• add the following lines to your intelxdk.config.additions.xml file
• see this Cordova doc page for some more details

Assuming your icons and splash screen images are stored in your source directory (usually named www), add lines similar to these into your intelxdk.config.additions.xml file (the precise name of your png files may be different than what is shown here):

<!-- for adding xxhdpi and xxxhdpi icons on Android --><platform name="android"><icon src="www/xxhdpi.png" density="xxhdpi" /><icon src="www/xxxhdpi.png" density="xxxhdpi" /><splash src="www/splash-port-xhdpi.png" density="port-xhdpi"/><splash src="www/splash-land-xhdpi.png" density="land-xhdpi"/></platform>

The precise names of your PNG files are not important, but the "density" designations are very important and, of course, the respective resolutions of your PNG files must be consistent with Android requirements. Those density parameters specify the respective "res-drawable-*dpi" directories that will be created in your APK for use by the underlying Android OS. NOTE: splash screen references have been added for reference, you do not need to use this technique for splash screens.

You can continue to insert the other icons into your app using the Intel XDK Projects tab.

Q34: Which plugin is the best to use with my app?

We are not able to track all the plugins out there, so we generally cannot give you a "this is better than that" evaluation of plugins. Check the Cordova plugin registry to see which plugins are most popular and check Stack Overflow to see which are best supported; also, check the individual plugin repos to see how well the plugin is supported and how frequently it is updated. Since the Cordova platform and the mobile platforms continue to evolve, those that are well-supported are likely to be those that have good activity in their repo.

Keep in mind that the XDK builds Cordova apps, so whichever plugins you find being supported and working best with other Cordova (or PhoneGap) apps would likely be your "best" choice.

See Adding Plugins to Your Intel® XDK Cordova* App for instructions on how to include third-party plugins with your app.

Back to FAQs Main 

test

test test

test test test

The providing of your email address is optional. If you choose to receive additional information from Intel your email address will be used to keep you informed on activities that pertain to the Intel® Developer Zone. Your email address may also be used to notify you in the event that you win a prize or giveaway through the use of this application.

To learn more about Intel’s privacy practices, please visit http://www.appsflyer.com/privacy-policy/.
Intel is committed to respecting your privacy.

To learn more about Intel’s privacy practices, please visit http://www.intel.com/privacy.

*Other names and brands may be claimed as the property of others. All product information and prices are not determined and set by Intel but by their owner and may be subject to change without notice.

Directive-based programming models are one solution for exploiting many-core coprocessors to increase simulation rates in molecular dynamics. They offer the potential to reduce code complexity with offload models that can selectively target computations to run on the CPU, the coprocessor, or both. In this paper, we describe modifications to the LAMMPS molecular dynamics code to enable concurrent calculations on a CPU and coprocessor. We demonstrate that standard molecular dynamics algorithms can run efficiently on both the CPU and an x86-based coprocessor using the same subroutines. As a consequence, we demonstrate that code optimizations for the coprocessor also result in speedups on the CPU; in extreme cases up to 4.7X. We provide results for LAMMPS benchmarks and for production molecular dynamics simulations using the Stampede hybrid supercomputer with both Intel^® Xeon Phi™ coprocessors and NVIDIA GPUs. The optimizations presented have increased simulation rates by over 2X for organic molecules and over 7X for liquid crystals on Stampede. The optimizations are available as part of the “Intel package” supplied with LAMMPS.

Download complete PDF DownloadDownload

Data science is not a new discipline. However, with the growth of big data and adoption of big data technologies, the request for better quality data has grown exponentially. Today data science is applied to every facet of life—product validation through fault prediction, genome sequence analysis, personalized medicine through population studies and Patient 360 view, credit card fraud-detection, improvement in customer experience through sentiment analysis and purchase patterns, weather forecast, detecting cyber or terrorist attacks, aircraft maintenance utilizing predictive analytics to repair critical parts before they fail, and many more. Every day, data scientists are detecting patterns in data and providing actionable insights to influence organizational changes.

The data scientist’s work broadly involves acquisition, cleanup, and analysis of data. Being a cross-functional discipline, this work involves communication, collaboration, and interaction with other individuals, internal and possibly external to your organization. This is one reason why the “notebook” features in data analysis tools are gaining popularity. They ease organizing, sharing, and interactively working with long workflows. IPython* Notebook is a great example but is limited to usage of Python* language. Apache Zeppelin* is a new web-based notebook that enables data-driven, interactive data analytics, and visualization with the added bonus of supporting multiple languages, including Python*, Scala*, Spark SQL, Hive*, Shell, and Markdown. Zeppelin also provides Apache Spark* integration by default, making use of Spark’s fast in-memory, distributed, data processing engine to accomplish data science at lightning speed.

In this paper we describe how to install and configure Apache Zeppelin on the Cloudera Distribution of Apache Hadoop*, providing access to Hadoop and Spark.

Download complete PDF DownloadDownload

By utilizing the strengths of the Intel® Xeon Phi™ coprocessor, the  chapter 3 High Performance Parallelism Pearls authors were able to improve and modernize their code and “achieve great scaling, vectorization, bandwidth utilization and performance/watt”. The authors (Jacob Weismann Poulsen, Karthik Raman and Per Berg) note, “The thinking process and techniques used in this chapter have wide applicability: focus on data locality and then apply threading and vectorization techniques.”. In particular, they write about the advection routine from the HIROMB‐BOOS­‐Model (HBM)  which was initially underperforming on the Intel Xeon Phi coprocessor. However, they were able to achieve a 3x performance improvement after re-structuring the code which involved changing data structures for better data locality, exploiting the available threads and SIMD lanes for better concurrency at thread and loop level to utilize the maximum available memory bandwidth. To avoid data licensing issues the example code provided in High Performance Parallelism Pearls utilizes the Baffin Bay setup generated from the freely available ETOPO2 data set.

Click to view entire article.

Linux based HPC clusters can use different Linux distributions or different versions of a given Linux distribution for different types of nodes in the HPC cluster.

When the Linux distribution on which the connector extension has been built uses a glibc version 2.14 or newer and the Linux distribution where the connector extension is used, i.e. where clck-analyze is executed, uses a glibc version lower than 2.14, clck-analyze is not able to execute the shared library of the connector extension due to a missing symbol.

clck-analyze will show a message like this:

<your check>... not found

and

ldd lib<your check>.so

will show the following message, in addition to other output:

./lib<your check>.so: /lib64/libc.so.6: version `GLIBC_2.14' not found (required by ./lib<your check>.so)

The underlying reason is that memcpy is versioned by default as memcpy@GLIBC_2.14 starting in glibc version 2.14.
glibc versions lower than 2.14 will not have memcpy versioned like this.
The previous version, memcpy@GLIBC_2.2.5, is available in all glibc versions.

There are three solutions to this problem.

1. The preferred solution is to compile the connector extension, i.e. lib<your check>.so, on a Linux distribution using a glibc version lower than 2.14
2. If case option #1 cannot be used, you can enforce the use of the compatible memcpy@GLIBC_2.2.5 by adding the following code into the header file of your connector extension (as described here http://stackoverflow.com/questions/8823267/linking-against-older-symbol-version-in-a-so-file):

   #if defined(__GNUC__) && defined(__LP64__)  /* only with 64bit gcc, just to be sure */
   #include <features.h>       /* get the glibc version */
   /* only change memcpy when the version is newer than 2.14 */
   #if defined(__GLIBC__) && (__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 14)
   /* enforce mempcy to use the earlier, i.e. compatible, memcpy@GLIBC_2.2.5 */
   __asm__(".symver memcpy,memcpy@GLIBC_2.2.5");
   #endif
   #undef _FEATURES_H  /* reload it ... usually necessary */
   #endif

3. The third solution is to use a wrapper function. This is also described on the above mentioned web page, but option #2 is simpler and easier to use.

Now you can compile your connector extension on a Linux distribution with a glibc version of 2.14 or newer and use it on a Linux distribution with a glibc version lower than 2.14.

When compiling connector extensions in the Intel^® Cluster Checker v3 SDK it is recommended to use an Intel compiler version 15.0 or newer and a gcc/g++ compiler version 4.9.0 or newer, as described in the Intel^® Cluster Checker developer's Guide. This explicitly includes gcc version 5.1.0 and newer as well.

Due to changes to the C++ ABI that have been introduced in gcc version 5.1.0, a connector extension, i.e. the lib<your check>.so shared library, built with such a gcc version will not function when called from clck-analyze, even when the libstdc++.so.6 provided by that gcc version is being used.

clck-analyze will show a message like this:

<your check>... not found

and executing

ldd lib<your check>.so

without using the libstdc++.so.6 provided by gcc version 5.1.0 or newer will show the following message, in addition to other output:

./lib<your check>.so: /usr/lib64/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by ./lib<your check>.so)

In order to be able to use gcc version 5.1.0 or newer with the Intel^® Cluster Checker v3 SDK you will have to force gcc/g++ to use a previous ABI version by using -D_GLIBCXX_USE_CXX11_ABI=0  as part of the CXXFLAGS.

Introduction

Prior to OpenCL™ 2.0, there was no ability to read and write to an image within the same kernel. Images could always be declared as a “CL_MEM_READ_WRITE”, but once the image was passed to the kernel, it had to be either “__read_only” or “__write_only”.

input1 = clCreateImage(
oclobjects.context,
CL_MEM_READ_WRITE|CL_MEM_COPY_HOST_PTR,&format,&desc,&input_data1[0],&err );
SAMPLE_CHECK_ERRORS( err );

Code 1 Image buffer could be created with CL_MEM_READ_WRITE

__kernel void Alpha( __read_write image2d_t inputImage1,
__read_only image2d_t
inputImage2,
uint width,
uint height,
float alpha,
float beta,
int gamma )

Code 2 OpenCL 2.0 introduced the ability to read and write to images in Kernels

The addition, while intuitive, comes with a few caveats that are discussed in the next section.

The value of Read-Write Images

While Image convolution is not as effective with the new Read-Write images functionality, any image processing technique that needs be done in place may benefit from the Read-Write images. One example of a process that could be used effectively is image composition.

In OpenCL 1.2 and earlier, images were qualified with the “__read_only” and __write_only” qualifiers. In the OpenCL 2.0, images can be qualified with a “__read_write” qualifier, and copy the output to the input buffer. This reduces the number of resources that are needed.

Since OpenCL 1.2 images are either read_only or write_image. Performing an in-place modifications of an image requires treating the image as a buffer and operating on the buffer (see cl_khr_image2d_from_buffer: https://software.intel.com/en-us/articles/using-image2d-from-buffer-extension.

The current solution is to treat the images as buffers, and manipulate the buffers. Treating 2d images as buffers many not be a free operation and prevents clamping and filtering abilities available in read_images from being used. As a result, it may be more desirable to use read_write qualified images.

Overview of the Sample

The sample takes two windows bitmap images “input1.bmp” and “input2.bmp” and puts them into an image buffer. These images are then composited based on the value of the alpha, a weight factor in the equation of the calculated pixel, which can be passed in as an option.

Figure 1 Using Alpha value 0.84089642

The images have to be either 24/32-bit images. The output is a 24-bit image. The images have to be of the same size. The images were also of the Format ARGB, so when loading that fact was taken into consideration.

Figure2. Using Alpha value of 0.32453

The ARGB is converted to RGBA. Changing the value of the beta value causes a significant change in the output.

Using the Sample SDK

The SDK demonstrates how to use image composition with Read write images. Use the following command-line options to control this sample:

The sample SDK has a number of default values that allow the application to be able to run without any user input. The user will be able to use their input .bmp files. The files have to be either 24/32 bmp files as well. The alpha value is used to determine how much prominence image one will have over image 2 as such:

calculatedPixel = ((currentPixelImage1 * alpha) + (currentPixeImage2 * beta) + gamma);

The beta value is determined by subtracting the value of the alpha from 1.

float beta = 1 – alpha;

These two values determine the weighted distribution of images 1 to image 2.

The gamma value can be used to brighten each of the pixels. The default value is 0. But user can brighten the overall composited image. 

Example Run of Program

Figure 3 Program running on OCL2.0 Device

Limitations of Read-Write Images

Barriers cannot be used with images that require synchronization across different workgroups. Image convolution requires synchronizing all threads. Convolution with respect to images usually involves a mathematical operation on two matrices that results in the creation of a third matrix. An example of an image convolution is using Gaussian blur. Other examples are image sharpening, edge detection, and embossing.

Let’s use Gaussian blur as an example. A Gaussian filter is a low pass filter that removes high frequency values. The implication of this is to reduce detail and eventually cause a blurring like effect. Applying a Gaussian blur is the same as convolving the image with a Gaussian function that is often called the mask. To effectively show the functionality of Read-Write images, a horizontal and vertical blurring had to be done.

In OpenCL 1.2, this would have to be done in two passes. One kernel would be exclusively used for the horizontal blur, and another does the vertical blur. The result of one of the blurs would be used as the input of the next one depending on which was done first.

__kernel void GaussianBlurHorizontalPass( __read_only image2d_t inputImage, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);
    float4 calculatedPixel = (float4)(0,0,0,0);
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, imageSampler, currentPosition + (int2)(maskIndex, 0));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

__kernel void GaussianBlurVerticalPass( __read_only image2d_t inputImage, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);
    float4 calculatedPixel = (float4)(0,0,0,0); 
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, imageSampler, currentPosition + (int2)(0, maskIndex));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

Code 3 Gaussian Blur OCL1.2 Kernel

The idea for the OpenCL 2.0 would be to combine these two kernels into one. Use a barrier to force the completion of each of the horizontal or vertical blurs before the next one begins.

__kernel void GaussianBlurDualPass( __read_only image2d_t inputImage, __read_write image2d_t tempRW, __write_only image2d_t outputImage, __constant float* mask, int maskSize)
{
    int2 currentPosition = (int2)(get_global_id(0), get_global_id(1));
    float4 currentPixel = (float4)(0,0,0,0);  
    float4 calculatedPixel = (float4)(0,0,0,0)
    currentPixel = read_imagef(inputImage, currentPosition);
    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(inputImage, currentPosition + (int2)(maskIndex, 0));     
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(tempRW, currentPosition, calculatedPixel);

    barrier(CLK_GLOBAL_MEM_FENCE);

    for(int maskIndex = -maskSize; maskIndex < maskSize+1; ++maskIndex)
    {
        currentPixel = read_imagef(tempRW, currentPosition + (int2)(0, maskIndex));
        calculatedPixel += currentPixel * mask[maskSize + maskIndex];
    }
    write_imagef(outputImage, currentPosition, calculatedPixel);
}

Code 4 Gaussian Blur 2.0 Kernel

Barriers were found to be ineffective. Using a barrier does not guarantee that the horizontal blur is completed before the vertical blur begins, assuming you did the horizontal blur first. The implication of this was an inconsistent result in multiple runs. Barriers can be used to synchronize threads within a group. The reason the problem occurs is that edge pixels are read from multiple workgroups, and there is no way to synchronize multiple workgroups. The initial assumption that we can implement a single Gaussian blur using read_write images proved incorrect because the inter-workgroup data dependency cannot be synchronized in OpenCL.

References

• OpenCL 2.0 Spec: https://www.khronos.org/registry/cl/specs/opencl-2.0.pdf
• OpenCL Programming Guide – A. Munshi et al (Pearson 2012)
• OpenCL Programming by Example – Banfer, Ravishekhar
• Shapiro, L. G. & Stockman, G. C: "Computer Vision", page 137, 150. Prentice Hall, 2001
• https://en.wikipedia.org/wiki/Alpha_compositing
• http://mathnathan.com/2010/07/5opencv/

Downloads