session/session.cpp

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
 *
 * SPDX-License-Identifier: Apache-2.0 */
 
#include <cstring>
 
#include "device/cpu/device.h"
#include "device/device.h"
#include "integrator/path_trace.h"
#include "scene/background.h"
#include "scene/camera.h"
#include "scene/integrator.h"
#include "scene/light.h"
#include "scene/mesh.h"
#include "scene/object.h"
#include "scene/scene.h"
#include "scene/shader_graph.h"
#include "session/buffers.h"
#include "session/display_driver.h"
#include "session/output_driver.h"
#include "session/session.h"
 
#include "util/log.h"
#include "util/math.h"
#include "util/task.h"
#include "util/time.h"
 
CCL_NAMESPACE_BEGIN
 
Session::Session(const SessionParams &params_, const SceneParams &scene_params)
    : params(params_), render_scheduler_(tile_manager_, params)
{
  TaskScheduler::init(params.threads);
 
  delayed_reset_.do_reset = false;
 
  pause_ = false;
  new_work_added_ = false;
 
  device = Device::create(params.device, stats, profiler, params_.headless);
 
  if (device->have_error()) {
    progress.set_error(device->error_message());
  }
 
  scene = make_unique<Scene>(scene_params, device.get());
 
  if (params.device == params.denoise_device) {
    /* Reuse render device. */
  }
  else {
    denoise_device_ = Device::create(params.denoise_device, stats, profiler, params_.headless);
 
    if (denoise_device_->have_error()) {
      progress.set_error(denoise_device_->error_message());
    }
  }
 
  /* Configure path tracer. */
  path_trace_ = make_unique<PathTrace>(device.get(),
                                       denoise_device(),
                                       scene->film,
                                       &scene->dscene,
                                       render_scheduler_,
                                       tile_manager_);
  path_trace_->set_progress(&progress);
  path_trace_->progress_update_cb = [&]() { update_status_time(); };
 
  tile_manager_.full_buffer_written_cb = [&](string_view filename) {
    if (!full_buffer_written_cb) {
      return;
    }
    full_buffer_written_cb(filename);
  };
 
  /* Create session thread. */
  session_thread_ = make_unique<thread>([this] { thread_run(); });
}
 
Session::~Session()
{
  /* Cancel any ongoing render operation. */
  cancel();
 
  /* Signal session thread to end. */
  {
    const thread_scoped_lock session_thread_lock(session_thread_mutex_);
    session_thread_state_ = SESSION_THREAD_END;
  }
  session_thread_cond_.notify_all();
 
  /* Destroy session thread. */
  session_thread_->join();
  session_thread_.reset();
 
  /* Destroy path tracer, before the device. This is needed because destruction might need to
   * access device for device memory free.
   * TODO(sergey): Convert device to be unique_ptr, and rely on C++ to destruct objects in the
   * pre-defined order. */
  path_trace_.reset();
 
  /* Destroy scene and device. */
  scene.reset();
  denoise_device_.reset();
  device.reset();
 
  /* Stop task scheduler. */
  TaskScheduler::exit();
}
 
void Session::start()
{
  {
    /* Signal session thread to start rendering. */
    const thread_scoped_lock session_thread_lock(session_thread_mutex_);
    if (session_thread_state_ == SESSION_THREAD_RENDER) {
      /* Already rendering, nothing to do. */
      return;
    }
    session_thread_state_ = SESSION_THREAD_RENDER;
  }
 
  session_thread_cond_.notify_all();
}
 
void Session::cancel(bool quick)
{
  /* Cancel any long running device operations (e.g. shader compilations). */
  device->cancel();
 
  /* Check if session thread is rendering. */
  const bool rendering = is_session_thread_rendering();
 
  if (rendering) {
    /* Cancel path trace operations. */
    if (quick && path_trace_) {
      path_trace_->cancel();
    }
 
    /* Cancel other operations. */
    progress.set_cancel("Exiting");
 
    /* Signal unpause in case the render was paused. */
    {
      const thread_scoped_lock pause_lock(pause_mutex_);
      pause_ = false;
    }
    pause_cond_.notify_all();
 
    /* Wait for render thread to be cancelled or finished. */
    wait();
  }
}
 
bool Session::ready_to_reset()
{
  return path_trace_->ready_to_reset();
}
 
