Cycles: merge of cycles-x branch, a major update to the renderer

This includes much improved GPU rendering performance, viewport interactivity,
new shadow catcher, revamped sampling settings, subsurface scattering anisotropy,
new GPU volume sampling, improved PMJ sampling pattern, and more.

Some features have also been removed or changed, breaking backwards compatibility.
Including the removal of the OpenCL backend, for which alternatives are under
development.

Release notes and code docs:
https://wiki.blender.org/wiki/Reference/Release_Notes/3.0/Cycles
https://wiki.blender.org/wiki/Source/Render/Cycles

Credits:
* Sergey Sharybin
* Brecht Van Lommel
* Patrick Mours (OptiX backend)
* Christophe Hery (subsurface scattering anisotropy)
* William Leeson (PMJ sampling pattern)
* Alaska (various fixes and tweaks)
* Thomas Dinges (various fixes)

For the full commit history, see the cycles-x branch. This squashes together
all the changes since intermediate changes would often fail building or tests.

Ref T87839, T87837, T87836
Fixes T90734, T89353, T80267, T80267, T77185, T69800

1 files changed, 361 insertions, 932 deletions

diff --git a/intern/cycles/render/session.cpp b/intern/cycles/render/session.cpp
index 1b91c49f0ea..84407f8e6dd 100644
--- a/intern/cycles/render/session.cpp
+++ b/intern/cycles/render/session.cpp
@@ -17,10 +17,15 @@
 #include <limits.h>
 #include <string.h>
 
+#include "device/cpu/device.h"
 #include "device/device.h"
+#include "integrator/pass_accessor_cpu.h"
+#include "integrator/path_trace.h"
+#include "render/background.h"
 #include "render/bake.h"
 #include "render/buffers.h"
 #include "render/camera.h"
+#include "render/gpu_display.h"
 #include "render/graph.h"
 #include "render/integrator.h"
 #include "render/light.h"
@@ -39,70 +44,63 @@
 
 CCL_NAMESPACE_BEGIN
 
