Slash Your MSC Nastran* Simulation Runtimes by Up to 50 Percent

Doubling performance for your most complex MSC Nastran simulations can deliver a range of high-value options for your engineering and design teams. You may be able to obtain results hours or even days sooner to shorten your design cycles. Or you may choose to test more design options to accelerate innovation, or explore a wider range of coupled variables to gain a deeper understanding of real-world product behavior.

DownloadDownload

Achieve Fast, Scalable ETL with Apache Hadoop* Running on Intel® Architecture

Organizations across public and private sectors are gathering and analyzing “big data” to forecast market conditions more accurately and to make better decisions about the issues that are most critical to their success. They sort through vast amounts of data from weather and economic reports, discussion forums, news sites, social networks, wikis, tweets, and blogs. They then analyze relevant data more deeply to gain new insights into their customers, operations, and competitors. Some even apply predictive analytics to identify the opportunities and risks they are most likely to face a month from now, a year from now, or even five years from now.

DownloadDownload

A Mission-Critical Big Data Platform for the Real-Time Enterprise

As the volume and velocity of enterprise data continue to grow, extracting highvalue insight is becoming more challenging and more important. Businesses that can analyze fresh operational data instantly—without the delays of traditional data warehouses and data marts—can make the right decisions faster to deliver better outcomes.
Business Oriented Solution (BOS) software from the Nomura Research Institute (NRI) answers this challenge. Running on enterprise-class servers based on the Intel® Xeon® processor E7 v3 family, BOS turns operational data into a rich source of real-time business insight. There is no need to duplicate, pre-manipulate, or move data. A highly optimized in-memory database schema enables transactions and queries to be performed simultaneously and at high speed on the same data set.

DownloadDownload

ANSYS® and Intel Team Up to Shrink Simulation Timelines

ANSYS, a world leader in simulation software, announced on March 12 that its premier engineering simulation software product, ANSYS* Mechanical APDL 16.0 (ANSYS Mechanical 16.0), will ship with built-in, optimized support for Intel® Xeon Phi™ coprocessors.

Structural engineers and designers using ANSYS Mechanical 16.0 will be able to tap into the power and performance of highly-parallelized, multicore processing to speed engineering workloads, and at an affordable price.

Combine ANSYS Mechanical* with the Intel® Xeon Phi™ Coprocessor for Dramatic Performance gains in both Windows* and Linux* Environments

Incremental performance gains for engineering simulations can improve productivity and shrink product development timelines and time to market. Doubling performance can transform entire workflows, allowing design teams to run more and larger simulations in less time to improve innovation, quality, safety, reliability, manufacturability, and time to market.

Intel® Xeon Phi™ Coprocessor Applications and Solutions Catalog

This document contains a growing list of available, downloadable or work in progress code that can be run, or is actively being optimized to run on Intel® Xeon Phi™ coprocessors.

Software Defined Storage with Intel® Enabling Technologies

Software-Defined Storage (SDS) is a software layer that manages storage infrastructure.  Software developers have the flexibility to use a variety of hardware, such as processors, network cards, and hard drives with their storage managing software to develop their own SDS solutions.  We share some examples of developers using Intel enabling technologies (features of the hardware and/or software) to develop their SDS solutions. 

Creating a New Standard in Virtual Crash Testing

Altair advances frontal crash simulation with help from Intel® Software Development products. By using state-of-the-art hybrid programming mixing different parallelization techniques to achieve more scalability and deliver optimal performance for very large number of processors.

DownloadDownload

Simple Path to Dramatic Performance and Cost Improvements

Moving workloads without application changes to Red Hat Enterprise Virtualization and the Intel® Xeon® processor E5-2600 product family can help slash data center costs.

Downloadxeon-rhev-intel-redhat-brief.pdf

Performance Gains for Ayasdi Analytics* on the Intel® Xeon® Processor E7-8890 V3

Ayasdi deploys vertical applications that utilize Topological Data Analysis to extract value from large and complex data. The Ayasdi platform incorporates statistical, geometric, and machine-learning methods through a topological framework to more precisely segment populations, detect anomalies, and extract features.

Performance Gains for SunGard’s Adaptiv Analytics* on the Intel® Xeon® Processor E7-8890 V3

SunGard’s Adaptiv Analytics* allows traders to run pre-deal cost-of-credit calculations. Due to the volume and complexity of products, these calculations are often time consuming, causing delays that can lead to missed opportunities or taking action with incomplete information.

Introduction

FreeType is a font service middleware that is written in industry-standard ANSI C. It comes with the build system that is based on GNU Make. The native development kit (NDK) is a toolset that allows you to implement C and C++ in Android apps, auto-generate project and build files, build native libraries, copy the libraries into appropriate folders, and more. For more information on the NDK, see http://developer.android.com/tools/sdk/ndk/index.html. To download and install the latest NDK build, go to http://developer.android.com/ndk/downloads/index.html.

There are many ways to build middleware libraries. You can compile middleware using an automatic NDK build system. Alternatively, you can cross-compile middleware from Cygwin* using the standalone toolchain option. For the list of some Android* middleware libraries that support x86, visit https://software.intel.com/en-us/blogs/2015/06/26/building-android-middleware-libraries-for-x86-devices-using-the-android-ndk. In this document, we’ll describe how to configure Eclipse* to set up an automatic NDK build for FreeType.

Creating a New Android* Application Project in Eclipse

For detailed instruction of how to create a new Android application project in Eclipse*, see http://developer.android.com/tools/projects/projects-eclipse.html. After you have created a new Android* application project, create a “jni” folder inside the Android project as shown below:

Figure 1: Create a jni folder

Downloading the FreeType Library

To download the latest FreeType middleware, browse to http://sourceforge.net/projects/freetype/files/freetype2. As of this writing, the latest FreeType version is 2.6. Change to the jni directory, and untar the freetype-2.6.tar.gz using a cgwin or Linux* console.

Figure 2: FreeType source files under the jni folder

Adding Android.mk and Application.mk into the Android* Project

Android.mk and Application.mk are located in the subdirectory jni of the Android* application project. Android.mk is a GNU makefile that the build system parses. Android.mk specifies source files and shared libraries to the build system. For a description of the syntax of the Android.mk build file for the C and C++ source files to link to the Android* NDK, go to https://developer.android.com/ndk/guides/android_mk.html. Create the native code makefile Android.mk in the subdirectory jni for all FreeType fonts, which looks like this:

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

