Channel 9 - Entries tagged with R2PERF

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 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) 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 class in optimized object initialization scenarios.

Lazy 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 class in class Producer/Consumer parallel computing scenarios.

BlockingCollection 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

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.

Arun Kishan: Inside Windows 7 - Farewell to the Windows Kernel Dispatcher Lock

Charles — Thu, 06 Aug 2009 17:28:00 GMT

You've learned about many of the new features of the latest version of the Windows kernel in the Mark Russinovich Inside Windows 7 conversation here on Channel 9. One of Mark’s favorite kernel innovations is the way the Windows 7 kernel manages scheduling of threads and the underlying synchronization primitives that embody kernel thread management.

Prior to Windows 7 (and therefore Windows Server 2008 R2) the Windows kernel dispatcher employed a single lock, the dispatcher lock, which worked well for a relatively small numbers of processors (like 64). However, now that we find ourselves in the midst of the ManyCore era, well, 64 processors aren’t that many... A new strategy was required to scale Windows to large numbers of processors since a single lock is limited in capability, by design: The masterful David Cutler, one of the world's greatest software engineers, wrote the NT scheduler in a time when the notion of affordable 256-processor machines was more science fiction than probable.

As we learned in the Mark Russinovich video, Windows 7 can now scale to 256 processors thanks to the great engineering of Arun Kishan, a kernel architect you've met on C9 back in the Vista days. In order to promote further scalability of the NT kernel, Arun completely eliminated the dispatcher lock and replaced it with a much finer grained set of synchronization primitives. Gone are the days of contention for a single spinlock. How did Arun pull this off, exactly, you ask? Who is this genius? Well, tune in. Lots of answers await…

Arun's work directly benefits the overall performance of Windows running on many processors and means, simply, Windows can now really scale. Thank you, Arun!

Spinlocks are synchronization primitives that cause a processor to busy-wait until the state of the lock’s memory location changes.

As the name implies, the dispatcher lock is the fundamental lock associated with the kernel dispatcher, or the scheduler.

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.

Parallel Programming with .NET Parallel Extensions

Phil Pennington — Tue, 05 May 2009 20:54:00 GMT

This video demonstrates the use of Parallel Extensions to the .NET Framework. Parallel Extensions requires .NET 3.5 and the final version will be part of the .NET 4.0 Framework when released. These extensions introduce new classes and functionality into the System.Threading namespace. It's now considerably easier to parallelize a code block without creating explicit threads.

Windows Server 2008 R2 and Windows 7 introduce new system-level features (e.g. User-Mode-Scheduling) that both the C++ Concurrency Runtime and the .NET Parallel Extensions extend. Developers may easily target current and legacy platforms using the new runtime and extensions.

First, a project is shown that counts the number of primes up to a given upper bound. Each number is checked by seeing if it’s divisible by any number between 2 and its square root. Each prime number found increases the count. The main control is a standard for loop.

Next, the same code is converted to work with the new Parallel.For() method. This takes the lower and upper bound, and a delegate for the action to take. Using a Lamda expression, the original loop body is made to work using i => {} syntax. When this code is run, it is clear that a bug has surfaced in the form of a bad prime count. This is actually a common multithreading bug, stemming from the use of the increment operator, ++. Using the Interlocked.Increment() method fixes the problem.

The next demo starts with a LINQ query and converts to a Parallel LINQ, or PLINQ, query. After demonstrating the original loop which uses Enumerable.Range() to generate a range of numbers, it is shown that ParallelEnumerable.Range() creates an enumerator that is automatically multi-threaded.

Finally, to demonstrate a more general-usage solution, any IEnumerable collection can easily be parallelized using the expression method AsParallel(). Thus, a collection students of type List could be used in a LINQ as a parallel query by simply using it as students.AsParallel().

Learn more about Parallel Computing on Windows at the MSDN Concurrency Dev Center.

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!

Dave Probert: Inside Windows 7 - User Mode Scheduler (UMS)

Charles — Mon, 02 Feb 2009 20:11:00 GMT

