Sculpt: use TBB instead of BLI_task for multithreading

This solves performance issues on some computers where there is significant
threading overhead. Rather than doing the complicated work of optimizing our
own task scheduler, use TBB which appears to work well. The downside is that
we have another thread pool, but it is already there when using OpenVDB voxel
remesh.

For future releases we can switch to using TBB to replace our task scheduler
implementation entirely, and use the same thread pool for BLI_task, Cycles,
Mantaflow, etc.

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

1 files changed, 166 insertions, 188 deletions

diff --git a/source/blender/editors/sculpt_paint/sculpt.c b/source/blender/editors/sculpt_paint/sculpt.c
index 2d329ff3bca..2bde42c739c 100644
--- a/source/blender/editors/sculpt_paint/sculpt.c
+++ b/source/blender/editors/sculpt_paint/sculpt.c
@@ -423,17 +423,19 @@ static void do_nearest_vertex_get_task_cb(void *__restrict userdata,
   BKE_pbvh_vertex_iter_end;
 }
 
-static void nearest_vertex_get_finalize(void *__restrict userdata, void *__restrict tls)
+static void nearest_vertex_get_reduce(const void *__restrict UNUSED(userdata),
+                                      void *__restrict chunk_join,
+                                      void *__restrict chunk)
 {
-  SculptThreadedTaskData *data = userdata;
-  NearestVertexTLSData *nvtd = tls;
-  if (data->nearest_vertex_index == -1) {
-    data->nearest_vertex_index = nvtd->nearest_vertex_index;
-    data->nearest_vertex_distance_squared = nvtd->nearest_vertex_distance_squared;
+  NearestVertexTLSData *join = chunk_join;
+  NearestVertexTLSData *nvtd = chunk;
+  if (join->nearest_vertex_index == -1) {
+    join->nearest_vertex_index = nvtd->nearest_vertex_index;
+    join->nearest_vertex_distance_squared = nvtd->nearest_vertex_distance_squared;
   }
-  else if (nvtd->nearest_vertex_distance_squared < data->nearest_vertex_distance_squared) {
-    data->nearest_vertex_index = nvtd->nearest_vertex_index;
-    data->nearest_vertex_distance_squared = nvtd->nearest_vertex_distance_squared;
+  else if (nvtd->nearest_vertex_distance_squared < join->nearest_vertex_distance_squared) {
+    join->nearest_vertex_index = nvtd->nearest_vertex_index;
+    join->nearest_vertex_distance_squared = nvtd->nearest_vertex_distance_squared;
   }
 }
 
@@ -460,25 +462,23 @@ static int sculpt_nearest_vertex_get(
       .ob = ob,
       .nodes = nodes,
       .max_distance_squared = max_distance * max_distance,
-      .nearest_vertex_index = -1,
   };
 
   copy_v3_v3(task_data.nearest_vertex_search_co, co);
-  task_data.nearest_vertex_distance_squared = FLT_MAX;
   NearestVertexTLSData nvtd;
   nvtd.nearest_vertex_index = -1;
   nvtd.nearest_vertex_distance_squared = FLT_MAX;
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  settings.func_finalize = nearest_vertex_get_finalize;
+  settings.func_reduce = nearest_vertex_get_reduce;
   settings.userdata_chunk = &nvtd;
   settings.userdata_chunk_size = sizeof(NearestVertexTLSData);
-  BLI_task_parallel_range(0, totnode, &task_data, do_nearest_vertex_get_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &task_data, do_nearest_vertex_get_task_cb, &settings);
 
   MEM_SAFE_FREE(nodes);
 
-  return task_data.nearest_vertex_index;
+  return nvtd.nearest_vertex_index;
 }
 
 static bool is_symmetry_iteration_valid(char i, char symm)
@@ -937,9 +937,9 @@ static void paint_mesh_restore_co(Sculpt *sd, Object *ob)
       .nodes = nodes,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP) && !ss->bm, totnode);
-  BLI_task_parallel_range(0, totnode, &data, paint_mesh_restore_co_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, paint_mesh_restore_co_task_cb, &settings);
 
   MEM_SAFE_FREE(nodes);
 }
