Blender V5.3
wm_jobs.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
10
11#include <cstring>
12
14
15#include "MEM_guardedalloc.h"
16
17#include "BLI_build_config.hh"
18#include "BLI_listbase.hh"
19#include "BLI_string.hh"
20#include "BLI_threads.hh"
21#include "BLI_time.hh"
22#include "BLI_utildefines.hh"
23
24#if OS_WINDOWS
25# include "BLI_winstuff.hh"
26#endif
27
28#include "BKE_context.hh"
29#include "BKE_global.hh"
30#include "BKE_report.hh"
31
32#include "SEQ_prefetch.hh"
33
34#include "WM_api.hh"
35#include "WM_types.hh"
36#include "wm.hh"
37#include "wm_event_types.hh"
38
39namespace blender {
40
41/*
42 * Add new job
43 * - register in WM
44 * - configure callbacks
45 *
46 * Start or re-run job
47 * - if job running
48 * - signal job to end
49 * - add timer notifier to verify when it has ended, to start it
50 * - else
51 * - start job
52 * - add timer notifier to handle progress
53 *
54 * Stop job
55 * - signal job to end
56 * on end, job will tag itself as sleeping
57 *
58 * Remove job
59 * - signal job to end
60 * on end, job will remove itself
61 *
62 * When job is done:
63 * - it puts timer to sleep (or removes?)
64 */
65
66struct ThreadSlot;
67
68struct wmJob {
70
73
80 void (*initjob)(void *);
90 void (*update)(void *);
102 void (*timer_step)(void *);
107 void (*free)(void *);
112 void (*endjob)(void *);
117 void (*completed)(void *);
122 void (*canceled)(void *);
123
125 double time_step;
131
132 /* Internal. */
133 const void *owner;
137
140
142 char name[128];
143
146 void (*run_free)(void *);
147
149 ListBaseT<ThreadSlot> threads;
150
152
158};
159
160/* Main thread locking. */
161
166
171
172static void wm_job_main_thread_yield(wmJob *wm_job)
173{
174 /* Unlock and lock the ticket mutex. because it's a fair mutex any job that
175 * is waiting to acquire the lock will get it first, before we can lock. */
178}
179
181{
182 /* A QoS API is currently only available for Windows. */
183#if OS_WINDOWS
184 for (wmJob &wm_job : wm->runtime->jobs) {
185 if (wm_job.flag & WM_JOB_PRIORITY) {
187 return;
188 }
189 }
190
192#else
194#endif
195}
196
199static wmJob *wm_job_find(const wmWindowManager *wm, const void *owner, const eWM_JobType job_type)
200{
201 if (owner && (job_type != WM_JOB_TYPE_ANY)) {
202 for (wmJob &wm_job : wm->runtime->jobs) {
203 if (wm_job.owner == owner && wm_job.job_type == job_type) {
204 return &wm_job;
205 }
206 }
207 }
208 else if (owner) {
209 for (wmJob &wm_job : wm->runtime->jobs) {
210 if (wm_job.owner == owner) {
211 return &wm_job;
212 }
213 }
214 }
215 else if (job_type != WM_JOB_TYPE_ANY) {
216 for (wmJob &wm_job : wm->runtime->jobs) {
217 if (wm_job.job_type == job_type) {
218 return &wm_job;
219 }
220 }
221 }
222
223 return nullptr;
224}
225
226/* ******************* public API ***************** */
227
229 wmWindow *win,
230 const void *owner,
231 const char *name,
232 const eWM_JobFlag flag,
233 const eWM_JobType job_type)
234{
235 wmJob *wm_job = wm_job_find(wm, owner, job_type);
236
237 if (wm_job == nullptr) {
238 wm_job = MEM_new_zeroed<wmJob>("new job");
239
240 BLI_addtail(&wm->runtime->jobs, wm_job);
241 wm_job->win = win;
242 wm_job->owner = owner;
243 wm_job->flag = flag;
244 wm_job->job_type = job_type;
245 STRNCPY(wm_job->name, name);
246
249
250 wm_job->worker_status.reports = MEM_new<ReportList>(__func__);
253
255 }
256 /* Else: a running job, be careful. */
257
258 /* Prevent creating a job with an invalid type. */
260
261 return wm_job;
262}
263
264bool WM_jobs_progress_test(const wmWindowManager *wm, const void *owner, int job_type)
265{
266 /* Job can be running or about to run (suspended). */
267 for (wmJob &wm_job : wm->runtime->jobs) {
268 if (wm_job.owner != owner) {
269 continue;
270 }
271
272 if (!ELEM(job_type, WM_JOB_TYPE_ANY, wm_job.job_type)) {
273 continue;
274 }
275
276 if ((wm_job.flag & WM_JOB_PROGRESS) && (wm_job.running || wm_job.suspended)) {
277 return true;
278 }
279 }
280
281 return false;
282}
283
284float WM_jobs_progress(const wmWindowManager *wm, const void *owner)
285{
286 const wmJob *wm_job = wm_job_find(wm, owner, WM_JOB_TYPE_ANY);
287
288 if (wm_job && wm_job->flag & WM_JOB_PROGRESS) {
289 return wm_job->worker_status.progress;
290 }
291
292 return 0.0;
293}
294
296{
297 float total_progress = 0.0f;
298 float jobs_progress = 0;
299
300 for (wmJob &wm_job : wm->runtime->jobs) {
301 if (wm_job.threads.first() && !wm_job.ready) {
302 if (wm_job.flag & WM_JOB_PROGRESS) {
303 /* Accumulate global progress for running jobs. */
304 jobs_progress++;
305 total_progress += wm_job.worker_status.progress;
306 }
307 }
308 }
309
310 /* If there are running jobs, set the global progress indicator. */
311 if (jobs_progress > 0) {
312 float progress = total_progress / jobs_progress;
313
314 for (wmWindow &win : wm->windows) {
315 WM_progress_set(&win, progress);
316 }
317 }
318 else {
319 for (wmWindow &win : wm->windows) {
320 WM_progress_clear(&win);
321 }
322 }
323}
324
325double WM_jobs_starttime(const wmWindowManager *wm, const void *owner)
326{
327 const wmJob *wm_job = wm_job_find(wm, owner, WM_JOB_TYPE_ANY);
328
329 if (wm_job && wm_job->flag & WM_JOB_PROGRESS) {
330 return wm_job->start_time;
331 }
332
333 return 0;
334}
335
336const char *WM_jobs_name(const wmWindowManager *wm, const void *owner)
337{
338 wmJob *wm_job = wm_job_find(wm, owner, WM_JOB_TYPE_ANY);
339
340 if (wm_job) {
341 return wm_job->name;
342 }
343
344 return nullptr;
345}
346
347void *WM_jobs_customdata_from_type(wmWindowManager *wm, const void *owner, int job_type)
348{
349 wmJob *wm_job = wm_job_find(wm, owner, eWM_JobType(job_type));
350
351 if (wm_job) {
352 return WM_jobs_customdata_get(wm_job);
353 }
354
355 return nullptr;
356}
357
358bool WM_jobs_is_running(const wmJob *wm_job)
359{
360 return wm_job->running;
361}
362
363bool WM_jobs_is_stopped(const wmWindowManager *wm, const void *owner)
364{
365 wmJob *wm_job = wm_job_find(wm, owner, WM_JOB_TYPE_ANY);
366 return wm_job ? wm_job->worker_status.stop : true; /* XXX to be redesigned properly. */
367}
368
370{
371 if (!wm_job->customdata) {
372 return wm_job->run_customdata;
373 }
374 return wm_job->customdata;
375}
376
377void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void (*free)(void *customdata))
378{
379 /* Pending job? just free. */
380 if (wm_job->customdata) {
381 wm_job->free(wm_job->customdata);
382 }
383
384 wm_job->customdata = customdata;
385 wm_job->free = free;
386
387 if (wm_job->running) {
388 /* Signal job to end. */
389 wm_job->worker_status.stop = true;
390 }
391}
392
394 wmJob *wm_job, double time_step, uint note, uint endnote, void (*timer_step)(void *))
395{
396 wm_job->time_step = time_step;
397 wm_job->note = note;
398 wm_job->endnote = endnote;
399 wm_job->timer_step = timer_step;
400}
401
402void WM_jobs_delay_start(wmJob *wm_job, double delay_time)
403{
404 wm_job->start_delay_time = delay_time;
405}
406
408 wm_jobs_start_callback startjob,
409 void (*initjob)(void *),
410 void (*update)(void *),
411 void (*endjob)(void *))
412{
413 WM_jobs_callbacks_ex(wm_job, startjob, initjob, update, endjob, nullptr, nullptr);
414}
415
417 wm_jobs_start_callback startjob,
418 void (*initjob)(void *),
419 void (*update)(void *),
420 void (*endjob)(void *),
421 void (*completed)(void *),
422 void (*canceled)(void *))
423{
424 wm_job->startjob = startjob;
425 wm_job->initjob = initjob;
426 wm_job->update = update;
427 wm_job->endjob = endjob;
428 wm_job->completed = completed;
429 wm_job->canceled = canceled;
430}
431
436
437static void *do_job_thread(void *job_v)
438{
439 wmJob *wm_job = static_cast<wmJob *>(job_v);
440
441 wm_job->startjob(wm_job->run_customdata, &wm_job->worker_status);
442 wm_job->ready = true;
443
444 return nullptr;
445}
446
447/* Don't allow same startjob to be executed twice. */
449{
450 bool suspend = false;
451
452 /* Job added with suspend flag, we wait 1 timer step before activating it. */
453 if (test->start_delay_time > 0.0) {
454 suspend = true;
455 test->start_delay_time = 0.0;
456 }
457 else {
458 /* Check other jobs. */
459 for (wmJob &wm_job : wm->runtime->jobs) {
460 /* Obvious case, no test needed. */
461 if (&wm_job == test || !wm_job.running) {
462 continue;
463 }
464
465 /* If new job is not render, then check for same job type. */
466 if (0 == (test->flag & WM_JOB_EXCL_RENDER)) {
467 if (wm_job.job_type != test->job_type) {
468 continue;
469 }
470 }
471
472 /* If new job is render, any render job should be stopped. */
473 if (test->flag & WM_JOB_EXCL_RENDER) {
474 if (0 == (wm_job.flag & WM_JOB_EXCL_RENDER)) {
475 continue;
476 }
477 }
478
479 suspend = true;
480
481 /* If this job has higher priority, stop others. */
482 if (test->flag & WM_JOB_PRIORITY) {
483 wm_job.worker_status.stop = true;
484 // printf("job stopped: %s\n", wm_job->name);
485 }
486 }
487 }
488
489 /* Possible suspend ourselves, waiting for other jobs, or de-suspend. */
490 test->suspended = suspend;
491#if 0
492 if (suspend) {
493 printf("job suspended: %s\n", test->name);
494 }
495#endif
496}
497
499{
500 if (wm_job->running) {
501 /* Signal job to end and restart. */
502 wm_job->worker_status.stop = true;
503 // printf("job started a running job, ending... %s\n", wm_job->name);
504 }
505 else {
506
507 if (wm_job->customdata && wm_job->startjob) {
508 const double time_step = (wm_job->start_delay_time > 0.0) ? wm_job->start_delay_time :
509 wm_job->time_step;
510
512
513 if (wm_job->suspended == false) {
514 /* Copy to ensure proper free in end. */
515 wm_job->run_customdata = wm_job->customdata;
516 wm_job->run_free = wm_job->free;
517 wm_job->free = nullptr;
518 wm_job->customdata = nullptr;
519 wm_job->running = true;
520
521 if (wm_job->initjob) {
522 wm_job->initjob(wm_job->run_customdata);
523 }
524
525 wm_job->worker_status.stop = false;
526 wm_job->ready = false;
527 wm_job->worker_status.progress = 0.0;
528
529 // printf("job started: %s\n", wm_job->name);
530
532 BLI_threadpool_insert(&wm_job->threads, wm_job);
533 }
534
535 /* Restarted job has timer already. */
536 if (wm_job->wt && (wm_job->wt->time_step > time_step)) {
537 WM_event_timer_remove(wm, wm_job->win, wm_job->wt);
538 wm_job->wt = WM_event_timer_add(wm, wm_job->win, TIMERJOBS, time_step);
539 }
540 if (wm_job->wt == nullptr) {
541 wm_job->wt = WM_event_timer_add(wm, wm_job->win, TIMERJOBS, time_step);
542 }
543
545 }
546 else {
547 printf("job fails, not initialized\n");
548 }
549 }
550}
551
552static void wm_job_end(wmWindowManager *wm, wmJob *wm_job)
553{
554 BLI_assert_msg(BLI_thread_is_main(), "wm_job_end should only be called from the main thread");
555 if (wm_job->endjob) {
556 wm_job->endjob(wm_job->run_customdata);
557 }
558
559 /* Do the final callback based on whether the job was run to completion or not.
560 * Not all jobs have the same way of signaling cancellation (i.e. rendering stops when
561 * `G.is_break == true`, but doesn't set any wm_job properties to cancel the WM job). */
562 const bool was_canceled = wm_job->worker_status.stop || G.is_break;
563 void (*final_callback)(void *) = (wm_job->ready && !was_canceled) ? wm_job->completed :
564 wm_job->canceled;
565 if (final_callback) {
566 final_callback(wm_job->run_customdata);
567 }
568
569 /* Ensure all reports have been moved to WM. */
570 wm_jobs_reports_update(wm, wm_job);
571}
572
573static void wm_job_free(wmWindowManager *wm, wmJob *wm_job)
574{
575 BLI_remlink(&wm->runtime->jobs, wm_job);
578
579 BLI_assert(wm_job->worker_status.reports->list.is_empty());
581 MEM_delete(wm_job->worker_status.reports);
582 MEM_delete(wm_job);
583
585}
586
587/* Stop job, end thread, free data completely. */
589{
590 bool update_progress = (wm_job->flag & WM_JOB_PROGRESS) != 0;
591
592 if (wm_job->running) {
593 /* Signal job to end. */
594 wm_job->worker_status.stop = true;
595
597 BLI_threadpool_end(&wm_job->threads);
599 wm_job_end(wm, wm_job);
600 }
601
602 if (wm_job->wt) {
603 WM_event_timer_remove(wm, wm_job->win, wm_job->wt);
604 }
605 if (wm_job->customdata) {
606 wm_job->free(wm_job->customdata);
607 }
608 if (wm_job->run_customdata) {
609 wm_job->run_free(wm_job->run_customdata);
610 }
611
612 /* Remove wm_job. */
613 wm_job_free(wm, wm_job);
614
615 /* Update progress bars in windows. */
616 if (update_progress) {
618 }
619}
620
622{
623 wmJob *wm_job;
624
625 while ((wm_job = wm->runtime->jobs.first())) {
626 wm_jobs_kill_job(wm, wm_job);
627 }
628
629 /* This job will be automatically restarted. */
631}
632
634{
635 for (wmJob &wm_job : wm->runtime->jobs.items_mutable()) {
636 if (wm_job.owner != owner) {
637 wm_jobs_kill_job(wm, &wm_job);
638 }
639 }
640}
641
642void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
643{
644 BLI_assert(job_type != WM_JOB_TYPE_ANY);
645
646 for (wmJob &wm_job : wm->runtime->jobs.items_mutable()) {
647 if (owner && wm_job.owner != owner) {
648 continue;
649 }
650
651 if (wm_job.job_type == job_type) {
652 wm_jobs_kill_job(wm, &wm_job);
653 }
654 }
655}
656
658{
659 for (wmJob &wm_job : wm->runtime->jobs.items_mutable()) {
660 if (wm_job.owner == owner) {
661 wm_jobs_kill_job(wm, &wm_job);
662 }
663 }
664}
665
666void WM_jobs_stop_type(wmWindowManager *wm, const void *owner, eWM_JobType job_type)
667{
668 BLI_assert(job_type != WM_JOB_TYPE_ANY);
669
670 for (wmJob &wm_job : wm->runtime->jobs) {
671 if (owner && wm_job.owner != owner) {
672 continue;
673 }
674 if (wm_job.job_type == job_type) {
675 if (wm_job.running) {
676 wm_job.worker_status.stop = true;
677 }
678 }
679 }
680}
681
683{
684 for (wmJob &wm_job : wm->runtime->jobs) {
685 if (wm_job.owner == owner) {
686 if (wm_job.running) {
687 wm_job.worker_status.stop = true;
688 }
689 }
690 }
691}
692
694{
695 wmJob *wm_job = static_cast<wmJob *>(BLI_findptr(&wm->runtime->jobs, wt, offsetof(wmJob, wt)));
696 if (wm_job) {
697 wm_jobs_kill_job(wm, wm_job);
698 }
699}
700
702{
703 if (job.update) {
704 job.update(job.run_customdata);
705 }
706
707 if (job.note) {
708 WM_event_add_notifier_ex(wm, job.win, job.note, nullptr);
709 }
710
711 if (job.flag & WM_JOB_PROGRESS) {
712 WM_event_add_notifier_ex(wm, job.win, NC_WM | ND_JOB, nullptr);
713 }
714
715 job.worker_status.do_update = false;
716}
717
719{
720 wmJob *wm_job = static_cast<wmJob *>(BLI_findptr(&wm->runtime->jobs, wt, offsetof(wmJob, wt)));
721
722 if (wm_job) {
723 /* Running threads. */
724 if (wm_job->threads.first()) {
725 /* Let threads get temporary lock over main thread if needed. */
727
728 if (wm_job->timer_step) {
729 wm_job->timer_step(wm_job->run_customdata);
730 }
731
732 if (wm_job->worker_status.do_update) {
733 wm_job_update(wm, *wm_job);
734 }
735 }
736 else if (wm_job->suspended) {
737 WM_jobs_start(wm, wm_job);
738 }
739
740 /* Move pending reports generated by the worker thread to the WM main list. */
741 if (wm_job) {
742 wm_jobs_reports_update(wm, wm_job);
743 }
744 }
745
746 /* Update progress bars in windows. */
748}
749
751{
753 for (wmJob &job : wm->runtime->jobs.items_reversed_mutable()) {
754 if (!job.threads.first()) {
755 continue;
756 }
757
758 /* Let threads get temporary lock over main thread if needed. */
760
761 /* Job not yet finished. */
762 if (!job.ready) {
763 continue;
764 }
765
766 wm_job_update(wm, job);
767 wm_job_end(wm, &job);
768
769 /* Free owned data. */
770 job.run_free(job.run_customdata);
771 job.run_customdata = nullptr;
772 job.run_free = nullptr;
773
774 if (G.debug & G_DEBUG_JOBS) {
775 printf(
776 "Job '%s' finished in %f seconds\n", job.name, BLI_time_now_seconds() - job.start_time);
777 }
778
779 job.running = false;
780
782 BLI_threadpool_end(&job.threads);
784
785 if (job.endnote) {
786 WM_event_add_notifier_ex(wm, job.win, job.endnote, nullptr);
787 }
788
789 WM_event_add_notifier_ex(wm, job.win, NC_WM | ND_JOB, nullptr);
790
791 /* New job added for wm_job? */
792 if (job.customdata) {
793 // printf("job restarted with new data %s\n", job.name);
794 WM_jobs_start(wm, &job);
795 }
796 else {
797 WM_event_timer_remove(wm, job.win, job.wt);
798 job.wt = nullptr;
799
800 /* Remove wm_job. */
801 wm_job_free(wm, &job);
802 }
803 }
804
805 /* Update progress bars in windows. */
807}
808
809bool WM_jobs_has_running(const wmWindowManager *window_manager,
810 const void *owner,
811 const eWM_JobType type,
812 const eWM_JobFlag exclude_flags)
813{
814 for (const wmJob &job : window_manager->runtime->jobs) {
815 if (owner && job.owner != owner) {
816 continue;
817 }
818
819 if (!ELEM(type, WM_JOB_TYPE_ANY, job.job_type)) {
820 continue;
821 }
822
823 if (job.flag & exclude_flags) {
824 continue;
825 }
826
827 if (job.running || job.suspended) {
828 return true;
829 }
830 }
831
832 return false;
833}
834
835} // namespace blender
Platform independent time functions.
Compatibility-like things for windows.
Read Blender memory allocation and freeing.
#define C
Definition RandGen.cpp:29
#define ND_JOB
Definition WM_types.hh:432
#define NC_WM
Definition WM_types.hh:387
#define UNUSED_VARS(...)
#define ELEM(...)
#define BLI_assert_msg(a, msg)
#define offsetof(t, d)
void free(Subdiv *subdiv)
Definition subdiv.cc:192
void prefetch_stop_all()
Definition prefetch.cc:327
BMesh Iterators.
void * BLI_findptr(const ListBase *listbase, const void *ptr, int offset) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:710
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
char * STRNCPY(char(&dst)[N], const char *src)
void WM_jobs_kill_all_from_owner(wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:657
void WM_event_add_notifier_ex(wmWindowManager *wm, const wmWindow *win, uint type, void *reference)
static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:588
@ RPT_WARNING
Definition BKE_report.hh:40
void WM_job_main_thread_lock_acquire(wmJob *wm_job)
Definition wm_jobs.cc:162
void BLI_ticket_mutex_lock(TicketMutex *ticket)
Definition threads.cc:555
void WM_jobs_callbacks(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *))
Definition wm_jobs.cc:407
void WM_jobs_delay_start(wmJob *wm_job, double delay_time)
Definition wm_jobs.cc:402
void WM_jobs_kill_all_except(wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:633
void WM_jobs_stop_type(wmWindowManager *wm, const void *owner, eWM_JobType job_type)
Definition wm_jobs.cc:666
unsigned int uint
Definition BKE_text.h:55
void BKE_reports_free(ReportList *reports)
Definition report.cc:106
void BKE_report_print_level_set(ReportList *reports, eReportType level)
Definition report.cc:276
void BKE_reports_init(ReportList *reports, int flag)
Definition report.cc:91
@ WM_JOB_TYPE_ANY
Definition WM_api.hh:2008
void BLI_threadpool_insert(ListBaseT< ThreadSlot > *threadbase, void *callerdata)
Definition threads.cc:189
void BLI_threadpool_end(ListBaseT< ThreadSlot > *threadbase)
Definition threads.cc:239
void WM_progress_clear(wmWindow *win)
void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void(*free)(void *customdata))
Definition wm_jobs.cc:377
static void wm_jobs_update_qos(const wmWindowManager *wm)
Definition wm_jobs.cc:180
@ WM_JOB_PRIORITY
Definition WM_api.hh:1990
@ WM_JOB_EXCL_RENDER
Definition WM_api.hh:1995
@ WM_JOB_PROGRESS
Definition WM_api.hh:1997
static void wm_job_end(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:552
bool WM_jobs_progress_test(const wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:264
void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:498
Global G
Definition blender.cc:57
void * WM_jobs_customdata_get(wmJob *wm_job)
Definition wm_jobs.cc:369
void(*)(void *custom_data, wmJobWorkerStatus *worker_status) wm_jobs_start_callback
Definition WM_api.hh:2094
void WM_jobs_callbacks_ex(wmJob *wm_job, wm_jobs_start_callback startjob, void(*initjob)(void *), void(*update)(void *), void(*endjob)(void *), void(*completed)(void *), void(*canceled)(void *))
Definition wm_jobs.cc:416
const char * WM_jobs_name(const wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:336
void * MEM_new_zeroed(size_t len, const char *str) ATTR_WARN_UNUSED_RESULT ATTR_ALLOC_SIZE(1) ATTR_NONNULL(2)
static void wm_jobs_update_progress_bars(wmWindowManager *wm)
Definition wm_jobs.cc:295
static void wm_jobs_test_suspend_stop(wmWindowManager *wm, wmJob *test)
Definition wm_jobs.cc:448
void BLI_remlink(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:138
bool WM_jobs_has_running(const wmWindowManager *window_manager, const void *owner, const eWM_JobType type, const eWM_JobFlag exclude_flags)
Definition wm_jobs.cc:809
void WM_progress_set(wmWindow *win, float progress)
wmWindowManager * CTX_wm_manager(const bContext *C)
TicketMutex * BLI_ticket_mutex_alloc()
Definition threads.cc:513
void BLI_ticket_mutex_free(TicketMutex *ticket)
Definition threads.cc:523
int BLI_thread_is_main()
Definition threads.cc:184
void BLI_ticket_mutex_unlock(TicketMutex *ticket)
Definition threads.cc:565
void wm_jobs_timer(wmWindowManager *wm, wmTimer *wt)
Definition wm_jobs.cc:718
void WM_jobs_kill_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:642
void BLI_addtail(ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition listbase.cc:118
void WM_reports_from_reports_move(wmWindowManager *wm, ReportList *reports)
void BLI_windows_process_set_qos(QoSMode qos_mode, QoSPrecedence qos_precedence)
static void wm_job_free(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:573
wmJob * WM_jobs_get(wmWindowManager *wm, wmWindow *win, const void *owner, const char *name, const eWM_JobFlag flag, const eWM_JobType job_type)
Definition wm_jobs.cc:228
static wmJob * wm_job_find(const wmWindowManager *wm, const void *owner, const eWM_JobType job_type)
Definition wm_jobs.cc:199
static void wm_jobs_reports_update(wmWindowManager *wm, wmJob *wm_job)
Definition wm_jobs.cc:432
double BLI_time_now_seconds()
Definition time.cc:30
void WM_event_timer_remove(wmWindowManager *wm, wmWindow *, wmTimer *timer)
void WM_job_main_thread_lock_release(wmJob *wm_job)
Definition wm_jobs.cc:167
void WM_jobs_kill_all(wmWindowManager *wm)
Definition wm_jobs.cc:621
wmTimer * WM_event_timer_add(wmWindowManager *wm, wmWindow *win, const wmEventType event_type, const double time_step)
bool WM_jobs_is_stopped(const wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:363
static void wm_job_update(wmWindowManager *wm, wmJob &job)
Definition wm_jobs.cc:701
void WM_jobs_stop_all_from_owner(wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:682
void wm_jobs_timer_end(wmWindowManager *wm, wmTimer *wt)
Definition wm_jobs.cc:693
static void * do_job_thread(void *job_v)
Definition wm_jobs.cc:437
void WM_jobs_timer(wmJob *wm_job, double time_step, uint note, uint endnote, void(*timer_step)(void *))
Definition wm_jobs.cc:393
void BLI_threadpool_init(ListBaseT< ThreadSlot > *threadbase, void *(*do_thread)(void *), int tot)
Definition threads.cc:123
float WM_jobs_progress(const wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:284
bool WM_jobs_is_running(const wmJob *wm_job)
Definition wm_jobs.cc:358
static void wm_job_main_thread_yield(wmJob *wm_job)
Definition wm_jobs.cc:172
void wm_jobs_handle_finished(const bContext *C)
Definition wm_jobs.cc:750
double WM_jobs_starttime(const wmWindowManager *wm, const void *owner)
Definition wm_jobs.cc:325
void * WM_jobs_customdata_from_type(wmWindowManager *wm, const void *owner, int job_type)
Definition wm_jobs.cc:347
ListBaseT< Report > list
Definition BKE_report.hh:79
void(*) update(void *)
Definition wm_jobs.cc:90
void(*) timer_step(void *)
Definition wm_jobs.cc:102
eWM_JobFlag flag
Definition wm_jobs.cc:134
wmJobWorkerStatus worker_status
Definition wm_jobs.cc:139
const void * owner
Definition wm_jobs.cc:133
TicketMutex * main_thread_mutex
Definition wm_jobs.cc:157
void(*) canceled(void *)
Definition wm_jobs.cc:122
double start_delay_time
Definition wm_jobs.cc:128
wmWindow * win
Definition wm_jobs.cc:72
eWM_JobType job_type
Definition wm_jobs.cc:136
double time_step
Definition wm_jobs.cc:125
void(*) run_free(void *)
Definition wm_jobs.cc:146
double start_time
Definition wm_jobs.cc:151
void * customdata
Definition wm_jobs.cc:75
wmJob * prev
Definition wm_jobs.cc:69
ListBaseT< ThreadSlot > threads
Definition wm_jobs.cc:149
void(*) initjob(void *)
Definition wm_jobs.cc:80
void(*) free(void *)
Definition wm_jobs.cc:107
wmTimer * wt
Definition wm_jobs.cc:126
wmJob * next
Definition wm_jobs.cc:69
wm_jobs_start_callback startjob
Definition wm_jobs.cc:85
char name[128]
Definition wm_jobs.cc:142
void(*) endjob(void *)
Definition wm_jobs.cc:112
void(*) completed(void *)
Definition wm_jobs.cc:117
void * run_customdata
Definition wm_jobs.cc:145
bke::WindowManagerRuntime * runtime