FREETYPE_SRC_PATH :=

LOCAL_MODULE := freetype

LOCAL_CFLAGS := -DANDROID_NDK \
  -DFT2_BUILD_LIBRARY=1

LOCAL_C_INCLUDES := $(LOCAL_PATH)/include_all \
  $(FREETYPE_SRC_PATH)include \
  $(FREETYPE_SRC_PATH)src

LOCAL_SRC_FILES := \
 $(FREETYPE_SRC_PATH)src/autofit/autofit.c \
 $(FREETYPE_SRC_PATH)src/base/basepic.c \
 $(FREETYPE_SRC_PATH)src/base/ftapi.c \
 $(FREETYPE_SRC_PATH)src/base/ftbase.c \
 $(FREETYPE_SRC_PATH)src/base/ftbbox.c \
 $(FREETYPE_SRC_PATH)src/base/ftbitmap.c \
 $(FREETYPE_SRC_PATH)src/base/ftdbgmem.c \
 $(FREETYPE_SRC_PATH)src/base/ftdebug.c \
 $(FREETYPE_SRC_PATH)src/base/ftglyph.c \
 $(FREETYPE_SRC_PATH)src/base/ftinit.c \
 $(FREETYPE_SRC_PATH)src/base/ftpic.c \
 $(FREETYPE_SRC_PATH)src/base/ftstroke.c \
 $(FREETYPE_SRC_PATH)src/base/ftsynth.c \
 $(FREETYPE_SRC_PATH)src/base/ftsystem.c \
 $(FREETYPE_SRC_PATH)src/cff/cff.c \
 $(FREETYPE_SRC_PATH)src/pshinter/pshinter.c \
 $(FREETYPE_SRC_PATH)src/pshinter/pshglob.c \
 $(FREETYPE_SRC_PATH)src/pshinter/pshpic.c \
 $(FREETYPE_SRC_PATH)src/pshinter/pshrec.c \
 $(FREETYPE_SRC_PATH)src/psnames/psnames.c \
 $(FREETYPE_SRC_PATH)src/psnames/pspic.c \
 $(FREETYPE_SRC_PATH)src/raster/raster.c \
 $(FREETYPE_SRC_PATH)src/raster/rastpic.c \
 $(FREETYPE_SRC_PATH)src/sfnt/pngshim.c \
 $(FREETYPE_SRC_PATH)src/sfnt/sfntpic.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttbdf.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttkern.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttload.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttmtx.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttpost.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttsbit.c \
 $(FREETYPE_SRC_PATH)src/sfnt/sfobjs.c \
 $(FREETYPE_SRC_PATH)src/sfnt/ttcmap.c \
 $(FREETYPE_SRC_PATH)src/sfnt/sfdriver.c \
 $(FREETYPE_SRC_PATH)src/smooth/smooth.c \
 $(FREETYPE_SRC_PATH)src/smooth/ftspic.c \
 $(FREETYPE_SRC_PATH)src/truetype/truetype.c \
 $(FREETYPE_SRC_PATH)src/type1/t1driver.c \
 $(FREETYPE_SRC_PATH)src/cid/cidgload.c \
 $(FREETYPE_SRC_PATH)src/cid/cidload.c \
 $(FREETYPE_SRC_PATH)src/cid/cidobjs.c \
 $(FREETYPE_SRC_PATH)src/cid/cidparse.c \
 $(FREETYPE_SRC_PATH)src/cid/cidriver.c \
 $(FREETYPE_SRC_PATH)src/pfr/pfr.c \
 $(FREETYPE_SRC_PATH)src/pfr/pfrgload.c \
 $(FREETYPE_SRC_PATH)src/pfr/pfrload.c \
 $(FREETYPE_SRC_PATH)src/pfr/pfrobjs.c \
 $(FREETYPE_SRC_PATH)src/pfr/pfrsbit.c \
 $(FREETYPE_SRC_PATH)src/type42/t42objs.c \
 $(FREETYPE_SRC_PATH)src/type42/t42parse.c \
 $(FREETYPE_SRC_PATH)src/type42/type42.c \
 $(FREETYPE_SRC_PATH)src/winfonts/winfnt.c \
 $(FREETYPE_SRC_PATH)src/pcf/pcfread.c \
 $(FREETYPE_SRC_PATH)src/pcf/pcfutil.c \
 $(FREETYPE_SRC_PATH)src/pcf/pcfdrivr.c \
 $(FREETYPE_SRC_PATH)src/psaux/afmparse.c \
 $(FREETYPE_SRC_PATH)src/psaux/psaux.c \
 $(FREETYPE_SRC_PATH)src/psaux/psconv.c \
 $(FREETYPE_SRC_PATH)src/psaux/psobjs.c \
 $(FREETYPE_SRC_PATH)src/psaux/t1decode.c \
 $(FREETYPE_SRC_PATH)src/tools/apinames.c \
 $(FREETYPE_SRC_PATH)src/type1/t1afm.c \
 $(FREETYPE_SRC_PATH)src/type1/t1gload.c \
 $(FREETYPE_SRC_PATH)src/type1/t1load.c \
 $(FREETYPE_SRC_PATH)src/type1/t1objs.c \
 $(FREETYPE_SRC_PATH)src/type1/t1parse.c\
 $(FREETYPE_SRC_PATH)src/bdf/bdfdrivr.c\
 $(FREETYPE_SRC_PATH)src/bdf/bdflib.c\
 $(FREETYPE_SRC_PATH)src/gzip/ftgzip.c\
 $(FREETYPE_SRC_PATH)src/lzw/ftlzw.c \


LOCAL_LDLIBS := -ldl -llog

include $(BUILD_SHARED_LIBRARY)

Code Sample 1: Android.mk

The NDK build system generates machine code for armeabi by default. To add support to the Intel® architecture, simply add x86 to the APP_ABI variable in jni/Application.mk. You can specify multiple architectures on the same line using space delimited.

APP_ABI := armeabi-v7a x86 #can also be x86_64, armeabi, arm64-v8a, mips, mips64

To generate machine code for all supported instruction sets:

APP_ABI := all #can also be all32 or all64

APP_PLATFORM specifies the name of the target Android* platform. Create the simple native modules build file Application.mk in the subdirectory jni as below:

APP_ABI :=all
APP_PLATFORM := android-20

Code Sample 2: Application.mk

Figure 3: Setting APP_ABI in Application.mk

