Usage

.Net provides atomic operations for variables that are shared by multiple threads .These operation are exposed by Interlocked class.

Concurrent Extensions Library (CEL) with it's InterlockedEx class provides a broader range of atomic operations like multiplying, bitwise AND, OR, XOR and more...

The following example computes a mathematical power in parallel in a thread safe way, by using InterlockedEx class.

class Mul
{
    /// <summary>
    /// Holds the accumulated multiplied value which can be 
    /// accessed by multiple threads.
    /// This variable must be accessed in a thread safe way
    /// </summary>
    int _total = 0;

    public Mul(int initial)
    {
        _total = initial;
    }

    /// <summary>
    /// Retruns the total value
    /// </summary>
    public int Total
    {
        get { return _total; }

    }

    /// <summary>
    /// Multiplies the running total with the specified factor, 
    /// in a thread safe way
    /// </summary>
    public void MultiplyTotal(int factor)
    {
        //This method multiplies _total with factor, 
        //saves the product in _total and returns the product atomically 
        InterlockedEx.Mul(ref _total, factor);
    }
}

 

class Program
{
    static void Main(string[] args)
    {
        //the base
        int x = 2;
        //the power
        int y = 30;

        //compute the power
        int res = Power(x, y);

        Console.WriteLine("{0} raised to the power of {1} = {2}.", x, y, res);
                
        Console.ReadLine();
    }

    /// <summary>
    /// Raises x to the power of y in parallel
    /// </summary>        
    static int Power(int x,int y)
    {
        Mul m = new Mul(x);

        //x is multiplied y times in a thread safe manner
        Parallel.For(1, y , (i) =>
        {
            m.MultiplyTotal(x);
        });

        return m.Total;
    }

}

 

The program's output is:

2 raised to the power of 30 = 1073741824

Concept

InterlockedEx behaves the same as Interlocked class:

  • It does not block any thread
  • Operations (function calls) are atomic - doing the operation, getting the result and assigning it to the shared variable are atomic.
  • The shared variable is manipulated in a thread safe manner
  • Method calls are very fast

InterlockedEx contains operations like - bitwise AND, OR, XOR, mathematical minimum, mathematical maximum, integer multiplication.

CEL Future releases will include more atomic operations, and other implementations that enrich the concurrernt APIs which .Net exposes.

 


API

InterlockedEx Methods

 


Last edited Nov 28, 2012 at 8:57 AM by brin_zohar, version 30

Comments

No comments yet.