Entries tagged with parallel computing platform - Channel 9

Wes Dyer and Stephen Toub: Rx and Px - Working Together

Charles — Thu, 19 Nov 2009 21:56:00 GMT

Reactive Extensions for .NET (Rx) released this week during PDC09. Rx uses Parallel Extensions for .NET (Px) for all of it's concurrent and parallel computing needs. How is it using Px, specifically? What's going on here and why?

Stephen Toub, PM on the Px team, and Wes Dyer, developer on the Rx team, tell us all about this partnership the experience of collaborating on two very compatible technologies that, taken together, create something beautiful. Some many xs, so little time.

Enjoy.

Parallel Debugging in Visual Studio 2010 - MSDN mag companion

Daniel Moth — Fri, 13 Nov 2009 01:37:00 GMT

Author: Hi, I am Daniel Moth

Introduction:
This screencasts covers the new Parallel Tasks and Parallel Stacks debugging windows in Visual Studio 2010.

It demonstrates the sample code from the MSDN Magazine on this topic which you can read here:
Debugging Task-Based Parallel Applications in Visual Studio 2010

Speeding up Parallel.For using the Range Partitioner

Phil Pennington — Thu, 12 Nov 2009 18:29:00 GMT

Join Danny Shih as he demonstrates using the range partitioner feature. Parallel.For is great, but being a general solution, it does not perform optimally for certain specific scenarios, such as when there are a ton of iterations and very little work per iteration. In these cases, the range partitioner can be used to speed things up.

Learn more about the .NET Framework 4 and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

TaskCompletionSource

Phil Pennington — Thu, 12 Nov 2009 17:06:00 GMT

Join Danny Shih as he introduces the TaskCompletionSource<TResult> type. He’ll cover basic usage and walk through a full scenario

Learn more about the .NET Framework 4 and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Task and Task<TResult>, Waiting and Continuations

Phil Pennington — Thu, 12 Nov 2009 16:46:00 GMT

Join Danny Shih as he introduces the heart of the Task Parallel Library (TPL). He’ll talk about two core types (Task and Task<TResult>) and two functionalities that they support (waiting and continuations).

Learn more about the .NET Framework 4 and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Refactoring "for" Loops to Run in Parallel

Phil Pennington — Thu, 12 Nov 2009 16:13:00 GMT

Join Danny Shih as he demonstrates how to use the Task Parallel Library (TPL) to refactor sequential "for" loops so that they execute in parallel. He’ll also cover breaking out of parallelized loops.Collections and related constructs are new with .NET4 and Visual Studio 2010.

Learn more about the .NET Framework 4 and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Concurrent Programming with .NET4 Collections

Phil Pennington — Wed, 11 Nov 2009 18:23:00 GMT

Join Josh and Steve as they demonstrate how to use various concurrency-safe Collections classes.

Collections and related constructs are new with .NET4 and Visual Studio 2010.

Learn more about the System.Collections.Concurrent namespace and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

How to Cancel Work using .NET4 CancellationToken

Phil Pennington — Tue, 10 Nov 2009 23:08:00 GMT

Join Josh and Steve as they demonstrate how to safely cancel tasks in a parallel task execution scenario.

CancellationToken and related constructs are new with .NET4 and Visual Studio 2010.

Learn more about the System.Collections.Concurrent namespace and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Thread Blocking Analysis in the VS2010 Profiler

Phil Pennington — Mon, 09 Nov 2009 19:04:00 GMT

Join Bill Colburn once again as he demonstrates useful analysis techniques within the VS2010 Concurrency Visualizer. In this screencast, he demonstrates thread synchronization reports, unblocking stacks, and how to view crucial call sites. He also demonstrates how to get to the source code responsible for substantial thread blocking time.

Check-out the following additional resources:
- The Parallel Visualization Blog
- The MSDN Parallel Computing Dev-Center
- Visual Studio 2010 on Learning Center
- Parallel capabilities of the VS2010 profiler
- Download Visual Studio 2010 beta2
- Hazim Shafi’s Blog on Windows Parallel Performance Tools

See all videos in this series.

The .NET4 Countdown Synchronization Primitive

Phil Pennington — Thu, 05 Nov 2009 16:53:00 GMT

Join Josh and Steve as they demonstrate how to use the new .NET4 Countdown event synchronization primitive in task coordination scenarios.

Countdown and related constructs are new with .NET4 and Visual Studio 2010.

Learn more about the System.Collections.Concurrent namespace and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Lazy<T> Optimized Resource Initialization

Phil Pennington — Tue, 03 Nov 2009 18:48:00 GMT