Setting Up Automatic NDK Builds

The first step is to configure the Builders for the project, then select which Builders to enable for the project.

• Right-click your Android* project, and then choose properties.
• To add the new builder to the list, select Builders on the left side, and then click the New button.

Figure 4: Project properties

• From the list of configuration types, select Program. The program option allows you to define an external tool location and how to execute the script.

Figure 5: Configuration type

• Name: Type the name of the new builder.
• Location: Location of the ndk-build.cmd.
• Working Directory: Browse to the working project.

Figure 6: NDK configuration

Building the Project

After the project successfully built, all the libfreetype.so files for all the supported architectures are placed under /lib<APP_ABI>. The <APP_ABI> is x86, x86_64, armeabi, arm64-v8a, armeabi-v7a, mips, or mips64, depending how you set it in APP_ABI in Application.mk.

Figure 7: libfreetype.so for x86 devices

Summary

We have described how to set APP_ABI in Application.mk and generate libfreetype.so libraries for x86 devices using an automatic NDK build system.

References

• FreeType: http://www.freetype.org/freetype2/docs/index.html
• Android* application in Eclipse*: http://developer.android.com/tools/projects/projects-eclipse.html
• Android* NDK: http://developer.android.com/tools/sdk/ndk/index.html
• Android.mk: https://developer.android.com/ndk/guides/android_mk.html
• Application.mk: https://developer.android.com/ndk/guides/application_mk.html
• Building Android* middleware libraries for x86 devices: https://software.intel.com/en-us/blogs/2015/06/26/building-android-middleware-libraries-for-x86-devices-using-the-android-ndk

About the Author

Nancy Le is a software engineer at Intel® Corporation in the Software and Services Group working on Intel® Atom™ processor scale-enabling projects.

Multi-OS Engine enables developers to:

• Create cross-OS (Android* and iOS*) and cross-platform (IA and ARM) applications using shared Java*/C++* app logic code
• Design native look-and-feel UI using common tools within Android Studio*
• Build and deploy Android* and iOS* apps from within Android Studio* running on Mac OS X* and Windows* hosts

This page provides the Release Notes for Multi-OS Engine with the most recent being listed at the top of the page. For more details, please take a look at the documents on the table below.

Customer Support

For technical support of Multi-OS Engine, including answers to questions not addressed in this product, latest online getting started help, visit the Technical Support Forum, FAQs, and other support information at the Product Page. For quick peek on Tutorials & Quick Start Guides visit our blogs.

The dark underbelly of the carnival has captured audience attention as an archetype of mystery in movies and games.

Halloween is a time when we collectively let our fantasies and worst fears loose, where fun and terror seem to blend together. One of the archetype backdrops for this special brand of scared is the carnival. What is it about amusement parks that make them so ripe for mystery and horror? Last August, vigilante artist Banksy created a whole installation called “Dismaland” in Somerset, England that used the carnival theme as a backdrop for some biting social commentary.

It might be because the era of the circus feels like an antiquated medium of entertainment compared to the latest 3D blockbuster or virtual reality, that the carousel and the funhouse seem decrepit next to shinier productions and big explosions.

Or maybe it’s that the whole enterprise of the amusement park is dedicated to manufacturing fun, and that human nature derives a certain amount of satisfaction from peering behind a happy curtain to find something monstrous. Historically, traveling carnivals were “home” to society’s outcasts where the public could project its fantasies and fears onto the pageantry.

Countless horror movies have chosen dilapidated theme parks as their backdrop, where the cheerful veneer of the big top tent peels to reveal something sinister. Clowns and freaks terrorize an adventurous group of teens, or zombies run amok with a charming calliope as background music. The ironic contrast of blinking lights and painted-on performer expressions juxtaposes with mystery and murder in a way that is totally arresting. And strangely fun.

Our sensibilities may have changed, but desire to get scared out of our wits is still there, perhaps even more articulated and elaborate in the digital era. With the tremendous strides that technology has made, stories, games, and photos have taken on such a life-like quality that it is hard to distinguish them from real life. The vicarious thrill of the chase, for example, has driven the gaming industry to whole new heights, and the level of interaction we experience is surprisingly heart pounding.

One standout in this strange subgenre of spook is Weird Park –Final Show, a gaming app by Alawar, where players must solve a bizarre abduction partly set in an abandoned theme park. A young boy is missing after entering his closet, and the whole community is up in arms trying to figure out what happened. Days after Patrick disappeared, aggressive animatronic toys suddenly invaded his house and authorities were forced to seal it off.

Unbeknownst to the whole town, the boy has been sequestered to an alternate dimension by the evil clown Mr. Dudley. Enter the dark arts of the carney folk.

The game takes you as an investigative journalist on an elaborate and unsettling adventure where reality and illusion are equally deceptive. Armed with your most powerful tool– your journal– you must retrace the missing boy’s last locations to an amusement park that is rife with clues and creepy characters.

Drawn in extraordinary lush detail with artfully eerie music, the Weird Park­ – Final Show app available on enabled for devices powered by Intel® Core™ Processors, is a serial critical thinking mystery wrapped in a carnival masquerade. The developers have gone to tremendous lengths to blend in black magic and 26 mini-games into 54 stunning environments taking players on a marvelous adventure. The perfect game for Halloween, solve the mystery of Weird Park – Final Show, visit: http://www.alawar.com/game/weird-park-the-final-show/.

The zombie-slayer gaming genre locks and loads just in time for the most terrifying of holidays.

Something sinister this way comes. It’s that time of year to don a disguise and get scared out of your skin. Halloween leaves some treats and tricks at your doorstep, but watch out! All the creepy creatures, monsters and mysteries come out of hiding in these new apps for your Intel-powered devices.

Zombie City Defense is as terrifying as it sounds. The virtual city is under attack and the threat is so real and so menacing, players must break out the big guns. This army style-garrison defense strategy game puts your vigilante skills to the test. The more missions you complete, the more feet your team has on the ground. Each mission rewards gamers with tech points that they can trade for vehicles, training and gear. Mozg Labs had the ingenuity to model the game after night vision, giving it a neon x-ray style that looks mind-blowing on the high-definition screens.

Can’t get enough of the zombie-slaying action? Your sharp shooting skills reach their limit with Last Hope - Zombie Sniper 3D by JE Software. Defend yourself against the undead hordes! The once familiar landscape is now a wasteland of destruction and desertion, but at any turn, the droves of living dead can attack. This gaming app is so real– survival depends upon accuracy, while progress unlocks new experience levels. It’s a cold and desolate landscape that crisp and responsive CGI makes the menacing zombies a true terror.

