Fortran applications that use the Rogue Wave* IMSL* Fortran Numerical Library, specify linking to the static library form of IMSL, and build under Microsoft Visual Studio 2015* (or from a command prompt environment using the Visual Studio 2015 C++ libraries) may get linker errors such as:

imslsuperlu.lib(scomplex.obj) : error LNK2001: unresolved external symbol _fprintf
imslsuperlu.lib(zmemory.obj) : error LNK2001: unresolved external symbol ___iob_func
imslsuperlu.lib(sutil.obj) : error LNK2001: unresolved external symbol _sprintf

The situations where this will appear involve use of IMSL routines that are based on the SuperLU library for solvers and linear algebra operators. Static linking is specified by referencing the IMSL INCLUDE files link_fnl_static.h or link_fnl_static_imsl.h, or if building from the command line and referencing environment variables LINK_FNL_STATIC, LINK_FNL_STATIC_HPC or LINK_FNL_STATIC_IMSL.

These errors are due to incompatibilities in the Microsoft Visual C++* static libraries introduced with Visual Studio 2015. The workaround is to link to the DLL (shared) form of the IMSL libraries. If using the INCLUDE file method, specify link_fnl_shared.h or link_fnl_shared_imsl.h. If linking from the command line, use the environment variables LINK_FNL_SHARED or LINK_FNL_IMSL. (The variants without "IMSL" use the Intel® Math Kernel Library to improve performance; those with "IMSL" do not.)

For more information on building applications with Rogue Wave IMSL, see Configuring Visual Studio for using the IMSL Fortran Numerical Library. If you need further assistance, please refer to Intel® Developer Support.

Download Code Samples

This project demonstrates how to detect which mode a 2 in 1 laptop is in (slate vs. clamshell) on Windows* 8(.1) as well as Windows® 10’s new mouse and touch mode. Even though mouse / touch mode is similar in concept to slate / clamshell mode, Windows 10 has a new capability for users to override the mode, while Windows 8 depended only on the physical state of the convertible. Therefore, Windows 10 users are able to use the enhanced GUI designed for touch even if the machine is not a convertible as long as it has a touch screen (such as All-in-One). This new capability is based on the new UWP (Universal Windows Platform) APIs, and you’ll need to add a few lines of code to Windows 8 apps to take advantage of this feature for Windows 10. This white paper shows you how to enable Win32 apps to take advantage of the UWP APIs via WRL (Windows Runtime C++ Template Library) on Windows 10. For enabling UWP apps directly, refer to the sample code from Microsoft.

Requirements

1. Windows 10
2. Visual Studio* 2015. The new API doesn’t exist on Visual Studio 2013

Windows 10 Mouse and Touch Mode Overview

• Manual setting
  • Slide in from the right and the Action Center will show up (known as charm menu on Windows 8).
  • Tap the “Tablet mode” button to toggle between touch and mouse modes.

• Hardware-assisted setting
  • When the convertible detects physical state changes, it notifies the OS.
  • The OS asks the user to confirm. If the user confirms, the OS will toggle the mode.

• For testing purposes, go to Settings->System->Tablet mode and set the preferences to “Always ask me before switching.”

Sample App

Depending on the OS, the sample application, a dialog-based app, will either:

• Windows 10 - log the touch / mouse mode event and time, either from the manual settings or automatic switch.
• Windows 8 - report the physical state change events and the time (slate / clamshell mode.)

Just as Windows 8 broadcasts WM_SETTINGCHANGE (lParam == “ConvertibleSlateMode”) message for physical state changes, Windows 10 broadcasts WM_SETTINGCHANGE (lParam == “UserInteractionMode”) to the top-level window. However, it also broadcasts the old message as well. The application needs to detect the OS version and provide a different code path depending on it. Otherwise, it will end up responding to the messages twice on Windows 10.

void CMy2in1LogDlg::OnSettingChange(UINT uFlags, LPCTSTR lpszSection)
{
	CDialogEx::OnSettingChange(uFlags, lpszSection);

	// TODO: Add your message handler code here
	if (lpszSection != NULL)
	{
		CString strMsg = CString(lpszSection);

		if (m_dwVersionMajor < 10 && strMsg == _T("ConvertibleSlateMode"))
		{
			CString strTime;
			GetTime(strTime);
			BOOL bSlate = GetSystemMetrics(SM_CONVERTIBLESLATEMODE) == 0;
			CString strMsg = CString(bSlate ? _T("Slate Mode") : _T("Clamshell Mode"));
			m_ctrlEvents.InsertItem(m_iEvent, strTime);
			m_ctrlEvents.SetItemText(m_iEvent, 1, strMsg);
			m_iEvent++;
			return;
		}

		if (m_dwVersionMajor >= 10 && strMsg == _T("UserInteractionMode"))
		{
			CString strTime, strMsg;
			GetTime(strTime);
			int mode;

			if (GetUserInteractionMode(mode) == S_OK)
			{
				if (mode == UserInteractionMode_Mouse)
					strMsg.Format(_T("Mouse Mode"));
				else if (mode == UserInteractionMode_Touch)
					strMsg.Format(_T("Touch Mode"));
				m_ctrlEvents.InsertItem(m_iEvent, strTime);
				m_ctrlEvents.SetItemText(m_iEvent, 1, strMsg);
				m_iEvent++;
			}
		}
	}
}

