MemoryBarrier vs volatile vs lock

[DanGo]

Hi All,

I'm trying to get my head around synchronization .

Documentation seems to say that creating a volatile field gives a
memorybarrier.

Great! But when I do a little performance testing Thread.MemoryBa rrier is
40 times slower than accessing a volatile int. Also I don't see any
significant difference between the time to increment a volatile int and a
non-volatile int.

Could the difference all be attributable to the overhead of a function call?

When I read documentation on Thread.Volatile Write it says that all other
processors are guaranteed to see your write immediately.

But when I use reflector to decompile VolatileWrite I get:

public static void VolatileWrite(r ef int address, int value)
{
Thread.MemoryBa rrier();
address = value;
}

Now if the MemoryBarrier is before the write couldn't I throw the
MemoryBarrier on processor1 read value (through the cache) on processor 2 and
then write to address on processor 1 now the next read of address on
processor2 gets its "cached" value from before the new write.

(Boy it's as hard to write about this stuff as it is to read).
processor1: Thread.MemoryBa rrier
processor2: read address getting old_value (old_value cached)
processor1: address = new_value
processor2: read address still returning old_value.

VolatileWrite the way it is written seems to guarantee that any write before
it will get to main memory before this write but makes no guarantees about
this write.

Thanks

[DanGo]

My Results of running following code:

baseline = 00:00:00.031823 5
volatile_int = 00:00:00.032038 4
Memory Barriers = 00:00:01.144961 4
VolatileMethods = 00:00:02.317065 1
locked = 00:00:00.485872 3
Interlocked = 00:00:00.090715 4

Code:

using System;
using System.Collecti ons.Generic;
using System.Text;
using System.Diagnost ics;
using System.Threadin g;

namespace ConsoleApplicat ion1
{
class Program
{
private object _syncobj = new Object();
private int m_a;
private volatile int m_v;

public void Test()
{
Stopwatch sw = new Stopwatch();

m_a = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
m_a++;

Console.WriteLi ne("baseline = " + sw.Elapsed);

sw.Reset();
m_v = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
m_v++;

Console.WriteLi ne("volatile_in t = " + sw.Elapsed);

sw.Reset();
m_v = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
{
// Thread.MemoryBa rrier();
m_v++;
Thread.MemoryBa rrier();
}

Console.WriteLi ne("Memory Barriers = " + sw.Elapsed);

sw.Reset();
m_a = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
Thread.Volatile Write(ref m_a, Thread.Volatile Read(ref m_a)+1);

Console.WriteLi ne("VolatileMet hods = " + sw.Elapsed);

sw.Reset();
m_a = 0;
sw.Start();

for (int i = 0; i < 10000000; ++i)
{
lock(_syncobj)
{
m_a++;
}
}

Console.WriteLi ne("locked = " + sw.Elapsed);

sw.Reset();
m_a = 0;
sw.Start();

for (int i = 0; i < 10000000; ++i)
{
Interlocked.Inc rement(ref m_a);
}

Console.WriteLi ne("Interlocke d = " + sw.Elapsed);

sw.Reset();
}
static void Main(string[] args)
{
Program p = new Program();
p.Test();
}
}
}

[DanGo]

"DanGo" wrote:

My Results of running following code:

baseline = 00:00:00.031823 5
volatile_int = 00:00:00.032038 4
Memory Barriers = 00:00:01.144961 4
VolatileMethods = 00:00:02.317065 1
locked = 00:00:00.485872 3
Interlocked = 00:00:00.090715 4

Note that using a lock is considerably faster than using a memorybarrier.

Doesn't a lock imply a memory barrier ( a read barrier at the top and a
write barrier at the bottom) Since the lock is 4-5 times faster than a pair
of memory barriers and twice as fast as a single barrier. We could use lock
in place of calls to MemoryBarrier.

If a volatile field really gives us a barrier it is much faster. In
addition it also gives the compiler hints on how to treat the field.

