Channel 9 - Entries tagged with Concurrency Microsoft http://mschnlnine.vo.llnwd.net/d1/Dev/App_Themes/C9/images/feedimage.png Channel 9 - Entries tagged with Concurrency http://channel9.msdn.com/Tags/concurrency Channel 9 keeps you up to date with the latest news and behind the scenes info from Microsoft that developers love to keep up with. From LINQ to SilverLight – Watch videos and hear about all the cool technologies coming and the people behind them. http://channel9.msdn.com/Tags/concurrency en Sun, 19 May 2013 11:20:14 GMT Sun, 19 May 2013 11:20:14 GMT Rev9 47 2 25 C++ and Beyond 2012: Herb Sutter - C++ Concurrency Herb Sutter presents C++ Concurrency. This was filmed at C++ and Beyond 2012.

Get Herb's slides for this session.

Herb says:

I've spoken and written on these topics before. Here's what's different about this talk:

  • Brand new: This material goes beyond what I've written and taught about before in my Effective Concurrency articles and courses.
  • Cutting-edge current: It covers the best-practices state of the art techniques and shipping tools, and what parts of that are standardized in C++11 already (the answer to that one may surprise you!) and what's en route to near-term standardization and why, with coverage of the latest discussions.
  • Blocking vs. non-blocking: What's the difference between blocking and non-blocking styles, why on earth would you care, which kinds does C++11 support, and how are we looking at rounding it out in C++1y?

The answers all matter to you – even the ones not yet in the C++ standard – because they are real, available in shipping products, and affect how you design your software today.

]]> http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Herb-Sutter-Concurrency-and-Parallelism Herb Sutter presents C++ Concurrency. This was filmed at C++ and Beyond 2012. Get Herb's slides for this session. Herb says: I've spoken and written on these topics before. Here's what's different about this talk: Brand new: This material goes beyond what I've written and taught about before in my Effective Concurrency articles and courses. Cutting-edge current: It covers the best-practices state of the art techniques and shipping tools, and what parts of that are standardized in C++11 already (the answer to that one may surprise you!) and what's en route to near-term standardization and why, with coverage of the latest discussions. Blocking vs. non-blocking: What's the difference between blocking and non-blocking styles, why on earth would you care, which kinds does C++11 support, and how are we looking at rounding it out in C++1y? The answers all matter to you – even the ones not yet in the C++ standard – because they are real, available in shipping products, and affect how you design your software today. 4538 http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Herb-Sutter-Concurrency-and-Parallelism Fri, 04 Jan 2013 15:42:32 GMT http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Herb-Sutter-Concurrency-and-Parallelism Charles Charles 33 http://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Herb-Sutter-Concurrency-and-Parallelism/RSS C++ Concurrency Parallelism Programming Herb Sutter C++11 C++ and Beyond 2012 YOW! 2011: Martin Thompson - On Concurrent Programming and Concurrency Folklore Martin Thompson is the creator of Disruptor, a concurrent programming framework. He's passionate about solving hard problems - like writing scalable concurrent software systems. His session at YOW! - Tackling the Folklore Surrounding High Performance Computing - was excellent. You'll be able to see it online in the near future, so look for it on the YOW! site.

Martin is a Java and C++ developer and employs an analog design methodology to his digital development efforts. He thinks through the conceptual design and paints a detailed picture of the solution, then he writes code. Many developers do this, of course, but sometimes we don't think through the problem thoroughly enough before we start writing code. This is especially true when it comes to solving hard problems of a concurrent computing nature.

To Martin, the concurrency problem is as much a developer methodology, educational and behavioral problem as it is a pure technological one. We talk about this, of course. His perspectives on the subject are refreshing.

Tune in. Enjoy. Learn.

Thanks for joining us on C9, Martin. Keep pushing the envelope.

 

http://yowaustralia.com.au/YOW2011/general/details.html?speakerId=2336

The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff - Mary Catherine (MC), Lisa, Aino, Melissa, and others - for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great developers down under. That's for sure. The speakers are exceptional—Dave and team set a high bar!

]]> http://channel9.msdn.com/Blogs/Charles/YOW-2011-Martin-Thompson-On-Concurrent-Programming-and-Concurrency-Folklore Martin Thompson is the creator of Disruptor, a concurrent programming framework. He's passionate about solving hard problems - like writing scalable concurrent software systems. His session at YOW! - Tackling the Folklore Surrounding High Performance Computing - was excellent. You'll be able to see it online in the near future, so look for it on the YOW! site. Martin is a Java and C++ developer and employs an analog design methodology to his digital development efforts. He thinks through the conceptual design and paints a detailed picture of the solution, then he writes code. Many developers do this, of course, but sometimes we don't think through the problem thoroughly enough before we start writing code. This is especially true when it comes to solving hard problems of a concurrent computing nature. To Martin, the concurrency problem is as much a developer methodology, educational and behavioral problem as it is a pure technological one. We talk about this, of course. His perspectives on the subject are refreshing.Tune in. Enjoy. Learn.Thanks for joining us on C9, Martin. Keep pushing the envelope.   http://yowaustralia.com.au/YOW2011/general/details.html?speakerId=2336 The YOW! Developer Conference offers outstanding opportunities to learn more about the latest practices, technologies, and methodologies for building innovative software solutions as well as the chance to meet and network with international software experts and other talented developers in Australia. Thanks to Dave Thomas and the event's excellent staff - Mary Catherine (MC), Lisa, Aino, Melissa, and others - for inviting me to this excellent pure developer event and thanks to all of the speakers for letting me take some of their time to record conversations for Channel 9. If you live in Australia, or aren't too far away, or just like to travel (who doesn't?), then you need to go to this yearly event. It's outstanding. There are many great d 1406 http://channel9.msdn.com/Blogs/Charles/YOW-2011-Martin-Thompson-On-Concurrent-Programming-and-Concurrency-Folklore Mon, 26 Dec 2011 19:41:13 GMT http://channel9.msdn.com/Blogs/Charles/YOW-2011-Martin-Thompson-On-Concurrent-Programming-and-Concurrency-Folklore Charles Charles 2 http://channel9.msdn.com/Blogs/Charles/YOW-2011-Martin-Thompson-On-Concurrent-Programming-and-Concurrency-Folklore/RSS C++ Concurrency High Performance Computing Java Parallel Computing Programming YOW! 2011 C&B 2011 Panel: Herb Sutter, Andrei Alexandrescu and Scott Meyers - Concurrency and Parallelism I was able to attend C++ and Beyond 2011 and it was a tremendous experience. The technical depth and C++ goodness was profound and lasted for 3 whole days (and two evenings). Thanks Andrei Alexandrescu, Scott Meyers and Herb Sutter for allowing me to crash your affair with my camera - which was perhaps too big and too advanced for the likes of me - still, I was abe to capture some great content like this interactive panel on Concurrency and Parallelism with Scott, Andrei and Herb. Great questions from attendees. Note that this is the second in a series of three panels from C++ and Beyond 2011 that will appear on C9 over the coming months.