Once the application receives the message, it queries the current state because the message only notifies the OS of the mode change, but not what state it is. There is no Win32 API to directly query the new states, but WRL can be used to access Windows RT components from Win32 app as illustrated in the following code snippet.

HRESULT CMy2in1LogDlg::GetUserInteractionMode(int & iMode)
{
	ComPtr<IUIViewSettingsInterop> uiViewSettingsInterop;

	HRESULT hr = GetActivationFactory(
		HStringReference(RuntimeClass_Windows_UI_ViewManagement_UIViewSettings).Get(), &uiViewSettingsInterop);

	if (SUCCEEDED(hr))
	{
		ComPtr<IUIViewSettings> uiViewSettings;
		hr = uiViewSettingsInterop->GetForWindow(this->m_hWnd, IID_PPV_ARGS(&uiViewSettings));
		if (SUCCEEDED(hr))
		{
			UserInteractionMode mode;
			hr = uiViewSettings->get_UserInteractionMode(&mode);
			if (SUCCEEDED(hr))
			{
				switch (mode)
				{
				case UserInteractionMode_Mouse:
					iMode = UserInteractionMode_Mouse;
					break;

				case UserInteractionMode_Touch:
					iMode = UserInteractionMode_Touch;
					break;

				default:

					break;
				}
			}
		}
	}

	return S_OK;
}

Conclusion & Other Possibilities

This sample code shows how to enable 2 in 1 detection on Windows 8/8.1 and Windows 10 using Win32. It was not possible to detect 2 in 1 events on Windows Store Apps on Windows 8. With Windows 10, UWP APIs are provided so that universal apps can take advantage of 2 in 1 capability. Instead of providing a comparable Win32 API, a method to use the UWP API from Win32 app is presented. It may be worthwhile to note that UWP APIs do not have a specific notification for this, but use window resize events, followed by verifying the current state. If the state is different from the saved state, the state has changed. If it is not convenient to use Win32 messages (as in Java* applications), you can use Java’s window resize event and call the JNI wrapper to confirm the state.

License
Intel sample sources are provided to users under the Intel Sample Source Code License Agreement.

Well, SIGGRAPH 2015 is in the books and once again, it was a great time to celebrate the computer graphics industry’s top contributors, network with friends old and new, learn about new and exciting developments in the computer graphics industry, and show people what Intel is doing to move the industry forward.

This event recap captures some of the highlights from SIGGRAPH for those who unfortunately missed out on all the fun and learning this year. Plan early to attend next year!

Tech Sessions

I’ve always felt that the number one reason to attend SIGGRAPH is to learn, and the SIGGRAPH event team at Intel tried to do its part by helping people learn about cool things being done at Intel and with our collaborators. We offered six unique talks at SIGGRAPH, and all of them received stellar marks from the attendees. Sven Woop’s talk, “Embree Ray Tracing Kernels” was particularly well-received. Talks given in collaboration with our friends at Dreamworks were the most highly attended, and we give them a shout-out for doing a great job at SIGGRAPH.

We’ve posted the six Intel SIGGRAPH 2015 tech session presentations so that you can view them at your leisure or study them in more detail:

• Software-defined Visualization, High-Fidelity Visualization: OpenSWR and OSPRay
• Embree Ray Tracing Kernels
• Improving the performance of OpenSubdiv* on Intel® Architecture
• DreamWorks Animation: Slashing the cost of 3d Matrix Math using X-Form (Transform) Building Blocks
• DreamWorks Animation (DWA): How We Achieved a 4x Speedup of Skin Deformation with SIMD
• Let there be light - Light capture and Online Tools for Virtual Production in the Dreamspace project

Booth and Demos

A big thanks to all who wandered by the Intel booth in the Exhibition Hall. We had a continuous stream of visitors throughout the three days of the exhibition, and it was great to meet and talk with so many of you. We featured nine demos ranging from Intel® Atom™ processor (codenamed CherryTrail)-based tablets to Intel® Xeon® processor-based servers, as well as a “walk up and play” island. As we have done for the past several years, we showed support for a new graphics API from the moment it was announced. This time it was OpenGL* ES 3.2 running several demos the same week as it was announced by the Khronos Group. We also showed some whizzy demos running on top of Vulkan*. Autodesk, Wacom, Impulsonic, USC ICT, Epic, and The MIX helped us show off the capabilities of Intel® graphics – a big thanks to those partners!

We showed a Photoshop* plugin that we are developing to raise the content creation industry’s awareness of Intel’s products. This plugin takes advantage of multiple cores to bring a previously unusable texture compression algorithm (BC7) into the realm of interactive usability. We were signing people up for the upcoming beta test (get information and sign up for the beta here).

We filmed short videos to bring all Intel’s SIGGRAPH demos to those of you who couldn’t make it to SIGGRAPH and published them on YouTube*.

Waskul.tv

