COM_ExecutionSystem.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <functional>
 
#include "atomic_ops.h"
 
#include "BLI_index_range.hh"
#include "BLI_threads.h"
#include "BLI_vector.hh"
 
#include "COM_CompositorContext.h"
#include "COM_SharedOperationBuffers.h"
 
#include "DNA_color_types.h"
#include "DNA_node_types.h"
#include "DNA_scene_types.h"
#include "DNA_vec_types.h"
 
namespace blender::realtime_compositor {
class RenderContext;
class Profiler;
}  // namespace blender::realtime_compositor
 
namespace blender::compositor {
 
/* Forward declarations. */
class ExecutionModel;
class NodeOperation;
 
class ExecutionSystem {
 private:
  SharedOperationBuffers active_buffers_;
 
  CompositorContext context_;
 
  Vector<NodeOperation *> operations_;
 
  ExecutionModel *execution_model_;
 
  int num_work_threads_;
 
  ThreadMutex work_mutex_;
  ThreadCondition work_finished_cond_;
 
 public:
  ExecutionSystem(RenderData *rd,
                  Scene *scene,
                  bNodeTree *editingtree,
                  bool rendering,
                  const char *view_name,
                  realtime_compositor::RenderContext *render_context,
                  realtime_compositor::Profiler *profiler);
 
  ~ExecutionSystem();
 
  void set_operations(Span<NodeOperation *> operations);
 
  void execute();
 
  const CompositorContext &get_context() const
  {
    return context_;
  }
 
  void execute_work(const rcti &work_rect, std::function<void(const rcti &split_rect)> work_func);
 
  template<typename TResult>
  void execute_work(const rcti &work_rect,
                    std::function<TResult(const rcti &split_rect)> work_func,
                    TResult &join,
                    std::function<void(TResult &join, const TResult &chunk)> reduce_func)
  {
    Array<TResult> chunks(num_work_threads_);
    int num_started = 0;
    execute_work(work_rect, [&](const rcti &split_rect) {
      const int current = atomic_fetch_and_add_int32(&num_started, 1);
      chunks[current] = work_func(split_rect);
    });
    for (const int i : IndexRange(num_started)) {
      reduce_func(join, chunks[i]);
    }
  }
 
  bool is_breaked() const;
 
 private:
  /* allow the DebugInfo class to look at internals */
  friend class DebugInfo;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:ExecutionSystem")
#endif
};
 
}  // namespace blender::compositor