Join Josh and Steve as they demonstrate how to use the new .NET4 Lazy<T> class in optimized object initialization scenarios.

Lazy<T> is one of many new thread-safe data-structures available with .NET4 and Visual Studio 2010.

Learn more about the System.Collections.Concurrent namespace and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Concurrent Visualization Techniques in the VS2010 Profiler

Phil Pennington — Tue, 03 Nov 2009 02:34:00 GMT

Join Bill Colburn as he demonstrates useful features of the Concurrency Visualizer available in VS2010. He discusses visualization of parallel-for loops, I/O reports, sorting the display of threads, and viewing thread affinity.

Check-out the following additional resources:
- The Parallel Visualization Blog
- The MSDN Parallel Computing Dev-Center
- Visual Studio 2010 on Learning Center
- Download Visual Studio 2010 beta2
- Hazim Shafi’s Blog on Windows Parallel Performance Tools

See all videos in this series.

BlockingCollection<T> Demonstration in Producer-Consumer Scenarios

Phil Pennington — Thu, 29 Oct 2009 21:22:00 GMT

Join Josh and Steve as they demonstrate how to use the new .NET4 BlockingCollection<T> class in class Producer/Consumer parallel computing scenarios.

BlockingCollection<T> is one of many new thread-safe data-structures available with .NET4 and Visual Studio 2010.

Learn more about the System.Collections.Concurrent namespace and keep abreast of Parallel Computing tools and techniques via the Concurrency Dev Center.

See all videos in this series.

Thread Visualization in the VS2010 Profiler

Phil Pennington — Tue, 27 Oct 2009 19:12:00 GMT

Join James Rapp once again as he dives deeper into the new parallel performance analysis tools available in Visual Studio 2010. In this video, he discusses ways of managing the quantity of data presented by the profiler and how to obtain meaningful statistics about your parallel application.

Check-out the following additional resources:
- The Parallel Visualization Blog
- The MSDN Parallel Computing Dev-Center
- Visual Studio 2010 on Learning Center
- Download Visual Studio 2010 beta2
- Hazim Shafi’s Blog on Windows Parallel Performance Tools

Visualizing Concurrency: VS 2010 Beta 2 - Parallel Performance Profiling Advancements

Charles — Mon, 19 Oct 2009 17:21:00 GMT

In Visual Studio 2010 Beta 1, you were introduced to new analysis and profiling capabilities (Parallel Profiling and Performance Tools) designed to make concurrency understandable and, ultimately, debuggable. Today, with the release of Visual Studio 2010 Beta 2, we introduce an updated and significantly more capable concurrency visualization and profiling tool which is available with other profiling features in Visual Studio 2010 Premium and Ultimate. What does it do, exactly? How does it work?
What's new?

Here, Architect Hazim Shafi, Dev Lead Sasha Dadiomov and PM Bill Colburn tell us all about the Concurrency Visualizer Profiling Tool, including a demo. So, fire up Beta 2, spin up some threads and visualize concurrency. You should profile an already-existing application that employs concurrency and, perhaps for the first time, get to see what your concurrent code is actually doing at run time.

Parallel visualization tools team blog: http://blogs.msdn.com/visualizeparallel/

The parallel computing dev center: http://msdn.microsoft.com/en-us/concurrency/default.aspx

Hazim's blog: http://blogs.msdn.com/hshafi/default.aspx

VS2010 Parallel Computing Features Tour

Daniel Moth — Mon, 19 Oct 2009 16:14:00 GMT

Author: Hi, I am Daniel Moth

Introduction:

In Visual Studio 2010, the Parallel Computing team has delivered APIs and tools for developers wanting to build applications that take advantage of multiple cores. This video provides a glimpse on the managed APIs, debugging windows and profiler support.

For more on the managed APIs, please start on the team's blog. For more on profiler start on that team's blog. For more on Parallel Tasks and Parallel Stacks please start on my blog post on Parallel Debugging.

Parallel Tasks – new Visual Studio 2010 debugger window

Daniel Moth — Mon, 15 Jun 2009 19:29:00 GMT

UPDATED for the VS2010 Beta 2 release

Author: Hi, I am Daniel Moth

Introduction:

In the next version of .NET and C++ that ship with Visual Studio 2010, a new task-based programming model is introduced. In this short video you will learn about Parallel Tasks, a new debugger window that helps developers debug applications that use tasks. You will also get a glimpse at the task-specific features of the Parallel Stacks debugger window introduced in another video.