We were fortunate to once again partner with our good friends at Waskul.tv and offer some amazing video interviews live-streamed from the SIGGRAPH show floor. The lineup of interviews included leading graphics researchers (James O’Brien, UC Berkeley; Jernej Barbic and Ari Shapiro, USC; Dinesh Manocha, UNC; Kavita Bala, Cornell; and Doug James, Stanford), leading figures from SIGGRAPH (Marc Barr, 2015 Conference Chair; Mona Kasra, 2016 Conference Chair; and Kristy Pron, 2015 Emerging Technologies Chair), figures from the game developer segment (Mike Zyda, founder of the USC GamePipe Lab; Gavin Moran, Epic Games; and several indie developers from The MIX), key event and industry partners (Martin Watt, Dreamworks Animation; Eddie Perlberg and Chris Vienneau, Autodesk; Doug Little, Wacom; David Helmly, Adobe; and Dave Clayton Weta Digital, and seven of us from Intel.

Waskul.tv will be posting the interview videos starting at the end of August. We’ll be working with them to produce “highlight” versions of some of the best interviews too. Stay tuned to the Achievement Unlocked web page and to Waskul.tv. (If you need something to do while waiting, check out all of the interviews from GDC 2015.)

Academic Reception

AWESOME was the best way to describe the Intel Academic Reception at SIGGRAPH 2015! We had a great time in a great venue (Lucky Strike Lanes in L.A. Live). For people doing advanced research in computer graphics, this was a perfect way to visit with a ton of industry colleagues and get caught up on what they are doing. (This is really one of the key reasons for attending an event like SIGGRAPH in person.) Attendees included world-renowned graphics researchers (Stanford, Princeton, UC Berkeley, CMU, Princeton, Cornell, MIT, USC, North Carolina, Victoria, BC, Toronto, London, Darmstadt, Saarland, TU Berlin, Max Planck, ETH Zurich, etc.), numerous SIGGRAPH achievement award winners, SIGGRAPH dignitaries (this year’s Papers Chair, next year’s Conference Chair), game developers (The MIX), and employees from key companies such as Weta Digital, Oculus, Disney Research, Adobe, Google, and Dreamworks, and of course many of the people from Intel involved in the computer graphics industry. There was also buzz about this party at SIGGRAPH, with people trying to secure invitations up until the day of the event. Humongous thanks to all who showed up!

Technical Artist BoF

Intel organized the first-ever Birds-of-a-Feather for Technical Artists at SIGGRAPH. We would have been happy with half a dozen people showing up, but we counted approximately 50! The majority were TAs in the game industry. Billed as an informal networking event, this helps to fill a SIGGRAPH gap, as unlike GDC there has been no specific Tech-Artist BoF at SIGGRAPH. Example questions discussed were “what is a TA?”, “how do I know if I’m a TA?”, and “who’s hiring TAs?” The discussion was lively and many attendees expressed appreciation for setting this up. Thanks to all who showed up and contributed to the discussion, and please drop us a line to continue the conversation.

The MIX

Intel once again sponsored The MIX (previous sponsorships include E3 2014 & 2015, SIGGRAPH 2014 and GDC 2015). This year The MIX at SIGGRAPH had 13 studios represented. They had great traffic in their area in South Hall near the Emerging Technologies section. And they also helped us out by demonstrating some of their games on Intel® platforms in our booth. As always, we were blown away by the creativity and the enthusiasm of this group of game developers…fun stuff!

What I learned at SIGGRAPH

Let me close by giving you a few of my key learnings from SIGGRAPH this year:

• EVERYONE is talking about VR! And many, many people are trying to move VR forward with new ideas, new research, and new products.
• ILM has formed “ILM Xlab” – devoted to bringing new interactive experiences to people on tablets. One demo showed how you can re-direct the Star Wars scene of the Tatooine Outpost, choosing new camera angles, looking in different directions, etc. How cool is that!
• Paul Debevec thinks we have crossed the Uncanny Valley a few times and "stuck the landing"– he and his team at USC ICT have created digital doubles indistinguishable from the real thing that have been used in some feature films. For example, in the movie Gravity, there is a scene showing Sandra Bullock and George Clooney in their space suits talking while orbiting Earth. NOTHING in this scene is physical – it is all digital – including the faces of Bullock and Clooney – so lifelike as to be indistinguishable from the real thing. Debevec and his team were also responsible for recently creating the first completely accurate digital facial model of a sitting president– President Obama – a very entertaining story! (And wouldn’t you think this would pose a security risk? Have you seen any episodes of Mission Impossible?)
• Pixar has open-sourced USD– Universal Scene Description
• SIGGRAPH is a great event that everyone should attend! (Actually, I learned this a long, long time ago!)

Diagnostic message "function was not vectorized: dereference too complex"  should not be emitted in the officially supported versions of the  Intel^(R) C++ Compiler 15.X and the current 16.X respectively.

NOTE:
Substantial improvements have been made to the memory reference analysis. If you encounter the above diagnostic please file an issue in the Intel(R) Premier Support at https://premier.intel.com

Diagnostic message "function was not vectorized: unsupported loop structure" is RETIRED.

NOTE: The diagnostic message "function was not vectorized: unsupported loop structure” is retired in the officially supported versions of the  Intel^(R) C++ Compiler 15.X and the current 16.X respectively.  Previously, older versions of the compiler emitted the diagnostic when loops failed to fulfill the requirements of countability, single entry and exit, etc.  Latest officially supported versions of the compiler as mentioned earlier, should not emit this diagnostic due to several enhancements in the compiler.

Diagnostic message"function was not vectorized: subscript too complex" should not be emitted in the officially supported versions of the  Intel^(R) C++ Compiler 15.X and the current 16.X respectively.

NOTE:
Substantial improvements have been made to the memory reference analysis. If you encounter the above diagnostic please file an   issue in the Intel(R) Premier Support at https://premier.intel.com

Diagnostic message"function was not vectorized: operator unsuited for vectorization”is RETIRED.

NOTE: The diagnostic message "function was not vectorized: operator unsuited for vectorization” is retired in the officially supported versions of the  Intel^(R) C++ Compiler 15.X and the current 16.X respectively.  Previously, older versions of the compiler emitted the diagnostic when certain operators, such as the "%" (modulus) operator, can't be vectorized.

Intel® System Debugger 2016 is the complete system debug solution provides deep insight into memory and system configuration.

Key features of Intel® System Debugger 2016:

• JTAG debug for Intel^® Atom™, Core™, Xeon^® & Quark™ SoC-based platforms
• EFI/UEFI Firmware, bootloader debug, Linux^* OS awareness
• Dynamically loaded Linux kernel module debug
• In depth visualization of memory configuration, system state and register sets
• LBR & Intel® Processor Trace On-Chip instruction trace support
• JTAG debug & instruction trace to Microsoft* WinDbg* kernel debugger
• System Trace: System-wide hardware and software event trace

Intel® Processor Trace is the hardware based low overhead code execution logging on instruction level and provides a powerful and deep insight into past instruction flow combined with interactive debug.

Key features of Intel® Processor Trace:

• Low-overhead execution tracing feature
• Capturing information about software execution
• Reconstruct the exact program flow

More Details are in the PDF file attached. (Please click link below.)

PDF FILE: Intel® System Studio – System Debugger – Processor Trace Sample

It consists of:

Overview of Intel® System Debugger and Processor Trace

    Details on Intel® System Debugger and Processor Trace

    Intel® Processor Trace Decoder Flow

Intel® System Debugger and Processor Trace Sample

    Test Environment

    Configurations

    Intel® Processor Trace Sample

Example: Intel® Processor Trace and Call Stack Saved in XDB via command console.

The Multi-OS Engine provides two options for building the UI for iOS* applications. 

1) Through the UI builder which is available within Android Studio when the Multi-OS Engine is installed. Look at this article.

