Port Concurrency Runtime (PCR)

New Post: Is this project still alive?

blessyahu — Tue, 28 Apr 2009 22:45:04 GMT

If the CCR is moved to .NET 4 library, it will leave out anyone who is using the IDE less than 2010. I think that is a lot now.

New Post: Is this project still alive?

staceyw — Thu, 02 Apr 2009 04:45:06 GMT

Still here. Have not updated in a while. With CCR moving to a library and then probably some form in the Fx, I will have to see what direction this could go without overlapping current offerings.

NEW POST: Is this project still alive?

kwaclaw — Tue, 21 Aug 2007 15:58:54 GMT

Haven't seen any activity since January.

Karl

NEW POST: Managed IOCP & ACB

adityapasumarthi — Sat, 14 Jul 2007 04:03:22 GMT

Hi,

I saw PCR recently and wanted the guys using PCR to take a look at my own concurrency libraries for .Net community. My libraries won Article of the Month award for Oct' 2006 and had clear design patterns for multi-threaded and asynchronous applications. These libraries come with lock-free implementations that provide good performance for server side applications. Moreover I tried to put pretty good documentation for these libraries, which are available as articles on CodeProject.com.

My intention of this post is only informational.

Here are the links to my articles and libraries.

1. Asynchronous Code Blocks
http://www.codeproject.com/cs/library/AsynchronousCodeBlocks.asp

2. Managed I/O Completion Ports (IOCP)
http://www.codeproject.com/cs/library/managediocp.asp

3. Managed I/O Completion Ports (IOCP) - Part 2
http://www.codeproject.com/cs/library/managediocp-part-2.asp

Regards,

Adityanand Pasumarthi

NEW POST: Sample: Chat

aldousd666 — Fri, 13 Jul 2007 03:29:51 GMT

sorry to post again, but someone actually articulated the issue very well on a news group about IOCP... nobody shows any examples of actually writing data back to a client. which is the bit I'm a little frustrated with. Not to do with your library in particular, but it's a screwey scenario in basically all situations that would use IOCP. I think Winsock accounts for this by offering AcceptEx with the native call, but as far as I can see there isn't an equivalent nice (not that AcceptEx makes it all that much clearer) way to do this in the CLR because it's such a new idea, and basically doing this in managed code virtualizes the whole process so the native implementation may not only be painful, but actually counter productive, exposing one to the preemptive nature of the native IOCP stuff. Does that help make what I'm getting at any clearer? I hope so.

NEW POST: Sample: Chat

aldousd666 — Thu, 12 Jul 2007 04:03:16 GMT

That is pretty neat, and it's close to what I'm trying to get to. But what if I want each client only to receive it's own messages... how would I sequence this, do I just use the shared storage like this and have them all filter for a key... that might be a little too chatty for something like a data engine. I just can't get my head around how I'd be able to take advantage of asynch operations in a client server scenario, though it all makes complete sense when you're printing stuff to the console and broadcasting, I'm just missing the last piece. I'm sure I'm not the only one. Can you please enlighten?

UPDATED WIKI: FAQ

staceyw — Fri, 16 Mar 2007 16:39:19 GMT

PCR FAQ

UPDATED WIKI: What is a Selector?

staceyw — Fri, 16 Mar 2007 16:34:41 GMT

What is a Selector?

The best way to think about selectors is with an analogy. A selector is like a query on a collection of objects in a port. If the query matches, the item(s) are removed from the port and the selector is run asyncronously. Using this thinking, a port is the table, the port items are the rows, and a Selector is the SQL query.

NEW POST: How many threads, and how distributed?

staceyw — Fri, 16 Mar 2007 16:29:38 GMT

"The major issue that I keep coming up against is how the work is assigned to a thread. The .NET thread pool doesn't strike me as the right approach because worker threads are intended to get in and get out quickly. So, a different threading model is required. But it also begs the question, what kind of infrastructure would be needed to deal with issues such as thread creation and processor utilization?"

In the general case, the TP works pretty well. As you point out, most cases, you don't want to start a thread per work item, as if that was desired, you would not need any of this and could just start threads passing ThreadStart delegate and go. On the other hand, there are times when you want more threads and your own thread pool. I may need 1 thread per client connection for example upto some max and what to leave the TP for io tasks. In this case, we could use a custom Dispatcher (i.e. tp) using our own TP logic. The CCR has this option, I have not added that yet.

