blender
/
blender
130
398
Fork 573
Code Issues 6.2k Pull Requests 745 Projects 19 Wiki Activity

Task scheduler: Use single parallel range function with more flexible function 

Now all the fine-tuning is happening using parallel range settings structure,
which avoid passing long lists of arguments, allows extend fine-tuning further,
avoid having lots of various functions which basically does the same thing.
This commit is contained in:
Sergey Sharybin 2018-01-08 11:35:48 +01:00
parent d2708b0f73
commit 4c4a7e84c6
33 changed files with 938 additions and 373 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
source/blender/blenkernel/intern/CCGSubSurf_legacy.c
View File

@ -331,10 +331,15 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
.numEffectedF = numEffectedF
};
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcVertNormals_faces_accumulate_cb,
numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcVertNormals_faces_accumulate_cb,
&settings);
}
/* XXX can I reduce the number of normalisations here? */
for (ptrIdx = 0; ptrIdx < numEffectedV; ptrIdx++) {
@ -360,15 +365,25 @@ static void ccgSubSurf__calcVertNormals(CCGSubSurf *ss,
}
}
BLI_task_parallel_range(0, numEffectedE,
&data,
ccgSubSurf__calcVertNormals_edges_accumulate_cb,
numEffectedE * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedE * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedE,
&data,
ccgSubSurf__calcVertNormals_edges_accumulate_cb,
&settings);
}
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcVertNormals_faces_finalize_cb,
numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcVertNormals_faces_finalize_cb,
&settings);
}
for (ptrIdx = 0; ptrIdx < numEffectedE; ptrIdx++) {
CCGEdge *e = (CCGEdge *) effectedE[ptrIdx];
@ -653,10 +668,15 @@ static void ccgSubSurf__calcSubdivLevel(
.curLvl = curLvl
};
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_interior_faces_edges_midpoints_cb,
numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_interior_faces_edges_midpoints_cb,
&settings);
}
/* exterior edge midpoints
* - old exterior edge points
@ -931,10 +951,15 @@ static void ccgSubSurf__calcSubdivLevel(
}
}
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_interior_faces_edges_centerpoints_shift_cb,
numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_interior_faces_edges_centerpoints_shift_cb,
&settings);
}
/* copy down */
edgeSize = ccg_edgesize(nextLvl);
@ -946,10 +971,15 @@ static void ccgSubSurf__calcSubdivLevel(
VertDataCopy(EDGE_getCo(e, nextLvl, edgeSize - 1), VERT_getCo(e->v1, nextLvl), ss);
}
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_verts_copydata_cb,
numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numEffectedF * edgeSize * edgeSize * 4 >= CCG_OMP_LIMIT);
BLI_task_parallel_range(0, numEffectedF,
&data,
ccgSubSurf__calcSubdivLevel_verts_copydata_cb,
&settings);
}
}
void ccgSubSurf__sync_legacy(CCGSubSurf *ss)

12
source/blender/blenkernel/intern/colortools.c
View File

