BLI_task: Add pooled threaded index range iterator, Take II.

This code allows to push a set of different operations all based on
iterations over a range of indices, and then process them all at once
over multiple threads.

This commit also adds unit tests for both old un-pooled, and new pooled
task_parallel_range family of functions, as well as some basic
performances tests.

This is mainly interesting for relatively low amount of individual
tasks, as expected.

E.g. performance tests on a 32 threads machine, for a set of 10
different tasks, shows following improvements when using pooled version
instead of ten sequential calls to BLI_task_parallel_range():

| Num Items | Sequential | Pooled  | Speed-up |
| --------- | ---------- | ------- | -------- |
|       10K |     365 us |  138 us |   2.5  x |
|      100K |     877 us |  530 us |   1.66 x |
|     1000K |    5521 us | 4625 us |   1.25 x |

Differential Revision: https://developer.blender.org/D6189

Note: Compared to previous commit yesterday, this reworks atomic handling in
parallel iter code, and fixes a dummy double-free bug.

Now we should only use the two critical values for synchronization from
atomic calls results, which is the proper way to do things.

Reading a value after an atomic operation does not guarantee you will
get the latest value in all cases (especially on Windows release builds
it seems).

1 files changed, 16 insertions, 3 deletions

diff --git a/source/blender/blenlib/BLI_task.h b/source/blender/blenlib/BLI_task.h
index 7ef5e518cc8..05c3d43a0de 100644
--- a/source/blender/blenlib/BLI_task.h
+++ b/source/blender/blenlib/BLI_task.h
@@ -196,9 +196,22 @@ void BLI_task_parallel_range(const int start,
                              const int stop,
                              void *userdata,
                              TaskParallelRangeFunc func,
-                             const TaskParallelSettings *settings);
-
-/* This data is shared between all tasks, its access needs thread lock or similar protection. */
+                             TaskParallelSettings *settings);
+
+typedef struct TaskParallelRangePool TaskParallelRangePool;
+struct TaskParallelRangePool *BLI_task_parallel_range_pool_init(
+    const struct TaskParallelSettings *settings);
+void BLI_task_parallel_range_pool_push(struct TaskParallelRangePool *range_pool,
+                                       const int start,
+                                       const int stop,
+                                       void *userdata,
+                                       TaskParallelRangeFunc func,
+                                       const struct TaskParallelSettings *settings);
+void BLI_task_parallel_range_pool_work_and_wait(struct TaskParallelRangePool *range_pool);
+void BLI_task_parallel_range_pool_free(struct TaskParallelRangePool *range_pool);
+
+/* This data is shared between all tasks, its access needs thread lock or similar protection.
+ */
 typedef struct TaskParallelIteratorStateShared {
   /* Maximum amount of items to acquire at once. */
   int chunk_size;