Parallel Programming with .NET : Talks

PDC09 Parallelism Session Videos Now Available

toub — Sat, 21 Nov 2009 09:05:20 GMT

Attendees at PDC09 this past week were privy to quite a few sessions on parallel computing. Now that the videos of these sessions are online, you can view them as well from the comfort of your own home. Here are some of the key parallelism-related sessions from this past week:

Overview

The State of Parallel Programming

Managed code in Visual Studio 2010

Native code in Visual Studio 2010

HPC Server

Accelerating Applications Using Windows HPC Server 2008

Research and Incubation

Enjoy!

Scaling out PLINQ: DryadLINQ at PDC09 and Supercomputing09

toub — Wed, 11 Nov 2009 21:11:25 GMT

PLINQ enables developers to scale up computations in order to leverage the multiple cores available in modern hardware. For many problem domains, this is quite useful and sufficient. What happens, however, when a workload being processed is so big that even a manycore machine is insufficient to adequately handle the load? This can be the case with massively complex calculations. Moreover, in the age of “big data,” more and more we as an industry are encountering problems as we attempt to analyze and churn through data sets measured in terabytes and even petabytes.

In such situations, one solution is to scale out, distributing the computation amongst multiple computers aggregated into a computing cluster. That’s the domain of HPC, High Performance Computing, for which Microsoft provides valuable support through Windows HPC Server.

For those of you attending PDC09 or SC09 next week, we’re excited that we’ll be showcasing DryadLINQ, a project from Microsoft Research that runs LINQ queries on an HPC Server cluster. Instead of just using an IEnumerable, DryadLINQ provides a PartitionedTable entity that represents data partitioned across the nodes of the cluster. You can create a PartitionedTable from any IEnumerable, or you can preload the data onto the cluster manually. When you write a LINQ expression on a PartitionedTable, that expression is parsed and shipped to the cluster, which executes the expression in a distributed fashion. The Dryad execution infrastructure running on HPC Server and targeted by DryadLINQ handles the communication amongst the cluster nodes, deals with data partitioning, ensures proper aggregation, and so forth. The cluster nodes themselves run PLINQ in order to fully utilize as many cores as are available in the machine in order to achieve maximum speedup locally. Results can be streamed back into your program, or you can have them saved back into another partitioned table on the cluster to be reused by a subsequent query or manually at a later time.

Here’s an example of using DryadLINQ to implement the core of the PageRank algorithm:

public static IQueryable<Rank> Step(
    IQueryable<Page> pages, IQueryable<Rank> ranks)
{
    // Join pages with ranks, and disperse updates.
    var updates = from page in pages
                         join rank in ranks on page.name equals rank.name
                         select page.Disperse(rank);

    // Re-accumulate.
    return from list in updates
              from rank in list
              group rank.rank by rank.name into g
              select new Rank(g.Key, g.Sum());
}
…
var pages = PartitionedTable.Get<Page>(“pages.pt”);
var ranks = pages.Select(page => new Rank(page.name, 1.0));
ranks = Step(pages, ranks);
ranks.ToPartitionedTable<Rank>(“ranks.pt”);

As you can see, the actual algorithm is just a standard LINQ query and could run as well on a single machine (also in parallel if you used PLINQ’s AsParallel operator). However, as the data source is a PartitionedTable loaded from the cluster, this query will run now in a distributed fashion utilizing the remote environment, and all with very little additional effort.

If you’ll be at PDC09, we encourage you to go to John Vert’s presentation on DryadLINQ (currently scheduled in room 515A on Tuesday at 3:00 PM). If you’ll be attending SC09, come visit us at the Microsoft Exhibitor Booth for live demos, more details, and conversations about scenarios. Dryad and DryadLINQ are currently research projects, and we’d love any feedback you may have.

See you all soon!

Attending PDC09? Meet with the Parallel Computing Platform team.

toub — Tue, 03 Nov 2009 02:55:00 GMT

Are you attending PDC09? Want to meet with members of the Parallel Computing Platform team? See http://blogs.msdn.com/visualizeparallel/archive/2009/11/02/the-parallel-computing-platform-team-pcd-09.aspx for more details.

Slides from Parallelism Tour

toub — Mon, 02 Nov 2009 02:58:00 GMT

