boost and winthreads

[Michael Ost]

Does boost::threads + wine threads == happiness?

I would like to use boost threads in my winelib application, but they
need to coexist with threads created using the windows APIs by 3rd party
plugin DLLs. I built a test app that uses the two and they appear to
share both a CRITICAL_SECTION and a boost::mutex fine, so it looks like
I am in the clear. But I don't have alot of confidence in my
understanding of how Wine implements threads, so I thought it would be
wise to ask.

Attached is my test program. To build and run:

$ wineg++ -c boost-win.cpp
$ wineg++ -o boost-win.exe.so boost-win.o -lboost_threads
$ wine ./boost-win.exe.so

Cheers... mo

PS: thanks to whoever is responsible for wineg++. What a timesaver!

boost-win.cpp:

#include "boost/thread.hpp"
#include <pthread.h>			// pthread_create
#include <sys/resource.h>		// PRIO_PROCESS
#include <stdio.h>				// printf
#include <windows.h>			// CreateThread

#define INDENT "                    "

DWORD WINAPI CSTestA(void* arg)
{
    CRITICAL_SECTION* cs = (CRITICAL_SECTION*) arg;
    puts("in, try CS");
    
    ::EnterCriticalSection(cs);
    puts("CS locked");

sleep(2);
    puts("wake up");

::LeaveCriticalSection(cs);
    puts("unlock");

sleep(1);
    puts("wake up, try CS");

::EnterCriticalSection(cs);
    puts("CS locked");

sleep(1);
    puts("wake up");

::LeaveCriticalSection(cs);
    puts("unlock");

puts("out");
}

struct CSTestB
{
    CSTestB(CRITICAL_SECTION* cs) :
    	m_criticalSection(cs)
    {
    }
    void operator()()
    {
    	puts(INDENT "in, try CS");

::EnterCriticalSection(m_criticalSection);
    	puts(INDENT "CS locked");

boost::xtime t;
    	boost::xtime_get(&t, boost::TIME_UTC);
    	t.sec += 3;
    	boost::thread::sleep(t);
    	puts(INDENT"wake up");

::LeaveCriticalSection(m_criticalSection);
    	puts(INDENT "unlocked, out");

boost::xtime_get(&t, boost::TIME_UTC);
    	t.sec += 3;
    	boost::thread::sleep(t);
    	puts(INDENT "out");
    }
    
    CRITICAL_SECTION* m_criticalSection;
};

struct MutexTestA
{
    MutexTestA(boost::mutex* mutex) :
    	m_mutex(mutex)
    {
    }
    void operator()()
    {
    	puts("in - try mutex");
    	boost::xtime t;

{ // scope
    		boost::mutex::scoped_lock lock(*m_mutex);
    		puts("mutex locked");

boost::xtime_get(&t, boost::TIME_UTC);
    		t.sec += 2;
    		boost::thread::sleep(t);
    		
    		puts("wake up");
    	}
    	puts("unlock");

boost::xtime_get(&t, boost::TIME_UTC);
    	t.sec += 1;
    	boost::thread::sleep(t);
    	puts("wake up, try mutex");

{ // scope
    		boost::mutex::scoped_lock lock(*m_mutex);
    		puts("mutex locked");

boost::xtime_get(&t, boost::TIME_UTC);
    		t.sec += 1;
    		boost::thread::sleep(t);
    		
    		puts("wake up");
    	}
    	puts("unlock");

puts("out");
    }
    
    boost::mutex* m_mutex;
};

DWORD WINAPI MutexTestB(void* arg)
{
    boost::mutex* mutex = (boost::mutex*) arg;
    
    puts(INDENT "in - try mutex");

{ // scope
    	boost::mutex::scoped_lock lock(*mutex);
    	puts(INDENT "mutex locked");

boost::xtime t;
    	boost::xtime_get(&t, boost::TIME_UTC);
    	t.sec += 3;
    	boost::thread::sleep(t);
    	
    	puts(INDENT "wake up");
    }
    puts(INDENT "unlock");

puts(INDENT "out");
}

int main(int argc, char *argv[])
{
    // boost blocks on CS held by winthread
    if (argc > 1 && memcmp(argv[1], "cs", 2) == 0) {
    	puts("Testing CRITICAL_SECTIONS...\n");
    	puts("    winThread and boostThread share a CRITICAL_SECTION.
winThread grabs");
    	puts("    it and sleeps, while boostThread waits for winThread to wake
up and");
    	puts("    release. Then vice-versa.");
    	puts("");
    	puts("winThread           boostThread");
    	puts("----------------------------------");
    	CRITICAL_SECTION* criticalSection = new CRITICAL_SECTION();
    	::InitializeCriticalSection(criticalSection);
    
    	DWORD junk;
    	HANDLE winThread = ::CreateThread(NULL, 0, CSTestA, criticalSection,
0, &junk);
    
    	// delay 'cause boost starts faster
    	sleep(1);
    	CSTestB boostTest(criticalSection);
    	boost::thread boostThread(boostTest);
    	
    	boostThread.join();
    	// todo: howto wait for winThread?	
    
    	::DeleteCriticalSection(criticalSection);
    	delete(criticalSection);
    }
    else if (argc > 1 && memcmp(argv[1], "mu", 2) == 0) {
    	puts("Testing boost::mutex...\n");
    	puts("    winThread and boostThread share a boost::mutex. boostThread
grabs");
    	puts("    it and sleeps, while winThread waits for boostThread to wake
up and");
    	puts("    release. Then vice-versa.");
    	puts("");
    	puts("boostThread         winThread");
    	puts("----------------------------------");

boost::mutex mutex;
    	MutexTestA testA(&mutex);
    	boost::thread boostThread(testA);

DWORD junk;
    	HANDLE winThread = ::CreateThread(NULL, 0, MutexTestB, &mutex, 0,
&junk);
    
    	boostThread.join();
    	// todo: howto wait for winThread?	
    }
    else {
    	puts("usage: boost-win [boostcs]");
    	puts("options:");
    	puts("   cs - see if boost and win threads can both honor a
CRITICAL_SECTION");

return 1;
    }
    
    return 0;
}