2) For more complex UI, you can design in XCode Interface Builder and Multi-OS Engine can generate the Java bindings in Android Studio. Letz discuss this approach in detail in this article by building the same Quiz App as in the above approach (1)

As Step 1, To create any iOS application with Multi-OS Engine, create a stock Android application like this.

Step 2: Right click on the new Android project and select "Intel Multi-OS Engine Module" to create a new iOS* module.

Step 3: Then select "Single View Application" as a starting template for your app. This app is named "QuizApp". 

When you expand the project structure, you will notice these files. Letz delete the files "AppViewController", "MainUI.storyboard" and the folder "resources/layout". Because, we are going to regenerate them after designing the UI in the XCode Interface Builder. It may prompt you that there are other references and if you still want to delete these files. Go ahead and delete them.

Step 4: Remove the reference to AppViewController in the imports of Main.java file as seen below

Step 5: Right click on QuizApp project and "Open Project in XCode"

It should bring up the XCode Editor. Now the next step will presume at least basic level of UI design with XCode for iOS* apps. If you want to refresh some iOS* design skills, now is the time.

Step 6: Expand the QuizApp Project in XCode and add a new source file based on Cocoa Touch class. Follow the following screenshots and there will be two files created MyViewController.m and MyViewController.h at the end of the step.

Step 7: Now create a new user interface by right clicking on the QuizApp project. Name your Storyboard as "MainUI" because that's the name defined in the Multi-OS templates in Android Studio which is going to be connected to this interface later.

At the end of this step, you should see the new project structure like below.

Step 8: Drag a new ViewController and select the newly created MyViewController in the highlighted section.

Step 9: Pick the UI controls from the bottom right and drag them to the storyboard. For this app, we need two labels and two buttons.

Create an entry point in the Storyboard by checking "Is Initial View Controller" box on the right.

Step 10: Click on the circular icon as highlighted and this will open up the center pane and open up "MyViewController.h" file from the pane. Create the IBOutlets for the two labels and two buttons and IBActions for the two buttons. Save the project.

Step 11:  Now, go back to Android Studio and right click on the "QuizApp" project and click "Generate UI Interface Bindings".

This will create a new file called "MyViewController.java" and this file will have the java bindings for all the UI controls and actions that were created in XCode. Everytime, any UI element is added/deleted or modified in XCode, then UI Interface bindings have to be generated by the above process.

Step 12: Letz add a new Java class that implements a simple logic for the Quiz App

Step 13:  It is necessary to delete "@Generated" and "native" from the methods that you are going to modify. This is to imply that the originally generated code is modified.

Step 14:  And then create a new object of class QuizDataSet and then initiate it in a separate method "viewDidLoad". Call the necessary methods from the above class in the action handlers defined for the two buttons. The screen below is all that required to implement the logic.

