OSD

Set of Operating System Dependent (OSD) tools.

Simple tool for code parallelization.
OSD_Parallel class provides simple interface for parallel processing of tasks that can be formulated in terms of "for" or "foreach" loops.
To use this tool it is necessary to:

• organize the data to be processed in a collection accessible by iteration (usually array or vector);
• implement a functor class providing operator () accepting iterator (or index in array) that does the job;
• call either For() or ForEach() providing begin and end iterators and a functor object.
  Iterators should satisfy requirements of STL forward iterator. Functor

classFunctor { public: voidoperator()([processinginstance])const { //... } };

The operator () should be implemented in a thread-safe way so that the same functor object can process different data items in parallel threads.
Iteration by index (For) is expected to be more efficient than using iterators (ForEach).
Implementation uses TBB if OCCT is built with support of TBB; otherwise it uses ad-hoc parallelization tool. In general, if TBB is available, it is more efficient to use it directly instead of using OSD_Parallel.

A simple platform-intependent interface to execute and control threads.

Class defining a thread pool for executing algorithms in multi-threaded mode. Thread pool allocates requested amount of threads and keep them alive (in sleep mode when unused) during thread pool lifetime. The same pool can be used by multiple consumers, including nested multi-threading algorithms and concurrent threads:

• Thread pool can be used either by multi-threaded algorithm by creating OSD_ThreadPool::Launcher. The functor performing a job takes two parameters - Thread Index and Data Index: void operator(int theThreadIndex, int theDataIndex){} Multi-threaded algorithm may rely on Thread Index for allocating thread-local variables in array form, since the Thread Index is guaranteed to be within range OSD_ThreadPool::Lower() and OSD_ThreadPool::Upper().
• Default thread pool (OSD_ThreadPool::DefaultPool()) can be used in general case, but application may prefer creating a dedicated pool for better control.
• Default thread pool allocates the amount of threads considering concurrency level of the system (amount of logical processors). This can be overridden during OSD_ThreadPool construction or by calling OSD_ThreadPool::Init() (the pool should not be used!).
• OSD_ThreadPool::Launcher reserves specific amount of threads from the pool for executing multi-threaded Job. Normally, single Launcher instance will occupy all threads available in thread pool, so that nested multi-threaded algorithms (within the same thread) and concurrent threads trying to use the same thread pool will run sequentially.
  This behavior is affected by OSD_ThreadPool::NbDefaultThreadsToLaunch() parameter and Launcher constructor, so that single Launcher instance will occupy not all threads in the pool allowing other threads to be used concurrently.
• OSD_ThreadPool::Launcher locks thread one-by-one from thread pool in a thread-safe way.
• Each working thread catches exceptions occurred during job execution, and Launcher will throw Standard_Failure in a caller thread on completed execution.