+4

src/xrt/auxiliary/CMakeLists.txt

··· 214 214 util/u_verify.h 215 215 util/u_process.c 216 216 util/u_process.h 217 217 + util/u_worker.c 218 218 + util/u_worker.cpp 219 219 + util/u_worker.h 220 220 + util/u_worker.hpp 217 221 "${CMAKE_CURRENT_BINARY_DIR}/u_git_tag.c" 218 222 ) 219 223

+4

src/xrt/auxiliary/meson.build

··· 87 87 'util/u_verify.h', 88 88 'util/u_process.c', 89 89 'util/u_process.h', 90 90 + 'util/u_worker.c', 91 91 + 'util/u_worker.cpp', 92 92 + 'util/u_worker.h', 93 93 + 'util/u_worker.hpp', 90 94 ) + [ 91 95 u_git_tag_c, 92 96 ],

+534

src/xrt/auxiliary/util/u_worker.c

··· 1 1 + // Copyright 2022, Collabora, Ltd. 2 2 + // SPDX-License-Identifier: BSL-1.0 3 3 + /*! 4 4 + * @file 5 5 + * @brief Simple worker pool. 6 6 + * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 + * 8 8 + * @ingroup aux_util 9 9 + */ 10 10 + 11 11 + #include "os/os_threading.h" 12 12 + 13 13 + #include "util/u_logging.h" 14 14 + #include "util/u_worker.h" 15 15 + #include "util/u_trace_marker.h" 16 16 + 17 17 + 18 18 + #define MAX_TASK_COUNT (64) 19 19 + #define MAX_THREAD_COUNT (16) 20 20 + 21 21 + struct group; 22 22 + struct pool; 23 23 + 24 24 + struct task 25 25 + { 26 26 + //! Group this task was submitted from. 27 27 + struct group *g; 28 28 + 29 29 + //! Function. 30 30 + u_worker_group_func_t func; 31 31 + 32 32 + //! Function data. 33 33 + void *data; 34 34 + }; 35 35 + 36 36 + struct thread 37 37 + { 38 38 + //! Pool this thread belongs to. 39 39 + struct pool *p; 40 40 + 41 41 + // Native thread. 42 42 + struct os_thread thread; 43 43 + }; 44 44 + 45 45 + struct pool 46 46 + { 47 47 + struct u_worker_thread_pool base; 48 48 + 49 49 + //! Big contenious mutex. 50 50 + struct os_mutex mutex; 51 51 + 52 52 + //! Array of tasks. 53 53 + struct task tasks[MAX_TASK_COUNT]; 54 54 + 55 55 + //! Number of tasks in array. 56 56 + size_t tasks_in_array_count; 57 57 + 58 58 + struct 59 59 + { 60 60 + size_t count; 61 61 + struct os_cond cond; 62 62 + } available; //!< For worker threads. 63 63 + 64 64 + //! Given at creation. 65 65 + uint32_t initial_worker_limit; 66 66 + 67 67 + //! Currently the number of works that can work, waiting increases this. 68 68 + uint32_t worker_limit; 69 69 + 70 70 + //! Number of threads working on tasks. 71 71 + size_t working_count; 72 72 + 73 73 + //! Number of created threads. 74 74 + size_t thread_count; 75 75 + 76 76 + //! The worker threads. 77 77 + struct thread threads[MAX_THREAD_COUNT]; 78 78 + 79 79 + //! Is the pool up and running? 80 80 + bool running; 81 81 + }; 82 82 + 83 83 + struct group 84 84 + { 85 85 + //! Base struct has to come first. 86 86 + struct u_worker_group base; 87 87 + 88 88 + //! Pointer to poll of threads. 89 89 + struct u_worker_thread_pool *uwtp; 90 90 + 91 91 + //! Number of tasks that is pending or being worked on in this group. 92 92 + size_t current_submitted_tasks_count; 93 93 + 94 94 + //! Number of threads that have been released or newly entered wait. 95 95 + size_t released_count; 96 96 + 97 97 + struct 98 98 + { 99 99 + size_t count; 100 100 + struct os_cond cond; 101 101 + } waiting; //!< For wait_all 102 102 + }; 103 103 + 104 104 + 105 105 + /* 106 106 + * 107 107 + * Helper functions. 108 108 + * 109 109 + */ 110 110 + 111 111 + static inline struct group * 112 112 + group(struct u_worker_group *uwp) 113 113 + { 114 114 + return (struct group *)uwp; 115 115 + } 116 116 + 117 117 + static inline struct pool * 118 118 + pool(struct u_worker_thread_pool *uwtp) 119 119 + { 120 120 + return (struct pool *)uwtp; 121 121 + } 122 122 + 123 123 + 124 124 + /* 125 125 + * 126 126 + * Internal pool functions. 127 127 + * 128 128 + */ 129 129 + 130 130 + static void 131 131 + locked_pool_pop_task(struct pool *p, struct task *out_task) 132 132 + { 133 133 + assert(p->tasks_in_array_count > 0); 134 134 + 135 135 + for (size_t i = 0; i < MAX_TASK_COUNT; i++) { 136 136 + if (p->tasks[i].func == NULL) { 137 137 + continue; 138 138 + } 139 139 + 140 140 + *out_task = p->tasks[i]; 141 141 + p->tasks[i] = (struct task){NULL, NULL, NULL}; 142 142 + p->tasks_in_array_count--; 143 143 + return; 144 144 + } 145 145 + 146 146 + assert(false); 147 147 + } 148 148 + 149 149 + static void 150 150 + locked_pool_push_task(struct pool *p, struct group *g, u_worker_group_func_t func, void *data) 151 151 + { 152 152 + assert(p->tasks_in_array_count < MAX_TASK_COUNT); 153 153 + 154 154 + for (size_t i = 0; i < MAX_TASK_COUNT; i++) { 155 155 + if (p->tasks[i].func != NULL) { 156 156 + continue; 157 157 + } 158 158 + 159 159 + p->tasks[i] = (struct task){g, func, data}; 160 160 + p->tasks_in_array_count++; 161 161 + g->current_submitted_tasks_count++; 162 162 + return; 163 163 + } 164 164 + 165 165 + assert(false); 166 166 + } 167 167 + 168 168 + static void 169 169 + locked_pool_wake_worker_if_allowed(struct pool *p) 170 170 + { 171 171 + // No tasks in array, don't wake any thread. 172 172 + if (p->tasks_in_array_count == 0) { 173 173 + return; 174 174 + } 175 175 + 176 176 + // The number of working threads is at the limit. 177 177 + if (p->working_count >= p->worker_limit) { 178 178 + return; 179 179 + } 180 180 + 181 181 + // No waiting thread. 182 182 + if (p->available.count == 0) { 183 183 + //! @todo Is this a error? 184 184 + return; 185 185 + } 186 186 + 187 187 + os_cond_signal(&p->available.cond); 188 188 + } 189 189 + 190 190 + 191 191 + /* 192 192 + * 193 193 + * Thread group functions. 194 194 + * 195 195 + */ 196 196 + 197 197 + static bool 198 198 + locked_group_should_enter_wait_loop(struct pool *p, struct group *g) 199 199 + { 200 200 + if (g->current_submitted_tasks_count == 0) { 201 201 + return false; 202 202 + } 203 203 + 204 204 + // Enter the loop as a released thread. 205 205 + g->released_count++; 206 206 + 207 207 + return true; 208 208 + } 209 209 + 210 210 + static bool 211 211 + locked_group_should_wait(struct pool *p, struct group *g) 212 212 + { 213 213 + /* 214 214 + * There are several cases that needs to be covered by this function. 215 215 + * 216 216 + * A thread is entering the wait_all function for the first time, and 217 217 + * work is outstanding what we should do then is increase the worker 218 218 + * limit and wait on the conditional. 219 219 + * 220 220 + * Similar to above, we where woken up, there are more work outstanding 221 221 + * on the group and we had been released, remove one released and up the 222 222 + * worker limit, then wait on the conditional. 223 223 + * 224 224 + * A thread (or more) has been woken up and no new tasks has been 225 225 + * submitted, then break out of the loop and decrement the released 226 226 + * count. 227 227 + * 228 228 + * As above, but we where one of many woken up but only one thread had 229 229 + * been released and that released count had been taken, then we should 230 230 + * do nothing and wait again. 231 231 + */ 232 232 + 233 233 + // Tasks available. 234 234 + if (g->current_submitted_tasks_count > 0) { 235 235 + 236 236 + // We have been released or newly entered the loop. 237 237 + if (g->released_count > 0) { 238 238 + g->released_count--; 239 239 + p->worker_limit++; 240 240 + 241 241 + // Wake a worker with the new worker limit. 242 242 + locked_pool_wake_worker_if_allowed(p); 243 243 + } 244 244 + 245 245 + return true; 246 246 + } 247 247 + 248 248 + // No tasks, and we have been released, party! 249 249 + if (g->released_count > 0) { 250 250 + g->released_count--; 251 251 + return false; 252 252 + } 253 253 + 254 254 + // We where woken up, but nothing had been released, loop again. 255 255 + return true; 256 256 + } 257 257 + 258 258 + static void 259 259 + locked_group_wake_waiter_if_allowed(struct pool *p, struct group *g) 260 260 + { 261 261 + // Are there still outstanding tasks? 262 262 + if (g->current_submitted_tasks_count > 0) { 263 263 + return; 264 264 + } 265 265 + 266 266 + // Is there a thread waiting or not? 267 267 + if (g->waiting.count == 0) { 268 268 + return; 269 269 + } 270 270 + 271 271 + // Wake one waiting thread. 272 272 + os_cond_signal(&g->waiting.cond); 273 273 + 274 274 + assert(p->worker_limit > p->initial_worker_limit); 275 275 + 276 276 + // Remove one waiting threads. 277 277 + p->worker_limit--; 278 278 + 279 279 + // We have released one thread. 280 280 + g->released_count++; 281 281 + } 282 282 + 283 283 + static void 284 284 + locked_group_wait(struct pool *p, struct group *g) 285 285 + { 286 286 + // Update tracking. 287 287 + g->waiting.count++; 288 288 + 289 289 + // The wait, also unlocks the mutex. 290 290 + os_cond_wait(&g->waiting.cond, &p->mutex); 291 291 + 292 292 + // Update tracking. 293 293 + g->waiting.count--; 294 294 + } 295 295 + 296 296 + 297 297 + /* 298 298 + * 299 299 + * Thread internal functions. 300 300 + * 301 301 + */ 302 302 + 303 303 + static bool 304 304 + locked_thread_allowed_to_work(struct pool *p) 305 305 + { 306 306 + // No work for you! 307 307 + if (p->tasks_in_array_count == 0) { 308 308 + return false; 309 309 + } 310 310 + 311 311 + // Reached the limit. 312 312 + if (p->working_count >= p->worker_limit) { 313 313 + return false; 314 314 + } 315 315 + 316 316 + return true; 317 317 + } 318 318 + 319 319 + static void 320 320 + locked_thread_wait_for_work(struct pool *p) 321 321 + { 322 322 + // Update tracking. 323 323 + p->available.count++; 324 324 + 325 325 + // The wait, also unlocks the mutex. 326 326 + os_cond_wait(&p->available.cond, &p->mutex); 327 327 + 328 328 + // Update tracking. 329 329 + p->available.count--; 330 330 + } 331 331 + 332 332 + static void * 333 333 + run_func(void *ptr) 334 334 + { 335 335 + struct thread *t = (struct thread *)ptr; 336 336 + struct pool *p = t->p; 337 337 + 338 338 + os_mutex_lock(&p->mutex); 339 339 + 340 340 + while (p->running) { 341 341 + 342 342 + if (!locked_thread_allowed_to_work(p)) { 343 343 + locked_thread_wait_for_work(p); 344 344 + 345 345 + // Check running first when woken up. 346 346 + continue; 347 347 + } 348 348 + 349 349 + // Pop a task from the pool. 350 350 + struct task task = {NULL, NULL, NULL}; 351 351 + locked_pool_pop_task(p, &task); 352 352 + 353 353 + // We are now counting as working, needed for wake below. 354 354 + p->working_count++; 355 355 + 356 356 + // Signal another thread if conditions are met. 357 357 + locked_pool_wake_worker_if_allowed(p); 358 358 + 359 359 + // Do the actual work here. 360 360 + os_mutex_unlock(&p->mutex); 361 361 + task.func(task.data); 362 362 + os_mutex_lock(&p->mutex); 363 363 + 364 364 + // No longer working. 365 365 + p->working_count--; 366 366 + 367 367 + // Only now decrement the task count on the owning group. 368 368 + task.g->current_submitted_tasks_count--; 369 369 + 370 370 + // Wake up any waiter. 371 371 + locked_group_wake_waiter_if_allowed(p, task.g); 372 372 + } 373 373 + 374 374 + // Make sure all threads are woken up. 375 375 + os_cond_signal(&p->available.cond); 376 376 + 377 377 + os_mutex_unlock(&p->mutex); 378 378 + 379 379 + return NULL; 380 380 + } 381 381 + 382 382 + 383 383 + /* 384 384 + * 385 385 + * 'Exported' thread pool functions. 386 386 + * 387 387 + */ 388 388 + 389 389 + struct u_worker_thread_pool * 390 390 + u_worker_thread_pool_create(uint32_t starting_worker_count, uint32_t thread_count) 391 391 + { 392 392 + XRT_TRACE_MARKER(); 393 393 + 394 394 + assert(starting_worker_count < thread_count); 395 395 + if (starting_worker_count >= thread_count) { 396 396 + return NULL; 397 397 + } 398 398 + 399 399 + assert(thread_count <= MAX_THREAD_COUNT); 400 400 + if (thread_count > MAX_THREAD_COUNT) { 401 401 + return NULL; 402 402 + } 403 403 + 404 404 + struct pool *p = U_TYPED_CALLOC(struct pool); 405 405 + p->base.reference.count = 1; 406 406 + p->initial_worker_limit = starting_worker_count; 407 407 + p->worker_limit = starting_worker_count; 408 408 + p->thread_count = thread_count; 409 409 + p->running = true; 410 410 + 411 411 + for (size_t i = 0; i < thread_count; i++) { 412 412 + p->threads[i].p = p; 413 413 + os_thread_init(&p->threads[i].thread); 414 414 + os_thread_start(&p->threads[i].thread, run_func, &p->threads[i]); 415 415 + } 416 416 + 417 417 + return (struct u_worker_thread_pool *)p; 418 418 + } 419 419 + 420 420 + void 421 421 + u_worker_thread_pool_destroy(struct u_worker_thread_pool *uwtp) 422 422 + { 423 423 + XRT_TRACE_MARKER(); 424 424 + 425 425 + struct pool *p = pool(uwtp); 426 426 + 427 427 + os_mutex_lock(&p->mutex); 428 428 + 429 429 + p->running = false; 430 430 + os_cond_signal(&p->available.cond); 431 431 + os_mutex_unlock(&p->mutex); 432 432 + 433 433 + // Wait for all threads. 434 434 + for (size_t i = 0; i < p->thread_count; i++) { 435 435 + os_thread_join(&p->threads[i].thread); 436 436 + os_thread_destroy(&p->threads[i].thread); 437 437 + } 438 438 + 439 439 + os_mutex_destroy(&p->mutex); 440 440 + os_cond_destroy(&p->available.cond); 441 441 + 442 442 + free(p); 443 443 + } 444 444 + 445 445 + 446 446 + /* 447 447 + * 448 448 + * 'Exported' group functions. 449 449 + * 450 450 + */ 451 451 + 452 452 + struct u_worker_group * 453 453 + u_worker_group_create(struct u_worker_thread_pool *uwtp) 454 454 + { 455 455 + XRT_TRACE_MARKER(); 456 456 + 457 457 + struct group *g = U_TYPED_CALLOC(struct group); 458 458 + g->base.reference.count = 1; 459 459 + u_worker_thread_pool_reference(&g->uwtp, uwtp); 460 460 + 461 461 + os_cond_init(&g->waiting.cond); 462 462 + 463 463 + return (struct u_worker_group *)g; 464 464 + } 465 465 + 466 466 + void 467 467 + u_worker_group_push(struct u_worker_group *uwp, u_worker_group_func_t f, void *data) 468 468 + { 469 469 + XRT_TRACE_MARKER(); 470 470 + 471 471 + struct group *g = group(uwp); 472 472 + struct pool *p = pool(g->uwtp); 473 473 + 474 474 + os_mutex_lock(&p->mutex); 475 475 + while (p->tasks_in_array_count >= MAX_TASK_COUNT) { 476 476 + os_mutex_unlock(&p->mutex); 477 477 + 478 478 + //! @todo Don't wait all, wait one. 479 479 + u_worker_group_wait_all(uwp); 480 480 + 481 481 + os_mutex_lock(&p->mutex); 482 482 + } 483 483 + 484 484 + locked_pool_push_task(p, g, f, data); 485 485 + 486 486 + // There are worker threads available, wake one up. 487 487 + if (p->available.count > 0) { 488 488 + os_cond_signal(&p->available.cond); 489 489 + } 490 490 + 491 491 + os_mutex_unlock(&p->mutex); 492 492 + } 493 493 + 494 494 + void 495 495 + u_worker_group_wait_all(struct u_worker_group *uwp) 496 496 + { 497 497 + XRT_TRACE_MARKER(); 498 498 + 499 499 + struct group *g = group(uwp); 500 500 + struct pool *p = pool(g->uwtp); 501 501 + 502 502 + os_mutex_lock(&p->mutex); 503 503 + 504 504 + // Can we early out? 505 505 + if (!locked_group_should_enter_wait_loop(p, g)) { 506 506 + os_mutex_unlock(&p->mutex); 507 507 + return; 508 508 + } 509 509 + 510 510 + // Wait here until all work been started and completed. 511 511 + while (locked_group_should_wait(p, g)) { 512 512 + // Do the wait. 513 513 + locked_group_wait(p, g); 514 514 + } 515 515 + 516 516 + os_mutex_unlock(&p->mutex); 517 517 + } 518 518 + 519 519 + void 520 520 + u_worker_group_destroy(struct u_worker_group *uwp) 521 521 + { 522 522 + XRT_TRACE_MARKER(); 523 523 + 524 524 + struct group *g = group(uwp); 525 525 + assert(g->base.reference.count == 0); 526 526 + 527 527 + u_worker_group_wait_all(uwp); 528 528 + 529 529 + u_worker_thread_pool_reference(&g->uwtp, NULL); 530 530 + 531 531 + os_cond_destroy(&g->waiting.cond); 532 532 + 533 533 + free(uwp); 534 534 + }