Or maybe, School of Chaos MMORPG will satisfy the escape fantasy like a zombie attack on the teachers! Kids run wild and hide in lockers as the flesh-eating combat masters attempt to take over the school. No teachers, no supervision, no rules! Block-style, comic animation, lightning-fast action and a very twisted plot gets trick-or-treaters pumped up for some sneaky hijinks. This action, hand-to-hand combat game is a wildly entertaining contribution from VNL Entertainment.

If the total onslaught of zombie apocalypse is simply too life-like, try the creepy carnival mystery of Weird Park- The Final Show by Alawar. A young boy has stepped into a closet and vanished into another dimension. The community searches for the missing boy, but the bizarre alternate reality is invisible to them. Who is the twisted mind that created this other world? Players become investigative reporters and unlock the secret of the boy’s disappearance. Stunning, realistic graphics set in a bizarre amusement park drive the addictive, suspenseful narrative and make this game a non-stop thrill on the latest devices.

Another Halloween favorite is the all-ages Alien Jump- Lab Escape app from Big Hut. He may seem cute, but he’s smarter than he seems. Zippy the Alien is plotting his escape from the evil scientists who hold him in captivity– it’s up to you to help him break free! This point-based platformer offers over 60 levels filled with dangerous traps, powerups and jetpacks, plus coins that can pay from upgrades.

Whatever your particular flavor of fright is, these spooktackular apps for your Intel-powered device, bring the Halloween spirit to life in an eerie and electrifying way. Fluid, dynamic action and truly creative design means the zombie hunt, supernatural sleuthing and alien liberation can continue late into the night.

Deep neural network (DNN) training is computationally intensive and can take days or weeks on modern computing platforms. In the recent article, Single-node Caffe Scoring and Training on Intel® Xeon® E5 Family, we demonstrated a tenfold performance increase of the Caffe* framework on the AlexNet* topology and reduced the training time to 5 days on a single node. Intel continues to deliver on the machine learning vision outlined in Pradeep Dubey’s Blog, and in this technical preview, we demonstrate how the training time for Caffe can be reduced from days to hours in a multi-node, distributed-memory environment.

Caffe is a deep learning framework developed by the Berkeley Vision and Learning Center (BVLC) and one of the most popular community frameworks for image recognition. Caffe is often used as a benchmark together with AlexNet*, a neural network topology for image recognition, and ImageNet*, a database of labeled images.

The Caffe framework does not support multi-node, distributed-memory systems by default and requires extensive changes to run on distributed-memory systems. We perform strong scaling of the synchronous minibatch stochastic gradient descent (SGD) algorithm with the help of Intel® MPI Library. Computation for one iteration is scaled across multiple nodes, such that the multi-threaded multi-node parallel implementation is equivalent to the single-node, single-threaded serial implementation.

We use three approaches—data parallelism, model parallelism, and hybrid parallelism—to scale computation. Model parallelism refers to partitioning the model or weights into nodes, such that parts of weights are owned by a given node and each node processes all the data points in a minibatch. This requires communication of the activations and gradients of activations, unlike communication of weights and weight gradients, as is the case with data parallelism.

With this additional level of distributed parallelization, we trained AlexNet on the full ImageNet Large Scale Visual Recognition Challenge 2012 (ILSVRC-2012) dataset and reached 80% top-5 accuracy in just over 5 hours on a 64-node cluster of systems based on Intel® Xeon® processor E5 family.

Getting Started

While we are working to incorporate the new functionality outlined in this article into future versions of Intel^® Math Kernel Library (Intel^® MKL) and Intel^® Data Analytics Acceleration Library (Intel^® DAAL), you can use the technology preview package attached to this article to reproduce the demonstrated performance results and even train AlexNet on your own dataset. The preview includes both the single-node and the multi-node implementations. Note that the current implementation is limited to the AlexNet topology and may not work with other popular DNN topologies.

The package supports the AlexNet topology and introduces the ‘intel_alexnet’ and ‘mpi_intel_alexnet’ models, which are similar to ‘bvlc_alexnet’ with the addition of two new ‘IntelPack’ and ‘IntelUnpack’ layers, as well as the optimized convolution, pooling, normalization layers, and MPI-based implementations for all these layers. We also changed the validation parameters to facilitate vectorization by increasing the validation minibatch size from 50 to 256 and reducing the number of test iterations from 1,000 to 200, thus keeping constant the number of images used in the validation run. The package contains the ‘intel_alexnet’ model in these folders:

• models/intel_alexnet/deploy.prototxt
• models/intel_alexnet/solver.prototxt
• models/intel_alexnet/train_val.prototxt.

• models/mpi_intel_alexnet/deploy.prototxt
• models/mpi_intel_alexnet/solver.prototxt
• models/mpi_intel_alexnet/train_val.prototxt.
• models/mpi_intel_alexnet/train_val_shared_db.prototxt
• models/mpi_intel_alexnet/train_val_split_db.prototxt

Both the ’intel_alexnet’ and the ’mpi_intel_alexnet’ models allow you to train and test the ILSVRC-2012 training set.

To start working with the package, ensure that all the regular Caffe dependencies and Intel software tools listed in the System Requirements and Limitations section are installed on your system.

Running on Single Node

1. Unpack the package.
2. Specify the paths to the database, snapshot location, and image mean file in these ‘intel_alexnet’ model files:
   • models/intel_alexnet/deploy.prototxt
   • models/intel_alexnet/solver.prototxt
   • models/intel_alexnet/train_val.prototxt
3. Set up a runtime environment for the software tools listed in the System Requirements and Limitations section.
4. Add the path to ./build/lib/libcaffe.so to the LD_LIBRARY_PATH environment variable.
5. Set the threading environment as follows:
   $> export OMP_NUM_THREADS=<N_processors * N_cores>
   $> export KMP_AFFINITY=compact,granularity=fine

Note: OMP_NUM_THREADS must be an even number equal to at least 2.

1. Run timing on a single node using this command:
   $> ./build/tools/caffe time \
          -iterations <number of iterations> \
          --model=models/intel_alexnet/train_val.prototxt
2. Run training on a single node using this command:
   $> ./build/tools/caffe train \
          --solver=models/intel_alexnet/solver.prototxt

Running on Cluster