To read more about the features of the Parallel Tasks window please read my blog post here. To follow some steps and explore the Parallel Tasks (and Parallel Stacks) windows on your own Visual Studio 2010 follow this MSDN walkthrough.

Parallel Stacks – new Visual Studio 2010 debugger window

Daniel Moth — Fri, 12 Jun 2009 21:21:00 GMT

UPDATED for the VS2010 Beta 2 release

Author: Hi, I am Daniel Moth

Introduction:

As developers try to take advantage of more and more cores in their applications, ultimately more and more threads will execute their code at the same time. When debugging such applications, there is a need to visualize multiple call stacks of multiple threads in a single view. This scenario is supported in Visual Studio 2010 via a new debugger window that this short video explores: Parallel Stacks.

To read more about the features of the Parallel Stacks window please read my blog posts here, here and here. To follow some steps and explore the Parallel Stacks (and Parallel Tasks) windows on your own Visual Studio 2010 installation, follow this MSDN walkthrough.

Axum Published! Tutorial: Building your first Axum application

Charles — Thu, 07 May 2009 17:45:00 GMT

Not familiar with Axum? Here's a C9 interview with the Axum team to refresh your memory (it's a domain specific language for concurrent programming, formerly known as "Maestro", developed by the Parallel Computing Platform team).

Here, Axum PM Josh Phillips walks us through building a simple Axum application in just over 5 minutes. Josh builds a simple “math library” on agents and shows how easy it is with Axum to focus on your code and get parallelism and safety implicitly.

Axum Team Blog: http://blogs.msdn.com/maestroteam

-->Get Axum<--

Concurrency and Parallelism: Native (C/C++) and Managed (.NET) Perspectives

Charles — Mon, 30 Mar 2009 17:24:00 GMT

Parallel Computing Platform team members Stephen Toub, Rick Molloy, Don McCrady and Dana Groff join me for a chat about the differences and similarities in their conceptual approach to designing and building concurrent programming abstractions targeting .NET developers and native (C/C++) developers.