Last week, I had the privilege of touring around Tennessee, Kentucky, Ohio, and Michigan, speaking about the new parallel computing support in Visual Studio 2010 and the .NET Framework 4. Many folks I spoke with were interested in getting a copy of the slide deck I used, so I’ve attached it to this blog post. Enjoy!

Parallel Computing at PDC09 and TechEd Europe 2009

toub — Fri, 16 Oct 2009 17:28:23 GMT

It’s fall, and that means conference season! In November, members of the Parallel Computing Platform team will be descending upon both PDC09 in Los Angeles and TechEd Europe 2009 in Berlin. We’re extremely excited to see all of you there and to discuss the new support for parallel computing that’s coming in Visual Studio 2010, Visual C++ 10, and the .NET Framework 4. Please find us and introduce yourselves… we’re looking forward to speaking with you.

There are a bunch of cool sessions at both conferences having to do with parallel computing. Here’s a rundown of relevant announced sessions at the PDC:

A Computing Platform That Scales	See how Windows Server 2008 R2 represents the latest evolution of the Windows Server operating system and supports high-end hardware systems with large numbers of microprocessors. Learn how new Non-Uniform Memory Access (NUMA) and User-Mode Scheduling (UMS) API's effectively enable application developers to "minimize contention and maximize locality" of system resources relative to thread execution contexts. See how these new platform capabilities are extended via libraries such as the C++ Concurrency Runtime and the .NET Parallel Extensions along with complementary tools support within Visual Studio 2010.
Axum: A .NET Language for Safe and Scalable Concurrency	Axum is an incubation project from Microsoft's Parallel Computing Platform that aims to validate a safe and productive parallel programming model for the .NET framework. It's a language that builds on the principles of isolation, agents, and message-passing to increase application safety, responsiveness, scalability and developer productivity. Come learn about Axum and other advanced concepts we are exploring including data flow networks, asynchronous methods, and protocol-based component interactions.
Data-Intensive Computing on Windows HPC Server with the DryadLINQ Framework	Come get an overview of the DryadLINQ features and runtime environment, and walk through some real-world examples of DryadLINQ programs based on the familiar declarative syntax of LINQ combined with the fault-tolerant distributed graph scheduling of the Dryad runtime. Hear how DryadLINQ provides a programming model and runtime for data-parallel programs running across large clusters and partitioned data sets.
Lighting up Windows Server 2008 R2 Using the ConcRT on UMS	See examples of how to use C++ and the new Concurrency Runtime (ConcRT) to take advantage of new technologies on Windows Server 2008 R2, such as the ability to scale beyond 64 cores and User-Mode Scheduling (UMS) of threads. Learn to write code that scales even in the face of complicated processor architectures, Non-Uniform Memory Access (NUMA), and many-cores. Hear how ConcRT provides mechanisms that allow you to naturally express affinity requirements and schedule work on appropriate nodes without thrashing the system.
PLINQ: LINQ, but Faster!	Multi-core processors are everywhere! Parallel Language Integrated Query (PLINQ) in the Microsoft .NET Framework 4 offers a minimal-code solution to take advantage of this parallel hardware, providing an implementation of the .NET Standard Query Operators that uses parallel execution techniques underneath the simple LINQ programming to make applications run faster! Come for a deep dive into PLINQ via Microsoft Visual Studio 2010. See what it looks like from the perspective of LINQ developers, the debugging and profiling support, how it's implemented under the covers, and how to best incorporate it into your applications in order to reap the performance benefits of the manycore era.
F# for Parallel and Asynchronous Programming	Concurrency is increasingly important for many applications. The shift to manycore brings abundant parallelism to the desktop. The Web, Microsoft Silverlight, and distributed systems increase the demand for asynchronous solutions. F#, a functional and object-oriented language for Microsoft .NET, adds many tools to make parallel and asynchronous programming both fun and easy. Come hear the core concepts of the F# language, and see how ideas like immutability, functional design, async workflows, agents, and more can be used to meet the challenges of today’s real-world applications.
C++ Forever: Interactive Applications in the Age of Manycore	Developing concurrent applications is hard. Making them robust and responsive is even more challenging. The new asynchronous agents library and parallel debugging and profiling support in Microsoft Visual Studio 2010 simplify the situation, enabling you to develop I/O- and computationally-intensive applications that offload work from the UI and that make good use of available resources. Come for a deep dive into the power of actor-based and dataflow programming in Microsoft Visual C++ 2010. Learn how it can help you to write correct, efficient, and scalable applications.
The State of Parallel Programming	Parallel programming has been more difficult than it needs to be, perhaps because its tools have been treated as an “add-on” to serial programming. The objectives of composability and productivity demand something better. Come hear a relatively recent consensus view about what is needed for productive parallel programming, and why.
Manycore and the Microsoft .NET Framework 4: A Match Made in Microsoft Visual Studio 2010	The Microsoft .NET Framework 4 and Visual Studio 2010 include new technologies for expressing, debugging, and tuning parallelism in managed applications. Dive into key areas of support, including the new System.Threading.Tasks and System.Collections.Concurrent namespaces, cutting-edge concurrency views in the Visual Studio profiler, and debugger tool windows for analyzing the state of concurrent code.
Patterns of Parallel Programming: A Tutorial on Fundamental Patterns and Practices for Parallelism	The transition from single-core to multi-core technology is altering computing as we know it, enabling increased productivity, powerful energy-efficient performance, and leading-edge advanced computing experiences. Multi-core and HPC technologies are rapidly moving into the computing mainstream, allowing us to develop applications with improved performance, increased responsiveness, and reduced latency. This workshop is aimed at experienced software developers who are relatively new to the parallel computing space but expect it to become more important to their work. The workshop helps software developers understand the fundamental challenges of parallel computing, that span from the client to the cluster, such as synchronization, shared state, and moving from multi-core to multi-server. Learn how established software patterns can help developers building on both Microsoft’s Parallel Computing Platform—consisting of Task Parallel Library, PLINQ and Coordination Data Structures for .NET development, and Parallel Patterns Library and Concurrency Runtime for C++—and the HPC platform. The presenters describe the patterns in a bigger context, share their experience, and demonstrate implementations of these patterns in examples and demos. Learn how to add these patterns and new technologies to your toolbox.