@ -1387,8 +1387,16 @@ void scopes_update(Scopes *scopes, ImBuf *ibuf, const ColorManagedViewSettings *
ScopesUpdateDataChunk data_chunk = {{0}};
INIT_MINMAX(data_chunk.min, data_chunk.max);
BLI_task_parallel_range_finalize(0, ibuf->y, &data, &data_chunk, sizeof(data_chunk),
scopes_update_cb, scopes_update_finalize, ibuf->y > 256, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (ibuf->y > 256);
settings.userdata_chunk = &data_chunk;
settings.userdata_chunk_size = sizeof(data_chunk);
settings.func_finalize = scopes_update_finalize;
BLI_task_parallel_range(0, ibuf->y,
&data,
scopes_update_cb,
&settings);
/* test for nicer distribution even - non standard, leave it out for a while */
#if 0

299
source/blender/blenkernel/intern/dynamicpaint.c
View File

@ -709,10 +709,19 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
/* calculate canvas dimensions */
/* Important to init correctly our ref grid_bound... */
boundInsert(&grid->grid_bounds, bData->realCoord[bData->s_pos[0]].v);
BLI_task_parallel_range_finalize(
0, sData->total_points, bData, &grid->grid_bounds, sizeof(grid->grid_bounds),
grid_bound_insert_cb_ex, grid_bound_insert_finalize, sData->total_points > 1000, false);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
settings.userdata_chunk = &grid->grid_bounds;
settings.userdata_chunk_size = sizeof(grid->grid_bounds);
settings.func_finalize = grid_bound_insert_finalize;
BLI_task_parallel_range(
0, sData->total_points,
bData,
grid_bound_insert_cb_ex,
&settings);
}
/* get dimensions */
sub_v3_v3v3(dim, grid->grid_bounds.max, grid->grid_bounds.min);
copy_v3_v3(td, dim);
@ -761,9 +770,19 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
if (!error) {
/* calculate number of points withing each cell */
BLI_task_parallel_range_finalize(
0, sData->total_points, bData, grid->s_num, sizeof(*grid->s_num) * grid_cells,
grid_cell_points_cb_ex, grid_cell_points_finalize, sData->total_points > 1000, false);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
settings.userdata_chunk = grid->s_num;
settings.userdata_chunk_size = sizeof(*grid->s_num) * grid_cells;
settings.func_finalize = grid_cell_points_finalize;
BLI_task_parallel_range(
0, sData->total_points,
bData,
grid_cell_points_cb_ex,
&settings);
}
/* calculate grid indexes (not needed for first cell, which is zero). */
for (i = 1; i < grid_cells; i++) {
@ -779,7 +798,15 @@ static void surfaceGenerateGrid(struct DynamicPaintSurface *surface)
}
/* calculate cell bounds */
BLI_task_parallel_range(0, grid->dim[0], bData, grid_cell_bounds_cb, grid_cells > 1000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (grid_cells > 1000);
BLI_task_parallel_range(0, grid->dim[0],
bData,
grid_cell_bounds_cb,
&settings);
}
}
if (temp_s_num)
@ -1550,7 +1577,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
.mloop = mloop, .mlooptri = mlooptri, .mloopuv = mloopuv, .pool = pool,
.scene_color_manage = scene_color_manage
};
BLI_task_parallel_range(0, tottri, &data, dynamic_paint_set_init_color_tex_to_vcol_cb, tottri > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (tottri > 1000);
BLI_task_parallel_range(0, tottri,
&data,
dynamic_paint_set_init_color_tex_to_vcol_cb,
&settings);
BKE_image_pool_free(pool);
}
else if (surface->format == MOD_DPAINT_SURFACE_F_IMAGESEQ) {
@ -1559,8 +1592,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
.mlooptri = mlooptri, .mloopuv = mloopuv,
.scene_color_manage = scene_color_manage
};
BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_set_init_color_tex_to_imseq_cb,
sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_set_init_color_tex_to_imseq_cb,
&settings);
}
}
/* vertex color layer */
@ -1588,8 +1626,13 @@ static void dynamicPaint_setInitialColor(const Scene *scene, DynamicPaintSurface
.surface = surface,
.mlooptri = mlooptri, .mloopcol = col,
};
BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_set_init_color_vcol_to_imseq_cb,
sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_set_init_color_vcol_to_imseq_cb,
&settings);
}
}
}
@ -1707,8 +1750,13 @@ static void dynamicPaint_applySurfaceDisplace(DynamicPaintSurface *surface, Deri
MVert *mvert = result->getVertArray(result);
DynamicPaintModifierApplyData data = {.surface = surface, .mvert = mvert};
BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_apply_surface_displace_cb,
sData->total_points > 10000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 10000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_apply_surface_displace_cb,
&settings);
}
}
@ -1843,9 +1891,16 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
float (*fcolor)[4] = MEM_callocN(sizeof(*fcolor) * sData->total_points, "Temp paint color");
DynamicPaintModifierApplyData data = {.surface = surface, .fcolor = fcolor};
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_apply_surface_vpaint_blend_cb,
sData->total_points > 1000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_apply_surface_vpaint_blend_cb,
&settings);
}
/* paint layer */
MLoopCol *mloopcol = CustomData_get_layer_named(&result->loopData, CD_MLOOPCOL, surface->output_name);
@ -1880,8 +1935,16 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
data.mloopcol_wet = mloopcol_wet;
data.mloopcol_preview = mloopcol_preview;
BLI_task_parallel_range(0, totpoly, &data, dynamic_paint_apply_surface_vpaint_cb,
totpoly > 1000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (totpoly > 1000);
BLI_task_parallel_range(
0, totpoly,
&data,
dynamic_paint_apply_surface_vpaint_cb,
&settings);
}
MEM_freeN(fcolor);
@ -1931,8 +1994,14 @@ static DerivedMesh *dynamicPaint_Modifier_apply(
MVert *mvert = result->getVertArray(result);
DynamicPaintModifierApplyData data = {.surface = surface, .mvert = mvert};
BLI_task_parallel_range(0, sData->total_points, &data, dynamic_paint_apply_surface_wave_cb,
sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_apply_surface_wave_cb,
&settings);
update_normals = true;
}
@ -2772,7 +2841,15 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
.mlooptri = mlooptri, .mloopuv = mloopuv, .mloop = mloop, .tottri = tottri,
.faceBB = faceBB,
};
BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_direct_cb, h > 64 || tottri > 1000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (h > 64 || tottri > 1000);
BLI_task_parallel_range(0, h,
&data,
dynamic_paint_create_uv_surface_direct_cb,
&settings);
}
*progress = 0.04f;
*do_update = true;
@ -2784,7 +2861,15 @@ int dynamicPaint_createUVSurface(Scene *scene, DynamicPaintSurface *surface, flo
* (To avoid seams on uv island edges)
*/
data.active_points = &active_points;
BLI_task_parallel_range(0, h, &data, dynamic_paint_create_uv_surface_neighbor_cb, h > 64);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (h > 64);
BLI_task_parallel_range(0, h,
&data,
dynamic_paint_create_uv_surface_neighbor_cb,
&settings);
}
*progress = 0.06f;
*do_update = true;
@ -3125,13 +3210,29 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
case MOD_DPAINT_SURFACE_T_PAINT:
switch (output_layer) {
case 0:
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_output_surface_image_paint_cb, sData->total_points > 10000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 10000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_output_surface_image_paint_cb,
&settings);
break;
}
case 1:
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_output_surface_image_wetmap_cb, sData->total_points > 10000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 10000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_output_surface_image_wetmap_cb,
&settings);
break;
}
default:
BLI_assert(0);
break;
@ -3140,9 +3241,17 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
case MOD_DPAINT_SURFACE_T_DISPLACE:
switch (output_layer) {
case 0:
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_output_surface_image_displace_cb, sData->total_points > 10000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 10000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_output_surface_image_displace_cb,
&settings);
break;
}
case 1:
break;
default:
@ -3153,9 +3262,17 @@ void dynamicPaint_outputSurfaceImage(DynamicPaintSurface *surface, char *filenam
case MOD_DPAINT_SURFACE_T_WAVE:
switch (output_layer) {
case 0:
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_output_surface_image_wave_cb, sData->total_points > 10000);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 10000);
BLI_task_parallel_range(
0, sData->total_points,
&data,
dynamic_paint_output_surface_image_wave_cb,
&settings);
break;
}
case 1:
break;
default:
@ -3642,7 +3759,13 @@ static void dynamicPaint_brushMeshCalculateVelocity(
.mvert_p = mvert_p, .mvert_c = mvert_c, .obmat = ob->obmat, .prev_obmat = prev_obmat,
.timescale = timescale,
};
BLI_task_parallel_range(0, numOfVerts_c, &data, dynamic_paint_brush_velocity_compute_cb, numOfVerts_c > 10000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numOfVerts_c > 10000);
BLI_task_parallel_range(0, numOfVerts_c,
&data,
dynamic_paint_brush_velocity_compute_cb,
&settings);
dm_p->release(dm_p);
}
@ -4131,9 +4254,13 @@ static int dynamicPaint_paintMesh(DynamicPaintSurface *surface,
.brush_radius = brush_radius, .avg_brushNor = avg_brushNor, .brushVelocity = brushVelocity,
.treeData = &treeData
};
BLI_task_parallel_range_ex(0, grid->s_num[c_index], &data, NULL, 0,
dynamic_paint_paint_mesh_cell_point_cb_ex,
grid->s_num[c_index] > 250, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (grid->s_num[c_index] > 250);
BLI_task_parallel_range(0, grid->s_num[c_index],
&data,
dynamic_paint_paint_mesh_cell_point_cb_ex,
&settings);
}
}
}
@ -4416,9 +4543,13 @@ static int dynamicPaint_paintParticles(DynamicPaintSurface *surface,
.solidradius = solidradius, .timescale = timescale, .c_index = c_index,
.treeData = tree,
};
BLI_task_parallel_range_ex(0, grid->s_num[c_index], &data, NULL, 0,
dynamic_paint_paint_particle_cell_point_cb_ex,
grid->s_num[c_index] > 250, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (grid->s_num[c_index] > 250);
BLI_task_parallel_range(0, grid->s_num[c_index],
&data,
dynamic_paint_paint_particle_cell_point_cb_ex,
&settings);
}
}
BLI_end_threaded_malloc();
@ -4561,9 +4692,13 @@ static int dynamicPaint_paintSinglePoint(
.brush_radius = brush_radius, .brushVelocity = &brushVel,
.pointCoord = pointCoord,
};
BLI_task_parallel_range_ex(0, sData->total_points, &data, NULL, 0,
dynamic_paint_paint_single_point_cb_ex,
sData->total_points > 1000, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_paint_single_point_cb_ex,
&settings);
return 1;
}
@ -4615,8 +4750,13 @@ static void dynamicPaint_prepareAdjacencyData(DynamicPaintSurface *surface, cons
if (!bNeighs)
return;
BLI_task_parallel_range(
0, sData->total_points, sData, dynamic_paint_prepare_adjacency_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
sData,
dynamic_paint_prepare_adjacency_cb,
&settings);
/* calculate average values (single thread).
* Note: tried to put this in threaded callback (using _finalize feature), but gave ~30% slower result! */
@ -4876,8 +5016,13 @@ static int dynamicPaint_prepareEffectStep(
.surface = surface, .scene = scene,
.force = *force, .effectors = effectors,
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_prepare_effect_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_prepare_effect_cb,
&settings);
/* calculate average values (single thread) */
for (int index = 0; index < sData->total_points; index++) {
@ -5140,8 +5285,13 @@ static void dynamicPaint_doEffectStep(
DynamicPaintEffectData data = {
.surface = surface, .prevPoint = prevPoint, .eff_scale = eff_scale,
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_effect_spread_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_effect_spread_cb,
&settings);
}
/*
@ -5156,8 +5306,13 @@ static void dynamicPaint_doEffectStep(
DynamicPaintEffectData data = {
.surface = surface, .prevPoint = prevPoint, .eff_scale = eff_scale,
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_effect_shrink_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_effect_shrink_cb,
&settings);
}
/*
@ -5178,8 +5333,13 @@ static void dynamicPaint_doEffectStep(
.eff_scale = eff_scale, .force = force,
.point_locks = point_locks,
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_effect_drip_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_effect_drip_cb,
&settings);
MEM_freeN(point_locks);
}
@ -5256,8 +5416,13 @@ static void dynamicPaint_doBorderStep(DynamicPaintSurface *surface)
.surface = surface
};
BLI_task_parallel_range(
0, sData->adj_data->total_border, &data, dynamic_paint_border_cb, sData->adj_data->total_border > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->adj_data->total_border > 1000);
BLI_task_parallel_range(0, sData->adj_data->total_border,
&data,
dynamic_paint_border_cb,
&settings);
}
static void dynamic_paint_wave_step_cb(void *userdata, const int index,
@ -5403,8 +5568,12 @@ static void dynamicPaint_doWaveStep(DynamicPaintSurface *surface, float timescal
.wave_speed = wave_speed, .wave_scale = wave_scale, .wave_max_slope = wave_max_slope,
.dt = dt, .min_dist = min_dist, .damp_factor = damp_factor, .reset_wave = (ss == steps - 1),
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_wave_step_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data, dynamic_paint_wave_step_cb,
&settings);
}
MEM_freeN(prevPoint);
@ -5753,8 +5922,13 @@ static int dynamicPaint_generateBakeData(DynamicPaintSurface *surface, const Sce
.mvert = mvert, .canvas_verts = canvas_verts,
.do_velocity_data = do_velocity_data, .new_bdata = new_bdata,
};
BLI_task_parallel_range(
0, sData->total_points, &data, dynamic_paint_generate_bake_data_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_generate_bake_data_cb,
&settings);
MEM_freeN(canvas_verts);
@ -5787,8 +5961,13 @@ static int dynamicPaint_doStep(Scene *scene, Object *ob, DynamicPaintSurface *su
if (dynamic_paint_surface_needs_dry_dissolve(surface)) {
DynamicPaintDissolveDryData data = {.surface = surface, .timescale = timescale};
BLI_task_parallel_range(0, sData->total_points, &data,
dynamic_paint_surface_pre_step_cb, sData->total_points > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (sData->total_points > 1000);
BLI_task_parallel_range(0, sData->total_points,
&data,
dynamic_paint_surface_pre_step_cb,
&settings);
}
/*

8
source/blender/blenkernel/intern/mask_rasterize.c
View File

@ -1475,5 +1475,11 @@ void BKE_maskrasterize_buffer(MaskRasterHandle *mr_handle,
.width = width,
.buffer = buffer
};
BLI_task_parallel_range(0, (int)height, &data, maskrasterize_buffer_cb, height * width > 10000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((size_t)height * width > 10000);
BLI_task_parallel_range(0, (int)height,
&data,
maskrasterize_buffer_cb,
&settings);
}

12
source/blender/blenkernel/intern/mesh_evaluate.c
View File

@ -282,6 +282,10 @@ void BKE_mesh_calc_normals_poly(
const bool do_threaded = (numPolys > BKE_MESH_OMP_LIMIT);
float (*pnors)[3] = r_polynors;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = do_threaded;
if (only_face_normals) {
BLI_assert((pnors != NULL) || (numPolys == 0));
BLI_assert(r_vertnors == NULL);
@ -290,7 +294,7 @@ void BKE_mesh_calc_normals_poly(
.mpolys = mpolys, .mloop = mloop, .mverts = mverts, .pnors = pnors,
};
BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_cb, do_threaded);
BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_cb, &settings);
return;
}
@ -313,13 +317,13 @@ void BKE_mesh_calc_normals_poly(
};
/* Compute poly normals, and prepare weighted loop normals. */
BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_prepare_cb, do_threaded);
BLI_task_parallel_range(0, numPolys, &data, mesh_calc_normals_poly_prepare_cb, &settings);
/* Actually accumulate weighted loop normals into vertex ones. */
BLI_task_parallel_range(0, numLoops, &data, mesh_calc_normals_poly_accum_cb, do_threaded);
BLI_task_parallel_range(0, numLoops, &data, mesh_calc_normals_poly_accum_cb, &settings);
/* Normalize and validate computed vertex normals. */
BLI_task_parallel_range(0, numVerts, &data, mesh_calc_normals_poly_finalize_cb, do_threaded);
BLI_task_parallel_range(0, numVerts, &data, mesh_calc_normals_poly_finalize_cb, &settings);
if (free_vnors) {
MEM_freeN(vnors);

5
source/blender/blenkernel/intern/ocean.c
View File

@ -749,7 +749,10 @@ void BKE_ocean_simulate(struct Ocean *o, float t, float scale, float chop_amount
* This is not optimal in all cases, but remains reasonably simple and should be OK most of the time. */
/* compute a new htilda */
BLI_task_parallel_range(0, o->_M, &osd, ocean_compute_htilda, o->_M > 16);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (o->_M > 16);
BLI_task_parallel_range(0, o->_M, &osd, ocean_compute_htilda, &settings);
if (o->_do_disp_y) {
BLI_task_pool_push(pool, ocean_compute_displacement_y, NULL, false, TASK_PRIORITY_HIGH);

56
source/blender/blenkernel/intern/particle_system.c
View File

@ -3637,9 +3637,16 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
/* Apply SPH forces using double-density relaxation algorithm
* (Clavat et. al.) */
BLI_task_parallel_range_ex(
0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
dynamics_step_sph_ddr_task_cb_ex, psys->totpart > 100, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (psys->totpart > 100);
settings.userdata_chunk = &sphdata;
settings.userdata_chunk_size = sizeof(sphdata);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
dynamics_step_sph_ddr_task_cb_ex,
&settings);
sph_springs_modify(psys, timestep);
}
@ -3649,21 +3656,46 @@ static void dynamics_step(ParticleSimulationData *sim, float cfra)
* and Monaghan). Note that, unlike double-density relaxation,
* this algorithm is separated into distinct loops. */
BLI_task_parallel_range_ex(
0, psys->totpart, &task_data, NULL, 0,
dynamics_step_sph_classical_basic_integrate_task_cb_ex, psys->totpart > 100, true);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (psys->totpart > 100);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
dynamics_step_sph_classical_basic_integrate_task_cb_ex,
&settings);
}
/* calculate summation density */
/* Note that we could avoid copying sphdata for each thread here (it's only read here),
* but doubt this would gain us anything except confusion... */
BLI_task_parallel_range_ex(
0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
dynamics_step_sph_classical_calc_density_task_cb_ex, psys->totpart > 100, true);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (psys->totpart > 100);
settings.userdata_chunk = &sphdata;
settings.userdata_chunk_size = sizeof(sphdata);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
dynamics_step_sph_classical_calc_density_task_cb_ex,
&settings);
}
/* do global forces & effectors */
BLI_task_parallel_range_ex(
0, psys->totpart, &task_data, &sphdata, sizeof(sphdata),
dynamics_step_sph_classical_integrate_task_cb_ex, psys->totpart > 100, true);
{
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (psys->totpart > 100);
settings.userdata_chunk = &sphdata;
settings.userdata_chunk_size = sizeof(sphdata);
BLI_task_parallel_range(
0, psys->totpart,
&task_data,
dynamics_step_sph_classical_integrate_task_cb_ex,
&settings);
}
}
BLI_spin_end(&task_data.spin);

