{"id":55925,"date":"2010-04-12T10:00:00","date_gmt":"2010-04-12T10:00:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/pfxteam\/2010\/04\/12\/parallelextensionsextras-tour-8-reductionvariablet\/"},"modified":"2010-04-12T10:00:00","modified_gmt":"2010-04-12T10:00:00","slug":"parallelextensionsextras-tour-8-reductionvariablet","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/dotnet\/parallelextensionsextras-tour-8-reductionvariablet\/","title":{"rendered":"ParallelExtensionsExtras Tour – #8 – ReductionVariable"},"content":{"rendered":"

(The full set of ParallelExtensionsExtras Tour posts is available <\/em>here<\/em><\/font><\/a>.)<\/em> <\/font><\/font><\/p>\n

The new .NET 4 System.Threading.ThreadLocal<T><\/a> is quite useful when you need per-thread, per-instance storage.  <\/span>This is in contrast to the fast ThreadStaticAttribute, which supports only per-thread storage (in .NET 4, ThreadLocal<T> actually layers on top of ThreadStaticAttribute to provide the additional per-instance behavior).<\/p>\n

<\/font><\/font><\/p>\n

ThreadLocal<T> exposes through its Value property the thread-local value of the variable for the current thread.  <\/span>However, it doesn’t expose in any way a collection of all of the thread-local values that have been created on that ThreadLocal<T> instance.  <\/span>Having that functionality can be useful in a variety of circumstances.  <\/span>For example, if you use ThreadLocal<T> to store per-thread instances of some heavyweight and disposable object, you might want to dispose of all of the instances when you’re done using them.  <\/span>Or if you were implementing a reduction, doing a local reduction on each thread involved in the computation, you would need access to all of the thread-local values at the end in order to do the final cross-thread reduction.<\/font><\/font><\/p>\n

This extra functionality is quite similar to the combinable<\/a> type provided in Visual C++ 10.  <\/span>And although ThreadLocal<T> doesn’t provide this functionality out-of-the-box, we can easily layer it on top of it.  <\/span>This is precisely what the ReductionVariable<T> type in ParallelExtensionsExtras<\/a> provides (see the ReductionVariable.cs file).<\/p>\n

<\/font><\/font><\/p>\n

The ReductionVariable<T> type is very similar to ThreadLocal<T> in surface area, the key difference being that it adds a Values property (plural) that’s an IEnumerable<T> in addition to exposing the familiar Value property (singular) that returns a T:<\/p>\n

<\/font><\/font><\/p>\n

public sealed class ReductionVariable<T><\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>public ReductionVariable(Func<T> seedFactory);<\/p>\n

<\/font><\/p>\n

    <\/span>public T Value { get; }<\/p>\n

<\/font><\/p>\n

 <\/span>   <\/span>public IEnumerable<T> Values { get; }<\/p>\n

<\/font><\/p>\n

    <\/span>… \/\/ a few additional public helper methods<\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

The ReductionVariable<T> instance maintains three private fields:<\/p>\n

<\/font><\/font><\/p>\n

private readonly Func<T> _seedFactory;<\/p>\n

<\/font><\/p>\n

private readonly ThreadLocal<StrongBox<T>> _threadLocal;<\/p>\n

<\/font><\/p>\n

private readonly ConcurrentQueue<StrongBox<T>> _values;<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

The Func<> is the user-provided delegate used to initialize a thread’s local value when one hasn’t been initialized yet (if the seed factory is null, the default value of T will be used).  <\/span>The ThreadLocal<> is the thread-local storage, and the ConcurrentQueue<> is used to store all of the values from all of the threads.<\/p>\n

<\/font><\/font><\/p>\n

Because we need to maintain a list of all of the thread-local values, and because the thread-local values might change over time, we need to wrap the values with an object we can always use to reference each of them.  <\/span>For that purpose, we utilize the System.Runtime.CompilerServices.StrongBox<T> type, which is simply an object that contains a field of type T.  <\/span>Then, instead of using a ThreadLocal<T>, we utilize a ThreadLocal<StrongBox<T>>, and instead of using a ConcurrentQueue<T>, we use a ConcurrentQueue<StrongBox<T>>.  <\/span>In this manner, the Value field of the StrongBox instances may change repeatedly, but the StrongBox<T> object reference will remain constant.  <\/span>From this, the rest of the implementation falls into place.<\/p>\n

<\/font><\/font><\/p>\n

The constructor initializes the ThreadLocal<StrongBox<T>> to create a StrongBox<T> that wraps a newly created seed value and adds that new StrongBox<T> instance to the queue of values.<\/p>\n

<\/font><\/font><\/p>\n

public ReductionVariable(Func<T> seedFactory)<\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>_seedFactory = seedFactory;<\/p>\n

<\/font><\/p>\n

    <\/span>_threadLocal = new ThreadLocal<StrongBox<T>>(CreateValue);<\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

private StrongBox<T> CreateValue()<\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>var s = new StrongBox<T>(<\/p>\n

<\/font><\/p>\n

        <\/span>_seedFactory != null ? _seedFactory() : default(T));<\/p>\n

<\/font><\/p>\n

    <\/span>_values.Enqueue(s);<\/p>\n

<\/font><\/p>\n

    <\/span>return s;<\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

The Value property then need only get and set the boxed value’s value:<\/p>\n

<\/font><\/font><\/p>\n

public T Value<\/p>\n

<\/font><\/p>\n

{<\/p>\n

<\/font><\/p>\n

    <\/span>get { return _threadLocal.Value.Value; }<\/p>\n

<\/font><\/p>\n

    <\/span>set { _threadLocal.Value.Value = value; }<\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

And the Values property need only return the contents of the list.  <\/span>Of course, we don’t want to return the StrongBox<T> instances, but rather the values they contain, so we’ll use LINQ’s Select method to select just the values:<\/p>\n

<\/font><\/font><\/p>\n

public IEnumerable<T> Values <\/p>\n

<\/font><\/p>\n

{ <\/p>\n

<\/font><\/p>\n

    <\/span>get { return _values.Select(s => s.Value); } <\/p>\n

<\/font><\/p>\n

}<\/p>\n

<\/font><\/p>\n

\n

 <\/font><\/p>\n<\/p>\n

With our ReductionVariable<T> in place, we can now utilize it to perform reductions, to track and clean up after thread-local state, and more.  <\/span>Here’s an example:<\/p>\n

<\/font><\/font><\/p>\n

var edos = new ReductionVariable<ExpensiveDisposableObject>(<\/p>\n

<\/font><\/p>\n

    <\/span>() => new ExpensiveDisposableObject());<\/p>\n

<\/font><\/p>\n

var q = (from d in dataSource.AsParallel<\/p>\n

<\/font><\/p>\n

         <\/span>select ProcessValueWithExpensiveObject(d, edos.Value)).ToArray();<\/p>\n

<\/font><\/p>\n

foreach(var edo in edos) edo.Dispose();<\/p>\n

<\/font><\/p><\/p>\n","protected":false},"excerpt":{"rendered":"

(The full set of ParallelExtensionsExtras Tour posts is available here.)  The new .NET 4 System.Threading.ThreadLocal<T> is quite useful when you need per-thread, per-instance storage.  This is in contrast to the fast ThreadStaticAttribute, which supports only per-thread storage (in .NET 4, ThreadLocal<T> actually layers on top of ThreadStaticAttribute to provide the additional per-instance behavior). ThreadLocal<T> exposes through […]<\/p>\n","protected":false},"author":360,"featured_media":58792,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[7908],"tags":[7907,7911,7916,7909,7924],"class_list":["post-55925","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pfxteam","tag-net-4","tag-code-samples","tag-coordination-data-structures","tag-parallel-extensions","tag-parallelextensionsextras"],"acf":[],"blog_post_summary":"

(The full set of ParallelExtensionsExtras Tour posts is available here.)  The new .NET 4 System.Threading.ThreadLocal<T> is quite useful when you need per-thread, per-instance storage.  This is in contrast to the fast ThreadStaticAttribute, which supports only per-thread storage (in .NET 4, ThreadLocal<T> actually layers on top of ThreadStaticAttribute to provide the additional per-instance behavior). ThreadLocal<T> exposes through […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55925","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/users\/360"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/comments?post=55925"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/posts\/55925\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media\/58792"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/media?parent=55925"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/categories?post=55925"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/dotnet\/wp-json\/wp\/v2\/tags?post=55925"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}