-/* Note about  preserve_tile_device option for tile manager:
- * progressive refine and viewport rendering does requires tiles to
- * always be allocated for the same device
- */
-Session::Session(const SessionParams &params_)
-    : params(params_),
-      tile_manager(params.progressive,
-                   params.samples,
-                   params.tile_size,
-                   params.start_resolution,
-                   params.background == false || params.progressive_refine,
-                   params.background,
-                   params.tile_order,
-                   max(params.device.multi_devices.size(), 1),
-                   params.pixel_size),
-      stats(),
-      profiler()
+Session::Session(const SessionParams &params_, const SceneParams &scene_params)
+    : params(params_), render_scheduler_(tile_manager_, params)
 {
-  device_use_gl_ = ((params.device.type != DEVICE_CPU) && !params.background);
-
   TaskScheduler::init(params.threads);
 
-  session_thread_ = NULL;
-  scene = NULL;
-
-  reset_time_ = 0.0;
-  last_update_time_ = 0.0;
+  session_thread_ = nullptr;
 
   delayed_reset_.do_reset = false;
-  delayed_reset_.samples = 0;
-
-  display_outdated_ = false;
-  gpu_draw_ready_ = false;
-  gpu_need_display_buffer_update_ = false;
 
   pause_ = false;
   cancel_ = false;
   new_work_added_ = false;
 
-  buffers = NULL;
-  display = NULL;
+  device = Device::create(params.device, stats, profiler);
 
-  /* Validate denoising parameters. */
-  set_denoising(params.denoising);
+  scene = new Scene(scene_params, device);
 
-  /* Create CPU/GPU devices. */
-  device = Device::create(params.device, stats, profiler, params.background);
-
-  if (!device->error_message().empty()) {
-    progress.set_error(device->error_message());
-    return;
-  }
+  /* Configure path tracer. */
+  path_trace_ = make_unique<PathTrace>(
+      device, scene->film, &scene->dscene, render_scheduler_, tile_manager_);
+  path_trace_->set_progress(&progress);
+  path_trace_->tile_buffer_update_cb = [&]() {
+    if (!update_render_tile_cb) {
+      return;
+    }
+    update_render_tile_cb();
+  };
+  path_trace_->tile_buffer_write_cb = [&]() {
+    if (!write_render_tile_cb) {
+      return;
+    }
+    write_render_tile_cb();
+  };
+  path_trace_->tile_buffer_read_cb = [&]() -> bool {
+    if (!read_render_tile_cb) {
+      return false;
+    }
+    read_render_tile_cb();
+    return true;
+  };
+  path_trace_->progress_update_cb = [&]() { update_status_time(); };
 
-  /* Create buffers for interactive rendering. */
-  if (!(params.background && !params.write_render_cb)) {
-    buffers = new RenderBuffers(device);
-    display = new DisplayBuffer(device, params.display_buffer_linear);
-  }
+  tile_manager_.full_buffer_written_cb = [&](string_view filename) {
+    if (!full_buffer_written_cb) {
+      return;
+    }
+    full_buffer_written_cb(filename);
+  };
 }
 
 Session::~Session()
 {
   cancel();
 
+  /* TODO(sergey): Bring the passes in viewport back.
+   * It is unclear why there is such an exception needed though. */
+#if 0
   if (buffers && params.write_render_cb) {
     /* Copy to display buffer and write out image if requested */
     delete display;
@@ -116,12 +114,14 @@ Session::~Session()
     uchar4 *pixels = display->rgba_byte.copy_from_device(0, w, h);
     params.write_render_cb((uchar *)pixels, w, h, 4);
   }
+#endif
 
-  /* clean up */
-  tile_manager.device_free();
+  /* Make sure path tracer is destroyed before the deviec. 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();
 
-  delete buffers;
-  delete display;
   delete scene;
   delete device;
 
@@ -135,15 +135,16 @@ void Session::start()
   }
 }
 
-void Session::cancel()
+void Session::cancel(bool quick)
 {
+  if (quick && path_trace_) {
+    path_trace_->cancel();
+  }
+
   if (session_thread_) {
     /* wait for session thread to end */
     progress.set_cancel("Exiting");
 
-    gpu_need_display_buffer_update_ = false;
-    gpu_need_display_buffer_update_cond_.notify_all();
-
     {
       thread_scoped_lock pause_lock(pause_mutex_);
       pause_ = false;
@@ -157,570 +158,43 @@ void Session::cancel()
 
 bool Session::ready_to_reset()
 {
-  double dt = time_dt() - reset_time_;
-
-  if (!display_outdated_)
-    return (dt > params.reset_timeout);
-  else
-    return (dt > params.cancel_timeout);
+  return path_trace_->ready_to_reset();
 }
 
-/* GPU Session */
-
-void Session::reset_gpu(BufferParams &buffer_params, int samples)
+void Session::run_main_render_loop()
 {
-  thread_scoped_lock pause_lock(pause_mutex_);
-
-  /* block for buffer access and reset immediately. we can't do this
-   * in the thread, because we need to allocate an OpenGL buffer, and
-   * that only works in the main thread */
-  thread_scoped_lock display_lock(display_mutex_);
-  thread_scoped_lock buffers_lock(buffers_mutex_);
+  path_trace_->clear_gpu_display();
 
-  display_outdated_ = true;
-  reset_time_ = time_dt();
+  while (true) {
+    RenderWork render_work = run_update_for_next_iteration();
 
-  reset_(buffer_params, samples);
-
-  gpu_need_display_buffer_update_ = false;
-  gpu_need_display_buffer_update_cond_.notify_all();
-
-  new_work_added_ = true;
-
-  pause_cond_.notify_all();
-}
-
-bool Session::draw_gpu(BufferParams &buffer_params, DeviceDrawParams &draw_params)
-{
-  /* block for buffer access */
-  thread_scoped_lock display_lock(display_mutex_);
-
-  /* first check we already rendered something */
-  if (gpu_draw_ready_) {
-    /* then verify the buffers have the expected size, so we don't
-     * draw previous results in a resized window */
-    if (buffer_params.width == display->params.width &&
-        buffer_params.height == display->params.height) {
-      /* for CUDA we need to do tone-mapping still, since we can
-       * only access GL buffers from the main thread. */
-      if (gpu_need_display_buffer_update_) {
-        thread_scoped_lock buffers_lock(buffers_mutex_);
-        copy_to_display_buffer(tile_manager.state.sample);
-        gpu_need_display_buffer_update_ = false;
-        gpu_need_display_buffer_update_cond_.notify_all();
+    if (!render_work) {
+      if (VLOG_IS_ON(2)) {
+        double total_time, render_time;
+        progress.get_time(total_time, render_time);
+        VLOG(2) << "Rendering in main loop is done in " << render_time << " seconds.";
+        VLOG(2) << path_trace_->full_report();
       }
 
-      display->draw(device, draw_params);
-
-      if (display_outdated_ && (time_dt() - reset_time_) > params.text_timeout)
-        return false;
-
-      return true;
-    }
-  }
-
-  return false;
-}
-
-void Session::run_gpu()
-{
-  bool tiles_written = false;
-
-  reset_time_ = time_dt();
-  last_update_time_ = time_dt();
-  last_display_time_ = last_update_time_;
-
-  progress.set_render_start_time();
-
-  while (!progress.get_cancel()) {
-    const bool no_tiles = !run_update_for_next_iteration();
-
-    if (no_tiles) {
       if (params.background) {
-        /* if no work left and in background mode, we can stop immediately */
+        /* if no work left and in background mode, we can stop immediately. */
         progress.set_status("Finished");
         break;
       }
     }
 
-    if (run_wait_for_work(no_tiles)) {
-      continue;
-    }
-
-    if (progress.get_cancel()) {
-      break;
-    }
-
-    if (!no_tiles) {
-      if (!device->error_message().empty())
-        progress.set_error(device->error_message());
-
-      if (progress.get_cancel())
-        break;
-
-      /* buffers mutex is locked entirely while rendering each
-       * sample, and released/reacquired on each iteration to allow
-       * reset and draw in between */
-      thread_scoped_lock buffers_lock(buffers_mutex_);
-
-      /* update status and timing */
-      update_status_time();
-
-      /* render */
-      bool delayed_denoise = false;
-      const bool need_denoise = render_need_denoise(delayed_denoise);
-      render(need_denoise);
-
-      device->task_wait();
-
-      if (!device->error_message().empty())
-        progress.set_cancel(device->error_message());
-
-      /* update status and timing */
-      update_status_time();
-
-      gpu_need_display_buffer_update_ = !delayed_denoise;
-      gpu_draw_ready_ = true;
-      progress.set_update();
-
-      /* wait for until display buffer is updated */
-      if (!params.background) {
-        while (gpu_need_display_buffer_update_) {
-          if (progress.get_cancel())
-            break;
-
-          gpu_need_display_buffer_update_cond_.wait(buffers_lock);
-        }
-      }
-
-      if (!device->error_message().empty())
-        progress.set_error(device->error_message());
-
-      tiles_written = update_progressive_refine(progress.get_cancel());
-
-      if (progress.get_cancel())
-        break;
-    }
-  }
-
-  if (!tiles_written)
-    update_progressive_refine(true);
-}
-
-/* CPU Session */
-
-void Session::reset_cpu(BufferParams &buffer_params, int samples)
-{
-  thread_scoped_lock reset_lock(delayed_reset_.mutex);
-  thread_scoped_lock pause_lock(pause_mutex_);
-
-  display_outdated_ = true;
-  reset_time_ = time_dt();
-
-  delayed_reset_.params = buffer_params;
-  delayed_reset_.samples = samples;
-  delayed_reset_.do_reset = true;
-  device->task_cancel();
-
-  pause_cond_.notify_all();
-}
-
-bool Session::draw_cpu(BufferParams &buffer_params, DeviceDrawParams &draw_params)
-{
-  thread_scoped_lock display_lock(display_mutex_);
-
-  /* first check we already rendered something */
-  if (display->draw_ready()) {
-    /* then verify the buffers have the expected size, so we don't
-     * draw previous results in a resized window */
-    if (buffer_params.width == display->params.width &&
-        buffer_params.height == display->params.height) {
-      display->draw(device, draw_params);
-
-      if (display_outdated_ && (time_dt() - reset_time_) > params.text_timeout)
-        return false;
-
-      return true;
-    }
-  }
-
-  return false;
-}
-
-bool Session::steal_tile(RenderTile &rtile, Device *tile_device, thread_scoped_lock &tile_lock)
-{
-  /* Devices that can get their tiles stolen don't steal tiles themselves.
-   * Additionally, if there are no stealable tiles in flight, give up here. */
-  if (tile_device->info.type == DEVICE_CPU || stealable_tiles_ == 0) {
-    return false;
-  }
-
-  /* Wait until no other thread is trying to steal a tile. */
-  while (tile_stealing_state_ != NOT_STEALING && stealable_tiles_ > 0) {
-    /* Someone else is currently trying to get a tile.
-     * Wait on the condition variable and try later. */
-    tile_steal_cond_.wait(tile_lock);
-  }
-  /* If another thread stole the last stealable tile in the meantime, give up. */
-  if (stealable_tiles_ == 0) {
-    return false;
-  }
-
-  /* There are stealable tiles in flight, so signal that one should be released. */
-  tile_stealing_state_ = WAITING_FOR_TILE;
-
-  /* Wait until a device notices the signal and releases its tile. */
-  while (tile_stealing_state_ != GOT_TILE && stealable_tiles_ > 0) {
-    tile_steal_cond_.wait(tile_lock);
-  }
-  /* If the last stealable tile finished on its own, give up. */
-  if (tile_stealing_state_ != GOT_TILE) {
-    tile_stealing_state_ = NOT_STEALING;
-    return false;
-  }
-
-  /* Successfully stole a tile, now move it to the new device. */
-  rtile = stolen_tile_;
-  rtile.buffers->buffer.move_device(tile_device);
-  rtile.buffer = rtile.buffers->buffer.device_pointer;
-  rtile.stealing_state = RenderTile::NO_STEALING;
-  rtile.num_samples -= (rtile.sample - rtile.start_sample);
-  rtile.start_sample = rtile.sample;
-
-  tile_stealing_state_ = NOT_STEALING;
-
-  /* Poke any threads which might be waiting for NOT_STEALING above. */
-  tile_steal_cond_.notify_one();
-
-  return true;
-}
-
-bool Session::get_tile_stolen()
-{
-  /* If tile_stealing_state is WAITING_FOR_TILE, atomically set it to RELEASING_TILE
-   * and return true. */
-  TileStealingState expected = WAITING_FOR_TILE;
-  return tile_stealing_state_.compare_exchange_weak(expected, RELEASING_TILE);
-}
-
-bool Session::acquire_tile(RenderTile &rtile, Device *tile_device, uint tile_types)
-{
-  if (progress.get_cancel()) {
-    if (params.progressive_refine == false) {
-      /* for progressive refine current sample should be finished for all tiles */
-      return false;
-    }
-  }
-
-  thread_scoped_lock tile_lock(tile_mutex_);
-
-  /* get next tile from manager */
-  Tile *tile;
-  int device_num = device->device_number(tile_device);
-
-  while (!tile_manager.next_tile(tile, device_num, tile_types)) {
-    /* Can only steal tiles on devices that support rendering
-     * This is because denoising tiles cannot be stolen (see below)
-     */
-    if ((tile_types & (RenderTile::PATH_TRACE | RenderTile::BAKE)) &&
-        steal_tile(rtile, tile_device, tile_lock)) {
-      return true;
-    }
-
-    /* Wait for denoising tiles to become available */
-    if ((tile_types & RenderTile::DENOISE) && !progress.get_cancel() && tile_manager.has_tiles()) {
-      denoising_cond_.wait(tile_lock);
-      continue;
-    }
-
-    return false;
-  }
-
-  /* fill render tile */
-  rtile.x = tile_manager.state.buffer.full_x + tile->x;
-  rtile.y = tile_manager.state.buffer.full_y + tile->y;
-  rtile.w = tile->w;
-  rtile.h = tile->h;
-  rtile.start_sample = tile_manager.state.sample;
-  rtile.num_samples = tile_manager.state.num_samples;
-  rtile.resolution = tile_manager.state.resolution_divider;
-  rtile.tile_index = tile->index;
-  rtile.stealing_state = RenderTile::NO_STEALING;
-
-  if (tile->state == Tile::DENOISE) {
-    rtile.task = RenderTile::DENOISE;
-  }
-  else {
-    if (tile_device->info.type == DEVICE_CPU) {
-      stealable_tiles_++;
-      rtile.stealing_state = RenderTile::CAN_BE_STOLEN;
-    }
-
-    if (read_bake_tile_cb) {
-      rtile.task = RenderTile::BAKE;
-    }
-    else {
-      rtile.task = RenderTile::PATH_TRACE;
-    }
-  }
-
-  tile_lock.unlock();
-
-  /* in case of a permanent buffer, return it, otherwise we will allocate
-   * a new temporary buffer */
-  if (buffers) {
-    tile_manager.state.buffer.get_offset_stride(rtile.offset, rtile.stride);
-
-    rtile.buffer = buffers->buffer.device_pointer;
-    rtile.buffers = buffers;
-
-    device->map_tile(tile_device, rtile);
-
-    /* Reset copy state, since buffer contents change after the tile was acquired */
-    buffers->map_neighbor_copied = false;
-
-    /* This hack ensures that the copy in 'MultiDevice::map_neighbor_tiles' accounts
-     * for the buffer resolution divider. */
-    buffers->buffer.data_width = (buffers->params.width * buffers->params.get_passes_size()) /
-                                 tile_manager.state.resolution_divider;
-    buffers->buffer.data_height = buffers->params.height / tile_manager.state.resolution_divider;
-
-    return true;
-  }
-
-  if (tile->buffers == NULL) {
-    /* fill buffer parameters */
-    BufferParams buffer_params = tile_manager.params;
-    buffer_params.full_x = rtile.x;
-    buffer_params.full_y = rtile.y;
-    buffer_params.width = rtile.w;
-    buffer_params.height = rtile.h;
-
-    /* allocate buffers */
-    tile->buffers = new RenderBuffers(tile_device);
-    tile->buffers->reset(buffer_params);
-  }
-  else if (tile->buffers->buffer.device != tile_device) {
-    /* Move buffer to current tile device again in case it was stolen before.
-     * Not needed for denoising since that already handles mapping of tiles and
-     * neighbors to its own device. */
-    if (rtile.task != RenderTile::DENOISE) {
-      tile->buffers->buffer.move_device(tile_device);
-    }
-  }
-
-  tile->buffers->map_neighbor_copied = false;
-
-  tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride);
-
-  rtile.buffer = tile->buffers->buffer.device_pointer;
-  rtile.buffers = tile->buffers;
-  rtile.sample = tile_manager.state.sample;
-
-  if (read_bake_tile_cb) {
-    /* This will read any passes needed as input for baking. */
-    if (tile_manager.state.sample == tile_manager.range_start_sample) {
-      {
-        thread_scoped_lock tile_lock(tile_mutex_);
-        read_bake_tile_cb(rtile);
-      }
-      rtile.buffers->buffer.copy_to_device();
-    }
-  }
-  else {
-    /* This will tag tile as IN PROGRESS in blender-side render pipeline,
-     * which is needed to highlight currently rendering tile before first
-     * sample was processed for it. */
-    update_tile_sample(rtile);
-  }
-
-  return true;
-}
-
-void Session::update_tile_sample(RenderTile &rtile)
-{
-  thread_scoped_lock tile_lock(tile_mutex_);
-
-  if (update_render_tile_cb) {
-    if (params.progressive_refine == false) {
-      /* todo: optimize this by making it thread safe and removing lock */
-
-      update_render_tile_cb(rtile, true);
-    }
-  }
-
-  update_status_time();
-}
-
-void Session::release_tile(RenderTile &rtile, const bool need_denoise)
-{
-  thread_scoped_lock tile_lock(tile_mutex_);
-
-  if (rtile.stealing_state != RenderTile::NO_STEALING) {
-    stealable_tiles_--;
-    if (rtile.stealing_state == RenderTile::WAS_STOLEN) {
-      /* If the tile is being stolen, don't release it here - the new device will pick up where
-       * the old one left off. */
-
-      assert(tile_stealing_state_ == RELEASING_TILE);
-      assert(rtile.sample < rtile.start_sample + rtile.num_samples);
-
-      tile_stealing_state_ = GOT_TILE;
-      stolen_tile_ = rtile;
-      tile_steal_cond_.notify_all();
-      return;
-    }
-    else if (stealable_tiles_ == 0) {
-      /* If this was the last stealable tile, wake up any threads still waiting for one. */
-      tile_steal_cond_.notify_all();
-    }
-  }
-
-  progress.add_finished_tile(rtile.task == RenderTile::DENOISE);
-
-  bool delete_tile;
-
-  if (tile_manager.finish_tile(rtile.tile_index, need_denoise, delete_tile)) {
-    /* Finished tile pixels write. */
-    if (write_render_tile_cb && params.progressive_refine == false) {
-      write_render_tile_cb(rtile);
-    }
-
-    if (delete_tile) {
-      delete rtile.buffers;
-      tile_manager.state.tiles[rtile.tile_index].buffers = NULL;
-    }
-  }
-  else {
-    /* In progress tile pixels update. */
-    if (update_render_tile_cb && params.progressive_refine == false) {
-      update_render_tile_cb(rtile, false);
-    }
-  }
-
-  update_status_time();
-
-  /* Notify denoising thread that a tile was finished. */
-  denoising_cond_.notify_all();
-}
-
-void Session::map_neighbor_tiles(RenderTileNeighbors &neighbors, Device *tile_device)
-{
-  thread_scoped_lock tile_lock(tile_mutex_);
-
-  const int4 image_region = make_int4(
-      tile_manager.state.buffer.full_x,
-      tile_manager.state.buffer.full_y,
-      tile_manager.state.buffer.full_x + tile_manager.state.buffer.width,
-      tile_manager.state.buffer.full_y + tile_manager.state.buffer.height);
-
-  RenderTile &center_tile = neighbors.tiles[RenderTileNeighbors::CENTER];
-
-  if (!tile_manager.schedule_denoising) {
-    /* Fix up tile slices with overlap. */
-    if (tile_manager.slice_overlap != 0) {
-      int y = max(center_tile.y - tile_manager.slice_overlap, image_region.y);
-      center_tile.h = min(center_tile.y + center_tile.h + tile_manager.slice_overlap,
-                          image_region.w) -
-                      y;
-      center_tile.y = y;
-    }
-
-    /* Tiles are not being denoised individually, which means the entire image is processed. */
-    neighbors.set_bounds_from_center();
-  }
-  else {
-    int center_idx = center_tile.tile_index;
-    assert(tile_manager.state.tiles[center_idx].state == Tile::DENOISE);
-
-    for (int dy = -1, i = 0; dy <= 1; dy++) {
-      for (int dx = -1; dx <= 1; dx++, i++) {
-        RenderTile &rtile = neighbors.tiles[i];
-        int nindex = tile_manager.get_neighbor_index(center_idx, i);
-        if (nindex >= 0) {
-          Tile *tile = &tile_manager.state.tiles[nindex];
-
-          rtile.x = image_region.x + tile->x;
-          rtile.y = image_region.y + tile->y;
-          rtile.w = tile->w;
-          rtile.h = tile->h;
-
-          if (buffers) {
-            tile_manager.state.buffer.get_offset_stride(rtile.offset, rtile.stride);
-
-            rtile.buffer = buffers->buffer.device_pointer;
-            rtile.buffers = buffers;
-          }
-          else {
-            assert(tile->buffers);
-            tile->buffers->params.get_offset_stride(rtile.offset, rtile.stride);
-
-            rtile.buffer = tile->buffers->buffer.device_pointer;
-            rtile.buffers = tile->buffers;
-          }
-        }
-        else {
-          int px = center_tile.x + dx * params.tile_size.x;
-          int py = center_tile.y + dy * params.tile_size.y;
-
-          rtile.x = clamp(px, image_region.x, image_region.z);
-          rtile.y = clamp(py, image_region.y, image_region.w);
-          rtile.w = rtile.h = 0;
-
-          rtile.buffer = (device_ptr)NULL;
-          rtile.buffers = NULL;
-        }
-      }
-    }
-  }
-
-  assert(center_tile.buffers);
-  device->map_neighbor_tiles(tile_device, neighbors);
-
-  /* The denoised result is written back to the original tile. */
-  neighbors.target = center_tile;
-}
-
-void Session::unmap_neighbor_tiles(RenderTileNeighbors &neighbors, Device *tile_device)
-{
-  thread_scoped_lock tile_lock(tile_mutex_);
-  device->unmap_neighbor_tiles(tile_device, neighbors);
-}
-
-void Session::run_cpu()
-{
-  bool tiles_written = false;
-
-  last_update_time_ = time_dt();
-  last_display_time_ = last_update_time_;
-
-  while (!progress.get_cancel()) {
-    const bool no_tiles = !run_update_for_next_iteration();
-    bool need_copy_to_display_buffer = false;
-
-    if (no_tiles) {
-      if (params.background) {
-        /* if no work left and in background mode, we can stop immediately */
-        progress.set_status("Finished");
+    const bool did_cancel = progress.get_cancel();
+    if (did_cancel) {
+      render_scheduler_.render_work_reschedule_on_cancel(render_work);
+      if (!render_work) {
         break;
       }
     }
-
-    if (run_wait_for_work(no_tiles)) {
+    else if (run_wait_for_work(render_work)) {
       continue;
     }
 
-    if (progress.get_cancel()) {
-      break;
-    }
-
-    if (!no_tiles) {
-      if (!device->error_message().empty())
-        progress.set_error(device->error_message());
-
-      if (progress.get_cancel())
-        break;
-
+    {
       /* buffers mutex is locked entirely while rendering each
        * sample, and released/reacquired on each iteration to allow
        * reset and draw in between */
@@ -730,49 +204,25 @@ void Session::run_cpu()
       update_status_time();
 
       /* render */
-      bool delayed_denoise = false;
-      const bool need_denoise = render_need_denoise(delayed_denoise);
-      render(need_denoise);
+      path_trace_->render(render_work);
 
       /* update status and timing */
       update_status_time();
 
-      if (!params.background)
-        need_copy_to_display_buffer = !delayed_denoise;
-
-      if (!device->error_message().empty())
-        progress.set_error(device->error_message());
-    }
-
-    device->task_wait();
-
-    {
-      thread_scoped_lock reset_lock(delayed_reset_.mutex);
-      thread_scoped_lock buffers_lock(buffers_mutex_);
-      thread_scoped_lock display_lock(display_mutex_);
-
-      if (delayed_reset_.do_reset) {
-        /* reset rendering if request from main thread */
-        delayed_reset_.do_reset = false;
-        reset_(delayed_reset_.params, delayed_reset_.samples);
-      }
-      else if (need_copy_to_display_buffer) {
-        /* Only copy to display_buffer if we do not reset, we don't
-         * want to show the result of an incomplete sample */
-        copy_to_display_buffer(tile_manager.state.sample);
+      if (device->have_error()) {
+        const string &error_message = device->error_message();
+        progress.set_error(error_message);
+        progress.set_cancel(error_message);
+        break;
       }
-
-      if (!device->error_message().empty())
-        progress.set_error(device->error_message());
-
-      tiles_written = update_progressive_refine(progress.get_cancel());
     }
 
     progress.set_update();
-  }
 
-  if (!tiles_written)
-    update_progressive_refine(true);
+    if (did_cancel) {
+      break;
+    }
+  }
 }
 
 void Session::run()
@@ -789,10 +239,7 @@ void Session::run()
     /* reset number of rendered samples */
     progress.reset_sample();
 
-    if (device_use_gl_)
-      run_gpu();
-    else
-      run_cpu();
+    run_main_render_loop();
   }
 
   profiler.stop();
@@ -804,31 +251,92 @@ void Session::run()
     progress.set_update();
 }
 
-bool Session::run_update_for_next_iteration()
+RenderWork Session::run_update_for_next_iteration()
 {
+  RenderWork render_work;
+
   thread_scoped_lock scene_lock(scene->mutex);
   thread_scoped_lock reset_lock(delayed_reset_.mutex);
 
+  bool have_tiles = true;
+  bool switched_to_new_tile = false;
+
   if (delayed_reset_.do_reset) {
     thread_scoped_lock buffers_lock(buffers_mutex_);
-    reset_(delayed_reset_.params, delayed_reset_.samples);
-    delayed_reset_.do_reset = false;
+    do_delayed_reset();
+
+    /* After reset make sure the tile manager is at the first big tile. */
+    have_tiles = tile_manager_.next();
+    switched_to_new_tile = true;
+  }
+
+  /* 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. */
+  scene->integrator->set_aa_samples(params.samples);
+
+  /* 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);
   }
 
-  const bool have_tiles = tile_manager.next();
+  render_scheduler_.set_num_samples(params.samples);
+  render_scheduler_.set_time_limit(params.time_limit);
+
+  while (have_tiles) {
+    render_work = render_scheduler_.get_render_work();
+    if (render_work) {
+      break;
+    }
 
-  if (have_tiles) {
+    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) {
     scoped_timer update_timer;
-    if (update_scene()) {
+
+    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.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);
+    }
+
+    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);
+
+    if (update_scene(width, height)) {
       profiler.reset(scene->shaders.size(), scene->objects.size());
     }
     progress.add_skip_time(update_timer, params.background);
   }
 
-  return have_tiles;
+  return render_work;
 }
 
-bool Session::run_wait_for_work(bool no_tiles)
+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) {
@@ -837,19 +345,20 @@ bool Session::run_wait_for_work(bool no_tiles)
 
   thread_scoped_lock pause_lock(pause_mutex_);
 
-  if (!pause_ && !no_tiles) {
+  if (!pause_ && render_work) {
     /* Rendering is not paused and there is work to be done. No need to wait for anything. */
     return false;
   }
 
-  update_status_time(pause_, no_tiles);
+  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 (!cancel_) {
     scoped_timer pause_timer;
 
-    if (!pause_ && (!no_tiles || new_work_added_ || delayed_reset_.do_reset)) {
+    if (!pause_ && (render_work || new_work_added_ || delayed_reset_.do_reset)) {
       break;
     }
 
@@ -860,52 +369,88 @@ bool Session::run_wait_for_work(bool no_tiles)
       progress.add_skip_time(pause_timer, params.background);
     }
 
-    update_status_time(pause_, no_tiles);
+    update_status_time(pause_, no_work);
     progress.set_update();
   }
 
   new_work_added_ = false;
 
-  return no_tiles;
+  return no_work;
 }
 
-bool Session::draw(BufferParams &buffer_params, DeviceDrawParams &draw_params)
+void Session::draw()
 {
-  if (device_use_gl_)
-    return draw_gpu(buffer_params, draw_params);
-  else
-    return draw_cpu(buffer_params, draw_params);
+  path_trace_->draw();
 }
 
-void Session::reset_(BufferParams &buffer_params, int samples)
+int2 Session::get_effective_tile_size() const
 {
-  if (buffers && buffer_params.modified(tile_manager.params)) {
-    gpu_draw_ready_ = false;
-    buffers->reset(buffer_params);
-    if (display) {
-      display->reset(buffer_params);
-    }
+  /* No support yet for baking with tiles. */
+  if (!params.use_auto_tile || scene->bake_manager->get_baking()) {
+    return make_int2(buffer_params_.width, buffer_params_.height);
   }
 
-  tile_manager.reset(buffer_params, samples);
-  stealable_tiles_ = 0;
-  tile_stealing_state_ = NOT_STEALING;
-  progress.reset_sample();
+  /* TODO(sergey): Take available memory into account, and if there is enough memory do not tile
+   * and prefer optimal performance. */
+
+  return make_int2(params.tile_size, params.tile_size);
+}
+
+void Session::do_delayed_reset()
+{
+  if (!delayed_reset_.do_reset) {
+    return;
+  }
+  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_.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();
 
-  bool show_progress = params.background || tile_manager.get_num_effective_samples() != INT_MAX;
-  progress.set_total_pixel_samples(show_progress ? tile_manager.state.total_pixel_samples : 0);
+  /* Tile and work scheduling. */
+  tile_manager_.reset_scheduling(buffer_params_, get_effective_tile_size());
+  render_scheduler_.reset(buffer_params_, params.samples);
 
-  if (!params.background)
+  /* Passes. */
+  /* When multiple tiles are used SAMPLE_COUNT pass is used to keep track of possible partial
+   * tile results. It is safe to use generic update function here which checks for changes since
+   * changes in tile settings re-creates session, which ensures film is fully updated on tile
+   * changes. */
+  scene->film->update_passes(scene, tile_manager_.has_multiple_tiles());
+
+  /* Update for new state of scene and passes. */
+  buffer_params_.update_passes(scene->passes);
+  tile_manager_.update(buffer_params_, scene);
+
+  /* Progress. */
+  progress.reset_sample();
+  progress.set_total_pixel_samples(buffer_params_.width * buffer_params_.height * params.samples);
+
+  if (!params.background) {
     progress.set_start_time();
+  }
   progress.set_render_start_time();
 }
 
-void Session::reset(BufferParams &buffer_params, int samples)
+void Session::reset(const SessionParams &session_params, const BufferParams &buffer_params)
 {
-  if (device_use_gl_)
-    reset_gpu(buffer_params, samples);
-  else
-    reset_cpu(buffer_params, samples);
+  {
+    thread_scoped_lock reset_lock(delayed_reset_.mutex);
+    thread_scoped_lock pause_lock(pause_mutex_);
+
+    delayed_reset_.do_reset = true;
+    delayed_reset_.session_params = session_params;
+    delayed_reset_.buffer_params = buffer_params;
+
+    path_trace_->cancel();
+  }
+
+  pause_cond_.notify_all();
 }
 
 void Session::set_samples(int samples)
@@ -915,7 +460,22 @@ void Session::set_samples(int samples)
   }
 
   params.samples = samples;
-  tile_manager.set_samples(samples);
+
+  {
+    thread_scoped_lock pause_lock(pause_mutex_);
+    new_work_added_ = true;
+  }
+
+  pause_cond_.notify_all();
+}
+
+void Session::set_time_limit(double time_limit)
+{
+  if (time_limit == params.time_limit) {
+    return;
+  }
+
+  params.time_limit = time_limit;
 
   {
     thread_scoped_lock pause_lock(pause_mutex_);
@@ -948,38 +508,9 @@ void Session::set_pause(bool pause)
   }
 }
 
-void Session::set_denoising(const DenoiseParams &denoising)
+void Session::set_gpu_display(unique_ptr<GPUDisplay> gpu_display)
 {
-  bool need_denoise = denoising.need_denoising_task();
-
-  /* Lock buffers so no denoising operation is triggered while the settings are changed here. */
-  thread_scoped_lock buffers_lock(buffers_mutex_);
-  params.denoising = denoising;
-
-  if (!(params.device.denoisers & denoising.type)) {
-    if (need_denoise) {
-      progress.set_error("Denoiser type not supported by compute device");
-    }
-
-    params.denoising.use = false;
-    need_denoise = false;
-  }
-
-  // TODO(pmours): Query the required overlap value for denoising from the device?
-  tile_manager.slice_overlap = need_denoise && !params.background ? 64 : 0;
-
-  /* Schedule per tile denoising for final renders if we are either denoising or
-   * need prefiltered passes for the native denoiser. */
-  tile_manager.schedule_denoising = need_denoise && !buffers;
-}
-
-void Session::set_denoising_start_sample(int sample)
-{
-  if (sample != params.denoising.start_sample) {
-    params.denoising.start_sample = sample;
-
-    pause_cond_.notify_all();
-  }
+  path_trace_->set_gpu_display(move(gpu_display));
 }
 
 void Session::wait()
@@ -989,81 +520,67 @@ void Session::wait()
     delete session_thread_;
   }
 
-  session_thread_ = NULL;
+  session_thread_ = nullptr;
 }
 
-bool Session::update_scene()
+bool Session::update_scene(int width, int height)
 {
-  /* update camera if dimensions changed for progressive render. the camera
+  /* 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 */
+   * image dimensions passed in. */
   Camera *cam = scene->camera;
-  int width = tile_manager.state.buffer.full_width;
-  int height = tile_manager.state.buffer.full_height;
-  int resolution = tile_manager.state.resolution_divider;
-
-  cam->set_screen_size_and_resolution(width, height, resolution);
+  cam->set_screen_size(width, height);
 
-  /* number of samples is needed by multi jittered
-   * sampling pattern and by baking */
-  Integrator *integrator = scene->integrator;
-  BakeManager *bake_manager = scene->bake_manager;
+  /* First detect which kernel features are used and allocate working memory.
+   * This helps estimate how may device memory is available for the scene and
+   * how much we need to allocate on the host instead. */
+  scene->update_kernel_features();
 
-  if (integrator->get_sampling_pattern() != SAMPLING_PATTERN_SOBOL || bake_manager->get_baking()) {
-    integrator->set_aa_samples(tile_manager.num_samples);
-  }
+  path_trace_->load_kernels();
+  path_trace_->alloc_work_memory();
 
-  bool kernel_switch_needed = false;
-  if (scene->update(progress, kernel_switch_needed)) {
-    if (kernel_switch_needed) {
-      reset(tile_manager.params, params.samples);
-    }
+  if (scene->update(progress)) {
     return true;
   }
+
   return false;
 }
 
+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)
 {
-  int progressive_sample = tile_manager.state.sample;
-  int num_samples = tile_manager.get_num_effective_samples();
+  string status, substatus;
 
-  int tile = progress.get_rendered_tiles();
-  int num_tiles = tile_manager.state.num_tiles;
+  const int current_tile = progress.get_rendered_tiles();
+  const int num_tiles = tile_manager_.get_num_tiles();
 
-  /* update status */
-  string status, substatus;
+  const int current_sample = progress.get_current_sample();
+  const int num_samples = render_scheduler_.get_num_samples();
 
-  if (!params.progressive) {
-    const bool is_cpu = params.device.type == DEVICE_CPU;
-    const bool rendering_finished = (tile == num_tiles);
-    const bool is_last_tile = (tile + 1) == num_tiles;
-
-    substatus = string_printf("Rendered %d/%d Tiles", tile, num_tiles);
-
-    if (!rendering_finished && (device->show_samples() || (is_cpu && is_last_tile))) {
-      /* Some devices automatically support showing the sample number:
-       * - CUDADevice
-       * - OpenCLDevice when using the megakernel (the split kernel renders multiple
-       *   samples at the same time, so the current sample isn't really defined)
-       * - CPUDevice when using one thread
-       * For these devices, the current sample is always shown.
-       *
-       * The other option is when the last tile is currently being rendered by the CPU.
-       */
-      substatus += string_printf(", Sample %d/%d", progress.get_current_sample(), num_samples);
-    }
-    if (params.denoising.use && params.denoising.type != DENOISER_OPENIMAGEDENOISE) {
-      substatus += string_printf(", Denoised %d tiles", progress.get_denoised_tiles());
-    }
-    else if (params.denoising.store_passes && params.denoising.type == DENOISER_NLM) {
-      substatus += string_printf(", Prefiltered %d tiles", progress.get_denoised_tiles());
-    }
+  /* TIle. */
+  if (tile_manager_.has_multiple_tiles()) {
+    substatus = status_append(substatus,
+                              string_printf("Rendered %d/%d Tiles", current_tile, num_tiles));
   }
-  else if (tile_manager.num_samples == Integrator::MAX_SAMPLES)
-    substatus = string_printf("Path Tracing Sample %d", progressive_sample + 1);
-  else
-    substatus = string_printf("Path Tracing Sample %d/%d", progressive_sample + 1, num_samples);
+
+  /* Sample. */
+  if (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));
+  }
+
+  /* TODO(sergey): Denoising status from the path trace. */
 
   if (show_pause) {
     status = "Rendering Paused";
@@ -1080,210 +597,122 @@ void Session::update_status_time(bool show_pause, bool show_done)
   progress.set_status(status, substatus);
 }
 
-bool Session::render_need_denoise(bool &delayed)
+void Session::device_free()
 {
-  delayed = false;
-
-  /* Not supported yet for baking. */
-  if (read_bake_tile_cb) {
-    return false;
-  }
-
-  /* Denoising enabled? */
-  if (!params.denoising.need_denoising_task()) {
-    return false;
-  }
-
-  if (params.background) {
-    /* Background render, only denoise when rendering the last sample. */
-    return tile_manager.done();
-  }
-
-  /* Viewport render. */
-
-  /* It can happen that denoising was already enabled, but the scene still needs an update. */
-  if (scene->film->is_modified() || !scene->film->get_denoising_data_offset()) {
-    return false;
-  }
+  scene->device_free();
+  path_trace_->device_free();
+}
 
-  /* Immediately denoise when we reach the start sample or last sample. */
-  const int num_samples_finished = tile_manager.state.sample + 1;
-  if (num_samples_finished == params.denoising.start_sample ||
-      num_samples_finished == params.samples) {
-    return true;
+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, profiler);
   }
+}
 
