Entries tagged with parallel computing - Channel 9

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.

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.

E2E: Erik Meijer and Burton Smith - Concurrency, Parallelism and Programming

Charles — Tue, 03 Nov 2009 16:19:00 GMT

The great Burton Smith, Microsoft Technical Fellow and an international leader in high-performance computer architecture and programming languages for parallel computing joins functional programming purist and language design guru Erik Meijer to discuss several major themes of parallel computing and distributed programming. As always, you will get a lesson in history, present trends and future possibilities. This is simply an awesome and deeply wonderful conversation. Burton is a treasure.

Erik shows up for the conversation only after Burton begins to talk about a potential definition for functional programming. Right on queue, Erik arrives!

Burton will be presenting his thinking on parallel and concurrent programming at PDC09. He will also be a panelist on the Future of Programming panel (and Erik will be the panel moderator - you won't want to miss the panel if you are attending PDC!).

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.

New Parallel Capabilities of the Visual Studio 2010 Profiler

Phil Pennington — Wed, 21 Oct 2009 20:17:00 GMT

Visual Studio 2010 (currently in beta) includes new Parallel Performance Analysis tools. The new Profiler is a must-have tool for Developers interested in designing new "many-core" parallel-computing applications. Join James as he illustrates the profiler, profiling-options, and concurrency visualization techniques.

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.

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 Performance Tuning for Haskell

Charles — Sat, 12 Sep 2009 19:30:00 GMT

Very interesting work with implications for integration into more mainstream runtimes... In general, runtime support for parallel tuning is necessary going forward. The Many Core age has only just begun... This paper is a great read.

Parallel Haskell programming has entered the mainstream with support now included in GHC for multiple parallel programming models, along with multicore execution support in the runtime. However, tuning programs for parallelism is still something of a black art. Without much in the way of feedback provided by the runtime system, it is a matter of trial and error combined with experience to achieve good parallel speedups.

This paper describes an early prototype of a parallel profiling system for multicore programming with GHC. The system comprises three parts: fast event tracing in the runtime, a Haskell library for reading the resulting trace files, and a number of tools built on this library for presenting the information to the programmer. We focus on one tool in particular, a graphical timeline browser called ThreadScope.

Ade Miller and Patterns of Parallel Programming

Robert Hess — Wed, 09 Sep 2009 19:06:00 GMT

While technically the PDC this year starts on November 17th, the day before that we will be hosting a set of day-long intensive workshops on several specific topics.

One of these workshops will focus on the Patterns of Parallel Programming in order to help developers understand how the applications they are developing can, and should, be designed to take advantage of the multi-core processers which are now becoming common.

In this episode, Ade Miller stops by to share with us the importance of understanding parallelism and some of the issues which need to be considered and how it isn't just a "recompile" to make your applications ready.

You can get more details about this workshop on the PDC website here:

Patterns of Parallel Programming
with Richard Ciapala, Ade Miller, Herb Sutter, Stephen Toub

If you are planning on attending this workshop, feel free to post comments, thoughts, and issues to the discussion thread here so that Ade and the other speakers be sure to try to incorporate your needs in their training material.

Christian Kleinerman: Introduction to SQL Server Project Madison

Charles — Tue, 01 Sep 2009 19:21:00 GMT

The SQL Server team is working on a new project code-named “Madison”. "Madison" is a highly scalable data warehouse appliance that delivers performance at low cost through massively parallel processing (MPP). How does it work? What's the story? Well, "Madison" Product Unit Manager Christian Kleinerman sure knows the answers and he provides an introduction to this new SQL data warehousing technology. Tune in.

More info here:

http://blogs.technet.com/dataplatforminsider/archive/2009/08/24/microsoft-ships-the-first-technology-preview-for-project-code-named-madison.aspx

The C++ Concurrency Runtime - Asynchronous Agents Library

Phil Pennington — Thu, 23 Jul 2009 03:55:00 GMT

The Asynchronous Agents Library (or just Agents Library) provides a programming model that enables you to increase the robustness of concurrency-enabled application development. The Agents Library is a C++ template library that promotes an actor-based programming model and in-process message passing for fine-grained dataflow and pipelining tasks. The Agents Library builds upon the scheduling and resource management components of the Concurrency Runtime.

The agent class itself is intended for course grained parallelism/components that handle larger computationally intensive tasks or collections of smaller tasks. Fundamentally, agents are tasks that have an observable lifecycle and communicate with other agents by using message passing. Agents are NOT intended to be used for fine-grained parallelism; for that, the patterns and constructs in the Parallel Patterns Library are better suited.

You'll want to subscribe to the Native Concurrency blog, find more resource and download example code from Code Gallery.

The C++ Concurrency Runtime - Parallel Patterns Library

Phil Pennington — Thu, 23 Jul 2009 03:55:00 GMT

The C++ Concurrency Runtime is new with Visual Studio 2010 and currently in beta. The runtime encapsulates and extends many new operating system features including NUMA resource locality and User-Mode-Scheduling.

The Parallel Patterns Library (PPL) provides an imperative programming model that promotes scalability and ease-of-use for developing concurrent applications. The PPL raises the level of abstraction between your application code and the underlying thread/task scheduling mechanisms by providing generic, type-safe algorithms and containers that act on data in parallel. The PPL also enables you to develop applications that scale by providing alternatives to shared state.

The PPL provides the following features:

Task Parallelism: a mechanism to execute several work items (tasks) in parallel.
Parallel algorithms: generic algorithms that act on collections of data in parallel.
Parallel containers and objects: generic container types that provide safe concurrent access to their elements.

By using PPL, you can introduce fine-grained parallelism without even having to manage a scheduler. You would use the Asynchronous Agents Library instead to express coarse-grained parallelism.

You'll want to subscribe to the Native Concurrency blog, find more resource and download example code from Code Gallery.

Expert to Expert: Erik Meijer and Michael Isard - Inside Dryad

Charles — Tue, 21 Jul 2009 15:55:00 GMT

Microsoft Research recently announced the availability, under Academic Licensing, of Dryad, an infrastructure which allows a programmer to use the resources of a computer cluster or a data center for running data-parallel programs.

A Dryad programmer can use thousands of machines, each of them with multiple processors or cores, without knowing anything about concurrent programming.

That's a pretty heady statement. What does Dryad do, exactly, to enable this level of abstraction, shielding programmers from the incredibly complex world of distributed parallel computing? Does the level of abstraction impact the degree to which sophisticated programmers can interact with and control some of the low level mechanisms of the Dryad runtime? What is it about LINQ that made it the no-brainer managed programming abstraction for Dryad?

Simply, how does Dryad work? This is the core question that Erik and I had after our conversation with Roger Barga (part one of this E2E mini-series on Dryad and DryadLINQ - perhaps we should focus just on DryadLINQ next time, but for now, all the information in this conversation is certain to keep you very busy and answer many questions you may have after learning about Dryad in part one...).

Lots of whiteboarding here. Put on your thinking caps!

Enjoy.

Expert to Expert: Erik Meijer and Roger Barga - Introduction to Dryad and DryadLINQ

Charles — Thu, 16 Jul 2009 16:43:00 GMT

Microsoft Research recently announced the availability, under Academic Licensing, of Dryad, an infrastructure which allows a programmer to use the resources of a computer cluster or a data center for running data-parallel programs. A Dryad programmer can use thousands of machines, each of them with multiple processors or cores, without knowing anything about concurrent programming.

DryadLINQ is the managed high level programming abstraction used to compose Dryad vertex topology graphs that the Dryad infrastructure uses to partition parallel computations. Here, Erik Meijer and Dryad team member Roger Barga discuss Drayad and DryadLINQ at a high level so that most of us can understand the implications, history and future of Dryad. This is an introductory piece. Erik and I will dive deep into Dryad with one of the scientists behind it in the second part of this Expert to Expert mini series on Dryad. UPDATE: The Going Deep episode on Dryad is now live.

Enjoy! This is incredible and important technology for simplifying the inherent complexity of distributed computation in the cloud. In essence, DryadLINQ enables a sequential programming experience over what will execute across potentially thousands of machines (depending upon the computational complexity of the program) concurrently. Much to learn here. Channel 9 will help teach.

Editorial note: When we discuss native code and the implementation of Dryad, the focus is on DryadLINQ not the Dryad infrastructure and low level vertex APIs, which are written in C++. Just to be clear...

Useful links:

Connect site: http://connect.microsoft.com/site/sitehome.aspx?SiteID=891

ER Website on Academic Use: http://research.microsoft.com/en-us/collaboration/tools/dryad.aspx

MSR Info: http://research.microsoft.com/en-us/projects/dryadlinq/

Parallel Computing TechTalk (nur der VS2010 Teil)

Dariusz Parys — Thu, 16 Jul 2009 05:13:00 GMT

Dies ist die Aufzeichnung der Parallel Computing TechTalk Tour die zusammen mit Intel(r) durchgeführt wurde. Die komplette Aufzeichnung des Abends findet sich hier.

Diese Aufzeichnung stellt nur den Teil rund um Visual Studio 2010 vor.

Viel Spaß beim reinschauen,
Dariusz

Task Parallel Library: Parallel Invoke

Dariusz Parys — Thu, 09 Jul 2009 16:07:00 GMT

In diesem Screencast wird gezeigt wie die Klasse Parallel verwendet werden kann um einfache Funktionsblöcke parallel auszuführen. Der Screencast basiert auf der Visual Studio 2010 Beta 1 und demzufolge kann sich die API ändern.

Viel Spaß beim reinschauen,
Dariusz

Task Parallel Library: Task Results

Dariusz Parys — Tue, 07 Jul 2009 11:56:00 GMT

In diesem Screencast wird gezeigt wie die Klasse Task Rückgabewerte an die Ablauflogik zurückliefern kann. . Der Screencast basiert auf der Visual Studio 2010 Beta 1 und demzufolge kann sich die API ändern.

Viel Spaß beim reinschauen,
Dariusz