Fidelity Pointwise uses multi-threading to improve performance in a few key areas: GUI, Examine, and the
Unstructured Domain Solver. Although not listed here, there are additional tasks in Fidelity Pointwise
that benefit from parallelism for at least some of their operation. For more information on the
use of multi-threading in Fidelity Pointwise, see the
How I Thread (Parallelism & Pointwise) blog post.
In order to ensure that the user interface remains robust and responsive, Fidelity Pointwise separates
the graphical user interface (GUI) into its own thread. The GUI thread handles all GUI
interaction and ensures that visual feedback can continue while the main thread (also known as the Core) executes
commands. Communication between the GUI and Core threads is handled through the
Fidelity Pointwise uses separate threads for the GUI and the Core which communicate with one another
through the Glyph scripting language.
This separation of GUI and computational tasks is what allows the
Messages window and
Status Bar to be updated and the
Display window to remain responsive to view
manipulations even during computationally expensive commands such as unstructured block initialization.
Multi-threading is also used to improve performance of render data generation. If multiple objects
need render data computed, each object is assigned to a thread so that multiple objects can be
processed simultaneously. This performance improvement is the most beneficial when render data is generated upon loading
a large file with many objects.
For many of the Examine Functions, the metric for any
one cell (or vertex for vertex-centered metrics) in the mesh can be computed independently from any
other cell in the mesh. These types of algorithms lend themselves very easily to multi-threading
since it is straightforward to split up the problem and it requires little to no
communication between threads.
Fidelity Pointwise applies multi-threading to the Examine metrics by distributing the cells (or vertices
for vertex-centered metrics)
among several threads and having each thread compute the metric for its portion of the cells.
In this case
the cells are evenly distributed among the threads and each
thread computes the metric for its portion of the mesh. Then the main thread brings together the
partial results from all of the threads to form the final result.
Unstructured Domain Initialization
Since initializing or refining a single unstructured domain can occur largely independently of
other domains, Fidelity Pointwise also applies multi-threading when multiple unstructured
domains are being updated simultaneously. Both the
Unstructured Domain Solver
and Domains On Database Entities
benefit from this multi-threading.
Similar to how multi-threading was applied to the Examine functions (described in the
Examine Metrics section above), in this case, the list of domains is divided among
the threads and each thread is responsible for updating its portion of the list.