What I’d like to see are the key stakeholders in the gaming industry start by considering the problem from the Consumer’s viewpoint & wallet. Today if I’m a gamer-consumer I’m assaulted with an array of Game System choices. Unlike music or movies, in order to play the game I want I’m forced to make some hard choices. If I want to play the next Halo when it releases I have to buy an Xbox. If I want to play God of War I’ll likely have to buy a Playstation. If I want to play the next Zelda I’ll likely have to buy a Nintendo Wii. If I want to play World of Warcraft I’ll have to buy a PC or a Mac & so on it goes. The irony is that these same key stakeholders in wanting to ‘wall off their gardens’ are actually costing themselves and the consumers more money in the end. Everyone in this current ‘fail-boat’ scenario is a loser.

Enough! Am I the only person that thinks this is a bit crazy and unfair to consumers? Imagine if we were to extend this same business model out to include movies & or music? I’d have to buy three or more systems to play all my movies. I’d have to buy another three or more systems to play all my music. Imagine if this scenario extended broadly to certain broadcast networks (e.g. CBS, NBC, etc) and I then have to purchase separate TVs? In a word this is ‘nutty’. My living room would be stacked floor to ceiling with twenty or more media playback devices.

There is one platform device that has the ability to play all media (Games, Music, and Movies) very well so why not fix it? If I have to spell it out that would be a PC. In order to do this though there would need to be some sort of Hardware and Software standards in place; likely set at a certain agreed upon cadence with all the key stakeholders.

Let me briefly touch upon and preempt the naysayers on two big topics that are bound to be mentioned for the PC.
1) Piracy is killing PC gaming? Really? Do we ever hear about the impact of secondary sales on the Console? Ask yourself what is worse? I sold my old Console games on Craig’s list. (Cha-Ching!) None of that money went back to the Game Developer or Publisher. Both are very serious issues though that I’ll tackle in a later blog. Fundamentally though Game Developers will most likely have to shift the value propositions of their games to the cloud & or somehow stay tethered to the internet to combat Piracy. The Pirates only have themselves to thank for that one. We’re seeing Consoles jumping on that band wagon now. I’ve also mused about how the OEMs feel about Proprietary Gaming systems but I digress.
2) Ease of use? Again … nothing a PC can’t handle here either. Time to load a game, menus and so on. The bulk of these issues are so easy to solve by following some game design 101 basics. A game on any platform should always work and be easily accessible. Solutions here are really not that hard.

So there you have it. Someday I hope to retire; and when I do walk into my local retail or etail store, I hope to be able to simply pick up the game, or download it, and have it work. I for one will definitely be averse to having to continue mixing and matching devices to games. Hopefully by then the gaming industry I’m so fond of will have matured a little by then. While I’m bound to hear primarily from industry insiders who I’d like to hear from the most is actually the gaming-consumers. How do you feel about all this?

Some parallel frameworks, like OpenMP, can parallelize my for loop with a single pragma. The fact of the matter is that this can work sometimes, but other times it may provide incorrect output data or crash my application before a tool like Inspector can find the race conditions. When this happens, it can be very difficult to debug. Crashes in parallel applications may occur non-deteministically and may not be repeatable. This type of bug can be very time consuming to find and correct. By using a modeler I can ensure that my serial testing framework will still work, and the output will be the same as a run without the modeler.

Here is an example of an application that works fine serially, but could crash if parallelized:

This code fills two arrays of integer pointers with the addresses of integers. One array points to integers in counting order, the other in reverse order. It then prints out the integers by dereferencing the pointers in the arrays. When run serially, this code works fine and prints the numbers 0-99 then 99-0. Without a modeler like Parallel Advisor Lite, I could add the #pragma (currently commented out) to parallelize the loop and let another tool check for races. However, this could crash my application. Since there is a data race on both index variables, some pointers may not be initialized. When they are dereferenced in the printing loops they may throw an exception and never allow my code to finish.

Thus, modeling parallelism as opposed to implementing it can be a very useful step in parallelizing serial code.