13
source/blender/blenkernel/intern/pbvh.c
View File

@ -1052,9 +1052,13 @@ static void pbvh_update_normals(PBVH *bvh, PBVHNode **nodes,
.fnors = fnors, .vnors = vnors,
};
BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_accum_task_cb, totnode > PBVH_THREADED_LIMIT);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (totnode > PBVH_THREADED_LIMIT);
BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_store_task_cb, totnode > PBVH_THREADED_LIMIT);
BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_accum_task_cb, &settings);
BLI_task_parallel_range(0, totnode, &data, pbvh_update_normals_store_task_cb, &settings);
MEM_freeN(vnors);
}
@ -1087,7 +1091,10 @@ void pbvh_update_BB_redraw(PBVH *bvh, PBVHNode **nodes, int totnode, int flag)
.flag = flag,
};
BLI_task_parallel_range(0, totnode, &data, pbvh_update_BB_redraw_task_cb, totnode > PBVH_THREADED_LIMIT);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (totnode > PBVH_THREADED_LIMIT);
BLI_task_parallel_range(0, totnode, &data, pbvh_update_BB_redraw_task_cb, &settings);
}
static void pbvh_update_draw_buffers(PBVH *bvh, PBVHNode **nodes, int totnode)

35
source/blender/blenkernel/intern/shrinkwrap.c
View File

