COM_ExecutionGroup.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Copyright 2011, Blender Foundation.
 */
 
#pragma once
 
#ifdef WITH_CXX_GUARDEDALLOC
#  include "MEM_guardedalloc.h"
#endif
 
#include "BLI_array.hh"
#include "BLI_rect.h"
#include "BLI_vector.hh"
 
#include "COM_CompositorContext.h"
#include "COM_Device.h"
#include "COM_MemoryProxy.h"
#include "COM_Node.h"
#include "COM_NodeOperation.h"
#include "COM_WorkPackage.h"
#include <vector>
 
namespace blender::compositor {
 
class ExecutionSystem;
class MemoryProxy;
class MemoryBuffer;
class ReadBufferOperation;
class Device;
 
struct ExecutionGroupFlags {
  bool initialized : 1;
  bool is_output : 1;
  bool complex : 1;
 
  bool open_cl : 1;
 
  bool single_threaded : 1;
 
  ExecutionGroupFlags()
  {
    initialized = false;
    is_output = false;
    complex = false;
    open_cl = false;
    single_threaded = false;
  }
};
 
std::ostream &operator<<(std::ostream &os, const ExecutionGroupFlags &flags);
 
class ExecutionGroup {
 private:
  // fields
  int m_id;
 
  Vector<NodeOperation *> m_operations;
 
  ExecutionGroupFlags m_flags;
 
  unsigned int m_width;
 
  unsigned int m_height;
 
  unsigned int m_chunkSize;
 
  unsigned int m_x_chunks_len;
 
  unsigned int m_y_chunks_len;
 
  unsigned int m_chunks_len;
 
  unsigned int m_max_read_buffer_offset;
 
  Vector<ReadBufferOperation *> m_read_operations;
 
  const bNodeTree *m_bTree;
 
  unsigned int m_chunks_finished;
 
  Vector<WorkPackage> m_work_packages;
 
  rcti m_viewerBorder;
 
  double m_executionStartTime;
 
  // methods
  bool can_contain(NodeOperation &operation);
 
  void determineChunkRect(rcti *r_rect,
                          const unsigned int xChunk,
                          const unsigned int yChunk) const;
 
  void init_number_of_chunks();
 
  bool scheduleChunkWhenPossible(ExecutionSystem *graph, const int chunk_x, const int chunk_y);
 
  bool scheduleAreaWhenPossible(ExecutionSystem *graph, rcti *area);
 
  bool scheduleChunk(unsigned int chunkNumber);
 
  void determineDependingAreaOfInterest(rcti *input,
                                        ReadBufferOperation *readOperation,
                                        rcti *output);
 
  blender::Array<unsigned int> get_execution_order() const;
 
  void init_read_buffer_operations();
  void init_work_packages();
 
 public:
  // constructors
  ExecutionGroup(int id);
 
  int get_id() const
  {
    return m_id;
  }
 
  const ExecutionGroupFlags get_flags() const
  {
    return m_flags;
  }
 
  // methods
  bool addOperation(NodeOperation *operation);
 
  void setOutputExecutionGroup(bool is_output)
  {
    this->m_flags.is_output = is_output;
  }
 
  void determineResolution(unsigned int resolution[2]);
 
  void setResolution(unsigned int resolution[2])
  {
    this->m_width = resolution[0];
    this->m_height = resolution[1];
  }
 
  unsigned int getWidth() const
  {
    return m_width;
  }
 
  unsigned int getHeight() const
  {
    return m_height;
  }
 
  NodeOperation *getOutputOperation() const;
 
  MemoryBuffer *constructConsolidatedMemoryBuffer(MemoryProxy &memoryProxy, rcti &rect);
 
  void initExecution();
 
  MemoryBuffer **getInputBuffersCPU();
 
  MemoryBuffer **getInputBuffersOpenCL(int chunkNumber);
 
  MemoryBuffer *allocateOutputBuffer(rcti &rect);
 
  void finalizeChunkExecution(int chunkNumber, MemoryBuffer **memoryBuffers);
 
  void deinitExecution();
 
  void execute(ExecutionSystem *graph);
 
  void determineChunkRect(rcti *r_rect, const unsigned int chunkNumber) const;
 
  void setChunksize(int chunksize)
  {
    this->m_chunkSize = chunksize;
  }
 
  eCompositorPriority getRenderPriority();
 
  void setViewerBorder(float xmin, float xmax, float ymin, float ymax);
 
  void setRenderBorder(float xmin, float xmax, float ymin, float ymax);
 
  /* allow the DebugInfo class to look at internals */
  friend class DebugInfo;
 
#ifdef WITH_CXX_GUARDEDALLOC
  MEM_CXX_CLASS_ALLOC_FUNCS("COM:ExecutionGroup")
#endif
};
 
std::ostream &operator<<(std::ostream &os, const ExecutionGroup &execution_group);
 
}  // namespace blender::compositor