Kenny Kerr

Asynchronous Agents

KennyKerr — Wed, 03 Jun 2009 10:55:00 GMT

Rick Molloy, one of the masterminds behind the new concurrency runtime (concrt) and parallel patterns library (PPL), has written an article in the latest issue of MSDN Magazine demonstrating the new asynchronous agents library with the classic dining philosophers problem.

Concurrent Affairs: Solving The Dining Philosophers Problem With Asynchronous Agents

Enabling C++ developers to write highly concurrent applications is a major focus of Visual Studio 2010. The beta release includes the Concurrency Runtime, parallel libraries, and development tools aimed at addressing several common problems preventing developers from unlocking the performance potential inherent to multicore hardware. Notably, this includes ensuring that developers can identify and take advantage of opportunities for concurrency in their code, productively manage shared state and its side effects, and not having to worry about building low-overhead concurrency infrastructure that is scalable at run time on a variety of hardware.

In this article, I'm going to demonstrate how to use the new Asynchronous Agents Library included as part of Visual C++ 2010 to manage the difficulties that can arise with shared state. To show you how this works, I will walk through an implementation of a classic concurrency problem: Djikstra's Dining Philosophers. You'll see how the actor-based programming construct of an agent in combination with asynchronous message-passing APIs can be used to provide a correct and easy to understand solution to this problem that doesn't rely directly on threading or synchronization primitives.

Enjoy!

Lost Carrier Pigeon

KennyKerr — Tue, 02 Jun 2009 15:08:00 GMT

What do you when a carrier pigeon lands in your back yard seemingly lost?

It has bracelets around its feet with numbers but no email address. :)

It’s pretty tame and let me pick it up to inspect its markings.

Windows with C++: Introducing Direct2D

KennyKerr — Tue, 02 Jun 2009 10:44:00 GMT

I’ve been away from my computer for a few days working on a house renovation project and didn’t notice that my latest Windows with C++ column came out until the mail man delivered a copy of the June 2009 issue of MSDN Magazine.

In this issue I introduce a new technology that I’m very excited about. I’ve been waiting for Direct2D for some time. When Microsoft started pushing WPF as the “one true path” (TM) I just couldn’t persuade myself to buy the sales pitch. If you felt the same way then read on. This just might make your day.

Windows with C++: Introducing Direct2D

With the introduction of Windows Vista a few years ago, it was clear that the era of the Windows Graphics Device Interface (GDI) was coming to an end. GDI, even with the help of GDI+, had been showing its age especially when compared to the superior graphics capabilities of Windows Presentation Foundation (WPF). As if that weren't enough, GDI lost its hardware acceleration while WPF took advantage of Direct3D's abundance of hardware acceleration.

However, if you want to develop high-performance and high-quality commercial applications, you'll still look to C++ and native code to deliver that power. That's why few things excite me more about Windows 7 than the introduction of Direct2D and DirectWrite. Direct2D is a brand new 2D graphics API designed to support the most demanding and visually rich desktop applications with the best possible performance. DirectWrite is also a brand-new API that complements Direct2D and provides hardware-accelerated text, when used with Direct2D, and high-quality text layout and rendering with advanced support for OpenType typography and ClearType text rendering.

In this article, I will explore these new technologies and give you an idea of why it matters and how you can start using them today.

Big thanks to Mark Lawrence and Ben Constable, from the Direct2D team, for their feedback on the article as well as for providing a side bar discussing rendering performance.

Stay tuned for more Direct2D articles in my upcoming Windows with C++ columns.

If you’re looking for one of my previous articles here is a complete list of them for you to browse through.

Produce the highest quality screenshots with the least amount of effort! Use Window Clippings.

WTL 8.1 is coming!

KennyKerr — Tue, 19 May 2009 10:01:00 GMT

After almost two years of silence there appears to be activity around WTL again. Of course this makes sense since Windows 7 is almost done. I just noticed build 8.1.9127 posted over on SourceForge.NET.

For starters it now builds cleanly by internally suppressing warnings against the use of unsafe CRT functions. I have got into the habit of including WTL 8.0 in my precompiled header as follows:

#pragma warning(push)
#pragma warning(disable:4996) // WTL still uses some unsafe CRT functions
#include <atlapp.h>
.
.
.
#pragma warning(pop)