Make sure to check out all the C&B 2011 content we're lucky enough to have stored on C9 Smiley

Enjoy! Learn!

Table of contents (click on the time code link to move the player to that point in time...):

[00:00] Using multiple cores for useful work...
[01:56] Does C++AMP build on PPL?
[02:48] What about operating system scheduling for GPU operations?
[03:49] Transition from platform-specific memory models to a standard(ized) C++ memory model (C++11's MM, to be specific...).
[06:41] Is there a performance penalty associated with a standard C++ memory model?
[09:18] What about functional languages/techniques (with respect to parallel and concurrent programming)?
[15:44] Which performance pitfalls we may pitfall into?
[16:13] What about the work on ranges and wouldn't they help parallelism?
[20:34] Fortran arrays have things like slices and strides. What about C++AMP?
[22:42] Parallel debugging...
[23:30] How baked is C++AMP?
[25:26] On SIMD and MIMD...
[34:20] Computation-following-data versus data-following-computation...

]]> http://channel9.msdn.com/Shows/Going+Deep/CB-2011-Panel-Herb-Sutter-Andrei-Alexandrescu-and-Scott-Meyers-Concurrency-and-Parallelism I was able to attend C++ and Beyond 2011 and it was a tremendous experience. The technical depth and C++ goodness was profound and lasted for 3 whole days (and two evenings). Thanks Andrei Alexandrescu, Scott Meyers and Herb Sutter for allowing me to crash your affair with my camera - which was perhaps too big and too advanced for the likes of me - still, I was abe to capture some great content like this interactive panel on Concurrency and Parallelism with Scott, Andrei and Herb. Great questions from attendees. Note that this is the second in a series of three panels from C++ and Beyond 2011 that will appear on C9 over the coming months. Make sure to check out all the C&B 2011 content we're lucky enough to have stored on C9 Enjoy! Learn! Table of contents (click on the time code link to move the player to that point in time...): [00:00] Using multiple cores for useful work...[01:56] Does C++AMP build on PPL?[02:48] What about operating system scheduling for GPU operations?[03:49] Transition from platform-specific memory models to a standard(ized) C++ memory model (C++11's MM, to be specific...).[06:41] Is there a performance penalty associated with a standard C++ memory model?[09:18] What about functional languages/techniques (with respect to parallel and concurrent programming)?[15:44] Which performance pitfalls we may pitfall into?[16:13] What about the work on ranges and wouldn't they help parallelism?[20:34] Fortran arrays have things like slices and strides. What about C++AMP?[22:42] Parallel debugging...[23:30] How baked is C++AMP?[25:26] On SIMD and MIMD...[34:20] Computation-following-data versus data-following-computation... 2446 http://channel9.msdn.com/Shows/Going+Deep/CB-2011-Panel-Herb-Sutter-Andrei-Alexandrescu-and-Scott-Meyers-Concurrency-and-Parallelism Tue, 15 Nov 2011 14:00:00 GMT http://channel9.msdn.com/Shows/Going+Deep/CB-2011-Panel-Herb-Sutter-Andrei-Alexandrescu-and-Scott-Meyers-Concurrency-and-Parallelism Charles Charles 3 http://channel9.msdn.com/Shows/Going+Deep/CB-2011-Panel-Herb-Sutter-Andrei-Alexandrescu-and-Scott-Meyers-Concurrency-and-Parallelism/RSS C++ Concurrency Parallelism Herb Sutter C++11 Andrei Alexandrescu Scott Meyers C++ and Beyond C++ and Beyond 2011 Visual Studio 11 Developer Preview: Concurrency Visualizer This discussion about new Concurrency Visualizer features available in Visual Studio 11 Developer Preview includes team members James Rapp, Sasha Dadiomov, Matthew Jacobs, and Alexey Kamenev.  Some of the new features include C++ AMP profiling support, an SDK for custom visualizations, and improved performance. 

See more details at the Concurrency Visualizer team blog: http://blogs.msdn.com/b/visualizeparallel/.

]]> http://channel9.msdn.com/posts/Visual-Studio-vNext-Concurrency-Visualizer This discussion about new Concurrency Visualizer features available in Visual Studio 11 Developer Preview includes team members James Rapp, Sasha Dadiomov, Matthew Jacobs, and Alexey Kamenev.  Some of the new features include C++ AMP profiling support, an SDK for custom visualizations, and improved performance.  See more details at the Concurrency Visualizer team blog: http://blogs.msdn.com/b/visualizeparallel/. 2827 http://channel9.msdn.com/posts/Visual-Studio-vNext-Concurrency-Visualizer Fri, 16 Sep 2011 15:28:14 GMT http://channel9.msdn.com/posts/Visual-Studio-vNext-Concurrency-Visualizer Charles Charles 3 http://channel9.msdn.com/posts/Visual-Studio-vNext-Concurrency-Visualizer/rss Concurrency Parallel Computing Parallel Computing Platform Visual Studio Visualization ICSE 2011: Victor Pankratius - Developing Manycore Applications with Concurrency Auto-Tuners Continuing on with our coverage of ICSE 2011, meet Dr. Victor Pankratius. Dr. Pankratius heads the Multicore Software Engineering investigator group at the Karlsruhe Institute of Technology, Germany. He also serves as the elected chairman of the Software Engineering for parallel Systems (SEPARS) international working group. Dr. Pankratius' current research concentrates on how to make parallel programming easier. His work on multicore software engineering covers a range of research topics including empirical studies, auto-tuning, language design, and debugging.

