🚀 go-pugleaf

In article
<karsten.loeffler-7D396D.15575505102000@newsserv.uni-tuebingen.de>,
Karsten Loeffler <karsten.loeffler@uni-tuebingen.de> wrote:

| Are there plans at Metrowerks to make the MSL - especially the 'MSL 
| C++.PPC.Lib' - MP-safe?
| That means, to use MPAllocateAligned(...) in the operator new() methods.

Yes, there are plans to migrate to use of the MPxxx calls.  Note that this
will break compatibility with earlier Mac OS's, so it will first probably
be offered as an option.

However, there is really no need for you to wait.  In the shipping
configuration, new simply forwards to malloc.  And malloc has a single
entry point into the OS in pool_alloc.mac.c:  __sys_alloc and __sys_free. 
You can simply substitute calls to the MPxxx functions and recompile the C
lib.

You should also #define _MWMT 1 in <ansi_prefix.mac.h> and recompile the C
and C++ libs.  This will protect the pooling that malloc does with calls
to MPEnterCriticalRegion, etc.  This will also put a mutex object in
std::string to protect two threads from simultaneously fooling with a
string's refcount.  This may degrade performance.  An alternative
std::string implementation is available without refcounting (and mutexes)
with #define _MSL_NO_REFCOUNT_STRING in <mslconfig> (requires a C++ lib
recompile).

Please note that the C++ lib is designed to be "level 1" thread safe.  That is:

   1.  It is safe to simultaneously call const and non-const
       methods from different threads to distinct objects. 

   2.  It is safe to simultaneously call const methods, and
       methods otherwise guaranteed not to alter the state
       of an object (or invalidate outstanding references and
       iterators of a container) from different threads to
       the same object. 

   3.  It is not safe for different threads to simultaneously
       access the same object when at least one thread calls
       non-const methods, or methods that invalidate outstanding
       references or iterators to the object. The programmer is
       responsible for using thread synchronization primitives
       (e.g. mutex) to avoid such situations. 

-Howard