There are also several good and related sessions at TechEd Europe:

F# for Parallel and Asynchronous Programming	Concurrency is increasingly important for many applications. The shift to manycore brings abundant parallelism to the desktop. The Web, Microsoft Silverlight, and distributed systems increase the demand for asynchronous solutions. F#, a functional and object-oriented language for Microsoft .NET, adds many tools to make parallel and asynchronous programming both fun and easy. This talk quickly reviews the core concepts of the F# language, and shows how ideas like immutability, functional design, async workflows, agents and more can be used to meet the challenges of today's real-world applications.
Parallel Computing for Managed Developers	The microprocessor industry has undergone a major paradigm shift from increasing clock speed with each successive hardware revision to increasing core count and potential for parallelism. This change requires software developers to think parallel in order to extract performance and provide a competitive user experience. This session discusses the new programming model and tools technologies in Visual Studio 2010 and .NET 4.0, including the Task Parallel Library (TPL), Parallel Language Integrated Query (PLINQ), and Concurrent Data Structures (CDS). Developers will also gain a deeper understanding of the advantages of building applications using these task-centric parallel technologies and will see demonstrations of several important patterns for parallelization.
Microsoft Visual C++ 2010: The "Fast" Way towards Modern Windows Applications	Do you love it when your application is the fastest on the block? Do you want to get the most of the Windows platform without re-writing your application and make it even faster in the process? Come and watch an action-packed demo and see how Visual Studio 2010 is a huge release for C++ developers! It's huge because it's focused on making it easier for ISVs who have many million lines of code. We have dramatically improved the scalability and productivity of the IDE and enabled MFC applications to seamlessly light up on Windows Vista and Windows 7. With the advent of highly parallel hardware, our adoption of the new C++ standard ushers in new ways to program scalable native applications.
Building High Performance Parallel Software	In this session, attendees will learn how to parallelize their software to take advantage of the industry shift to multicore hardware architectures. Several key aspects of achieving performance through parallelization will be covered, including identifying opportunities for parallelism, high performance patterns and best practices for parallel coding, effectively employing the new Visual Studio 2010 programming models, and the use of the Visual Studio 2010 Profiler to identify bottlenecks and optimize applications. Examples will be shown in both managed and native code.

Both events should prove to be very exciting. See you there.

