NAME

       multithreading_support - Multithreading Support in Coin The support in Coin for using multiple threads in
       application programs and the Coin library itself, consists of two main features:

       • Coin  provides  platform-independent  thread-handling  abstraction  classes. These are classes that the
         application programmer can freely use in her application code  to  start  new  threads,  control  their
         execution, work with mutexes and do other tasks related to handling multiple threads.
       The classes in question are SbThread, SbMutex, SbStorage, SbBarrier, SbCondVar, SbFifo, SbThreadAutoLock,
       SbRWMutex, and SbTypedStorage. See their respective documentation for the detailed information.
       The  classes  fully hides the system-specific implementation, which is either done on top of native Win32
       (if on Microsoft Windows), or over POSIX threads (on UNIX and UNIX-like systems).
       • The other aspect of our multi-threading support is that  Coin  can  be  specially  configured  so  that
         rendering  traversals  of  the scene graph are done in a thread-safe manner. This means e.g. that it is
         possible to have Coin render the scene in parallel on multiple CPUs for multiple  rendering  pipes,  to
         better take advantage of such high-end systems (like CAVE environments, for instance).
       Thread-safe  render traversals are off by default, because there is a small overhead involved which would
       make rendering (very) slightly slower on single-threaded invocations.
       To get a Coin library built with thread-safe rendering, one must actively re-configure Coin and  build  a
       special,  local  version.  For  configure-based  builds  (UNIX  and  UNIX-like systems, or with Cygwin on
       Microsoft Windows) this is done with the option '--enable-threadsafe' to Autoconf  configure.  To  change
       the  configuration  and  re-build  with Visual Studio, you will need to change the preprocessor directive
       COIN_THREADSAFE to defined in the file src/setup.h located in the same folder as you found your  solution
       file.
       There are some restrictions and other issues which it is important to be aware of:
       • We  do  not  yet  provide  any support for binding the multi-threaded rendering support into the SoQt /
         SoWin / etc GUI bindings, and neither do we provide bindings against any specific library that  handles
         multi-pipe  rendering.  This  means the application programmer will have to possess some expertise, and
         put in some effort, to be able to utilize multi-pipe rendering with Coin.
       • Rendering traversals is currently the only operation which we publicly support to be thread-safe. There
         are other aspects of Coin that we know are thread-safe, like most other action traversals  beside  just
         rendering, but we make no guarantees in this regard.
       • Be  careful  about  using  a  separate  thread for changing Coin structures versus what is used for the
         application's GUI event thread.
       We are aware of at least issues with Qt3 (and thereby SoQt), where you should not modify the scene  graph
       in  any  way  in a thread separate from the main Qt thread. This because it will trigger operations where
       Qt3 is not thread-safe. For Qt4, we have not been aware of such problems.
       Since:
           Coin 2.0
Version 4.0.0a                                   Wed Feb 26 2014                       multithreading_support(3)