1. Unpack the package.
2. Set up a runtime environment for the software tools listed in the System Requirements and Limitations section.
3. Add the path to ./build-mpi/lib/libcaffe.so to the LD_LIBRARY_PATH environment variable.
4. Set the NP environment variable to the number of nodes to be used, as follows:

$> export NP=<number-of-mpi-ranks>

Note: the best performance is achieved with one MPI rank per node.

1. Create a node file in the root directory of the application with the name of x${NP}.hosts. For instance, for IBM* Platform LSF*, run the following command:

$> cat $PBS_NODEFILE > x${NP}.hosts

1. Specify the paths to the database, snapshot location, and image mean file in the following ‘mpi_intel_alexnet’ model files:
   • models/mpi_intel_alexnet/deploy.prototxt,
   • models/mpi_intel_alexnet/solver.prototxt,
   • models/mpi_intel_alexnet/train_val_shared_db.prototxt

Note: on some system configurations, performance of a shared-disk system may become a bottleneck. In this case, pre-distributing the image database to compute nodes is recommended to achieve best performance results. Refer to the readme files included with the package for instructions.

1. Set the threading environment as follows:

$> export OMP_NUM_THREADS=<N_processors * N_cores>
$> export KMP_AFFINITY=compact,granularity=fine

Note: OMP_NUM_THREADS must be an even number equal to at least 2.

1. Run timing using this command:
   $> mpirun -nodefile x${NP}.hosts -n $NP -ppn 1 -prepend-rank \

         ./build/tools/caffe time \

         -iterations <number of iterations> \

        --model=models/mpi_intel_alexnet/train_val.prototxt

1. Run training using this command:
   $> mpirun -nodefile x${NP}.hosts -n $NP -ppn 1 -prepend-rank \

         ./build-mpi/tools/caffe train \

         --solver=models/mpi_intel_alexnet/solver.prototxt

System Requirements and Limitations

The package has the same software dependencies as non-optimized Caffe:

• boost* 1.53.0
• opencv* 2.4.9
• protobuf* 3.0.0-beta1
• glog* 0.3.4
• gflags* 2.1.2
• lmdb* 0.9.16
• leveldb* 1.18
• hdf5* 1.8.15
• Red Hat Enterprise Linux* 6.5 or higher

Intel software tools:

• Intel MKL 11.3 or higher
• Intel MPI Library 5.0

Hardware compatibility:

• 4^th Generation Intel® Core™ Processor (code name Haswell)

This software was validated with the AlexNet topology only and may not work with other configurations.

Support

Please direct questions and comments on this package to mailto:intel.mkl@intel.com.

The fantasy of defending humanity against zombies comes back to life in time for Halloween.

Apocalyptic themes have always captured the collective imagination, but it certainly seems to have taken hold in a new way. The film and gaming industries have seen scads of end-of-days stories where chaos reigns and society disintegrates into a mass of flesh-eating monsters. Thanks to advancements in digital technology, we can now experience the fear with shocking realism.

At this time of year, with Halloween and Dias de los Muertos (Day of the Dead) just around the corner, it’s fun to venture a guess as to the macabre appeal of the zombie mayhem. Maybe it’s because beyond the terror there is a thrill attached to the sudden absence of order, a meltdown of the system. Work and school no longer apply when our very survival is on the line. The opening scene in 28 Days Later has a somewhat harrowing shot of London’s streets completely vacant of its populace after a complete zombie takeover.

Maybe, like in Shaun of the Dead, it’s the transformation of the everyman into the superhero: we saw a lazy, aimless loafer suddenly rise to the challenge, discovering that he had a gift for zombie slaying. If that guy can defend his people against a mob of ravenous humanoids, then anyone can.

When it comes to the gaming sector, there are certainly many offerings that go all in for the guts and destruction, but many developers have seized the opportunity to branch out in several different directions, incorporating strategy, tower defense, and precision shooting with the grim task of terminating the undead as the objective.

Perhaps the zombie genre is so popular because it easily overlaps with charged military interaction and it satisfies our predator-prey instinct without breaking any rules. It’s clear who the bad guys are, and it takes some well-rounded gaming skill to conquer the siege.

A great example of this mash-up is Zombie City Defense, a next-level gaming now enabled for Intel® Atom™ processor-based tablets for Android*. That certainly qualifies as a crossover with all the excitement that accompanies high-threat strategy. This next-level game makes the hungry hoards nothing more than a suggestion, focusing on war simulation with holographic night vision-style graphics in sharp 3D. In the simulation vein, the narrative is based on building layers of strategy to combat waves of attacks and each triumph rewards the player with new military might.

Gaming bloggers have received Zombie City Defense warmly, noting that it is a standout among the plethora of tower defense because of its richly detailed cityscapes in striking x-ray visuals that give players a top down or angled view. Modeled after Google Earth*, the game allows players to zoom in and out and the landscapes become more complex as the game progresses. Multiple views of the action heighten the overall gameplay experience and each level up provides more infantry, weapons, and capabilities. After all, if you are going to take out zombies, you need all the tools and tactics you can get.

Whatever the draw is, these games see an uptick in interest around this time of year, when it is extra enticing to get totally terrified for the sake of some heart-pounding fun. The shorter days, colder weather, and of course, Halloween, set the tone for some hair-raising, and Zombie City Defense optimized for Intel-powered devices delivers some truly terrifying entertainment.

To check out Zombie City Defense, visit the Google Play store here: https://play.google.com/store/apps/details?id=com.mozglabs.citysiedge&hl=en

This Technology Insight will demonstrate how to optimize data analytics and machine learning workloads for Intel® Architecture based data center platforms.

Speaker: Pradeep Dubey Intel Fellow, Intel Labs Director, Parallel Computing Lab, Intel Corporation

Topics include:

• How to use Intel® Architecture (IA) tools for achieving high performance for core machine learning methods such as, clustering, correlation, regression, etc.
• Both single-node, as well as multi-node distributed platform optimizations
• Updates on hardware technologies and software tools innovation
• Developer tools: Intel® Analytics Toolkit for Apache Hadoop* software, Intel® Data Analytics Acceleration Library (Intel® DAAL), Intel® Math Kernel Library (Intel® MKL)

Download PDF DownloadDownload

View webcast

Reference Number: DPD200377642

Version: 2016 Initial Release and Update 1

Product: Intel(R) Parallel Studio XE

Operating System: Windows*

Problem Description:

The problem occurs when performing a custom installation of Intel(R) Parallel Studio XE 2016 on a Japanese version of Windows* OS where the custom installation specifies an installation path that contains non-English characters. This results in any documents selected from the Microsoft Visual Studio* "Help > Intel Compilers and Libraries" pull down men to fail to launch and the browser's default page appearing instead.

Workarounds:

1. Install product in the standard place or avoid non-English characters in the custom installation path.
2. Manually open the help files listed below using an internet browser:

• "<Driver letter>:\<Directory where product is installed>\samples_2016\ja\compiler_c\psxe\samples.htm for C++ Samples 
• "<Driver letter>:\<Directory where product is installed>\samples_2016\ja\compiler_f\psxe\samples.htm for Fortran Samples 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\compiler_c\common\core\index.htm" for  for Intel® C++ Compiler 16.0 User and Reference Guide 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\compiler_f\common\core\index.htm" for  for Intel® Fortran Compiler 16.0 User and Reference Guide 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\mkl\common\mkl_userguide\index.htm" for User's Guide for Intel® Math Kernel Library 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\mkl\common\mklman_c\index.htm" for Reference Manual for Intel® Math Kernel Library 11.3 - C 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\ipp\common\ipp_userguide\index.htm" for User's Guide for Intel® Integrated Performance Primitives 
•   "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\ipp\common\ipp_manual\index.htm" for Reference Manual for Intel® Integrated Performance Primitives 
• "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\tbb\common\tbb_ugref\index.htm" for Intel® Intel® Threading Building Blocks Documentation 
• "<Driver letter>:\<Directory where product is installed>\documentation_2016\ja\daal\common\daal_ur_guides\index.htm" for User and Reference Guides for Intel® Data Analytics Acceleration Library 

Resolution Status: A fix has been implemented and will appear in a future update.

The OpenSSL* library v1.0.2 introduces the multibuffer enhancements for AES. Multibuffer significantly increases the performance of CBC mode encryption by processing multiple TLS records in parallel on a single hardware thread. As shown in the white paper Improving OpenSSL Performance, the multibuffer enhancements to AES-CBC encryption can result in a 50 to 100% increase in throughput. This makes it an attractive feature for web site administrators using these ciphers, and this article explains how to enable it under two popular, open source, Linux*-based web servers: Apache* HTTP Server from the Apache Software Foundation, and nginx* from Nginx, Inc.

Multibuffer Basics

Multibuffer works by encrypting the TLS records created during a file transfer in parallel. Because of the overhead involved, however, multibuffer only works when the SSL buffers are at least 16 KB in size (where 1 KB is defined as 1024 bytes). Since the current multibuffer implementations process four data streams in parallel this means that the minimum file size required for multibuffer to engage is 64 KB.

Each TLS record is encrypted separately with CBC encryption which means each record also requires a random IV. Since those TLS records are also processed simultaneously, the multibuffer solution demands random numbers at a higher frequency: all else being equal, multibuffer will consume the same number of random values as the non-multibuffer code path, but do so in less time. In OpenSSL 1.0.2, random numbers are supplied by the RAND_bytes() function which uses OpenSSL's software-based pseudorandom number generator (PRNG), mixed with values obtained from the RDRAND instruction if Intel^® Data Protection with Secure Key is supported by the processor. Multibuffer throughput might benefit from using Secure Key as the sole random number provider, freeing up CPU cycles for the AES encryption. This can be accomplished by enabling the rdrand engine in OpenSSL, though this will do so for other areas of OpenSSL that depend on random numbers such as the SSL/TLS handshake, too.

Configuring Apache for Multibuffer

Apache uses dynamically sized SSL buffers that adapt to the file being transferred. As a result, Apache will automatically make use of multibuffer if the target file is 64 KB or larger. No configuration needs to be done.

To configure OpenSSL to use the rdrand engine for Apache, use the OpenSSLConf directive:

SSLCryptoDevice rdrand

More information can be found in the article "Configuring the Apache Web server to use RDRAND in SSL sessions".

Configuring nginx for Multibuffer

nginx uses a fixed SSL buffer size which is configured in the nginx.conf file. In order to enable multibuffer the configuration parameter ssl_buffer_size must be set to 64k or larger:

ssl_buffer_size 64k;

Larger sizes will result in greater throughput, but unfortunately it can have an impact on latency no matter which cipher is used. For small files (ones that would not benefit from multibuffer), this means incurring a small penalty in performance.

Unfortuantely, there is no single magic number that works well for all file sizes. This value should be chosen based on the workloads that are common and appropriate for the server, and administrators are encouraged to test different values to find the one that works best for their environment.

At the current time, nginx does not provide a way to configure specific engines within OpenSSL so there is no way to force the rdrand engine for random number generation.

§

Autumn serves as the perfect time to revisit paranormal influence on pop culture, and all the reasons we like to get involved.

With Halloween approaching, many familiar spooky sights and sounds come to mind. A haunted hayride, a scary movie, a costume party, or a playlist of festive songs for the holiday may creep into your head.

But Halloween traditions are nothing new, and actually go far back; the celebration is thought to have originated with the ancient Celtic festival of Samhain, when people would light bonfires and wear costumes to ward off roaming ghosts. In the eighth century, Pope Gregory III designated November 1 as a time to honor all saints and martyrs; the holiday, All Saints’ Day, incorporated some of the traditions of Samhain. The evening before was known as All Hallows’ Eve, and later Halloween.[1]

Aliens in particular have played a prominent role in popular culture, especially at this time of the year, since the mid-20th century. Humanity has conducted a tireless search for signs of extraterrestrial intelligence, from radios used to detect possible extraterrestrial signals, to telescopes used to search for potentially habitable extrasolar planets.

This fascination has dominated in works of science fiction, and thanks to Hollywood's involvement, has continued to capture the public's interest in the possibility of extraterrestrial life. Aliens are often portrayed as aggressive, adversarial, or scheming, possibly just because this makes for easier action script writing.

One of the most influential early examples of aliens in pop culture was HG Wells'War of the Worlds;(1898), which popularized the notion that advanced, malevolent aliens could invade the earth. The Orson Welles radio adaptation in 1938 is one of the most infamous episodes in alien storytelling, as many people actually believed a real alien invasion was underway.

As our scientific understanding has advanced, our ideas about the nature of otherworldly beings have changed accordingly. Instead of god-like creatures living in magical places, modern aliens are usually thought of as flesh-and-blood creatures evolved from unusual but natural environments.