Parallel Computing Presentations in Michigan, Ohio, Kentucky, and Tennessee

toub — Fri, 16 Oct 2009 15:49:29 GMT

In a week, I’m going to be traveling through Michigan, Ohio, Kentucky, and Tennessee, speaking about parallel computing, Visual Studio 2010, and .NET 4, primarily at corporations during the day and at user groups in the evenings.

If you’re in the area and interested, please do attend, and I look forward to meeting you! A list of events is available at http://blogs.msdn.com/jennifer/archive/2009/10/14/stephen-toub-parallel-computing-tour.aspx.

See you in a week!

Stephen

“Session-in-a-box” on Parallel Programming with .NET 4.0

toub — Thu, 12 Feb 2009 08:56:32 GMT

At PDC 2008 and TechEd EMEA 2008, Daniel Moth delivered several hit talks on parallel programming with the .NET Framework 4.0. The videos of both of those talks are available online, and he’s since created a series of blog posts capturing the content from those sessions in a way that should make it easy for others to re-present the content. Definitely worth a look: http://www.danielmoth.com/Blog/2009/02/give-session-on-parallel-programming-or.html.

Thanks, Daniel!

Parallelism Videos Galore

toub — Tue, 18 Nov 2008 11:14:00 GMT

It's been a hectic and exciting few weeks, and we on the Parallel Computing Platform team have been having a great time talking with customers all over the world, at the PDC, at TechEd EMEA, at DevConnections, through Channel 9, and more. A lot of the resulting material is now available online for viewing, so do check it out if you're interested.

PDC 2008 videos

Parallel Programming for Managed Developers with the Next Version of Microsoft Visual Studio

Parallel Programming for C++ Developers in the Next Version of Microsoft Visual Studio

Microsoft Visual Studio: Bringing out the Best in Multicore Systems

Concurrency Runtime Deep Dive: How to Harvest Multicore Computing Resources

Parallel Symposium: Addressing the Hard Problems with Concurrency

Parallel Symposium: Application Opportunities and Architectures

Parallel Symposium: Future of Parallel Computing

Research: Concurrency Analysis Platform and Tools for Finding Concurrency Bugs

The Concurrency and Coordination Runtime and Decentralized Software Services Toolkit

Channel 9: Visual Studio 2010 and .NET Framework 4.0 Week

Using the Parallel Extensions to the .NET Framework

Native Parallelism with the Parallel Patterns Library

Debugging Parallel Applications with Visual Studio 2010

TechEd EMEA 2008

Parallel Programming for Managed developers with Visual Studio 2010 and .NET Framework 4.0

Tech chat with Microsoft's parallel guru Steve Teixeira

Why we Need the Task-Based Programming Model Introduced in .NET 4

The Inexorable Drive to Many-Core Processors

Other (OnMicrosoft, University of Washington Colloquium, ...)

Concurrent Programming on Windows

Visual Studio 2010 Part 1 of 2- Support for Parallelism

Microsoft's Parallel Computing Platform: Applied Research in a Product Setting

And if you're more interested in the written word, check out this recent tech brief in Redmond Developer News:

Tech Brief: Parallel Extensions

All of this is, of course, in addition to all of the previous material that's been posted online, such as was mentioned at The Channel 9 videos are rolling in, Webcasts on Parallelism from France, Parallel Extensions Demo Fun on Channel 9, More Channel 9 Parallel Extensions Goodness, New PLINQ video on Channel 9, Task Parallel Library on Channel 9, Burton Smith on Channel 9, Parallel Extensions on .NET Rocks, Parallelism in October 2008 MSDN Magazine, and Another Parallel Extensions screencast.

Enjoy!

Concurrent, Multi-core Programming on Windows and .NET

toub — Tue, 28 Oct 2008 08:51:00 GMT

Thanks to everyone who attended our PDC pre-conference session yesterday on parallelism and concurrency! We had a wonderful turnout at the event, and David, Joe, and I all had a terrific time. Attached to this post are the slides we presented.

