progress.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
 *
 * SPDX-License-Identifier: Apache-2.0 */
 
#pragma once
 
#include <functional>
 
/* Progress
 *
 * Simple class to communicate progress status messages, timing information,
 * update notifications from a job running in another thread. All methods
 * except for the constructor/destructor are thread safe. */
 
#include "util/string.h"
#include "util/thread.h"
#include "util/time.h"
 
CCL_NAMESPACE_BEGIN
 
class Progress {
 public:
  Progress()
  {
    start_time = time_dt();
    render_start_time = time_dt();
    status = "Initializing";
  }
 
  Progress(Progress &progress)
  {
    *this = progress;
  }
 
  Progress &operator=(Progress &progress)
  {
    const thread_scoped_lock lock(progress.progress_mutex);
 
    progress.get_status(status, substatus);
 
    pixel_samples = progress.pixel_samples;
    total_pixel_samples = progress.total_pixel_samples;
    current_tile_sample = progress.get_current_sample();
 
    return *this;
  }
 
  void reset()
  {
    pixel_samples = 0;
    total_pixel_samples = 0;
    current_tile_sample = 0;
    rendered_tiles = 0;
    denoised_tiles = 0;
    start_time = time_dt();
    render_start_time = time_dt();
    time_limit = 0.0;
    end_time = 0.0;
    status = "Initializing";
    substatus = "";
    sync_status = "";
    sync_substatus = "";
    cancel = false;
    cancel_message = "";
    error = false;
    error_message = "";
  }
 
  /* cancel */
  void set_cancel(const string &cancel_message_)
  {
    const thread_scoped_lock lock(progress_mutex);
    cancel_message = cancel_message_;
    cancel = true;
  }
 
  bool get_cancel() const
  {
    if (!cancel && cancel_cb) {
      cancel_cb();
    }
 
    return cancel;
  }
 
  string get_cancel_message() const
  {
    const thread_scoped_lock lock(progress_mutex);
    return cancel_message;
  }
 
  void set_cancel_callback(std::function<void()> function)
  {
    cancel_cb = function;
  }
 
  /* error */
  void set_error(const string &error_message_)
  {
    const thread_scoped_lock lock(progress_mutex);
    error_message = error_message_;
    error = true;
    /* If error happens we also stop rendering. */
    cancel_message = error_message_;
    cancel = true;
  }
 
  bool get_error() const
  {
    return error;
  }
 
  string get_error_message() const
  {
    const thread_scoped_lock lock(progress_mutex);
    return error_message;
  }
 
  /* tile and timing information */
 
  void set_start_time()
  {
    const thread_scoped_lock lock(progress_mutex);
 
    start_time = time_dt();
    end_time = 0.0;
  }
 
  void set_render_start_time()
  {
    const thread_scoped_lock lock(progress_mutex);
 
    render_start_time = time_dt();
  }
 
  void set_time_limit(const double time_limit_)
  {
    const thread_scoped_lock lock(progress_mutex);
 
    time_limit = time_limit_;
  }
 
  void add_skip_time(const scoped_timer &start_timer, bool only_render)
  {
    const double skip_time = time_dt() - start_timer.get_start();
 
    render_start_time += skip_time;
    if (!only_render) {
      start_time += skip_time;
    }
  }
 
  void get_time(double &total_time_, double &render_time_) const
  {
    const thread_scoped_lock lock(progress_mutex);
 
    const double time = (end_time > 0) ? end_time : time_dt();
 
    total_time_ = time - start_time;
    render_time_ = time - render_start_time;
  }
 
  void set_end_time()
  {
    end_time = time_dt();
  }
 
  void reset_sample()
  {
    const thread_scoped_lock lock(progress_mutex);
 
    pixel_samples = 0;
    current_tile_sample = 0;
    rendered_tiles = 0;
    denoised_tiles = 0;
  }
 
  void set_total_pixel_samples(const uint64_t total_pixel_samples_)
  {
    const thread_scoped_lock lock(progress_mutex);
 
    total_pixel_samples = total_pixel_samples_;
  }
 