Well no more. To be precise, it still uses those unsafe functions but the warnings are now suppressed internally and explicitly around those functions so that we don’t have to deal with it ourselves.

Wrappers have also been added for the Desktop Window Manager API as well as the support needed to subclass and double-buffer the painting of controls on glass. For more information on the DWM API as well as the issues with controls on glass you can read my articles here and here.

Beyond that it looks like this is just the initial placeholder for what will become the 8.1 release of WTL.

Visual Studio 2010 and .NET Framework 4 Beta 1 are here!

KennyKerr — Mon, 18 May 2009 19:40:00 GMT

Microsoft has finally released an update to the Visual Studio 2010 preview build that showed so much promise but unfortunately was so unreliable. If you have an MSDN subscription just head over to subscriber downloads and start downloading now!

Interestingly (and thankfully) they appear to have reduced the number of SKUs. There is only “Professional” and “Team Suite”.

Resolving Windows Sleep Problems

KennyKerr — Fri, 08 May 2009 16:58:00 GMT

This is more of a reminder to myself but it may come in handy for you.

Whenever I reinstall Windows I always make sure to install the latest chipset drivers from Intel which tends to make things run more smoothly, especially on laptops, with regards to power management.

On my desktop computer there is one more step I need to take before it will correctly sleep and stay asleep but I always seem to forget this and spend some time wondering which driver or device isn’t letting the computer go to sleep. Nine times out of ten though it’s not as a result faulty or missing drivers but is actually “by design”.

Wired network adapters seem to always be configured to Wake-on-LAN by default. This may be useful for corporate networks but is terribly annoying for home computers where it gives the appearance that Windows simply can’t sleep reliably when in fact it is the network adapter that keeps waking up the computer when network traffic is received.

Anyway the solution is simple, simply uncheck the “Allow this device to wake the computer” option for you wired network adapter:

Hope that helps.

C++ Exception Handling

KennyKerr — Tue, 05 May 2009 13:19:00 GMT

A while ago I made a passing remark on my blog that I prefer not to use exceptions in native code. Some readers asked me to justify this position and I’ve been a bit reluctant to do so only because it’s a lengthy argument that I’m sure will bring a lot of passionate responses that I don’t really have the time to deal with. I was reminded of this again last night when I walked past one of our bookshelves at home and picked up my copy of John Robbins’ excellent debugging book and noticed that it has a chapter on crash handlers within which John does a good job of covering many of the reasons why I don’t use exception handling in native code. If you’re interested in this topic I would encourage you to read John’s book.

Of course I still write “exception safe” code in the sense that I use “resource acquisition is initialization” or constructors and destructors to scope resources, avoid side effects in functions, define invariants, etc. but this is just good practice to write simple and correct code whether or not exceptions are in play.

The Visual C++ compiler actually lets you disable exception handling in your code which by the way improves performance and reduces code size. Here’s how:

The story is very different for managed code where exceptions are very much an integral part of the runtime and thus cannot be avoided. Of course managed exceptions more than make up for the pitfalls with exception handling by providing a standard base class with exception information including the call stack at the time an exception was thrown thus greatly improving the ability for developers to track down bugs.

Exciting Changes

KennyKerr — Tue, 05 May 2009 10:54:00 GMT

I’ve made a few changes to my professional life. I’ve had the opportunity to work with some really talented developers in London and I’m sorry to say goodbye to them. I’ll talk more about that in the coming weeks and months but one of the outcomes is that I’ll have much more time for my software projects. To unwind from employment (e.g. slavery :) ) I took Karin and the kids camping and boy did things change in the world of Microsoft technology in just one week. Here are just some of the announcements.

Windows 7 (and Server) Release Candidate – by far the biggest news is the arrival of the Windows 7 RC. You can get it from your MSDN subscription along with the latest Windows SDK. The server version of Windows 7, called Windows Server 2008 R2, is also available. Interestingly, the Windows SDK is now split across platforms.

Office 2007 Service Pack 2 – the next service pack for Office 2007 is out so if there was ever any doubt that Office 2007 is ready for mass corporate adoption you’re now all out of excuses! :)

Windows Vista Service Pack 2 – the second service pack for Windows Vista has also been released.