More recently, the popularity of aliens has made a smooth transition to interactive digital media, and benefited from some modern twists. A fitting example of this continued interest is the BigHut Games app Alien Jump – Lab Escape. This game, for participants of all ages, features non-threatening, cute aliens that were captured by evil scientists, and the players’ challenge is to help them escape from the lab. The three highlighted characters are alien Zippy and his friends, and they are involved in a daring get-away adventure, using the scientists’ own inventions against them.

Along the way, coins can be collected to upgrade items, powerful jetpacks enable players to fly, and many powerups are available to help in the ultimate escape. Friends can compete with each other in the alien fun, as everyone attempts to be the first to reach the exit.

The app, now optimized for Intel devices, offers beautiful and colorful graphics, and over 60 levels filled with dangerous traps, and challenging twists and turns. Alien Jump is completely free to play, but also offers items that can be purchased; this feature can easily be disabled on individual devices based on preference.

The ways in which we recognize Halloween and incorporate its traditions into popular culture have certainly evolved over time, but at least in the case of aliens, these modern portrayals couldn’t be more fun. As the leaves fall and the nights get chillier, we can delight in the scary elements of Halloween with a whole new level of interaction and believability in the digital age. To start your extraterrestrial adventure now, download Alien Jump – Lab Escape here:
https://play.google.com/store/apps/details?id=com.bighutgames.alienjump

[1]http://www.history.com/topics/halloween/history-of-halloween

Code Modernization Best Practices: Multi-level Parallelism for Intel® Xeon® and Intel® Xeon Phi™ Processors

Intel® Xeon® and Intel® Xeon Phi™ processor based platforms provide multiple levels of parallel execution resources. The amount of compute power of these resources is growing with every product generation, yet most applications do not fully utilize the available computing resources. This session will provide details on the growth in hardware resources and characterize performance using different levels of parallelism. Also covered are the key principles of how to use all levels of parallelism with clear examples and supporting data.

Topics include:

• Parallel computing resources in Intel® Architecture (IA)
• The parallel programming model for IA
• Best practices in parallelizing serial code
• The limitations of performance portability
• Summary

Speaker: Robert Geva Principal Engineer, Manager of Financial Services Engineering Group, Intel Corporation

Download PDF DownloadDownload

View Webcast

The high prevalence of all things zombie has created a new category of interest, one that blends with other genres for today’s modern audiences.

Zombie apocalypse stories are inescapable; they’re contagious, spreading rapidly from their origins in early 20th-century literature and film to completely invading modern popular culture.  Robert Kirkman’s “The Walking Dead” comic books spawned AMC’s series of the same title and the successful zombie flick “28 Days Later” resulted in a sequel, a graphic novel, and a comic book series.

Popular culture has become undeniably fixated upon the zombie phenomenon for a reason: zombies are the ultimate enemy.  They’re frightening, and while they start out as normal humans, the loss of their humanity renders them pitiable.

With Halloween right around the corner, we are reminded of just how intriguing zombie tales can be, and why their popularity and diversity have only grown.  To stand out these days, anything zombie-related has to be something special. One way the genre has evolved is by incorporating other areas of interest into storylines expanding the zombie experience.

One movie example of this is “Warm Bodies,” a 2013 movie that even turned a zombie apocalypse into a surprisingly well-received romantic comedy.  That same year, “World War Z” went beyond gore, and explored the insight behind unraveling the zombie disease and averting total human extinction.  Viewers got a snapshot into the minds of those entrapped in this terrifying experience, putting themselves into the shoes of Brad Pitt’s character Gerry Lane, as he fights for survival in a relentless zombie onslaught.

Clearly, gaming can transport audiences into the action in a way that movies or even books never could.  The digital world has taken advantage of this, also combining enthralling genres into one complete out-of-this-world experience.  A perfect example of the successful marriage of exciting elements is JE Software AB’s Last Hope Zombie Sniper app….

• Creepy, zombie interactivity just in time for Halloween?  Check.
• A challenging, harrowing adventure through an altered world?  Check.
• Shooting and surviving based solely on your skills?  Check.

Last Hope, now enabled for All in One devices powered by Intel® Core™ processors, is an arcade Zombie Sniper 3D Shooter game placed in the desert.  The story takes you on a journey through a changed world, exploring soccer fields in the desert, a sad wilderness, small villages, and infected canyons.  It’s all about surviving the zombies as much as earning high scores and reaching new experience levels.  Players need to find out which combinations of skills and items work best in order to survive and climb the ranks in becoming the best sniper in Last Hope.  It’s easy to catch onto, but hard to master.

A character named Burt guides players through using a sniper rifle by first practicing on cans and bottles.  When ready, they can venture out in the cold, lonely desert facing the Zombie menace, trying to find the reason why civilization ended.  While battling in the land owned by the dead, gamers will meet tougher zombies.  With wide variations of gameplay modes and goals, upgradable weapons, and rich and colorful shooting grounds, Last Hope remains fresh and challenging for hours of play.  The zombie phenomenon meshed with a whole lot of action makes for endless spooky, skill-required enjoyment this Halloween season.

Start your zombie combat adventure now by accessing the app here:
https://appshowcase.intel.com/en-us/allinone/node/9264

Role playing games invite everybody to assume their secret identities and fight evil.

With school in full swing and the days getting shorter, kids are starting to think about donning costumes and trick-or-treating. The spirit of Halloween lends itself to disguise and make-believe, and fantasy has taken on a whole new meaning with the explosion of MMORPG, or Massively Multi-player Online Role Play Gaming.

These games combine all the engagement of classic role playing like Dungeons and Dragons, but the way the CGI graphics, narrative, and gameplay have evolved, the adventure is all that much more convincing. Plus, the fundamentals of these games goes from very basic to very complex, so now kids in a broader age range can assume an avatar, customize their attributes, and go on a continued journey with their friends. The MMORPG genre has captured kids’ attention because it offers some unique features that allow players to flex some different gaming muscles.

