Cleanup: Set execution system as operations member in Compositor

source/blender/compositor/intern/COM_ExecutionSystem.cc

@@ -101,6 +101,9 @@ void ExecutionSystem::set_operations(const Vector<NodeOperation *> &operations,
 {
   m_operations = operations;
   m_groups = groups;
+  for (NodeOperation *op : m_operations) {
+    op->set_execution_system(this);
+  }
 }
 
 void ExecutionSystem::execute()

source/blender/compositor/intern/COM_FullFrameExecutionModel.cc

@@ -63,7 +63,7 @@ void FullFrameExecutionModel::execute(ExecutionSystem &exec_system)
   DebugInfo::graphviz(&exec_system);
 
   determine_areas_to_render_and_reads();
-  render_operations(exec_system);
+  render_operations();
 }
 
 void FullFrameExecutionModel::determine_areas_to_render_and_reads()
@@ -107,14 +107,14 @@ MemoryBuffer *FullFrameExecutionModel::create_operation_buffer(NodeOperation *op
   return new MemoryBuffer(data_type, op_rect, is_a_single_elem);
 }
 
-void FullFrameExecutionModel::render_operation(NodeOperation *op, ExecutionSystem &exec_system)
+void FullFrameExecutionModel::render_operation(NodeOperation *op)
 {
   Vector<MemoryBuffer *> input_bufs = get_input_buffers(op);
 
   const bool has_outputs = op->getNumberOfOutputSockets() > 0;
   MemoryBuffer *op_buf = has_outputs ? create_operation_buffer(op) : nullptr;
   Span<rcti> areas = active_buffers_.get_areas_to_render(op);
-  op->render(op_buf, areas, input_bufs, exec_system);
+  op->render(op_buf, areas, input_bufs);
   active_buffers_.set_rendered_buffer(op, std::unique_ptr<MemoryBuffer>(op_buf));
 
   operation_finished(op);
@@ -123,7 +123,7 @@ void FullFrameExecutionModel::render_operation(NodeOperation *op, ExecutionSyste
 /**
  * Render output operations in order of priority.
  */
-void FullFrameExecutionModel::render_operations(ExecutionSystem &exec_system)
+void FullFrameExecutionModel::render_operations()
 {
   const bool is_rendering = context_.isRendering();
 
@@ -131,8 +131,8 @@ void FullFrameExecutionModel::render_operations(ExecutionSystem &exec_system)
   for (eCompositorPriority priority : priorities_) {
     for (NodeOperation *op : operations_) {
       if (op->isOutputOperation(is_rendering) && op->getRenderPriority() == priority) {
-        render_output_dependencies(op, exec_system);
+        render_output_dependencies(op);
-        render_operation(op, exec_system);
+        render_operation(op);
       }
     }
   }
@@ -166,14 +166,13 @@ static Vector<NodeOperation *> get_operation_dependencies(NodeOperation *operati
   return dependencies;
 }
 
-void FullFrameExecutionModel::render_output_dependencies(NodeOperation *output_op,
+void FullFrameExecutionModel::render_output_dependencies(NodeOperation *output_op)
-                                                         ExecutionSystem &exec_system)
 {
   BLI_assert(output_op->isOutputOperation(context_.isRendering()));
   Vector<NodeOperation *> dependencies = get_operation_dependencies(output_op);
   for (NodeOperation *op : dependencies) {
     if (!active_buffers_.is_operation_rendered(op)) {
-      render_operation(op, exec_system);
+      render_operation(op);
     }
   }
 }

source/blender/compositor/intern/COM_FullFrameExecutionModel.h

@@ -66,11 +66,11 @@ class FullFrameExecutionModel : public ExecutionModel {
 
  private:
   void determine_areas_to_render_and_reads();
-  void render_operations(ExecutionSystem &exec_system);
+  void render_operations();
-  void render_output_dependencies(NodeOperation *output_op, ExecutionSystem &exec_system);
+  void render_output_dependencies(NodeOperation *output_op);
   Vector<MemoryBuffer *> get_input_buffers(NodeOperation *op);
   MemoryBuffer *create_operation_buffer(NodeOperation *op);
-  void render_operation(NodeOperation *op, ExecutionSystem &exec_system);
+  void render_operation(NodeOperation *op);
 
   void operation_finished(NodeOperation *operation);
 

source/blender/compositor/intern/COM_MultiThreadedOperation.cc

@@ -12,12 +12,11 @@ MultiThreadedOperation::MultiThreadedOperation()
 
 void MultiThreadedOperation::update_memory_buffer(MemoryBuffer *output,
                                                   const rcti &area,
-                                                  Span<MemoryBuffer *> inputs,
+                                                  Span<MemoryBuffer *> inputs)
-                                                  ExecutionSystem &exec_system)
 {
   for (current_pass_ = 0; current_pass_ < num_passes_; current_pass_++) {
     update_memory_buffer_started(output, area, inputs);
-    exec_system.execute_work(area, [=](const rcti &split_rect) {
+    exec_system_->execute_work(area, [=](const rcti &split_rect) {
       update_memory_buffer_partial(output, split_rect, inputs);
     });
     update_memory_buffer_finished(output, area, inputs);

source/blender/compositor/intern/COM_MultiThreadedOperation.h

@@ -64,8 +64,7 @@ class MultiThreadedOperation : public NodeOperation {
  private:
   void update_memory_buffer(MemoryBuffer *output,
                             const rcti &area,
-                            Span<MemoryBuffer *> inputs,
+                            Span<MemoryBuffer *> inputs) override;
-                            ExecutionSystem &exec_system) override;
 };
 
 }  // namespace blender::compositor

source/blender/compositor/intern/COM_NodeOperation.cc

@@ -226,18 +226,16 @@ void NodeOperation::get_area_of_interest(NodeOperation *input_op,
  * \param output_buf: Buffer to write result to.
  * \param areas: Areas within this operation bounds to render.
  * \param inputs_bufs: Inputs operations buffers.
- * \param exec_system: Execution system.
  */
 void NodeOperation::render(MemoryBuffer *output_buf,
                            Span<rcti> areas,
-                           Span<MemoryBuffer *> inputs_bufs,
+                           Span<MemoryBuffer *> inputs_bufs)
-                           ExecutionSystem &exec_system)
 {
   if (get_flags().is_fullframe_operation) {
-    render_full_frame(output_buf, areas, inputs_bufs, exec_system);
+    render_full_frame(output_buf, areas, inputs_bufs);
   }
   else {
-    render_full_frame_fallback(output_buf, areas, inputs_bufs, exec_system);
+    render_full_frame_fallback(output_buf, areas, inputs_bufs);
   }
 }
 
@@ -246,12 +244,11 @@ void NodeOperation::render(MemoryBuffer *output_buf,
  */
 void NodeOperation::render_full_frame(MemoryBuffer *output_buf,
                                       Span<rcti> areas,
-                                      Span<MemoryBuffer *> inputs_bufs,
+                                      Span<MemoryBuffer *> inputs_bufs)
-                                      ExecutionSystem &exec_system)
 {
   initExecution();
   for (const rcti &area : areas) {
-    update_memory_buffer(output_buf, area, inputs_bufs, exec_system);
+    update_memory_buffer(output_buf, area, inputs_bufs);
   }
   deinitExecution();
 }
@@ -261,8 +258,7 @@ void NodeOperation::render_full_frame(MemoryBuffer *output_buf,
  */
 void NodeOperation::render_full_frame_fallback(MemoryBuffer *output_buf,
                                                Span<rcti> areas,
-                                               Span<MemoryBuffer *> inputs_bufs,
+                                               Span<MemoryBuffer *> inputs_bufs)
-                                               ExecutionSystem &exec_system)
 {
   Vector<NodeOperationOutput *> orig_input_links = replace_inputs_with_buffers(inputs_bufs);
 
@@ -274,7 +270,7 @@ void NodeOperation::render_full_frame_fallback(MemoryBuffer *output_buf,
   }
   else {
     for (const rcti &rect : areas) {
-      exec_system.execute_work(rect, [=](const rcti &split_rect) {
+      exec_system_->execute_work(rect, [=](const rcti &split_rect) {
         rcti tile_rect = split_rect;
         if (is_output_operation) {
           executeRegion(&tile_rect, 0);

source/blender/compositor/intern/COM_NodeOperation.h

@@ -316,6 +316,8 @@ class NodeOperation {
    */
   NodeOperationFlags flags;
 
+  ExecutionSystem *exec_system_;
+
  public:
   virtual ~NodeOperation()
   {
@@ -402,6 +404,12 @@ class NodeOperation {
   {
     this->m_btree = tree;
   }
+
+  void set_execution_system(ExecutionSystem *system)
+  {
+    exec_system_ = system;
+  }
+
   virtual void initExecution();
 
   /**
@@ -569,18 +577,14 @@ class NodeOperation {
   /** \name Full Frame Methods
    * \{ */
 
-  void render(MemoryBuffer *output_buf,
+  void render(MemoryBuffer *output_buf, Span<rcti> areas, Span<MemoryBuffer *> inputs_bufs);
-              Span<rcti> areas,
-              Span<MemoryBuffer *> inputs_bufs,
-              ExecutionSystem &exec_system);
 
   /**
    * Executes operation updating output memory buffer. Single-threaded calls.
    */
   virtual void update_memory_buffer(MemoryBuffer *UNUSED(output),
                                     const rcti &UNUSED(area),
-                                    Span<MemoryBuffer *> UNUSED(inputs),
+                                    Span<MemoryBuffer *> UNUSED(inputs))
-                                    ExecutionSystem &UNUSED(exec_system))
   {
   }
 
@@ -678,13 +682,11 @@ class NodeOperation {
 
   void render_full_frame(MemoryBuffer *output_buf,
                          Span<rcti> areas,
-                         Span<MemoryBuffer *> inputs_bufs,
+                         Span<MemoryBuffer *> inputs_bufs);
-                         ExecutionSystem &exec_system);
 
   void render_full_frame_fallback(MemoryBuffer *output_buf,
                                   Span<rcti> areas,
-                                  Span<MemoryBuffer *> inputs,
+                                  Span<MemoryBuffer *> inputs);
-                                  ExecutionSystem &exec_system);
   void render_tile(MemoryBuffer *output_buf, rcti *tile_rect);
   Vector<NodeOperationOutput *> replace_inputs_with_buffers(Span<MemoryBuffer *> inputs_bufs);
   void remove_buffers_and_restore_original_inputs(

source/blender/compositor/operations/COM_SetColorOperation.cc

@@ -44,8 +44,7 @@ void SetColorOperation::determineResolution(unsigned int resolution[2],
 
 void SetColorOperation::update_memory_buffer(MemoryBuffer *output,
                                              const rcti &area,
-                                             Span<MemoryBuffer *> UNUSED(inputs),
+                                             Span<MemoryBuffer *> UNUSED(inputs))
-                                             ExecutionSystem &UNUSED(exec_system))
 {
   BLI_assert(output->is_a_single_elem());
   float *out_elem = output->get_elem(area.xmin, area.ymin);

source/blender/compositor/operations/COM_SetColorOperation.h

@@ -83,8 +83,7 @@ class SetColorOperation : public NodeOperation {
 
   void update_memory_buffer(MemoryBuffer *output,
                             const rcti &area,
-                            Span<MemoryBuffer *> inputs,
+                            Span<MemoryBuffer *> inputs) override;
-                            ExecutionSystem &exec_system) override;
 };
 
 }  // namespace blender::compositor

source/blender/compositor/operations/COM_SetValueOperation.cc

@@ -44,8 +44,7 @@ void SetValueOperation::determineResolution(unsigned int resolution[2],
 
 void SetValueOperation::update_memory_buffer(MemoryBuffer *output,
                                              const rcti &area,
-                                             Span<MemoryBuffer *> UNUSED(inputs),
+                                             Span<MemoryBuffer *> UNUSED(inputs))
-                                             ExecutionSystem &UNUSED(exec_system))
 {
   BLI_assert(output->is_a_single_elem());
   float *out_elem = output->get_elem(area.xmin, area.ymin);

source/blender/compositor/operations/COM_SetValueOperation.h

@@ -53,8 +53,7 @@ class SetValueOperation : public NodeOperation {
                            unsigned int preferredResolution[2]) override;
   void update_memory_buffer(MemoryBuffer *output,
                             const rcti &area,
-                            Span<MemoryBuffer *> inputs,
+                            Span<MemoryBuffer *> inputs) override;
-                            ExecutionSystem &exec_system) override;
 };
 
 }  // namespace blender::compositor