Re: how to avoid pulling in Win32 include "world" for mutex

andrew_nuss@yahoo.com wrote:
....


First find out how much is space for a critical section. Since a
critical section is more or less a given size for a particular platform
you can use this value.

// run this on all the windows platforms you try
// place some conditionally compiled code that chooses the
// correct values for that platform
#include <windows.h>

#include <iostream>

struct Alignof
{
    char a;
    CRITICAL_SECTION b;
};

int main()
{

         std::cout << "Size = " << sizeof( CRITICAL_SECTION ) << "\n";
         std::cout << "Align = " << (int) & ( (Alignof *) 0 )->b << "\n";
}

on my x86 machine I get this:
Size = 24
Align = 4

In your library header file put this:

// make this one 32 bytes if you want to have some head room
const unsigned g_win32_critical_section_size_upper_bound = 24;

// pick a type that has an alignment of 4
typedef int t_win32_critical_section_type_align;

// define a "context" which has the size and alignment of a
// CRITICAL_SECTION

struct SystemMutexContextType
{
     t_win32_critical_section_type_align data[
       ( g_win32_critical_section_size_upper_bound - 1
    + sizeof( t_win32_critical_section_type_align )
       ) / sizeof( t_win32_critical_section_type_align )
     ];

     // you can add more stuff here.
};
// all SystemMutexContextType is a struct that contains an array
// that has at least the size of
// g_win32_critical_section_size_upper_bound

// Define the mutex class - lifted from austria C++ code

// THIS goes in your header file ...

// ======== Mutex =====================================================
/**
  * Mutex is a "mutual exclusion" lock. The goal here is that the
  * Mutex is able to be constructed anywhere, hopefully not requiring
  * an allocation of memory.
  */

class Mutex
{

     public:

     // ======== Mutex =================================================
     /**
      * Mutex constructor initializes the m_mutex_context for this
      * object based on the mutex type.
      *
      */

     Mutex();

     // ======== Mutex =================================================
     /**
      * Mutex destructor.
      *
      */

     virtual ~Mutex();

     // ======== Lock ==================================================
     /**
      * Lock will wait indefinitely to attain the lock.
      *
      * @return nothing
      */

     void Lock();

     // ======== TryLock ===============================================
     /**
      * TryLock will attempt to attain the mutex. If mutex is currently
      * taken, TryLock will return immediatly with a "false" return value,
      * otherwise it will attain the lock and return true.
      *
      * @return true when lock is successfully attained, false otherwise.
      */

     bool TryLock();

     // ======== Unlock ================================================
     /**
      * Unlock will release the mutex. It is an error to call unlock
      * if the calling thread has not previously locked the mutex.
      *
      * @return nothing
      */

     void Unlock();

     /**
      * MutexContext is opaque but it occupies the same size as the
      * implementation dependant (posix) mutex.
      */

     struct MutexContext
     {
         SystemMutexContextType m_data;
     };

     private:

     /**
      * m_mutex_context is a system dependant context variable.
      */

     MutexContext m_mutex_context;

     // copy constructor and assignment operator are private and
     // unimplemented. It is illegal to copy a mutex.
     Mutex( const Mutex & );
     Mutex & operator= ( const Mutex & );
};

//

mutex.cpp
// Then you need to implement your Mutex ... in this case you need to
#include <windows.h>

Mutex::Mutex( Mutex::MutexType i_type )
{
     // at the beginning of all the member functions
     // do this
     CRITICAL_SECTION l_crit_sect =
        reinterpret_cast< CRITICAL_SECTION * >(
      & m_mutex_context.m_data[0]
        );

     // PIMPL construct
     ::InitializeCriticalSection( l_crit_sect );
};

Mutex::~Mutex()
{
     // at the beginning of all the member functions
     // do this
     CRITICAL_SECTION l_crit_sect =
        reinterpret_cast< CRITICAL_SECTION * >(
      & m_mutex_context.m_data[0]
        );

     ::DeleteCriticalSection( l_crit_sect );
}

void Mutex::Lock()
{
     // at the beginning of all the member functions
     // do this
     CRITICAL_SECTION l_crit_sect =
        reinterpret_cast< CRITICAL_SECTION * >(
      & m_mutex_context.m_data[0]
        );

     ::EnterCriticalSection(l_crit_sect);
}

bool Mutex::TryLock()
{
     // at the beginning of all the member functions
     // do this
     CRITICAL_SECTION l_crit_sect =
        reinterpret_cast< CRITICAL_SECTION * >(
      & m_mutex_context.m_data[0]
        );

     bool retval = (TRUE == ::TryEnterCriticalSection(l_crit_sect));
     return retval;
}

.... I didn't compile or test this ... use at your own peril....

I used exactly this pattern for posix mutexes and it has worked
flawlessly. For windows, the developer who pulled my condition variable
friendly home spun implementation of mutex, decided not to use the PIMPL
idiom for the win32 implementation in the alpha.

It is inevitable that you're dealing with a function call overhead,
there is little you can do about it if you don't want to include
windows.h (which is probably the most polluted header in existance).

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]