@ -167,9 +167,14 @@ static void shrinkwrap_calc_nearest_vertex(ShrinkwrapCalcData *calc)
nearest.dist_sq = FLT_MAX;
ShrinkwrapCalcCBData data = {.calc = calc, .treeData = &treeData};
BLI_task_parallel_range_ex(
0, calc->numVerts, &data, &nearest, sizeof(nearest), shrinkwrap_calc_nearest_vertex_cb_ex,
calc->numVerts > BKE_MESH_OMP_LIMIT, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
settings.userdata_chunk = &nearest;
settings.userdata_chunk_size = sizeof(nearest);
BLI_task_parallel_range(0, calc->numVerts,
&data,shrinkwrap_calc_nearest_vertex_cb_ex,
&settings);
free_bvhtree_from_mesh(&treeData);
}
@ -463,9 +468,15 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc, bool for
.auxData = auxData, .aux_tree = aux_tree, .aux_callback = aux_callback,
.proj_axis = proj_axis, .local2aux = &local2aux,
};
BLI_task_parallel_range_ex(
0, calc->numVerts, &data, &hit, sizeof(hit), shrinkwrap_calc_normal_projection_cb_ex,
calc->numVerts > BKE_MESH_OMP_LIMIT, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
settings.userdata_chunk = &hit;
settings.userdata_chunk_size = sizeof(hit);
BLI_task_parallel_range(0, calc->numVerts,
&data,
shrinkwrap_calc_normal_projection_cb_ex,
&settings);
}
/* free data structures */
@ -583,9 +594,15 @@ static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
/* Find the nearest vertex */
ShrinkwrapCalcCBData data = {.calc = calc, .treeData = &treeData};
BLI_task_parallel_range_ex(
0, calc->numVerts, &data, &nearest, sizeof(nearest), shrinkwrap_calc_nearest_surface_point_cb_ex,
calc->numVerts > BKE_MESH_OMP_LIMIT, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (calc->numVerts > BKE_MESH_OMP_LIMIT);
settings.userdata_chunk = &nearest;
settings.userdata_chunk_size = sizeof(nearest);
BLI_task_parallel_range(0, calc->numVerts,
&data,
shrinkwrap_calc_nearest_surface_point_cb_ex,
&settings);
free_bvhtree_from_mesh(&treeData);
}

33
source/blender/blenkernel/intern/smoke.c
View File