(It turns out that the PDC site does allow you to submit an evaluation for a precon. If you attended, we'd love your feedback.)

Concurrency Pre-Conference Session at the PDC

toub — Thu, 29 May 2008 20:47:28 GMT

Interested in parallel programming with .NET and on Windows? Thinking of attending the Microsoft PDC this year? Well, if you do, make sure to come a day early. The Parallel Computing Platform team will be presenting a day-long pre-conference session on October 26th from 10:00am-5:45pm:

Concurrent, Multi-core Programming on Windows and .NET
Presenter(s): David Callahan, Joe Duffy, Stephen Toub

It should be an awesome time. Register now.

Parallel Computing Platform at TechEd 2008

toub — Thu, 29 May 2008 08:16:00 GMT

Heading to TechEd 2008? Come discover some of the exciting technologies the Parallel Computing Platform team is working on.

We're presenting four sessions on parallelism at the Developer conference:

DVP205
The Microsoft Parallel Computing Initiative: Bringing Concurrency to the Masses
Tuesday, June 3 10:30 AM - 11:45 AM, S210 B

Software is headed for a fundamental change. Over the last 30 years, developers have relied on exponential growth in computing power in order to write applications that run fast. However, whereas the average PC clock speed increased more than ten-fold between 1993 and 1999, the average processor speed in the last four years hasn’t even doubled. Instead, the hardware industry is shifting to multi-core and manycore processors. The average PC on the market today is a dual-core. Next year, expect the average to be quad-core. Two years after that, eight-core. Unfortunately, most software today is single-threaded in nature and will not take advantage of multiple processors. The key to high-performance applications in the future is parallelism. In this session, we explore the need for concurrency, as well as what Microsoft is doing through its programming languages, libraries, runtimes, and tools to help developers leverage parallelism in their code.

DVP304
Parallelize Your Microsoft .NET Framework-Based Applications with Parallel Extensions
Wednesday, June 4 10:15 AM - 11:30 AM, S220 A

With the Microsoft .NET Framework today, correctly introducing concurrency into libraries and applications is difficult, time consuming, and error-prone. However, as the hardware industry shifts towards multi-core and manycore processors, the key to high-performance applications is parallelism. Parallel Extensions to the .NET Framework offers solutions to help make writing concurrent applications significantly easier. In this session, we dive into Parallel Extensions, exploring Parallel LINQ-to-Objects (PLINQ), the Task Parallel Library (TPL), the underlying concurrency runtime, and more, in order to provide an in-depth look at the next generation of parallel programming with .NET.

DVP316
Simplify Parallel Application Debugging and Profiling with Concurrency Tools in Microsoft Visual Studio
Thursday, June 5 8:30 AM - 9:45 AM, S330 C

Developing software doesn’t begin and end with writing code. Tools are incredibly important in the life cycle of applications, especially when it comes to debugging and improving performance. This is never more true than when writing parallel applications, as concurrency introduces a whole host of issues that can be very difficult to find and fix. In this talk, we explore difficulties with debugging and profiling concurrent applications, and we dive into powerful new tools being introduced in Visual Studio to improve their development.

TLA327
Parallelize Your Microsoft Visual C++ Applications with the Concurrency Runtime
Friday, June 6 8:30 AM - 9:45 AM, S310 A

Introducing concurrency into native Visual C++ applications has long been the domain of true experts and gurus. Yet, as the hardware industry shifts toward multi-core and manycore processors, all developers will need to be able to write robust and scalable parallel applications. As part of its work on Visual C++ and Visual Studio, the Parallel Computing Platform team is building a key set of technologies that will enable the development of such applications. In this talk, we explore libraries for expressing concurrency, a set of messaging APIs that allow developers to consistently build parallel applications that are robust and resilient, and a shared user-mode runtime for scheduling and for coordinating system resources. Come learn about these exciting new technologies that will help bring concurrency to the masses.

Heading to the IT Professional conference? No problem: we're presenting there, too!

APP253
The Manycore Shift: Bringing Concurrency to the Masses
Tuesday, June 10 3:00 PM - 4:15 PM, N220 A

Recent advances in microelectronic technology and the advent of multi-core and manycore processors are a signal that a large industry change is on the horizon. The computational power of manycore processors, new programming models and platforms, and advanced research in usability promises to change the way people interact with computers. As a result, software is headed for a fundamental change. Over the last 30 years, developers have relied on exponential growth in computing power in order to write applications that run fast. However, whereas the average PC clock speed increased more than 10x between 1993 and 1999, the average processor speed in the last four years hasn’t even doubled. Instead, the hardware industry is shifting to multi-core and manycore processors. The average PC on the market today is a dual-core. Next year, expect the average to be quad-core. Two years after that, eight-core. Unfortunately, most software today will not take advantage of multiple processors. The key to high-performance applications in the future is parallelism, and IT professionals need to be intimately aware of this coming shift so that the applications and scripts they develop can fully utilize all available processing power. In this session, we explore the need for concurrency as well as what Microsoft is doing through its programming languages, libraries, runtimes, and tools to help developers and IT professionals leverage parallelism in their code.

We're looking forward to seeing you there!

Q&As from the 2008 Financial Services Developer Conference

toub — Thu, 03 Apr 2008 18:27:00 GMT

A few weeks ago, I presented on Parallel Extensions to the .NET Framework at the 6th annual Microsoft Financial Services Developer Conference (the decks from the conference are now available online). I had a great time and a great audience, and during the presentation on Thursday I received some good questions. Here are some of them along with answers.

Question: This stuff looks really cool, but why do we need to modify our code to use Parallel Extensions; why can't you just automatically parallelize it for me?

Igor Ostrovsky, a developer on our team, has a nice set of explanations in his responses to some questions on the Parallel Extensions MSDN Forums:

"The way we traditionally express programs makes it very difficult for the compiler to understand the code at a high level, and parallelize the work. (A part of the problem is that understanding code at a high level is in some sense impossible - see the halting problem.) However, the user can help the parallel engine in various ways:

The user expresses the goal of the computation instead of the explicit steps to perform it (e.g. Parallel LINQ).

The user tells the parallel engine how to parallelize the computation (e.g. Task Parallel Library)

The user specifies certain invariants of the code (e.g. which parts are atomic - transactional memory)"

Question: Parallel Extensions looks like a great way to express concurrency in my applications, but how will I then debug my apps? Debugging parallel applications today is really hard... what are you doing about that?

It most certainly is hard, and we fully realize that developing software doesn’t begin and end with writing code. Tools are incredibly important in the life cycle of applications, especially when it comes to debugging and improving performance. This is never more true than when writing parallel applications, as concurrency introduces a whole host of issues that can be very difficult to find and fix. Alongside Parallel Extensions, the Parallel Computing Platform team is investing in the development of debugging and profiling tools that will increase developer productivity and improve the correctness and maintainability of parallel code. We haven't released previews of these tools yet, but you can expect to see them in the future.

Question: Do you need multiple cores or multiple processors to do multithreading? Is it possible to use Parallel Extensions on a single CPU machine, and if so, is there overhead in doing so?

Even with a single CPU, there are many places where multithreading can provide significant value. For example, in GUI programming on Windows, doing any significant work on the main GUI thread will cause user interaction with the application to suffer. Instead, it's better to offload work to a background thread, which can do processing while allowing the application to stay responsive. But when it comes to computationally-intensive tasks, multithreading on a single CPU can lead to decreased performance. Parallel Extensions seeks to minimize that decrease in performance. It can be used on a machine with a single CPU; the idea is that you write your code using Parallel Extensions correctly, and it will then help your application to scale from one to many cores. There is overhead to using Parallel Extensions (as there will be for pretty much any parallel framework), but we're working hard to minimize that overhead, and for many problems on multi-core machines, the overhead introduced will be greatly dwarfed by the parallel benefits received. On a single CPU, we can typically reduce the overhead to the point where for any problem that would have benefited from parallelism on a multi-core machine, the overhead will be negligible on a single core.

Question: Can one mix and match Parallel Extensions with existing concurrency mechanisms? For example, can I use the .NET ThreadPool in the same application as Parallel Extensions? Can I use monitors and mutexes and sempahores and reader-writer locks with Parallel Extensions just as I do with threads today?

Yes, to all of your questions. Parallel Extensions relies on threads, so you can continue to use existing synchronization primitives with Parallel Extensions just as you would with threads you spin up manually or with threads from the ThreadPool; we're also introducing some new synchronization and coordination primitives in upcoming releases of Parallel Extensions, so stay tuned for those. (Note, however, that there are some corner-case rules to be aware of. As an example, don’t evaluate futures or wait on tasks while holding a reentrant lock. Doing so isn't implicitly a problem, but it could lead to some issues that you'll need to be aware of; I'll dive into this further in a future blog post.)