In this video, Wolfram Schulte joins Victor to discuss the challenges of making concurrency easier for developers. One of the really interesting approaches that Victor and team are investigating is concurrency auto-tuning, and the example discussed here involve adding OS kernel-level support for auto-tuning user mode applications for manycore processor architectures. This is very fascinating research with great potential. Concurrency auto-tuner in an OS kernel? Concurrency-enlightened operating systems? Why not? Always great to meet young innovators with no fear of failure. I hope to see this type of thing materialize. Very interesting research and real world problem.  Go Victor. Go!

Thanks to Wolfram and Victor for another great conversation. Tune in.

]]> http://channel9.msdn.com/posts/ICSE-2011-Victor-Pankratius-Developing-Manycore-Applications-with-Auto-Tuners Continuing on with our coverage of ICSE 2011, meet Dr. Victor Pankratius. Dr. Pankratius heads the Multicore Software Engineering investigator group at the Karlsruhe Institute of Technology, Germany. He also serves as the elected chairman of the Software Engineering for parallel Systems (SEPARS) international working group. Dr. Pankratius' current research concentrates on how to make parallel programming easier. His work on multicore software engineering covers a range of research topics including empirical studies, auto-tuning, language design, and debugging. In this video, Wolfram Schulte joins Victor to discuss the challenges of making concurrency easier for developers. One of the really interesting approaches that Victor and team are investigating is concurrency auto-tuning, and the example discussed here involve adding OS kernel-level support for auto-tuning user mode applications for manycore processor architectures. This is very fascinating research with great potential. Concurrency auto-tuner in an OS kernel? Concurrency-enlightened operating systems? Why not? Always great to meet young innovators with no fear of failure. I hope to see this type of thing materialize. Very interesting research and real world problem.  Go Victor. Go!Thanks to Wolfram and Victor for another great conversation. Tune in. 1155 http://channel9.msdn.com/posts/ICSE-2011-Victor-Pankratius-Developing-Manycore-Applications-with-Auto-Tuners Mon, 20 Jun 2011 21:21:02 GMT http://channel9.msdn.com/posts/ICSE-2011-Victor-Pankratius-Developing-Manycore-Applications-with-Auto-Tuners Charles Charles 0 http://channel9.msdn.com/posts/ICSE-2011-Victor-Pankratius-Developing-Manycore-Applications-with-Auto-Tuners/rss Computer Science Concurrency Kernel Microsoft Research MS Research Operating System Programming RiSE ICSE 2011 TPL Dataflow Tour This 15-minute video provides a high-level tour through some of the functionality available in the new TPL Dataflow library (System.Threading.Tasks.Dataflow.dll), an early preview of which was released as part of the Visual Studio Async CTP, available for download at http://msdn.com/vstudio/async.

]]> http://channel9.msdn.com/posts/TPL-Dataflow-Tour This 15-minute video provides a high-level tour through some of the functionality available in the new TPL Dataflow library (System.Threading.Tasks.Dataflow.dll), an early preview of which was released as part of the Visual Studio Async CTP, available for download at http://msdn.com/vstudio/async. 952 http://channel9.msdn.com/posts/TPL-Dataflow-Tour Fri, 10 Dec 2010 20:22:37 GMT http://channel9.msdn.com/posts/TPL-Dataflow-Tour Stephen Toub Stephen Toub 6 http://channel9.msdn.com/posts/TPL-Dataflow-Tour/rss Asynchronous Agents Concurrency Parallel Parallel Computing Parallel Computing Platform Async CTP Orleans: A Framework for Scalable Client+Cloud Computing
Orleans is a Microsoft Research (MSR) project and managed (.NET) software framework for building client + cloud applications. As outlined in the recently released paper on the topic: Orleans defines an actor-like model of isolated grains that communicate through asynchronous messages and manage asynchronous computations with promises. The isolated state and constrained execution model of grains allows the Orleans runtime to persist, migrate, replicate, and reconcile grain state without programmer intervention. Orleans also provides lightweight, optimistic, distributed transactions that provide predictable consistency and failure handling for distributed operations across multiple grains.

Here, we meet the Orleans team—Sergey Bykov, Alan Geller, Gabriel Kliot, James Larus, Ravi Pandya, and Jorgen Thelin—as they introduce Orleans and provide insights into the rationale and design decisions behind the project and also spend a fair amount of time focusing on the basic unit of isolated computation in Orleans, the grain. Very interesting and promising research! 

I highly recommend that you read the paper—it's very approachable and makes many aspects of Orleans crystal clear. In fact, that's the goal of the Orleans project: to make reliable and scalable distributed concurrent computing easier for developers to compose using tools and concepts they already understand (.NET). As we all know, it's hard to effectively program scalable distributed concurrent systems reliably. Orleans's goal is to change this fact by exploring and implementing new approaches (like grain-based programming) using novel combinations of time-tested programming models and technologies (actors, promises, transactions, etc). 

