Exercises in Programming Style–Dataspaces

NOTE : read the rest of the series, or check out the source code.

If you enjoy read­ing these exer­cises then please buy Crista’s book to sup­port her work.

Following on from the last post, we will look at the Dataspaces style today.

Style 29 — Dataspaces

Constraints

• Existence of one or more units that execute concurrently.
• Existence of one or more data spaces where concurrent units store and retrieve data.
• No direct data exchanges between the concurrent units, other than via the data spaces.

To get started, we’ll define our dataspaces — one to store the words we need to process, and one to store the partial frequencies from each concurrent unit processing the words (we’ll see what this means soon).

Next, we’ll define the processWords function that will be executed concurrently.

Each concurrent unit will poll the wordSpace dataspace for words to process and create a word frequencies dictionary for the words that it has processed. Upon exhausting all the available words, each concurrent unit will save the locally aggregated word frequencies into the freqSpace dataspace.

Next, we’ll read the text from Pride & Prejudice and add the words into our wordSpace dataspace for processing.

In Crista’s solution, she kicked off 5 concurrent threads to process the words and waited for all of them to finish before merging the partial results in the freqSpace dataspace. I’m not sure if this fork-join approach is a necessary part of this style, but it seems a reasonable choice here.

To follow the same approach, we can use F#’s Async.Parallel method.

Here, I chose to use Async.RunSynchronously to synchronously wait for the parallel tasks to finish (this is the same approach Crista took in her solution). Alternatively, you can make the wait happen asynchronously by capturing the result of Async.Parallel instead (see Version 2 below).

The next step is pretty straight forward. Iterate through the partial results in the freqSpace dataspace and aggregate them into a single word frequencies dictionary, then return the word frequencies as a sorted array.

Finally, take the top 25 results from the sorted array and display them on screen.

Version 2 — Async all the way

If you didn’t like the synchronous waiting in the fork-join approach above, here’s a modified version of the solution that is async all the way.

So first, we’ll capture the parallel processing of words (and subsequently ignoring the results) as an Async<unit>. Notice that at this point we haven’t done any work yet, we merely captured the asynchronous computation that we will perform (which is one of the key differences between async in C# and F#).

Inside another async { } block, we can action the parallel processing, asynchronously wait for its completion (i.e. do! processAllWords) and then merge the partial results in the freqSpace dataspace as before.

Finally, we’ll kick off the entire train of asynchronous computations that we have composed together with Async.Start.

And voila, now everything runs asynchronously end-to-end

You can find the source code for this exercise here (v1) and here (v2 — async all the way).