@ -868,8 +868,13 @@ static void obstacles_from_derivedmesh(
.velocityX = velocityX, .velocityY = velocityY, .velocityZ = velocityZ,
.num_obstacles = num_obstacles
};
BLI_task_parallel_range(
sds->res_min[2], sds->res_max[2], &data, obstacles_from_derivedmesh_task_cb, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
BLI_task_parallel_range(sds->res_min[2], sds->res_max[2],
&data,
obstacles_from_derivedmesh_task_cb,
&settings);
}
/* free bvh tree */
free_bvhtree_from_mesh(&treeData);
@ -1395,7 +1400,13 @@ static void emit_from_particles(
.solid = solid, .smooth = smooth, .hr_smooth = hr_smooth,
};
BLI_task_parallel_range(min[2], max[2], &data, emit_from_particles_task_cb, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
BLI_task_parallel_range(min[2], max[2],
&data,
emit_from_particles_task_cb,
&settings);
}
if (sfs->flags & MOD_SMOKE_FLOW_USE_PART_SIZE) {
@ -1720,7 +1731,13 @@ static void emit_from_derivedmesh(Object *flow_ob, SmokeDomainSettings *sds, Smo
.flow_center = flow_center, .min = min, .max = max, .res = res,
};
BLI_task_parallel_range(min[2], max[2], &data, emit_from_derivedmesh_task_cb, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
BLI_task_parallel_range(min[2], max[2],
&data,
emit_from_derivedmesh_task_cb,
&settings);
}
/* free bvh tree */
free_bvhtree_from_mesh(&treeData);
@ -2510,7 +2527,13 @@ static void update_effectors(Scene *scene, Object *ob, SmokeDomainSettings *sds,
data.velocity_z = smoke_get_velocity_z(sds->fluid);
data.obstacle = smoke_get_obstacle(sds->fluid);
BLI_task_parallel_range(0, sds->res[0], &data, update_effectors_task_cb, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.scheduling_mode = TASK_SCHEDULING_DYNAMIC;
BLI_task_parallel_range(0, sds->res[0],
&data,
update_effectors_task_cb,
&settings);
}
pdEndEffectors(&effectors);

5
source/blender/blenkernel/intern/tracking_auto.c
View File

@ -512,10 +512,13 @@ bool BKE_autotrack_context_step(AutoTrackContext *context)
const int frame_delta = context->backwards ? -1 : 1;
context->step_ok = false;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (context->num_tracks > 1);
BLI_task_parallel_range(0, context->num_tracks,
context,
autotrack_context_step_cb,
context->num_tracks > 1);
&settings);
/* Advance the frame. */
BLI_spin_lock(&context->spin_lock);

6
source/blender/blenkernel/intern/tracking_stabilize.c
View File

@ -1600,10 +1600,14 @@ ImBuf *BKE_tracking_stabilize_frame(MovieClip *clip,
.ibuf = ibuf, .tmpibuf = tmpibuf, .mat = mat,
.interpolation = interpolation
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (tmpibuf->y > 128);
BLI_task_parallel_range(0, tmpibuf->y,
&data,
tracking_stabilize_frame_interpolation_cb,
tmpibuf->y > 128);
&settings);
if (tmpibuf->rect_float)
tmpibuf->userflags |= IB_RECT_INVALID;

72
source/blender/blenlib/BLI_task.h
View File

@ -19,7 +19,9 @@
*/
#ifndef __BLI_TASK_H__
#define __BLI_TASK_H__
#define __BLI_TASK_H__
#include <string.h> /* for memset() */
struct Link;
struct ListBase;
@ -117,6 +119,20 @@ void BLI_task_pool_delayed_push_end(TaskPool *pool, int thread_id);
/* Parallel for routines */
typedef enum eTaskSchedulingMode {
/* Task scheduler will divide overall work into equal chunks, scheduling
* even chunks to all worker threads.
* Least run time benefit, ideal for cases when each task requires equal
* amount of compute power.
*/
TASK_SCHEDULING_STATIC,
/* Task scheduler will schedule small amount of work to each worker thread.
* Has more run time overhead, but deals much better with cases when each
* part of the work requires totally different amount of compute power.
*/
TASK_SCHEDULING_DYNAMIC,
} eTaskSchedulingMode;
/* Per-thread specific data passed to the callback. */
typedef struct ParallelRangeTLS {
/* Identifier of the thread who this data belongs to. */
@ -131,29 +147,36 @@ typedef void (*TaskParallelRangeFunc)(void *userdata,
const int iter,
const ParallelRangeTLS *tls);
typedef void (*TaskParallelRangeFuncFinalize)(void *userdata, void *userdata_chunk);
void BLI_task_parallel_range_ex(
int start, int stop,
void *userdata,
void *userdata_chunk,
const size_t userdata_chunk_size,
TaskParallelRangeFunc func,
const bool use_threading,
const bool use_dynamic_scheduling);
typedef struct ParallelRangeSettings {
/* Whether caller allows to do threading of the particular range.
* Usually set by some equation, which forces threading off when threading
* overhead becomes higher than speed benefit.
* BLI_task_parallel_range() by itself will always use threading when range
* is higher than a chunk size. As in, threading will always be performed.
*/
bool use_threading;
/* Scheduling mode to use for this parallel range invocation. */
eTaskSchedulingMode scheduling_mode;
/* Each instance of looping chunks will get a copy of this data
* (similar to OpenMP's firstprivate).
*/
void *userdata_chunk; /* Pointer to actual data. */
size_t userdata_chunk_size; /* Size of that data. */
/* Function called from calling thread once whole range have been
* processed.
*/
TaskParallelRangeFuncFinalize func_finalize;
} ParallelRangeSettings;
BLI_INLINE void BLI_parallel_range_settings_defaults(
ParallelRangeSettings* settings);
void BLI_task_parallel_range(
int start, int stop,
void *userdata,
TaskParallelRangeFunc func,
const bool use_threading);
void BLI_task_parallel_range_finalize(
int start, int stop,
void *userdata,
void *userdata_chunk,
const size_t userdata_chunk_size,
TaskParallelRangeFunc func,
TaskParallelRangeFuncFinalize func_finalize,
const bool use_threading,
const bool use_dynamic_scheduling);
const ParallelRangeSettings *settings);
typedef void (*TaskParallelListbaseFunc)(void *userdata,
struct Link *iter,
@ -173,6 +196,15 @@ void BLI_task_parallel_mempool(
TaskParallelMempoolFunc func,
const bool use_threading);
/* TODO(sergey): Think of a better place for this. */
BLI_INLINE void BLI_parallel_range_settings_defaults(
ParallelRangeSettings* settings)
{
memset(settings, 0, sizeof(*settings));
settings->use_threading = true;
settings->scheduling_mode = TASK_SCHEDULING_STATIC;
}
#ifdef __cplusplus
}
#endif

18
source/blender/blenlib/intern/BLI_kdopbvh.c
View File

@ -923,9 +923,14 @@ static void non_recursive_bvh_div_nodes(
cb_data.depth = depth;
if (true) {
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (num_leafs > KDOPBVH_THREAD_LEAF_THRESHOLD);
BLI_task_parallel_range(
i, i_stop, &cb_data, non_recursive_bvh_div_nodes_task_cb,
num_leafs > KDOPBVH_THREAD_LEAF_THRESHOLD);
i, i_stop,
&cb_data,
non_recursive_bvh_div_nodes_task_cb,
&settings);
}
else {
/* Less hassle for debugging. */
@ -1342,9 +1347,14 @@ BVHTreeOverlap *BLI_bvhtree_overlap(
data[j].thread = j;
}
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (tree1->totleaf > KDOPBVH_THREAD_LEAF_THRESHOLD);
BLI_task_parallel_range(
0, thread_num, data, bvhtree_overlap_task_cb,
tree1->totleaf > KDOPBVH_THREAD_LEAF_THRESHOLD);
0, thread_num,
data,
bvhtree_overlap_task_cb,
&settings);
for (j = 0; j < thread_num; j++)
total += BLI_stack_count(data[j].overlap);

8
source/blender/blenlib/intern/math_statistics.c
View File

@ -118,8 +118,14 @@ void BLI_covariance_m_vn_ex(
.covfac = covfac, .n = n, .nbr_cos_vn = nbr_cos_vn,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((nbr_cos_vn * n * n) >= 10000);
BLI_task_parallel_range(
0, n * n, &data, covariance_m_vn_ex_task_cb, (nbr_cos_vn * n * n) >= 10000);
0, n * n,
&data,
covariance_m_vn_ex_task_cb,
&settings);
}
/**

83
source/blender/blenlib/intern/task.c
View File

@ -1147,86 +1147,21 @@ static void task_parallel_range_ex(
}
}
/**
* This function allows to parallelize for loops in a similar way to OpenMP's 'parallel for' statement.
*
* \param start First index to process.
* \param stop Index to stop looping (excluded).
* \param userdata Common userdata passed to all instances of \a func.
* \param userdata_chunk Optional, each instance of looping chunks will get a copy of this data
* (similar to OpenMP's firstprivate).
* \param userdata_chunk_size Memory size of \a userdata_chunk.
* \param func_ex Callback function (advanced version).
* \param use_threading If \a true, actually split-execute loop in threads, else just do a sequential forloop
* (allows caller to use any kind of test to switch on parallelization or not).
* \param use_dynamic_scheduling If \a true, the whole range is divided in a lot of small chunks (of size 32 currently),
* otherwise whole range is split in a few big chunks (num_threads * 2 chunks currently).
*/
void BLI_task_parallel_range_ex(
int start, int stop,
void *userdata,
void *userdata_chunk,
const size_t userdata_chunk_size,
TaskParallelRangeFunc func,
const bool use_threading,
const bool use_dynamic_scheduling)
{
task_parallel_range_ex(
start, stop, userdata, userdata_chunk, userdata_chunk_size, func, NULL,
use_threading, use_dynamic_scheduling);
}
/**
* A simpler version of \a BLI_task_parallel_range_ex, which does not use \a use_dynamic_scheduling,
* and does not handle 'firstprivate'-like \a userdata_chunk.
*
* \param start First index to process.
* \param stop Index to stop looping (excluded).
* \param userdata Common userdata passed to all instances of \a func.
* \param func Callback function (simple version).
* \param use_threading If \a true, actually split-execute loop in threads, else just do a sequential forloop
* (allows caller to use any kind of test to switch on parallelization or not).
*/
void BLI_task_parallel_range(
int start, int stop,
void *userdata,
TaskParallelRangeFunc func,
const bool use_threading)
{
task_parallel_range_ex(start, stop, userdata, NULL, 0, func, NULL, use_threading, false);
}
/**
* This function allows to parallelize for loops in a similar way to OpenMP's 'parallel for' statement,
* with an additional 'finalize' func called from calling thread once whole range have been processed.
*
* \param start First index to process.
* \param stop Index to stop looping (excluded).
* \param userdata Common userdata passed to all instances of \a func.
* \param userdata_chunk Optional, each instance of looping chunks will get a copy of this data
* (similar to OpenMP's firstprivate).
* \param userdata_chunk_size Memory size of \a userdata_chunk.
* \param func_ex Callback function (advanced version).
* \param func_finalize Callback function, called after all workers have finished,
* useful to finalize accumulative tasks.
* \param use_threading If \a true, actually split-execute loop in threads, else just do a sequential forloop
* (allows caller to use any kind of test to switch on parallelization or not).
* \param use_dynamic_scheduling If \a true, the whole range is divided in a lot of small chunks (of size 32 currently),
* otherwise whole range is split in a few big chunks (num_threads * 2 chunks currently).
*/
void BLI_task_parallel_range_finalize(
int start, int stop,
void *userdata,
void *userdata_chunk,
const size_t userdata_chunk_size,
TaskParallelRangeFunc func,
TaskParallelRangeFuncFinalize func_finalize,
const bool use_threading,
const bool use_dynamic_scheduling)
const ParallelRangeSettings *settings)
{
task_parallel_range_ex(
start, stop, userdata, userdata_chunk, userdata_chunk_size, func, func_finalize,
use_threading, use_dynamic_scheduling);
start, stop,
userdata,
settings->userdata_chunk,
settings->userdata_chunk_size,
func,
settings->func_finalize,
settings->use_threading,
(settings->scheduling_mode == TASK_SCHEDULING_DYNAMIC));
}
#undef MALLOCA

5
source/blender/bmesh/intern/bmesh_interp.c
View File