Tune in. Enjoy.

]]> http://channel9.msdn.com/Shows/Going+Deep/Project-Orleans-A-Cloud-Computing-Framework Orleans is a Microsoft Research (MSR) project and managed (.NET) software framework for building client + cloud applications. As outlined in the recently released paper on the topic: Orleans defines an actor-like model of isolated grains that communicate through asynchronous messages and manage asynchronous computations with promises. The isolated state and constrained execution model of grains allows the Orleans runtime to persist, migrate, replicate, and reconcile grain state without programmer intervention. Orleans also provides lightweight, optimistic, distributed transactions that provide predictable consistency and failure handling for distributed operations across multiple grains.Here, we meet the Orleans team—Sergey Bykov, Alan Geller, Gabriel Kliot, James Larus, Ravi Pandya, and Jorgen Thelin—as they introduce Orleans and provide insights into the rationale and design decisions behind the project and also spend a fair amount of time focusing on the basic unit of isolated computation in Orleans, the grain. Very interesting and promising research!  I highly recommend that you read the paper—it's very approachable and makes many aspects of Orleans crystal clear. In fact, that's the goal of the Orleans project: to make reliable and scalable distributed concurrent computing easier for developers to compose using tools and concepts they already understand (.NET). As we all know, it's hard to effectively program scalable distributed concurrent systems reliably. Orleans's goal is to change this fact by exploring and implementing new approaches (like grain-based programming) using novel combinations of time-tested programming models and technologies (actors, promises, transactions, etc). Tune in. Enjoy. 3777 http://channel9.msdn.com/Shows/Going+Deep/Project-Orleans-A-Cloud-Computing-Framework Thu, 02 Dec 2010 23:07:10 GMT http://channel9.msdn.com/Shows/Going+Deep/Project-Orleans-A-Cloud-Computing-Framework Charles Charles 10 http://channel9.msdn.com/Shows/Going+Deep/Project-Orleans-A-Cloud-Computing-Framework/RSS .NET 4.0 .NET Framework 4.0 Cloud Computing CLR 4 Concurrency Developer Tools Distributed Computing Microsoft Research MS Research Programming E2E: Concurrent Programming with Revisions  

 

Building applications that are responsive and can exploit parallel hardware poses an important challenge. In particular, enabling applications to execute various tasks in parallel can be difficult if those tasks exhibit read and write conflicts. Revisions are forked and joined much like asynchronous tasks. However, rather than accessing global shared data directly (and thereby risking data races or atomicity violations), all revisions execute on a (conceptual) copy of the shared state, a "global mutable snapshot" so to speak. Any changes performed in a revision apply to that snapshot only, until the revision is joined at which the [sic] changes become globally effective [source = http://research.microsoft.com/en-us/projects/revisions/].

Here, Erik Meijer interrogates (in a nice way) computer scientists Daan Leijen and Sebastian Burckhardt, the researchers behind Revisions. As usual, Erik asks great questions and the scientists spend much of the time at the whiteboard, drawing and writing answers to clearly explain what revisions are, how they work, and why this model matters. In a nice twist of fate, Erik was Daan's PhD advisor at Utrecht University in the Netherlands (that must have been awesome—lucky Daan!).

Revisions are yet another example of the great work coming out of the RiSE group in MSR. You don't have to wait for a "CTP" of Revisions for C# -> Just go to http://rise4fun.com/Revisions and write some code! Thanks to Peli and the RiSE team developers for implementing such an awesome web-based experimentation sandbox.

Tune in. Learn. Enjoy.

 

]]> http://channel9.msdn.com/Shows/Going+Deep/E2E-Concurrent-Programming-with-Revisions     Building applications that are responsive and can exploit parallel hardware poses an important challenge. In particular, enabling applications to execute various tasks in parallel can be difficult if those tasks exhibit read and write conflicts. Revisions are forked and joined much like asynchronous tasks. However, rather than accessing global shared data directly (and thereby risking data races or atomicity violations), all revisions execute on a (conceptual) copy of the shared state, a "global mutable snapshot" so to speak. Any changes performed in a revision apply to that snapshot only, until the revision is joined at which the [sic] changes become globally effective [source = http://research.microsoft.com/en-us/projects/revisions/]. Here, Erik Meijer interrogates (in a nice way) computer scientists Daan Leijen and Sebastian Burckhardt, the researchers behind Revisions. As usual, Erik asks great questions and the scientists spend much of the time at the whiteboard, drawing and writing answers to clearly explain what revisions are, how they work, and why this model matters. In a nice twist of fate, Erik was Daan's PhD advisor at Utrecht University in the Netherlands (that must have been awesome—lucky Daan!). Revisions are yet another example of the great work coming out of the RiSE group in MSR. You don't have to wait for a "CTP" of Revisions for C# -> Just go to http://rise4fun.com/Revisions and write some code! Thanks to Peli and the RiSE team developers for implementing such an awesome web-based experimentation sandbox. Tune in. Learn. Enjoy.   4238 http://channel9.msdn.com/Shows/Going+Deep/E2E-Concurrent-Programming-with-Revisions Thu, 11 Nov 2010 17:54:37 GMT http://channel9.msdn.com/Shows/Going+Deep/E2E-Concurrent-Programming-with-Revisions Charles Charles 18 http://channel9.msdn.com/Shows/Going+Deep/E2E-Concurrent-Programming-with-Revisions/RSS Concurrency Erik Meijer Expert to Expert Microsoft Research MS Research Parallelism Programming RiSE Madan Musuvathi and Sebastian Burckhardt - Concurrency Fuzzing with Cuzz Madan Musuvathi and Sebastian Burckhardt, two Researchers at the Research in Software Engineering team (RiSE), explain and demo a new testing tool called Cuzz. As you will see in this video, Cuzz stands for "Concurrency fuzzing."

Cuzz is a very effective tool for finding concurrency bugs. Cuzz works on unmodified Win32 executables and is designed for maximizing concurrency coverage for your existing (unmodified) tests. It randomizes the thread schedules in a systematic and disciplined way, using an algorithm that provides probabilistic coverage guarantees.

The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA.

]]> http://channel9.msdn.com/Blogs/Peli/Concurrency-Fuzzing-with-Cuzz Madan Musuvathi and Sebastian Burckhardt, two Researchers at the Research in Software Engineering team (RiSE), explain and demo a new testing tool called Cuzz. As you will see in this video, Cuzz stands for "Concurrency fuzzing." Cuzz is a very effective tool for finding concurrency bugs. Cuzz works on unmodified Win32 executables and is designed for maximizing concurrency coverage for your existing (unmodified) tests. It randomizes the thread schedules in a systematic and disciplined way, using an algorithm that provides probabilistic coverage guarantees. The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA. 493 http://channel9.msdn.com/Blogs/Peli/Concurrency-Fuzzing-with-Cuzz Fri, 16 Jul 2010 17:23:00 GMT http://channel9.msdn.com/Blogs/Peli/Concurrency-Fuzzing-with-Cuzz Peli de Halleux Peli de Halleux 4 http://channel9.msdn.com/Blogs/Peli/Concurrency-Fuzzing-with-Cuzz/RSS Concurrency fuzzing Microsoft Research RiSE Software Engineering Research testing tools Northeast Roadshow: Parallel Programming with .NET 4 Chris Bowen is an overview of writing parallel code using the new classes and features available in .NET Framework 4 and the tools in Visual Studio 2010.  Based on a session given for the Northeast Roadshow, this walks through the basics of parallel programming, Tasks, PLINQ, data structures, debugging, and performance analysis.

