Login or Register to Ask a Question and Join Our Community

Linux and UNIX Man Pages

Linux & Unix Commands - Search Man Pages

multithreading_support(3) [debian man page]

multithreading_support(3)					       Coin						 multithreading_support(3)

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:

       o 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).
       o 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. For how to change the configuration and re-build with Visual Studio, get in touch with us at 'coin-
       support@coin3d.org'.
       There are some restrictions and other issues which it is important to be aware of:
       o 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.
       o 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.
       o 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 Qt (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 Qt is not thread-safe.
       Since:
	   Coin 2.0
Version 3.1.3							  Wed May 23 2012					 multithreading_support(3)

Check Out this Related Man Page

Portable Threads Abstraction Classes(3)                                Coin                                Portable Threads Abstraction Classes(3)

NAME

       Portable Threads Abstraction Classes -

   Classes
       class SbBarrier
           The SbBarrier class implements the 'barrier' multi-thread synchronization technique.

       A barrier is a synchronization mechanism that is used for blocking threads as they enter the barrier until a given number of threads are
       blocked, at which point all the threads are released again. "
   class SbCondVar
       A class for synchronizing access to global variables.

       Condition variables are used to protect global variables in an environment where multiple threads are running concurrently. "
   class SbFifo
       A class for managing a pointer first-in, first-out queue.
   class SbMutex
       A basic class for managing a mutex.

       This class provides a portable framework around the mutex interface of the underlying native thread-handling toolkit. "
   class SbThreadAutoLock
       Simple convenience class for locking access to a function.

       This class provides a simple convenience mechanism for automatically locking access to a function that is not re-entrant. "
   class SbRWMutex
   class SbStorage
       The SbStorage class manages thread-local memory.

       This class manages thread-local memory. When different threads access the memory an SbStorage object manages, they will receive different
       memory blocks back. "
   class SbTypedStorage< Type >
       The SbTypedStorage class manages generic thread-local memory.

       This class manages thread-local memory. When different threads access the memory an SbTypedStorage object manages, they will receive
       different memory blocks back. "
   class SbThread
       A class for managing threads.

       This class provides a portable framework around the tasks of instantiating, starting, stopping and joining threads. "

Detailed Description
       Coin implements a set of abstractions over the native threads data types that can be portably used across all the platforms Coin has been
       ported to.

Author
       Generated automatically by Doxygen for Coin from the source code.

Version 3.1.3                                                     Wed May 23 2012                          Portable Threads Abstraction Classes(3)
Man Page