"For example, it makes no sense to distribute work across 50 threads if you have two cores and each of those threads is going to utilize the core 100%. However, the thread is waiting for completion of other events (perhaps I/O, etc), then it does make sense."

Exactly. Good point. The thread pool is designed for exactly that. If you have say max 4 threads in the thread pool and 2 cores, the thread pool will start 2 threads. If one of those threads blocks on IO (which mostly happens eventually), another thread is released upto max threads. This now means 3 threads will be running when t2 unblocks. It is not ideal as now 2 threads will be competing for cpu time, but it works pretty well in general. There is some studder because of built in lag times so not to start and stop thread in a spastic way which would void most benefit from TP.

"What sort of plans do you have for addressing these issues? Is there (and can there be) a clean separation of concerns between the work list and the assignment of a work item to a thread? If that were possible, then different engines for assigning the work item could be explored without affecting the core concepts of mailboxes/ports and pattern/selectors."

Plan is to at least as a custom Dispatcher that does its own TP. So there is a pretty clean separation of work list and worker today because we can swap Dispatchers with no change to other code and the selectors don't care what dispatcher is used - all they know is they run. If you mean other, please explain. It is an interesting topic.

NEW POST: Erlang Programming Language

staceyw — Fri, 16 Mar 2007 16:07:23 GMT

That is interesting. I know nothing of Erlang, but that seems similar idea. Your thoughts on Linq are right on. In many ways this is Linq like. I will explore linq integration how that may fit. If you have ideas, please let me know.

How many threads, and how distributed?:

cliftonm — Fri, 23 Feb 2007 15:59:35 GMT

The major issue that I keep coming up against is how the work is assigned to a thread. The .NET thread pool doesn't strike me as the right approach because worker threads are intended to get in and get out quickly. So, a different threading model is required. But it also begs the question, what kind of infrastructure would be needed to deal with issues such as thread creation and processor utilization?

For example, it makes no sense to distribute work across 50 threads if you have two cores and each of those threads is going to utilize the core 100%. However, the thread is waiting for completion of other events (perhaps I/O, etc), then it does make sense.

What sort of plans do you have for addressing these issues? Is there (and can there be) a clean separation of concerns between the work list and the assignment of a work item to a thread? If that were possible, then different engines for assigning the work item could be explored without affecting the core concepts of mailboxes/ports and pattern/selectors.

Marc

Erlang Programming Language:

cliftonm — Fri, 23 Feb 2007 15:51:19 GMT

This reminds me of the Erlang Programming Language, and its description of how concurrency is handled:

"The processes communicate via a share-nothing asynchronous message-passing system: every process has a "mailbox", a queue of messages sent by other processes, that are not yet consumed. Threads then use the receive primitive to retrieve messages that match desired patterns. A message-handling routine tests messages in turn against each pattern, until one of them matches. When the message is consumed (removed from the mailbox), the thread resumes execution."

So, for example, their "mailbox" is your "port", their "pattern" is your "selector".

Is there any consideration to using Linq for building expressions that determine selector? It seems like you're mostly there already with the delegate method.

Source code checked in

staceyw — Wed, 31 Jan 2007 22:57:36 GMT

UPDATED WIKI: Cool comments from devs

staceyw — Tue, 30 Jan 2007 16:51:49 GMT

Karloff wrote Mon at 5:33 PM delete this comment
Excellent work and a much needed alternative to CCR for the community who may not be able to utilize commercial licensing of the MS Robotics Runtime components. I look forward to giving the PCR a run. Keep up the fantastic job and thanks!

UPDATED WIKI: FAQ

staceyw — Tue, 30 Jan 2007 16:50:54 GMT

PCR FAQ

UPDATED WIKI: What is a Port?

staceyw — Tue, 30 Jan 2007 16:29:15 GMT

What is a Port?

A port is a container for objects of a type. A port also contains a collection of handlers that will be evaluated in-order when a new item is added to the port. So a port contains both items and selectors(1) as seperate lists. After adding an item, if a selector is satisfied, the matching item(s) are removed from the port and the selector is invoked with the item(s).