Outline:
  • Introduction
  • [1:40] Parallelism
  • [3:29] Contention
  • [5:25] Threads, Thread Pool, Tasks & the TPL
  • [8:12] Demo - The Task Class
  • [14:42] Demo - PLINQ
  • [20:18] Data Structures & Primitives
  • [21:33] Demo - Barrier Class & CancellationSource/Token
  • [25:36] The Parallel Class
  • [27:09] Demo - Parallel Invoke() & For()
  • [30:04] Demo - Visual Studio 2010 Parallel Stacks & Parallel Tasks Windows
  • [32:41] Demo - Visual Studio 2010 Concurrency Visualizer
  • [39:08] Other Tools & Technologies for Parallel Computing
  • [40:57] Resources & Conclusion 

Slides for this session, and other Northeast Roadshow sessions, can be found on the Code Gallery.

]]> http://channel9.msdn.com/Blogs/dpeeast/Northeast-Roadshow-Parallel-Programming-with-NET-4 This screencast with Chris Bowen is an overview of writing parallel code using the new classes and features available in .NET Framework 4 and the tools in Visual Studio 2010.  Based on a session given for the Northeast Roadshow, this walks through the basics of parallel programming, Tasks, PLINQ, data structures, debugging, and performance analysis.Outline: Introduction [1:40] Parallelism [3:29] Contention [5:25] Threads, Thread Pool, Tasks & the TPL [8:12] Demo - The Task Class [14:42] Demo - PLINQ [20:18] Data Structures & Primitives [21:33] Demo - Barrier Class & CancellationSource/Token [25:36] The Parallel Class [27:09] Demo - Parallel Invoke() & For() [30:04] Demo - Visual Studio 2010 Parallel Stacks & Parallel Tasks Windows [32:41] Demo - Visual Studio 2010 Concurrency Visualizer [39:08] Other Tools & Technologies for Parallel Computing [40:57] Resources & Conclusion  Slides for this session, and other Northeast Roadshow sessions, can be found on the Code Gallery. 2563 http://channel9.msdn.com/Blogs/dpeeast/Northeast-Roadshow-Parallel-Programming-with-NET-4 Thu, 01 Jul 2010 01:41:00 GMT http://channel9.msdn.com/Blogs/dpeeast/Northeast-Roadshow-Parallel-Programming-with-NET-4 Chris Bowen Chris Bowen 0 http://channel9.msdn.com/Blogs/dpeeast/Northeast-Roadshow-Parallel-Programming-with-NET-4/RSS .NET 4.0 .NET Framework 4.0 Chris Bowen Concurrency DPEeast Northeast Parallel Parallel Computing Visual Studio 2010 Concurrency Visualizer High Speed Tour This 75-second video provides a quick introduction to the Concurrency Visualizer, a new profiling tool available in Visual Studio 2010. The Concurrency Visualizer enables you to look under the hood of your parallel applications and quickly discover performance bottlenecks. If you’re hungry to learn more, visit http://blogs.msdn.com/visualizeparallel.

]]> http://channel9.msdn.com/Blogs/LarryLarsen/Concurrency-Visualizer-High-Speed-Tour This 75-second video provides a quick introduction to the Concurrency Visualizer, a new profiling tool available in Visual Studio 2010. The Concurrency Visualizer enables you to look under the hood of your parallel applications and quickly discover performance bottlenecks. If you’re hungry to learn more, visit http://blogs.msdn.com/visualizeparallel. 76 http://channel9.msdn.com/Blogs/LarryLarsen/Concurrency-Visualizer-High-Speed-Tour Thu, 22 Apr 2010 03:46:00 GMT http://channel9.msdn.com/Blogs/LarryLarsen/Concurrency-Visualizer-High-Speed-Tour Larry Larsen Larry Larsen 3 http://channel9.msdn.com/Blogs/LarryLarsen/Concurrency-Visualizer-High-Speed-Tour/RSS Concurrency Visual Studio 2010 VS2010dk Microsoft Research: Tools to Help Resolve Concurrency Problems
At PDC09, Madan Musuvathi and Sebastian Burckhardt showed off some tools (“Cuzz” and “FeatherLite”) that Microsoft Research is currently working on that may one day assist developers in addressing concurrency issues they may be having in their application. I’ve invited them to join me today to talk with us about some of the issues involved with tracking down concurrency problems, as well as how each tool works.

If you’d like more information about the tools they are working on, you may want to check out their PDC09 session, which is available here:

You can also find more details about what Madan and Sebastian are doing in Microsoft Research on the Microsoft Research Website:

]]> http://channel9.msdn.com/Shows/The+Knowledge+Chamber/Microsoft-Research-Tools-to-help-resolve-concurrency-problems If you are developing multi-threaded applications, there is a possibility that you may be having concurrency problems, and these problems can be difficult to reproduce and identify.At PDC09, Madan Musuvathi and Sebastian Burckhardt showed off some tools (“Cuzz” and “FeatherLite”) that Microsoft Research is currently working on that may one day assist developers in addressing concurrency issues they may be having in their application. I’ve invited them to join me today to talk with us about some of the issues involved with tracking down concurrency problems, as well as how each tool works.If you’d like more information about the tools they are working on, you may want to check out their PDC09 session, which is available here: PDC09 Seminar:Concurrency Fuzzing & Data Races You can also find more details about what Madan and Sebastian are doing in Microsoft Research on the Microsoft Research Website: Cuzz FeatherLite Madan Musuvathi Sebastian Burckhardt 1016 http://channel9.msdn.com/Shows/The+Knowledge+Chamber/Microsoft-Research-Tools-to-help-resolve-concurrency-problems Fri, 05 Mar 2010 21:02:00 GMT http://channel9.msdn.com/Shows/The+Knowledge+Chamber/Microsoft-Research-Tools-to-help-resolve-concurrency-problems Robert Hess Robert Hess 3 http://channel9.msdn.com/Shows/The+Knowledge+Chamber/Microsoft-Research-Tools-to-help-resolve-concurrency-problems/RSS Concurrency Microsoft Research Multi-Core PDC09 PDC 2009 RiSE Channel 9 Live at PDC09: Stephen Toub Recorded Live, November 19th 2009 at 11:30AM (PST)
Click here for full schedule
]]> http://channel9.msdn.com/Blogs/NicFill/Channel-9-Live-at-PDC09-Stephen-Toub Channel 9 Live at PDC09: Stephen Toub with Charles TorreRecorded Live, November 19th 2009 at 11:30AM (PST)Click here for full schedule 1668 http://channel9.msdn.com/Blogs/NicFill/Channel-9-Live-at-PDC09-Stephen-Toub Fri, 18 Dec 2009 22:44:00 GMT http://channel9.msdn.com/Blogs/NicFill/Channel-9-Live-at-PDC09-Stephen-Toub Nic Fillingham Nic Fillingham 0 http://channel9.msdn.com/Blogs/NicFill/Channel-9-Live-at-PDC09-Stephen-Toub/RSS Ch9live Concurrency Concurrency Runtime Parallel Computing Parallel Computing Platform PDC09 PDC 2009 Stephen Toub Channel 9 Live Wes Dyer: Controlling Concurrency in Rx
These changes drastically improve the user experience. Your feedback inspired the future direction of Rx.

New bits can be found on the Rx DevLabs page ]]> http://channel9.msdn.com/Blogs/J.Van.Gogh/Controlling-concurrency-in-Rx The Rx team has received a lot of questions about Rx and concurrency, thread-affinity, timers and performance. In this video, Wes explains the major changes in the latest release of Rx. These changes drastically improve the user experience. Your feedback inspired the future direction of Rx. New bits can be found on the Rx DevLabs page 1516 http://channel9.msdn.com/Blogs/J.Van.Gogh/Controlling-concurrency-in-Rx Fri, 18 Dec 2009 21:31:00 GMT http://channel9.msdn.com/Blogs/J.Van.Gogh/Controlling-concurrency-in-Rx Jeffrey van Gogh Jeffrey van Gogh 6 http://channel9.msdn.com/Blogs/J.Van.Gogh/Controlling-concurrency-in-Rx/RSS Concurrency Parallel Computing Reactive Extensions Rx Wes Dyer and Stephen Toub: Rx and Px - Working Together 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. ]]> http://channel9.msdn.com/Blogs/Charles/Wes-Dyer-and-Stephen-Toub-Rx-and-Px-Working-Together 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. 1248 http://channel9.msdn.com/Blogs/Charles/Wes-Dyer-and-Stephen-Toub-Rx-and-Px-Working-Together Thu, 19 Nov 2009 21:56:00 GMT http://channel9.msdn.com/Blogs/Charles/Wes-Dyer-and-Stephen-Toub-Rx-and-Px-Working-Together Charles Charles 6 http://channel9.msdn.com/Blogs/Charles/Wes-Dyer-and-Stephen-Toub-Rx-and-Px-Working-Together/RSS Concurrency Parallel Computing Parallel Computing Platform Parallel Extensions Parallelism Px Reactive Extensions Rx E2E: Erik Meijer and Burton Smith - Concurrency, Parallelism and Programming 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!). ]]> http://channel9.msdn.com/Shows/Going+Deep/E2E-Erik-Meijer-and-Burton-Smith-Concurrency-Parallelism-and-Programming 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!). 3854 http://channel9.msdn.com/Shows/Going+Deep/E2E-Erik-Meijer-and-Burton-Smith-Concurrency-Parallelism-and-Programming Tue, 03 Nov 2009 16:19:00 GMT http://channel9.msdn.com/Shows/Going+Deep/E2E-Erik-Meijer-and-Burton-Smith-Concurrency-Parallelism-and-Programming Charles Charles 19 http://channel9.msdn.com/Shows/Going+Deep/E2E-Erik-Meijer-and-Burton-Smith-Concurrency-Parallelism-and-Programming/RSS Burton Smith Computer Hardware Concurrency Erik Meijer Expert to Expert Functional Programming Parallel Computing PDC09 PDC 2009 Visualizing Concurrency: VS 2010 Beta 2 - Parallel Performance Profiling Advancements 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

]]> http://channel9.msdn.com/Shows/Going+Deep/Visualizing-Concurrency-Inside-the-Concurrency-Visualizer-Profiling-Tool 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 2807 http://channel9.msdn.com/Shows/Going+Deep/Visualizing-Concurrency-Inside-the-Concurrency-Visualizer-Profiling-Tool Mon, 19 Oct 2009 17:21:00 GMT http://channel9.msdn.com/Shows/Going+Deep/Visualizing-Concurrency-Inside-the-Concurrency-Visualizer-Profiling-Tool Charles Charles 12 http://channel9.msdn.com/Shows/Going+Deep/Visualizing-Concurrency-Inside-the-Concurrency-Visualizer-Profiling-Tool/RSS Concurrency Parallel Computing Parallel Computing Platform Visual Studio 2010 Parallel Performance Tuning for Haskell 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.

]]> http://channel9.msdn.com/Blogs/Charles/Parallel-Performance-Tuning-for-Haskell 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. http://channel9.msdn.com/Blogs/Charles/Parallel-Performance-Tuning-for-Haskell Sat, 12 Sep 2009 19:30:00 GMT http://channel9.msdn.com/Blogs/Charles/Parallel-Performance-Tuning-for-Haskell Charles Charles 5 http://channel9.msdn.com/Blogs/Charles/Parallel-Performance-Tuning-for-Haskell/RSS Concurrency Haskell Parallel Computing Parallelism Programming STM.NET: Who. What. Why. Software Transactional Memory is no longer a pipe dream or the stuff of academics. STM.NET, as it's called, is ready for your experimentation.