You can download a free copy of Parallel Advisor Lite and an evaluation copy of Intel® Parallel Studio to try them out.

I’m working with Windows 7 RTM and I wanted to install Intel® Parallel Advisor Lite. Its latest version is a Windows Installer Package (.MSI), Advisor_Lite_update1_win.msi. The package has to be installed with Administrator rights. Therefore, if you just double click on the file, the installation is not going to work as expected.

As Windows 7 hasn’t been released yet, Intel® Parallel Advisor Lite doesn’t offer official support for this operating system. However, I’m already working with Windows 7 and I wanted to optimize some code for multicore microprocessors taking advantage of the new performance improvements offered by the new Windows 7 kernel.

There is a very simple way to successfully install Intel® Parallel Advisor Lite on Windows 7. Besides, the same steps work with Windows Vista:

1. Run a Command Prompt as Administrator: Start Menu, All Programs, Accesories. Right-click on “Command Prompt” and select “Run as administrator” from the context menu that appears, as shown in the following picture.

2. A command line (terminal) Window will appear displaying the title “Administrator: Command Prompt”. Go to the folder where you downloaded the Advisor_Lite_update1_win.msi file. Remember that you have to use the CD command. For example, if the file is in C:\downloads, you just have to type:

CD C:\downloads

Important note: As a developer, you should know the CD command. However, I wanted to keep things as simple as possible for those who don’t use command line commands in Windows.

3. Run msiexec with the /i option and the Windows Installer Package (.MSI) as a parameter:

msiexec /i Advisor_Lite_update1_win.msi

The installation will start because you’re running the Advisor_Lite_update1_win.msi package as an Administrator. You’ll be able to enjoy Intel® Parallel Advisor Lite. Follow the advice and tackle the multicore revolution!

The events are different for each platform so you need to know what platform you are executing your software on.   We just recently updated our guide to event based tuning on the popular Intel(R) Core(TM) i7 processor based platforms.  The guide is updated to include suggestions for both single socket and dual socket systems.   Check out:  http://software.intel.com/en-us/articles/using-intel-vtune-performance-analyzer-to-optimize-software-for-the-intelr-coretm-i7-processor-family/

Many of you following our platforms know that on our new platforms the memory bandwidth measurements can no longer be done on the core processor.    For those who want to measure bandwidth on the Intel(r) Core(TM) i7 processor based platforms we have enabled a method using uncore events.   Check out this link:  http://software.intel.com/en-us/articles/how-do-i-measure-memory-bandwidth-on-an-intel-core-i7-or-xeon-5500-series-platform-using-intel-vtune-performance-analyzer/  You must have a VTune Performance Analyzer License and you will also need to download the Performance Tuning Utility from whatif.intel.com.

This update ensures that Advisor Lite works cleanly with Intel® Parallel Inspector Update 1, Intel® Parallel Amplifier Update 1, and Intel® Parallel Composer Update 1. In addition to the integration improvements, the Advisor Lite documentation has been revised to improve the workflow information in the Getting Started Guide and on-line help. This stresses the importance of the Advisor Lite methodolgy for parallelizing serial applications and makes it easier to follow the workflow while using the tool.

Also, the Advisor Lite homepage http://software.intel.com/en-us/articles/intel-parallel-advisor-lite/ has been updated with new information to describe how and when to use Advisor Lite and when to use the Intel Parallel Studio tools. The updated site also includes a blog section as a convenient way to locate timely on-line publications about Advisor Lite.

The Release Notes have been updated to address using Advisor Lite Samples with different versions of Intel® Threading Building Blocks.

In addition, this update also helps Advisor Lite work more cleanly with the first updates of the Parallel Studio tools.

You should only install Advisor Lite Update 1 with Intel Parallel Studio products that are also at Update 1. To confirm that you have already installed Update 1 of Intel Parallel Amplifier, Intel Parallel Inspector, and Intel Parallel Composer, do the following:

1. From the Control Panel, select Add or Remove Programs.
2. Scroll to the Intel products.
3. Verify that the versions displayed show Update 1 for Intel Parallel Amplifier, Intel Parallel Inspector, and Intel Parallel Composer.
4. If all products show Update 1 is installed, you can install Advisor Lite Update 1.

Uninstalling the Advisor Lite Update from systems with older versions of these products will cause the Amplifier, Inspector, and Composer items to disappear from the Visual Studio Help menu and the Solution Explorer context menu. You can fix the problem by using the Repair option for each product (Amplifier, Inspector, and Composer):

1. From the Control Panel, select Add or Remove Programs.
2. Scroll to the Intel product that needs to be repaired. Click (select) that product.
3. Select Change/Remove.
4. Select Repair.
5. Click Next>.
6. Click Repair.
7. Click Finish.

As hardware trends away from faster clocks towards more cores per chip, software must adapt to take advantage of multi-core architectures. Performance gains will have to come from parallelizing applications instead of waiting for more cycles per second.

Intel® Parallel Advisor Lite along with Intel® Parallel Studio lay out a multi-step process to aid developers in transitioning their serial code to parallel code. This blog article will focus on the first step of the process: How to determine where to add parallelism in an application.

Parallel Advisor Lite provides an easy to use GUI interface as a plug-in to Microsoft® Visual Studio that can help developers profile their code and understand where most of the time is being spent. These “Hotspots” are good starting points when deciding where to add parallelism in an application. Figure 1 shows a screenshot of some profile data generated by Parallel Advisor Lite on a K-Nearest Neighbors application.

Figure 1

Figure 1 shows that the majority of the program is spent in a function called “vector” (see the top function vector in the screenshot above) and a method called “KNN::distance”. Navigating to the vector function reveals that it is part of the Standard Template Library (STL). In my quest to parallelize my application I’m going to rule out diving into the STL and focus on the KNN::distance method. With the click of a mouse, Parallel Advisor Lite will automatically navigate me to the source code (definition) of this method. Figure 2 shows the breakdown of time spent in KNN::distance.

Figure 2

By looking at this method I can see that a single call shouldn’t take very long. All it does is calculate the distance between two points and it spends almost as much time returning the value as it does in the calculation. If I wrote this method myself I might have known it was fast without even navigating to the code.

If this was all the information that I had, I may be out of luck for parallelization because even though I’ve found the location of the bulk of my work, it doesn’t appear to be very conducive to parallelism. Now let’s switch to the Top-Down profile view that exposes where the calls to KNN::distance are coming from to open up more possibilities for parallelism.

Figure 3

Figure 3 revels that the KNN::predict method is making calls to distance and by looking at the source code I can see that it makes these calls in the body of a loop.

Now I’ve identified another possible site for parallelism that still focuses on the Hotspots of my code. This site appears to be a loop with independent iterations (the execution of one iteration isn’t dependent on a previous iteration), which is a prime candidate for parallelization.

The way Parallel Advisor Lite encourages us to use profile information can be very useful in uncovering the not-so-obvious locations where introducing parallelism may greatly improve performance.

You can download a free copy of Parallel Advisor Lite and an evaluation copy of Intel® Parallel Studio to try them out. I’ve used the tool and found that the Top-down and Bottom-up views are both useful in finding sites to parallelize. The Bottom-up view helps to identify the functions that are consuming the most time. The Top-down view can present call path information that may reveal better locations to introduce parallelism while still focusing on the hotspots. The timing breakdowns also reveal interesting characteristics about my applications that I wouldn’t have guessed, such as the heavy overhead of vector operations.

Do you think there are better ways to visualize the data?

Have you used the tool and been surprised by the results?

Please share your experiences and perspectives!

I'll not get into deep details about the application, but it does have many features (shutdown, restart, standby… even screenshot). While it doesn't have a huge crowd of users, it does have a lot of buzz and attention from top gadget and technology blogs (like LifeHacker, Gizmodo). This shows that there is a lot of interest in remote control and remote management solutions, even in home consumer markets.

