There is some truly amazing support for parallel programming in .NET 4.0. One of the compelling new features of the Thread Pool in .NET 4.0 is work-stealing, which allows work to be processed by worker threads more efficiently.
First of all, in addition to the global queue, there are local queues for each worker thread.
Let's say that the main program thread generated 2 tasks, which are added to the global queue.
Then each worker thread can take a task to process.
Then, suppose that Task 2 spawns three subtasks: Task 3, Task 4, and Task 5. These tasks are placed on the local queue of Worker Thread 1.
Next, assume Worker Thread 1 completes Task 2. It looks at its local queue, and takes the last task (Task 5) off to process. It purposefully takes the last task, the point being that the last task might still be in the cache, while it is likely that the first task (Task 3) is out of the cache. Hence, there are performance improvements in processing local queues in a LIFO order.
Now, assume Worker Thread p completes Task 1. It looks first at its local queue, and there are no tasks there. Then it looks at the global queue...no tasks there either. Finally, it looks at other local queues. This is the concept of work-stealing: it can "steal" tasks from those queues. So Worker Thread p would take Task 3 to process.
Note also that it steals work from the top of the queue (taking the first in), while Worker Thread 1 is processing from the bottom of the queue (taking the last in). That is to reduce contention. It also optimizes for caching: Worker Thread 1 is taking the tasks that are likely still in its cache, and Worker Thread p is taking the tasks that are least likely to be in Worker Thread 1's cache.
Finally, if Task 3 had further subtasks, they would be placed on Worker Thread p's local queue.
To learn more about the support for parallel programming in .NET 4.0, check out Daniel Moth's talk from PDC 2008 at http://channel9.msdn.com/pdc2008/TL26/. It was one of my top 2 favorite talks from PDC last year...Daniel is an amazing presenter and the functionality is just so cool.
Other Resources on Work-Stealing Queues:
http://www.danielmoth.com/Blog/2008/11/new-and-improved-clr-4-thread-pool.html
http://www.bluebytesoftware.com/blog/2008/08/12/BuildingACustomThreadPoolSeriesPart2AWorkStealingQueue.aspx
nPlus1.org is hosting its fourth Architecture Summit on July 31st at the Microsoft office in Southfield, MI. The topic of this summit will be Patterns and Principles.
Session One: Software Patterns
Patterns are an important tool to use as architects and developers. They provide a common vocabulary for us to design with, as well as a common approach to a common problem. Come learn about useful patterns, and how to use them in your everyday code.
Session Two: How I Learned To Love Dependency Injection
Dependency Injection is one of those scary topics that most developers avoid. It sounds all ‘high-falootin’ and complex. It’s not. Really. We wouldn’t lie. It’s a great way to manage complexity in your system, and a great way to make your system so much more testable. And isn’t that what we all want?
Each session will be followed by open discussions periods. A catered lunch will be provided starting at noon when the welcome time begins.
Register at https://www.clicktoattend.com/invitation.aspx?code=139245.
About nPlus1.org
nPlus1.org is a site dedicated to helping Architects, aspiring Architects and Lead Developers learn, connect and contribute. At nplu1.org you have access to great first party content written by some of the most skilled and experienced Architects working today. You also have access to a nexus of content from around the Internet aimed at keeping Architects up to date on all the new developments in their fields of interest.
In version 4.0 of the .NET Framework, there is a lot of support for parallel programming. One cool class to know is System.Threading.Parallel, which contains a number of static methods to parallelize loops and regions.
Consider this code which uses a for loop:
static void ComputePerfectSquares1()
{
Int64[] perfectSquares = new Int64[arraySize];
for (int i = 0; i < arraySize; i++)
{
perfectSquares[i] = i * i;
Thread.SpinWait(waitTime); // Pretending this is more computationally difficult
}
}
This is a simple example that calculates perfect squares. Because that is a relatively cheap operation, I've also added a Thread.SpinWait to simulate a more computationally expensive action.
Now, I'll write a second method which uses the new Parallel.For. This is one of the static methods on the Parallel class.
static void ComputePerfectSquares2()
{
Int64[] perfectSquares = new Int64[arraySize];
Parallel.For(0, arraySize, i =>
{
perfectSquares[i] = i * i;
Thread.SpinWait(waitTime); // Pretending this is more computationally difficult
});
}
The arguments of the parallel for are very similar to the information we provided to the original for. The first argument is the start index (inclusive) and the second argument is the end index (exclusive). I passed in 0 and arraySize, respectively. Then the third argument is the body to be invoked on each iteration; I'm using a lambda expression to do this. There are also some optional parameters with other method overloads.
Next, I wrote some code to test the relative performance of these methods:
static void Main(string[] args)
{
DateTime startTime;
TimeSpan duration;
// Run using original for
startTime = DateTime.Now;
ComputePerfectSquares1();
duration = DateTime.Now - startTime;
Console.WriteLine("Original for: " + duration.TotalMilliseconds + " ms");
// Run using parallel for
startTime = DateTime.Now;
ComputePerfectSquares2();
duration = DateTime.Now - startTime;
Console.WriteLine("Parallel for: " + duration.TotalMilliseconds + " ms");
// Pause so output can be read.
Console.Read();
}
If I run this code (with arraySize = 1000 and waitTime = 5000000), here are my results:
Running in parallel has cut my processing time down by roughly half (which makes sense since my machine has two cores), from 25.5 seconds to 13.5 seconds. Fabulous!
However, note that if I remove the "Thread.SpinWait" and run again, the original for loop performs better than the parallel for loop:
This is because there is some overhead to using the parallel version. The lesson here: don't parallelize all of your work blindly, but measure performance, find out where the computationally-expensive bottlenecks are and if they can be broken down into smaller chunks that can be run in parallel, and then use this functionality there. The Parallel class is a wonderful resource, giving you an easy way to run a for loop (and other programming constructs) in parallel.
For reference, I've attached the entirety of my program. Note that I did do some refactoring from the code above (which contains a lot of duplication), but I thought it was easier to understand if I inlined in the examples above.
Attachment(s): ParallelConsoleApp.zip
I am completely psyched about XBOX Project Natal.
How sweet is that? Without a controller, the game responds to your body’s movements. You can watch real people using it at the E3 conference.
SRT Solutions is running a number of events next week, which may be of interest to those in the Detroit/Ann Arbor area.
First, there is a Software Stimulus lab on Monday, June 15. This features two distinct sessions: the morning session introduces effective software engineering techniques, such as version control, continuous integration, and automated testing, and the afternoon session focuses on topics of interest to attendees. You can register at http://srtstimulus.eventbrite.com/.
Secondly, they are offering executive briefings on emerging technologies. These high-level briefings are designed to help business owners and CEOs understand critical emerging technologies along with their potential impact and benefits. They will focus on “WHY” you might adopt a new technology, rather than "HOW" to implement it. The events will be held at Ann Arbor SPARK. On June 16, the topics are Cloud Computing and Rich Internet Applications. On June 18, the topics are Natural User Interfaces and Social Networking in Business. The sessions run from 8:30am-noon and the cost is $150 (continental breakfast included). You can register using the links below.
June 16
Save Money with Green Computing: Leveraging Cloud Platforms
Cloud Computing platforms promise to give you flexibility to scale your IT infrastructure on demand and deliver global scope with lower cost. In this session you’ll learn why Microsoft, Google and Amazon all believe your business will be more productive, green, and cost-effective with cloud computing. But we’ll go beyond that. We’ll talk about YOUR business and whether or not it makes sense to have a cloud strategy.
Gain Competitive Advantage with Rich Internet Applications
Rich Internet Applications, Web 2.0… buzzwords or opportunities for competitive advantage? Learn what RIA means for your products and internal IT investments, including why online and offline mode matters and how to use RIA concepts to create rich user experiences. See how you can use browser-based technology to create reach and outpace your competition.
Signup: http://srtexecjune16.eventbrite.com/
June 18
Natural User Interfaces: R.I.P. Mouse & Keyboard
Imagine gaining productivity and effectiveness by changing how you interact with your computer. iPhone, Microsoft Surface, and Windows 7 MultiTouch are the future of user interfaces and offer ways to help you gain a competitive edge. Get an insider’s look at these platforms and see their potential for helping your business succeed.
Social Networking for Business: Beyond the Mainstream
Twitter, Facebook, Digg, the blogosphere: Your customers are interacting on these platforms… smart businesses do, too. Learn how to find and react quickly to comments about your company. See examples of how companies are building positive, committed brand value through social networks. Beyond such mainstream use as Oprah and other celebrities, discover social networking discussions pertinent to your business, participate in those discussions, and ultimately improve your image with customers and prospects.
Signup: http://srtexecjune18.eventbrite.com/
This warrants calling out - the queues in Windows Azure aren't your typical FIFO queue/dequeue mechanism. They actually use a two-step dequeuing process.
Imagine the typical Windows Azure architecture where a web role (or multiple web roles) accepts incoming network traffic, pushes work onto a queue, and then the work is dequeued and done by worker roles.
Let's look at how to dequeue. This dequeuing code is taken from the Thumbnails sample in the Windows Azure SDK. It's done by the worker role.
QueueStorage queueStorage = QueueStorage.Create(StorageAccountInfo.GetDefaultQueueStorageAccountFromConfiguration());
MessageQueue queue = queueStorage.GetQueue("thumbnailmaker");
...
while (true)
{
try
{
Message msg = queue.GetMessage();
if (msg != null)
{
string path = msg.ContentAsString();
RoleManager.WriteToLog("Information", string.Format("Dequeued '{0}'", path));
// Insert code to process the message and do the work here...
RoleManager.WriteToLog("Information", string.Format("Done with '{0}'", path));
queue.DeleteMessage(msg);
}
else
{
Thread.Sleep(1000);
}
}
catch (StorageException e)
{
// Explicitly catch all exceptions of type StorageException here because we should be able to
// recover from these exceptions next time the queue message, which caused this exception,
// becomes visible again.
RoleManager.WriteToLog("Error", string.Format("Exception when processing queue item. Message: '{0}'", e.Message));
}
}
So what's going on here? After we get a reference to the queue, we're starting an infinite loop. That is because we want the worker to continuously wake up, check the queue for new messages, process the messages if there are any, and then sleep if there are no new messages.
Now, let's look at the dequeuing process.
The first step is to call queue.GetMessage(). This gives us a copy of the message, but it actually doesn't remove the message from the queue. Instead, the message remains on the queue, but is put into a hidden state. Then worker roles can continue to process other messages behind it on the queue. After a certain amount of time passes, if the second step of the dequeuing process hasn't been completed, the message will come out of the hidden state and be re-added to the queue. Why does this behavior make sense? Imagine if a worker role dequeued a message for processing, but then the worker role died in mid-process. With this architecture, after the configured amount of time passes with no followup from the worker role, the message will be re-added to the queue and processed by another worker role, instead of data being lost.
The second step is to call queue.DeleteMessage(), after the message has been successfully processed. This step completes the dequeuing and removes the message from the queue.
Also, note the use of RoleManager.WriteToLog() throughout the code. When your code is running in the cloud, you can't attach a debugger to it. (There are a couple of reasons for this. First, there are security concerns. Debuggers essentially latch onto a running process and this could be dangerous in a shared environment like the cloud. Secondly, when your app is running in the cloud, it's in a production environment. You really shouldn't be debugging and stepping through code that's running in production.) Therefore, use logging to figure out what's going on with your code. There's a good video from PDC 2008 that gives best practices on logging effectively in Windows Azure at http://channel9.msdn.com/pdc2008/ES03/.
This new CloudApp() contest looks extremely cool: the objective is to create a cloud application running on Windows Azure. There are categories for both .NET and PHP applications. The contest will be judged by Michael Cote, Om Malik, and you - the developer community will vote on a winner too.
The full details are at http://www.newcloudapp.com/.
The prizes are literally fame and fortune.
The fame:
Be featured on www.azure.com as well as at major Microsoft events Be featured in a video interview on Channel 9 Be announced at Structure 09 (U.S. Only) The fortune:
One .NET App Category (U.S. Only) Grand Prize winner: $5,000 VISA gift card One PHP App Category (U.S. Only) Grand Prize winner: $5,000 VISA gift card One U.S. Community winner: $2,500 VISA gift card One International Community winner: $2,500 VISA gift card Submission are due by June 18. Good luck!
Hopefully you've learned a little about Surface development this week! I didn't originally intend to have a fifth section, but wanted to include the new announcements and some resources for further investigation.
First, at TechEd last week, the Surface team announced Surface 1.0 SP1. Cruise over to the Surface team blog to get all of the details on SP1, but here's a quick summary of some of the new features and improvements:
- Contact visualizations such as subtle UI trails in response to fingers on the Surface top
- International support including virtual keyboards in other languages
- New "LibraryStack" control - lets you neatly stack items, as opposed to the artful scattering of the ScatterView
- New "ElementMenu" control - circular UI on the top of an item that expands menu options
- Stress testing tool - how awesome is this! Stress testing for the Surface is very difficult when you just have a mouse to work with. This allows you to simulate lots of fingers, tags, and blobs touching the Surface top.
- Object routing - launching applications via tagged objects
- ScatterView and TagVisualizer enhancements, including a DragDropScatterView control
Here is a video walkthrough of some of the new features:
Secondly, here are some resources to help you with Surface development:
Other posts in this Surface Development series
Surface Development Part 1: What is the Microsoft Surface?
Surface Development Part 2: Surface Controls
Surface Development Part 3: ScatterView
Surface Development Part 4: Reacting to Physical Objects
Surface has the ability to recognize and respond to actual physical real-world objects placed on the Surface top, and it does this by means of tags.
Recognize
There are two types of tags that are recognized by Surface's vision system:
| Byte tags | Identity tag |
 |  |