Step 15: Run the project and you will see the App in action.

And there you go! You have successfully designed your app with the XCode Interface builder and implemented in Android Studio using Java.  

Problem:
With Intel® Parallel Studio XE 2016 for Linux* (initial release), sourcing the compilervars.[csh|sh] scripts (simply compilervars in the following) might set $MANPATH incorrectly. This can result in not being able to view the system man pages anymore. This is only temporarily since being limited to the shell environment for which the scripts have been sourced. Opening a new shell does show the correct $MANPATH again, according to the system configuration.

Example:

$ man ls

<shows man page for ls>

 

$ source <install-dir>/compilers_and_libraries/linux/bin/compilervars.sh intel64

 

$ man ls

No manual entry for ls

See 'man 7 undocumented' for help when manual pages are not available.

Some man pages from Intel® Software Development Products are still shown correctly, like man icc, man ifort, ...

Environment:
Intel® Parallel Studio XE 2016 for Linux* (with Intel® C++ Compiler and/or Intel® Fortran Compiler 16.0).
Some Linux* distributions, like Ubuntu*, are affected but not all.

Root Cause:
The compilervars scripts also source the ones for the debug solutions (debuggervars.[csh|sh]) which in turn modify the $MANPATH incorrectly.

Resolution:
Since the modification of the shell's environment via compilervars is only temporary, opening another shell has a correct $MANPATH again. That other shell can be used to view the man pages.
A fix will be available with the next update.

This page provides the current Release Notes for the Rogue Wave* IMSL* Fortran Numerical Libraries for Intel® Parallel Studio XE Composer Edition for Windows* product. The files are in PDF format - Adobe Reader* (or compatible) required.

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

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

Diagnostic message: XXX was not vectorized: loop with early exits cannot be vectorized unless it meets search loop idiom criteria is only emitted in Intel(R) C++ Compiler 15.0 and the current 16.0 version of the product.

Cause:

This diagnostic message is emitted when the loop in question doesn't meet the vectorization criteria on not having a complete loop execution without a loop exit or branch redirection. In the example below the iteration control variable causes a conditional loop exit preventing vectorization. 

Example:

%cat vec.c
void no_vec(float a[], float b[], float c[])
{
   int i,j,k;
   while (i < 100) {
      a[i] = b[i] * c[i];
      ++i;
      if (i==5) break;else continue;
   }
}

Using Intel(R) C++ Compiler 16.0:

% icc -c -opt-report-phase=vec -opt-report-file=stdout vec.c
Intel(R) Advisor can now assist with vectorization and show optimization
  report messages with your source code.
See "https://software.intel.com/en-us/intel-advisor-xe" for details.

Begin optimization report for: no_vec(float *, float *, float *)
Report from: Vector optimizations [vec]

LOOP BEGIN at vec.c(4,4)
   remark #15520: loop was not vectorized: loop with multiple exits cannot be vectorized unless it meets search loop idiom criteria
LOOP END

Recommendation

Try to see if you can redo the loop as below

% cat vec.c
void no_vec(float a[], float b[], float c[])
{

   int i,j,k;
   while (i < 5 || i > 5) {
      a[i] = b[i] * c[i];
      ++i;
   }
}

% icc -c -opt-report-phase=vec -opt-report-file=stdout vec.c
Intel(R) Advisor can now assist with vectorization and show optimization
  report messages with your source code.
See "https://software.intel.com/en-us/intel-advisor-xe" for details.

Begin optimization report for: no_vec(float *, float *, float *)

    Report from: Vector optimizations [vec]

LOOP BEGIN at vec2.c(4,4)
<Peeled loop for vectorization, Multiversioned v1>
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Multiversioned v1>
   remark #15300: LOOP WAS VECTORIZED
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Alternate Alignment Vectorized Loop, Multiversioned v1>
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Remainder loop for vectorization, Multiversioned v1>
   remark #15301: REMAINDER LOOP WAS VECTORIZED
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Remainder loop for vectorization, Multiversioned v1>
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Multiversioned v2>
   remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
LOOP END

LOOP BEGIN at vec2.c(4,4)
<Remainder, Multiversioned v2>
LOOP END

Introduction

Instead of setuping a system from beginning and capturing the trace file by yourself, you can find a sample trace file and one-page illustration pdf guide inside the attached file of this article. This can enable you to evaluate this system trace viewer functionalities immediately. Check the attached zip file. You can access another article to know the system setup for how to validate system trace feature provided by Intel System Debugger. 

DownloadDownload

Runtime
Apple iOS* API Bindings
Integration with Android Studio
Layout Editor
Local build
Remote build
Installation
UI Binding Generator

The known issues apply to Multi-OS Engine update 1 (version 1.0 build 285)

Runtime 

• The only class loader the runtime supports is the bootstrap class loader. It constructs NoClassDefFoundError exceptions without detailed messages.

• The runtime is derived from Android* ART and inherits most Java packages it implements. The preloaded-classes.txt file, which resides in the installation directory, contains the list of the implemented Java packages:
  • To use Java packages that are not on the list add them as external dependencies for your project.
  • If external dependencies for your project implement classes on the list, the build will fail (the dex2oat tool will fail with an error message like “dex2oat ... Check failed: method != NULL”).