And of course, I couldn’t stop thinking about Intel AMT when I saw these links. :)
What if we could add to the simplicity of this interface the features available in Intel AMT? For example, one short SMS message and your system is powered down (the "macho" way, without waiting for apps to close :) ).
Or what about setting 3PDS information to be retrieved later? Your computer could become your always-available note taking device :). Everyone in the family can 'tweet' the groceries list, and then anyone can retrieve it from a remote computer, without need to wake up the Operating System.

And even cooler, with an SMS message that stops a Software Agent from sending heartbeats, one can block the network connection with System Defense. Forgot a VoiceOverIP application connected? System Defense can block the specific protocol or port at a remote SMS command from the road.

I believe this simplicity and this availability will come.
In the future, technologies like AMT will be spread enough and easy to use enough for us to have such a straightforward interface. We will see semantic parsers that will let us text our machines "block all connections apart from port 31426, update the antivirus and then shutdown".

We are getting close, step by step. And Intel AMT can add a myriad of features to this future :).

To model potential parallelism, you insert Parallel Advisor Lite annotations into your source code to mark your tentative decisions about your program's parallel task structure. Annotations are textual hints that will not cause compilation or link-time errors when you are not building for Parallel Advisor Lite or when the Parallel Advisor Lite libraries are not found on your system. By using annotations, you avoid having dependencies on particular compilers or parallel constructs.

How to proceed…

1. Start by identifying likely locations to add parallelism with the use of a profiling tool.
   Using a Release configuration built with debug information, launch the Parallel Advisor Lite profile tool:
   
2. Create a new header file that is initialized with the Parallel Advisor Lite Annotation definitions and include it
   
3. Insert task annotations around a block of code that will execute as a task (red arrows below), then insert the site annotations around the task(s) that you want to execute in parallel with one another (blue arrows below). For example:
   
4. Build your project configurations as before (release configuration with debug information)
   

5. Confirm that the annotated sites and tasks have potential performance gains. This requires some manual effort since Parallel Advisor Lite does not provide a tool for this step.
   The process of how to evaluate the performance impact can be found in our help documentation.
   

6. Using a Debug configuration (with debug information) and a small representative data set, run the Parallel Advisor Lite Correctness Modeling tool to evaluate data accesses that occur within the annotated regions. Depending on the data observations reported, you may be required to insert annotations to model locking of a data access or model a “critical region” or consider larger changes to your source pool...

Once you achieve a clean Correctness Modeling run, you have the choice of replacing annotations with the parallel constructs (creating a parallel program) or looking for another region to prototype. You will be able to exploit the full potential of the Intel® Parallel Studio tools now that you have parallelized your application, such as using Intel(R) Parallel Amplifier to improve concurrency or Intel(R) Parallel Inspector to check for threading errors.

For more information about where and when to insert annotations can be found in our Parallel Advisor Lite help Task Organization and Annotations and in our Annotation Reference sections.


Note: Our annotate.h includes windows.h. This is due to combining what would typically be found in an annotate.h/.cpp file pair into a single file. Unfortunately, this inclusion can result in unexpected compilation errors when your application already includes windows.h. You can sidestep this issue by defining “WIN32_LEAN_AND_MEAN” as shown below

As a starting reference point I snapped a photo of an older 120GB Standard sized Hard Drive. Next to this is a US Quarter for size comparison. Next to that is my 8GB Solid State Thumb Drive. Pretty nifty… although I can’t say much for my amateurish photography skills.

So what fascinates me so much about this you might ask? A lot of things! For starters lets start with the size. The Hard Drive on the left is the standard 5 ¾”x4”x1”(Or ~17x12x 3cm thick). The USB 2.0 Thumb drive is 1 1/8th” x½”x 1/8th” thick (Or 3.5x1.5cm x ~2mm thick). The weight of this Hard Drive is a little over ~1.6lbs (~725g). Conversely on the other end of the spectrum we have the Thumb Drive pictured which weighs less than the quarter pictured or about ~.01 lbs (5g). Unfortunately I didn’t have a laptop Solid State Drive (SDD) on hand for this picture. However; it may not be necessary in order to get my salient points across which segue ways into my next topic.