-  /* Do not denoise until the sample at which denoising should start is reached. */
-  if (num_samples_finished < params.denoising.start_sample) {
-    return false;
-  }
+/* --------------------------------------------------------------------
+ * Tile and tile pixels aceess.
+ */
 
-  /* Avoid excessive denoising in viewport after reaching a certain amount of samples. */
-  delayed = (tile_manager.state.sample >= 20 &&
-             (time_dt() - last_display_time_) < params.progressive_update_timeout);
-  return !delayed;
+bool Session::has_multiple_render_tiles() const
+{
+  return tile_manager_.has_multiple_tiles();
 }
 
-void Session::render(bool need_denoise)
+int2 Session::get_render_tile_size() const
 {
-  if (buffers && tile_manager.state.sample == tile_manager.range_start_sample) {
-    /* Clear buffers. */
-    buffers->zero();
-  }
-
-  if (tile_manager.state.buffer.width == 0 || tile_manager.state.buffer.height == 0) {
-    return; /* Avoid empty launches. */
-  }
+  return path_trace_->get_render_tile_size();
+}
 
-  /* Add path trace task. */
-  DeviceTask task(DeviceTask::RENDER);
-
-  task.acquire_tile = function_bind(&Session::acquire_tile, this, _2, _1, _3);
-  task.release_tile = function_bind(&Session::release_tile, this, _1, need_denoise);
-  task.map_neighbor_tiles = function_bind(&Session::map_neighbor_tiles, this, _1, _2);
-  task.unmap_neighbor_tiles = function_bind(&Session::unmap_neighbor_tiles, this, _1, _2);
-  task.get_cancel = function_bind(&Progress::get_cancel, &this->progress);
-  task.update_tile_sample = function_bind(&Session::update_tile_sample, this, _1);
-  task.update_progress_sample = function_bind(&Progress::add_samples, &this->progress, _1, _2);
-  task.get_tile_stolen = function_bind(&Session::get_tile_stolen, this);
-  task.need_finish_queue = params.progressive_refine;
-  task.integrator_branched = scene->integrator->get_method() == Integrator::BRANCHED_PATH;
-
-  task.adaptive_sampling.use = (scene->integrator->get_sampling_pattern() ==
-                                SAMPLING_PATTERN_PMJ) &&
-                               scene->dscene.data.film.pass_adaptive_aux_buffer;
-  task.adaptive_sampling.min_samples = scene->dscene.data.integrator.adaptive_min_samples;
-  task.adaptive_sampling.adaptive_step = scene->dscene.data.integrator.adaptive_step;
-
-  /* Acquire render tiles by default. */
-  task.tile_types = RenderTile::PATH_TRACE;
-
-  if (need_denoise) {
-    task.denoising = params.denoising;
-
-    task.pass_stride = scene->film->get_pass_stride();
-    task.target_pass_stride = task.pass_stride;
-    task.pass_denoising_data = scene->film->get_denoising_data_offset();
-    task.pass_denoising_clean = scene->film->get_denoising_clean_offset();
-
-    task.denoising_from_render = true;
-
-    if (tile_manager.schedule_denoising) {
-      /* Acquire denoising tiles during rendering. */
-      task.tile_types |= RenderTile::DENOISE;
-    }
-    else {
-      assert(buffers);
-
-      /* Schedule rendering and wait for it to finish. */
-      device->task_add(task);
-      device->task_wait();
-
-      /* Then run denoising on the whole image at once. */
-      task.type = DeviceTask::DENOISE_BUFFER;
-      task.x = tile_manager.state.buffer.full_x;
-      task.y = tile_manager.state.buffer.full_y;
-      task.w = tile_manager.state.buffer.width;
-      task.h = tile_manager.state.buffer.height;
-      task.buffer = buffers->buffer.device_pointer;
-      task.sample = tile_manager.state.sample;
-      task.num_samples = tile_manager.state.num_samples;
-      tile_manager.state.buffer.get_offset_stride(task.offset, task.stride);
-      task.buffers = buffers;
-    }
-  }
+int2 Session::get_render_tile_offset() const
+{
+  return path_trace_->get_render_tile_offset();
+}
 
