How your application accesses memory can dramatically impact performance. It is not enough to parallelize your application by adding threads and vectorization. Memory bandwidth is just as important but it is often not as well understood by software developers. Tools that help minimize memory latency and increase bandwidth can greatly assist developers with pin-pointing performance bottlenecks and diagnosing their causes.

Today’s modern processors have many different types of memory accesses. For example the latency of an L1 cache hit is vastly different from the latency of an access that misses all of your memory caches and needs to access DRAM. In addition there are also some additional complexities brought about by NUMA architectures.

Intel® VTune™ Amplifier XE is a performance profiler that now has the many features you can use to analyze memory accesses, these features are contained in the new “Memory Access” analysis type. Using this new analysis type you can:

1. Detect performance problems by memory hierarchy (e.g., L1-, L2-, LLC-, DRAM-bound)
2. Track memory objects and attribute the latency these objects cause to their appropriate code and data structures. 
3. Analyze Bandwidth-limited accesses (including DRAM and Intel® QuickPath Interconnect [Intel® QPI] bandwidth) and quickly see graphs and histograms of your DRAM and QPI that show you bandwidth over the timeline of your program.
4. Identify NUMA related issues contributing to performance problems

This article will present an overview of the new “Memory Access” feature and will also show several tough memory problems that demonstrate how this feature can be used to greatly increase an applications performance.

Overview

To access VTune Amplifier’s memory access feature, click on the new “Memory Access” analysis type and click start.

View Bandwidth Utilization

You can also see how effective your DRAM and QPI bandwidth is being utilized (Figure 13). You need to be concerned about high bandwidth utilization. To help fix this you can find the places in your code contributing to bandwidth. (Figure 14)

Figure 13. Bandwidth histogram

View memory objects inducing bandwidth

Identify the code source and memory objects that are inducing bandwidth.  Grouping by the Bandwidth Domain allows you to identify memory objects that are contributing most to your memory bandwidth (Figure 14). You can see the sections of code that have more DRAM issues, QPI issues, etc.

Figure 14. Memory bandwidth

Graph Memory Bandwidth over the lifetime of your application

Your memory bandwidth will generally vary as your program runs. By viewing the bandwidth in a graph that shows your Read/Write Bandwidth in GB/Sec you can see where in your application spikes in memory usage and target the section of your application where the extra memory usage occurs. You can then filter by selecting the area in the timeline where the spike was occurring and see only the code that was active during that time.

Figure 15. Memory usage

The ability to track down the code sections in your application that are inducing memory bandwidth is a powerful feature. Average Latency is critical when tuning for Memory Accesses. Viewing Bandwidth in the timeline graph is a simple way to characterize your memory usage as your application runs. In the latest version of VTune Amplifier the bandwidth graph is relative to the maximum possible that your platform is capable of achieving so you can clearly see how much performance you are leaving on the table.

Memory problems solved using Intel VTune Amplifier XE

Tough Problem #1 - False Sharing

First some quick definitions, if more than one thread accesses the same piece of memory than they are said to “share” the memory. Because of the way that modern computers are organized, this sharing can cause all sorts of performance penalties. These performance penalties are necessary because all of the different threads/cores need to agree what is stored at a memory address and synchronizing all of the various caches due to this contention.

False sharing is when two different threads access a piece of memory that is located on the same cache line, they don’t actually share the same piece of memory but because the memory references are located close together they just happen to be stored together on same cache line. When multiple threads have false sharing they have the same type performance penalties that threads that are actually sharing the same piece of memory but they are taking the performance hit that is completely unnecessary. 