@@ -1413,9 +1413,10 @@ static float calc_symmetry_feather(Sculpt *sd, StrokeCache *cache)
  * \{ */
 
 typedef struct AreaNormalCenterTLSData {
-  float private_co[2][3];
-  float private_no[2][3];
-  int private_count[2];
+  /* 0=towards view, 1=flipped */
+  float area_cos[2][3];
+  float area_nos[2][3];
+  int area_count[2];
 } AreaNormalCenterTLSData;
 
 static void calc_area_normal_and_center_task_cb(void *__restrict userdata,
@@ -1425,8 +1426,8 @@ static void calc_area_normal_and_center_task_cb(void *__restrict userdata,
   SculptThreadedTaskData *data = userdata;
   SculptSession *ss = data->ob->sculpt;
   AreaNormalCenterTLSData *anctd = tls->userdata_chunk;
-  float(*area_nos)[3] = data->area_nos;
-  float(*area_cos)[3] = data->area_cos;
+  const bool use_area_nos = data->use_area_nos;
+  const bool use_area_cos = data->use_area_cos;
 
   PBVHVertexIter vd;
   SculptUndoNode *unode = NULL;
@@ -1479,13 +1480,13 @@ static void calc_area_normal_and_center_task_cb(void *__restrict userdata,
         normal_tri_v3(no, UNPACK3(co_tri));
 
         flip_index = (dot_v3v3(ss->cache->view_normal, no) <= 0.0f);
-        if (area_cos) {
-          add_v3_v3(anctd->private_co[flip_index], co);
+        if (use_area_cos) {
+          add_v3_v3(anctd->area_cos[flip_index], co);
         }
-        if (area_nos) {
-          add_v3_v3(anctd->private_no[flip_index], no);
+        if (use_area_nos) {
+          add_v3_v3(anctd->area_nos[flip_index], no);
         }
-        anctd->private_count[flip_index] += 1;
+        anctd->area_count[flip_index] += 1;
       }
     }
   }
@@ -1531,40 +1532,37 @@ static void calc_area_normal_and_center_task_cb(void *__restrict userdata,
 
         flip_index = (dot_v3v3(ss->cache ? ss->cache->view_normal : ss->cursor_view_normal, no) <=
                       0.0f);
-        if (area_cos) {
-          add_v3_v3(anctd->private_co[flip_index], co);
+        if (use_area_cos) {
+          add_v3_v3(anctd->area_cos[flip_index], co);
         }
-        if (area_nos) {
-          add_v3_v3(anctd->private_no[flip_index], no);
+        if (use_area_nos) {
+          add_v3_v3(anctd->area_nos[flip_index], no);
         }
-        anctd->private_count[flip_index] += 1;
+        anctd->area_count[flip_index] += 1;
       }
     }
     BKE_pbvh_vertex_iter_end;
   }
 }
 
-static void calc_area_normal_and_center_finalize(void *__restrict userdata, void *__restrict tls)
+static void calc_area_normal_and_center_reduce(const void *__restrict UNUSED(userdata),
+                                               void *__restrict chunk_join,
+                                               void *__restrict chunk)
 {
-  SculptThreadedTaskData *data = userdata;
-  AreaNormalCenterTLSData *anctd = tls;
-  float(*area_nos)[3] = data->area_nos;
-  float(*area_cos)[3] = data->area_cos;
+  AreaNormalCenterTLSData *join = chunk_join;
+  AreaNormalCenterTLSData *anctd = chunk;
+
   /* for flatten center */
-  if (area_cos) {
-    add_v3_v3(area_cos[0], anctd->private_co[0]);
-    add_v3_v3(area_cos[1], anctd->private_co[1]);
-  }
+  add_v3_v3(join->area_cos[0], anctd->area_cos[0]);
+  add_v3_v3(join->area_cos[1], anctd->area_cos[1]);
 
   /* for area normal */
-  if (area_nos) {
-    add_v3_v3(area_nos[0], anctd->private_no[0]);
-    add_v3_v3(area_nos[1], anctd->private_no[1]);
-  }
+  add_v3_v3(join->area_nos[0], anctd->area_nos[0]);
+  add_v3_v3(join->area_nos[1], anctd->area_nos[1]);
 
   /* weights */
-  data->count[0] += anctd->private_count[0];
-  data->count[1] += anctd->private_count[1];
+  join->area_count[0] += anctd->area_count[0];
+  join->area_count[1] += anctd->area_count[1];
 }
 
 static void calc_area_center(
@@ -1575,11 +1573,6 @@ static void calc_area_center(
   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
   int n;
 
-  /* 0=towards view, 1=flipped */
-  float area_cos[2][3] = {{0.0f}};
-
-  int count[2] = {0};
-
   /* Intentionally set 'sd' to NULL since we share logic with vertex paint. */
   SculptThreadedTaskData data = {
       .sd = NULL,
@@ -1588,24 +1581,22 @@ static void calc_area_center(
       .nodes = nodes,
       .totnode = totnode,
       .has_bm_orco = has_bm_orco,
-      .area_cos = area_cos,
-      .area_nos = NULL,
-      .count = count,
+      .use_area_cos = true,
   };
 
   AreaNormalCenterTLSData anctd = {{{0}}};
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  settings.func_finalize = calc_area_normal_and_center_finalize;
+  settings.func_reduce = calc_area_normal_and_center_reduce;
   settings.userdata_chunk = &anctd;
   settings.userdata_chunk_size = sizeof(AreaNormalCenterTLSData);
-  BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
 
   /* for flatten center */
-  for (n = 0; n < ARRAY_SIZE(area_cos); n++) {
-    if (count[n] != 0) {
-      mul_v3_v3fl(r_area_co, area_cos[n], 1.0f / count[n]);
+  for (n = 0; n < ARRAY_SIZE(anctd.area_cos); n++) {
+    if (anctd.area_count[n] != 0) {
+      mul_v3_v3fl(r_area_co, anctd.area_cos[n], 1.0f / anctd.area_count[n]);
       break;
     }
   }
@@ -1633,11 +1624,6 @@ bool sculpt_pbvh_calc_area_normal(const Brush *brush,
   SculptSession *ss = ob->sculpt;
   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
 
-  /* 0=towards view, 1=flipped */
-  float area_nos[2][3] = {{0.0f}};
-
-  int count[2] = {0};
-
   /* Intentionally set 'sd' to NULL since this is used for vertex paint too. */
   SculptThreadedTaskData data = {
       .sd = NULL,
@@ -1646,24 +1632,22 @@ bool sculpt_pbvh_calc_area_normal(const Brush *brush,
       .nodes = nodes,
       .totnode = totnode,
       .has_bm_orco = has_bm_orco,
-      .area_cos = NULL,
-      .area_nos = area_nos,
-      .count = count,
+      .use_area_nos = true,
       .any_vertex_sampled = false,
   };
 
   AreaNormalCenterTLSData anctd = {{{0}}};
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, use_threading, totnode);
-  settings.func_finalize = calc_area_normal_and_center_finalize;
+  settings.func_reduce = calc_area_normal_and_center_reduce;
   settings.userdata_chunk = &anctd;
   settings.userdata_chunk_size = sizeof(AreaNormalCenterTLSData);
-  BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
 
   /* for area normal */
-  for (int i = 0; i < ARRAY_SIZE(area_nos); i++) {
-    if (normalize_v3_v3(r_area_no, area_nos[i]) != 0.0f) {
+  for (int i = 0; i < ARRAY_SIZE(anctd.area_nos); i++) {
+    if (normalize_v3_v3(r_area_no, anctd.area_nos[i]) != 0.0f) {
       break;
     }
   }
@@ -1681,12 +1665,6 @@ static void calc_area_normal_and_center(
   const bool has_bm_orco = ss->bm && sculpt_stroke_is_dynamic_topology(ss, brush);
   int n;
 
-  /* 0=towards view, 1=flipped */
-  float area_cos[2][3] = {{0.0f}};
-  float area_nos[2][3] = {{0.0f}};
-
-  int count[2] = {0};
-
   /* Intentionally set 'sd' to NULL since this is used for vertex paint too. */
   SculptThreadedTaskData data = {
       .sd = NULL,
@@ -1695,24 +1673,23 @@ static void calc_area_normal_and_center(
       .nodes = nodes,
       .totnode = totnode,
       .has_bm_orco = has_bm_orco,
-      .area_cos = area_cos,
-      .area_nos = area_nos,
-      .count = count,
+      .use_area_cos = true,
+      .use_area_nos = true,
   };
 
   AreaNormalCenterTLSData anctd = {{{0}}};
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  settings.func_finalize = calc_area_normal_and_center_finalize;
+  settings.func_reduce = calc_area_normal_and_center_reduce;
   settings.userdata_chunk = &anctd;
   settings.userdata_chunk_size = sizeof(AreaNormalCenterTLSData);
-  BLI_task_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, calc_area_normal_and_center_task_cb, &settings);
 
   /* for flatten center */
-  for (n = 0; n < ARRAY_SIZE(area_cos); n++) {
-    if (count[n] != 0) {
-      mul_v3_v3fl(r_area_co, area_cos[n], 1.0f / count[n]);
+  for (n = 0; n < ARRAY_SIZE(anctd.area_cos); n++) {
+    if (anctd.area_count[n] != 0) {
+      mul_v3_v3fl(r_area_co, anctd.area_cos[n], 1.0f / anctd.area_count[n]);
       break;
     }
   }
@@ -1721,8 +1698,8 @@ static void calc_area_normal_and_center(
   }
 
   /* for area normal */
-  for (n = 0; n < ARRAY_SIZE(area_nos); n++) {
-    if (normalize_v3_v3(r_area_no, area_nos[n]) != 0.0f) {
+  for (n = 0; n < ARRAY_SIZE(anctd.area_nos); n++) {
+    if (normalize_v3_v3(r_area_no, anctd.area_nos[n]) != 0.0f) {
       break;
     }
   }
@@ -2824,7 +2801,7 @@ static void smooth(Sculpt *sd,
         .strength = strength,
     };
 
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
 
     switch (type) {
@@ -2842,16 +2819,16 @@ static void smooth(Sculpt *sd,
 
         settings.userdata_chunk = data_chunk;
         settings.userdata_chunk_size = size;
-        BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_multires_task_cb_ex, &settings);
+        BKE_pbvh_parallel_range(0, totnode, &data, do_smooth_brush_multires_task_cb_ex, &settings);
 
         MEM_freeN(data_chunk);
         break;
       }
       case PBVH_FACES:
-        BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_mesh_task_cb_ex, &settings);
+        BKE_pbvh_parallel_range(0, totnode, &data, do_smooth_brush_mesh_task_cb_ex, &settings);
         break;
       case PBVH_BMESH:
-        BLI_task_parallel_range(0, totnode, &data, do_smooth_brush_bmesh_task_cb_ex, &settings);
+        BKE_pbvh_parallel_range(0, totnode, &data, do_smooth_brush_bmesh_task_cb_ex, &settings);
         break;
     }
 
@@ -2883,10 +2860,10 @@ static void bmesh_topology_rake(
         .nodes = nodes,
         .strength = factor,
     };
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
 
-    BLI_task_parallel_range(0, totnode, &data, do_topology_rake_bmesh_task_cb_ex, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &data, do_topology_rake_bmesh_task_cb_ex, &settings);
   }
 }
 
@@ -2940,9 +2917,9 @@ static void do_mask_brush_draw(Sculpt *sd, Object *ob, PBVHNode **nodes, int tot
       .nodes = nodes,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_mask_brush_draw_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_mask_brush_draw_task_cb_ex, &settings);
 }
 
 static void do_mask_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
@@ -3027,9 +3004,9 @@ static void do_draw_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
       .offset = offset,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_draw_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_draw_brush_task_cb_ex, &settings);
 }
 
 static void do_draw_sharp_brush_task_cb_ex(void *__restrict userdata,
@@ -3103,9 +3080,9 @@ static void do_draw_sharp_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int to
       .offset = offset,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_draw_sharp_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_draw_sharp_brush_task_cb_ex, &settings);
 }
 
 /**
@@ -3219,9 +3196,9 @@ static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
       .flippedbstrength = flippedbstrength,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_crease_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_crease_brush_task_cb_ex, &settings);
 }
 
 static void do_pinch_brush_task_cb_ex(void *__restrict userdata,
@@ -3281,9 +3258,9 @@ static void do_pinch_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
       .nodes = nodes,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_pinch_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_pinch_brush_task_cb_ex, &settings);
 }
 
 static void do_grab_brush_task_cb_ex(void *__restrict userdata,
@@ -3353,9 +3330,9 @@ static void do_grab_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
       .grab_delta = grab_delta,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_grab_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_grab_brush_task_cb_ex, &settings);
 }
 
 /* Regularized Kelvinlets: Sculpting Brushes based on Fundamental Solutions of Elasticity
@@ -3606,9 +3583,9 @@ static void do_elastic_deform_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, in
       .grab_delta = grab_delta,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_elastic_deform_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_elastic_deform_brush_task_cb_ex, &settings);
 }
 
 static void do_pose_brush_task_cb_ex(void *__restrict userdata,
@@ -3695,14 +3672,14 @@ static void do_pose_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
       .transform_trans_inv = transform_trans_inv,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_pose_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_pose_brush_task_cb_ex, &settings);
 }
 
 typedef struct PoseGrowFactorTLSData {
   float pos_avg[3];
-  int tot_pos_avg;
+  int pos_count;
 } PoseGrowFactorTLSData;
 
 static void pose_brush_grow_factor_task_cb_ex(void *__restrict userdata,
@@ -3731,7 +3708,7 @@ static void pose_brush_grow_factor_task_cb_ex(void *__restrict userdata,
       data->pose_factor[vd.index] = max;
       if (check_vertex_pivot_symmetry(vd.co, active_co, symm)) {
         add_v3_v3(gftd->pos_avg, vd.co);
-        gftd->tot_pos_avg++;
+        gftd->pos_count++;
       }
     }
   }
@@ -3739,12 +3716,14 @@ static void pose_brush_grow_factor_task_cb_ex(void *__restrict userdata,
   BKE_pbvh_vertex_iter_end;
 }
 
-static void pose_brush_grow_factor_finalize(void *__restrict userdata, void *__restrict tls)
+static void pose_brush_grow_factor_reduce(const void *__restrict UNUSED(userdata),
+                                          void *__restrict chunk_join,
+                                          void *__restrict chunk)
 {
-  SculptThreadedTaskData *data = userdata;
-  PoseGrowFactorTLSData *gftd = tls;
-  add_v3_v3(data->tot_pos_avg, gftd->pos_avg);
-  data->tot_pos_count += gftd->tot_pos_avg;
+  PoseGrowFactorTLSData *join = chunk_join;
+  PoseGrowFactorTLSData *gftd = chunk;
+  add_v3_v3(join->pos_avg, gftd->pos_avg);
+  join->pos_count += gftd->pos_count;
 }
 
 /* Grow the factor until its boundary is near to the offset pose origin */
@@ -3763,12 +3742,12 @@ static void sculpt_pose_grow_pose_factor(
       .totnode = totnode,
       .pose_factor = pose_factor,
   };
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   PoseGrowFactorTLSData gftd;
-  gftd.tot_pos_avg = 0;
+  gftd.pos_count = 0;
   zero_v3(gftd.pos_avg);
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  settings.func_finalize = pose_brush_grow_factor_finalize;
+  settings.func_reduce = pose_brush_grow_factor_reduce;
   settings.userdata_chunk = &gftd;
   settings.userdata_chunk_size = sizeof(PoseGrowFactorTLSData);
 
@@ -3776,15 +3755,13 @@ static void sculpt_pose_grow_pose_factor(
   float prev_len = FLT_MAX;
   data.prev_mask = MEM_mallocN(sculpt_vertex_count_get(ss) * sizeof(float), "prev mask");
   while (grow_next_iteration) {
-    zero_v3(data.tot_pos_avg);
-    data.tot_pos_count = 0;
     zero_v3(gftd.pos_avg);
-    gftd.tot_pos_avg = 0;
+    gftd.pos_count = 0;
     memcpy(data.prev_mask, pose_factor, sculpt_vertex_count_get(ss) * sizeof(float));
-    BLI_task_parallel_range(0, totnode, &data, pose_brush_grow_factor_task_cb_ex, &settings);
-    if (data.tot_pos_count != 0) {
-      mul_v3_fl(data.tot_pos_avg, 1.0f / (float)data.tot_pos_count);
-      float len = len_v3v3(data.tot_pos_avg, pose_origin);
+    BKE_pbvh_parallel_range(0, totnode, &data, pose_brush_grow_factor_task_cb_ex, &settings);
+    if (gftd.pos_count != 0) {
+      mul_v3_fl(gftd.pos_avg, 1.0f / (float)gftd.pos_count);
+      float len = len_v3v3(gftd.pos_avg, pose_origin);
       if (len < prev_len) {
         prev_len = len;
         grow_next_iteration = true;
@@ -3953,9 +3930,9 @@ static void sculpt_pose_brush_init(
 
   /* Smooth the pose brush factor for cleaner deformation */
   for (int i = 0; i < 4; i++) {
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-    BLI_task_parallel_range(0, totnode, &data, pose_brush_init_task_cb_ex, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &data, pose_brush_init_task_cb_ex, &settings);
   }
 
   MEM_SAFE_FREE(nodes);
@@ -4023,9 +4000,9 @@ static void do_nudge_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
       .cono = cono,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_nudge_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_nudge_brush_task_cb_ex, &settings);
 }
 
 static void do_snake_hook_brush_task_cb_ex(void *__restrict userdata,
@@ -4144,9 +4121,9 @@ static void do_snake_hook_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int to
       .grab_delta = grab_delta,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_snake_hook_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_snake_hook_brush_task_cb_ex, &settings);
 }
 
 static void do_thumb_brush_task_cb_ex(void *__restrict userdata,
@@ -4216,9 +4193,9 @@ static void do_thumb_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
       .cono = cono,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_thumb_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_thumb_brush_task_cb_ex, &settings);
 }
 
 static void do_rotate_brush_task_cb_ex(void *__restrict userdata,
@@ -4289,9 +4266,9 @@ static void do_rotate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
       .angle = angle,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_rotate_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_rotate_brush_task_cb_ex, &settings);
 }
 
 static void do_layer_brush_task_cb_ex(void *__restrict userdata,
@@ -4386,9 +4363,9 @@ static void do_layer_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
   };
   BLI_mutex_init(&data.mutex);
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_layer_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_layer_brush_task_cb_ex, &settings);
 
   BLI_mutex_end(&data.mutex);
 }
@@ -4454,9 +4431,9 @@ static void do_inflate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
       .nodes = nodes,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_inflate_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_inflate_brush_task_cb_ex, &settings);
 }
 
 static void calc_sculpt_plane(
@@ -4663,9 +4640,9 @@ static void do_flatten_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
       .area_co = area_co,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_flatten_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_flatten_brush_task_cb_ex, &settings);
 }
 
 static void do_clay_brush_task_cb_ex(void *__restrict userdata,
@@ -4761,9 +4738,9 @@ static void do_clay_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
       .area_co = area_co,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_clay_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_clay_brush_task_cb_ex, &settings);
 }
 
 static void do_clay_strips_brush_task_cb_ex(void *__restrict userdata,
@@ -4891,9 +4868,9 @@ static void do_clay_strips_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int t
       .mat = mat,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_clay_strips_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_clay_strips_brush_task_cb_ex, &settings);
 }
 
 static void do_fill_brush_task_cb_ex(void *__restrict userdata,
@@ -4984,9 +4961,9 @@ static void do_fill_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
       .area_co = area_co,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_fill_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_fill_brush_task_cb_ex, &settings);
 }
 
 static void do_scrape_brush_task_cb_ex(void *__restrict userdata,
@@ -5076,9 +5053,9 @@ static void do_scrape_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
       .area_co = area_co,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_scrape_brush_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_scrape_brush_task_cb_ex, &settings);
 }
 
 static void do_gravity_task_cb_ex(void *__restrict userdata,
@@ -5145,9 +5122,9 @@ static void do_gravity(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, fl
       .offset = offset,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-  BLI_task_parallel_range(0, totnode, &data, do_gravity_task_cb_ex, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, do_gravity_task_cb_ex, &settings);
 }
 
 void sculpt_vertcos_to_key(Object *ob, KeyBlock *kb, const float (*vertCos)[3])
@@ -5319,9 +5296,9 @@ static void do_brush_action(Sculpt *sd, Object *ob, Brush *brush, UnifiedPaintSe
         .nodes = nodes,
     };
 
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-    BLI_task_parallel_range(0, totnode, &task_data, do_brush_action_task_cb, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &task_data, do_brush_action_task_cb, &settings);
 
     if (sculpt_brush_needs_normal(ss, brush)) {
       update_sculpt_normal(sd, ob, nodes, totnode);
@@ -5539,9 +5516,9 @@ static void sculpt_combine_proxies(Sculpt *sd, Object *ob)
         .nodes = nodes,
     };
 
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-    BLI_task_parallel_range(0, totnode, &data, sculpt_combine_proxies_task_cb, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &data, sculpt_combine_proxies_task_cb, &settings);
   }
 
   MEM_SAFE_FREE(nodes);