-  device->task_add(task);
+string_view Session::get_render_tile_layer() const
+{
+  const BufferParams &buffer_params = path_trace_->get_render_tile_params();
+  return buffer_params.layer;
 }
 
-void Session::copy_to_display_buffer(int sample)
+string_view Session::get_render_tile_view() const
 {
-  /* add film conversion task */
-  DeviceTask task(DeviceTask::FILM_CONVERT);
-
-  task.x = tile_manager.state.buffer.full_x;
-  task.y = tile_manager.state.buffer.full_y;
-  task.w = tile_manager.state.buffer.width;
-  task.h = tile_manager.state.buffer.height;
-  task.rgba_byte = display->rgba_byte.device_pointer;
-  task.rgba_half = display->rgba_half.device_pointer;
-  task.buffer = buffers->buffer.device_pointer;
-  task.sample = sample;
-  tile_manager.state.buffer.get_offset_stride(task.offset, task.stride);
-
-  if (task.w > 0 && task.h > 0) {
-    device->task_add(task);
-    device->task_wait();
-
-    /* set display to new size */
-    display->draw_set(task.w, task.h);
-
-    last_display_time_ = time_dt();
-  }
+  const BufferParams &buffer_params = path_trace_->get_render_tile_params();
+  return buffer_params.view;
+}
 