The goal of STM.NET is to be able to exploit concurrency by using components written by experts and consumed by application programmers who can then compose together these components using STM. Transactional memory provides an easy-to-use mechanism to do this safely. STM.NET is of course not a concurrency silver bullet and this is an experimental rrelease of the .NET Framework that allows C# programmers to try out this technology, specifically a particular implementation of STM. 

The STM team really needs your feedback to understand if they're doing the right things to meet your needs. Traditionally, using STM for simple trasactional tasks didn't make sense. The overhead was too high. Is this still the case? What needed to change in the .NET Framework to enable STM.NET? Remember, this is a .NET Framework experiment to enable STM for managed code.

Here, we meet most of the team responsible for STM.NET:  Chris Dern‎, Yossi Levanoni‎, Sasha Dadiomov‎, Weirong Zhu‎, Sukhdeep Sodhi‎ and Lingli Zhang.

Tune in, meet the team and get a good sense of what this very small team has accomplished with STM.NET and  learn about some of the paths taken to get there. This represents really great engineering. Congratulations to the STM team! Now, Niners, go get the bits!

Enjoy. ]]> http://channel9.msdn.com/Blogs/Charles/STMNET-Who-What-Why Software Transactional Memory is no longer a pipe dream or the stuff of academics. STM.NET, as it's called, is ready for your experimentation. The goal of STM.NET is to be able to exploit concurrency by using components written by experts and consumed by application programmers who can then compose together these components using STM. Transactional memory provides an easy-to-use mechanism to do this safely. STM.NET is of course not a concurrency silver bullet and this is an experimental rrelease of the .NET Framework that allows C# programmers to try out this technology, specifically a particular implementation of STM.  The STM team really needs your feedback to understand if they're doing the right things to meet your needs. Traditionally, using STM for simple trasactional tasks didn't make sense. The overhead was too high. Is this still the case? What needed to change in the .NET Framework to enable STM.NET? Remember, this is a .NET Framework experiment to enable STM for managed code.Here, we meet most of the team responsible for STM.NET:  Chris Dern‎, Yossi Levanoni‎, Sasha Dadiomov‎, Weirong Zhu‎, Sukhdeep Sodhi‎ and Lingli Zhang. Tune in, meet the team and get a good sense of what this very small team has accomplished with STM.NET and  learn about some of the paths taken to get there. This represents really great engineering. Congratulations to the STM team! Now, Niners, go get the bits!Enjoy. 3153 http://channel9.msdn.com/Blogs/Charles/STMNET-Who-What-Why Fri, 14 Aug 2009 17:39:00 GMT http://channel9.msdn.com/Blogs/Charles/STMNET-Who-What-Why Charles Charles 9 http://channel9.msdn.com/Blogs/Charles/STMNET-Who-What-Why/RSS Concurrency Parallelism Programming Software Transactional Memory STM Expert to Expert: Erik Meijer and Michael Isard - Inside Dryad 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. ]]> http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Erik-Meijer-and-Michael-Isard-Inside-Dryad 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. 3993 http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Erik-Meijer-and-Michael-Isard-Inside-Dryad Tue, 21 Jul 2009 15:55:00 GMT http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Erik-Meijer-and-Michael-Isard-Inside-Dryad Charles Charles 15 http://channel9.msdn.com/Shows/Going+Deep/Expert-to-Expert-Erik-Meijer-and-Michael-Isard-Inside-Dryad/RSS Architecture C++ Cloud Computing Concurrency Distributed Computing Dryad DryadLINQ Erik Meijer Michael Isard Parallel Computing Programming Expert to Expert: Erik Meijer and Roger Barga - Introduction to Dryad and DryadLINQ 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/

]]> http://channel9.msdn.com/Blogs/Charles/Expert-to-Expert-Erik-Roger-Barga-Introduction-to-Dryad-and-DryadLINQ 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/ 1945 http://channel9.msdn.com/Blogs/Charles/Expert-to-Expert-Erik-Roger-Barga-Introduction-to-Dryad-and-DryadLINQ Thu, 16 Jul 2009 16:43:00 GMT http://channel9.msdn.com/Blogs/Charles/Expert-to-Expert-Erik-Roger-Barga-Introduction-to-Dryad-and-DryadLINQ Charles Charles 12 http://channel9.msdn.com/Blogs/Charles/Expert-to-Expert-Erik-Roger-Barga-Introduction-to-Dryad-and-DryadLINQ/RSS Concurrency Dryad DryadLINQ Erik Meijer Expert to Expert LINQ Parallel Computing Programming Sebastian Burckhardt - Data Race Detection with CHESS Sebastian Burckhardt gives a short tutorial of some of the new features of CHESS: data race detection and ChessBoard. CHESS is a concurrency testing tool takes a concurrent unit test and executes it with different thread schedules. Sebastian explains us how CHESS can detect data races, a very subtle kind of concurrency bug. You'll also learn how to drill into concurrency issues using the ChessBoard, a little application designed to drill and investigate concurrent tests.

The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA. ]]> http://channel9.msdn.com/Blogs/Peli/Data-Race-Detection-with-CHESS Sebastian Burckhardt gives a short tutorial of some of the new features of CHESS: data race detection and ChessBoard. CHESS is a concurrency testing tool takes a concurrent unit test and executes it with different thread schedules. Sebastian explains us how CHESS can detect data races, a very subtle kind of concurrency bug. You'll also learn how to drill into concurrency issues using the ChessBoard, a little application designed to drill and investigate concurrent tests. CHESS home page: http://research.microsoft.com/en-us/projects/chess/ CHESS forums: http://social.msdn.microsoft.com/Forums/en-us/chess/threads/ The Research in Software Engineering team (RiSE) coordinates Microsoft's research in Software Engineering in Redmond, USA. 1327 http://channel9.msdn.com/Blogs/Peli/Data-Race-Detection-with-CHESS Fri, 12 Jun 2009 18:31:00 GMT http://channel9.msdn.com/Blogs/Peli/Data-Race-Detection-with-CHESS Peli de Halleux Peli de Halleux 6 http://channel9.msdn.com/Blogs/Peli/Data-Race-Detection-with-CHESS/RSS CHESS Concurrency Microsoft Research Reliability RiSE Software Engineering Research Testing MetraTech: Polymorphic Iterators, Concurrency, CRM and MetraFlow Donald Trump recently praised Metratech’s business model embraced by their customer, ACN, who appeared on the Celebrity Apprentice.  