  double get_progress() const
  {
    const thread_scoped_lock lock(progress_mutex);
 
    if (pixel_samples > 0) {
      double progress_percent = (double)pixel_samples / (double)total_pixel_samples;
      if (time_limit != 0.0) {
        const double time_since_render_start = time_dt() - render_start_time;
        progress_percent = fmax(progress_percent, time_since_render_start / time_limit);
      }
      return fmin(1.0, progress_percent);
    }
    return 0.0;
  }
 
  void add_samples(const uint64_t pixel_samples_, int tile_sample)
  {
    const thread_scoped_lock lock(progress_mutex);
 
    pixel_samples += pixel_samples_;
    current_tile_sample = tile_sample;
  }
 
  void add_samples_update(const uint64_t pixel_samples_, int tile_sample)
  {
    add_samples(pixel_samples_, tile_sample);
    set_update();
  }
 
  void add_finished_tile(bool denoised)
  {
    const thread_scoped_lock lock(progress_mutex);
 
    if (denoised) {
      denoised_tiles++;
    }
    else {
      rendered_tiles++;
    }
  }
 
  int get_current_sample() const
  {
    const thread_scoped_lock lock(progress_mutex);
    /* Note that the value here always belongs to the last tile that updated,
     * so it's only useful if there is only one active tile. */
    return current_tile_sample;
  }
 
  int get_rendered_tiles() const
  {
    const thread_scoped_lock lock(progress_mutex);
    return rendered_tiles;
  }
 
  int get_denoised_tiles() const
  {
    const thread_scoped_lock lock(progress_mutex);
    return denoised_tiles;
  }
 
  /* status messages */
 
  void set_status(const string &status_, const string &substatus_ = "")
  {
    {
      const thread_scoped_lock lock(progress_mutex);
      status = status_;
      substatus = substatus_;
    }
 
    set_update();
  }
 
  void set_substatus(const string &substatus_)
  {
    {
      const thread_scoped_lock lock(progress_mutex);
      substatus = substatus_;
    }
 
    set_update();
  }
 
  void set_sync_status(const string &status_, const string &substatus_ = "")
  {
    {
      const thread_scoped_lock lock(progress_mutex);
      sync_status = status_;
      sync_substatus = substatus_;
    }
 
    set_update();
  }
 
  void set_sync_substatus(const string &substatus_)
  {
    {
      const thread_scoped_lock lock(progress_mutex);
      sync_substatus = substatus_;
    }
 
    set_update();
  }
 
  void get_status(string &status_, string &substatus_) const
  {
    const thread_scoped_lock lock(progress_mutex);
 
    if (!sync_status.empty()) {
      status_ = sync_status;
      substatus_ = sync_substatus;
    }
    else {
      status_ = status;
      substatus_ = substatus;
    }
  }
 
  /* callback */
 
  void set_update()
  {
    if (update_cb) {
      const thread_scoped_lock lock(update_mutex);
      update_cb();
    }
  }
 
  void set_update_callback(std::function<void()> function)
  {
    update_cb = function;
  }
 
 protected:
  mutable thread_mutex progress_mutex;
  mutable thread_mutex update_mutex;
  std::function<void()> update_cb = nullptr;
  std::function<void()> cancel_cb = nullptr;
 
  /* pixel_samples counts how many samples have been rendered over all pixel, not just per pixel.
   * This makes the progress estimate more accurate when tiles with different sizes are used.
   *
   * total_pixel_samples is the total amount of pixel samples that will be rendered. */
  uint64_t pixel_samples = 0, total_pixel_samples = 0;
  /* Stores the current sample count of the last tile that called the update function.
   * It's used to display the sample count if only one tile is active. */
  int current_tile_sample = 0;
  /* Stores the number of tiles that's already finished.
   * Used to determine whether all but the last tile are finished rendering,
   * in which case the current_tile_sample is displayed. */
  int rendered_tiles = 0, denoised_tiles = 0;
 
  double start_time = 0.0, render_start_time = 0.0, time_limit = 0.0;
  /* End time written when render is done, so it doesn't keep increasing on redraws. */
  double end_time = 0.0;
 
  string status;
  string substatus;
 
  string sync_status;
  string sync_substatus;
 
  volatile bool cancel = false;
  string cancel_message;
 
  volatile bool error = false;
  string error_message;
};
 
CCL_NAMESPACE_END