Refactor: Draw Cache: use 'BLI_task_parallel_range'

This is an adaptation of {D11488}.

A disadvantage of manually setting the iter ranges per thread is that
we don't know how many threads are running in the background and so we
don't know how to best distribute the ranges.

To solve this limitation we can use `parallel_reduce` and thus let the
driver choose the best distribution of ranges among the threads.

This proved to be especially beneficial for computers with few cores.

**Benchmarking:**
Here's the result on an 4-core laptop:
||master:|PATCH:
|---|---|---|
|large_mesh_editing:|Average: 5.203638 FPS|Average: 5.398925 FPS
||rdata 15ms iter 43ms (frame 193ms)|rdata 14ms iter 36ms (frame 187ms)

Here's the result on an 8-core PC:
||master:|PATCH:
|---|---|---|
|large_mesh_editing:|Average: 15.267482 FPS|Average: 15.906881 FPS
||rdata 9ms iter 28ms (frame 65ms)|rdata 9ms iter 25ms (frame 63ms)
|large_mesh_editing_ledge: |Average: 15.145966 FPS|Average: 15.520474 FPS
||rdata 9ms iter 29ms (frame 65ms)|rdata 9ms iter 25ms (frame 64ms)
|looptris_test:|Average: 4.001917 FPS|Average: 4.061105 FPS
||rdata 12ms iter 90ms (frame 236ms)|rdata 12ms iter 87ms (frame 230ms)
|subdiv_mesh_cage_and_final:|Average: 1.917769 FPS|Average: 1.971790 FPS
||rdata 7ms iter 37ms (frame 261ms)|rdata 7ms iter 31ms (frame 258ms)
||rdata 7ms iter 38ms (frame 252ms)|rdata 7ms iter 33ms (frame 249ms)
|subdiv_mesh_final_only:|Average: 6.387240 FPS|Average: 6.591251 FPS
||rdata 3ms iter 25ms (frame 151ms)|rdata 3ms iter 16ms (frame 145ms)
|subdiv_mesh_final_only_ledge:|Average: 6.247393 FPS|Average: 6.596024 FPS
||rdata 3ms iter 26ms (frame 158ms)|rdata 3ms iter 16ms (frame 148ms)

**Notes:**
- The improvement can only be noticed if all extracts are multithreaded.
- This patch touches different areas of the code, so it can be split into another patch if the idea is accepted.

These screenshots show how threads behave in a quadcore:
Master:
{F10164664}
Patch:
{F10164666}

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

2 files changed, 10 insertions, 25 deletions

diff --git a/source/blender/gpu/GPU_index_buffer.h b/source/blender/gpu/GPU_index_buffer.h
index 03d60c60b4b..48f80e321b6 100644
--- a/source/blender/gpu/GPU_index_buffer.h
+++ b/source/blender/gpu/GPU_index_buffer.h
@@ -44,7 +44,6 @@ typedef struct GPUIndexBufBuilder {
   uint index_max;
   GPUPrimType prim_type;
   uint32_t *data;
-  const struct GPUIndexBufBuilder *parent;
 } GPUIndexBufBuilder;
 
 /* supports all primitive types. */
@@ -55,17 +54,12 @@ void GPU_indexbuf_init(GPUIndexBufBuilder *, GPUPrimType, uint prim_len, uint ve
 GPUIndexBuf *GPU_indexbuf_build_on_device(uint index_len);
 
 /*
- * Thread safe sub builders.
+ * Thread safe.
  *
- * Note that `GPU_indexbuf_subbuilder_init` and `GPU_indexbuf_subbuilder_finish` are not thread
- * safe and should be called when no threads are active. The pattern is to create a subbuilder for
- * each thread/task. Each thread/task would update their sub builder. When all thread are completed
- * the sub-builders can then be merged back to the parent builder.
+ * Function inspired by the reduction directives of multithread work APIs..
  */
-void GPU_indexbuf_subbuilder_init(const GPUIndexBufBuilder *parent_builder,
-                                  GPUIndexBufBuilder *sub_builder);
-void GPU_indexbuf_subbuilder_finish(GPUIndexBufBuilder *builder,
-                                    const GPUIndexBufBuilder *parent_builder);
+void GPU_indexbuf_join_copies(GPUIndexBufBuilder *builder,
+                              const GPUIndexBufBuilder *parent_builder);
 
 void GPU_indexbuf_add_generic_vert(GPUIndexBufBuilder *, uint v);
 void GPU_indexbuf_add_primitive_restart(GPUIndexBufBuilder *);
diff --git a/source/blender/gpu/intern/gpu_index_buffer.cc b/source/blender/gpu/intern/gpu_index_buffer.cc
index 3cdcaac5544..993bcdf743b 100644
--- a/source/blender/gpu/intern/gpu_index_buffer.cc
+++ b/source/blender/gpu/intern/gpu_index_buffer.cc
@@ -57,7 +57,6 @@ void GPU_indexbuf_init_ex(GPUIndexBufBuilder *builder,
   builder->index_max = 0;
   builder->prim_type = prim_type;
   builder->data = (uint *)MEM_callocN(builder->max_index_len * sizeof(uint), "GPUIndexBuf data");
-  builder->parent = nullptr;
 }
 
 void GPU_indexbuf_init(GPUIndexBufBuilder *builder,
@@ -80,21 +79,13 @@ GPUIndexBuf *GPU_indexbuf_build_on_device(uint index_len)
   return elem_;
 }
 
-void GPU_indexbuf_subbuilder_init(const GPUIndexBufBuilder *parent_builder,
-                                  GPUIndexBufBuilder *sub_builder)
+void GPU_indexbuf_join_copies(GPUIndexBufBuilder *builder_to,
+                              const GPUIndexBufBuilder *builder_from)
 {
-  BLI_assert(parent_builder->parent == nullptr);
-  memcpy(sub_builder, parent_builder, sizeof(GPUIndexBufBuilder));
-  sub_builder->parent = parent_builder;
-}
-
-void GPU_indexbuf_subbuilder_finish(GPUIndexBufBuilder *parent_builder,
-                                    const GPUIndexBufBuilder *sub_builder)
-{
-  BLI_assert(parent_builder == sub_builder->parent);
-  parent_builder->index_len = max_uu(parent_builder->index_len, sub_builder->index_len);
-  parent_builder->index_min = min_uu(parent_builder->index_min, sub_builder->index_min);
-  parent_builder->index_max = max_uu(parent_builder->index_max, sub_builder->index_max);
+  BLI_assert(builder_to->data == builder_from->data);
+  builder_to->index_len = max_uu(builder_to->index_len, builder_from->index_len);
+  builder_to->index_min = min_uu(builder_to->index_min, builder_from->index_min);
+  builder_to->index_max = max_uu(builder_to->index_max, builder_from->index_max);
 }
 
 void GPU_indexbuf_add_generic_vert(GPUIndexBufBuilder *builder, uint v)