• The runtime does not contain an implementation of JDBC Driver.

Apple iOS* API Bindings 

• Using methods with Ptr<? extends ObjCObject> in applications targeting Mac OS X* host can lead to crash with null pointer exception if you working with pointers returned from native, not created yourself.

• If a ‘Division by 0’ exception occurs after an incorrect NatJ initialization, start working with NatJ by creating an Obj-C class that implements a UIApplicationDelegate interface.
   
• Missed NatJ annotations or misprints are not checked by the build system or NatJ initializer. Manually written methods with inaccuracies in annotation can lead to exceptions in runtime and undefined behavior.
   
• Double pointer to primitive types as a return value from methods of binded objects is not supported.

Integration with Android Studio 

• Multi-OS Engine samples require setting the active JDK version to 1.8 manually in Android Studio. “Invalid source release: 1.8” error will occur if this isn’t done. To resolve this issue, go to Android Studio* to File -> Project Structure -> SDK Location -> JDK location and specify the path to JDK 1.8.

• Info.plist (located at /path/to/application/MOE_module_name/xcode/project_name/) should contains a valid Bundle ID. Otherwise the following error will occur: “Application installation on device failed (Incorrect bundle id in your Info.plist file)”. For more information please visit: https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/ConfiguringYourApp/ConfiguringYourApp.html#//apple_ref/doc/uid/TP40012582-CH28-SW8

• When the debugger is not closed properly, it leaves the device in the state which will not allow you to restart and use the debugging again. This is true even if you reboot the device. One workaround is to debug projects from XCode on the device. This will reset the state.

• When you add “Intel MOE Module” to your project, it is always added to the root directory of the project, regardless of the project directory you have chosen.

• If you manually installed a previous version of iOS Simulator* (for example iOS Simulator* 8.3 to the system which had already installed iOS SDK* 8.4), the build project may fail with error “SDK 8.3 not found”. The workaround is to explicitly specify the installed iOS SDK* version in the build configuration.

• IPA build (“Export IPA for Application” from Android Studio* “Build” menu) may fail immediately after you import a project. The workaround is to press the “Project” tab located on the left side of Android Studio. After that IPA export will be successful.

• Removing the storyboard file can cause the following build error: “Could not find a storyboard named “MainUI” in NSBundle”. The problem will disappear after running build again.

Layout Editor 

• For the correct rendering of widgets, you must have Android SDK* with API level 9 or higher installed.

• Constraints can be conflicted for difficult UI written in iXML. XCode cannot manage conflict situations with constraints. As a result, generated constraints do not match with XCode constraints.

Local build 

• If Gradle Daemon is enabled, the build may fail with an error message like the following: “Could not find “/../SharedFrameworks/DVTFoundation.framework”. You can fix this by disabling Gradle Daemon: remove “org.gradle.daemon=true” line from the ~/.gradle/gradle.properties file.

Remote build 

• Build may fail with the “User interaction is not allowed” error. In this case, you may have to grant the “codesign” tool permissions to access some specific resources. For details, refer to Getting Started tutorials at resources given in the Customer Support section of this document.

Installation 

• In rare cases, Multi-OS Engine plugins for Android Studio* will not be installed automatically. It can occur if you use a pre-release version of the Android Studio* or when Multi-OS Engine plugins could not be loaded previous time and Android Studio* disabled the plugins.
  After installation, please verify that two plugins “Intel INDE MOE Plugin” and “Intel INDE MOE Layout Editor” are enabled in the Preferences-> Plugins menu of Android Studio*. If you cannot find them there, please install them manually using “Install plugin from disk” button from “<MOE install directory>/intellij_plugins” directory.
• If you log in to a Mac OS X* system with a “root” account, Android Studio* will not see the INTEL_MULTI_OS_ENGINE_HOME environment variable. As a result, Multi-OS Engine plugins for Android Studio* will not function. Please use a regular user account to work with the Multi-OS Engine capability.

UI Binding Generator 

• Unstable work of UI binding generation feature. With correct .xib; .storyboard; .m; .h files UI binding generation procedure may require more than one attempt.
• For successfully UI binding generation, all necessary files (.storyboard, .xib, .h, .m) should place in xcode project directory. In current version this feature do not support reference on files in Xcode project.
• Generation UI binding for existing Java View Controller leads to that existing outlets and actions(in Java View Controller) stop working. The cause is difference in declarations of existing and generated outlets and actions.


• Workaround steps:
  1. Add annotation ‘@Property’ in Java code for all generated outlets
  2. Add implementation in Java code for all generated actions
  3. Exclude native source files (with implementation of view controllers) from the build procedure.

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

Required for Operation of Intel® Software Development Products

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

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

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

Used within Intel® Software Development Products

The following products contain Intel® Application Debugger, Intel® Debugger for Heterogeneous Compute, Intel® Many Integrated Core Debugger (Intel® MIC Debugger), Intel® JTAG Debugger, and/or Intel® System Debugger tools which are using third party libraries as listed below.

Products and Versions:

Intel® System Studio 2016 Beta

Intel® Parallel Studio XE 2016 for Linux*