Virtual PC Beta – we all thought it was dead but here comes a new version. It looks like this will be the last version of Virtual PC before Hyper-V is rolled into all versions of Windows. In other words I expect Windows 8 to include Hyper-V just as Windows Server now does. This is in much the same was as Remote Desktop Services first debuted in Windows Server and is now included in all editions of Windows.

If you really need XP support then you may want to take a look at Windows 7’s XP Mode, which allows you to run Windows XP applications on your Windows 7 desktop. This uses the new version of Virtual PC but will eventually be based on Hyper-V.

As a (native) C++ developer there’s just so much to be excited about when you consider Windows 7. I’ve started covering Windows 7 technology in my Windows with C++ column in MSDN Magazine and you can expect many more articles focused on Windows 7 in the coming months. Here are just a few that I’m particularly interested in:

Virtual Disk API – I covered this in the April 2009 issue of MSDN Magazine.

Direct2D – I have an introduction to Direct2D in the upcoming June 2009 issue of MSDN Magazine.

In addition there are new APIs for advanced text rendering and typography, powerful user interface animation, ribbon user interface, web services clients and servers, and much more. And all of this is designed for C++ developers! I’ll be covering many of these in upcoming articles.

As I’ve said before, these are exciting times for a C++ developer on Windows.

Another year in the MVP Award program!

KennyKerr — Thu, 02 Apr 2009 07:16:00 GMT

Thanks to all the talented people at Microsoft.

There's never been a more exciting time to be a C++ developer on the Windows platform!

Windows with C++: The Virtual Disk API in Windows 7

KennyKerr — Mon, 23 Mar 2009 09:34:00 GMT

My latest Windows with C++ column in the April 2009 issue of MSDN Magazine is now online:

The Virtual Disk API in Windows 7

As I write this, the Windows 7 beta has been available for a few days, and I must say there is a lot to like. As usual, I took a look under the hood to see what is new in the Windows SDK. Windows 7 is very much a minor release as far as the SDK is concerned, and that's a good thing. The fundamentals of writing native C++ applications for Windows 7 have not changed much compared to the way they changed for Windows Vista. Having said that, however, Windows 7 has some completely new features that are sure to interest anyone looking to take advantage of the platform.

One of these features is the Virtual Disk API. Although designed with other formats in mind, the Virtual Disk API in the Windows 7 beta is very much geared toward the Microsoft Virtual Hard Disk (VHD) format popularized by virtualization products from Microsoft such as Hyper-V and Virtual PC.

Enjoy!

If you’re looking for one of my previous articles here is a complete list of them for you to browse through.

Produce the highest quality screenshots with the least amount of effort! Use Window Clippings.

More on COM Safe Arrays and .NET Interop

KennyKerr — Thu, 12 Mar 2009 12:37:00 GMT

A few years ago I wrote about P/Invoke and how it can provide benefits even when C++ Interop is available on the consuming end. Recently I’ve had to do a bit of work consuming COM safe arrays from C#. I’ve seen safe arrays trip up developers time and again so I thought I’d share some thoughts and tips on the subject.

This discussion focuses on the use of two-dimensional safe arrays. Single-dimensional safe arrays are marshalled automatically by the CLR (in most cases) but it is two-dimensional safe arrays that are often used to communicate key-value pairs such as for a map or dictionary of some kind. The trouble is that a two-dimensional safe array is really just a table of values. You can think of it as having an X axis and a Y axis. Storing key-value pairs in the table then requires a decision to be made regarding whether the keys will be stored down the Y axis as rows or along the X axis as columns. You could argue about which is better but at the end of the day you’re likely going to be at the mercy of whatever native API you’re calling.

If keys are stored down the Y axis then a particular key is indexed with the safe array’s first dimension. The first dimension will thus have as many elements as there are pairs. The second dimension will have exactly two elements with the first storing the key and the second storing the value.

On the other hand if keys are stored along the X axis then a particular key is indexed not by the first dimension but by the second. The second dimension will thus have as many elements as there are pairs. The first dimension will have exactly two elements with the first storing all the keys and the second storing all the values.

Of course not everyone naturally thinks in terms of the same coordinate space and you may need to apply a transform before it makes sense to you. Apologies to graphics developers everywhere. :)

Let’s make this a bit more concrete with an example. Here is a native container of string-double pairs implemented by ATL’s CAtlMap class:

typedef CAtlMap<CString, double> Map;
Map m_map;