void Session::run_main_render_loop()
{
  path_trace_->zero_display();
 
  while (true) {
    RenderWork render_work = run_update_for_next_iteration();
 
    if (!render_work) {
      if (LOG_IS_ON(LOG_LEVEL_INFO)) {
        double total_time;
        double render_time;
        progress.get_time(total_time, render_time);
        LOG_INFO << "Rendering in main loop is done in " << render_time << " seconds.";
        LOG_INFO << path_trace_->full_report();
      }
 
      if (params.background) {
        /* if no work left and in background mode, we can stop immediately. */
        progress.set_status("Finished");
        break;
      }
    }
 
    const bool did_cancel = progress.get_cancel();
    if (did_cancel) {
      render_scheduler_.render_work_reschedule_on_cancel(render_work);
      if (!render_work) {
        break;
      }
    }
    else if (run_wait_for_work(render_work)) {
      continue;
    }
 
    /* Stop rendering if error happened during scene update or other step of preparing scene
     * for render. */
    if (device->have_error()) {
      progress.set_error(device->error_message());
      break;
    }
 
    {
      /* buffers mutex is locked entirely while rendering each
       * sample, and released/reacquired on each iteration to allow
       * reset and draw in between */
      const thread_scoped_lock buffers_lock(buffers_mutex_);
 
      /* update status and timing */
      update_status_time();
 
      /* render */
      path_trace_->render(render_work);
 
      /* update status and timing */
      update_status_time();
 
      /* Stop rendering if error happened during path tracing. */
      if (device->have_error()) {
        progress.set_error(device->error_message());
        break;
      }
    }
 
    progress.set_update();
 
    if (did_cancel) {
      break;
    }
  }
}
 
void Session::thread_run()
{
  while (true) {
    {
      thread_scoped_lock session_thread_lock(session_thread_mutex_);
 
      if (session_thread_state_ == SESSION_THREAD_WAIT) {
        /* Continue waiting for any signal from the main thread. */
        session_thread_cond_.wait(session_thread_lock);
        continue;
      }
      if (session_thread_state_ == SESSION_THREAD_END) {
        /* End thread immediately. */
        break;
      }
    }
 
    /* Execute a render. */
    thread_render();
 
    /* Go back from rendering to waiting. */
    {
      const thread_scoped_lock session_thread_lock(session_thread_mutex_);
      if (session_thread_state_ == SESSION_THREAD_RENDER) {
        session_thread_state_ = SESSION_THREAD_WAIT;
      }
    }
    session_thread_cond_.notify_all();
  }
 
  /* Flush any remaining operations and destroy display driver here. This ensure
   * graphics API resources are created and destroyed all in the session thread,
   * which can avoid problems contexts and multiple threads. */
  path_trace_->flush_display();
  path_trace_->set_display_driver(nullptr);
}
 
void Session::thread_render()
{
  if (params.use_profiling && (params.device.type == DEVICE_CPU)) {
    profiler.start();
  }
 
  /* session thread loop */
  progress.set_status("Waiting for render to start");
 
  /* run */
  if (!progress.get_cancel()) {
    /* reset number of rendered samples */
    progress.reset_sample();
 
    run_main_render_loop();
  }
 
  profiler.stop();
 
  /* progress update */
  if (progress.get_cancel()) {
    progress.set_status(progress.get_cancel_message());
  }
  else {
    progress.set_update();
  }
}
 
bool Session::is_session_thread_rendering()
{
  const thread_scoped_lock session_thread_lock(session_thread_mutex_);
  return (session_thread_state_ == SESSION_THREAD_RENDER);
}
 