+20

src/xrt/auxiliary/util/u_worker.cpp

··· 1 1 + // Copyright 2022, Collabora, Ltd. 2 2 + // SPDX-License-Identifier: BSL-1.0 3 3 + /*! 4 4 + * @file 5 5 + * @brief C++ wrappers for workers. 6 6 + * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 + * 8 8 + * @ingroup aux_util 9 9 + */ 10 10 + 11 11 + #include "util/u_worker.hpp" 12 12 + 13 13 + 14 14 + void 15 15 + xrt::auxiliary::util::TaskCollection::cCallback(void *data_ptr) 16 16 + { 17 17 + auto &f = *static_cast<Functor *>(data_ptr); 18 18 + f(); 19 19 + f = nullptr; 20 20 + }

+172

src/xrt/auxiliary/util/u_worker.h

··· 1 1 + // Copyright 2022, Collabora, Ltd. 2 2 + // SPDX-License-Identifier: BSL-1.0 3 3 + /*! 4 4 + * @file 5 5 + * @brief Worker and threading pool. 6 6 + * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 + * 8 8 + * @ingroup aux_util 9 9 + */ 10 10 + 11 11 + #include "xrt/xrt_defines.h" 12 12 + 13 13 + 14 14 + #ifdef __cplusplus 15 15 + extern "C" { 16 16 + #endif 17 17 + 18 18 + 19 19 + /* 20 20 + * 21 21 + * Worker thread pool. 22 22 + * 23 23 + */ 24 24 + 25 25 + /*! 26 26 + * A worker pool, can shared between multiple groups worker pool. 27 27 + * 28 28 + * @ingroup aux_util 29 29 + */ 30 30 + struct u_worker_thread_pool 31 31 + { 32 32 + struct xrt_reference reference; 33 33 + }; 34 34 + 35 35 + /*! 36 36 + * Creates a new thread pool to be used by a worker group. 37 37 + * 38 38 + * @param starting_worker_count How many worker threads can be active at the 39 39 + * same time without any "donated" threads. 40 40 + * @param thread_count The number of threads to be created in total, 41 41 + * this is the maximum threads that can be in 42 42 + * flight at the same time. 43 43 + * 44 44 + * @ingroup aux_util 45 45 + */ 46 46 + struct u_worker_thread_pool * 47 47 + u_worker_thread_pool_create(uint32_t starting_worker_count, uint32_t thread_count); 48 48 + 49 49 + /*! 50 50 + * Internal function, only called by reference. 51 51 + * 52 52 + * @ingroup aux_util 53 53 + */ 54 54 + void 55 55 + u_worker_thread_pool_destroy(struct u_worker_thread_pool *uwtp); 56 56 + 57 57 + /*! 58 58 + * Standard Monado reference function. 59 59 + * 60 60 + * @ingroup aux_util 61 61 + */ 62 62 + static inline void 63 63 + u_worker_thread_pool_reference(struct u_worker_thread_pool **dst, struct u_worker_thread_pool *src) 64 64 + { 65 65 + struct u_worker_thread_pool *old_dst = *dst; 66 66 + 67 67 + if (old_dst == src) { 68 68 + return; 69 69 + } 70 70 + 71 71 + if (src) { 72 72 + xrt_reference_inc(&src->reference); 73 73 + } 74 74 + 75 75 + *dst = src; 76 76 + 77 77 + if (old_dst) { 78 78 + if (xrt_reference_dec(&old_dst->reference)) { 79 79 + u_worker_thread_pool_destroy(old_dst); 80 80 + } 81 81 + } 82 82 + } 83 83 + 84 84 + 85 85 + /* 86 86 + * 87 87 + * Worker group. 88 88 + * 89 89 + */ 90 90 + 91 91 + /*! 92 92 + * A worker group where you submit tasks to. Can share a thread pool with 93 93 + * multiple groups. Also can "donate" a thread to the thread pool by waiting. 94 94 + * 95 95 + * @ingroup aux_util 96 96 + */ 97 97 + struct u_worker_group 98 98 + { 99 99 + struct xrt_reference reference; 100 100 + }; 101 101 + 102 102 + /*! 103 103 + * Function typedef for tasks. 104 104 + * 105 105 + * @ingroup aux_util 106 106 + */ 107 107 + typedef void (*u_worker_group_func_t)(void *); 108 108 + 109 109 + /*! 110 110 + * Create a new worker group. 111 111 + * 112 112 + * @ingroup aux_util 113 113 + */ 114 114 + struct u_worker_group * 115 115 + u_worker_group_create(struct u_worker_thread_pool *uwtp); 116 116 + 117 117 + /*! 118 118 + * Push a new task to worker group. 119 119 + * 120 120 + * @ingroup aux_util 121 121 + */ 122 122 + void 123 123 + u_worker_group_push(struct u_worker_group *uwg, u_worker_group_func_t f, void *data); 124 124 + 125 125 + /*! 126 126 + * Wait for all pushed tasks to be completed, "donates" this thread to the 127 127 + * shared thread pool. 128 128 + * 129 129 + * @ingroup aux_util 130 130 + */ 131 131 + void 132 132 + u_worker_group_wait_all(struct u_worker_group *uwg); 133 133 + 134 134 + /*! 135 135 + * Destroy a worker pool. 136 136 + * 137 137 + * @ingroup aux_util 138 138 + */ 139 139 + void 140 140 + u_worker_group_destroy(struct u_worker_group *uwg); 141 141 + 142 142 + /*! 143 143 + * Standard Monado reference function. 144 144 + * 145 145 + * @ingroup aux_util 146 146 + */ 147 147 + static inline void 148 148 + u_worker_group_reference(struct u_worker_group **dst, struct u_worker_group *src) 149 149 + { 150 150 + struct u_worker_group *old_dst = *dst; 151 151 + 152 152 + if (old_dst == src) { 153 153 + return; 154 154 + } 155 155 + 156 156 + if (src) { 157 157 + xrt_reference_inc(&src->reference); 158 158 + } 159 159 + 160 160 + *dst = src; 161 161 + 162 162 + if (old_dst) { 163 163 + if (xrt_reference_dec(&old_dst->reference)) { 164 164 + u_worker_group_destroy(old_dst); 165 165 + } 166 166 + } 167 167 + } 168 168 + 169 169 + 170 170 + #ifdef __cplusplus 171 171 + } 172 172 + #endif

