Build 2014: Favourite Sessions

Build2014

Build 2014 is a distant memory at this point. Luckily, all sessions are still available for viewing on Channel 9. Here are my favourite sessions from the conference.

Modern C++: What You Need to Know
If you’re still in the dark about C++11/14, check out Herb Suter’s talk on the power and ease of using the new additions to the C++ language. There’s also a great section in the talk about the performance benefits of C++ arrays (and contiguous arrays in general).

Tips and Tricks in Visual Studio 2013
Cathy Sullivan presents an hour of ways to increase productivity and decrease frustration in Visual Studio 2013. If you use Visual Studio on any sort of regular basis, you will benefit from this hour. Ctrl+Q is your friend.

Diagnosing Issues in Windows Phone XAML Apps Using Visual Studio
I’ve never written a Windows Phone App but still found this session very interesting. Dan Taylor uses Visual Studio to analyze CPU, UI throughput, memory, and energy efficiency issues. Visual Studio debugging and analysis tools have come a *long* way

Windows and the Internet of Things
Steve Teixeira helped me understand what the internet of things is all about. Great presentation and great content. Most of Build 2014 was focused on convergence of Windows, Phone, and XBox; this session introduced me to some divergent flavours of Windows that I had not heard of.

Native Code Performance on Modern CPUs: A Changing Landscape
There was a noticeable lack of low-level sessions at Build 2014 and so the minor headache induced by Eric Brumer’s complex talk was most welcome. The big takeaway: with ever-faster CPUs, memory operations have become the bottleneck. Dovetails nicely with Herb Suter’s session above, but goes much more in-depth.

Avoiding Cloud Fail: Learning from the Mistakes of Azure with Mark Russinovich
As always, Russinovich is engaging and informative. Though the talk is focused on cloud there are lessons here for all types of development, for example, pragmatic exception handling strategies.

Advertisements
This entry was posted in Performance, Training, Troubleshooting and tagged , , , , . Bookmark the permalink.

2 Responses to Build 2014: Favourite Sessions

  1. brucedawson says:

    I really like Eric’s talks, but I felt his analysis of the normal versus FMA dot products was incorrect, or at best incomplete.

    At the limit the normal dot product is limited by add latency (all multiplies can be parallelized enough to not matter) so the performance for 1,000 iterations is 3,000 cycles, or 3,005 cycles if you allow for the latency of the first multiply.

    Meanwhile the FMA loop is limited by FMA latency of 5 cycles, so 1,000 iterations is 5,000 cycles. But Eric coded it to do two independent FMAs per iteration, so it drops to 2,500 cycles.

    In other words, the no FMA version is intrinsically faster but Eric applied an unrelated optimization to the FMA case. If you apply the same optimization to the no FMA case (it will change the result so the compiler can’t do it automatically) then it should go faster also. If you do two parallel adds in the no FMA case then it will only take 1,500 cycles and will win handily. It may be that you will run out of floating-point units before you hit that rate, but that needs to be mentioned if that is the limiting factor.

    But, messy stuff and a good talk.

  2. Interesting. I suspect he may have tailored the presentation for the level of the people in the room. In any event, it helped me understand why developer intuition can be so far off the mark when it comes to performance optimization.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s