Byte tags have 256 unique values. They can be used in Surface applications where the Surface reacts to a few different physical objects.
Identity tags have 340,282,366,920,938 septillion (that's 24 more zeroes) unique values. They can be used in Surface applications where you need to uniquely identify a large number of people, such as tags on a hotel loyalty card.
Respond
Next, let's look at the code that you would write to allow the Surface to respond to a tag. This is done by the TagVisualizer control, along with TagVisualization and TagVisualizationDefinition, in the namespace Microsoft.Surface.Presentation.Controls.
For example, let’s say that we are writing an application for a retail store which sells cellular phones, using the Surface as a kiosk to display product information. (This is a real scenario - AT&T is currently doing this in select stores.) When you set a cell phone on the Surface top, you want a visualization with information on the phone specs, calling plans, network coverage, etc. to appear on the Surface next to it. To accomplish this, the steps are:
1. Create a TagVisualization which contains the XAML to display the phone specs, calling plans, network coverage, etc. In Visual Studio, you can right-click on a Surface project in the Solution Explorer and select Add, New Item. Select a "Tag Visualization (WPF)" and name it CellPhoneData.xaml. Then, in that XAML, you can create a rich visual experience which displays the relevant cell phone data.
2. Put a physical tag on the cell phone (tags are included with the Surface unit). In this scenario, there will probably be a limited number of demo cell phones available for customers to play with, so a byte tag would suffice. Let's say that the tag that we put on the Samsung Saga cell phone was 0xC1 (one of the tags shown above).
3. Create a TagVisualizer, which contains a TagVisualizationDefinition. This maps the TagVisualization that we created in step #1 to the tag’s value, enabling the cell phone data visualization to appear when the tagged cell phone is placed on the Surface. The code would look something like this:
<s:TagVisualizer>
<s:TagVisualizer.Definitions>
<s:ByteTagVisualizationDefinition
Source="CellPhoneData.xaml"
Value="0xC1"
PhysicalCenterOffsetFromTag="-.23,-.4"
OrientationOffsetFromTag="266"/>
</s:TagVisualizer.Definitions>
</s:TagVisualizer>
Note that this code would be in the main SurfaceWindow XAML, not in the TagVisualization XAML. We can set the various offsets to make the cell phone data on the Surface appear positioned properly from the physical cell phone. Optionally, we could set other properties, like the maximum number of cell phones allowed and the behavior when a tag is removed from the Surface.
One of the special facets of Surface applications is that they are highly collaborative, because you have a 360-degree view of the application. To support this amazing experience, a good class to learn is ScatterView, in the namespace Microsoft.Surface.Presentation.Controls.
The ScatterView control quickly enables 360-degree applications. Using data binding as you would in WPF, you can connect a ScatterView to a directory of images and the control will artfully scatter the pictures across the Surface top. It also standardizes the manipulations for resizing, moving, and rotating the pictures.
Using the Surface SDK, I can create a new project in Visual Studio using the Surface Application (WPF) template. In the SurfaceWindow1.xaml file that is created by default, I can create a ScatterView in the Grid:
<s:ScatterView Name="Scatter">
<s:ScatterView.ItemTemplate>
<DataTemplate>
<Image Source="{Binding}"/>
</DataTemplate>
</s:ScatterView.ItemTemplate>
</s:ScatterView>
We're simply creating a ScatterView and filling the items in the ScatterView using standard databinding, just like we would do in WPF.
Then in the codebehind, I can hook up the databinding in the SurfaceWindow1 constructor:
Scatter.ItemsSource = System.IO.Directory.GetFiles(
@"C:\Users\Public\pictures\Sample Pictures", "*.jpg");
This will grab all of the pictures in the Sample Pictures directory with the .jpg extension (and all of the samples are .jpgs).
I'm not currently developing this code on a Surface unit, so when I press F5 to run, it invokes the Surface emulator on my laptop, which displays this:
I can use my mouse to move the pictures around on my laptop screen. On the Surface, I would be able to move, rotate, and resize the pictures with simple intuitive hand gestures, like stretching and flicking, that mimic the way you would interact with a real physical object.
Pretty cool, huh? With relatively few lines of code, I could produce a natural interface to interact with photos.
By default, you can move, rotate, and resize these pictures. However, there are scenarios when you might not want this behavior. For example, perhaps you want tokens on a game board to be able to move around, but not be resizable. There are properties that you can tweak:
- CanScale - Boolean that specifies whether you can resize a photo
- CanRotate - Boolean that specifies whether you can rotate a photo
- DecelerationRate - double that specifies the rate of translational deceleration. This value is measured in device-independent units per second squared. By default, the value is set so that when an item is travelling at 1,536 pixels per second (that is, 16 inches per second at 96 DPI), the item takes 1 second to decelerate fully.
- AngularDecelerationRate - double that specifies the rate of angular deceleration. This value is measured in degrees per second squared. By default, the value is set so that when an item is rotating at 270 degrees per second, the item takes 1 second to decelerate fully.
Finally, Robert Levy also did a video showing the ScatterView control here.
Are you familiar with WPF? If so, you’re most of the way there with Surface development! Many of the Surface controls derive from and have similar functionality to corresponding WPF controls, but provide extra enhancements for the Surface. For example, the Surface’s SurfaceWindow has very close functionality to the WPF Window, except the SurfaceWindow runs full screen on the Surface (because all Surface apps run maximized on the Surface space) and automatically orients the display toward the user (since the Surface is a 360-degree environment). The table below illustrates some examples of WPF controls, the equivalent Surface controls, and the extra functionality that the Surface control gives to support the Surface multi-touch experience.
| WPF Control | Surface Control | Extra Functionality in Surface Control |
| Window | SurfaceWindow | Runs full screen on the Surface, oriented towards the user |
| Menu | SurfaceMenu | Multiple menus can be used at the same time (multi-touch support) |
| Button | SurfaceButton | Only “clicks” when all fingers are removed from button |
| ListBox | SurfaceListBox | Determines scrolling vs. select, allows flicking gesture to scroll through list, provides elastic effect when end of list is reached |
| ScrollBar | SurfaceScrollBar | Allows flicking, scroll bar grows thicker to better fit finger when touched and then returns to original thin UI |
| TextBox | SurfaceTextBox | Invokes virtual keyboard oriented towards user when touched |
Of course, this is not a comprehensive list of controls. There are many more Surface controls than just these. For example, in addition to the SurfaceButton, there is a SurfaceRadioButton, SurfaceCheckBox, and SurfaceToggleButton, and they share the extra functionality of only clicking when all contacts are removed from the control. So if two users touch a SurfaceButton or one of these other controls, and then one user lifts his finger, the "Click" event will not fire until the second user lifts her finger too.
However, this table does demonstrate the broad categories of controls available, and gives you a flavor for the extra functionality that you get with the Surface version - support for multi-touch, the 360-degree environment, and the other unique attributes of Surface.
Finally, the Surface SDK (where these controls live) is not available to the public at this point. The Surface team has given away access at major conferences such as PDC if you attended the Surface sessions or tried the Surface hands-on labs. You also get access to the Surface SDK when you purchase a Surface developer unit. If you have a serious interest in Surface development, let me know.
This post is the beginning of a four-part series on developing for the Microsoft Surface. But before you can write cool apps for the Microsoft Surface, you should understand what it is.
The Surface is a coffee-table-sized touch computer that can respond to natural hand gestures and real-world objects. It utilizes a vision system with five cameras to sense input. The 30-inch diagonal display allows a number of users to see the screen while surrounding the table, enabling highly collaborative experiences. The users can interact with the content by touch, "grabbing" digital information with their hands. Surface can recognize many points of contact simultaneously, not just one finger as with a typical touch screen. Finally, Surface sees what touches it and can recognize physical objects, providing potential for many compelling experiences:
With Windows 7, it will be much easier to do multi-touch computing on normal computers. So what makes Surface different from that? Two major things:
- Surface supports *massive* multi-touch capabilities. Surface can track over 52 simultaneous contacts at once. The number of simultaneous contacts that a touch-enabled computer running Windows 7 can handle is dependent on the hardware, but it's not close to that scale.
- Surface can react to tagged objects placed on it.
In the remaining posts in this series, I will dive into the Surface SDK and discuss three things that you should understand to get started with coding Surface applications:
- Surface controls (and how close they are to WPF controls)
- The ScatterView class
- The classes to enable Surface to react to tagged objects
Yes, so did I. :) I attended PDC this year, and my colleague Jeff Blankenburg covered MIX. In case you're not familiar, MIX is a conference for designers and developers focused on user experience and innovative web solutions.
If you did miss MIX, like me, you have a couple of options:
1. Watch the videos online. Jeff recommended 3 must-see videos:
2. Attend the Stir Trek event in Columbus, OH on May 8, 2009. This event will bring the content of MIX 2009 much closer to home. Held at a movie theatre (read: comfortable seats), the day will feature two parallel tracks of content directly from MIX, and then conclude with a showing of the Star Trek movie. There will be sessions covering Silverlight 3, Internet Explorer 8, Expression Blend 3, User Experience Design, WPF, Rapid Prototyping with SketchFlow, and ASP.NET MVC. The cost is only $25, for a full day of technical content, food, giveaways, and a viewing of the Star Trek movie on the day that it comes out!
I'm giving a number of upcoming public presentations. If any of the below topics interest you, feel free to attend. 
Michigan Celebration of Women in Computing (MICWIC) - 4/3/2009-4/4/2009
http://www.egr.msu.edu/~msuwic/cgi-bin/micwic.php
I will be speaking on an Industry Careers panel and giving lightning talks on some cool research from Microsoft (AutoCollage and PhotoSynth).
Ann Arbor Cloud Camp - 4/9/2009
http://a2geeks.org/display/geek/CloudCamp+09
I will be speaking on "Developing your first Windows Azure cloud service". In this session we take a tour of the capabilities of the Microsoft cloud platform by building and running a simple service using the platform SDK. The sample service highlights some of the features of the platform including service management, storage, and an integrated developer experience. This is a demo-heavy session.
Great Lakes Area .NET User Group (GANG) - 4/15/2009
http://www.migang.org
I and Joe Engalan will be speaking on "Developing for the Microsoft Surface". Learn how to write code for the Surface! This session introduces the (not publically available) Surface SDK that forms the basis of the Windows 7 multi-touch programming model. In addition, learn about the unique attributes of Surface computing, dive into the core controls like ScatterView and vision-system tagging, and leverage your existing investments in Windows Presentation Foundation and Microsoft Visual Studio.
Central Ohio Day of .NET - 4/18/2009 
http://cinnug.org/cododn
I will be delivering an "Introduction to the Visual Studio Tools for Office (VSTO)". VSTO is a .NET Smart Client technology that allows you to build managed code applications with .NET languages like VB.NET and C#, and have the functionality of those applications manifest in the rich user interfaces of Microsoft Office Excel, Word, PowerPoint, Visio, Outlook, and others from the Office stack. We will walk through multiple demos to show just how easy it is to build powerful VSTO applications, demonstrating adding controls into Excel, adding functionality to the Office 2007 Ribbon UI, and adding custom task panes.
DevLink - 8/13/2009-8/15/2009 
http://www.devlink.net
I'm presenting 3 talks, on VSTO, WPF, and Azure. See the complete session list at http://www.devlink.net/Sessions/tabid/124/Default.aspx.