[Daniel O'Connell [C# MVP]]

"DanGo" <Da***@discussi ons.microsoft.c om> wrote in message
news:EB******** *************** ***********@mic rosoft.com...

"DanGo" wrote:

My Results of running following code:

baseline = 00:00:00.031823 5
volatile_int = 00:00:00.032038 4
Memory Barriers = 00:00:01.144961 4
VolatileMethods = 00:00:02.317065 1
locked = 00:00:00.485872 3
Interlocked = 00:00:00.090715 4

Note that using a lock is considerably faster than using a memorybarrier.

Are you using a multiple processor machine? I ran your test on my machine
and got these results:

baseline = 00:00:00.019197 1
volatile_int = 00:00:00.023364 5
Memory Barriers = 00:00:00.967236 9
VolatileMethods = 00:00:01.952810 8
locked = 00:00:01.780008 2
Interlocked = 00:00:00.725799 6

Memory Barrier is considerably faster than using a lock. I don't know the
synchronization structure well, but its possible that lock doesn't actually
use a memory barrier if there is only one processor.

[Jon Skeet [C# MVP]]

Daniel O'Connell [C# MVP] <[e-mail]> wrote:

<snip>

Memory Barrier is considerably faster than using a lock. I don't know the
synchronization structure well, but its possible that lock doesn't actually
use a memory barrier if there is only one processor.

It should do - otherwise you can still have problems, if (for instance)
another thread has a variable value cached in a register.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Daniel O'Connell [C# MVP]]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

Daniel O'Connell [C# MVP] <[e-mail]> wrote:

<snip>

Memory Barrier is considerably faster than using a lock. I don't know the
synchronization structure well, but its possible that lock doesn't
actually
use a memory barrier if there is only one processor.

It should do - otherwise you can still have problems, if (for instance)
another thread has a variable value cached in a register.

Good point, perhaps a more limited memory barrier, no processor cache flush,
just a register flush to processor cache?

Thats conjecture mostly, I have no clue how the performance of sync
primatives work, other than his machine does is not the same as what mine
does.

[Jon Skeet [C# MVP]]

Daniel O'Connell [C# MVP] <[e-mail]> wrote:

It should do - otherwise you can still have problems, if (for instance)
another thread has a variable value cached in a register.
Good point, perhaps a more limited memory barrier, no processor cache flush,
just a register flush to processor cache?

Possibly - but then couldn't MemoryBarrier do the same thing?
Thats conjecture mostly, I have no clue how the performance of sync
primatives work, other than his machine does is not the same as what mine
does.

Right. For the record, here are the results on my single processor
Pentium-M laptop:

baseline = 00:00:00.038889 0
volatile_int = 00:00:00.039399 9
Memory Barriers = 00:00:00.277513 4
VolatileMethods = 00:00:00.635096 6
locked = 00:00:00.351767 6
Interlocked = 00:00:00.173056 9

Interesting to see that your baseline and volatile int are better than
mine, but all the rest of mine are better than yours. Odd.

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet
If replying to the group, please do not mail me too

[Daniel O'Connell [C# MVP]]

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...

Daniel O'Connell [C# MVP] <[e-mail]> wrote:

> It should do - otherwise you can still have problems, if (for instance)
> another thread has a variable value cached in a register.

Good point, perhaps a more limited memory barrier, no processor cache
flush,
just a register flush to processor cache?

Possibly - but then couldn't MemoryBarrier do the same thing?

Very possibly, but I have no clue if it does or not. Peformance gets to be a
sticky thing when you scale out in processors.

Thats conjecture mostly, I have no clue how the performance of sync
primatives work, other than his machine does is not the same as what mine
does.

Right. For the record, here are the results on my single processor
Pentium-M laptop:

baseline = 00:00:00.038889 0
volatile_int = 00:00:00.039399 9
Memory Barriers = 00:00:00.277513 4
VolatileMethods = 00:00:00.635096 6
locked = 00:00:00.351767 6
Interlocked = 00:00:00.173056 9

Interesting to see that your baseline and volatile int are better than
mine, but all the rest of mine are better than yours. Odd.

Might be raw speed, might be due to multiple processors, might be because
yours is a laptop and mine not, might be luck. This is a dual 2.2ghz with
hyperthreading enabled.

[DanGo]

Here is an updated version of the source:

This version uses baseline as a normalization for the other tests:

class Program
{
private object _syncobj = new Object();
private int m_a;
private volatile int m_v;

public void Test()
{
Stopwatch sw = new Stopwatch();

m_a = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
m_a++;
sw.Stop();
Console.WriteLi ne("baseline = " + ": 1.0");
float baselineNormali zation = sw.ElapsedTicks ;
sw.Reset();
m_v = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
m_v++;

sw.Stop();
Console.WriteLi ne("volatile_in t = " + ": " +
(sw.ElapsedTick s/baselineNormali zation).ToStrin g());

sw.Reset();
m_v = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
{
// Thread.MemoryBa rrier();
m_v++;
Thread.MemoryBa rrier();
}

sw.Stop();
Console.WriteLi ne("Memory Barriers = " + ": " + (sw.ElapsedTick s
/ baselineNormali zation).ToStrin g());

sw.Reset();
m_a = 0;
sw.Start();
for (int i = 0; i < 10000000; ++i)
Thread.Volatile Write(ref m_a, Thread.Volatile Read(ref m_a)+1);

sw.Stop();
Console.WriteLi ne("VolatileMet hods = " + ": " + (sw.ElapsedTick s
/ baselineNormali zation).ToStrin g());

sw.Reset();
m_a = 0;
sw.Start();

for (int i = 0; i < 10000000; ++i)
{
lock(_syncobj)
{
m_a++;
}
}

sw.Stop();
Console.WriteLi ne("locked = " + ": " + (sw.ElapsedTick s /
baselineNormali zation).ToStrin g());

sw.Reset();
m_a = 0;
sw.Start();

for (int i = 0; i < 10000000; ++i)
{
Interlocked.Inc rement(ref m_a);
}

sw.Stop();
Console.WriteLi ne("Interlocke d = " + ": " + (sw.ElapsedTick s /
baselineNormali zation).ToStrin g());

sw.Reset();
}
static void Main(string[] args)
{
Program p = new Program();
p.Test();
}

[Daniel O'Connell [C# MVP]]

"DanGo" <Da***@discussi ons.microsoft.c om> wrote in message
news:E5******** *************** ***********@mic rosoft.com...

Here is an updated version of the source:

This version uses baseline as a normalization for the other tests:

Still seeing quite a bit of difference, what did you get?:

baseline = : 1.0
volatile_int = : 1.007561
Memory Barriers = : 53.18861
VolatileMethods = : 105.0428
locked = : 97.86585
Interlocked = : 39.32712