Pthread win32 libraray, PTHREAD_PROCESS_SHARED not supported

Question

I am using pthread win32 library to implement mqueue. But when it runs into following code, it throw #40 error should be ENOSYS, means system not supported.

pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
i = pthread_mutex_init(&mqhdr->mqh_lock, &mattr);
pthread_mutexattr_destroy(&mattr);      /* be sure to destroy */

i is 40 after it goes wrong. Any body has idea about this? or do you have some other alternative solution, like use what kind of WIN32 thread function to replace it.

Note: If anyone successfully implement a mqueue in win32? Thanks

Answer 1

•A child process created by the CreateProcess function can inherit a handle to a mutex object if the lpMutexAttributes parameter of CreateMutex enabled inheritance. This mechanism works for both named and unnamed mutexes.

•A process can specify the handle to a mutex object in a call to the DuplicateHandle function to create a duplicate handle that can be used by another process. This mechanism works for both named and unnamed mutexes.

•A process can specify a named mutex in a call to the OpenMutex or CreateMutex function to retrieve a handle to the mutex object.

Answer 2

I don't know if you feel comfortable hacking inside the Win32 PThread library, but, while the full PTHREAD_PROCESS_SHARED behavior cannot be attained, it IS possible to duplicate handles to kernel objects into other processes using the DuplicateHandle API - so it should be possible to add some windows specific extensions (that would compile out in unix builds) that allow a mutex to be shared between processes.

Answer 3

You will want to read up on Windows interprocess synchronization functions.

For an inter-process mutex in Windows, your choices are to implement your own using shared memory and InterlockedCompareExchange (spin then sleep or watch for Event).

Or easier to program but not as performant is to use the OS provided named Mutex object. These perform about 10 times worse than using CriticalSection within threads of a process.

In my own production code I was porting from Linux pthreads, I played with the first solution, but ended up releasing the code using the Mutex solution. It was more reliable and I was sure it would work in all cases.

Answer 4

I recognize the code you are using ...just comment the 2 lines in the code

pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);

...it works fine as a intra-process message queue ...unless you need it across processes.

Answer 5

I believe that is Aurelio Medina's code from 2000.

Unfortunately, his test code was a single process, so it didn't care if the PTHREAD_PROCESS_SHARED flag was set or not, since pthreads-32 has never supported it. When he built it in 2000, I bet that pthreads did't even throw an error, so his test code run fine.

Unfortunately for all of us, it seems he died in 2013, so he's not going to finish his opus.

I've taken up the torch and rewrote the mutex/signal handling to use native windows mutex and events. Please look here for the code:

https://github.com/marklakata/mqueue-w32