Today it’s easy to purchase that standard Hard Drive with those dimensions with a 1TB of Hard Drive space (Capacity) for ~$80 USD. The Thumb Drive pictured is 8GB for ~$15 USD. Granted… larger capacities are available. I believe ~2TB or > are available for standard size Hard Drives; and ~64GB are available now for USB Thumb Drives as of July 2009.

Looking back in time, I didn’t have a 1999 PC Magazine on hand to reference for my full 10 year outlook, but still have one from Dec 2000. What I found out was that one could buy a 7.5 GB Ultra ATA IDE HD for ~$74 USD and on the higher end a 75GB Ultra 160 SCSI HD was ~$1100 USD.

This is pretty amazing when you stop and think about it. Here we are less than ten years afterwards where one can purchase a very affordable Standard Hard drive (1TB) that has over 100x the storage capacity for roughly the same price. When comparing that (1TB) Standard Standard Hard Drive to the SCSI Hard drive from 9 years ago we're getting ~13x the capacity for less than 1/10th of the price. When we switch gears and compare the USB 2.0 thumb drive with 64GB capacity available today for ~$144 USD to the higher end 75GB SCSI Hard Drive referenced, in a USB 2.0 Thumb Drive form factor we're able to achieve something that is roughly 1/10th the price, with nearly the same capacity, at almost 1/10th of the dimensional footprint, at roughly 1/140th of the weight!!!

So here are some of the future implications given those trends. Extrapolating this out to the 2019-2020 timeframe here’s roughly what we might expect:

1) For starters, if standard Hard Drives are even still around, it’s possible we might see an $80-USD Hard drive with ~100TB of capacity.
2) Current sized thumb drives could likely hit 1TB capacities for about ~$10-15 USD.
3) More advanced smaller drives might emerge that would likely be ~100GB capacity, with dimensions that are only a few Millimeters in size (~1/4” or <), for price points in the ~$100 USD range.

If the above trends materialize there are some very interesting future possibilities that will likely emerge. Some of which I believe are almost painfully obvious and have been already talked about in countless forums. However these are ones that excite me the most.

1) Desktop PC form factors as we know them today are likely to be much smaller and lighter. What am I going to do with 100TB of Storage? My theory is that we could all have our own personal Media Servers if we so chose.
2) Laptop form factors as we know them continue to become thinner, lighter, faster. I think there’s a point at which this tapers off. However; every lady today can now fit a Netbook into their purse. This becomes even more feasible as time goes on. Thankfully what this means for me is that I won’t have to be lugging 7lb laptops through airport security anymore!
3) Cell phones and Hand Held form factors seem to be the most likely candidates to be our PC’s of the future, if not at least the brain or memory aspects of where we store our information. These are likely to be easily ‘paired’ with thin clients, displays, etc. At work, in the airport, on a plane, etc.
4) Secure thumb drives are already very much like a hot swappable hard drive. If my thumb drive of the future has a Terabytes worth of capacity on it this makes it easier for me when I have to move all my data, profiles, favorites, etc to a new PC form factor.
5) Gaming platforms are likely to become very cheap, and very portable. Hopefully by then we won’t have proprietary game systems anymore. My games play on anything – anywhere.
6) Game media content itself, or any media for that matter, could also simply be just preinstalled on OEM machines. Entire DVD libraries or Educational software etc. could simply be ‘already there’. Things like carrying around the library of congress in your pocket is sort of fun to think about.

So there you have it. I could go on for another few pages worth of possibilities; but I think at this point it’s going to be more fun to turn it over to you the reader to get your viewpoints on where you think this is all going? Let’s hear your feedback!

If you have ever parallelized a serial program, you know how tricky it can be to answer these questions! With the move to multi-core processors, the need to parallelize software is becoming somewhat inevitable. Those who chose to continue to ship serial code are potentially exposing themselves to obsolescence. Parallelization is becoming essential for survival in this tough marketplace.