1. Evolving real-time world. The architecture of these games is far more open, and the challenge is that they are always changing; no two scenarios are ever the same and so the novelty keeps players coming back for more. With the proliferation of 3D imaging, the spaces are much more expansive open and the maps are more elaborate.
2. Play with a couple thousand of your closest friends. These games can actually handle hundreds and sometimes thousands of online players simultaneously. This adds a level of chaos, excitement, and difficulty to the objective, requiring coordination with allies and organized attacks on enemies. Each game is a fascinating social experiment where players form allegiances and take risks.
3. Becoming a character is easier than putting on a costume. There is really no end of personas a gamer can inhabit in this virtual world. Weapons, tools, fighting moves, and even personality traits can all be mixed and matched into imaginative combinations.
4. Creativity. The level of interactivity and customization players experience in MMORPG encourages displays of uniqueness. Some sci-fi, horror, and simulation games let players design their own quests to challenge their adversaries. In other words, the interplay between characters and the space itself invites experimentation.
5. Curiosity. Because these worlds are so endlessly malleable, there is a high level of unpredictability that keeps players interested. With precision shooters or platformers, the movements are often limited and become rote, but with fighter simulations, there are always novel factors that influence the outcome.

While the game world is indeed every-changing, the wildly popular School of Chaos is the perfect blend of zombie attack, online team playing, block-style camp, and heart-pounding action. Set in a high-drama story where a high school has been overrun by the living dead, this app from VNL Entertainment allows gamers to form clans, wage war, buy houses, and even throw parties. Players can buy their own islands, with the ability to build, and then invite friends over. Loaded with weapons, upgrades, and real-time economics, the simulation throws 30 different fighting moves in with over five billion character customizations, so the action is always unexpected and exciting.

As Halloween draws closer, the urge toward superhero zombie slaying is irresistible for School of Chaos fans. Now that the app is enabled for Intel® Atom™ processor-based tablets for Android, kids and grownups alike can jump into the mayhem, joining their friends, and saving the day. Perfect for this time of year, special seasonal items are also featured, including Halloween ones that just happen to be on sale now too.

To download the School of Chaos app, visit Google Play: https://play.google.com/store/apps/details?id=com.vnlentertainment.mmoproject&hl=en.

The new update of Multi-OS engine provides “MOE Actions” context menu item for Android Studio. The item contains sub items namely Synchronize to Xcode, Synchronize to Java, Generate Bindings. This article takes a simple app and demonstrates the use of the above mentioned sub items.
To start with let us create a Multi-OS Engine module with Single View Application Template with storyboard. 

^{Synchronize to Xcode - To generate Objective C UI controller stubs from Java implementation for working in Xcode Interface Builder.}

1. At the module level – right click and select “MOE Actions”. Click on “Synchronize to Xcode”.
   
   
    
2. To view the generated Objective C controller files, change the view of the app to Project.
   
   
    
3. You can see the the Objective files generated under Xcode folder.
   
   

Synchronize to Java – Generate or update Java UI Controller based on changes make in Objective C stubs via Xcode.

1. Start with opening the project with Xcode. To open project with Xcode - At the module level- right click and click on “MOE Actions”. Select “Open Project in Xcode”
   
   
    
2. Once the project open up in Xcode. Open the storyboard file under resource folder. Add a button to the palette.
   
   
    
3. Open the assistant editor to associate IBAction of the button to the AppViewController file (control click to the .h file. Save the files in Xcode.
   
   
   
   
    
4. Go back to your Android Studio, on the Xcode folder, right click and under “MOE Actions” click on “Synchronize to Java”.
   
   
    
5. You will see the IBActions associated with the newly added button in your “AppViewController.java” file.
   
   

Generate Bindings- Generate or Updates Java classes/interfaces/enums based on Objective C code.

1. In the same Project, open the project with Xcode again.
2. Create another storyboard file. To create another storyboard file - Right Click on the project in Xcode and select new fileà User Interface (left panel) à StoryboardCocoa Touch Classes and click on next.
   
   
    
3. Open the newly created storyboard file. Drag and drop the view Controller on to the storyboard.
   
   
    
4. Let us create a custom class for the storyboard. Right Click on the project in Xcode and select new fileà Cocoa Touch Classes and click on next.  
   
   
    
5. Name your class and make it a subclass of UIViewController
   
   
    
6. In your interface builder – change the Custom class of the ViewController to the custom class created in the previous step.
   
   
    
7. Go back to your Android Studio, Right click at the Project level and under “MOE Actions”, click on “Generate Bindings”
   
   
    
8. You can see the custom class created for you using generate bindings . 
   
   

_{Note: The Generate Binding and Synchronize to Java have the same functionality with the following difference- right click on the module to invoke Generate Bindings vs right click on the xcode folder to invoke Synchronize to Java.} 

Test article to verify the ticket

In a world where internet video use is skyrocketing and consumers expect High Definition and ultra-high definition (UHD) 4K viewing anytime, anywhere and on any device, excel with Intel in delivering live and on-demand video faster, more efficiently, and at higher quality through the latest media acceleration technologies. Get the most performance from your media platform, and accelerate to 4K/UHD and HEVC, while reducing infrastructure and development costs.

Attend this free online webinar, Video Transcode Solutions on Dec. 1, 9 a.m. (Pacific), to learn about new media acceleration and Intel graphics technologies. Offer your cloud and communication service provider customers a customizable solution that can:

• Deliver fast video transcoding into multiple formats and bit rates in less time
• Reduce the amount of storage needed for multiple formats through higher compression processing and offering multiple rate control techniques
• Allow for real-time transcoding into multiple formats from the stored format, reducing the need to store all possible media formats
• Reduce the amount of network bandwidth needed (lower bit rates) at better video quality by compressing the video appropriately prior to transmission

Video Transcode Solutions: Simple, Fast Efficient
Online Webinar | Dec. 1, 2015 - 9 a.m. (Pacific)    
     

See how Intel can help you innovate and bring new media solutions quicker to market. Webinar is for cloud media solutions and video streaming/conferencing providers, media/graphics developers, broadcast/datacenter engineers, and IT/business decision-makers.

Speakers

Shantanu Gupta, Intel Media Accelerator Products Director
Shantanu has held leadership roles in technology/solutions marketing, integration, product design/development and more areas - for 27 years at Intel.

Mark J. Buxton, Intel Media Development Products Director
Mark has more than 20 years experience leading video standards development and Intel’s media development product efforts, including products such at Intel® Media Server Studio, Intel® Video Pro Analyzer, and Intel® Stress Bitstreams and Encoder

This document provides an overview of the Rocket kernel and its key benefits.

This guide contains instructions for creating an application workspace, configuring the OS, and building a Rocket application.

This guide contains information on Rocket’s supported platforms including details about pinouts, memory mappings, and IRQ configurations.  In addition, application and OS configuration recommendations are provided.