Besides the obvious semantic (and runtime) differences between purely managed (.NET) and native code (C/C++), how does the Parallel Computing Platform team develop technologies for each domain and how are these technologies different? Surely, system level developers need system level tooling support that can improve their experience with writing native code that can effectively (and safely) scale to 8 cores (and that's nothing. How many cores will be the norm in 5-8 years? Mostly likely significantly more than 8....). There’s no PLINQ for C++, for example. That said, the fundamental problems the Parallel Computing Platform team are trying to solve span languages and runtimes, but are the differences only in implementation details and programming abstractions? What's the same? What's different? How? Why?

This is another great conversation with some of the folks designing and building technologies that will ultimately, in one form or another, converge into tools (or components of tools) that will help software developers effectively, efficiently and reliably compose applications and services in a Many Core world.

Enjoy!

Expert to Expert - Joe Duffy: Perspectives on Concurrent Programming and Parallelism

Charles — Tue, 17 Feb 2009 17:39:00 GMT

Joe Duffy spends a lot of time thinking about the future of concurrent programming and parallelism. In his role as Lead Developer in the Parallel Computing Platform team, Joe is the creator of PLINQ and a key contributor to many of the managed (.NET) concurrency incubations happening in and around his broader team. He's also an author (check out his latest book, Concurrent Programming on Windows)

You've met Joe many times before on C9 and the concurrency topic should be quite familiar to you by now (There's a lot of very innovative thinking going on in the parallel computing platform team (and it's not just about the managed world, as you know)).

We've spent a lot time discussing library-based approaches to enabling parallelism in a readily understanable, predictable, safe and scalable way for .NET programmers. We've also spent time on language level approaches to the problem (new constructs in C# that make it easier to compose in a semi-functional way (lamdas, LINQ, etc) or purely in a hybrid-functional way in F# or with experimental DSLs like Maestro).

Erik Meijer, Expert to Expert host, programming language designer and one of the high priests of the lamda calculus spends a great deal of time thinking about the problem of software's capability to scale effectively (as efficiently, safely, and as composable as possible) in the Many-Core age. So, we add Joe + Erik and we get many excellent, insightful questions and answers. Of course the notion of side-effects plays a big role here and we even debate the merits of Haskell in the real world. This is a great conversation. It goes deep, but not so far into the rabbit hole that you won't be able to find your way back. :)

Enjoy!

Expert to Expert: Meijer and Chrysanthakopoulos - Concurrency, Coordination and the CCR

Charles — Fri, 16 Jan 2009 20:56:00 GMT

In this episode of Expert to Expert, programming language designer Erik Meijer chats with CCR creator George Chrysanthakopoulos. We've spent a good deal of time on Channel 9 addressing the Concurrency Problem and the various approaches Microsoft is taking in an effort to help solve it. George's CCR is a piece of managed technology (.NET) that provides an unusually high degree of concurrency for developers targeting Windows. The Coordination and Concurrency Runtime has been around for about five years. How are people using it today to build scalable concurrent systems? What's the current state of the CCR and what's it's future? Why is the CCR a better approach to scalable distributed concurrent programming than other technologies out there? Is concurrency the real issue? George believes that it's all about coordination(the other C in CCR) and concurrency is really just a side effect of coordinating systems. If you get distributed coordination right, then you have a concurrent system that can scale. Really? Do explain, dear George (oh, and he does and as passionately as you'd expect from him). This is a fantastic conversation. Classic Channel 9.

Enjoy!

Parallel Computing in Native Code: New Trends and Old Friends

Charles — Mon, 12 Jan 2009 19:48:00 GMT

We've covered a lot of ground on both C++ and Parallel Computing on Channel 9 over the past few years. For C++ in particular, we've gone deep on many fronts with some of the main players in Microsoft's native programming world. Damien Watkins is one of these players and he's the brains behind most of the interviews you've seen on C9 (he thought them up and set them up). But who is Damien and what does he do?

Rick Molloy (PM) and Don McCrady(Development Lead) have been on Channel 9 before and they are both members of the native side of the parallel computing platform (PCP) house. It's no surprise that most teams who ship Microsoft software work closely with the C++ team given that most of our products are written in native code. The C++ team produces the de facto compiler that most teams at MS use. The PCP team is no exception.

We figured it would be fun to get a C++ player (Damien is a PM on the front-end native compiler team) and some Parallel People together in a room to discuss the native side of the Concurrency Problem (and possible solutions) and get a feel for the synergy between teams. The next version of C++, C++0x, will undoubtedly contain new language constructs that will make it easier to program many-core algorithms. We dig into some of these here as well as reveal for the first time on C9 some new members of the C++ language that you may not have heard about yet....

Enjoy. This is a great conversation among key thinkers who live in and innovate the native world.

Maestro: A Managed Domain Specific Language For Concurrent Programming

Charles — Mon, 22 Dec 2008 19:46:00 GMT

Josh Phillips(PM), Niklas Gustafsson(Architect), and Artur Laksberg(Developer) of the Parallel Computing Platform Team spend some time with me to discuss a managed (.NET-based) DSL (Domain Specific Language) for concurrent programming, Maestro. Maestro incorporates well-entrenched language patterns (imperative, OO, C style syntax, etc) and language constructs (channels, agents, domains) in a compelling way to make concurrent composition more accessible and familiar to the legions of sequential code composers.

Here we dig into the architecture and design of the Maestro language and compiler as well as discuss the philosophy behind this incubation project (at this point in time there are no plans to release Maestro as a product - it's a research project, an incubation...). Why create another language to help solve the Concurrency Problem? What's the advantage over implementing a library (this is .NET after all -> CLR + BCL = most of the power of the platform)? There's obviously good reasons for implementig Maestro as a language, but you'll need to watch and listen to find out.

Enjoy.

Note: After this interview was conducted and posted to Channel 9, the Maestro team has renamed their technology to Axum. So, they are now the Axum team and the managed DSL for concurrent programming they're incubating is called Axum. :)

Lynne Hill: Parallel Computing Platform - The Vision and Future

Charles — Thu, 23 Oct 2008 19:38:00 GMT

Over the past few months you've seen several interviews with members of Microsoft's Parallel Computing Platform team and we've learned about tooling advances, managed support for parallelism (Parallel Extensions for .NET), and native support for parallelism (the Concurrency Runtime).

Here, we meet the leader of the Parallel Computing Platform team, General Manager Lynne Hill. Lynne is a veteran Microsoft leader, starting the Parallel Computing Team and builiding it into what it is today, a relatively large organization with many virtual members spread across the entire company. The Parallel Computing Team (and the industry at large, of course) have a tremendously daunting task: bringing parallel computing to the general purpose masses. The Parallel Computing Platform is in fact making significant strides in this area, as I hope we've made clear on Channel 9. Lynne tells us about the vision of her team, the history of the problem and the future of parallelism. She makes it clear that with the advent of much more computing power the industry is poised to invent some incredibly interesting technologies that will enable new classes of computation experience for computer users. Now, the problem of getting a grip on how to harness the impending power of many-core in reasonable ways is of paramount importance. Go Lynne! Go!

Enjoy.