@ -508,7 +508,10 @@ void BM_loop_interp_multires_ex(
.axis_x = axis_x, .axis_y = axis_y, .v1 = v1, .v4 = v4, .e1 = e1, .e2 = e2,
.res = res, .d = 1.0f / (float)(res - 1)
};
BLI_task_parallel_range(0, res, &data, loop_interp_multires_cb, res > 5);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (res > 5);
BLI_task_parallel_range(0, res, &data, loop_interp_multires_cb, &settings);
}
/**

7
source/blender/depsgraph/intern/eval/deg_eval.cc
View File

@ -143,15 +143,18 @@ static void calculate_pending_func(void *data_v,
static void calculate_pending_parents(Depsgraph *graph, unsigned int layers)
{
const int num_operations = graph->operations.size();
const bool do_threads = num_operations > 256;
const bool do_threads = (num_operations > 256);
CalculatePengindData data;
data.graph = graph;
data.layers = layers;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = do_threads;
BLI_task_parallel_range(0,
num_operations,
&data,
calculate_pending_func,
do_threads);
&settings);
}
static void initialize_execution(DepsgraphEvalState *state, Depsgraph *graph)

38
source/blender/depsgraph/intern/eval/deg_eval_flush.cc
View File

@ -106,16 +106,26 @@ void flush_init_id_node_func(void *data_v,
BLI_INLINE void flush_prepare(Depsgraph *graph)
{
const int num_operations = graph->operations.size();
BLI_task_parallel_range(0, num_operations,
graph,
flush_init_operation_node_func,
(num_operations > 256));
const int num_id_nodes = graph->id_nodes.size();
BLI_task_parallel_range(0, num_id_nodes,
graph,
flush_init_id_node_func,
(num_id_nodes > 256));
{
const int num_operations = graph->operations.size();
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (num_operations > 256);
BLI_task_parallel_range(0, num_operations,
graph,
flush_init_operation_node_func,
&settings);
}
{
const int num_id_nodes = graph->id_nodes.size();
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (num_id_nodes > 256);
BLI_task_parallel_range(0, num_id_nodes,
graph,
flush_init_id_node_func,
&settings);
}
}
BLI_INLINE void flush_schedule_entrypoints(Depsgraph *graph, FlushQueue *queue)
@ -299,7 +309,13 @@ void deg_graph_clear_tags(Depsgraph *graph)
/* Go over all operation nodes, clearing tags. */
const int num_operations = graph->operations.size();
const bool do_threads = num_operations > 256;
BLI_task_parallel_range(0, num_operations, graph, graph_clear_func, do_threads);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = do_threads;
BLI_task_parallel_range(0, num_operations,
graph,
graph_clear_func,
&settings);
/* Clear any entry tags which haven't been flushed. */
BLI_gset_clear(graph->entry_tags, NULL);
}

8
source/blender/editors/sculpt_paint/paint_cursor.c
View File

@ -318,7 +318,9 @@ static int load_tex(Brush *br, ViewContext *vc, float zoom, bool col, bool prima
.pool = pool, .size = size, .rotation = rotation, .radius = radius,
};
BLI_task_parallel_range_ex(0, size, &data, NULL, 0, load_tex_task_cb_ex, true, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(0, size, &data, load_tex_task_cb_ex, &settings);
if (mtex->tex && mtex->tex->nodetree)
ntreeTexEndExecTree(mtex->tex->nodetree->execdata);
@ -447,7 +449,9 @@ static int load_tex_cursor(Brush *br, ViewContext *vc, float zoom)
.br = br, .buffer = buffer, .size = size,
};
BLI_task_parallel_range(0, size, &data, load_tex_cursor_task_cb, true);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(0, size, &data, load_tex_cursor_task_cb, &settings);
if (!cursor_snap.overlay_texture)
glGenTextures(1, &cursor_snap.overlay_texture);

5
source/blender/editors/sculpt_paint/paint_image_2d.c
View File

@ -1157,9 +1157,12 @@ static int paint_2d_op(void *state, ImBuf *ibufb, unsigned short *curveb, unsign
data.blend = blend;
data.tilex = tilex;
data.tilew = tilew;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(tiley, tileh + 1, &data,
paint_2d_op_foreach_do,
true);
&settings);
}
}

15
source/blender/editors/sculpt_paint/paint_mask.c
View File

@ -156,9 +156,12 @@ static int mask_flood_fill_exec(bContext *C, wmOperator *op)
.mode = mode, .value = value,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, mask_flood_fill_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
&settings);
if (multires)
multires_mark_as_modified(ob, MULTIRES_COORDS_MODIFIED);
@ -301,9 +304,12 @@ int ED_sculpt_mask_box_select(struct bContext *C, ViewContext *vc, const rcti *r
.mode = mode, .value = value, .clip_planes_final = clip_planes_final,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, mask_box_select_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
&settings);
if (nodes)
MEM_freeN(nodes);
@ -482,9 +488,12 @@ static int paint_mask_gesture_lasso_exec(bContext *C, wmOperator *op)
data.task_data.mode = mode;
data.task_data.value = value;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && (totnode > SCULPT_THREADED_LIMIT));
BLI_task_parallel_range(
0, totnode, &data, mask_gesture_lasso_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && (totnode > SCULPT_THREADED_LIMIT)));
&settings);
if (nodes)
MEM_freeN(nodes);

103
source/blender/editors/sculpt_paint/paint_vertex.c
View File

@ -1450,9 +1450,13 @@ static void precompute_weight_values(
.C = C, .ob = ob, .wpd = wpd, .wpi = wpi, .me = me,
};
BLI_task_parallel_range_ex(
0, me->totvert, &data, NULL, 0, do_wpaint_precompute_weight_cb_ex,
true, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(
0, me->totvert,
&data,
do_wpaint_precompute_weight_cb_ex,
&settings);
wpd->precomputed_weight_ready = true;
}
@ -1775,9 +1779,14 @@ static void calculate_average_weight(SculptThreadedTaskData *data, PBVHNode **UN
struct WPaintAverageAccum *accum = MEM_mallocN(sizeof(*accum) * totnode, __func__);
data->custom_data = accum;
BLI_task_parallel_range_ex(
0, totnode, data, NULL, 0, do_wpaint_brush_calc_average_weight_cb_ex,
((data->sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((data->sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
data,
do_wpaint_brush_calc_average_weight_cb_ex,
&settings);
uint accum_len = 0;
double accum_weight = 0.0;
@ -1809,30 +1818,40 @@ static void wpaint_paint_leaves(
/* Use this so average can modify its weight without touching the brush. */
data.strength = BKE_brush_weight_get(scene, brush);
/* current mirroring code cannot be run in parallel */
bool use_threading = !(me->editflag & ME_EDIT_MIRROR_X);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
/* NOTE: current mirroring code cannot be run in parallel */
settings.use_threading = !(me->editflag & ME_EDIT_MIRROR_X);
switch (brush->vertexpaint_tool) {
case PAINT_BLEND_AVERAGE:
calculate_average_weight(&data, nodes, totnode);
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_wpaint_brush_draw_task_cb_ex, use_threading, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_wpaint_brush_draw_task_cb_ex,
&settings);
break;
case PAINT_BLEND_SMEAR:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_wpaint_brush_smear_task_cb_ex, use_threading, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_wpaint_brush_smear_task_cb_ex,
&settings);
break;
case PAINT_BLEND_BLUR:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_wpaint_brush_blur_task_cb_ex, use_threading, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_wpaint_brush_blur_task_cb_ex,
&settings);
break;
default:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_wpaint_brush_draw_task_cb_ex, use_threading, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_wpaint_brush_draw_task_cb_ex,
&settings);
break;
}
}
@ -2778,9 +2797,13 @@ static void calculate_average_color(SculptThreadedTaskData *data, PBVHNode **UNU
struct VPaintAverageAccum *accum = MEM_mallocN(sizeof(*accum) * totnode, __func__);
data->custom_data = accum;
BLI_task_parallel_range_ex(
0, totnode, data, NULL, 0, do_vpaint_brush_calc_average_color_cb_ex,
true, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
BLI_task_parallel_range(
0, totnode,
data,
do_vpaint_brush_calc_average_color_cb_ex,
&settings);
uint accum_len = 0;
uint accum_value[3] = {0};
@ -2812,27 +2835,37 @@ static void vpaint_paint_leaves(
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes, .vp = vp, .vpd = vpd,
.lcol = (uint *)me->mloopcol, .me = me, .C = C,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
switch (brush->vertexpaint_tool) {
case PAINT_BLEND_AVERAGE:
calculate_average_color(&data, nodes, totnode);
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_vpaint_brush_draw_task_cb_ex, true, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_vpaint_brush_draw_task_cb_ex,
&settings);
break;
case PAINT_BLEND_BLUR:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_vpaint_brush_blur_task_cb_ex, true, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_vpaint_brush_blur_task_cb_ex,
&settings);
break;
case PAINT_BLEND_SMEAR:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_vpaint_brush_smear_task_cb_ex, true, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_vpaint_brush_smear_task_cb_ex,
&settings);
break;
default:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0,
do_vpaint_brush_draw_task_cb_ex, true, false);
BLI_task_parallel_range(
0, totnode,
&data,
do_vpaint_brush_draw_task_cb_ex,
&settings);
break;
}
}