The following function creates and returns a safe array keyed along the X axis using ATL’s safe array wrapper classes:

#define HR(expr) { hr = expr; if (FAILED(hr)) return hr; }

HRESULT __stdcall GetDictionaryX(SAFEARRAY** dictionary)
{
    HRESULT hr;

    if (0 == dictionary)
    {
        return E_POINTER;
    }

    CComSafeArrayBound bounds[2] =
    {
        CComSafeArrayBound(2),
        CComSafeArrayBound(m_map.GetCount())
    };

    CComSafeArray<VARIANT> safeArray;
    HR(safeArray.Create(bounds, _countof(bounds)));

    LONG indices[2] = { 0 };
    POSITION position = m_map.GetStartPosition();

    for (; 0 != position; ++indices[1])
    {
        const Map::CPair* pair = m_map.GetNext(position);

        indices[0] = 0;
        HR(safeArray.MultiDimSetAt(indices, CComVariant(pair->m_key)));

        indices[0] = 1;
        HR(safeArray.MultiDimSetAt(indices, CComVariant(pair->m_value)));
    }

    *dictionary = safeArray.Detach();
    return S_OK;
}

Briefly, the bounds define the dimensions of the safe array and the indices are used to set the values in the table.

The following function does the same thing but returns a safe array keyed along the Y axis:

HRESULT __stdcall GetDictionaryY(SAFEARRAY** dictionary)
{
    HRESULT hr;

    if (0 == dictionary)
    {
        return E_POINTER;
    }

    CComSafeArrayBound bounds[2] =
    {
        CComSafeArrayBound(m_map.GetCount()),
        CComSafeArrayBound(2)
    };

    CComSafeArray<VARIANT> safeArray;
    HR(safeArray.Create(bounds, _countof(bounds)));

    LONG indices[2] = { 0 };
    POSITION position = m_map.GetStartPosition();

    for (; 0 != position; ++indices[0])
    {
        const Map::CPair* pair = m_map.GetNext(position);

        indices[1] = 0;
        HR(safeArray.MultiDimSetAt(indices, CComVariant(pair->m_key)));

        indices[1] = 1;
        HR(safeArray.MultiDimSetAt(indices, CComVariant(pair->m_value)));
    }

    *dictionary = safeArray.Detach();
    return S_OK;
}

With the native code out of the way let’s see how we can call these functions from C#. For simplicity lets assume they’re just exported functions and not COM interface methods. The same principals apply but it’s just less sample code for me to write.

The first step is to import the functions as follows:

[DllImport("Server.dll", EntryPoint = "GetDictionaryY", PreserveSig = false)]
[return: MarshalAs(UnmanagedType.SafeArray)]
static extern object[,] NativeGetDictionaryY();

[DllImport("Server.dll", EntryPoint = "GetDictionaryX", PreserveSig = false)]
[return: MarshalAs(UnmanagedType.SafeArray)]
static extern object[,] NativeGetDictionaryX();

This just adds some metadata needed by the CLR to call the LoadLibrary and GetProcAddress functions on your behalf, how to marshal the parameters and return value, and what to do with the HRESULT.

The next step is to determine how many key-value pairs the two-dimensional array consists of. The array’s GetLength method comes in handy as you can specify the dimension whose length you are interested in:

object[,] array = NativeGetDictionaryX();
int count = array.GetLength(1);

Given the count you can now enumerate the key-value pairs using a for loop and a bit of casting:

for (int i = 0; i < count; ++i)
{
    string key = (string)array[0, i];
    double value = (double)array[1, i];

    Console.WriteLine(key + "=" + value);
}

Needless to say this is quite error prone. It would be more desirable to use a foreach loop but the enumerator provided by the multi-dimensional array doesn’t know anything about the key-value pairs so it just returns it in a flat list. The good news is that it’s pretty easy to write your own enumerator or to be precise let the C# compiler generate one for you.

Here’s an implementation of the generic IEnumerable<TKey, TValue> interface that does just what you want for arrays keyed along the X axis:

class SafeArrayEnumerableX<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{
    private readonly object[,] m_array;