For this case we’ll study the linear_regression application from the phoenix suite (http://csl.stanford.edu/~christos/sw/phoenix).

Step #1 – Run memory access analysis to uncover potential memory issues

Run Memory Access analysis with the following options enabled:  memory objects analysis, and set object size threshold to 1, to capture all memory allocations.

The Summary view shows some key metrics:

For our first run the “Elapsed time” is 50 seconds. We can also see that the application is “Memory Bound” and that more than 42% of CPU resources are wasted waiting for memory operations to complete. Note that the “Memory Bound” metric is colored pink, this indicates that a potential performance issue needs to be addressed.

Step #2 – Investigate the memory issue identified

Switch to the Bottom-up tab to see more details:

We see that almost all of our time is spent in single function linear_regression_pthread, we can also see that this function is L1 and DRAM bound.

Expand the grid row for the linear_regression_pthread function to see what memory objects it accessed and sort by Loads:

We see that the hottest object (‘stddefines.h:52 (512B)’) is quite small, only 512 bytes, it should fit fully into the L1 cache but the “Average Latency” metric shows a latency of 44 cycles. This far exceed the normal L1 access latency of 4 cycles, this often this means we have some contention issues that could be either true or false sharing. By examining the allocation stack for the ‘stddefines.h:52 (512B)’ object we can see source location where the object was allocated. We can see that each thread is independently accessing it’s element in the array so it does look like false sharing!

Step #3 – Modify the code to remove the false sharing

False sharing can typically be easily avoided be adding padding so that threads always access different cache lines.

Step #4 – Rerun memory access analysis

Here is the new result:

The new Elapsed Time is now 12 seconds, we improved the application’s performance by approximately 4 times just by making a one line code change that padded a structure. The “Memory Bound” metric is also much lower and the “L1 Bound” issue has been resolved.

Tough Problem #2 – NUMA issues

In a processor that supports Non-Uniform Memory Access (NUMA), it is not enough to know that you missed a cache on the CPU where you are running. In NUMA architectures you could also be referencing the cache and DRAM on another CPU. The latencies for this type of access are an order of magnitude greater than the local case. You need the ability to identify and optimize these remote memory accesses.

For this case we’ll study a simple triad application parallelized using OpenMP* and running a dual-socket Haswell-based Xeon. 

Here is the code:

First we initialize the arrays and then call the triad function that uses a “omp parallel for”.

Step #1 – Run memory access analysis

Run the Memory Access analysis on this application. The expectation is for it to be DRAM bandwidth bound , it should utilize the system bandwidth up to the maximum.

In the summary section there are some very useful metrics. We can see the elapsed time is 12.449 seconds. The “Memory Bound” metric is high and highlighted as we expected. What is puzzling is the “Bandwidth Utilization” Histogram shows only a medium DRAM bandwidth utilization level, around 50 – 60 GB/s, this will need to be investigated.

Some of other useful metrics are:

• Average Latency – The average number of cycles our memory accesses are taking. Note: a L1 memory access can usually be done in 4 cycle buta remote DRAM access can take~300 cycles.
• KNL Bandwidth Estimate – This is an estimate of the expected per core bandwidth if run on Intel’s new of Intel Xeon Phi platform (code named Knights Landing) . This is a very useful for users who will be moving to KNL and would like to know if the memory access portion of their code is ready!

Step #1 – Investigate Bandwidth Utilization

Switch to Bottom-up tab to see more details:

From the timeline graph we see that DRAM bandwidth is utilized on only one of the sockets, package_1. In addition we see high QPI (intra-socket) traffic, up to 30 GB/s. This is one of the typical issues on NUMA machines where memory is allocated on one node and the work is split between multiple nodes, this forces some of them to have to load the data remotely over QPI links, this is much slower than accessing local memory.

Step #3 – Modify the code to avoid remote memory access

If we change the code to make both sockets access only local memory, thus avoiding remote node accesses, it should let us run faster. On Linux memory pages are allocated on first access so the solution for our case is simple, we should initialize the memory on the same nodes where we’ll be working with them. We can accomplish by adding a “omp parallel for” pragma to our initialization loop.

Step #4 – Re-run Memory Analysis with KMP_AFFINITY variable

Our Elapsed Time has decreased from 12.449 to 6.69 seconds, this is almost a 2x speed-up. Also, our “DRAM bandwidth” utilization moved to high levels, aligned with expectations.

Bandwidth is now equally split between the sockets and QPI traffic is 3x lower.

The complexities of NUMA architectures necessitate greater attention to the details of your memory accesses. By optimizing the memory accesses in your application that have the greatest latencies you can get the biggest potential performance gains.

Conclusion

It is critical to optimize the memory accesses of your program. Understanding how your program is accessing by using a tool such as Intel® VTune Amplifier XE can greatly assist you in getting the most out of your hardware.

We showed an overview of the new Intel VTune Amplifier XE Memory Access analysis feature. We also showed some tough memory problems could be resolved by using this feature.

We showed how users could detect false sharing problems by seeing high Average Latency values for relatively small memory objects. We improved application performance by 4x with a trivial 1-line code change by just padding a structure

We also showed how users could help detect NUMA issues with significant amount of remote memory accesses. We improved application performance by 2x after removing the remote access.

Intel® Advisor 2017 Beta Update 1 - What’s new

We’re pleased to announce new version of the Vectorization Assistant tool - Intel® Advisor 2017 Beta Update 1.

Below are highlights of the new functionality in Intel Advisor 2017 Update 1.

Full support for all analysis types on the second generation Intel® Xeon™ Phi processor (code named Knights Landing)

FLOPS and mask utilization

Tech Preview feature! Accurate hardware independent FLOPS measurement tool. (AVX512 only) Mask aware . Unique capability to correlate FLOPS with performance data.

Improved MPI workflow allows you to create snapshots for MPI results, so you can collect data in CLI and transfer self-contained packed result to a workstation with GUI for analysis. We also fixed some GUI and CLI interoperability issues.

Project properties dialog was extended with command line configuration for MPI launcher.

Project properties dialog also extended to allow setting FLOPS analysis.

Memory Access Patterns

MAP analysis now detects Gather instruction usage, unveiling more complex access patterns. A SIMD loop with Gather instructions will work faster than scalar one, but slower, than SIMD loop without Gather operations.  If a loop has “Gather stride” category, check new “Details” tab in Refinement report for information about strides and mask shape for the gather operation. One of possible solutions is to inform compiler about your data access patterns via OpenMP 4.x options – for cases, when gather instructions are not necessary actually.

In addition to Gather profiling, for AVX512 MAP analysis also detects Gather/scatter instruction usage, these instructions allow more code to vectorize but you can obtain greater performance by avoiding these types of instructions.

SMART MODE

New “Smart mode” for Survey results, which is an effective way to simplify data representation and to automatically select the loops that can be most impactful and/or suitable from a SIMD vector performance perspective.

NEW RECOMMENDATIONS

1. Consider outer loop vectorization in appropriate cases 
2. Consider refactoring the code to avoid using single Gather or Scatter instructions if the pattern is regular

Get Intel Advisor and more information

Visit the product site, where you can find videos and tutorials. .

There are a lot of different ways to think about making money from your app, and a lot of articles you can read about it. (Including our own recent article on monetization strategies. It’s a rich subject, and a really important one for anyone who’s thinking about making a game, app or piece of software. Because there are so many terms used to describe the different models, we wanted to provide a brief rundown on the various different models.

Here we go:

Retail Purchase— Physical purchase is made at a retail location. Customers pay for it once and can play it forever.

Paid Download— Paid download of complete game. Customers pay for it upon download, and enjoy the full gameplay experience forever (or, more accurately, for as long as the game is supported). One example of this is Lifeline—it costs $1.99 to download, but once you have it, everything is included, with no in-app purchases or in-app advertising. 

Free/Premium— Two versions of the game. One that’s free to play, and a premium version that's paid. The free version may have limited features or restricted gameplay. It should be valuable on its own—but should also try to convert users to the paid version. In Team Fortress 2, the premium version includes the ability to store more items in your backpack, access to rare and cosmetic items, and more powerful trading and crafting abilities—but anyone can download and play the free version.

Freemium— Very similar to the above, but instead of two versions of the game, there’s one version, which includes premium paid content. World of Warships is a PC game that uses this model, allowing users to purchase additional premium ships within the game.

“Paymium”— Paid download, with additional premium content or gameplay available for purchase. Marvel Pinball is a popular example—it’s $0.99 to download, with additional tables available as in-app purchases.

Free + In-App Purchases— Free to download and play, with extra content available for purchase in the app/program. Sometimes also called microtransactions, these could include anything from cosmetic upgrades or in-game currency to extra lives and otherwise unavailable gameplay. In Candy Crush, users can purchase things like extra lives, extra moves, color bombs, lollipop hammers and gold bars. For more about how to price your in-app purchases, see our article about pricing.

Free + In-App Advertising— The game is free to download and free to play, without any restricted content, but the user will see ads, either in-game, around the game canvas (for browser games), or even intermittently throughout the game (like television ads). This is a form of indirect monetization, meaning that the money doesn’t come directly from the consumer. Sometimes there’s an option to pay to remove ads. Angry Birds is always free to download, but players will see banner and video ads for Rovio products and other select partners. 

Subscription— Service or content that’s available by paid subscription. Usually paid monthly. The most famous example of this is World of Warcraft.

Server leasing— Virtual space in the game is sold. Much like in real life, players pay money to own real estate—but within the world of the game. In Second Life, users can purchase an apartment where their virtual friends can visit them, or a storefront where they can interact with customers.

Virtual currency— Also sometimes called “real cash economy games.” These games have an in-game currency that has a fixed rate of exchange with real-world currency. Players purchase in-game currency, and then cash out when they want to. An example of this is Entropia Universe, which has set records for the most expensive virtual world objects ever sold.

Offer walls — Instead of in-app purchases for cash, players are shown a "wall" of offers from partners which require some action or participation. For example, "Take this online survey to receive extra lives.”

Free flash games— Free flash games available on portal sites, driving traffic and interest to your game.

Which method do you prefer as a player? Which are you planning to implement in your game or app? Let us know in the comments!

• Which App Designer framework should I use? Which Intel XDK layout framework is best?
• What does the Google* Map widget’s "center type" attribute and its values "Auto calculate,""Address" and "Lat/Long" mean?
• How do I size UI elements in my project?
• How do I create lists, buttons and other UI elements with the Intel XDK?
• Why is the user interface for Chrome on Android* unresponsive?
• How do I work with more recent versions of App Framework* since the latest Intel XDK release?
• Is there a replacement to XPATH in App Framework* for selecting nodes from an XML document?
• Why does my App Framework* app that was previously working suddenly start having issues with Android* 4.4?
• How do I manually set a theme?
• How does page background color work in App Framework?
• What kind of templates can I use to create App Designer projects?
• My AJAX calls do not work on Android; I'm getting valid JSON data with an invalid return code.
• What do the data-uib and data-ver properties do in an App Designer project?

Which App Designer framework should I use? Which Intel XDK layout framework is best?

There is no "best" App Designer framework. Each framework has pros and cons. You should choose that framework which serves your application needs best. The list below provides a quick list of pros and cons for each of the frameworks that are available as part of App Designer.

• Twitter Bootstrap 3 -- PRO: a very clean UI framework that relies primarily on CSS with very little JavaScript trickery. Thriving third-party ecosystem with many plugins and add-ons, including themes. Probably the best place to start, especially for UI beginners. CON: some advanced mobile UI mechanisms (like swipe delete) are not part of this framework.

• App Framework 3 -- PRO: an optimized for mobile library that is very lean. App Framework includes the ability to automatically change the theme as a function of the target device. For example, on an Android device the styling of your UI looks like an Android app, on an iOS device the styling looks like an iOS app, etc. CON: not as widely known and supported as some other UI frameworks.

• Framework 7 -- PRO: provides pixel perfect layout with device-specific UI elements for Android and iOS platforms. CON: difficult to customize and modify; requires a strict adherence to the Framework 7 "rules of layout" for best results. You should have a good understanding of how Framework 7 works before using this framework to build your app!

• Ionic -- PRO: a very sophisticated mobile framework with many features. If you are familiar with and comfortable with Angular this framework may be a good choice for you. CON: tightly coupled with Angular, many features can only be accessed by writing JavaScript Angular directives. If you are not familiar or comfortable with Angular this is not a good choice!

• Topcoat -- This UI framework has been deprecated and will be retired from App Designer in a future release of the Intel XDK. You can always use this (or any mobile) framework with the Intel XDK, but you will have to do so manually, without the help of the Intel XDK App Designer UI layout tool. If you wish to continue using Topcoat please visit the Topcoat project page and the Topcoat GitHub repo for documentation.

• Ratchet -- This UI framework has been deprecated and will be retired from App Designer in a future release of the Intel XDK. You can always use this (or any mobile) framework with the Intel XDK, but you will have to do so manually, without the help of the Intel XDK App Designer UI layout tool. If you wish to continue using Ratchet please visit the Ratchet project page and the Ratchet GitHub repo for documentation.

• jQuery Mobile -- This UI framework has been deprecated and will be retired from App Designer in a future release of the Intel XDK. You can always use this (or any mobile) framework with the Intel XDK, but you will have to do so manually, without the help of the Intel XDK App Designer UI layout tool. If you wish to continue using jQuery Mobile please visit the jQuery Mobile API page and jQuery Mobile GitHub page for documentation.

What does the Google* Map widget’s "center type" attribute and its values "Auto calculate,""Address" and "Lat/Long" mean?

The "center type" parameter defines how the map view is centered in your div. It is used to initialize the map as follows:

• Lat/Long: center the map on a specific latitude and longitude (that you provide on the properties page)
• Address: center the map on a specific address (that you provide on the properties page)
• Auto Calculate: center the map on a collection of markers

This is just for initialization of the map widget. Beyond that you must use the standard Google maps APIs to move and/or modify the map. See the "google_maps.js" code for initialization of the widget and some calls to the Google maps APIs. There is also a pointer to the Google maps API at the beginning of the JS file.

To get the current position, you have to use the Geo API, and then push that into the Maps API to display it. The Google Maps API will not give you any device data, it will only display information for you. Please refer to the Intel XDK "Hello, Cordova" sample app for some help with the Geo API. There are a lot of useful comments and console.log messages.

How do I size UI elements in my project?

Trying to implement "pixel perfect" user interfaces with HTML5 apps is not recommended as there is a wide array of device resolutions and aspect ratios and it is impossible to insure you are sized properly for every device. Instead, you should use "responsive web design" techniques to build your UI so that it adapts to different sizes automatically. You can also use the CSS media query directive to build CSS rules that are specific to different screen dimensions.

Note:The viewport is sized in CSS pixels (aka virtual pixels or device independent pixels) and so the physical pixel dimensions are not what you will normally be designing for.

How do I create lists, buttons and other UI elements with the Intel XDK?

The Intel XDK provides you with a way to build HTML5 apps that are run in a webview on the target device. This is analogous to running in an embedded browser (refer to this blog for details). Thus, the programming techniques are the same as those you would use inside a browser, when writing a single-page client-side HTML5 app. You can use the Intel XDK App Designer tool to drag and drop UI elements.

Why is the user interface for Chrome on Android* unresponsive?

It could be that you are using an outdated version of the App Framework* files. You can find the recent versions here. You can safely replace any App Framework files that App Designer installed in your project with more recent copies as App Designer will not overwrite the new files.

How do I work with more recent versions of App Framework* since the latest Intel XDK release?

You can replace the App Framework* files that the Intel XDK automatically inserted with more recent versions that can be found here. App designer will not overwrite your replacement.

Is there a replacement to XPATH in App Framework* for selecting nodes from an XML document?

This FAQ applies only to App Framework 2. App Framework 3 no longer includes a replacement for the jQuery selector library, it expects that you are using standard jQuery.

App Framework is a UI library that implements a subset of the jQuery* selector library. If you wish to use jQuery for XPath manipulation, it is recommend that you use jQuery as your selector library and not App Framework. However, it is also possible to use jQuery with the UI components of App Framework. Please refer to this entry in the App Framework docs.

It would look similar to this:

<script src="lib/jq/jquery.js"></script><script src="lib/af/jq.appframework.js"></script><script src="lib/af/appframework.ui.js"></script>

Why does my App Framework* app that was previously working suddenly start having issues with Android* 4.4?

Ensure you have upgraded to the latest version of App Framework. If your app was built with the now retired Intel XDK "legacy" build system be sure to set the "Targeted Android Version" to 19 in the Android-Crosswalk build settings. The legacy build targeted Android 4.2.

How do I manually set a theme?

If you want to, for example, change the theme only on Android*, you can add the following lines of code:

1. $.ui.autoLaunch = false; //Stop the App Framework* auto launch right after you load App Framework*
2. Detect the underlying platform using either navigator.userAgent or intel.xdk.device.platform or window.device.platform. If the platform detected is Android*, set $.ui.useOSThemes=false todisable custom themes and set <div id=”afui” class=”android light”>
3. Otherwise, set $.ui.useOSThemes=true;
4. When device ready and document ready have been detected, add $.ui.launch();

How does page background color work in App Framework?

In App Framework the BODY is in the background and the page is in the foreground. If you set the background color on the body, you will see the page's background color. If you set the theme to default App Framework uses a native-like theme based on the device at runtime. Otherwise, it uses the App Framework Theme. This is normally done using the following:

<script>
$(document).ready(function(){ $.ui.useOSThemes = false; });</script>

Please see Customizing App Framework UI Skin for additional details.

What kind of templates can I use to create App Designer projects?

Currently, you can only create App Designer projects by selecting the blank 'HTML5+Cordova' template with app designer (select the app designer check box at the bottom of the template box) and the blank 'Standard HTML5' template with app designer. 

There were app designer versions of the layout and user interface templates that were removed in the Intel XDK 3088 version. 

My AJAX calls do not work on Android; I'm getting valid JSON data with an invalid return code.

The jQuery 1 library appears to be incompatible with the latest versions of the cordova-android framework. To fix this issue you can either upgrade your jQuery library to jQuery 2 or use a technique similar to that shown in the following test code fragment to check your AJAX return codes. See this forum thread for more details. 

The jQuery site only tests jQuery 2 against Cordova/PhoneGap apps (the Intel XDK builds Cordova apps). See the How to Use It section of this jQuery project blog > https://blog.jquery.com/2013/04/18/jquery-2-0-released/ for more information.

If you built your app using App Designer, it may still be using jQuery 1.x rather than jQuery 2.x, in which case you need to replace the version of jQuery in your project. Simply download and replace the existing copy of jQuery 1.x in your project with the equivalent copy of jQuery 2.x.

Note, in particular, the switch case that checks for zero and 200. This test fragment does not cover all possible AJAX return codes, but should help you if you wish to continue to use a jQuery 1 library as part of your Cordova application.

function jqueryAjaxTest() {

     /* button  #botRunAjax */
     $(document).on("click", "#botRunAjax", function (evt) {
         console.log("function started");
         var wpost = "e=132&c=abcdef&s=demoBASICA";
         $.ajax({
             type: "POST",
             crossDomain: true, //;paf; see http://stackoverflow.com/a/25109061/2914328
             url: "http://your.server.url/address",
             data: wpost,
             dataType: 'json',
             timeout: 10000
         })
         .always(function (retorno, textStatus, jqXHR) { //;paf; see http://stackoverflow.com/a/19498463/2914328
             console.log("jQuery version: " + $.fn.jquery) ;
             console.log("arg1:", retorno) ;
             console.log("arg2:", textStatus) ;
             console.log("arg3:", jqXHR) ;
             if( parseInt($.fn.jquery) === 1 ) {
                 switch (retorno.status) {
                    case 0:
                    case 200:
                        console.log("exit OK");
                        console.log(JSON.stringify(retorno.responseJSON));
                        break;
                    case 404:
                        console.log("exit by FAIL");
                        console.log(JSON.stringify(retorno.responseJSON));
                        break;
                    default:
                        console.log("default switch happened") ;
                        console.log(JSON.stringify(retorno.responseJSON));
                        break ;
                 }
             }
             if( (parseInt($.fn.jquery) === 2) && (textStatus === "success") ) {
                 switch (jqXHR.status) {
                    case 0:
                    case 200:
                        console.log("exit OK");
                        console.log(JSON.stringify(jqXHR.responseJSON));
                        break;
                    case 404:
                        console.log("exit by FAIL");
                        console.log(JSON.stringify(jqXHR.responseJSON));
                        break;
                    default:
                        console.log("default switch happened") ;
                        console.log(JSON.stringify(jqXHR.responseJSON));
                        break ;
                 }
             }
             else {
                console.log("unknown") ;
             }
         });
     });
 }

What do the data-uib and data-ver properties do in an App Designer project?

App Designer adds the data-uib and data-ver properties to many of the UI elements it creates. These property names only appear in the index.html file on various UI elements. There are other similar data properties, like data-sm, that only are required when you are using a service method.

The data-uib and data-ver properties are used only by App Designer. They are not needed by the UI frameworks supported by App Designer; they are used by App Designer to correctly display and apply widget properties when you are operating in the "design" view within App Designer. These properties are not critical to the functioning of your app; however, removing them will cause problems with the "design" view of App Designer.

The data-sm property is inserted by App Designer, and it may be used by data_support.js, along with other support libraries. The data-sm property is relevant to the proper functioning of your app.

Back to FAQs Main

Download [985 KB]

Now generally available, the Intel® NUC Kit NUC6i7KYK (code-named Skull Canyon) is a tiny, powerful PC that is great for gaming, living rooms, tradeshows, festivals, and anywhere where space is at a premium.

A new Mini PC has emerged as a compact gaming system, powered by Intel® Core™ processors and Iris™ Pro graphics. This form factor draws momentum from technology brands that are among the most popular on the planet. According to the April 2016 Steam Hardware & Software Survey, Intel® processors power about 77 percent of PCs, and Intel’s GPUs hold approximately 18 percent of their market segment share.

The most recent addition to Intel’s Mini PC lineup for gaming is the Intel® NUC Kit NUC6i7KYK (code-named Skull Canyon). A premium Next Unit of Computer (NUC) powered by an Intel® Core™ i7 processor and Iris Pro graphics, this worthy gaming system comes in a sleek, compact form factor (roughly 8.3 inches × 4.6 inches × 1.1 inches).

Intel® NUC Kit NUC6i7KYK (code-named Skull Canyon)

Under the hood, the NUC is powered by the 6th generation Intel® Core™ i7-6770HQ processor, with four cores running at 2.6 to 3.5 GHz (Turbo) and a 6 MB cache. Iris Pro graphics 580 support vivid 3D gameplay with 72 GPU execution units, in 1080p. It also supports 4K resolution on up to three monitors for those who needs premium screen real estate.

Thunderbolt™ 3 technology gives single-port connectivity to high-speed external storage, 4K displays, and high-end add-ons such as the Razer Core External Graphics Dock for discrete graphics cards and extra ports.

Graphics Techniques of Interest

Intel pushes the latest graphics APIs by providing support and extensions for advanced features in DirectX* 12 and Vulkan*. So, what will you do with that extra CPU and GPU headroom in a system with a 6th gen Intel® Core™ i7 processor and Iris Pro graphics? The potential can take you in lots of different directions, but here are a couple of interesting graphics techniques for game developers to consider.

Cloud Rendering with Pixel Shader Ordering

Employing natural-looking clouds by shading them realistically in real time is a prime example of how ambient effects can make game worlds more immersive. Puffy cumulus clouds are the most popular type for rendering in games, and as any impressionist painter could have told you, capturing the movement of light through them is the key to success. We demonstrate this approach using Pixel Shader Ordering, a DirectX extension supported on Iris Pro graphics and other Intel® HD Graphics technologies..

Screenshot generated by cloud rendering sample code.

The technique uses randomly rotated and scaled copies of a reference particle, with photon scattering based on pre-computed values that are accessed from a lookup table at runtime. Elements such as a highly efficient particle algorithm and outdoor lighting model allow your games to render high-quality, realistic clouds in real time. This is a particularly great addition to any game that includes flying or large swaths of open terrain.

Download the sample code and supporting documentation at https://software.intel.com/en-us/blogs/2014/08/31/cloud-rendering-sample-updated.

Software Occlusion Culling

Significant efficiency and performance advantage can be gained by optimizing the mechanisms that cull objects from the frame that don’t need to be rendered because they’re obscured by others. Offloading occlusion culling from the GPU to the CPU can help avoid GPU bottlenecks. It also avoids the cost of submitting occlusion queries to the GPU and transferring occluders between the GPU and CPU.

Intel offers sample code and accompanying documentation for a software occlusion algorithm that runs on the CPU. This algorithm efficiently categorizes screen objects as occluders or occludees based on a depth comparison and culls the latter set of objects from the rendering pipeline.

Screenshot generated by software occlusion culling sample code.

The code implementation of this algorithm is optimized for multi-threaded Intel Core processors using Intel® Advanced Vector Extensions 2.0 (Intel® AVX2.0). The present code outperforms an earlier version that was itself optimized using Intel® Streaming SIMD Extensions 4.1 (Intel® SSE4.1), reducing cull time by up to 1.32x. Ongoing refinements continue to drive up performance, reducing draw time per frame for game developers who take advantage of it.

Download the sample code and supporting documentation at https://software.intel.com/en-us/articles/software-occlusion-culling

Increased Graphics Settings

Beyond the addition of software features, the GPU and CPU performance headroom afforded by the Intel NUC Kit NUC6i7KYK allows for wholesale benefits in player experience by increasing engine-level graphics settings. For example, in the context of Unreal Engine* 4, the game Dreadnought*—a space-borne flight simulator developed by Yager Development and published by Grey Box with Six Foot—is an Unreal Engine 4 game that runs great on Iris Pro graphics.

Dreadnought*

Testing with Dreadnought on Iris Pro graphics shows that it is possible to increase the quality level from 720p low or medium settings to 1080p medium or high settings. To achieve this in Unreal Engine 4 , call SetFromSingleQualityLevel in the GameUserSettings class and set the value to 1 for medium and 2 for high.

Click here to learn more about setting quality settings in Unreal Engine 4.

In a typical game on the Unity* engine, such as Kerbal Space Program*, Iris Pro graphics supports quality settings of 4 or 5 at 1080p resolution. Graphics settings in the Unity engine are made by accessing the QualitySettings class and modifying SetQualityLevel.

Kerbal Space Program

Click here to learn more about setting quality settings in the Unity engine.  You can also use the code sample below in your game to create a script that sets your quality settings.

using UnityEngine;
using System.Collections;

public class SillyExample : MonoBehaviour {
       private int QualityValue;
       void QualityLevel(QualityValue) {
                QualitySettings.SetQualityLevel(QualityValue);
        }
}

Note that the appropriate setting in any engine for a specific circumstance will vary based on factors such as how many particle effects are in use, how many triangles are being rendered, and general scene complexity. To get the most out of your game, see how high you can set your graphics settings when you detect Intel® Iris™ Pro Graphics 580  in your game!

Conclusion

With the Intel NUC Kit NUC6i7KYK, high-end gaming is now supported on a Mini PC form factor—not as a compromise, but as a full-featured platform. 6th gen Intel Core processors and Iris Pro graphics support advanced techniques for graphics and 1080P gaming, and their tiny footprint make for a mean developer machine.

We look forward to hearing about your adventures with the new Intel NUC and the games you are able to create by taking advantage of 6th gen Intel Core processors and Iris Pro graphics.

Other Related References

https://software.intel.com/en-us/blogs/2016/03/25/introduction-to-games-engineering-at-intel
https://software.intel.com/en-us/gpa/faq
https://software.intel.com/en-us/articles/Unreal-Engine-4-with-x86-Support
https://software.intel.com/en-us/articles/unity
https://software.intel.com/en-us/articles/unity-software-performance-optimizations-for-games-best-practices

About the Author

Landyn Pethrus is an engineer at Intel, avid gamer, and hardware enthusiast. When he is not fountain sniping with the Ancient Apparition in Dota 2*, slaying bosses, or pursuing higher-level education, he can be found fishing on the rivers of Oregon.

Thank you for your interest in the 2016 Intel® Level Up Game Dev Contest. The contest closed on 5/24/2016 at 11:59:59 pm Pacific Time.

A floating license owner can share a floating serial number (SN) with other users from the same email domain. However, it cannot be a public domain such as Gmail, Yahoo, etc. By registering the SN each person will be added as a user of that license.

Existing User:

1. If you already have an IRC account, go to Intel Registration Center (IRC) and log in with your login id and password.
2. On the right-hand side enter the floating SN you received from the license owner.
   
   
3. Once you have registered the SN you will get a confirmation message followed by a confirmation email with the details of the account.

New User:

1. Go to Intel Registration Center (IRC).
2. Enter your email and the SN you received from the license owner.
   Be advised, you have to share the same private domain as the license owner.
   
   
3. You will be prompted to create an IRC account
4. Once your account is created you will get a confirmation message followed by a confirmation email with the details of the account.

A registered user will be able to download the product from IRC. A registered user will be eligible to Intel® Premier Support (IPS) only if the product has active support.

Note:
If you try to register a SN that belongs to a different domain you will get an error message.
Be advised, this procedure is for a Floating license only. Attempting to register an already registered named-user SN will transfer the license from one user to another.

Have Questions?

Check out the Licensing FAQ
Or ask* in our Intel® Software Development Products Download, Registration & Licensing forum

* If you have a question be sure to start a new forum thread.

• How can I get started with Intel XDK?
• Can I use an external editor for development in Intel® XDK?
• How do I get code refactoring capability in Brackets* (the Intel XDK code editor)?
• Why doesn’t my app show up in Google* play for tablets?
• What is the global-settings.xdk file and how do I locate it?
• When do I use the intelxdk.js, xhr.js and cordova.js libraries?
• How do I get my Android (and Crosswalk) keystore file?
• How do I rename my project that is a duplicate of an existing project?
• How do I recover when the Intel XDK hangs or won't start?
• Is Intel XDK an open source project? How can I contribute to the Intel XDK community?
• How do I configure Intel XDK to use 9 patch png for Android* apps splash screen?
• How do I stop AVG from popping up the "General Behavioral Detection" window when Intel XDK is launched?
• What do I specify for "App ID" in Intel XDK under Build Settings?
• Is it possible to modify the Android Manifest or iOS plist file with the Intel XDK?
• How can I share my Intel XDK app build?
• Why does my iOS build fail when I am able to test it successfully on a device and the emulator?
• How do I add multiple domains in Domain Access?
• How do I build more than one app using the same Apple developer account?
• How do I include search and spotlight icons as part of my app?
• Does Intel XDK support Modbus TCP communication?
• How do I sign an Android* app using an existing keystore?
• How do I build separately for different Android* versions?
• How do I display the 'Build App Now' button if my display language is not English?
• How do I update my Intel XDK version?
• How do I import my existing HTML5 app into the Intel XDK?
• I am unable to login to App Preview with my Intel XDK password.
• How do I completely uninstall the Intel XDK from my system?
• Is there a tool that can help me highlight syntax issues in Intel XDK?
• How do I delete built apps and test apps from the Intel XDK build servers?
• I need help with the App Security API plugin; where do I find it?
• When I install my app or use the Debug tab Avast antivirus flags a possible virus, why?
• How do I add a Brackets extension to the editor that is part of the Intel XDK?
• Why does my app or game require so many permissions on Android when built with the Intel XDK?
• How do I make a copy of an existing Intel XDK project?
• My project does not include a www folder. How do I fix it so it includes a www or source directory?
• Can I install more than one copy of the Intel XDK onto my development system?
• On Apple OS X* and Linux* systems, does the Intel XDK need the OpenSSL* library installed?
• I have a web application that I would like to distribute in app stores without major modifications. Is this possible using the Intel XDK?
• What is the best training approach to using the Intel XDK for a newbie?
• What is the best platform to start building an app with the Intel XDK? And what are the important differences between the Android, iOS and other mobile platforms?
• Is my password encrypted and why is it limited to fifteen characters?
• Why does the Intel XDK take a long time to start on Linux or Mac?
• How do I generate a P12 file on a Windows machine?
• How do I change the default dir for creating new projects in the Intel XDK?
• Where I can find recent and upcoming webinars list?
• How can I change the email address associated with my Intel XDK login?
• What network addresses must I enable in my firewall to insure the Intel XDK will work on my restricted network?
• I cannot create a login for the Intel XDK, how do I create a userid and password to use the Intel XDK?
• Installing the Intel XDK on Windows fails with a "Package signature verification failed." message.
• Troubles installing the Intel XDK on a Linux or Ubuntu system, which option should I choose?
• Inactive account/ login issue/ problem updating an APK in store, How do I request account transfer?
• Connection Problems? -- Intel XDK SSL certificates update
• How do I resolve build failure: "libpng error: Not a PNG file"?  
• Why do I get a "Parse Error" when I try to install my built APK on my Android device?
• My converted legacy keystore does not work. Google Play is rejecting my updated app.
• How can I have others beta test my app using Intel App Preview?
• I'm having trouble making Google Maps work with my Intel XDK app. What can I do?
• How do I fix "Cannot find the Intel XDK. Make sure your device and intel XDK are on the same wireless network." error messages?

How can I get started with Intel XDK?

There are plenty of videos and articles that you can go through here to get started. You could also start with some of our demo apps. It may also help to read Five Useful Tips on Getting Started Building Cordova Mobile Apps with the Intel XDK, which will help you understand some of the differences between developing for a traditional server-based environment and developing for the Intel XDK hybrid Cordova app environment.

Having prior understanding of how to program using HTML, CSS and JavaScript* is crucial to using the Intel XDK. The Intel XDK is primarily a tool for visualizing, debugging and building an app package for distribution.

You can do the following to access our demo apps:

• Select Project tab
• Select "Start a New Project"
• Select "Samples and Demos"
• Create a new project from a demo

If you have specific questions following that, please post it to our forums.

Can I use an external editor for development in Intel® XDK?

Yes, you can open your files and edit them in your favorite editor. However, note that you must use Brackets* to use the "Live Layout Editing" feature. Also, if you are using App Designer (the UI layout tool in Intel XDK) it will make many automatic changes to your index.html file, so it is best not to edit that file externally at the same time you have App Designer open.

Some popular editors among our users include:

• Sublime Text* (Refer to this article for information on the Intel XDK plugin for Sublime Text*)
• Notepad++* for a lighweight editor
• Jetbrains* editors (Webstorm*)
• Vim* the editor

How do I get code refactoring capability in Brackets* (the Intel XDK code editor)?

...to be written...

Why doesn’t my app show up in Google* play for tablets?

...to be written...

What is the global-settings.xdk file and how do I locate it?

global-settings.xdk contains information about all your projects in the Intel XDK, along with many of the settings related to panels under each tab (Emulate, Debug etc). For example, you can set the emulator to auto-refresh or no-auto-refresh. Modify this file at your own risk and always keep a backup of the original!

You can locate global-settings.xdk here:

• Mac OS X*
  ~/Library/Application Support/XDK/global-settings.xdk
• Microsoft Windows*
  %LocalAppData%\XDK
• Linux*
  ~/.config/XDK/global-settings.xdk

If you are having trouble locating this file, you can search for it on your system using something like the following:

• Windows:
  > cd /
> dir /s global-settings.xdk
• Mac and Linux:
  $ sudo find / -name global-settings.xdk

When do I use the intelxdk.js, xhr.js and cordova.js libraries?

The intelxdk.js and xhr.js libraries were only required for use with the Intel XDK legacy build tiles (which have been retired). The cordova.js library is needed for all Cordova builds. When building with the Cordova tiles, any references to intelxdk.js and xhr.js libraries in your index.html file are ignored.

How do I get my Android (and Crosswalk) keystore file?

New with release 3088 of the Intel XDK, you may now download your build certificates (aka keystore) using the new certificate manager that is built into the Intel XDK. Please read the initial paragraphs of Managing Certificates for your Intel XDK Account and the section titled "Convert a Legacy Android Certificate" in that document, for details regarding how to do this.

It may also help to review this short, quick overview video (there is no audio) that shows how you convert your existing "legacy" certificates to the "new" format that allows you to directly manage your certificates using the certificate management tool that is built into the Intel XDK. This conversion process is done only once.

If the above fails, please send an email to html5tools@intel.com requesting help. It is important that you send that email from the email address associated with your Intel XDK account.

How do I rename my project that is a duplicate of an existing project?

See this FAQ: How do I make a copy of an existing Intel XDK project?

How do I recover when the Intel XDK hangs or won't start?

• If you are running Intel XDK on Windows* it must be Windows* 7 or higher. It will not run reliably on earlier versions.

• Delete the "project-name.xdk" file from the project directory that Intel XDK is trying to open when it starts (it will try to open the project that was open during your last session), then try starting Intel XDK. You will have to "import" your project into Intel XDK again. Importing merely creates the "project-name.xdk" file in your project directory and adds that project to the "global-settings.xdk" file.

• Rename the project directory Intel XDK is trying to open when it starts. Create a new project based on one of the demo apps. Test Intel XDK using that demo app. If everything works, restart Intel XDK and try it again. If it still works, rename your problem project folder back to its original name and open Intel XDK again (it should now open the sample project you previously opened). You may have to re-select your problem project (Intel XDK should have forgotten that project during the previous session).

• Clear Intel XDK's program cache directories and files.
  
  On a Windows machine this can be done using the following on a standard command prompt (administrator is not required):
  
  > cd %AppData%\..\Local\XDK
> del *.* /s/q
  
  To locate the "XDK cache" directory on [OS X*] and [Linux*] systems, do the following:
  
  $ sudo find / -name global-settings.xdk
$ cd <dir found above>
$ sudo rm -rf *
  
  You might want to save a copy of the "global-settings.xdk" file before you delete that cache directory and copy it back before you restart Intel XDK. Doing so will save you the effort of rebuilding your list of projects. Please refer to this question for information on how to locate the global-settings.xdk file.

• If you save the "global-settings.xdk" file and restored it in the step above and you're still having hang troubles, try deleting the directories and files above, along with the "global-settings.xdk" file and try it again.

• Do not store your project directories on a network share (Intel XDK currently has issues with network shares that have not yet been resolved). This includes folders shared between a Virtual machine (VM) guest and its host machine (for example, if you are running Windows* in a VM running on a Mac* host). This network share issue is a known issue with a fix request in place.

• There have also been issues with running behind a corporate network proxy or firewall. To check them try running Intel XDK from your home network where, presumably, you have a simple NAT router and no proxy or firewall. If things work correctly there then your corporate firewall or proxy may be the source of the problem.

• Issues with Intel XDK account logins can also cause Intel XDK to hang. To confirm that your login is working correctly, go to the Intel XDK App Center and confirm that you can login with your Intel XDK account. While you are there you might also try deleting the offending project(s) from the App Center.

If you can reliably reproduce the problem, please send us a copy of the "xdk.log" file that is stored in the same directory as the "global-settings.xdk" file to html5tools@intel.com.

Is Intel XDK an open source project? How can I contribute to the Intel XDK community?

No, It is not an open source project. However, it utilizes many open source components that are then assembled into Intel XDK. While you cannot contribute directly to the Intel XDK integration effort, you can contribute to the many open source components that make up Intel XDK.

The following open source components are the major elements that are being used by Intel XDK:

• Node-Webkit
• Chromium
• Ripple* emulator
• Brackets* editor
• Weinre* remote debugger
• Crosswalk*
• Cordova*
• App Framework*

How do I configure Intel XDK to use 9 patch png for Android* apps splash screen?

Intel XDK does support the use of 9 patch png for Android* apps splash screen. You can read up more at https://software.intel.com/en-us/xdk/articles/android-splash-screens-using-nine-patch-png on how to create a 9 patch png image and link to an Intel XDK sample using 9 patch png images.

How do I stop AVG from popping up the "General Behavioral Detection" window when Intel XDK is launched?

You can try adding nw.exe as the app that needs an exception in AVG.

What do I specify for "App ID" in Intel XDK under Build Settings?

Your app ID uniquely identifies your app. For example, it can be used to identify your app within Apple’s application services allowing you to use things like in-app purchasing and push notifications.

Here are some useful articles on how to create an App ID:

• iOS* App
• Android* App
• Windows* Phone 8 App

Is it possible to modify the Android Manifest or iOS plist file with the Intel XDK?

You cannot modify the AndroidManifest.xml file directly with our build system, as it only exists in the cloud. However, you may do so by creating a dummy plugin that only contains a plugin.xml file containing directives that can be used to add lines to the AndroidManifest.xml file during the build process. In essence, you add lines to the AndroidManifest.xml file via a local plugin.xml file. Here is an example of a plugin that does just that:

<?xml version="1.0" encoding="UTF-8"?><plugin xmlns="http://apache.org/cordova/ns/plugins/1.0" id="my-custom-intents-plugin" version="1.0.0"><name>My Custom Intents Plugin</name><description>Add Intents to the AndroidManifest.xml</description><license>MIT</license><engines><engine name="cordova" version=">=3.0.0" /></engines><!-- android --><platform name="android"><config-file target="AndroidManifest.xml" parent="/manifest/application"><activity android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale" android:label="@string/app_name" android:launchMode="singleTop" android:name="testa" android:theme="@android:style/Theme.Black.NoTitleBar"><intent-filter><action android:name="android.intent.action.SEND" /><category android:name="android.intent.category.DEFAULT" /><data android:mimeType="*/*" /></intent-filter></activity></config-file></platform></plugin>

You can inspect the AndroidManifest.xml created in an APK, using apktool with the following command line:

$ apktool d my-app.apk
$ cd my-app
$ more AndroidManifest.xml

This technique exploits the config-file element that is described in the Cordova Plugin Specification docs and can also be used to add lines to iOS plist files. See the Cordova plugin documentation link for additional details.

Here is an example of such a plugin for modifying the iOS plist file, specifically for adding a BIS key to the plist file:

<?xml version="1.0" encoding="UTF-8"?><plugin
    xmlns="http://apache.org/cordova/ns/plugins/1.0"
    id="my-custom-bis-plugin"
    version="0.0.2"><name>My Custom BIS Plugin</name><description>Add BIS info to iOS plist file.</description><license>BSD-3</license><preference name="BIS_KEY" /><engines><engine name="cordova" version=">=3.0.0" /></engines><!-- ios --><platform name="ios"><config-file target="*-Info.plist" parent="CFBundleURLTypes"><array><dict><key>ITSAppUsesNonExemptEncryption</key><true/><key>ITSEncryptionExportComplianceCode</key><string>$BIS_KEY</string></dict></array></config-file></platform></plugin>

How can I share my Intel XDK app build?

You can send a link to your project via an email invite from your project settings page. However, a login to your account is required to access the file behind the link. Alternatively, you can download the build from the build page, onto your workstation, and push that built image to some location from which you can send a link to that image.

Why does my iOS build fail when I am able to test it successfully on a device and the emulator?

Common reasons include:

• Your App ID specified in the project settings do not match the one you specified in Apple's developer portal.
• The provisioning profile does not match the cert you uploaded. Double check with Apple's developer site that you are using the correct and current distribution cert and that the provisioning profile is still active. Download the provisioning profile again and add it to your project to confirm.
• In Project Build Settings, your App Name is invalid. It should be modified to include only alpha, space and numbers.

How do I add multiple domains in Domain Access?

Here is the primary doc source for that feature.

If you need to insert multiple domain references, then you will need to add the extra references in the intelxdk.config.additions.xml file. This StackOverflow entry provides a basic idea and you can see the intelxdk.config.*.xml files that are automatically generated with each build for the <access origin="xxx" /> line that is generated based on what you provide in the "Domain Access" field of the "Build Settings" panel on the Project Tab.

How do I build more than one app using the same Apple developer account?

On Apple developer, create a distribution certificate using the "iOS* Certificate Signing Request" key downloaded from Intel XDK Build tab only for the first app. For subsequent apps, reuse the same certificate and import this certificate into the Build tab like you usually would.

How do I include search and spotlight icons as part of my app?

Please refer to this article in the Intel XDK documentation. Create anintelxdk.config.additions.xml file in your top level directory (same location as the otherintelxdk.*.config.xml files) and add the following lines for supporting icons in Settings and other areas in iOS*.

<!-- Spotlight Icon --><icon platform="ios" src="res/ios/icon-40.png" width="40" height="40" /><icon platform="ios" src="res/ios/icon-40@2x.png" width="80" height="80" /><icon platform="ios" src="res/ios/icon-40@3x.png" width="120" height="120" /><!-- iPhone Spotlight and Settings Icon --><icon platform="ios" src="res/ios/icon-small.png" width="29" height="29" /><icon platform="ios" src="res/ios/icon-small@2x.png" width="58" height="58" /><icon platform="ios" src="res/ios/icon-small@3x.png" width="87" height="87" /><!-- iPad Spotlight and Settings Icon --><icon platform="ios" src="res/ios/icon-50.png" width="50" height="50" /><icon platform="ios" src="res/ios/icon-50@2x.png" width="100" height="100" />

For more information related to these configurations, visit http://cordova.apache.org/docs/en/3.5.0/config_ref_images.md.html#Icons%20and%20Splash%20Screens.

For accurate information related to iOS icon sizes, visit https://developer.apple.com/library/ios/documentation/UserExperience/Conceptual/MobileHIG/IconMatrix.html

NOTE: The iPhone 6 icons will only be available if iOS* 7 or 8 is the target.

Cordova iOS* 8 support JIRA tracker: https://issues.apache.org/jira/browse/CB-7043

Does Intel XDK support Modbus TCP communication?

No, since Modbus is a specialized protocol, you need to write either some JavaScript* or native code (in the form of a plugin) to handle the Modbus transactions and protocol.

How do I sign an Android* app using an existing keystore?

New with release 3088 of the Intel XDK, you may now import your existing keystore into Intel XDK using the new certificate manager that is built into the Intel XDK. Please read the initial paragraphs of Managing Certificates for your Intel XDK Account and the section titled "Import an Android Certificate Keystore" in that document, for details regarding how to do this.

If the above fails, please send an email to html5tools@intel.com requesting help. It is important that you send that email from the email address associated with your Intel XDK account.

How do I build separately for different Android* versions?

Under the Projects Panel, you can select the Target Android* version under the Build Settings collapsible panel. You can change this value and build your application multiple times to create numerous versions of your application that are targeted for multiple versions of Android*.

How do I display the 'Build App Now' button if my display language is not English?

If your display language is not English and the 'Build App Now' button is proving to be troublesome, you may change your display language to English which can be downloaded by a Windows* update. Once you have installed the English language, proceed to Control Panel > Clock, Language and Region > Region and Language > Change Display Language.

How do I update my Intel XDK version?

When an Intel XDK update is available, an Update Version dialog box lets you download the update. After the download completes, a similar dialog lets you install it. If you did not download or install an update when prompted (or on older versions), click the package icon next to the orange (?) icon in the upper-right to download or install the update. The installation removes the previous Intel XDK version.

How do I import my existing HTML5 app into the Intel XDK?

If your project contains an Intel XDK project file (<project-name>.xdk) you should use the "Open an Intel XDK Project" option located at the bottom of the Projects List on the Projects tab (lower left of the screen, round green "eject" icon, on the Projects tab). This would be the case if you copied an existing Intel XDK project from another system or used a tool that exported a complete Intel XDK project.

If your project does not contain an Intel XDK project file (<project-name>.xdk) you must "import" your code into a new Intel XDK project. To import your project, use the "Start a New Project" option located at the bottom of the Projects List on the Projects tab (lower left of the screen, round blue "plus" icon, on theProjects tab). This will open the "Samples, Demos and Templates" page, which includes an option to "Import Your HTML5 Code Base." Point to the root directory of your project. The Intel XDK will attempt to locate a file named index.html in your project and will set the "Source Directory" on the Projects tab to point to the directory that contains this file.

If your imported project did not contain an index.html file, your project may be unstable. In that case, it is best to delete the imported project from the Intel XDK Projects tab ("x" icon in the upper right corner of the screen), rename your "root" or "main" html file to index.html and import the project again. Several components in the Intel XDK depend on this assumption that the main HTML file in your project is named index.hmtl. See Introducing Intel® XDK Development Tools for more details.

It is highly recommended that your "source directory" be located as a sub-directory inside your "project directory." This insures that non-source files are not included as part of your build package when building your application. If the "source directory" and "project directory" are the same it results in longer upload times to the build server and unnecessarily large application executable files returned by the build system. See the following images for the recommended project file layout.

I am unable to login to App Preview with my Intel XDK password.

On some devices you may have trouble entering your Intel XDK login password directly on the device in the App Preview login screen. In particular, sometimes you may have trouble with the first one or two letters getting lost when entering your password.

Try the following if you are having such difficulties:

• Reset your password, using the Intel XDK, to something short and simple.

• Confirm that this new short and simple password works with the XDK (logout and login to the Intel XDK).

• Confirm that this new password works with the Intel Developer Zone login.

• Make sure you have the most recent version of Intel App Preview installed on your devices. Go to the store on each device to confirm you have the most recent copy of App Preview installed.

• Try logging into Intel App Preview on each device with this short and simple password. Check the "show password" box so you can see your password as you type it.

If the above works, it confirms that you can log into your Intel XDK account from App Preview (because App Preview and the Intel XDK go to the same place to authenticate your login). When the above works, you can go back to the Intel XDK and reset your password to something else, if you do not like the short and simple password you used for the test.

How do I completely uninstall the Intel XDK from my system?

Take the following steps to completely uninstall the XDK from your Windows system:

• From the Windows Control Panel, remove the Intel XDK, using the Windows uninstall tool.

• Then:
  > cd %LocalAppData%\Intel\XDK
> del *.* /s/q

• Then:
  > cd %LocalAppData%\XDK
> copy global-settings.xdk %UserProfile%
> del *.* /s/q
> copy %UserProfile%\global-settings.xdk .

• Then:
  -- Goto xdk.intel.com and select the download link.
  -- Download and install the new XDK.

To do the same on a Linux or Mac system:

• On a Linux machine, run the uninstall script, typically /opt/intel/XDK/uninstall.sh.
   
• Remove the directory into which the Intel XDK was installed.
  -- Typically /opt/intel or your home (~) directory on a Linux machine.
  -- Typically in the /Applications/Intel XDK.app directory on a Mac.
   
• Then:
  $ find ~ -name global-settings.xdk
$ cd <result-from-above> (for example ~/Library/Application Support/XDK/ on a Mac)
$ cp global-settings.xdk ~
$ rm -Rf *
$ mv ~/global-settings.xdk .
   
• Then:
  -- Goto xdk.intel.com and select the download link.
  -- Download and install the new XDK.

Is there a tool that can help me highlight syntax issues in Intel XDK?

Yes, you can use the various linting tools that can be added to the Brackets editor to review any syntax issues in your HTML, CSS and JS files. Go to the "File > Extension Manager..." menu item and add the following extensions: JSHint, CSSLint, HTMLHint, XLint for Intel XDK. Then, review your source files by monitoring the small yellow triangle at the bottom of the edit window (a green check mark indicates no issues).

How do I delete built apps and test apps from the Intel XDK build servers?

You can manage them by logging into: https://appcenter.html5tools-software.intel.com/csd/controlpanel.aspx. This functionality will eventually be available within Intel XDK after which access to app center will be removed.

I need help with the App Security API plugin; where do I find it?

Visit the primary documentation book for the App Security API and see this forum post for some additional details.

When I install my app or use the Debug tab Avast antivirus flags a possible virus, why?

If you are receiving a "Suspicious file detected - APK:CloudRep [Susp]" message from Avast anti-virus installed on your Android device it is due to the fact that you are side-loading the app (or the Intel XDK Debug modules) onto your device (using a download link after building or by using the Debug tab to debug your app), or your app has been installed from an "untrusted" Android store. See the following official explanation from Avast:

Your application was flagged by our cloud reputation system. "Cloud rep" is a new feature of Avast Mobile Security, which flags apks when the following conditions are met:

1. The file is not prevalent enough; meaning not enough users of Avast Mobile Security have installed your APK.
2. The source is not an established market (Google Play is an example of an established market).

If you distribute your app using Google Play (or any other trusted market) your users should not see any warning from Avast.

Following are some of the Avast anti-virus notification screens you might see on your device. All of these are perfectly normal, they are due to the fact that you must enable the installation of "non-market" apps in order to use your device for debug and the App IDs associated with your never published app or the custom debug modules that the Debug tab in the Intel XDK builds and installs on your device will not be found in a "established" (aka "trusted") market, such as Google Play.

If you choose to ignore the "Suspicious app activity!" threat you will not receive a threat for that debug module any longer. It will show up in the Avast 'ignored issues' list. Updates to an existing, ignored, custom debug module should continue to be ignored by Avast. However, new custom debug modules (due to a new project App ID or a new version of Crosswalk selected in your project's Build Settings) will result in a new warning from the Avast anti-virus tool.

How do I add a Brackets extension to the editor that is part of the Intel XDK?

The number of Brackets extensions that are provided in the built-in edition of the Brackets editor are limited to insure stability of the Intel XDK product. Not all extensions are compatible with the edition of Brackets that is embedded within the Intel XDK. Adding incompatible extensions can cause the Intel XDK to quit working.

Despite this warning, there are useful extensions that have not been included in the editor and which can be added to the Intel XDK. Adding them is temporary, each time you update the Intel XDK (or if you reinstall the Intel XDK) you will have to "re-add" your Brackets extension. To add a Brackets extension, use the following procedure:

• exit the Intel XDK
• download a ZIP file of the extension you wish to add
• on Windows, unzip the extension here:
  %LocalAppData%\Intel\XDK\xdk\brackets\b\extensions\dev
• on Mac OS X, unzip the extension here:
  /Applications/Intel\ XDK.app/Contents/Resources/app.nw/brackets/b/extensions/dev
• start the Intel XDK

Note that the locations given above are subject to change with new releases of the Intel XDK.

Why does my app or game require so many permissions on Android when built with the Intel XDK?

When you build your HTML5 app using the Intel XDK for Android or Android-Crosswalk you are creating a Cordova app. It may seem like you're not building a Cordova app, but you are. In order to package your app so it can be distributed via an Android store and installed on an Android device, it needs to be built as a hybrid app. The Intel XDK uses Cordova to create that hybrid app.

A pure Cordova app requires the NETWORK permission, it's needed to "jump" between your HTML5 environment and the native Android environment. Additional permissions will be added by any Cordova plugins you include with your application; which permissions are includes are a function of what that plugin does and requires.

Crosswalk for Android builds also require the NETWORK permission, because the Crosswalk image built by the Intel XDK includes support for Cordova. In addition, current versions of Crosswalk (12 and 14 at the time this FAQ was written)also require NETWORK STATE and WIFI STATE. There is an extra permission in some versions of Crosswalk (WRITE EXTERNAL STORAGE) that is only needed by the shared model library of Crosswalk, we have asked the Crosswalk project to remove this permission in a future Crosswalk version.

If you are seeing more than the following five permissions in your XDK-built Crosswalk app:

• android.permission.INTERNET
• android.permission.ACCESS_NETWORK_STATE
• android.permission.ACCESS_WIFI_STATE
• android.permission.INTERNET
• android.permission.WRITE_EXTERNAL_STORAGE

then you are seeing permissions that have been added by some plugins. Each plugin is different, so there is no hard rule of thumb. The two "default" core Cordova plugins that are added by the Intel XDK blank templates (device and splash screen) do not require any Android permissions.

BTW: the permission list above comes from a Crosswalk 14 build. Crosswalk 12 builds do not included the last permission; it was added when the Crosswalk project introduced the shared model library option, which started with Crosswalk 13 (the Intel XDK does not support 13 builds).

How do I make a copy of an existing Intel XDK project?

If you just need to make a backup copy of an existing project, and do not plan to open that backup copy as a project in the Intel XDK, do the following:

• Exit the Intel XDK.
• Copy the entire project directory:
  • on Windows, use File Explorer to "right-click" and "copy" your project directory, then "right-click" and "paste"
  • on Mac use Finder to "right-click" and then "duplicate" your project directory
  • on Linux, open a terminal window, "cd" to the folder that contains your project, and type "cp -a old-project/ new-project/" at the terminal prompt (where "old-project/" is the folder name of your existing project that you want to copy and "new-project/" is the name of the new folder that will contain a copy of your existing project)

If you want to use an existing project as the starting point of a new project in the Intel XDK. The process described below will insure that the build system does not confuse the ID in your old project with that stored in your new project. If you do not follow the procedure below you will have multiple projects using the same project ID (a special GUID that is stored inside the Intel XDK <project-name>.xdk file in the root directory of your project). Each project in your account must have a unique project ID.

• Exit the Intel XDK.
• Make a copy of your existing project using the process described above.
• Inside the new project that you made (that is, your new copy of your old project), make copies of the <project-name>.xdk file and <project-name>.xdke files and rename those copies to something like project-new.xdk and project-new.xdke (anything you like, just something different than the original project name, preferably the same name as the new project folder in which you are making this new project).
• Using a TEXT EDITOR (only) (such as Notepad or Sublime or Brackets or some other TEXT editor), open your new "project-new.xdk" file (whatever you named it) and find the projectGuid line, it will look something like this:
  "projectGuid": "a863c382-ca05-4aa4-8601-375f9f209b67",
• Change the "GUID" to all zeroes, like this: "00000000-0000-0000-000000000000"
• Save the modified "project-new.xdk" file.
• Open the Intel XDK.
• Goto the Projects tab.
• Select "Open an Intel XDK Project" (the green button at the bottom left of the Projects tab).
• To open this new project, locate the new "project-new.xdk" file inside the new project folder you copied above.
• Don't forget to change the App ID in your new project. This is necessary to avoid conflicts with the project you copied from, in the store and when side-loading onto a device.

My project does not include a www folder. How do I fix it so it includes a www or source directory?

The Intel XDK HTML5 and Cordova project file structures are meant to mimic a standard Cordova project. In a Cordova (or PhoneGap) project there is a subdirectory (or folder) named www that contains all of the HTML5 source code and asset files that make up your application. For best results, it is advised that you follow this convention, of putting your source inside a "source directory" inside of your project folder.

This most commonly happens as the result of exporting a project from an external tool, such as Construct2, or as the result of importing an existing HTML5 web app that you are converting into a hybrid mobile application (eg., an Intel XDK Corodova app). If you would like to convert an existing Intel XDK project into this format, follow the steps below:

• Exit the Intel XDK.
• Copy the entire project directory:
  • on Windows, use File Explorer to "right-click" and "copy" your project directory, then "right-click" and "paste"
  • on Mac use Finder to "right-click" and then "duplicate" your project directory
  • on Linux, open a terminal window, "cd" to the folder that contains your project, and type "cp -a old-project/ new-project/" at the terminal prompt (where "old-project/" is the folder name of your existing project that you want to copy and "new-project/" is the name of the new folder that will contain a copy of your existing project)
• Create a "www" directory inside the new duplicate project you just created above.
• Move your index.html and other source and asset files to the "www" directory you just created -- this is now your "source" directory, located inside your "project" directory (do not move the <project-name>.xdk and xdke files and any intelxdk.config.*.xml files, those must stay in the root of the project directory)
• Inside the new project that you made above (by making a copy of the old project), rename the <project-name>.xdk file and <project-name>.xdke files to something like project-copy.xdk and project-copy.xdke (anything you like, just something different than the original project, preferably the same name as the new project folder in which you are making this new project).
• Using a TEXT EDITOR (only) (such as Notepad or Sublime or Brackets or some other TEXT editor), open the new "project-copy.xdk" file (whatever you named it) and find the line named projectGuid, it will look something like this:
  "projectGuid": "a863c382-ca05-4aa4-8601-375f9f209b67",
• Change the "GUID" to all zeroes, like this: "00000000-0000-0000-000000000000"
• A few lines down find: "sourceDirectory": "",
• Change it to this: "sourceDirectory": "www",
• Save the modified "project-copy.xdk" file.
• Open the Intel XDK.
• Goto the Projects tab.
• Select "Open an Intel XDK Project" (the green button at the bottom left of the Projects tab).
• To open this new project, locate the new "project-copy.xdk" file inside the new project folder you copied above.

Can I install more than one copy of the Intel XDK onto my development system?

Yes, you can install more than one version onto your development system. However, you cannot run multiple instances of the Intel XDK at the same time. Be aware that new releases sometimes change the project file format, so it is a good idea, in these cases, to make a copy of your project if you need to experiment with a different version of the Intel XDK. See the instructions in a FAQ entry above regarding how to make a copy of your Intel XDK project.

Follow the instructions in this forum post to install more than one copy of the Intel XDK onto your development system.

On Apple OS X* and Linux* systems, does the Intel XDK need the OpenSSL* library installed?

Yes. Several features of the Intel XDK require the OpenSSL library, which typically comes pre-installed on Linux and OS X systems. If the Intel XDK reports that it could not find libssl, go to https://www.openssl.org to download and install it.

I have a web application that I would like to distribute in app stores without major modifications. Is this possible using the Intel XDK?

Yes, if you have a true web app or “client app” that only uses HTML, CSS and JavaScript, it is usually not too difficult to convert it to a Cordova hybrid application (this is what the Intel XDK builds when you create an HTML5 app). If you rely heavily on PHP or other server scripting languages embedded in your pages you will have more work to do. Because your Cordova app is not associated with a server, you cannot rely on server-based programming techniques; instead, you must rewrite any such code to user RESTful APIs that your app interacts with using, for example, AJAX calls.

What is the best training approach to using the Intel XDK for a newbie?

First, become well-versed in the art of client web apps, apps that rely only on HTML, CSS and JavaScript and utilize RESTful APIs to talk to network services. With that you will have mastered 80% of the problem. After that, it is simply a matter of understanding how Cordova plugins are able to extend the JavaScript API for access to features of the platform. For HTML5 training there are many sites providing tutorials. It may also help to read Five Useful Tips on Getting Started Building Cordova Mobile Apps with the Intel XDK, which will help you understand some of the differences between developing for a traditional server-based environment and developing for the Intel XDK hybrid Cordova app environment.

What is the best platform to start building an app with the Intel XDK? And what are the important differences between the Android, iOS and other mobile platforms?

There is no one most important difference between the Android, iOS and other platforms. It is important to understand that the HTML5 runtime engine that executes your app on each platform will vary as a function of the platform. Just as there are differences between Chrome and Firefox and Safari and Internet Explorer, there are differences between iOS 9 and iOS 8 and Android 4 and Android 5, etc. Android has the most significant differences between vendors and versions of Android. This is one of the reasons the Intel XDK offers the Crosswalk for Android build option, to normalize and update the Android issues.

In general, if you can get your app working well on Android (or Crosswalk for Android) first you will generally have fewer issues to deal with when you start to work on the iOS and Windows platforms. In addition, the Android platform has the most flexible and useful debug options available, so it is the easiest platform to use for debugging and testing your app.

Is my password encrypted and why is it limited to fifteen characters?

Yes, your password is stored encrypted and is managed by https://signin.intel.com. Your Intel XDK userid and password can also be used to log into the Intel XDK forum as well as the Intel Developer Zone. the Intel XDK does not store nor does it manage your userid and password.

The rules regarding allowed userids and passwords are answered on this Sign In FAQ page, where you can also find help on recovering and changing your password.

Why does the Intel XDK take a long time to start on Linux or Mac?

...and why am I getting this error message? "Attempt to contact authentication server is taking a long time. You can wait, or check your network connection and try again."

At startup, the Intel XDK attempts to automatically determine the proxy settings for your machine. Unfortunately, on some system configurations it is unable to reliably detect your system proxy settings. As an example, you might see something like this image when starting the Intel XDK.

On some systems you can get around this problem by setting some proxy environment variables and then starting the Intel XDK from a command-line that includes those configured environment variables. To set those environment variables, similar to the following:

$ export no_proxy="localhost,127.0.0.1/8,::1"
$ export NO_PROXY="localhost,127.0.0.1/8,::1"
$ export http_proxy=http://proxy.mydomain.com:123/
$ export HTTP_PROXY=http://proxy.mydomain.com:123/
$ export https_proxy=http://proxy.mydomain.com:123/
$ export HTTPS_PROXY=http://proxy.mydomain.com:123/

IMPORTANT! The name of your proxy server and the port (or ports) that your proxy server requires will be different than those shown in the example above. Please consult with your IT department to find out what values are appropriate for your site. Intel has no way of knowing what configuration is appropriate for your network.

If you use the Intel XDK in multiple locations (at work and at home), you may have to change the proxy settings before starting the Intel XDK after switching to a new network location. For example, many work networks use a proxy server, but most home networks do not require such a configuration. In that case, you need to be sure to "unset" the proxy environment variables before starting the Intel XDK on a non-proxy network.

After you have successfully configured your proxy environment variables, you can start the Intel XDK manually, from the command-line.

On a Mac, where the Intel XDK is installed in the default location, type the following (from a terminal window that has the above environment variables set):

$ open /Applications/Intel\ XDK.app/

On a Linux machine, assuming the Intel XDK has been installed in the ~/intel/XDK directory, type the following (from a terminal window that has the above environment variables set):

$ ~/intel/XDK/xdk.sh &

In the Linux case, you will need to adjust the directory name that points to the xdk.sh file in order to start. The example above assumes a local install into the ~/intel/XDK directory. Since Linux installations have more options regarding the installation directory, you will need to adjust the above to suit your particular system and install directory.

How do I generate a P12 file on a Windows machine?

See these articles:

• How to Create an iOS Provisioning Profile and P12 with Windows
• Building an iOS signing key for PhoneGap in Windows

How do I change the default dir for creating new projects in the Intel XDK?

You can change the default new project location manually by modifying a field in the global-settings.xdk file. Locate the global-settings.xdk file on your system (the precise location varies as a function of the OS) and find this JSON object inside that file:

"projects-tab": {"defaultPath": "/Users/paul/Documents/XDK","LastSortType": "descending|Name","lastSortType": "descending|Opened","thirdPartyDisclaimerAcked": true
  },

The example above came from a Mac. On a Mac the global-settings.xdk file is located in the "~/Library/Application Support/XDK" directory.

On a Windows machine the global-settings.xdk file is normally found in the "%LocalAppData%\XDK" directory. The part you are looking for will look something like this:

"projects-tab": {"thirdPartyDisclaimerAcked": false,"LastSortType": "descending|Name","lastSortType": "descending|Opened","defaultPath": "C:\\Users\\paul/Documents"
  },

Obviously, it's the defaultPath part you want to change.

BE CAREFUL WHEN YOU EDIT THE GLOBAL-SETTINGS.XDK FILE!! You've been warned...

Make sure the result is proper JSON when you are done, or it may cause your XDK to cough and hack loudly. Make a backup copy of global-settings.xdk before you start, just in case.

Where I can find recent and upcoming webinars list?

• Upcoming webinars list.
• Recent webinars list.

How can I change the email address associated with my Intel XDK login?

Login to the Intel Developer Zone with your Intel XDK account userid and password and then locate your "account dashboard." Click the "pencil icon" next to your name to open the "Personal Profile" section of your account, where you can edit your "Name & Contact Info," including the email address associated with your account, under the "Private" section of your profile.

What network addresses must I enable in my firewall to insure the Intel XDK will work on my restricted network?

Normally, access to the external servers that the Intel XDK uses is handled automatically by your proxy server. However, if you are working in an environment that has restricted Internet access and you need to provide your IT department with a list of URLs that you need access to in order to use the Intel XDK, then please provide them with the following list of domain names:

• appcenter.html5tools-software.intel.com (for communication with the build servers)
• s3.amazonaws.com (for downloading sample apps and built apps)
• download.xdk.intel.com (for getting XDK updates)
• debug-software.intel.com (for using the Test tab weinre debug feature)
• xdk-feed-proxy.html5tools-software.intel.com (for receiving the tweets in the upper right corner of the XDK)
• signin.intel.com (for logging into the XDK)
• sfederation.intel.com (for logging into the XDK)

Normally this should be handled by your network proxy (if you're on a corporate network) or should not be an issue if you are working on a typical home network.

I cannot create a login for the Intel XDK, how do I create a userid and password to use the Intel XDK?

If you have downloaded and installed the Intel XDK but are having trouble creating a login, you can create the login outside the Intel XDK. To do this, go to the Intel Developer Zone and push the "Join Today" button. After you have created your Intel Developer Zone login you can return to the Intel XDK and use that userid and password to login to the Intel XDK. This same userid and password can also be used to login to the Intel XDK forum.

Installing the Intel XDK on Windows fails with a "Package signature verification failed." message.

If you receive a "Package signature verification failed" message (see image below) when installing the Intel XDK on your system, it is likely due to one of the following two reasons:

• Your system does not have a properly installed "root certificate" file, which is needed to confirm that the install package is good.
• The install package is corrupt and failed the verification step.

The first case can happen if you are attempting to install the Intel XDK on an unsupported version of Windows. The Intel XDK is only supported on Microsoft Windows 7 and higher. If you attempt to install on Windows Vista (or earlier) you may see this verification error. The workaround is to install the Intel XDK on a Windows 7 or greater machine.

The second case is likely due to a corruption of the install package during download or due to tampering. The workaround is to re-download the install package and attempt another install.

If you are installing on a Windows 7 (or greater) machine and you see this message it is likely due to a missing or bad root certificate on your system. To fix this you may need to start the "Certificate Propagation" service. Open the Windows "services.msc" panel and then start the "Certificate Propagation" service. Additional links related to this problem can be found here > https://technet.microsoft.com/en-us/library/cc754841.aspx

See this forum thread for additional help regarding this issue > https://software.intel.com/en-us/forums/intel-xdk/topic/603992

Troubles installing the Intel XDK on a Linux or Ubuntu system, which option should I choose?

Choose the local user option, not root or sudo, when installing the Intel XDK on your Linux or Ubuntu system. This is the most reliable and trouble-free option and is the default installation option. This will insure that the Intel XDK has all the proper permissions necessary to execute properly on your Linux system. The Intel XDK will be installed in a subdirectory of your home (~) directory.

Inactive account/ login issue/ problem updating an APK in store, How do I request account transfer?

As of June 26, 2015 we migrated all of Intel XDK accounts to the more secure intel.com login system (the same login system you use to access this forum).

We have migrated nearly all active users to the new login system. Unfortunately, there are a few active user accounts that we could not automatically migrate to intel.com, primarily because the intel.com login system does not allow the use of some characters in userids that were allowed in the old login system.

If you have not used the Intel XDK for a long time prior to June 2015, your account may not have been automatically migrated. If you own an "inactive" account it will have to be manually migrated -- please try logging into the Intel XDK with your old userid and password, to determine if it no longer works. If you find that you cannot login to your existing Intel XDK account, and still need access to your old account, please send a message to html5tools@intel.com and include your userid and the email address associated with that userid, so we can guide you through the steps required to reactivate your old account.

Alternatively, you can create a new Intel XDK account. If you have submitted an app to the Android store from your old account you will need access to that old account to retrieve the Android signing certificates in order to upgrade that app on the Android store; in that case, send an email to html5tools@intel.com with your old account username and email and new account information.

Connection Problems? -- Intel XDK SSL certificates update

On January 26, 2016 we updated the SSL certificates on our back-end systems to SHA2 certificates. The existing certificates were due to expire in February of 2016. We have also disabled support for obsolete protocols.

If you are experiencing persistent connection issues (since Jan 26, 2016), please post a problem report on the forum and include in your problem report:

• the operation that failed
• the version of your XDK
• the version of your operating system
• your geographic region
• and a screen capture

How do I resolve build failure: "libpng error: Not a PNG file"?  

f you are experiencing build failures with CLI 5 Android builds, and the detailed error log includes a message similar to the following:

Execution failed for task ':mergeArmv7ReleaseResources'.> Error: Failed to run command: /Developer/android-sdk-linux/build-tools/22.0.1/aapt s -i .../platforms/android/res/drawable-land-hdpi/screen.png -o .../platforms/android/build/intermediates/res/armv7/release/drawable-land-hdpi-v4/screen.png

Error Code: 42

Output: libpng error: Not a PNG file

You need to change the format of your icon and/or splash screen images to PNG format.

The error message refers to a file named "screen.png" -- which is what each of your splash screens were renamed to before they were moved into the build project resource directories. Unfortunately, JPG images were supplied for use as splash screen images, not PNG images. So the files were renamed and found by the build system to be invalid.

Convert your splash screen images to PNG format. Renaming JPG images to PNG will not work! You must convert your JPG images into PNG format images using an appropriate image editing tool. The Intel XDK does not provide any such conversion tool.

Beginning with Cordova CLI 5, all icons and splash screen images must be supplied in PNG format. This applies to all supported platforms. This is an undocumented "new feature" of the Cordova CLI 5 build system that was implemented by the Apache Cordova project.

Why do I get a "Parse Error" when I try to install my built APK on my Android device?

Because you have built an "unsigned" Android APK. You must click the "signed" box in the Android Build Settings section of the Projects tab if you want to install an APK on your device. The only reason you would choose to create an "unsigned" APK is if you need to sign it manually. This is very rare and not the normal situation.

My converted legacy keystore does not work. Google Play is rejecting my updated app.

The keystore you converted when you updated to 3088 (now 3240 or later) is the same keystore you were using in 2893. When you upgraded to 3088 (or later) and "converted" your legacy keystore, you re-signed and renamed your legacy keystore and it was transferred into a database to be used with the Intel XDK certificate management tool. It is still the same keystore, but with an alias name and password assigned by you and accessible directly by you through the Intel XDK.

If you kept the converted legacy keystore in your account following the conversion you can download that keystore from the Intel XDK for safe keeping (do not delete it from your account or from your system). Make sure you keep track of the new password(s) you assigned to the converted keystore.

There are two problems we have experienced with converted legacy keystores at the time of the 3088 release (April, 2016):

• Using foreign (non-ASCII) characters in the new alias name and passwords were being corrupted.
• Final signing of your APK by the build system was being done with RSA256 rather than SHA1.

Both of the above items have been resolved and should no longer be an issue.

If you are currently unable to complete a build with your converted legacy keystore (i.e., builds fail when you use the converted legacy keystore but they succeed when you use a new keystore) the first bullet above is likely the reason your converted keystore is not working. In that case we can reset your converted keystore and give you the option to convert it again. You do this by requesting that your legacy keystore be "reset" by filling out this form. For 100% surety during that second conversion, use only 7-bit ASCII characters in the alias name you assign and for the password(s) you assign.

IMPORTANT: using the legacy certificate to build your Android app is ONLY necessary if you have already published an app to an Android store and need to update that app. If you have never published an app to an Android store using the legacy certificate you do not need to concern yourself with resetting and reconverting your legacy keystore. It is easier, in that case, to create a new Android keystore and use that new keystore.

If you ARE able to successfully build your app with the converted legacy keystore, but your updated app (in the Google store) does not install on some older Android 4.x devices (typically a subset of Android 4.0-4.2 devices), the second bullet cited above is likely the reason for the problem. The solution, in that case, is to rebuild your app and resubmit it to the store (that problem was a build-system problem that has been resolved).

How can I have others beta test my app using Intel App Preview?

Apps that you sync to your Intel XDK account, using the Test tab's green "Push Files" button, can only be accessed by logging into Intel App Preview with the same Intel XDK account credentials that you used to push the files to the cloud. In other words, you can only download and run your app for testing with Intel App Preview if you log into the same account that you used to upload that test app. This restriction applies to downloading your app into Intel App Preview via the "Server Apps" tab, at the bottom of the Intel App Preview screen, or by scanning the QR code displayed on the Intel XDK Test tab using the camera icon in the upper right corner of Intel App Preview.

If you want to allow others to test your app, using Intel App Preview, it means you must use one of two options:

• give them your Intel XDK userid and password
• create an Intel XDK "test account" and provide your testers with that userid and password

For security sake, we highly recommend you use the second option (create an Intel XDK "test account"). 

A "test account" is simply a second Intel XDK account that you do not plan to use for development or builds. Do not use the same email address for your "test account" as you are using for your main development account. You should use a "throw away" email address for that "test account" (an email address that you do not care about).

Assuming you have created an Intel XDK "test account" and have instructed your testers to download and install Intel App Preview; have provided them with your "test account" userid and password; and you are ready to have them test:

• sign out of your Intel XDK "development account" (using the little "man" icon in the upper right)
• sign into your "test account" (again, using the little "man" icon in the Intel XDK toolbar)
• make sure you have selected the project that you want users to test, on the Projects tab
• goto the Test tab
• make sure "MOBILE" is selected (upper left of the Test tab)
• push the green "PUSH FILES" button on the Test tab
• log out of your "test account"
• log into your development account

Then, tell your beta testers to log into Intel App Preview with your "test account" credentials and instruct them to choose the "Server Apps" tab at the bottom of the Intel App Preview screen. From there they should see the name of the app you synced using the Test tab and can simply start it by touching the app name (followed by the big blue and white "Launch This App" button). Staring the app this way is actually easier than sending them a copy of the QR code. The QR code is very dense and is hard to read with some devices, dependent on the quality of the camera in their device.

Note that when running your test app inside of Intel App Preview they cannot test any features associated with third-party plugins, only core Cordova plugins. Thus, you need to insure that those parts of your apps that depend on non-core Cordova plugins have been disabled or have exception handlers to prevent your app from either crashing or freezing.

I'm having trouble making Google Maps work with my Intel XDK app. What can I do?

There are many reasons that can cause your attempt to use Google Maps to fail. Mostly it is due to the fact that you need to download the Google Maps API (JavaScript library) at runtime to make things work. However, there is no guarantee that you will have a good network connection, so if you do it the way you are used to doing it, in a browser...

<script src="https://maps.googleapis.com/maps/api/js?key=API_KEY&sensor=true"></script>

...you may get yourself into trouble, in an Intel XDK Cordova app. See Loading Google Maps in Cordova the Right Way for an excellent tutorial on why this is a problem and how to deal with it. Also, it may help to read Five Useful Tips on Getting Started Building Cordova Mobile Apps with the Intel XDK, especially item #3, to get a better understanding of why you shouldn't use the "browser technique" you're familiar with.

An alternative is to use a mapping tool that allows you to include the JavaScript directly in your app, rather than downloading it over the network each time your app starts. Several Intel XDK developers have reported very good luck with the open-source JavaScript library named LeafletJS that uses OpenStreet as it's map database source.

You can also search the Cordova Plugin Database for Cordova plugins that implement mapping features, in some cases using native SDKs and libraries.

How do I fix "Cannot find the Intel XDK. Make sure your device and intel XDK are on the same wireless network." error messages?

You can either disable your firewall or allow access through the firewall for the Intel XDK. To allow access through the Windows firewall goto the Windows Control Panel and search for the Firewall (Control Panel > System and Security > Windows Firewall > Allowed Apps) and enable Node Webkit (nw or nw.exe) through the firewall

See the image below (this image is from a Windows 8.1 system).

Back to FAQs Main

Earlier version of the Depth Camera Managers (DCM) and Intel® RealSense™ Runtime Distributable. 

DCM - F200

Note: Most version include a camera firmware update. 

DCM - SR300

DCM- R200

Runtime Distributable

Note: All app installers must include the runtime that matches the version of the SDK build. 

Download size before voice component. 

The Intel Python Windows installer defaults to c:\IntelPython27 & c:\intelpython35, but you can customize the directory. When you see the screen below select customize and next. It will let you specify the directory.

We have made it easy to use Intel Python from Anaconda. We recommend that you create a new environment when installing. To install the core python3 environment, do:

conda create -n idp -c intel intelpython3_core

If you want python 2 do:

conda create -n idp -c intel intelpython2_core

Then follow the directions for activating the environment. Linux/OSX users do:

source activate idp

and windows users do:

activate.bat idp

You now have the core environment, including python, numpy, scipy,... You can use the usual conda install commands for additional packages. For example, to install sympy do:

conda install -c intel --override-channel sympy

Available Intel packages can be viewed here: https://anaconda.org/intel/packages

For more information, read https://software.intel.com/sites/default/files/managed/9d/09/Conda-Guide-for-Intel(R)-Distribution-for-Python-2017.pdf

The Intel Advisor will soon offer a great step forward in memory performance optimization with a new vivid Advisor “Roofline” bounds and bottlenecks analysis  

This new feature provides insights beyond vectorization, such as memory usage and the quality of algorithm implementation.

If you want to try it out or influence the development of this new Roofline feature, sign up for the early access program by sending a request to vector_advisor@intel.com.

Accelerate your application: Tuning existing vectorization and adding new vectorization is easy with the visually intuitive Vectorization Advisor tool in the Intel® Advisor. Try out new vectorization capabilities available in the Intel® Parallel Studio Beta Update, such as expanded memory access patterns analysis, Flops information, and special features for the second generation of the Intel® Xeon Phi™ processor (code name Knights Landing) that uses the AVX-512 instruction set. Register for Intel® Parellel Studio XE 2017 beta program https://software.intel.com/en-us/articles/intel-parallel-studio-xe-2017-beta#howto , or  download an evaluation copy from http://software.intel.com/en-us/articles/intel-software-evaluation-center/. 

Roofline Modeling

Roofline modeling was first proposed by Berkley researchers  Samuel Williams, Andrew Waterman, and David Patterson in paper "Roofline: An Insightful Visual Performance Model for Multicore Architectures" in 2009. 

A Roofline model provides insight into how your application works by helping you answer the following questions:

• Does my application work optimally on the current hardware?
• What limits performance? Is my application workload memory or compute bound?
• What is the right strategy to improve application performance?

The model plots data to help you visualize application compute- and memory-bandwidth ceilings by measuring two parameters:

• Operational intensity – the number of floating-point operations per byte transferred from memory
• Floating-point performance – in Gflops per second

The proximity of the data points to the model lines (rooflines) shows the degree of optimization.

Consider the roofline plot in Fig. 1.

The kernel's on the right hand side are more compute bound and as you move up the Y-axis they become get close to the FP peak. The performance of these kernels are bounded by the compute capabilities of the platform. To improve performance of kernel 3 consider migrating this kernel to a highly parallel platform, such as the Intel Xeon Phi processor, where the compute ceiling and memory throughput is higher. For the kernel 2 vectorization can be considered as a performance improvement strategy as it is far away from the ceiling.

Towards the left-hand side of the plot, the kernel's here are memory bound and you go up the Y-axis they are more bound to the DRAM and cache peak bandwidth of the platform. To increase the performance of these kernels (shifting the plot position to the right with a higher performance ceiling), consider improving the algorithm or its implementation to perform more computations per data item. These kernels may also run faster on an Intel Xeon Phi processor because of greater memory bandwidth availability.

Intel Advisor Roofline Feature

The Intel Advisor implemented "Cache-aware roofline" model described in "Cache-aware Roofline model: Upgrading the loft" paper authored by Aleksandar Ilic, Frederico Pratas, and Leonel Sousa. It provides additional insight by addressing all levels of memory / cache hierarchy:

• Slope rooflines illustrate performance levels, if all the data fits into respective cache.
• Horizontal lines show the peak achievable performance levels if vectorization and other CPU resources are used effectively.

Intel Advisor places a dot for every loop in the Roofline plot. Consider the Intel Advisor roofline plot in the Fig.2.  Most of loops require extra cache use optimizations. Loops to the right of the plotted blue data point fall below the scalar execution roofline and therefore require vectorization.

You can examine you application performance opportunities by applying our experimental Roofline Vector Advisor and browsing through high loaded loops. The circles sizes denotes execution time of loops.

This page provides the current Release Notes for the Debug Solutions from Intel® Parallel Studio XE 2017 Composer Edition BETA Update 1 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® Fortran Compiler 17.0 Release Notes

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 2017 Composer Edition BETA

• Fortran Expression Evaluator (FEE):
  • Added support for displaying extended types that are parameterized
  • Added the ability in FEE to change the format in which a value is displayed in the debugger windows (e.g.: Watch, Immediate) by using format  specifiers (specified here). The supported format specifiers are "x","s","d","o","c","e","g", and "f".
  • Display of array dimensions in the "Value" column of the Watch and Locals views and in array tooltips.
  • Added support for viewing a particular element of a data structure across an array of such structures (e.g. students(1:100:1)%name). Value assignment to this type of expressions is not supported, though.
  • Modified to display character variable data that contain nulls. Editing of null containing string is disabled in the Watch and  Locals views. Editing in the memory window is still possible.

Changes since Intel® Parallel Studio XE 2016 Composer Edition

• Simplified Eclipse* plug-in
• Support for Intel® Xeon Phi™ coprocessor & processor X200 offload debugging
• Shipping GNU* Project Debugger (GDB) 7.10 (except for Intel® Debugger for Heterogeneous Compute 2017)
• Improved Fortran Variable Length Array support for GNU* Project Debugger

Product Contents

• Linux*:
  • GNU* Project Debugger (GDB) 7.10:
    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.10:
    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) of Intel® Xeon Phi™ coprocessor X100
• Support for Intel® Xeon Phi™ coprocessor & processor X200
• 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 X100 applications. For Intel® Xeon Phi™ coprocessor & processor X200 use gdb-ia.
    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 2017 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_2017/en/debugger/gdb-ia/gdb.pdf<install-dir>/documentation_2017/en/debugger/gdb-mic/gdb.pdf<install-dir>/documentation_2017/en/debugger/ps2016/get_started.htm

<install-dir>\documentation_2017\en\debugger\ps2017\get_started.htm

<Program Files (x86) Directory>\Microsoft Visual Studio 12.0\Common7\IDE\Remote Debugger\x64

<Program Files Directory>\Microsoft Visual Studio 12.0\Common7\IDE\Remote Debugger\x64

This page provides the current Release Notes for the Debug Solutions from Intel® Parallel Studio XE 2017 Composer Edition BETA Update 1 for C++ 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® C++ Compiler 17.0 Release Notes

Table of Contents:

• Change History
• Product Contents
• GNU* GDB
• Intel® Debugger for Heterogeneous Compute 2017
• Intel® Debugger Extension for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)
• 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 2016 Composer Edition

• Simplified Eclipse* plug-in
• Support for Intel® Xeon Phi™ coprocessor & processor X200 offload debugging
• Shipping GNU* Project Debugger (GDB) 7.10 (except for Intel® Debugger for Heterogeneous Compute 2017)

Product Contents

This section lists the individual Debug Solutions components for each supported host OS. Not all components are available for all host OSes.

• Linux*:
  • GNU* Project Debugger (GDB) 7.10:
    Command line for host CPU and Intel® Xeon Phi™ coprocessor & processor, and Eclipse* IDE plugin for offload enabled applications.
  • Intel® Debugger for Heterogeneous Compute 2017
• OS X*:
  • GNU* Project Debugger (GDB) 7.10:
    Command line for CPU only.
• Windows*:
  • Intel® Debugger Extension for Intel® Many Integrated Core Architecture (Intel® MIC Architecture)

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) of Intel® Xeon Phi™ coprocessor X100
• Support for Intel® Xeon Phi™ coprocessor & processor X200
• 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.
• Pointer Checker:
  Assist in finding pointer issues if compiled with Intel® C++ Compiler and having Pointer Checker feature enabled (see Intel® C++ Compiler documentation for more information)
• Improved Intel® Cilk™ Plus Support:
  Serialized execution of Intel® Cilk™ Plus parallel applications can be turned on and off during a debug session using the following command:
  (gdb) set cilk-serialization [on|off]

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 & processor 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 X100 applications. For Intel® Xeon Phi™ coprocessor & processor X200 use gdb-ia.
    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 2017 Composer Edition.
    This works only for offload enabled Intel® Xeon Phi™ coprocessor & processor applications. Instructions on how to use GNU* GDB can be found in the Documentation section.

<install-dir>/documentation_2017/en/debugger/gdb-ia/gdb.pdf<install-dir>/documentation_2017/en/debugger/gdb-mic/gdb.pdf<install-dir>/documentation_2017/en/debugger/ps2017/get_started.htm

Consider the following code snippet:

_Cilk_shared bool is_active;
_Cilk_shared my_target_func() {
  //Accessing “is_active” from the debugger *could* lead to unexpected
  // results e.g. a lost write or outdated data is read.
  is_active = true;
  // Accessing "is_active" (read or write) from the debugger at this
  // point is considered safe e.g. correct value is displayed.
}

<install-dir>/documentation_2017/en/debugger/gdb-igfx/gdb.pdf<install-dir>/documentation_2017/en/debugger/ps2017/get_started.htm

<install-dir>\documentation_2017\en\debugger\ps2017\get_started.htm

• HDD: the most popular storage in current use.
• SATA SSD: a faster storage which is gaining popularity.
• RAMDISK: used to emulate the extremely high performance PCIe NVMe-based SSDs and upcoming faster storage (e.g. Intel 3D XPoint® based SSD). Due to hardware unavailability, RAMDISK was used to perform this emulation. The results hold for PCIe SSD and other fast storage types.

Download the study at the link below:

The complexity of Intel® Active Management Technology (Intel® AMT) configuration profiles vary depending on the enabled features. The first step in integrating Intel AMT into a management console is to determine which features the console should support.

Begin by looking at configuration options within the ACU Wizard tool where you can examine the options. This tool is part of the Intel® Setup and Configuration Software (Intel® SCS) download. You can find more information about the options in the Intel SCS documentation within the Intel SCS download.

Console Integration of Host-Based Configuration

The most common console integration uses the host-based configuration methodology. This method uses the host's OS (Windows* 7+) with a scripted configuration to execute the configuration.

This article shows how the ACU Wizard tool creates a sample configuration profile. The profile provides the expected XML code so the console can create and encrypt for deployment to Intel AMT devices.

Note: If the console creates the profile XML, you should encrypt the file by using the SCSEncryption.exe tool prior to deployment to the Intel AMT device. Without encryption, the file will be sent to the client in clear text, exposing passwords within the profile.xml file.

Automating the configuration process will involve creating the profile.xml file and creating a script to perform the configuration. The basic steps are:

1. Copy the “configurator” folder and the profile.xml file from the SCS download folder to a location accessible by the Intel AMT client (Local, Network share, USB thumb drive, and so on).
2. Open a command prompt with “Run as Administrator”  privileges, and then navigate to the acuconfig folder and run the following command: "acuconfig.exe configamt <profile.xml> /decryptionpassword <PASSWORD>"
3. The configuration is successful if the program exits with code 0.

Host-based configuration, as described above, has one significant disadvantage. It does not allow an Intel AMT device to be configured into Admin Control Mode. With a slight change to the configuration profile, we can point the firmware to a Setup and Configuration Server to access a Provisioning Certificate. For more detail on Admin Control Mode/Client Control Mode, see Intel vPro Setup and Configuration Integration.

How to Use the ACU Wizard Tool

The ACU Wizard tool has several methods for configuring an Intel AMT Device. However for our purposes, we only need one of the options to get our sample xml file. To create the profile.xml file while using ACU Wizard, do the following:

1. Create the profile by opening the ACU Wizard and selecting the Create Settings to configure Multiple Systems option.
   
2. The Intel® AMT Configuration Utility: Profile Designer Window opens.
3. Click the green plus sign.
4. When the Configuration Profile Wizard opens, click Next.
5. When the Configuration Profile Wizard Optional Settings Window opens, click Next.
6. The Configuration Profile Wizard System Settings Window opens.
   1. Enter the RFB password if being enabled (not required).
      1. RFB refers to the Remote Frame Buffer protocol, also known as RFB5900. Enabling the RFB password allows for the use of a standard VNC viewer using port 5900, as opposed to a VNC viewer enabled for Intel AMT, which also uses Port 16994 or 16995.
   2. Enter the password in the use the following password for all systems data field.
   3. To edit the network settings, click the Set... button.
      1. There are no changes to make if the host OS is DHCP Enabled. Note the changes required if the OS has a static IP address.
      2. Select Cancel.
   4. Click Next.
      
7. The Configuration Profile Wizard - Finished window opens.
   1. Enter the profile name you want to use, for example: profile.
   2. Encrypt the xml file by adding and confirming the password.
   3. Click Finish.
      
8. The Intel® AMT Configuration Utility: Profile Designer Window opens.
   1. Note the Profile Path shown on your screen.
      1. It should look like this: <userName>\documents\SCS_Profile
   2. Close the ACU Wizard.

Note: For detailed instructions on using the ACU Wizard, please refer to or the documentation contained within the Intel® SCS download.

Using the Profile.xml file

Now we have an encrypted profile.xml. We next need to decrypt the file to expose the configuration parameters by using SCSEncryption.exe program, contained in the Intel SCS download. Once decrypted, you can open the file in an xml viewer and see the exposed xml tags.

Decryption syntax:

>SCSEncryption.exe Decrypt <input_filename> <password> /Output <output_filename>

Note: If you wish to enable additional features within your profile or explore other features of Intel AMT, these features can be enabled in step 5 above. For example, one of the popular and highly recommended features is wireless configuration.

Control Mode Choices

The configuration process will place the Intel AMT device into one of two modes: Client Control Mode or Admin Control Mode. The main difference is that Client Control Mode requires User Consent for redirection operations and Admin Control Mode does not.

User Consent

The User Consent feature adds another level of security for remote users. A User Consent code must be submitted when a redirection or control is required of the remote client. For example, accessing via Remote KVM or executing an IDEr command is considered a redirection operation, but performing a get power state or reboot is not.

Additional Resources

• Additional information on ACM vs CCM
• Intel® SCS Download
• Intel® AMT Implementation and Reference Guide
• Intel® AMT PowerShell Module
• Intel® AMT SDK Download
• Intel vPro Setup and Configuration Integration.

Summary

One of the most important integration tasks for managing Intel AMT-enabled devices is configuration. The process of configuration is straightforward when using ACUconfig.exe, however the profile creation process is the portion we need to address in depth.

Using ACUWizard.exe we can create a sample profile.xml that gives us a snapshot showing how we can create dynamic console-based profiles, so we are not tied to a specific static profile. This gives us the ability to manage Intel AMT in a wider range of feature enablement, such as User Consent Configuration, wireless profiles, Active Directory Access Control Lists (AD ACLs), and so on.

About the Author

Joe Oster has been at Intel working with Intel® vPro™ technology and Intel AMT since 2006. When not working, he spends time working on his family farm or flying drones and RC aircraft.

• The Intel XDK is not generating a debug module or is not starting my debug module.
• What are the requirements for Testing on Wi-Fi?
• How do I configure app preview to work over Wi-Fi?
• How do I clear app preview cache and memory?
• What are the Android* devices supported by App Preview?
• What do I do if Intel XDK stops detecting my Android* device?
• How do I debug an app that contains third party plugins?
• Why does my device show as offline on Intel XDK Debug?
• What do I do if my remote debugger does not launch?
• Why do I get an "error installing App Preview Crosswalk" message when trying to debug on device?
• Why is Chrome remote debug not working with my Android or Crosswalk app?
• How do I detect if my code is running in the Emulate tab?
• Never ending "Transferring your project files to the Testing Device" message from Debug tab; results in no Chrome DevTools debug console.
• Can you integrate the iOS Simulator as a testing platform for Intel XDK projects?
• What is the purpose of having only a partial emulation or simulation in the Emulate tab?
• Not everyone can afford hardware for testing, especially iOS devices; what can I do?
• Is testing on Crosswalk on a virtual Android device inside VirtualBox good enough?
• Why isn't the Intel XDK emulation as good as running on a real device?
• Why doesn't my custom splash screen does not show in the emulator or App Preview?
• Is there a way to detect if my program has stopped due to using uninitialized variable or an undefined method call?
• Why doesn't the Intel XDK go directly to Debug assuming that I have a device connected via USB?
• Can a custom debug module that supports USB debug with third-party plugins be built for iOS devices, or only for Android devices?
• Why does my Android debug session not start when I'm using the Debug tab?
• How do I share my app for testing in App Preview?
• I am trying to use Live Layout Editing but I get a message saying Chrome is not installed on my system.

The Intel XDK is not generating a debug module or is not starting my debug module.

There are a variety of things that can go wrong when attempting to use the Debug tab:

• your test device cannot be seen by the Debug tab:
• the debug module build fails 
• the debug module builds, but fails to install onto your test device 
• the debug module builds and installs, but fails to "auto-start" on your test device 
• your test device has run out of memory or storage and needs to be cleared
• there is a problem with the adb server on your development system

Other problems may also arise, but the above list represents the most common. Search this FAQ and the forum for solutions to these problems. Also, see the Debug tab documentation for some help with installing and configuring your system to use the adb debug driver with your device.

What are the requirements for Testing on Wi-Fi?

1. Both Intel XDK and App Preview mobile app must be logged in with the same user credentials.
2. Both devices must be on the same subnet.

Note: Your computer's Security Settings may be preventing Intel XDK from connecting with devices on your network. Double check your settings for allowing programs through your firewall. At this time, testing on Wi-Fi does not work within virtual machines.

How do I configure app preview to work over Wi-Fi?

1. Ensure that both Intel XDK and App Preview mobile app are logged in with the same user credentials and are on the same subnet
2. Launch App Preview on the device
3. Log into your Intel XDK account
4. Select "Local Apps" to see a list of all the projects in Intel XDK Projects tab
5. Select desired app from the list to run over Wi-Fi

Note: Ensure the app source files are referenced from the right source directory. If it isn't, on the Projects Tab, change the 'source' directory so it is the same as the 'project' directory and move everything in the source directory to the project directory. Remove the source directory and try to debug over local Wi-Fi.

How do I clear app preview cache and memory?

[Android*] Simply kill the app running on your device as an Active App on Android* by swiping it away after clicking the "Recent" button in the navigation bar. Alternatively, you can clear data and cache for the app from under Settings App > Apps > ALL > App Preview.

[iOS*] By double tapping the Home button then swiping the app away.

[Windows*] You can use the Windows* Cache Cleaner app to do so.

What are the Android* devices supported by App Preview?

We officially only support and test Android* 4.x and higher, although you can use Cordova for Android* to build for Android* 2.3 and above. For older Android* devices, you can use the build system to build apps and then install and run them on the device to test. To help in your testing, you can include the weinre script tag from the Test tab in your app before you build your app. After your app starts up, you should see the Test tab console light up when it sees the weinre script tag contact the device (push the "begin debugging on device" button to see the console). Remember to remove the weinre script tag before you build for the store.

What do I do if Intel XDK stops detecting my Android* device?

When Intel XDK is not running, kill all adb processes that are running on your workstation and then restart Intel XDK as conflicts between different versions of adb frequently causes such issues. Ensure that applications such as Eclipse that run copies of adb are not running. You may scan your disk for copies of adb:

[Linux*/OS X*]:

$ sudo find / -name adb -type f 

[Windows*]:

> cd \> dir /s adb.exe

For more information on Android* USB debug, visit the Intel XDK documentation on debugging and testing.

How do I debug an app that contains third party Cordova plugins?

See the Debug and Test Overview doc page for a more complete overview of your debug options.

When using the Test tab with Intel App Preview your app will not include any third-party plugins, only the "core" Cordova plugins.

The Emulate tab will load the JavaScript layer of your third-party plugins, but does not include a simulation of the native code part of those plugins, so it will present you with a generic "return" dialog box to allow you to execute code associated with third-party plugins.

When debugging Android devices with the Debug tab, the Intel XDK creates a custom debug module that is then loaded onto your USB-connected Android device, allowing you to debug your app AND its third-party Cordova plugins. When using the Debug tab with an iOS device only the "core" Cordova plugins are available in the debug module on your USB-connected iOS device.

If the solutions above do not work for you, then your best bet for debugging an app that contains a third-party plugin is to build it and debug the built app installed and running on your device. 

[Android*]

1) For Crosswalk* or Cordova for Android* build, create an intelxdk.config.additions.xml file that contains the following lines:

<!-- Change the debuggable preference to true to build a remote CDT debuggable app for --><!-- Crosswalk* apps on Android* 4.0+ devices and Cordova apps on Android* 4.4+ devices. --><preference name="debuggable" value="true" /><!-- Change the debuggable preference to false before you build for the store. --> 

and place it in the root directory of your project (in the same location as your other intelxdk.config.*.xml files). Note that this will only work with Crosswalk* on Android* 4.0 or newer devices or, if you use the standard Cordova for Android* build, on Android* 4.4 or greater devices.

2) Build the Android* app

3) Connect your device to your development system via USB and start app

4) Start Chrome on your development system and type "chrome://inspect" in the Chrome URL bar. You should see your app in the list of apps and tabs presented by Chrome, you can then push the "inspect" link to get a full remote CDT session to your built app. Be sure to close Intel XDK before you do this, sometimes there is interference between the version of adb used by Chrome and that used by Intel XDK, which can cause a crash. You might have to kill the adb process before you start Chrome (after you exit the Intel XDK).

[iOS*]

Refer to the instructions on the updated Debug tab docs to get on-device debugging. We do not have the ability to build a development version of your iOS* app yet, so you cannot use this technique to build iOS* apps. However, you can use the weinre script from the Test tab into your iOS* app when you build it and use the Test tab to remotely access your built iOS* app. This works best if you include a lot of console.log messages.