Metratech’s own David Blair, Director of Product Architecture, discusses how Microsoft is both a partner and a customer of Metratech.  David shares how they leverage the “Infobus Pattern” architecture and apply a micro-architecture approach with polymorphic iterators to provide dynamic CRM and other valuable tools. David gives a sneak preview of MetraFlow their product for addressing highly concurrent systems with a cluster enabled model.  MetraTech Corp. offers an innovative approach to charging, billing, settlement and customer care that enables organizations to embrace change without compromise.  

The flagship product, MetraNet, is deployed globally, enabling diverse customers to build innovative and successful business models, securely collect revenue, and manage their entire customer lifecycle in some 12 languages, 17 currencies and 52 countries.

]]> http://channel9.msdn.com/Shows/Inside+Out/MetraTech-Polymorphic-Iterators-Concurrency-CRM-and-MetraFlow Donald Trump recently praised Metratech’s business model embraced by their customer, ACN, who appeared on the Celebrity Apprentice.   Metratech’s own David Blair, Director of Product Architecture, discusses how Microsoft is both a partner and a customer of Metratech.  David shares how they leverage the “Infobus Pattern” architecture and apply a micro-architecture approach with polymorphic iterators to provide dynamic CRM and other valuable tools. David gives a sneak preview of MetraFlow their product for addressing highly concurrent systems with a cluster enabled model.  MetraTech Corp. offers an innovative approach to charging, billing, settlement and customer care that enables organizations to embrace change without compromise.   The flagship product, MetraNet, is deployed globally, enabling diverse customers to build innovative and successful business models, securely collect revenue, and manage their entire customer lifecycle in some 12 languages, 17 currencies and 52 countries. 1548 http://channel9.msdn.com/Shows/Inside+Out/MetraTech-Polymorphic-Iterators-Concurrency-CRM-and-MetraFlow Wed, 20 May 2009 17:45:00 GMT http://channel9.msdn.com/Shows/Inside+Out/MetraTech-Polymorphic-Iterators-Concurrency-CRM-and-MetraFlow Charles Charles 0 http://channel9.msdn.com/Shows/Inside+Out/MetraTech-Polymorphic-Iterators-Concurrency-CRM-and-MetraFlow/RSS Concurrency CRM Programming Axum Published! Tutorial: Building your first Axum application 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<--

]]> http://channel9.msdn.com/Blogs/Charles/Building-your-first-Axum-application Not familiar with Axum?&nbsp;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 &quot;Maestro&quot;,&nbsp;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.&nbsp; 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.&nbsp; &nbsp; Axum Team Blog: http://blogs.msdn.com/maestroteam --&gt;Get Axum&lt;-- 319 http://channel9.msdn.com/Blogs/Charles/Building-your-first-Axum-application Thu, 07 May 2009 17:45:00 GMT http://channel9.msdn.com/Blogs/Charles/Building-your-first-Axum-application Charles Charles 9 http://channel9.msdn.com/Blogs/Charles/Building-your-first-Axum-application/RSS Axum Concurrency Parallel Computing Parallel Computing Platform Parallelism Programming Programming Languages Intelligent Light: Computational Fluid Dynamics and High Performance Computing
Intelligent Light, with its Fortran and Python writing programmers, represents a typical ISV in the Microsoft HPC partner community with their flagship application having long been available on UNIX and Linux HPC clusters.  Intelligent Light provides an application called FieldView that takes massive data from Computational Fluid Dynamics (CFD) applications  and visualizes that data for engineers who design F16 fighters and Formula One cars.  Because of the long compute times required, FieldView is often run in parallel on High Performance Computing (HPC) clusters to return quicker results.  In this video, Intelligent Light founder Steve Legensky demonstrates the complex mathematics used by CFD engineers and talks about how HPC has evolved in his industry over the past 20 years. 

Steve is awesome. 

 

Check out the Microsoft ISV site for more information about ISVs working with Microsoft.

]]> http://channel9.msdn.com/Shows/Inside+Out/Intelligent-Light-Computational-Fluid-Dynamics-and-High-Performance-Computing Before a plane flies for the first time, in the sky, it has flown many thousands of virtual miles in distributed clusters of computation cells, calculating non-linear differential equations of fluid dynamics.&nbsp; Intelligent Light, with its Fortran and Python writing programmers, represents a typical ISV in the Microsoft HPC partner community with their flagship application having long been available on UNIX and Linux HPC clusters.&nbsp;&nbsp;Intelligent Light provides an application called FieldView that takes massive data from Computational Fluid Dynamics (CFD) applications&nbsp; and visualizes that data for engineers who design F16 fighters and Formula One cars.&nbsp; Because of the long compute times required, FieldView is often run in parallel on High Performance Computing (HPC) clusters to return quicker results.&nbsp; In this video, Intelligent Light founder Steve Legensky demonstrates the complex mathematics used by CFD engineers and talks about how HPC has evolved in his industry over the past 20 years.&nbsp; Steve is awesome.&nbsp; &nbsp; Check out the Microsoft ISV site for more information about ISVs working with Microsoft. 2178 http://channel9.msdn.com/Shows/Inside+Out/Intelligent-Light-Computational-Fluid-Dynamics-and-High-Performance-Computing Wed, 08 Apr 2009 20:21:00 GMT http://channel9.msdn.com/Shows/Inside+Out/Intelligent-Light-Computational-Fluid-Dynamics-and-High-Performance-Computing Charles Charles 3 http://channel9.msdn.com/Shows/Inside+Out/Intelligent-Light-Computational-Fluid-Dynamics-and-High-Performance-Computing/RSS Computing Concurrency High Performance Computing HPC Server 2008 Intelligent Light Mathematics Parallel Computing Partner Partners Physics