-  display_outdated_ = false;
+bool Session::copy_render_tile_from_device()
+{
+  return path_trace_->copy_render_tile_from_device();
 }
 
-bool Session::update_progressive_refine(bool cancel)
+bool Session::get_render_tile_pixels(const string &pass_name, int num_components, float *pixels)
 {
-  int sample = tile_manager.state.sample + 1;
-  bool write = sample == tile_manager.num_samples || cancel;
+  /* NOTE: The code relies on a fact that session is fully update and no scene/buffer modification
+   * is happenning while this function runs. */
 
-  double current_time = time_dt();
+  const BufferParams &buffer_params = path_trace_->get_render_tile_params();
 
-  if (current_time - last_update_time_ < params.progressive_update_timeout) {
-    /* If last sample was processed, we need to write buffers anyway. */
-    if (!write && sample != 1)
-      return false;
+  const BufferPass *pass = buffer_params.find_pass(pass_name);
+  if (pass == nullptr) {
+    return false;
   }
 
-  if (params.progressive_refine) {
-    foreach (Tile &tile, tile_manager.state.tiles) {
-      if (!tile.buffers) {
-        continue;
-      }
-
-      RenderTile rtile;
-      rtile.x = tile_manager.state.buffer.full_x + tile.x;
-      rtile.y = tile_manager.state.buffer.full_y + tile.y;
-      rtile.w = tile.w;
-      rtile.h = tile.h;
-      rtile.sample = sample;
-      rtile.buffers = tile.buffers;
-
-      if (write) {
-        if (write_render_tile_cb)
-          write_render_tile_cb(rtile);
-      }
-      else {
-        if (update_render_tile_cb)
-          update_render_tile_cb(rtile, true);
-      }
+  const bool has_denoised_result = path_trace_->has_denoised_result();
+  if (pass->mode == PassMode::DENOISED && !has_denoised_result) {
+    pass = buffer_params.find_pass(pass->type);
+    if (pass == nullptr) {
+      /* Happens when denoised result pass is requested but is never written by the kernel. */
+      return false;
     }
   }
 
-  last_update_time_ = current_time;
+  pass = buffer_params.get_actual_display_pass(pass);
+
+  const float exposure = buffer_params.exposure;
+  const int num_samples = path_trace_->get_num_render_tile_samples();
 
-  return write;
+  PassAccessor::PassAccessInfo pass_access_info(*pass);
+  pass_access_info.use_approximate_shadow_catcher = buffer_params.use_approximate_shadow_catcher;
+  pass_access_info.use_approximate_shadow_catcher_background =
+      pass_access_info.use_approximate_shadow_catcher && !buffer_params.use_transparent_background;
+
+  const PassAccessorCPU pass_accessor(pass_access_info, exposure, num_samples);
+  const PassAccessor::Destination destination(pixels, num_components);
+
+  return path_trace_->get_render_tile_pixels(pass_accessor, destination);
 }
 
-void Session::device_free()
+bool Session::set_render_tile_pixels(const string &pass_name,
+                                     int num_components,
+                                     const float *pixels)
 {
-  scene->device_free();
+  /* NOTE: The code relies on a fact that session is fully update and no scene/buffer modification
+   * is happenning while this function runs. */
+
+  const BufferPass *pass = buffer_params_.find_pass(pass_name);
+  if (!pass) {
+    return false;
+  }
+
+  const float exposure = scene->film->get_exposure();
+  const int num_samples = render_scheduler_.get_num_rendered_samples();
 
-  tile_manager.device_free();
+  const PassAccessor::PassAccessInfo pass_access_info(*pass);
+  PassAccessorCPU pass_accessor(pass_access_info, exposure, num_samples);
+  PassAccessor::Source source(pixels, num_components);
 
-  /* used from background render only, so no need to
-   * re-create render/display buffers here
-   */
+  return path_trace_->set_render_tile_pixels(pass_accessor, source);
 }
 
-void Session::collect_statistics(RenderStats *render_stats)
+/* --------------------------------------------------------------------
+ * Full-frame on-disk storage.
+ */
+
+void Session::process_full_buffer_from_disk(string_view filename)
 {
-  scene->collect_statistics(render_stats);
-  if (params.use_profiling && (params.device.type == DEVICE_CPU)) {
-    render_stats->collect_profiling(scene, profiler);
-  }
+  path_trace_->process_full_buffer_from_disk(filename);
 }
 
 CCL_NAMESPACE_END