• Intel® Parallel Studio XE 2016 Composer Edition for C++ Linux*/Intel® Parallel Studio XE 2016 Composer Edition for Fortran Linux*
  (Initial Release and higher)

Intel® Parallel Studio XE 2015 for Linux*

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

Intel® Composer XE 2013 SP1 for Linux*

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

Intel® Composer XE 2013 for Linux*

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

Intel® Composer XE 2011 for Linux*

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

Intel® Compiler Suite Professional Edition for Linux*

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

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

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

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

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

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

• Version 1.1
• Version 1.0

Intel AppUp™ SDK Suite for MeeGo*

• Initial Release (Version 1.0)

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

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

Diagnostic message: xxxx was not vectorized: volatile assignment was not vectorized. Try using non-volatile assignment.

Cause:

This diagnostic message is emitted when the loop in question doesn't meet the vectorization criteria in that any code involving volatile assignment within the loop prevents vectorization. In the example below the iteration control variable causes a conditional loop exit preventing vectorization.

Example:

%cat vec.c
void no_vec(float a[], float b[], float c[])
{
   volatile int i;
   int j,k;
   while (i < 100) {
      a[i] = b[i] * c[i];
      ++i;
   }
}

Using Intel(R) C++ Compiler 16.0:

% icc -c -opt-report-phase=vec -opt-report-file=stdout vec.c
Intel(R) Advisor can now assist with vectorization and show optimization
  report messages with your source code.
See "https://software.intel.com/en-us/intel-advisor-xe" for details.

Begin optimization report for: no_vec(float *, float *, float *)

    Report from: Vector optimizations [vec]

Non-optimizable loops:

LOOP BEGIN at vect.c(5,4)
   remark #15529: loop was not vectorized: volatile assignment was not vectorized. Try using non-volatile assignment.   [ vect.c(6,16) ]
LOOP END

Recommendation

Try to see if you can redo the loop as below eliminating volatile declaration:

% cat vec.c
void no_vec(float a[], float b[], float c[])
{
   int i, j,k;
   while (i < 100) {
      a[i] = b[i] * c[i];
      ++i;
   }
}
 

% icc -c -opt-report-phase=vec -opt-report-file=stdout vec.c
Intel(R) Advisor can now assist with vectorization and show optimization
  report messages with your source code.
See "https://software.intel.com/en-us/intel-advisor-xe" for details.

Begin optimization report for: no_vec(float *, float *, float *)

    Report from: Vector optimizations [vec]

LOOP BEGIN at vec.c(4,4)
<Peeled loop for vectorization, Multiversioned v1>
LOOP END

LOOP BEGIN at vec.c(4,4)
<Multiversioned v1>
   remark #15300: LOOP WAS VECTORIZED
LOOP END

LOOP BEGIN at vec.c(4,4)
<Alternate Alignment Vectorized Loop, Multiversioned v1>
LOOP END

LOOP BEGIN at vec.c(4,4)
<Remainder loop for vectorization, Multiversioned v1>
   remark #15301: REMAINDER LOOP WAS VECTORIZED
LOOP END

LOOP BEGIN at vec.c(4,4)
<Remainder loop for vectorization, Multiversioned v1>
LOOP END

LOOP BEGIN at vec.c(4,4)
<Multiversioned v2>
   remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
LOOP END

LOOP BEGIN at vec.c(4,4)
<Remainder, Multiversioned v2>
LOOP END

There are some debugging situations that simply cannot be satisfied by the features found on the Intel XDK Debug tab. In those cases, if you own a Mac and an Apple developer account, you can utilize Web Inspector in Safari to remotely debug an iOS Cordova app in a way that is analogous to using Remote Chrome DevTools with an Android device running a Cordova app. This process requires that you use a Mac and that your iOS device is attached to the Mac via a USB cable. Some configuration of Safari on your Mac and on your iOS device is required to make this work, and is described below.

Additional instructions regarding the use of Web Inspector with a USB-attached iOS device can be found in this Apple document titled Safari Web Inspector Guide. The instructions below will only get you connected and started, they do not attempt to explain how to use Web Inspector to debug your application.

Enable "web inspector" on your iOS device

• open "Settings" on the iOS device
• choose "Safari"
• choose "Advanced"
• set the "Web Inspector" button to "on" (make it green as shown in the image below)

Enable "device debug" in Safari on your Mac

• select "Preferences" from the Safari menu
• choose the "Advanced" tab
• check the "Show Develop menu in menu bar" option (as shown in the image below)

Build your app using an ad-hoc provisioning file and download the IPA to your Mac

Normally, if you were going to debug your app, you would build with a "dev" provisioning file. Unfortunately, the Intel XDK build system does not support dev builds, at this time, so you must build with an ad-hoc provisioning file and then download the IPA. In the next step you will "re-sign" that IPA with a dev provisioning file that you obtained from your Apple developer account.

Re-sign the app you just built with a dev provisioning file

The easiest way to do this is with a free open-source app named iReSign. You can download it directly from this GitHub repo and move the iReSign.app folder to your /Applications folder (or wherever you like to store such utilities...). See the README.md in the iResign GitHub repo for basic instructions. This app does require that Xcode is installed on your Mac.

Attach the iOS device to your Mac via a USB cable

Open iTunes and select the USB-attached iOS device so you can see the apps that are on the device.