RenderWork Session::run_update_for_next_iteration()
{
  RenderWork render_work;
 
  thread_scoped_lock scene_lock(scene->mutex);
 
  /* Perform delayed reset if requested. */
  const bool reset_buffers = delayed_reset_buffer_params();
 
  /* Update scene */
  const bool reset_scene = update_scene(delayed_reset_.do_reset);
 
  /* Update buffers for new parameters. After scene update which influences the passes used. */
  bool have_tiles = true;
  bool switched_to_new_tile = false;
 
  if (reset_buffers) {
    update_buffers_for_params();
 
    /* After reset make sure the tile manager is at the first big tile. */
    have_tiles = tile_manager_.next();
    switched_to_new_tile = true;
  }
 
  /* Update denoiser settings. */
  {
    const DenoiseParams denoise_params = scene->integrator->get_denoise_params();
    path_trace_->set_denoiser_params(denoise_params);
  }
 
  /* Update adaptive sampling. */
  {
    const AdaptiveSampling adaptive_sampling = scene->integrator->get_adaptive_sampling();
    path_trace_->set_adaptive_sampling(adaptive_sampling);
  }
 
  /* Update path guiding. */
  {
    const GuidingParams guiding_params = scene->integrator->get_guiding_params(device.get());
    const bool guiding_reset = (guiding_params.use) ? reset_scene : false;
    path_trace_->set_guiding_params(guiding_params, guiding_reset);
  }
 
  render_scheduler_.set_sample_params(params.samples,
                                      params.use_sample_subset,
                                      params.sample_subset_offset,
                                      params.sample_subset_length);
  render_scheduler_.set_time_limit(params.time_limit);
 
  while (have_tiles) {
    render_work = render_scheduler_.get_render_work();
    if (render_work) {
      break;
    }
 
    progress.add_finished_tile(false);
 
    have_tiles = tile_manager_.next();
    if (have_tiles) {
      render_scheduler_.reset_for_next_tile();
      switched_to_new_tile = true;
    }
  }
 
  if (render_work) {
    const scoped_timer update_timer;
 
    if (switched_to_new_tile) {
      BufferParams tile_params = buffer_params_;
 
      const Tile &tile = tile_manager_.get_current_tile();
 
      tile_params.width = tile.width;
      tile_params.height = tile.height;
 
      tile_params.window_x = tile.window_x;
      tile_params.window_y = tile.window_y;
      tile_params.window_width = tile.window_width;
      tile_params.window_height = tile.window_height;
 
      tile_params.full_x = tile.x + buffer_params_.full_x;
      tile_params.full_y = tile.y + buffer_params_.full_y;
      tile_params.full_width = buffer_params_.full_width;
      tile_params.full_height = buffer_params_.full_height;
 
      tile_params.update_offset_stride();
 
      path_trace_->reset(buffer_params_, tile_params, reset_buffers);
    }
 
    /* Update camera if dimensions changed for progressive render. the camera
     * knows nothing about progressive or cropped rendering, it just gets the
     * image dimensions passed in. */
    const int resolution = render_work.resolution_divider;
    const int width = max(1, buffer_params_.full_width / resolution);
    const int height = max(1, buffer_params_.full_height / resolution);
 
    scene->update_camera_resolution(progress, width, height);
 
    /* Unlock scene mutex before loading denoiser kernels, since that may attempt to activate
     * graphics interop, which can deadlock when the scene mutex is still being held. */
    scene_lock.unlock();
 
    path_trace_->load_kernels();
    path_trace_->alloc_work_memory();
 
    /* Wait for device to be ready (e.g. finish any background compilations). */
    string device_status;
    while (!device->is_ready(device_status)) {
      progress.set_status(device_status);
      if (progress.get_cancel()) {
        break;
      }
      std::this_thread::sleep_for(std::chrono::milliseconds(200));
    }
 
    progress.add_skip_time(update_timer, params.background);
  }
 
  return render_work;
}
 
bool Session::run_wait_for_work(const RenderWork &render_work)
{
  /* In an offline rendering there is no pause, and no tiles will mean the job is fully done. */
  if (params.background) {
    return false;
  }
 
  thread_scoped_lock pause_lock(pause_mutex_);
 
  if (!pause_ && render_work) {
    /* Rendering is not paused and there is work to be done. No need to wait for anything. */
    return false;
  }
 
  const bool no_work = !render_work;
  update_status_time(pause_, no_work);
 
  /* Only leave the loop when rendering is not paused. But even if the current render is
   * un-paused but there is nothing to render keep waiting until new work is added. */
  while (!progress.get_cancel()) {
    const scoped_timer pause_timer;
 
    if (!pause_ && (render_work || new_work_added_ || delayed_reset_.do_reset)) {
      break;
    }
 
    /* Wait for either pause state changed, or extra samples added to render. */
    pause_cond_.wait(pause_lock);
 
    if (pause_) {
      progress.add_skip_time(pause_timer, params.background);
    }
 
    update_status_time(pause_, no_work);
    progress.set_update();
  }
 
  new_work_added_ = false;
 
  return no_work;
}
 
void Session::draw()
{
  path_trace_->draw();
}
 