280
source/blender/editors/sculpt_paint/sculpt.c
View File

@ -439,9 +439,14 @@ static void paint_mesh_restore_co(Sculpt *sd, Object *ob)
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && !ss->bm && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, paint_mesh_restore_co_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && !ss->bm && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&data,
paint_mesh_restore_co_task_cb,
&settings);
if (nodes)
MEM_freeN(nodes);
@ -948,9 +953,14 @@ static void calc_area_center(
};
BLI_mutex_init(&data.mutex);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, calc_area_normal_and_center_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&data,
calc_area_normal_and_center_task_cb,
&settings);
BLI_mutex_end(&data.mutex);
@ -998,9 +1008,14 @@ void sculpt_pbvh_calc_area_normal(
};
BLI_mutex_init(&data.mutex);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = use_threading;
BLI_task_parallel_range(
0, totnode, &data, calc_area_normal_and_center_task_cb,
use_threading);
0, totnode,
&data,
calc_area_normal_and_center_task_cb,
&settings);
BLI_mutex_end(&data.mutex);
@ -1038,9 +1053,14 @@ static void calc_area_normal_and_center(
};
BLI_mutex_init(&data.mutex);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, calc_area_normal_and_center_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&data,
calc_area_normal_and_center_task_cb,
&settings);
BLI_mutex_end(&data.mutex);
@ -1897,6 +1917,10 @@ static void smooth(
.smooth_mask = smooth_mask, .strength = strength,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
switch (type) {
case PBVH_GRIDS:
{
@ -1911,22 +1935,30 @@ static void smooth(
data_chunk->tmpgrid_size = size;
size += sizeof(*data_chunk);
BLI_task_parallel_range_ex(
0, totnode, &data, data_chunk, size, do_smooth_brush_multires_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
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);
MEM_freeN(data_chunk);
break;
}
case PBVH_FACES:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_smooth_brush_mesh_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
BLI_task_parallel_range(
0, totnode,
&data,
do_smooth_brush_mesh_task_cb_ex,
&settings);
break;
case PBVH_BMESH:
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_smooth_brush_bmesh_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
BLI_task_parallel_range(
0, totnode,
&data,
do_smooth_brush_bmesh_task_cb_ex,
&settings);
break;
}
@ -1981,9 +2013,14 @@ static void do_mask_brush_draw(Sculpt *sd, Object *ob, PBVHNode **nodes, int tot
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_mask_brush_draw_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_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)
@ -2053,9 +2090,14 @@ static void do_draw_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
.offset = offset,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_draw_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_draw_brush_task_cb_ex,
&settings);
}
/**
@ -2150,9 +2192,14 @@ static void do_crease_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
.spvc = &spvc, .offset = offset, .flippedbstrength = flippedbstrength,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_crease_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_crease_brush_task_cb_ex,
&settings);
}
static void do_pinch_brush_task_cb_ex(
@ -2201,9 +2248,14 @@ static void do_pinch_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_pinch_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_pinch_brush_task_cb_ex,
&settings);
}
static void do_grab_brush_task_cb_ex(
@ -2262,9 +2314,14 @@ static void do_grab_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
.grab_delta = grab_delta,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_grab_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_grab_brush_task_cb_ex,
&settings);
}
static void do_nudge_brush_task_cb_ex(
@ -2318,9 +2375,14 @@ static void do_nudge_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
.cono = cono,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_nudge_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_nudge_brush_task_cb_ex,
&settings);
}
static void do_snake_hook_brush_task_cb_ex(
@ -2424,9 +2486,14 @@ static void do_snake_hook_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int to
.spvc = &spvc, .grab_delta = grab_delta,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_snake_hook_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_snake_hook_brush_task_cb_ex,
&settings);
}
static void do_thumb_brush_task_cb_ex(
@ -2485,9 +2552,14 @@ static void do_thumb_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
.cono = cono,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_thumb_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_thumb_brush_task_cb_ex,
&settings);
}
static void do_rotate_brush_task_cb_ex(
@ -2547,9 +2619,14 @@ static void do_rotate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
.angle = angle,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_rotate_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_rotate_brush_task_cb_ex,
&settings);
}
static void do_layer_brush_task_cb_ex(
@ -2632,9 +2709,14 @@ static void do_layer_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode
};
BLI_mutex_init(&data.mutex);
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_layer_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_layer_brush_task_cb_ex,
&settings);
BLI_mutex_end(&data.mutex);
}
@ -2687,9 +2769,14 @@ static void do_inflate_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_inflate_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_inflate_brush_task_cb_ex,
&settings);
}
static void calc_sculpt_plane(
@ -2876,9 +2963,14 @@ static void do_flatten_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totno
.area_no = area_no, .area_co = area_co,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_flatten_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_flatten_brush_task_cb_ex,
&settings);
}
static void do_clay_brush_task_cb_ex(
@ -2962,9 +3054,14 @@ static void do_clay_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
.area_no = area_no, .area_co = area_co,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_clay_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_clay_brush_task_cb_ex,
&settings);
}
static void do_clay_strips_brush_task_cb_ex(
@ -3072,9 +3169,14 @@ static void do_clay_strips_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int t
.area_no_sp = area_no_sp, .area_co = area_co, .mat = mat,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_clay_strips_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_clay_strips_brush_task_cb_ex,
&settings);
}
static void do_fill_brush_task_cb_ex(
@ -3153,9 +3255,14 @@ static void do_fill_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode)
.area_no = area_no, .area_co = area_co,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_fill_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_fill_brush_task_cb_ex,
&settings);
}
static void do_scrape_brush_task_cb_ex(
@ -3233,9 +3340,14 @@ static void do_scrape_brush(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnod
.area_no = area_no, .area_co = area_co,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_scrape_brush_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_scrape_brush_task_cb_ex,
&settings);
}
static void do_gravity_task_cb_ex(
@ -3290,9 +3402,14 @@ static void do_gravity(Sculpt *sd, Object *ob, PBVHNode **nodes, int totnode, fl
.offset = offset,
};
BLI_task_parallel_range_ex(
0, totnode, &data, NULL, 0, do_gravity_task_cb_ex,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT), false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode,
&data,
do_gravity_task_cb_ex,
&settings);
}
@ -3422,9 +3539,14 @@ static void do_brush_action(Sculpt *sd, Object *ob, Brush *brush, UnifiedPaintSe
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &task_data, do_brush_action_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&task_data,
do_brush_action_task_cb,
&settings);
if (sculpt_brush_needs_normal(brush, ss->cache->normal_weight))
update_sculpt_normal(sd, ob, nodes, totnode);
@ -3604,9 +3726,14 @@ static void sculpt_combine_proxies(Sculpt *sd, Object *ob)
.sd = sd, .ob = ob, .brush = brush, .nodes = nodes,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, sculpt_combine_proxies_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&data,
sculpt_combine_proxies_task_cb,
&settings);
}
if (nodes)
@ -3686,9 +3813,14 @@ static void sculpt_flush_stroke_deform(Sculpt *sd, Object *ob)
.vertCos = vertCos,
};
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, &data, sculpt_flush_stroke_deform_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
&data,
sculpt_flush_stroke_deform_task_cb,
&settings);
if (vertCos) {
sculpt_vertcos_to_key(ob, ss->kb, vertCos);

9
source/blender/editors/sculpt_paint/sculpt_undo.c
View File

@ -345,9 +345,14 @@ static void sculpt_undo_bmesh_restore_generic(bContext *C,
BKE_pbvh_search_gather(ss->pbvh, NULL, NULL, &nodes, &totnode);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = ((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT);
BLI_task_parallel_range(
0, totnode, nodes, sculpt_undo_bmesh_restore_generic_task_cb,
((sd->flags & SCULPT_USE_OPENMP) && totnode > SCULPT_THREADED_LIMIT));
0, totnode,
nodes,
sculpt_undo_bmesh_restore_generic_task_cb,
&settings);
if (nodes)
MEM_freeN(nodes);

28
source/blender/editors/space_sequencer/sequencer_scopes.c
View File

@ -501,9 +501,17 @@ static ImBuf *make_histogram_view_from_ibuf_byte(ImBuf *ibuf)
memset(bins, 0, sizeof(bins));
MakeHistogramViewData data = {.ibuf = ibuf, .bins = bins};
BLI_task_parallel_range_finalize(
0, ibuf->y, &data, bins, sizeof(bins), make_histogram_view_from_ibuf_byte_cb_ex,
make_histogram_view_from_ibuf_finalize, ibuf->y >= 256, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (ibuf->y >= 256);
settings.userdata_chunk = bins;
settings.userdata_chunk_size = sizeof(bins);
settings.func_finalize = make_histogram_view_from_ibuf_finalize;
BLI_task_parallel_range(
0, ibuf->y,
&data,
make_histogram_view_from_ibuf_byte_cb_ex,
&settings);
nr = nb = ng = 0;
for (x = 0; x < HIS_STEPS; x++) {
@ -576,9 +584,17 @@ static ImBuf *make_histogram_view_from_ibuf_float(ImBuf *ibuf)
memset(bins, 0, sizeof(bins));
MakeHistogramViewData data = {.ibuf = ibuf, .bins = bins};
BLI_task_parallel_range_finalize(
0, ibuf->y, &data, bins, sizeof(bins), make_histogram_view_from_ibuf_float_cb_ex,
make_histogram_view_from_ibuf_finalize, ibuf->y >= 256, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (ibuf->y >= 256);
settings.userdata_chunk = bins;
settings.userdata_chunk_size = sizeof(bins);
settings.func_finalize = make_histogram_view_from_ibuf_finalize;
BLI_task_parallel_range(
0, ibuf->y,
&data,
make_histogram_view_from_ibuf_float_cb_ex,
&settings);
nr = nb = ng = 0;
for (x = 0; x < HIS_STEPS; x++) {

8
source/blender/modifiers/intern/MOD_displace.c
View File

@ -382,7 +382,13 @@ static void displaceModifier_do(
data.pool = BKE_image_pool_new();
BKE_texture_fetch_images_for_pool(dmd->texture, data.pool);
}
BLI_task_parallel_range(0, numVerts, &data, displaceModifier_do_task, numVerts > 512);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numVerts > 512);
BLI_task_parallel_range(0, numVerts,
&data,
displaceModifier_do_task,
&settings);
if (data.pool != NULL) {
BKE_image_pool_free(data.pool);

8
source/blender/modifiers/intern/MOD_meshdeform.c
View File

@ -414,7 +414,13 @@ static void meshdeformModifier_do(
data.icagemat = icagemat;
/* Do deformation. */
BLI_task_parallel_range(0, totvert, &data, meshdeform_vert_task, totvert > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (totvert > 1000);
BLI_task_parallel_range(0, totvert,
&data,
meshdeform_vert_task,
&settings);
/* release cage derivedmesh */
MEM_freeN(dco);

10
source/blender/modifiers/intern/MOD_ocean.c
View File

@ -370,11 +370,15 @@ static DerivedMesh *generate_ocean_geometry(OceanModifierData *omd)
gogd.origindex = CustomData_get_layer(&result->polyData, CD_ORIGINDEX);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = use_threading;
/* create vertices */
BLI_task_parallel_range(0, gogd.res_y + 1, &gogd, generate_ocean_geometry_vertices, use_threading);
BLI_task_parallel_range(0, gogd.res_y + 1, &gogd, generate_ocean_geometry_vertices, &settings);
/* create faces */
BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_polygons, use_threading);
BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_polygons, &settings);
CDDM_calc_edges(result);
@ -387,7 +391,7 @@ static DerivedMesh *generate_ocean_geometry(OceanModifierData *omd)
gogd.ix = 1.0 / gogd.rx;
gogd.iy = 1.0 / gogd.ry;
BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_uvs, use_threading);
BLI_task_parallel_range(0, gogd.res_y, &gogd, generate_ocean_geometry_uvs, &settings);
}
}