    public SafeArrayEnumerableX(object[,] array)
    {
        Debug.Assert(null != array);
        Debug.Assert(2 == array.GetLength(0));

        m_array = array;
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        int count = m_array.GetLength(1);

        for (int i = 0; i < count; ++i)
        {
            yield return new KeyValuePair<TKey, TValue>((TKey)m_array[0, i], (TValue)m_array[1, i]);
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

Notice that it’s effectively doing the same looping and casting as the hand-rolled approach but in such a way that you end up with a reusable enumerator that hides all the nasty indexing and casting. With the enumerator providing a sequence of generic KeyValuePair<TKey, TValue> structures, enumerating over the pairs now becomes much more elegant:

static SafeArrayEnumerableX<string, double> GetDictionaryX()
{
    return new SafeArrayEnumerableX<string, double>(NativeGetDictionaryX());
}

foreach (var pair in GetDictionaryX())
{
    string key = pair.Key;
    double value = pair.Value;

    Console.WriteLine(key + "=" + value);
}

And that’s all there is to it. For completeness, here’s the equivalent enumerable implementation for arrays keyed along the Y axis:

class SafeArrayEnumerableY<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
{
    private readonly object[,] m_array;

    public SafeArrayEnumerableY(object[,] array)
    {
        Debug.Assert(null != array);
        Debug.Assert(2 == array.GetLength(1));

        m_array = array;
    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
    {
        int count = m_array.GetLength(0);

        for (int i = 0; i < count; ++i)
        {
            yield return new KeyValuePair<TKey, TValue>((TKey)m_array[i, 0], (TValue)m_array[i, 1]);
        }
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }
}

I hope that helps.

If you’re looking for one of my previous articles here is a complete list of them for you to browse through.

Produce the highest quality screenshots with the least amount of effort! Use Window Clippings.

Windows with C++: Visual C++ 2010 and the Parallel Patterns Library

KennyKerr — Tue, 27 Jan 2009 09:25:00 GMT

My latest Windows with C++ column in the February 2009 issue of MSDN Magazine is now online:

Windows with C++: Visual C++ 2010 and the Parallel Patterns Library

Visual C++ is getting a major upgrade in the 2010 release of Visual Studio. Many of the new language and library features are designed purely to make it easier and more natural to express your desires in code. But as has always been the case with C++, the combination of these features is what makes C++ such a powerful and expressive language.

So this month I am going to introduce some of the additions to the C++ language that Visual C++ has added as part of the forthcoming C++0x standard. I'll then look at the Parallel Patterns Library (PPL) that Microsoft has developed over and above the C++0x standard to introduce parallelism to your applications in a manner that naturally complements the standard C++ library.

This article was a bit hard to write as the pre-release version of Visual Studio 2010 that I had at the time of writing was very unstable. The IDE has a long way to go before it is ready for day to day use. There is however a great deal to look forward to for the native C++ developer and I hope you enjoy this introduction to some of the new language and library features.

If you’re looking for one of my previous articles here is a complete list of them for you to browse through.

Produce the highest quality screenshots with the least amount of effort! Use Window Clippings.

Windows 7 beta now on MSDN and Connect

KennyKerr — Thu, 08 Jan 2009 07:49:00 GMT

You can now download the beta of Windows 7 and Windows Server 2008 R2 from MSDN subscriber downloads and from Microsoft Connect.

~~Unfortunately the Windows SDK is not yet available. Let’s hope that it’s posted soon.~~

Update: the SDK is now available from MSDN.

Manifest View support for DLLs

KennyKerr — Fri, 02 Jan 2009 16:38:00 GMT

Since I blogged about my Manifest View tool I’ve had a few requests to add support for viewing manifests embedded within DLLs. It originally only supported viewing manifests embedded within executables.

Well I finally got around to it and spent the five minutes updating the code, rebuilding and testing. You can download it from the original blog for Manifest View 1.0 here.

Hope that helps. And a Happy New Year to you all.

Was Softwear a Joke?

KennyKerr — Mon, 29 Dec 2008 14:09:00 GMT

Earlier this month I heard about Microsoft’s Softwear line of t-shirts. It was supposedly launching on the 15th of December. Launching where?

I checked out the Microsoft company store and there’s no sign of them. But then I also noticed that MVPs get redirected to a different login page. The store also seems to only be offering older products. For example there’s no sign of the BlueTrack mice. There appears to be a shiny new store for employees only, or am I dreaming?

I’m not complaining but it is the first year I have MVP dollars to spend but nothing worth spending them on. :)