Here, we continue our exploration of the morphology of Windows 7 on Going Deep with windows kernel architect Dave Probert. You may remember him from an early four part episode of Going Deep where he teaches us about general purpose operating system architectures and history: Part 1, Part 2, Part 3, Part 4

That was a great conversation from a few years ago and it's been way too long since we returned to Windows kernel world to converse with and learn from Dr. Probert. Not surprisingly, Dave has been busy innovating the Windows core.

Dave and team, working very closely with the Parallel Computing Platform People, have created a very compelling new user mode thread scheduling/management system in Windows 7. In a nutshell, the User Mode Scheduler provides a new model for high-performance applications to control the execution of threads by allowing applications to schedule, throttle and control the overhead due to blocking system calls. In other words, applications can switch user threads completely in user mode without going through the kernel level scheduler. This frees up the kernel thread scheduler from having to block unnecessarily, which is a very good thing as we move into the age of Many-Core... Speaking of Many-Core, remember the piece we did on the Concurrency Runtime (ConcRT)? ConcRT is built on top of UMS and is the best way to most effectively utilize this new user mode thread scheduling model in Windows 7.

Make yourself comfortable and spend some time watching and listening to Dave make all of this crystal clear.

This is another great conversation with a fantastic OS architect and Windows kernel professor. Lots to learn here. Enjoy.

Mark Russinovich: Inside Windows 7

Charles — Wed, 14 Jan 2009 19:39:00 GMT

How has Windows evolved, as a general purpose operating system and at the lowest levels, in Windows 7? Who better to talk to than Technical Fellow and Windows Kernel guru Mark Russinovich? Here, Mark enlightens us on the new kernel constructs in Windows 7 (and, yeah, we do wander up into user mode, but only briefly). One very important change in the Windows 7 kernel is the dismantling of the dispatcher spin lock and redesign and implementation of its functionality. This great work was done by Arun Kishan (you've met him here on C9 last year). EDIT: You can learn exactly what Arun did in eliminating the dispatcher lock and replacing it with a set of synchronization primitives and a new "pre-wait" thread state, here. The direct result of the reworking of the dispatcher lock is that Windows 7 can scale to 256 processors. Further, this enabled the great Landy Wang to tune the Windows Memory Manager to be even more efficient than it already is. Mark also explains (again) what MinWin really is (heck, even I was confused. Not anymore...). MinWin is present in Windows 7. Native support for VHD (boot from VHD anyone?) is another very cool addition to our next general purpose OS. Yes, and there's more!

Tune in. This is a great conversation (if you're into operating systems). It's always great to chat with Mark.

New NUMA Support with Windows 7 and Windows Server 2008 R2, PM Talk

Phil Pennington — Wed, 14 Jan 2009 04:59:00 GMT

Windows Server 2008 R2 represents the latest evolution of the Windows Server operating system and corresponding support for high-end hardware systems with large numbers of microprocessors. Windows Server 2008 R2 is the first release of Windows to scale beyond 64 Logical Processors (LP) on a single computer.

R2 features enhanced support of Non-Uniform Memory Access (NUMA) computer architectures along with new User-Mode Thread Scheduling (UMS) technology. UMS enables custom thread-level scheduling within your own application. For certain categories of computing scenarios, this avoids the overhead of thread kernel transitions and context switching.

Why is this important for Application Developers? New commodity computer systems will soon appear that leverage many-core architectures. A system with 4 CPU sockets, 8 processor-cores per socket and with Simultaneous Multi-Threading (SMT) enabled per core, will readily achieve 64 Logical Processors. Application Developers will want to ensure their applications scale well on this new generation of high-performance commodity systems.

This presentation illustrates enhancements made to the Windows API to support more than 64 processors and enhanced NUMA support. Find detailed NUMA API usage scenarios at Code Gallery.

See related sessions on NUMA, UMS, and Concurrency.

New NUMA Support with Windows Server 2008 R2 and Windows 7

Phil Pennington — Tue, 13 Jan 2009 00:00:00 GMT

This presentation illustrates enhancements made to the Windows API to support more than 64 processors and enhanced NUMA support. Find detailed NUMA API usage scenarios at Code Gallery.

See related sessions on NUMA, UMS, and Concurrency.