18
source/blender/modifiers/intern/MOD_surfacedeform.c
View File

@ -1013,8 +1013,13 @@ static bool surfacedeformBind(SurfaceDeformModifierData *smd, float (*vertexCos)
mul_v3_m4v3(data.targetCos[i], smd->mat, mvert[i].co);
}
BLI_task_parallel_range_ex(0, numverts, &data, NULL, 0, bindVert,
numverts > 10000, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numverts > 10000);
BLI_task_parallel_range(0, numverts,
&data,
bindVert,
&settings);
MEM_freeN(data.targetCos);
@ -1170,8 +1175,13 @@ static void surfacedeformModifier_do(ModifierData *md, float (*vertexCos)[3], un
mul_v3_m4v3(data.targetCos[i], smd->mat, mvert[i].co);
}
BLI_task_parallel_range_ex(0, numverts, &data, NULL, 0, deformVert,
numverts > 10000, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numverts > 10000);
BLI_task_parallel_range(0, numverts,
&data,
deformVert,
&settings);
if (tdm_vert_alloc) {
MEM_freeN((void *)mvert);

8
source/blender/modifiers/intern/MOD_uvwarp.c
View File

@ -210,7 +210,13 @@ static DerivedMesh *applyModifier(ModifierData *md, Object *ob,
UVWarpData data = {.mpoly = mpoly, .mloop = mloop, .mloopuv = mloopuv,
.dvert = dvert, .defgrp_index = defgrp_index,
.warp_mat = warp_mat, .axis_u = axis_u, .axis_v = axis_v};
BLI_task_parallel_range(0, numPolys, &data, uv_warp_compute, numPolys > 1000);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numPolys > 1000);
BLI_task_parallel_range(0, numPolys,
&data,
uv_warp_compute,
&settings);
dm->dirty |= DM_DIRTY_TESS_CDLAYERS;

13
source/blender/modifiers/intern/MOD_weightvgproximity.c
View File

@ -178,9 +178,16 @@ static void get_vert2geom_distance(int numVerts, float (*v_cos)[3],
data.dist[1] = dist_e;
data.dist[2] = dist_f;
BLI_task_parallel_range_ex(
0, numVerts, &data, &data_chunk, sizeof(data_chunk), vert2geom_task_cb_ex,
numVerts > 10000, false);
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (numVerts > 10000);
settings.userdata_chunk = &data_chunk;
settings.userdata_chunk_size = sizeof(data_chunk);
BLI_task_parallel_range(
0, numVerts,
&data,
vert2geom_task_cb_ex,
&settings);
if (dist_v)
free_bvhtree_from_mesh(&treeData_v);

5
source/blender/render/intern/source/pointdensity.c
View File

@ -1081,11 +1081,14 @@ void RE_point_density_sample(
data.min = min;
data.dim = dim;
data.values = values;
ParallelRangeSettings settings;
BLI_parallel_range_settings_defaults(&settings);
settings.use_threading = (resolution > 32);
BLI_task_parallel_range(0,
resolution,
&data,
point_density_sample_func,
resolution > 32);
&settings);
free_pointdensity(pd);
}