Question: What is the relationship between HPC Server and Parallel Extensions? Does one replace the other?

Neither replaces the other, and in fact they're useful in combination. HPC Server is all about scaling out to nodes in a cluster of machines, and Parallel Extensions is all about scaling up on an individual machine. Just as you can use Parallel Extensions to parallelize your desktop applications, you can use Parallel Extensions to parallelize the .NET applications running on nodes in your cluster. This can be quite powerful when used in conjunction with HPC Server functionality like the new WCF-based SOA Service Broker.

Question: Is there any way to hook into the scheduler used by Parallel Extensions to automatically fan out the work to a cluster?

The scheduler in Parallel Extensions is not currently extensible in this way.

Question: Will the thread pool used by Parallel Extensions allow additional threads to be introduced when the number of cores increases?

Absolutely. When the threads in the pool are all being used to do useful work, the scheduler tries to maintain a ratio of one thread per core, so more cores typically translates to more threads. But in a variety of situations that ratio will not always be 1:1. In some cases, more threads may be used, such as if threads block (e.g. synchronization, I/O, etc.) or the user explicitly requests more threads through a TaskManagerPolicy. Similarly, a TaskManagerPolicy can be used to dial down the amount of available concurrency.

Question: Could you run out of memory if you have a large number of tasks?

