intern/cycles/util/util_task.h

   1 /*
   2  * Copyright 2011, Blender Foundation.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software Foundation,
  16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  */
  18
  19 #ifndef __UTIL_TASK_H__
  20 #define __UTIL_TASK_H__
  21
  22 #include "util_list.h"
  23 #include "util_thread.h"
  24 #include "util_vector.h"
  25
  26 CCL_NAMESPACE_BEGIN
  27
  28 class Task;
  29 class TaskPool;
  30 class TaskScheduler;
  31
  32 typedef boost::function<void(void)> TaskRunFunction;
  33
  34 /* Task
  35  *
  36  * Base class for tasks to be executed in threads. */
  37
  38 class Task
  39 {
  40 public:
  41         Task() {};
  42         Task(const TaskRunFunction& run_) : run(run_) {}
  43
  44         virtual ~Task() {}
  45
  46         TaskRunFunction run;
  47 };
  48
  49 /* Task Pool
  50  *
  51  * Pool of tasks that will be executed by the central TaskScheduler.For each
  52  * pool, we can wait for all tasks to be done, or cancel them before they are
  53  * done.
  54  *
  55  * The run callback that actually executes the task may be create like this:
  56  * function_bind(&MyClass::task_execute, this, _1, _2) */
  57
  58 class TaskPool
  59 {
  60 public:
  61         TaskPool();
  62         ~TaskPool();
  63
  64         void push(Task *task, bool front = false);
  65         void push(const TaskRunFunction& run, bool front = false);
  66
  67         void wait_work();       /* work and wait until all tasks are done */
  68         void cancel();          /* cancel all tasks, keep worker threads running */
  69         void stop();            /* stop all worker threads */
  70
  71         bool cancelled();       /* for worker threads, test if cancelled */
  72
  73 protected:
  74         friend class TaskScheduler;
  75
  76         void num_decrease(int done);
  77         void num_increase();
  78
  79         thread_mutex num_mutex;
  80         thread_condition_variable num_cond;
  81
  82         volatile int num;
  83         volatile bool do_cancel;
  84 };
  85
  86 /* Task Scheduler
  87  *
  88  * Central scheduler that holds running threads ready to execute tasks. A singe
  89  * queue holds the task from all pools. */
  90
  91 class TaskScheduler
  92 {
  93 public:
  94         static void init(int num_threads = 0);
  95         static void exit();
  96
  97         /* number of threads that can work on tasks, main thread counts too */
  98         static int num_threads() { return threads.size() + 1; }
  99
 100         /* test if any session is using the scheduler */
 101         static bool active() { return users != 0; }
 102
 103 protected:
 104         friend class TaskPool;
 105
 106         struct Entry {
 107                 Task *task;
 108                 TaskPool *pool;
 109         };
 110
 111         static thread_mutex mutex;
 112         static int users;
 113         static vector<thread*> threads;
 114         static vector<int> thread_level;
 115         static volatile bool do_exit;
 116
 117         static list<Entry> queue;
 118         static thread_mutex queue_mutex;
 119         static thread_condition_variable queue_cond;
 120
 121         static void thread_run(int thread_id);
 122         static bool thread_wait_pop(Entry& entry);
 123
 124         static void push(Entry& entry, bool front);
 125         static void clear(TaskPool *pool);
 126 };
 127
 128 CCL_NAMESPACE_END
 129
 130 #endif
 131