Drag the IPA file you re-signed to the iTunes icon on your Mac's "Dock."

Make sure you select "install" next to the name of the app you dragged to the iTunes Dock icon. It should appear in the list of apps shown for the iOS device in iTunes. Once you select "install" the button should change so it says "will install." In the image below we are going to install for debugging an app named "HelloCordova."

Sync iTunes with your iOS device

This is necessary to install the re-signed app onto your device. You "sync" iTunes with your device by pushing the "Apply" button in the lower right corner of iTunes. Do not remove the USB cable from your Mac, the next step requires that your iOS device remain connected to your Mac via the USB cable.

Start debugging the app on your iOS device

First, start the app on your iOS device; an icon for the app to be debugged should have appeared after the sync step above. Then, start debugging with Safari on the Mac:

• select "Develop" from the Safari menu
• select the "name of the attached device"
• select the "name of the app to be debugged"
• select "index.html" (see the image below)

Safari Web Inspector will startup on your Mac and you'll have a full debug environment (similar to Chrome Dev Tools) that is connected to the app running on your iOS device. For difficult debugging situations, especially those where the app crashes immediately on start, you may have to change the logic in your app to pause any action until you, for example, start a function manually from the JavaScript console.

Notice in the Web Inspector image below, the <p> tag is highlighted. See the scr

Principal Investigators:

Prof. Dr. Knut Reinert holds the chair of the Algorithms in Bioinformatics group in the institute of Bioinformatics. In addition, he is a Max Planck fellow at the Max Planck institute for Molecular Genetics. He and his team focus on the development of novel algorithms and data structures for problems in the analysis of biomedical mass data. Previously, Knut was at Celera Genomics, where he worked on bioinformatics algorithms and software for the Human Genome Project, which assembled the very first human genome.

Description:

New technologies have reduced the cost of sequencing by many orders of magnitude in the last decade. In recent years, next generation sequencing (NGS) data have begun to appear in many applications that are clinically relevant, such as resequencing of cancer patients, disease-gene discovery and diagnostics for rare diseases, microbiome analyses, and gene expression profiling. The management-consulting firm McKinsey currently endorsed NGS as one of the most disruptive technologies that will transform life, business, and the global economy. Its prospective scope of economic impact is broad and possibly changing the biomedical field. It promises to transform how doctors diagnose and treat cancer and other diseases, possibly extending lives. With rapid sequencing and advanced computing power, scientists can systematically test how genetic variations can bring about specific traits and diseases, rather than using trial and error.

Unfortunately, lack of expertise or programming infrastructure often makes it impossible or very time-consuming to develop bioinformatics solutions meeting the growing demand. The analysis of sequencing data is demanding because of the enormous data volume and the need for fast turnaround time, accuracy, reproducibility, and data security. This requires a large variety of expertise: algorithm design, strong implementation skills for analyzing big data on standard hardware and accelerators, statistical knowledge, and specific domain knowledge for each medical problem. Consequentially the development of tools is often fragmented, mainly driven by academic groups and SMEs (Small and Medium Enterprises) with different levels of expertise in the required domains.

We aim to address this problem by enabling academic groups and SMEs to significantly accelerate their time to market for innovative technical solutions in medical diagnostics by providing the open source software development kit (SDK) that enables researchers and software engineers to build efficient, hardware- accelerated, and sustainable tools for the analysis of medical NGS data. In this proposal we will address specifically the tight integration of Intel® Xeon™ and Intel® Xeon Phi® processor families to provide fast, well-tested, algorithmic components for medical next generation sequence (NGS) analysis by extending the existing and well-established C++ library SeqAn. Using the library will enable academic groups and SMEs to develop and maintain their own hardware-accelerated, efficient tools for medical NGS analysis at an unprecedented time-scale. To achieve this we plan to fully integrate modern multicore hardware for core data structures such as string indices or pairwise sequence alignment algorithms. This will make modern hardware accelerators available to non-expert programmers. In addition we will add the combination of data parallelism with compute parallelism as a strategy to reduce the computational effort required to process many genomes at once in main memory. This will allow a seamless scale-up of tools that need to process the very large data volumes associated with a large number of individual genomes, a challenge clearly visible for medical applications.

Related websites:

Reinert lab website: http://www.reinert-lab.de/

SeqAn website: http://www.seqan.de/

This is a "matrix multiplication" example that illustrates different features of Intel® System Studio on Microsoft* Visual Studio* IDE, Eclipse* IDE and on Yacto* Target System

By Downloading or copying all or any part of the sample source code, you agree to the terms of the Intel® Sample Source Code License Agreement

Windows* System : system_studio_sample_matrix_multiply.zip(829 KB)

Linux* System : system_studio_sample_matrix_multiply.tar.gz (1380 KB)

These package has got four samples to demonstrate usage of Intel® C++ Compiler,  Intel® VTune™ Amplifier for Systems, Intel® Cilk™ Plus and Intel® MKL. 

• Using Intel® C++ Compiler for Systems to get better performance
• Using Intel® VTune™ Amplifier for Systems to identify performance bottleneck
• Using Intel® Cilk™ Plus to parallelize the application
• Using optimized functions from Intel® Math Kernel Library