Tasks are objects just like any other in .NET, and are subject to the same memory constraints as any other managed code. In the same vein, they're also managed by the CLR's garbage collector, such that completed tasks with no references left to them may be collected.

Question: Why will this be faster than using the ThreadPool?

There are a variety of reasons a work-stealing scheduler can perform better than a typical thread pool. For one, the scheduler in Parallel Extensions enables more scalable queue management in that it's not bottlenecked on a single queue storing all work items. Work items are distributed amongst multiple queues, ideally limiting contention on a single queue for all work; this becomes more and more important as the size of the work items decreases, as the number of threads contending for work increases, and as the number of cores running that work increases. These processor-local queues also enable lock-freedom, which contributes to the efficiency of retrieving work items and executing them. There are other significant benefits related to work-stealing for many types of problems, such as very efficient queueing mechanisms when creating tasks recursively. Moreover, the design can provide significant improvements to things like memory locality, which can greatly improve an algorithm's performance.

Question: If I'm testing my code on a single-core machine, can I simulate more cores?

To some extent. With the PLINQ programming model exposed in the CTP, you can provide a degree of parallelism value to the AsParallel extension method, which controls the number of threads that can be used to execute the query; by default on a single-core machine, this value will be 1, but you can explicitly make it larger. And for the Task Parallel Library, you can create new TaskManagers with specific TaskManagerPolicy instances that increase the number of threads that can be used beyond the number of cores on the machine. However, while it is possible to simulate it this way, your application won't be subject to some of the complexities of having multiple cores, and as a result some bugs in the parallel implementation may remain hidden or get hit with much less frequently.

Question: Does Parallel Extensions use threads or fibers?

Threads. Avoid using fibers in managed code: see http://www.bluebytesoftware.com/blog/PermaLink,guid,2d0038b5-7ba5-421f-860b-d9282a1211d3.aspx for more details.

Question: If I spin up a task, and it throws an exception, where will that exception bubble up?

Just as with the Asynchronous Programming Model pattern, where exceptions thrown during asynchronous execution are reraised when the EndXx method is called, exceptions thrown during the execution of a task will be reraised when the Task is waited on (e.g. task.Wait()).

6th Annual Microsoft Financial Services Developer Conference

toub — Sun, 09 Mar 2008 09:41:52 GMT

We'll be speaking this week in NYC about Parallel Extensions to the .NET Framework at the Microsoft Financial Services Developer Conference.

"The 2008 Microsoft Financial Services Developer Conference will focus on providing developers and architects in Financial Services a clear roadmap of the Microsoft development platform with a focus on High Performance Computing (HPC)."

We hope to see you there!

PLINQ at Seattle Code Camp

toub — Sun, 27 Jan 2008 20:29:07 GMT

In the Seattle area and want to hear more about PLINQ? Igor Ostrovsky, a developer on the Parallel Extensions team, will be speaking today at the Seattle Code Camp from 3:00-4:15pm. Check it out!