@@ -5629,9 +5606,9 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob, bool is_proxy_use
         .vertCos = vertCos,
     };
 
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-    BLI_task_parallel_range(0, totnode, &data, sculpt_flush_stroke_deform_task_cb, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &data, sculpt_flush_stroke_deform_task_cb, &settings);
 
     if (vertCos) {
       sculpt_vertcos_to_key(ob, ss->shapekey_active, vertCos);
@@ -8216,10 +8193,10 @@ static void sculpt_filter_cache_init(Object *ob, Sculpt *sd)
       .nodes = ss->filter_cache->nodes,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(
       &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-  BLI_task_parallel_range(
+  BKE_pbvh_parallel_range(
       0, ss->filter_cache->totnode, &data, filter_cache_init_task_cb, &settings);
 }
 
@@ -8415,10 +8392,10 @@ static int sculpt_mesh_filter_modal(bContext *C, wmOperator *op, const wmEvent *
       .filter_strength = filter_strength,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(
       &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-  BLI_task_parallel_range(0, ss->filter_cache->totnode, &data, mesh_filter_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, ss->filter_cache->totnode, &data, mesh_filter_task_cb, &settings);
 
   if (ss->deform_modifiers_active || ss->shapekey_active) {
     sculpt_flush_stroke_deform(sd, ob, true);
@@ -8692,9 +8669,9 @@ static int sculpt_mask_filter_exec(bContext *C, wmOperator *op)
         .prev_mask = prev_mask,
     };
 
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
-    BLI_task_parallel_range(0, totnode, &data, mask_filter_task_cb, &settings);
+    BKE_pbvh_parallel_range(0, totnode, &data, mask_filter_task_cb, &settings);
 
     if (ELEM(filter_type, MASK_FILTER_GROW, MASK_FILTER_SHRINK)) {
       MEM_freeN(prev_mask);
@@ -8803,13 +8780,14 @@ static void dirty_mask_compute_range_task_cb(void *__restrict userdata,
   BKE_pbvh_vertex_iter_end;
 }
 
-static void dirty_mask_compute_range_finalize(void *__restrict userdata, void *__restrict tls)
+static void dirty_mask_compute_range_reduce(const void *__restrict UNUSED(userdata),
+                                            void *__restrict chunk_join,
+                                            void *__restrict chunk)
 {
-  SculptThreadedTaskData *data = userdata;
-  DirtyMaskRangeData *range = tls;
-
-  data->dirty_mask_min = min_ff(range->min, data->dirty_mask_min);
-  data->dirty_mask_max = max_ff(range->max, data->dirty_mask_max);
+  DirtyMaskRangeData *join = chunk_join;
+  DirtyMaskRangeData *range = chunk;
+  join->min = min_ff(range->min, join->min);
+  join->max = max_ff(range->max, join->max);
 }
 
 static void dirty_mask_apply_task_cb(void *__restrict userdata,
@@ -8880,8 +8858,6 @@ static int sculpt_dirty_mask_exec(bContext *C, wmOperator *op)
       .sd = sd,
       .ob = ob,
       .nodes = nodes,
-      .dirty_mask_min = FLT_MAX,
-      .dirty_mask_max = -FLT_MAX,
       .dirty_mask_dirty_only = RNA_boolean_get(op->ptr, "dirty_only"),
   };
   DirtyMaskRangeData range = {
@@ -8889,15 +8865,17 @@ static int sculpt_dirty_mask_exec(bContext *C, wmOperator *op)
       .max = -FLT_MAX,
   };
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(&settings, (sd->flags & SCULPT_USE_OPENMP), totnode);
 
-  settings.func_finalize = dirty_mask_compute_range_finalize;
+  settings.func_reduce = dirty_mask_compute_range_reduce;
   settings.userdata_chunk = &range;
   settings.userdata_chunk_size = sizeof(DirtyMaskRangeData);
 
-  BLI_task_parallel_range(0, totnode, &data, dirty_mask_compute_range_task_cb, &settings);
-  BLI_task_parallel_range(0, totnode, &data, dirty_mask_apply_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, totnode, &data, dirty_mask_compute_range_task_cb, &settings);
+  data.dirty_mask_min = range.min;
+  data.dirty_mask_max = range.max;
+  BKE_pbvh_parallel_range(0, totnode, &data, dirty_mask_apply_task_cb, &settings);
 
   MEM_SAFE_FREE(nodes);
 
@@ -9056,10 +9034,10 @@ static int sculpt_mask_expand_modal(bContext *C, wmOperator *op, const wmEvent *
     int smooth_iterations = RNA_int_get(op->ptr, "smooth_iterations");
     BKE_sculpt_update_object_for_edit(depsgraph, ob, true, false);
     for (int i = 0; i < smooth_iterations; i++) {
-      TaskParallelSettings settings;
+      PBVHParallelSettings settings;
       BKE_pbvh_parallel_range_settings(
           &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-      BLI_task_parallel_range(0, ss->filter_cache->totnode, &data, mask_filter_task_cb, &settings);
+      BKE_pbvh_parallel_range(0, ss->filter_cache->totnode, &data, mask_filter_task_cb, &settings);
     }
 
     /* Pivot position */
@@ -9125,10 +9103,10 @@ static int sculpt_mask_expand_modal(bContext *C, wmOperator *op, const wmEvent *
         .mask_expand_invert_mask = RNA_boolean_get(op->ptr, "invert"),
         .mask_expand_keep_prev_mask = RNA_boolean_get(op->ptr, "keep_previous_mask"),
     };
-    TaskParallelSettings settings;
+    PBVHParallelSettings settings;
     BKE_pbvh_parallel_range_settings(
         &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-    BLI_task_parallel_range(0, ss->filter_cache->totnode, &data, sculpt_expand_task_cb, &settings);
+    BKE_pbvh_parallel_range(0, ss->filter_cache->totnode, &data, sculpt_expand_task_cb, &settings);
     ss->filter_cache->mask_update_current_it = mask_expand_update_it;
   }
 
@@ -9277,10 +9255,10 @@ static int sculpt_mask_expand_invoke(bContext *C, wmOperator *op, const wmEvent
       .mask_expand_invert_mask = RNA_boolean_get(op->ptr, "invert"),
       .mask_expand_keep_prev_mask = RNA_boolean_get(op->ptr, "keep_previous_mask"),
   };
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(
       &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-  BLI_task_parallel_range(0, ss->filter_cache->totnode, &data, sculpt_expand_task_cb, &settings);
+  BKE_pbvh_parallel_range(0, ss->filter_cache->totnode, &data, sculpt_expand_task_cb, &settings);
 
   const char *status_str = TIP_(
       "Move the mouse to expand the mask from the active vertex. LBM: confirm mask, ESC/RMB: "
@@ -9594,10 +9572,10 @@ void ED_sculpt_update_modal_transform(struct bContext *C)
     mul_m4_m4m4(data.transform_mats[i], pivot_mat, data.transform_mats[i]);
   }
 
-  TaskParallelSettings settings;
+  PBVHParallelSettings settings;
   BKE_pbvh_parallel_range_settings(
       &settings, (sd->flags & SCULPT_USE_OPENMP), ss->filter_cache->totnode);
-  BLI_task_parallel_range(
+  BKE_pbvh_parallel_range(
       0, ss->filter_cache->totnode, &data, sculpt_transform_task_cb, &settings);
 
   if (ss->deform_modifiers_active || ss->shapekey_active) {