+191

src/xrt/auxiliary/util/u_worker.hpp

··· 1 1 + // Copyright 2022, Collabora, Ltd. 2 2 + // SPDX-License-Identifier: BSL-1.0 3 3 + /*! 4 4 + * @file 5 5 + * @brief C++ wrappers for workers. 6 6 + * @author Jakob Bornecrantz <jakob@collabora.com> 7 7 + * 8 8 + * @ingroup aux_util 9 9 + */ 10 10 + 11 11 + #pragma once 12 12 + 13 13 + #include "util/u_worker.h" 14 14 + 15 15 + #include <vector> 16 16 + #include <cassert> 17 17 + #include <functional> 18 18 + 19 19 + 20 20 + namespace xrt::auxiliary::util { 21 21 + 22 22 + class TaskCollection; 23 23 + class SharedThreadGroup; 24 24 + 25 25 + /*! 26 26 + * Wrapper around @ref u_worker_thread_pool. 27 27 + * 28 28 + * @ingroup aux_util 29 29 + */ 30 30 + class SharedThreadPool 31 31 + { 32 32 + private: 33 33 + u_worker_thread_pool *mPool = nullptr; 34 34 + 35 35 + 36 36 + public: 37 37 + explicit SharedThreadPool(SharedThreadPool const &copy) 38 38 + { 39 39 + u_worker_thread_pool_reference(&mPool, copy.mPool); 40 40 + } 41 41 + 42 42 + /*! 43 43 + * Take a C thread pool as argument in case the pool is shared between 44 44 + * different C++ components over C interfaces, or created externally. 45 45 + */ 46 46 + explicit SharedThreadPool(u_worker_thread_pool *uwtp) 47 47 + { 48 48 + u_worker_thread_pool_reference(&mPool, uwtp); 49 49 + } 50 50 + 51 51 + /*! 52 52 + * @copydoc u_worker_thread_pool_create. 53 53 + */ 54 54 + explicit SharedThreadPool(uint32_t starting_worker_count, uint32_t thread_count) 55 55 + { 56 56 + mPool = u_worker_thread_pool_create(starting_worker_count, thread_count); 57 57 + } 58 58 + 59 59 + ~SharedThreadPool() 60 60 + { 61 61 + u_worker_thread_pool_reference(&mPool, nullptr); 62 62 + } 63 63 + 64 64 + SharedThreadPool & 65 65 + operator=(const SharedThreadPool &other) 66 66 + { 67 67 + if (this == &other) { 68 68 + return *this; 69 69 + } 70 70 + 71 71 + u_worker_thread_pool_reference(&mPool, other.mPool); 72 72 + return *this; 73 73 + } 74 74 + 75 75 + friend SharedThreadGroup; 76 76 + 77 77 + // No default contstructor. 78 78 + SharedThreadPool() = delete; 79 79 + // No move. 80 80 + SharedThreadPool(SharedThreadPool &&) = delete; 81 81 + // No move assign. 82 82 + SharedThreadPool & 83 83 + operator=(SharedThreadPool &&) = delete; 84 84 + }; 85 85 + 86 86 + /*! 87 87 + * Wrapper around @ref u_worker_group, use @ref TaskCollection to dispatch work. 88 88 + * 89 89 + * @ingroup aux_util 90 90 + */ 91 91 + class SharedThreadGroup 92 92 + { 93 93 + private: 94 94 + u_worker_group *mGroup = nullptr; 95 95 + 96 96 + 97 97 + public: 98 98 + explicit SharedThreadGroup(SharedThreadPool const &stp) 99 99 + { 100 100 + mGroup = u_worker_group_create(stp.mPool); 101 101 + } 102 102 + 103 103 + ~SharedThreadGroup() 104 104 + { 105 105 + u_worker_group_reference(&mGroup, nullptr); 106 106 + } 107 107 + 108 108 + friend TaskCollection; 109 109 + 110 110 + // No default constructor. 111 111 + SharedThreadGroup() = delete; 112 112 + // Do not move or copy the shared thread group. 113 113 + SharedThreadGroup(SharedThreadGroup const &) = delete; 114 114 + SharedThreadGroup(SharedThreadGroup &&) = delete; 115 115 + SharedThreadGroup & 116 116 + operator=(SharedThreadGroup const &) = delete; 117 117 + SharedThreadGroup & 118 118 + operator=(SharedThreadGroup &&) = delete; 119 119 + }; 120 120 + 121 121 + /*! 122 122 + * Class to let users fall into a pit of success by 123 123 + * being designed as a one shot dispatcher instance. 124 124 + * 125 125 + * @ingroup aux_util 126 126 + */ 127 127 + class TaskCollection 128 128 + { 129 129 + public: 130 130 + typedef std::function<void()> Functor; 131 131 + 132 132 + 133 133 + private: 134 134 + static constexpr size_t kSize = 16; 135 135 + 136 136 + Functor mFunctors[kSize] = {}; 137 137 + u_worker_group *mGroup = nullptr; 138 138 + 139 139 + 140 140 + public: 141 141 + /*! 142 142 + * Give all Functors when constructed, some what partially 143 143 + * avoids use after leaving scope issues of function delegates. 144 144 + */ 145 145 + TaskCollection(SharedThreadGroup const &stc, std::vector<Functor> funcs) 146 146 + { 147 147 + assert(funcs.size() <= kSize); 148 148 + 149 149 + u_worker_group_reference(&mGroup, stc.mGroup); 150 150 + 151 151 + for (size_t i = 0; i < kSize && i < funcs.size(); i++) { 152 152 + mFunctors[i] = funcs[i]; 153 153 + u_worker_group_push(mGroup, &cCallback, &mFunctors[i]); 154 154 + } 155 155 + } 156 156 + 157 157 + ~TaskCollection() 158 158 + { 159 159 + // Also unreferences the group. 160 160 + waitAll(); 161 161 + } 162 162 + 163 163 + /*! 164 164 + * Waits for all given tasks to complete, also frees the group. 165 165 + */ 166 166 + void 167 167 + waitAll() 168 168 + { 169 169 + if (mGroup == nullptr) { 170 170 + return; 171 171 + } 172 172 + u_worker_group_wait_all(mGroup); 173 173 + u_worker_group_reference(&mGroup, nullptr); 174 174 + } 175 175 + 176 176 + 177 177 + // Do not move or copy the task collection. 178 178 + TaskCollection(TaskCollection const &) = delete; 179 179 + TaskCollection(TaskCollection &&) = delete; 180 180 + TaskCollection & 181 181 + operator=(TaskCollection const &) = delete; 182 182 + TaskCollection & 183 183 + operator=(TaskCollection &&) = delete; 184 184 + 185 185 + 186 186 + private: 187 187 + static void 188 188 + cCallback(void *data_ptr); 189 189 + }; 190 190 + 191 191 + } // namespace xrt::auxiliary::util