int2 Session::get_effective_tile_size() const
{
  const int image_width = buffer_params_.width;
  const int image_height = buffer_params_.height;
 
  if (!params.use_auto_tile) {
    return make_int2(image_width, image_height);
  }
 
  const int64_t image_area = static_cast<int64_t>(image_width) * image_height;
 
  /* TODO(sergey): Take available memory into account, and if there is enough memory do not
   * tile and prefer optimal performance. */
 
  const int tile_size = tile_manager_.compute_render_tile_size(params.tile_size);
  const int64_t actual_tile_area = static_cast<int64_t>(tile_size) * tile_size;
 
  if (actual_tile_area >= image_area && image_width <= TileManager::MAX_TILE_SIZE &&
      image_height <= TileManager::MAX_TILE_SIZE)
  {
    return make_int2(image_width, image_height);
  }
 
  return make_int2(tile_size, tile_size);
}
 
bool Session::delayed_reset_buffer_params()
{
  /* Reset buffer parameters, delayed from when we got the reset call so we can complete
   * rendering the sample. Otherwise e.g. viewport navigation might reset without ever
   * finishing anything. */
  const thread_scoped_lock reset_lock(delayed_reset_.mutex);
  if (!delayed_reset_.do_reset) {
    return false;
  }
 
  const thread_scoped_lock buffers_lock(buffers_mutex_);
  delayed_reset_.do_reset = false;
 
  params = delayed_reset_.session_params;
  buffer_params_ = delayed_reset_.buffer_params;
 
  /* Store parameters used for buffers access outside of scene graph. */
  buffer_params_.samples = min(params.samples, Integrator::MAX_SAMPLES);
  buffer_params_.exposure = scene->film->get_exposure();
  buffer_params_.use_approximate_shadow_catcher =
      scene->film->get_use_approximate_shadow_catcher();
  buffer_params_.use_transparent_background = scene->background->get_transparent();
 
  /* Tile and work scheduling. */
  tile_manager_.reset_scheduling(buffer_params_, get_effective_tile_size());
 
  return true;
}
 
void Session::update_buffers_for_params()
{
  render_scheduler_.set_sample_params(params.samples,
                                      params.use_sample_subset,
                                      params.sample_subset_offset,
                                      params.sample_subset_length);
  render_scheduler_.reset(buffer_params_);
 
  /* Update for new state of scene and passes. */
  buffer_params_.update_passes(scene->passes);
  tile_manager_.update(buffer_params_, scene.get());
 
  /* Update temp directory on reset.
   * This potentially allows to finish the existing rendering with a previously configure
   * temporary
   * directory in the host software and switch to a new temp directory when new render starts. */
  tile_manager_.set_temp_dir(params.temp_dir);
 
  /* Progress. */
  progress.reset_sample();
  progress.set_total_pixel_samples(static_cast<uint64_t>(buffer_params_.width) *
                                   buffer_params_.height * buffer_params_.samples);
 
  if (!params.background) {
    progress.set_start_time();
  }
  const double time_limit = params.time_limit * ((double)tile_manager_.get_num_tiles());
  progress.set_render_start_time();
  progress.set_time_limit(time_limit);
}
 
void Session::reset(const SessionParams &session_params, const BufferParams &buffer_params)
{
  {
    const thread_scoped_lock reset_lock(delayed_reset_.mutex);
    const thread_scoped_lock pause_lock(pause_mutex_);
 
    delayed_reset_.do_reset = true;
    delayed_reset_.session_params = session_params;
    delayed_reset_.buffer_params = buffer_params;
 
    scene->scene_updated_while_loading_kernels = true;
 
    path_trace_->cancel();
  }
 
  pause_cond_.notify_all();
}
 
void Session::set_samples(const int samples)
{
  if (samples == params.samples) {
    return;
  }
 
  params.samples = samples;
 
  {
    const thread_scoped_lock pause_lock(pause_mutex_);
    new_work_added_ = true;
  }
 
  pause_cond_.notify_all();
}
 
void Session::set_time_limit(const double time_limit)
{
  if (time_limit == params.time_limit) {
    return;
  }
 
  params.time_limit = time_limit;
 
  {
    const thread_scoped_lock pause_lock(pause_mutex_);
    new_work_added_ = true;
  }
 
  pause_cond_.notify_all();
}
 
void Session::set_pause(bool pause)
{
  bool notify = false;
 
  {
    const thread_scoped_lock pause_lock(pause_mutex_);
 
    if (pause != pause_) {
      pause_ = pause;
      notify = true;
    }
  }
 
  if (is_session_thread_rendering()) {
    if (notify) {
      pause_cond_.notify_all();
    }
  }
  else if (pause_) {
    update_status_time(pause_);
  }
}
 
void Session::set_output_driver(unique_ptr<OutputDriver> driver)
{
  path_trace_->set_output_driver(std::move(driver));
}
 