1) A Selector contains logic to pick one or more items from one or more ports.

UPDATED WIKI: FAQ

staceyw — Tue, 30 Jan 2007 16:21:05 GMT

PCR FAQ

UPDATED WIKI: Home

staceyw — Tue, 30 Jan 2007 16:20:24 GMT

What is PCR?

Port Concurrency Runtime (PCR) is a Port-Based asyncronous message passing library.

Simply put, you push messages to ports and the messages are processed (i.e popped) asyncronously using handlers which we call Selectors. All messages (i.e. objects) are sent and received via a Port. Selectors are user defined message handlers that can atomically process a single message or multiple messages from one or more ports based on rules defined by the Selector. The library includes common selectors that should satisfy the most common patterns such as SelectOne, SelectMany, Choice, Interleave, and Join.

        /// <summary>
        /// Test single item selector. SelectOne "can" have a FIFO gaureentee (depending on other factors defined by usage). In this case, only one
        /// selector will be scheduled at a time, but can also be set to run concurrent. The selector will run again when a message is pushed on port.
        /// </summary>
        static void SelectOneTest()
        {
            // Create a port and add some items.
            Port<string> p = new Port<string>();
            for (int i = 0; i < 20; i++)
                p.Push(i.ToString("00"));
            int activeCount = 0;
 
            // Create and activate the selector.
            Selector.SelectOne<string>(true, p,
                delegate(string s)
                {
                    if ( Interlocked.Increment(ref activeCount) > 1 )
                        Console.WriteLine("Error: active count should never go above 1.");
                    Console.WriteLine("SelectOneTest: {0} ThreadID:{1:00} Active:{2}", s, Thread.CurrentThread.ManagedThreadId, activeCount);
                    Thread.Sleep(10);
                    Interlocked.Decrement(ref activeCount);
                }).Add(); 
        }

The above code shows the general pattern that will be used by all selectors. A port is created, messages are added, and we register a selector query to process messages when they arrive on the port. The PCR runtime handles invoking the selector(s) registered with the port based on the selector rules and message availability. So a selector could run right away or not at all. More complex patterns such as selecting from many ports (i.e. a Join) or selecting many messages from a single port follow the same pattern. Things like Where filters are as simple as supplying a predicate delegate to a selector.

Helpful Links

--
William Stacey [C# MVP]

UPDATED WIKI: When is port processed FIFO or not?

staceyw — Tue, 30 Jan 2007 08:46:05 GMT

When are Port items processed in FIFO order?

By itself, a Port has FIFO queue symantics. Items are added at the end of the port and retrieved from the start of the port. However, Selectors can change this.

A Port is FIFO when:

A Selector's concurrent flag set to false. Another handler will not be scheduled until the current handler completes.
No other selectors are attached to the port. Another selector may also grab items from the port. Therefore, in the context of each selector, items could seem to be missing.
No filter (i.e. a Where predicate) is used. A filter explicitly nullifies the FIFO contract because it can grab items out of order.

A Port is not FIFO when:

A Selector's concurrent flag set to true. This would allow multiple items to be scheduled concurrently. The order of execution is not defined by the OS scheduler.
Multiple selectors are attached to the same port. Selectors would compete for items and the order of execution would be undefined.
A filter is used. A Selector filter, by design, allows for out-of-order processing of items.

UPDATED WIKI: When is port processed FIFO or not?

staceyw — Tue, 30 Jan 2007 08:45:40 GMT

A Port is FIFO when:

A Selector's concurrent flag set to false. Another handler will not be scheduled until the current handler completes.
No other selectors are attached to the port. Another selector may also grab items from the port. Therefore, in the context of each selector, items could seem to be missing.
No filter (i.e. a Where predicate) is used. A filter explicitly nullifies the FIFO contract because it can grab items out of order.

A Port is not FIFO when:

A Selector's concurrent flag set to true. This would allow multiple items to be scheduled concurrently. The order of execution is not defined by the OS scheduler.
Multiple selectors are attached to the same port. Selectors would compete for items and the order of execution would be undefined.
A filter is used. A Selector filter, by design, allows for out-of-order processing of items.