[Windows* 8]

You can use the test tab which would give you a weinre script. You can include it in the app that you build, run it and connect to the weinre server to work with the console.

Alternatively, you can use App Center to setup and access the weinre console (go here and use the "bug" icon).

Another approach is to write console.log messages to a <textarea> screen on your app. See either of these apps for an example of how to do that:

• https://github.com/xmnboy/test-third-party-plugin
• https://github.com/xmnboy/hello-cordova

Why does my device show as offline on Intel XDK Debug?

“Media” mode is the default USB connection mode, but due to some unidentified reason, it frequently fails to work over USB on Windows* machines. Configure the USB connection mode on your device for "Camera" instead of "Media" mode.

What do I do if my remote debugger does not launch?

You can try the following to have your app run on the device via debug tab:

• Place the intelxdk.js library before the </body> tag
• Place your app specific JavaScript files after it
• Place the call to initialize your app in the device ready event function

Why do I get an "error installing App Preview Crosswalk" message when trying to debug on device?

You may be running into a RAM or storage problem on your Android device; as in, not enough RAM available to load and install the special App Preview Crosswalk app (APX) that must be installed on your device. See this site (http://www.devicespecifications.com) for information regarding your device. If your device has only 512 MB of RAM, which is a marginal amount for use with the Intel XDK Debug tab, you may have difficulties getting APX to install.

You may have to do one or all of the following:

• remove as many apps from RAM as possible before installing APX (reboot the device is the simplest approach)
• make sure there is sufficient storage space in your device (uninstall any unneeded apps on the device)
• install APX by hand

The last step is the hardest, but only if you are uncomfortable with the command-line:

1. while attempting to install APX (above) the XDK downloaded a copy of the APK that must be installed on your Android device
2. find that APK that contains APX
3. install that APK manually onto your Android device using adb

To find the APK, on a Mac:

$ cd ~/Library/Application\ Support/XDK
$ find . -name *apk

To find the APK, on a Windows machine:

> cd %LocalAppData%\XDK> dir /s *.apk

For each version of Crosswalk that you have attempted to use (via the Debug tab), you will find a copy of the APK file (but only if you have attempted to use the Debug tab and the XDK has successfully downloaded the corresponding version of APX). You should find something similar to:

./apx_download/12.0/AppAnalyzer.apk

following the searches, above. Notice the directory that specifies the Crosswalk version (12.0 in this example). The file named AppAnalyzer.apk is APX and is what you need to install onto your Android device.

Before you install onto your Android device, you can double-check to see if APX is already installed:

• find "Apps" or "Applications" in your Android device's "settings" section
• find "App Preview Crosswalk" in the list of apps on your device (there can be more than one)

If you found one or more App Preview Crosswalk apps on your device, you can see which versions they are by using adb at the command-line (this assumes, of course, that your device is connected via USB and you can communicate with it using adb):

1. type adb devices at the command-line to confirm you can see your device
2. type adb shell 'pm list packages -f' at the command-line
3. search the output for the word app_analyzer

The specific version(s) of APX installed on your device end with a version ID. For example:com.intel.app_analyzer.v12 means you have APX for Crosswalk 12 installed on your device.

To install a copy of APX manually, cd to the directory containing the version of APX you want to install and then use the following adb command:

$ adb install AppAnalyzer.apk

If you need to remove the v12 copy of APX, due to crowding of available storage space, you can remove it using the following adb command:

$ adb uninstall com.intel.app_analyzer.v12

or

$ adb shell am start -a android.intent.action.DELETE -d package:com.intel.app_analyzer.v12

The second one uses the Android undelete tool to remove the app. You'll have to respond to a request to undelete on the Android device's screen. See this SO issue for details. Obviously, if you want to uninstall a different version of APX, specify the package ID corresponding to that version of APX.

Why is Chrome remote debug not working with my Android or Crosswalk app?

For a detailed discussion regarding how to use Chrome on your desktop to debug an app running on a USB-connected device, please read this doc page Remote Chrome* DevTools* (CDT).

Check to be sure the following conditions have been met:

• The version of Chrome on your desktop is greater than or equal to the version of the Chrome webview in which you are debugging your app.
  
  For example, Crosswalk 12 uses the Chrome 41 webview, so you must be running Chrome 41 or greater on your desktop to successfully attach a remote Chrome debug session to an app built with Crosswalk 12. The native Chrome webview in an Android 4.4.2 device is Chrome 30, so your desktop Chrome must be greater than or equal to Chrome version 30 to debug an app that is running on that native webview.
• Your Android device is running Android 4.4 or higher, if you are trying to remote debug an app running in the device's native webview, and it is running Android 4.0 or higher if you are trying to remote debug an app running Crosswalk.
  
  When debugging against the native webview, remote debug with Chrome requires that the remote webview is also Chrome; this is not guaranteed to be the case if your Android device does not include a license for Google services. Some manufacturers do not have a license agreement with Google for distribution of the Google services on their devices and, therefore, may not include Chrome as their native webview, even if they are an Android 4.4 or greater device.
• Your app has been built to allow for remote debug.
  
  Within the intelxdk.config.additions.xml file you must include this line: <preference name="debuggable" value="true" /> to build your app for remote debug. Without this option your app cannot be attached to for remote debug by Chrome on your desktop.

How do I detect if my code is running in the Emulate tab?

In the obsolete intel.xdk apis there is a property you can test to detect if your app is running within the Emulate tab or on a device. That property is intel.xdk.isxdk. A simple alternative is to perform the following test:

if( window.tinyHippos )

If the test passes (the result is true) you are executing in the Emulate tab.

Never ending "Transferring your project files to the Testing Device" message from Debug tab; results in no Chrome DevTools debug console.

This is a known issue but a resolution for the problem has not yet been determined. If you find yourself facing this issue you can do the following to help resolve it.

On a Windows machine, exit the Intel XDK and open a "command prompt" window:

> cd %LocalAppData%\XDK\> rmdir cdt_depot /s/q

On a Mac or Linux machine, exit the Intel XDK and open a "terminal" window:

$ find ~ -name global-settings.xdk
$ cd <location-found-above>
$ rm -Rf cdt_depot

Restart the Intel XDK and try the Debug tab again. This procedure is deleting the cached copies of the Chrome DevTools that were retrieved from the corresponding App Preview debug module that was installed on your test device.

One observation that causes this problem is the act of removing one device from your USB and attaching a new device for debug. A workaround that helps sometimes, when switching between devices, is to:

• switch to the Develop tab
• close the XDK
• detach the old device from the USB
• attach the new device to your USB
• restart the XDK
• switch to the Debug tab

Can you integrate the iOS Simulator as a testing platform for Intel XDK projects?

The iOS simulator only runs on Apple Macs... We're trying to make the Intel XDK accessible to developers on the most popular platforms: Windows, Mac and Linux. Additionally, the iOS simulator requires a specially built version of your app to run, you can't just load an IPA onto it for simulation.

What is the purpose of having only a partial emulation or simulation in the Emulate tab?

There's no purpose behind it, it's simply difficult to emulate/simulate every feature and quirk of every device.

Not everyone can afford hardware for testing, especially iOS devices; what can I do?

You can buy a used iPod and that works quite well for testing iOS apps. Of course, the screen is smaller and there is no compass or phone feature, but just about everything else works like an iPhone. If you need to do a lot of iOS testing it is worth the investment. A new iPod costs $200 in the US. Used ones should cost less than that. Make sure you get one that can run iOS 8.

Is testing on Crosswalk on a virtual Android device inside VirtualBox good enough?

When you run the Android emulator you are running on a fictitious device, but it is a better emulation than what you get with the iOS simulator and the Intel XDK Emulate tab. The Crosswalk webview further abstracts the system so you get a very good simulation of a real device. However, considering how inexpensive and easy Android devices are to obtain, we highly recommend you use a real device (with the Debug tab), it will be much faster and even more accurate than using the Android emulator.

Why isn't the Intel XDK emulation as good as running on a real device?

Because the Intel XDK Emulate tab is a Chromium browser, so what you get is the behavior inside that Chromium browser along with some conveniences that make it appear to be a hybrid device. It's poorly named as an emulator, but that was the name given to it by the original Ripple Emulator project. What it is most useful for is simulating most of the core Cordova APIs and your basic application logic. After that, it's best to use real devices with the Debug tab.

Why doesn't my custom splash screen does not show in the emulator or App Preview?

Ensure the splash screen plugin is selected. Custom splash screens only get displayed on a built app. The emulator and app preview will always use Intel XDK splash screens. Please refer to the 9-Patch Splash Screen sample for a better understanding of how splash screens work.

Is there a way to detect if my program has stopped due to using uninitialized variable or an undefined method call?

This is where the remote debug features of the Debug tab are extremely valuable. Using a remote CDT (or remote Safari with a Mac and iOS device) are the only real options for finding such issues. WEINRE and the Test tab do not work well in that situation because when the script stops WEINRE stops.

Why doesn't the Intel XDK go directly to Debug assuming that I have a device connected via USB?

We are working on streamlining the debug process. There are still obstacles that need to be overcome to insure the process of connecting to a device over USB is painless.

Can a custom debug module that supports USB debug with third-party plugins be built for iOS devices, or only for Android devices?

The Debug tab, for remote debug over USB can be used with both Android and iOS devices. Android devices work best. However, at this time, debugging with the Debug tab and third-party plugins is only supported with Android devices (running in a Crosswalk webview). We are working on making the iOS option also support debug with third-party plugins, like what you currently get with Android.

Why does my Android debug session not start when I'm using the Debug tab?

Some Android devices include a feature that prevents some applications and services from auto-starting, as a means of conserving power and maximizing available RAM. On Asus devices, for example, there is an app called the "Auto-start Manager" that manages apps that include a service that needs to start when the Android device starts.

If this is the case on your test device, you need to enable the Intel App Preview application as an app that is allowed to auto-start. See the image below for an example of the Asus Auto-start Manager:

Another thing you can try is manually starting Intel App Preview on your test device before starting a debug session with the Debug tab.

How do I share my app for testing in App Preview?

The only way to retrieve a list of apps in App Preview is to login. If you do not wish to share your credentials, you can create an alternate account and push your app to the cloud using App Preview and share that account's credentials, instead.

I am trying to use Live Layout Editing but I get a message saying Chrome is not installed on my system.

The Live Layout Editing feature of the Intel XDK is built on top of the Brackets Live Preview feature. Most of the issues you may experience with Live Layout Editing can be addressed by reviewing this Live Preview Isn't Working FAQ from the Brackets Troubleshooting wiki. In particular, see the section regarding using Chrome with Live Preview.

Back to FAQs Main

This article describes how to configure a rate limiting instance on ingress traffic for a Data Plane Development Kit (DPDK) interface on Open vSwitch* (OVS) with DPDK. This article was written with network admin users in mind who want to use Open vSwitch Rate Limiting to guarantee reception rate performance for DPDK port types in their Open vSwitch server deployments. This article is a companion to the QoS Configuration and Usage for Open vSwitch* with DPDK article as Rate Limiting and QoS execute on RX/TX paths respectively but use unique API utility commands for setup and usage.

Note: At the time of writing, rate limiting for OVS with DPDK is only available on the OVS master branch. Users can download the OVS master branch as a zip here. Installation steps for OVS with DPDK are available here.

Rate Limiting in OVS with DPDK

Before we configure rate limiting, let’s first discuss how it is different from QoS and how it interacts with traffic in the vSwitch.

Whereas QoS executes on traffic that is egress or transmitted from a port on OVS, rate limiting is configured in OVS with DPDK to operate only on ingress traffic received on the port on the vSwitch. Rate limiting is implemented in OVS with DPDK using an ingress policer (similar to the egress policer QoS type supported by OVS with DPDK). An ingress policer simply drops packets once a certain reception rate is surpassed on the interface (a token bucket implementation). For a physical device, the ingress policer will drop traffic that is received via a NIC from outside the host. For a virtual interface, that is, a DPDK vhost-user port, it will drop traffic that is transmitted from the guest to the vSwitch, in effect limiting the transmission rate of the traffic for the guest on that port. Figure 1 provides an illustration of this.

Figure 1: Rate Limiting via an ingress policer configured for a vhost-user port.

Test Environment

Figure 2: Test environment.

Note: Both the host and the virtual machines (VMs) used in this setup run Fedora* 23 Server 64-bit with Linux* kernel 4.4.6. Each VM has a virtual NIC that is connected to the vSwitch bridge via a DPDK vhost-user interface. The vnic appears as a Linux kernel device (for example, "ens0") in the VM OS. Ensure there is connectivity between the VMs (for example, ping VM2 from VM1).

Rate Limiting Configuration and Testing

To test the configuration, make sure iPerf* is installed on both VMs. Users should ensure that the rpm version is matched to the OS guest version; in this case the Fedora 64-bit rpm should be used. If using a package manager such as ‘dnf’ on Fedora 23, the user can install iPerf automatically with the following command:

dnf install iperf

To test the configuration, make sure that iPerf is installed on both VMs. iPerf can be run in a client mode or server mode. In this example, we will run the iPerf client on VM1 and the iPerf server on VM2.

Test Case without Rate Limiting Configured

From VM2, run the following to deploy an iPerf server in UDP mode on port 8080:

iperf –s –u –p 8080

From VM1, run the following to deploy an iPerf client in UDP mode on port 8080 with a transmission bandwidth of 100 Mbps:

iperf -c 7.7.7.2 -u -p 8080 -b 100m

This will cause VM1 to attempt to transmit UDP traffic at a rate of 100 Mbps to VM2. After 10 seconds, this will output a series of values. Run these commands before rate limiting is configured, and you will see results similar to Figure 3. We are interested in the Bandwidth column in the server report.

Figure 3: Output without Rate Limiting via ingress policing configured.

The figures shown in Figure 3 indicate that a bandwidth of 100 Mbps was attained between the VMs.

Test Case with Rate Limiting Ingress Policer Configured

Now we’ll configure rate limiting using an ingress policer on vhost-user1 to police traffic at a rate of 10 Mbps with the following command:

ovs-vsctl set interface vhost-user1 ingress_policing_rate=10000
ingress_policing_burst=1000

The relevant parameters are explained below:

• ingress_policing_rate: The maximum rate (in Kbps) that this VM should be allowed to send. For ingress policer creation, this value is mandatory. If no value is specified, the existing rate limiting configuration will not be modified.
• ingress_policing_burst: Measured in kb and represents a token bucket. At a minimum this parameter should be set to the expected largest size packet. If no value is specified, the default is 8000 kb.

Repeating the iPerf UDP bandwidth test now, we see something similar to Figure 4.

Figure 4: Output with Rate Limiting via ingress policing configured.

Note the attainable bandwidth with ratl Limiting configured is now 9.59 Mbps rather than 100 Mbps. iPerf has sent UDP traffic at the 100 Mbps bandwidth from its client on VM1 to its server on VM2, however the traffic has been policed on the vSwitch vhost-user1 ports reception path via Rate Limiting using an ingress policer. This has limited the traffic transmitted from the iPerf client on VM1 to ~10 Mbps.

It should be noted that if using TCP traffic, the ingress_policing_burst parameter should be set at a sizable fraction of the ingress_policing_rate; a general rule of thumb is > 10%. This is because TCP interacts poorly when packets are dropped, which causes issues with packet retransmission.

The current rate limiting configuration for vhost-user1 can be examined with:

ovs-vsctl list interface vhost-user1

To remove the rate limiting configuration from vhost-user1, simply set the ingress policing rate to 0 as follows (you do not need to set the burst size):

ovs-vsctl set interface vhost-user1 ingress_policing_rate=0

Conclusion

In this article, we have shown a simple use case where traffic is transmitted between 2 VMs over Open vSwitch* with DPDK configured with rate limiting via an ingress policer. We have demonstrated utility commands to configure Rate Limiting on a given DPDK port, how to examine current Rate Limiting configuration details, and finally how to clear a Rate Limiting configuration from a port.

Additional Information

For more details on rate limiting usage, parameters, and more, refer to the rate limiting sections detailed in the vswitch.xml and ovs-vswitchd.conf.db.

Have a question? Feel free to follow up with the query on the Open vSwitch discussion mailing thread.

To learn more about Open vSwitch* with DPDK, check out the following videos and articles on Intel® Developer Zone and Intel® Network Builders University.

QoS Configuration and usage for Open vSwitch* with DPDK

Open vSwitch* with DPDK Architectural Deep Dive

DPDK Open vSwitch*: Accelerating the Path to the Guest

About the Author

Ian Stokes is a network software engineer with Intel. His work is primarily focused on accelerated software switching solutions in user space running on Intel® architecture. His contributions to Open vSwitch* with DPDK include the OVS DPDK QoS API and egress/ingress policer solutions.

Every day, our team spends hours reading the latest on app development, user experience, monetization, marketing and more. We learn new things, debate how successful a new strategy may be, and take meticulous notes on particularly insightful ideas. So when we come across a really interesting read, we like to share it.

Check out these articles to see what we thought was interesting in the world of app development in May.

App Store Optimization - Where Does App-Store-Optimization Fit in the Context of Mobile Strategy?
App Store Optimization (ASO) is a big theme in this months must read’s list, and rightly so. The app marketplace has hit a point of maturity where the numbers are high and the value of many apps is low. So where does one start with ASO? How does it fit into your mobile strategy? Roger Woods touches on three key factors that are critical to a successful ASO and mobile strategy – competition, loyalty, and acquisition.

User Engagement & Retention - 5 Tips to Improve Apps’ Retention, Engagement & Conversion (Infographic)
Do you have your user engagement and retention practices down pat? Research continues to show users are downloading apps to open them once, and then delete them shortly after. Taking that into account, plus the rising average cost per install, app publishers need to focus more on engagement and retention. Getting a user to download your app isn't enough anymore. This article highlights the importance of personalization and timing when it comes to marketing, user engagement and in-app interactions.

Market Trends– Mary Meeker’s Essential 2016 Internet Trend Report
The fastest way to get up to speed on what’s happening in the world of tech is to read Mary Meeker’s Essential Trend Reports. Renowned for providing the most comprehensive overview of digital trends, this report sheds light on everything from global internet trends to smartphone adoption to digital advertising numbers and more. If your read nothing else, this report alone will give you everything you need to have a solid grasp of the internet in 2016.

App Design  - Mobile App Development: How to Create A Useful App by Google
Have you read the latest article from Think with Google on creating useful apps through market research? Bethany Poole, Group Marketing Manager at Google, discusses the value of market research and validation in the form of a case study, outlining the approach used to create the Google Primer app. Why is this relevant? Poole points out the importance of delivering valuable solutions to users who are sifting through overpopulated app stores, and how app developers can leverage user feedback earlier on to make their apps stand out. Take a look at the thought process behind creating the Google Primer app.

Case Study - Advice From the Guy With Two #1 AppStore Freemium Games: How to Adapt to a Changing App Market
App stores will forever be a make it or break it factor, as they often are first points of engagement for your customers.  In order to stand out from the crowd, app developers and publishers are starting to think outside of the box – but how do you be creative in marketing your app without breaking the bank? Check out this podcast by Eric Seufert, an indie game publisher who is responsible for two #1 app store freemium game listings. He shares his perspective on the constantly changing app market, the increasing cost of app marketing and power of virality as an app publisher.
 

Did you read anything interesting this month? Share the link in the comments below!

By Jonathan Rodriguez

Are you finding it hard to provide your users with a touch-friendly option on 2-in-1 devices? This is a common problem related to Web-based UIs, because most browsers do not easily reveal the current state of the OS, between desktop and tablet mode. So you are left with the agonizing questions: How do I find out? And after I find out, what do I do to make my UI touch-friendly? Read on for some suggestions.

One of the things you will encounter while making your Web-based UI touch-friendly, is how hard this can be to execute once you take into account the many Web browsers through which your UI may be rendered (I apologize for the irony, there – it was intended.) But why is it so hard to implement what should be such a simple option? And if it is so hard, what is the simplest option?

One of the reasons why you may be struggling to deploy a Web-based, touch-friendly option has its roots in the past. If you are familiar with the original Nintendo* gaming console and Michael Jackson’s Billie Jean song, you are probably old enough to remember how chaotic technology was in the mid-'90's. Back then, Web browsers allowed many questionable things to happen, “…thereby, making the world a [worse] place.” (a reference to the opposite of that statement, which many startups claim to be doing. I watch Silicon Valley. L.O.L.)

But seriously, the Internet was a dangerous place back then. Computer systems could get hacked due to the most illogical Web browser technicalities.

But we learned and evolved. And as a result of that dark past, these days, for security purposes, Web browsers are much more limiting. Additionally, some codes are simply not supported by some of the rendering engines (which execute the actual rendering of the pages within Web browsers), also with security in mind. Have you ever tried a piece of code that worked perfectly fine in one browser, but not in another? Now you get the gist.

Now, here comes the good stuff...

Due to the aforementioned Web browser limitations, when it comes to Web-based, touch-friendly development, almost every developer tends to resort to an approach that I call “Mode-Whispering.” Mode-Whispering refers to any method used to "fool" certain Web browsers into giving away the current state (Desktop or Tablet mode) of the OS, indirectly.

While the browser is not technically “whispering” anything to anybody, the code does the “whispering” to another section within itself. Most of these Mode-Whispering codes involve placing JavaScript* codes that are able to count the available pixels (within the screen) in order to determine whether a scroll bar is present within the Web browser. If it is, the code then uses an algorithm to determine the size of that scroll bar. This approach gracefully determines the OS state between the Desktop and Tablet modes (because Desktop and Tablet modes generate different sizes of scroll bars.)

While Mode-Whispering can work (mostly in Microsoft Edge*), I strongly recommend against using this approach. First, Mode-Whispering will not work unless your page is long enough to require a scroll bar from the Web browser (Web browsers will only show a scroll-bar if it is necessary.) But the main issue with Mode-Whispering is that your UI will have a piece of code (and icon/link) that will work in some browsers, but not in many others. Which could make your UI and user experience seem sub-par.

Since choosing the experience for your users, automatically, is not currently a viable or reliable option from a Web-based UI, why not tap into the human element and use it as your best ally? Simply let your users decide whether they want a touch-friendly experience in the first place. I call this approach “Manual-Moding.”

If you think about it, Manual-Moding makes sense. Unlike Mode-Whispering (which is done secretly in the background—deceitfully, at least from the Web browser’s perspective), Manual-Moding consists of a simple (straightforward) user-friendly option, preferably a button that your users can click, based on their preferences. This is the way the BitMar* premium TV platform deploys its touch-friendly option. Visit http://BitMar.com to see the Web-based app in action. (Full disclosure: I am the designer and developer behind BitMar.)

In order to deploy a Manual-Moding option, you will need to frame the top portion of your UI (using either an iFrame or Frameset) and have two, distinct top-section pages: A Desktop and a Touch version—each with different-size images and/or links. Obviously, the larger image/font version is recommended for Touch mode. And the smaller-size version is for Desktop mode. Both pages will have to inter-link (link to each other) within the same frame, preferably using the same or similar icon/s (just as you can see happening on http://BitMar.com.)  

Are there any disadvantages to implementing Manual-Moding? You bet—it’s not a perfect world. Although supported by every major Web browser (including mobile devices), Framesets are officially not part of the HTML5 standard (which is, arguably, the future of websites and Web-based apps.) However, unlike Framesets, iFrames are included in the standard. But HTML5-friendly iFrames may disable scripts and other page functionality. Therefore, it is recommended that you use Manual-Moding only within the top and side portions of your UI (that is, for the navigation menu and/or any other static menus and options). Otherwise, you risk having a UI that may not work properly in some Web browsers (because in the HTML5 standard, most Web browsers do not allow scripts to execute from any page that is rendered through an iFrame.) In the case of BitMar, the execution consists of two PHP pages, inter-linking, within the same frame. But you can do this with any type of page (.htm, .html, .asp, .php, and so on).

So, just make the "correct" choice (based on your situation), or be open to updating your UI, should the Frameset officially die out. But, whatever the case, at least now you have two options. And one of them provides your users a universal touch-switch option that will work in any environment.

Acknowledgements

About the Author and Company

Jonathan Rodriguez is the founder and CEO of BitMar Networks (the firm behind the BitMar premium TV platform.) BitMar is an Internet TV portal that provides access to millions of free, premium TV shows and movies (mostly in HD), over 200,000 channels, live radio and millions of songs (all in one single place, from safe, legal sources.) BitMar could be your free and legal alternative to expensive TV service, Netflix, Hulu, and so on. You may learn more at: http://BitMar.com

The BitMar name is a combination of "bit" (the basic unit of information in computing and digital communications) and "mar" (a synonym for "break", "impair" and "disfigure"). The adaptation of "mar" in the BitMar context reflects disruption.