.NET Micro Framework

New NETMF Book out for v4.1 and v4.2

Colin Miller — Mon, 09 Jan 2012 21:46:07 GMT

Some of our earliest partners from SJJ Embedded Micro Solutions - Sean Liming and John Malin - have written a book on the latest versions of NETMF. The book is targeted at the professional audience, hence the name - “Professional's Guide To .NET...(read more)

Version 4.2 RTM Today!! (Updated)

Colin Miller — Tue, 04 Oct 2011 21:13:25 GMT

We are glad to announce today the RTM of the .NET Micro Framework version 4.2. You can download the SDK and PK as well as the all sources from our Codeplex project , client_v4_2 branch, at change number 13620 . (We will be distributing...(read more)

So you always wanted to be an angel investor

Colin Miller — Tue, 04 Oct 2011 20:57:42 GMT

KickStarter.com was a new one for me. There are dozens of interesting projects out there from movies to technology to children’s books. What all these things have in common is that they need grass roots funding. At Kickstarter...(read more)

Cortex Support on NETMF in Open Source Project

Colin Miller — Mon, 12 Sep 2011 21:05:27 GMT

There is a lot of interest in the Cortex M series platforms these days. One reason that these are interesting for very small devices like .NET Micro Framework is that they use a new instruction set – Thumb2 – that is more compact than the one used...(read more)

NETMF Version 4.2 Release Candidate 2

Colin Miller — Tue, 30 Aug 2011 21:19:43 GMT

We have just posted the second Release Candidate for .NET Micro Framework version 4.2. We decided to do another release candidate so that we could take a few more features from the community and so that we could get a little more exposure to some...(read more)

NETMF 4.2 Contributor and a Cool Product

Colin Miller — Wed, 24 Aug 2011 15:18:22 GMT

It is great to be able to highlight a valuable contribution to the 4.2 codebase and a cool application of the platform at the same time. The contribution is from Richard Scott at Pulsecor ( http://www.pulsecor.com/ ). People have asked for examples of...(read more)

NETMF 4.2 – Regular Expressions

Colin Miller — Thu, 18 Aug 2011 15:38:20 GMT

With the 4.2 release just around the corner, I wanted to highlight another contributions from the community – specifically in this case, Regular Expressions. This feature was contributed by Julius Friedman. Regular Expressions This is desktop compatible...(read more)

NETMF Student and Hobbyist projects

Colin Miller — Wed, 10 Aug 2011 16:34:41 GMT

The last few blogs have highlighted some of the NETMF uses at the Imagine Cup. These are presumably products that are targeting commercial applications and both of these project teams are exploring the road to bringing their products to market. ...(read more)

Imagine Cup and NETMF (Part 2)

Colin Miller — Mon, 01 Aug 2011 16:35:01 GMT

The team that won the Software Design category was Team Hermes from Sligo, Ireland. This team created an application that addressed the issue of the high rate of traffic fatalities In Ireland with a classically ‘Internet of Things’ solution. They instrumented...(read more)

Imagine Cup and NETMF (Part 1)

Colin Miller — Fri, 29 Jul 2011 15:20:11 GMT

The Imagine Cup just finished an once again there were some great projects as always. This year, even more than in the past, there were a number of projects that included the .NET Micro Framework platform. I have had the opportunity to talk...(read more)

Internet of Things and StreamInsight

Colin Miller — Tue, 12 Jul 2011 13:43:32 GMT

The Internet of Things (IoT) is gaining momentum with more and more investment from governments and companies being announced all the time. There is still some complexity to the development of solutions in this segment because the solutions require...(read more)

NETMF 4.2 – Other CodePlex NETMF Projects

Colin Miller — Mon, 27 Jun 2011 14:11:32 GMT

In this latest release of the .NET Micro Framework we have tried to acknowledge some of the great contributions from the community and we will continue to do that. In addition, there are great contributions happening at our partner’s sites. ...(read more)

NETMF 4.2 – Porting Kit Studio

Colin Miller — Mon, 20 Jun 2011 18:47:26 GMT

Version 4.2 went to Beta a few days ago with an impressive assortment of contributions from the community. One contribution stands out for its scope and ambition. That contribution is the PKStudio contributed by Alexandr Surkov and Igor Kiselev...(read more)

NETMF Version 4.2 Beta now available

Colin Miller — Tue, 07 Jun 2011 17:24:00 GMT

Today, we have posted the Beta bits for the NETMF version 4.2 release to CodePlex.

There are some great additional features beyond what we announced for the 4.2 Alpha release (cryptographic primitives, PWM, FTP,…). These include:

...(read more)

Do You Have a Commercial Product Using NETMF?

Colin Miller — Fri, 03 Jun 2011 23:22:00 GMT

I am always being asked for examples of what NETMF is used for. I am also frequently surprised by what people are doing with it. Since going Open Source, there is not an obvious way for me to find out what people are doing with the product and the result is that my list of applications is getting a little stale

...(read more)

NETMF at TechEd 2011

Colin Miller — Mon, 23 May 2011 14:11:00 GMT

Just got back form TechEd 2011 where Microsoft’s smallest platform had the biggest booth (no kidding). We also had a lot of help manning the booth – thanks to all the volunteers there. The word got out that we had some cool demos as well. Here is what we were showing.

...(read more)

.NET Gadgeteer Live as an Open Source Project

Colin Miller — Mon, 02 May 2011 19:06:00 GMT

Over the last 7 months, we have shown the .NET Gadgeteer to a number of internal and external parties. The response is almost always the same – where can I get one?

...(read more)

New Kits from GHI Electronics

Colin Miller — Thu, 28 Apr 2011 15:04:00 GMT

In case you haven’t been out to the GHI site in the last few days, they just announced a new set of kits. These kits are intended to give you an easy on-ramp to building things.

...(read more)

The Curious Cloud Contest

Colin Miller — Tue, 19 Apr 2011 15:54:00 GMT

It has been a busy month getting ready for MIX 2011 in Las Vegas last week. We put together a cool challenge for some of the attendees – a challenge that was maybe a little too challenging but still fun.

...(read more)

NETMF 4.2 Alpha Available

Colin Miller — Thu, 24 Mar 2011 17:06:00 GMT

I’m a bit tardy on this announcement since the release has been available for almost 10 days now but things are pretty busy here. On March 15th, we posted an alpha version of the 4.2 release. The features that are available in this early look are security improvements, FTP Support, a PWM Object, and a number of fixes to the issues that you have reported in the issue tracker on the CodePlex project.

...(read more)

Thread Communication and Synchronization

Colin Miller — Tue, 01 Feb 2011 18:16:00 GMT

After the last blog on Threads and Thread Priorities, readers asked for a continuation on Thread Communication and Synchronization. Before I jump in, I have to reiterate that concurrency is a complex issue. I won’t try to compete with the technical books on the subject that run to hundreds of pages. I will focus on some basic examples of what is available in NETMF to support the concepts introduced in books like that. That means that you can take what you learn here and still get trouble if you are not careful.

Shared Resources – Locking Critical Sections

The most common interaction between threads is through shared resources. We can define a static resource that several threads can interact with. Here is a simple example where I have the main thread and one additional thread – both of which use a counter (s_IncCounter). The main thread prints it out and the worker thread increments it 5 times and then checks its work.

private static int s_IncCount = 0;

public static void Main()
{
Thread thread1 = new Thread(Thread1);
thread1.Start();

     while (true)
     {
         Thread.Sleep(5000);
         Debug.Print("Thread Execution Count = " + s_IncCount);
     }
}

private static void Thread1()
{
     while (true)
     {
         int j = 0;
         for (int i = 0; i < 5; i++)
         {
             s_IncCount++;
             for (int ii = 0; ii < 1000; ii++)
             {
                 j = s_IncCount % 5;
             }
         }
         if (j != 0)
         {
             Debug.Print("s_IncCount % 5 is: " + j.ToString());
         }
     }
}

The output of the execution of this application shows that we are getting slightly fewer than 700 increments every 5 seconds. We will use this measurement to see what the overhead of the thread synchronization mechanisms are. Also notice that the worker thread checks to see if exactly 5 increments have been done. There are no instances where we see that error message. It doesn’t mean that there is not some interaction between the two threads but since only one is writing to the shared resource (s_IncCounter), the interactions don’t have any side-effects.

Now let’s add a second thread. This one exactly matches the first worker thread.

private static void Thread2()
{
    while (true)
    {
        int j = 0;
        for (int i = 0; i < 5; i++)
        {
            s_IncCount++;
            for (int ii = 0; ii < 1000; ii++)
            {
                j = s_IncCount % 5;
            }
        }
        if (j != 0)
        {
            Debug.Print("s-IncCount % 5 is: " + j.ToString());
        }
    }
}

We start both threads in the main thread.

thread1.Start();
thread2.Start();

When we run these, we immediately see that both threads are reporting problems. Thread 1 is being interrupted in the middle of making its 5 increments and then Thread 2 starts up from there and runs some unknown number of times. The result can be seen below.

Even with three threads competing for time slices, the total throughput (increments/sec) do not change. The thread swapping is very low overhead in NETMF.

So, what we are seeing is just one of the pitfalls of a multithreaded environment that is called a race condition. That means that the results of your program are being determined by two threads racing against each other to complete their tasks. That is clearly not what you want. For our program to function smoothly, we need the portions of each thread that work on the shared resource to complete entirely (ie increment all 5 times then then swap out). Stated another way, those lines of code need to execute ‘atomically’ – as if they were one undisturbed machine instruction. Let’s look at the support NETMF has for this.

First, there is the Interlocked class that you saw in the previous article. The Interlocked class lets you perform a prescribed set of operations on a resource atomically. That set of operations that are supported are the methods to this class. The syntax for this is

Interlocked.Increment(ref s_IncCount);

You might not think you even need this lock – isn’t one line of code an atomic thing in itself? In fact it isn’t. To do the increment, the value is copied from the variable and into a register, incremented there, and then copied back to the variable in three separate instructions and the thread can be swapped out anywhere during that time.

What if you need to do more than the Interlocked class supports (a more complex operation on the resource or operations on several resources) and you need it to all complete before someone else can touch the resources. That is where the Lock mechanism comes in. In our example, we want to execute a number of steps on the counter and test what we did before we let anyone else have access to it. To do this, I first define an object that the will be used by the lock to identify it.

private static object s_IncLock = new object();

Now I add a lock that looks like this in each of our threads:

private static void Thread1()
{
    while (true)
    {
        int j = 0;
        lock (s_IncLock)
        {
            Debug.Print("Lock 1");
            for (int i = 0; i < 5; i++)
            {
                s_IncCount++;
                for (int ii = 0; ii < 1000; ii++)
                {
                    j = s_IncCount % 5;
                }
            }
            if (j != 0)
            {
                Debug.Print("s_IncCount % 5 is: " + j.ToString());
            }
        }
    }
}

With these locks, our output no longer has the race condition and the message reflecting the race condition is no longer showing up.

There is an interesting interaction between the Lock and the thread scheduler. Without the lock, each thread would execute for its 20 mSec before yielding. That would be many iterations of the while loop in each time slice. However, the thread scheduler takes locks into consideration in the following way – when each thread asks for the lock, the scheduler sees if there is anyone waiting for that lock. The priority goes to the thread that has been waiting the longest so the two threads we have defined end up executing the lock one time each and swapping back and forth.

The output looks like this:

Swapping out for each iteration through the while loop still does not change the number of iterations in a measurable way. You can see that locking and thread swapping is REALLY low overhead.

MethodImplOptions Attribute

There is a way to lock a method as opposed to a critical section within a method. That is using the MethodImplOptions attribute. The syntax looks like:

[MethodImpl(MethodImplOption.Synchronized)]
public void MySynchronizedMethod()
{
….
}

This locks the method so that only one thread can access it at a time. If one thread is in the method when it is swapped out and another thread tries to access that method, the second thread blocks.

Monitor Class

Before we leave locks, it is worth mentioning that NETMF supports the Monitor class which does effectively the same thing as the lock mechanism – it defines a critical section and blocks other threads from entering that section while there is a lock on it. Monitors are a little more flexible because they are not limited to using braces to define scope. With Monitors, you can exit your Monitor anywhere– possibly in different paths of execution. This flexibility comes with more risk making it easier to have a path of execution where the Monitor does not Exit(object) or Exit(object) is called more than Enter(object) is called.

The NETMF Monitor class is simpler than the full .NET Monitor implementation in that it lacks event wait handles. For those, you have to use the mechanisms described next.

Thread synchronization - Events

At times, you want to synchronize threads directly – ie run this thread when another thread enters some specific state. There are two ways to do this – one general and one used specifically for UI interactions. First let’s look at Events.

Events are the same mechanism that is available on the full .NET Framework with some minor differences. You can define an event that will control the execution of a thread. In the full .NET Framework, there is a richer semantic that supports waiting for one event, one of several events, or all events to occur. In NETMF, we only support waiting for a single event. First you define an event something like this:

static AutoResetEvent autoEvent = new AutoResetEvent(false);

This sets up the event in an initial state of ‘false’.

Now let’s add a third thread to our sample application that looks like this:

private static void Thread3()
{
    Debug.Print(" Waiting for 10000 iterations");
    autoEvent.WaitOne();
    Debug.Print("Finally got the 10000 iterations");
}

This thread is entered on its Start() call and prints out the message that it is waiting for 10000 iterations and then enters a suspended state until the event triggers (becomes true). In the other threads we add a test after we increment:

if (s_IncCount >= 10000)
{
autoEvent.Set();
}

When the event is Set(), the third thread is unblocked and the scheduler will pick it up quickly since it hasn’t run in some time. Thread3 writes out its second message and then exits and the other threads continue as expected.

The semantics of the AutoResetEvent class are that when set to false (unsignalled) it will block any thread calling the WaitOne() method on that event. Once the event is signaled by someone calling the Set() method on that event the AutoResetEvent unblocks the thread and then returns to the unsignalled state once again blocking. The MaunalResetEvent supports a slightly different set of behaviors. The ManualResetEvent also unblocks threads that have a WaitOne() call when the event is Set(). However, the ManualResetEvent does not automatically go back into an unsignalled state one it unblocks the thread. It stay in a signaled state until its Reset() is called. That means that all calls to WaitOne() return immediately.

Thread Synchronization with the Dispatcher

If you have created a graphical UI for your application using NETMF, then you actually have another thread that is created by the CLR – this is the Dispatcher thread that coordinates the access to all of the UI elements in a thread safe manner. The fact that you now have at least two threads means that you have to manage the access to anything that might be a shared resource. Since your UI logic is sharing the UI elements with the CLR created thread which is actually rendering them and there is no way to define a lock that the Dispatcher thread knows about, there is a different way to safely update the UI resources.

The way to synchronize the two threads is to not execute the code that interacts with the UI Elements on your thread but to execute it on the Dispatcher thread instead. To do this, you define a delegate that the Dispatcher will call back to, you implement the delegate, and you call Dispatcher.BeginInvoke when you want the Dispatcher to invoke your method. (There is also a Dispatcher.Invoke call that is synchronous so you need to define a maximum amount of time you will allow this call the wait for delegate to be called.) There is a previous blog on this topic specifically The Dispatcher and DispatchTimer called Using the Dispatcher.

Summary

This is a rather long blog but this is also a fairly complex subject. We have covered Interlocked, locks, MethodImplOptions, Monitors, Events, and (indirectly) synchronizing with the Dispatcher. Hopefully this is helpful.

Technorati Tags: .NET Micro Framework,NETMF,Threads,Thread Communication,Thread Synchronization,Locks,InterLocked,Monitor Class,Dispatcher,AutoResetEvent,ManualResetEvent

Where to find NETMF this Spring

Colin Miller — Tue, 01 Feb 2011 00:15:50 GMT

This is a busy spring for conferences for the platform. Here is a partial list of places that you can look for us. Spread the word about these events so that people can get hands on with the product and get any questions that they have answered...(read more)

Threads and Thread Priorities in NETMF

Colin Miller — Mon, 17 Jan 2011 21:32:23 GMT

I started this article with the objective of providing a more up to date discussion of thread priorities. I thought first that I should cover a little about threads just in case. If you are already conversant in threads, jump ahead to the Thread Priorities...(read more)

A New Book Experience!!

Colin Miller — Thu, 16 Dec 2010 16:21:45 GMT

There is a new book that is not completely out yet but I am really excited about it. The book is ‘Getting Started with the Internet of Things’ by Cuno Pfister. ( http://oreilly.com/catalog/0636920013037 ) There are a number of reasons that I really...(read more)

Need Help Getting Started with NETMF?

Colin Miller — Mon, 06 Dec 2010 21:45:43 GMT

Updated with new location. and new content description and translation ‘challenge’ Are you a .NET programmer who needs some background in embedded interfaces? Not sure how to debounce a button or why you might want to do that? Maybe you even...(read more)