[Bf-blender-cvs] [f43d1aebcc8] tmp-task-foreach-pool: More naming consistancy cleanup + fix bug in single thread case with tls data.
Bastien Montagne
noreply at git.blender.org
Fri Nov 22 15:53:51 CET 2019
Commit: f43d1aebcc8e3e3686c5d93a867183c71ae50556
Author: Bastien Montagne
Date: Fri Nov 22 11:57:11 2019 +0100
Branches: tmp-task-foreach-pool
https://developer.blender.org/rBf43d1aebcc8e3e3686c5d93a867183c71ae50556
More naming consistancy cleanup + fix bug in single thread case with tls data.
===================================================================
M source/blender/blenlib/intern/task.c
===================================================================
diff --git a/source/blender/blenlib/intern/task.c b/source/blender/blenlib/intern/task.c
index 5dc94922c66..94b6f80be00 100644
--- a/source/blender/blenlib/intern/task.c
+++ b/source/blender/blenlib/intern/task.c
@@ -1203,7 +1203,7 @@ BLI_INLINE bool parallel_range_next_iter_get(TaskParallelRangePool *__restrict r
return (state != NULL && previter < state->stop);
}
-static void parallel_range_func(TaskPool *__restrict pool, void *userdata_chunk_idx, int thread_id)
+static void parallel_range_func(TaskPool *__restrict pool, void *tls_data_idx, int thread_id)
{
TaskParallelRangePool *__restrict range_pool = BLI_task_pool_userdata(pool);
TaskParallelTLS tls = {
@@ -1214,7 +1214,7 @@ static void parallel_range_func(TaskPool *__restrict pool, void *userdata_chunk_
int iter, count;
while (parallel_range_next_iter_get(range_pool, &iter, &count, &state)) {
tls.userdata_chunk = (char *)state->flatten_tls_storage +
- (((size_t)POINTER_AS_INT(userdata_chunk_idx)) * state->tls_data_size);
+ (((size_t)POINTER_AS_INT(tls_data_idx)) * state->tls_data_size);
for (int i = 0; i < count; i++) {
state->func(state->userdata_shared, iter + i, &tls);
}
@@ -1230,25 +1230,25 @@ static void parallel_range_single_thread(TaskParallelRangePool *range_pool)
void *userdata = state->userdata_shared;
TaskParallelRangeFunc func = state->func;
- void *userdata_chunk = state->initial_tls_memory;
- const size_t userdata_chunk_size = state->tls_data_size;
- void *userdata_chunk_local = NULL;
- const bool use_userdata_chunk = (userdata_chunk_size != 0) && (userdata_chunk != NULL);
- if (use_userdata_chunk) {
- userdata_chunk_local = MALLOCA(userdata_chunk_size);
- memcpy(userdata_chunk_local, userdata_chunk, userdata_chunk_size);
+ void *initial_tls_memory = state->initial_tls_memory;
+ const size_t tls_data_size = state->tls_data_size;
+ void *flatten_tls_storage = NULL;
+ const bool use_tls_data = (tls_data_size != 0) && (initial_tls_memory != NULL);
+ if (use_tls_data) {
+ flatten_tls_storage = MALLOCA(tls_data_size);
+ memcpy(flatten_tls_storage, initial_tls_memory, tls_data_size);
}
TaskParallelTLS tls = {
.thread_id = 0,
- .userdata_chunk = userdata_chunk_local,
+ .userdata_chunk = flatten_tls_storage,
};
for (int i = start; i < stop; i++) {
func(userdata, i, &tls);
}
if (state->func_finalize != NULL) {
- state->func_finalize(userdata, userdata_chunk_local);
+ state->func_finalize(userdata, flatten_tls_storage);
}
- MALLOCA_FREE(userdata_chunk_local, userdata_chunk_size);
+ MALLOCA_FREE(flatten_tls_storage, tls_data_size);
}
}
@@ -1277,18 +1277,21 @@ void BLI_task_parallel_range(const int start,
.userdata_shared = userdata,
.func = func,
.iter_value = start,
+ .initial_tls_memory = settings->userdata_chunk,
+ .tls_data_size = settings->userdata_chunk_size,
+ .func_finalize = settings->func_finalize,
};
TaskParallelRangePool range_pool = {
.pool = NULL, .parallel_range_states = &state, .current_state = NULL, .settings = settings};
int i, num_threads, num_tasks;
- void *userdata_chunk = settings->userdata_chunk;
- const size_t userdata_chunk_size = settings->userdata_chunk_size;
- if (userdata_chunk_size != 0) {
- BLI_assert(userdata_chunk != NULL);
+ void *tls_data = settings->userdata_chunk;
+ const size_t tls_data_size = settings->userdata_chunk_size;
+ if (tls_data_size != 0) {
+ BLI_assert(tls_data != NULL);
}
- const bool use_userdata_chunk = (userdata_chunk_size != 0) && (userdata_chunk != NULL);
- void *userdata_chunk_array = NULL;
+ const bool use_tls_data = (tls_data_size != 0) && (tls_data != NULL);
+ void *flatten_tls_storage = NULL;
/* If it's not enough data to be crunched, don't bother with tasks at all,
* do everything from the current thread.
@@ -1324,17 +1327,15 @@ void BLI_task_parallel_range(const int start,
atomic_cas_ptr((void **)&range_pool.current_state, NULL, &state);
BLI_assert(range_pool.current_state == &state);
- if (use_userdata_chunk) {
- state.flatten_tls_storage = userdata_chunk_array = MALLOCA(userdata_chunk_size *
- (size_t)num_tasks);
- state.tls_data_size = userdata_chunk_size;
+ if (use_tls_data) {
+ state.flatten_tls_storage = flatten_tls_storage = MALLOCA(tls_data_size * (size_t)num_tasks);
+ state.tls_data_size = tls_data_size;
}
for (i = 0; i < num_tasks; i++) {
- if (use_userdata_chunk) {
- void *userdata_chunk_local = (char *)userdata_chunk_array +
- (userdata_chunk_size * (size_t)i);
- memcpy(userdata_chunk_local, userdata_chunk, userdata_chunk_size);
+ if (use_tls_data) {
+ void *userdata_chunk_local = (char *)flatten_tls_storage + (tls_data_size * (size_t)i);
+ memcpy(userdata_chunk_local, tls_data, tls_data_size);
}
/* Use this pool's pre-allocated tasks. */
BLI_task_pool_push_from_thread(task_pool,
@@ -1348,15 +1349,14 @@ void BLI_task_parallel_range(const int start,
BLI_task_pool_work_and_wait(task_pool);
BLI_task_pool_free(task_pool);
- if (use_userdata_chunk) {
+ if (use_tls_data) {
if (settings->func_finalize != NULL) {
for (i = 0; i < num_tasks; i++) {
- void *userdata_chunk_local = (char *)userdata_chunk_array +
- (userdata_chunk_size * (size_t)i);
+ void *userdata_chunk_local = (char *)flatten_tls_storage + (tls_data_size * (size_t)i);
settings->func_finalize(userdata, userdata_chunk_local);
}
}
- MALLOCA_FREE(userdata_chunk_array, userdata_chunk_size * (size_t)num_tasks);
+ MALLOCA_FREE(flatten_tls_storage, tls_data_size * (size_t)num_tasks);
}
}
More information about the Bf-blender-cvs
mailing list