C# and C++ Synchronize between processes

Question

Hi guys,
We have 2 applications. One written in C# and the other in C++. We need to maintain a counter (in memory) shared between these processes. Every time one of these applications start, it needs to check for this counter and increase it and every time the application shut-down it needs to decrease the counter. If the application has a crash or shut-down using task manager, we also need the counter to decrease.
We thought of using one of the OS synchronization objects like MUTEX.
My question: What kind of sync object is the best for cross process (when one is C# and the other C++)

Hope my question was clear.
Thank you very much,

Adi Barda

Answer 1

Seems like you need a named semaphore (CreateSemaphore): http://msdn.microsoft.com/en-us/library/ms682438(VS.85).aspx for C++ which is suited for increment/decrement.

In C# you have the System.Threading.Semaphore class.

Answer 2

Have a look at this thread for methods to share some memory for synchronisation purposes or here for some suggestions for synchronising in .net/c#.

If there are .net methods available, they should work for both C++ and C#..

Answer 3

You might get away with named semaphore. Semaphore is basically a count, it is here to allow developers limit the number of thread/processes that are accessing some resource. Usually it works like that

1. You create a semaphore with maximum count N.
2. N threads call waiting function on it, WaitForSingleObject or similar and each of them go on without waiting. Each time internal semaphore counter goes down.
3. N+1 thread also calls waiting function but because internal counter of our semaphore is 0 now, it has to wait.
4. One of our first N threads releases the semaphore by calling ReleaseSemaphore function. This function increments internal counter of semaphore.
5. Our waiting thread don't have to wait now, so it resumes but semaphore counter goes back to 0.

I don't think this is how you want to use it though. So, instead, you should:

1. Create named semaphore with initial counter set to zero.
2. When application start, immediately release it, increasing the counter. You'll get previous counter value during that call.
3. When application ends, call WaitForSingleObject(hSemaphore, 0), decreasing the counter. 0 means you don't want to wait.

This is all quite easy.

In C++

//create semaphore
HANDLER hSemaphore = CreateSemaphore(NULL, 0, BIG_NUMBER, "My cool semaphore name");
//increase counter
LONG prev_counter;
ReleaseSemaphore(hSemaphore, 1, &prev_counter);
//decrease counter
WaitForSingleObject(hSemaphore, 0);

In C#

using System.Threading;
//create semaphore
Semaphore sem = new Semaphore(0, BIG_NUMBER, "My cool semaphore name");
//increase counter
int prev_counter = sem.Release(); 
//decrease counter
sem.WaitOne(0);

Names and BIG_NUMBERs should be the same obviously.

If this is not sufficient for your task, you will have to look into shared memory and lock access to it though named mutex, but that is a little bit more complicated.