void Session::set_display_driver(unique_ptr<DisplayDriver> driver)
{
  path_trace_->set_display_driver(std::move(driver));
}
 
double Session::get_estimated_remaining_time() const
{
  const double completed = progress.get_progress();
  if (completed == 0.0) {
    return 0.0;
  }
 
  double total_time;
  double render_time;
  progress.get_time(total_time, render_time);
  double remaining = (1.0 - (double)completed) * (render_time / (double)completed);
 
  const double time_limit = render_scheduler_.get_time_limit() *
                            ((double)tile_manager_.get_num_tiles());
  if (time_limit != 0.0) {
    remaining = min(remaining, max(time_limit - render_time, 0.0));
  }
 
  return remaining;
}
 
void Session::wait()
{
  /* Wait until session thread either is waiting or ending. */
  while (true) {
    thread_scoped_lock session_thread_lock(session_thread_mutex_);
    if (session_thread_state_ != SESSION_THREAD_RENDER) {
      break;
    }
    session_thread_cond_.wait(session_thread_lock);
  }
}
 
bool Session::update_scene(const bool reset_samples)
{
  /* Update number of samples in the integrator.
   * Ideally this would need to happen once in `Session::set_samples()`, but the issue there is
   * the initial configuration when Session is created where the `set_samples()` is not used.
   *
   * NOTE: Unless reset was requested only allow increasing number of samples. */
  if (reset_samples || scene->integrator->get_aa_samples() < params.samples) {
    scene->integrator->set_aa_samples(params.samples);
  }
 
  scene->integrator->set_use_sample_subset(params.use_sample_subset);
  scene->integrator->set_sample_subset_offset(params.sample_subset_offset);
  scene->integrator->set_sample_subset_length(params.sample_subset_length);
 
  /* When multiple tiles are used SAMPLE_COUNT pass is used to keep track of possible partial
   * tile results. */
  scene->film->set_use_sample_count(tile_manager_.has_multiple_tiles());
 
  const bool reset = scene->need_reset(false);
 
  if (scene->update(progress)) {
    profiler.reset(scene->shaders.size(), scene->objects.size());
  }
 
  return reset;
}
 
static string status_append(const string &status, const string &suffix)
{
  string prefix = status;
  if (!prefix.empty()) {
    prefix += ", ";
  }
  return prefix + suffix;
}
 
void Session::update_status_time(bool show_pause, bool show_done)
{
  string status;
  string substatus;
 
  const int current_tile = progress.get_rendered_tiles();
  const int num_tiles = tile_manager_.get_num_tiles();
 
  const int current_sample = progress.get_current_sample();
  const int num_samples = render_scheduler_.get_num_samples();
 
  /* TIle. */
  if (tile_manager_.has_multiple_tiles()) {
    substatus = status_append(substatus,
                              string_printf("Rendered %d/%d Tiles", current_tile, num_tiles));
  }
 
  /* Sample. */
  if (!params.background && num_samples == Integrator::MAX_SAMPLES) {
    substatus = status_append(substatus, string_printf("Sample %d", current_sample));
  }
  else {
    substatus = status_append(substatus,
                              string_printf("Sample %d/%d", current_sample, num_samples));
  }
 
  /* Append any device-specific status (such as background kernel optimization) */
  string device_status;
  if (device->is_ready(device_status) && !device_status.empty()) {
    substatus += string_printf(" (%s)", device_status.c_str());
  }
 
  /* TODO(sergey): Denoising status from the path trace. */
 
  if (show_pause) {
    status = "Rendering Paused";
  }
  else if (show_done) {
    status = "Rendering Done";
    progress.set_end_time(); /* Save end time so that further calls to get_time are accurate. */
  }
  else {
    status = substatus;
    substatus.clear();
  }
 
  progress.set_status(status, substatus);
}
 
void Session::device_free()
{
  scene->device_free();
  path_trace_->device_free();
}
 
void Session::collect_statistics(RenderStats *render_stats)
{
  scene->collect_statistics(render_stats);
  if (params.use_profiling && (params.device.type == DEVICE_CPU)) {
    render_stats->collect_profiling(scene.get(), profiler);
  }
}
 
/* --------------------------------------------------------------------
 * Full-frame on-disk storage.
 */
 
void Session::process_full_buffer_from_disk(string_view filename)
{
  path_trace_->process_full_buffer_from_disk(filename);
}
 
CCL_NAMESPACE_END