Moving from an existing serial code base to efficient and correct parallel code is often difficult, error prone and expensive. Using intuition to identify the parallelization opportunities and then ascertaining that the parallelization was done correctly can be hit-or-miss. The whole experience can be improved using a tool like Intel® Parallel Advisor Lite – which has been built for this exact problem.

Parallel Advisor Lite is a parallel modeler for your serial application – you would use this tool to explore or model parallel possibilities while keeping your application serial. This is important because a parallel modeler lets you continue to use your existing test system and debugging methods as you modify your application to resolve data access issues.

The Parallel Advisor Lite workflow guides you through the process of

1. identifying performance “hotspots” in your application; those regions where your program spends most of its time
2. inserting Parallel Advisor Lite annotations to model your parallel experiments
3. verifying the performance benefit
4. having Parallel Advisor Lite Correctness Modeling verify data accesses that occur within your annotated sites/tasks
5. resolving the data conflicts that were identified by Parallel Advisor Lite’s Correctness Modeling – by either modeling locks or refactoring your serial application
6. testing your source changes by running your existing test system – this is possible because your application is still serial

Tell us what you think of Parallel Advisor Lite - we appreciate your feedback! Did it lessen a pain or solve a problem you encountered on the road to effective parallelization? How can it be improved?

p.s. Did you know that Parallel Advisor Lite is not tied to a threading paradigm? Or that you can build with either the Microsoft® VC++ compiler or the Intel® C++ compiler?

Are you developing apps for netbooks on a Windows platform? Interested in selling them on the Intel BX Software Store? It doesn't matter if you're located in the US or Canada, you can still sell your products in the store to consumers and SMBs located in the US and Canada. Sign up here to submit your apps today!

Intel® Parallel Advisor Lite has been available for a week and the downloads continue! We are excited about this technology preview -- the documentation, samples, Correctness Modeling, and the Microsoft Visual Studio* integration.

As you know, there is no silver bullet when it comes to parallelizing an existing serial application. Chances are that your application evolved over the years, the original architects may have moved on, interesting coding practices may have crept in, but most importantly - the coding style took advantage of optimizing compilers. That's the key philosophical difference – serial applications are developed to have a minimal number of instructions. In parallel applications, we want to distribute the instructions across the available cores.

This is where Parallel Advisor Lite comes in. It will help you evaluate your serial application so that you can determine whether it can be transformed into an effective parallel application - if there are a few “serial optimization artifacts” you can remove them quickly and move on; but if you are faced with code that is full of complexities, you might decide to do something else.

Yes - the possibility exists that you will conclude that your serial application should not be parallelized - perhaps a better serial algorithm should be used instead.

What has been your experience?

Our very first blog post was written by CV Vick on July 7, 2006.  CV is a fellow developer and an all around good guy.  Since CV first talked about Pigs and Chickens we’ve had conversations about everything from Elevators in India to Why Linux People Lust After DTrace.  More importantly, we’ve expanded the blog authors to include non-Intel voices such as Asaf Shelly, Jim Corrigan, Dmitriy Vyokuv, Gaston Hillar, Matthew Wolf and plenty of others.  And you’ve made over 7200 comments to their posts!

What’s been especially exciting for me is to watch how we’ve transformed the way we communicate with each other.  It’s hard to imagine not being able to leave a comment on something written by an “expert”.  But that was just the beginning.  Today we see developers helping each other solve problems in forums, sharing their ideas through articles and blogs, showing off their skills in contests, and telling us how to make our products better by sharing ideas in the Ideazone.

Here are the top 5 posts of all time.

1. The C# Programming Language Version 4.0

2. UMPC MID Clamshell

3. Sony Vaio VGN UX27CN UMPC

4. What Does 256 Cores Look Like?

5. Intel(r) AMT User Notification Service

We’ve come so far, yet we’re just scratching the surface on how we work together as a community.  To celebrate this milestone I thought I’d ask you a question – what is your favorite blog post?