Cycles: optimize device updates

This optimizes device updates (during user edits or frame changes in
the viewport) by avoiding unnecessary computations. To achieve this,
we use a combination of the sockets' update flags as well as some new
flags passed to the various managers when tagging for an update to tell
exactly what the tagging is for (e.g. shader was modified, object was
removed, etc.).

Besides avoiding recomputations, we also avoid resending to the devices
unmodified data arrays, thus reducing bandwidth usage. For OptiX and
Embree, BVH packing was also multithreaded.

The performance improvements may vary depending on the used device (CPU
or GPU), and the content of the scene. Simple scenes (e.g. with no adaptive
subdivision or volumes) rendered using OptiX will benefit from this work
the most.

On average, for a variety of animated scenes, this gives a 3x speedup.

Reviewed By: #cycles, brecht

Maniphest Tasks: T79174

Differential Revision: https://developer.blender.org/D9555

1 files changed, 67 insertions, 2 deletions

diff --git a/intern/cycles/device/device_memory.h b/intern/cycles/device/device_memory.h
index 00b2aa864aa..1f63a152458 100644
--- a/intern/cycles/device/device_memory.h
+++ b/intern/cycles/device/device_memory.h
@@ -259,6 +259,8 @@ class device_memory {
   device_ptr original_device_ptr;
   size_t original_device_size;
   Device *original_device;
+  bool need_realloc_;
+  bool modified;
 };
 
 /* Device Only Memory
@@ -329,6 +331,8 @@ template<typename T> class device_vector : public device_memory {
   {
     data_type = device_type_traits<T>::data_type;
     data_elements = device_type_traits<T>::num_elements;
+    modified = true;
+    need_realloc_ = true;
 
     assert(data_elements > 0);
   }
@@ -347,6 +351,7 @@ template<typename T> class device_vector : public device_memory {
       device_free();
       host_free();
       host_pointer = host_alloc(sizeof(T) * new_size);
+      modified = true;
       assert(device_pointer == 0);
     }
 
@@ -400,6 +405,19 @@ template<typename T> class device_vector : public device_memory {
     assert(device_pointer == 0);
   }
 
+  void give_data(array<T> &to)
+  {
+    device_free();
+
+    to.set_data((T *)host_pointer, data_size);
+    data_size = 0;
+    data_width = 0;
+    data_height = 0;
+    data_depth = 0;
+    host_pointer = 0;
+    assert(device_pointer == 0);
+  }
+
   /* Free device and host memory. */
   void free()
   {
@@ -411,10 +429,40 @@ template<typename T> class device_vector : public device_memory {
     data_height = 0;
     data_depth = 0;
     host_pointer = 0;
+    modified = true;
+    need_realloc_ = true;
     assert(device_pointer == 0);
   }
 
-  size_t size()
+  void free_if_need_realloc(bool force_free)
+  {
+    if (need_realloc_ || force_free) {
+      free();
+    }
+  }
+
+  bool is_modified() const
+  {
+    return modified;
+  }
+
+  bool need_realloc()
+  {
+    return need_realloc_;
+  }
+
+  void tag_modified()
+  {
+    modified = true;
+  }
+
+  void tag_realloc()
+  {
+    need_realloc_ = true;
+    tag_modified();
+  }
+
+  size_t size() const
   {
     return data_size;
   }
@@ -432,7 +480,24 @@ template<typename T> class device_vector : public device_memory {
 
   void copy_to_device()
   {
-    device_copy_to();
+    if (data_size != 0) {
+      device_copy_to();
+    }
+  }
+
+  void copy_to_device_if_modified()
+  {
+    if (!modified) {
+      return;
+    }
+
+    copy_to_device();
+  }
+
+  void clear_modified()
+  {
+    modified = false;
+    need_realloc_ = false;
   }
 
   void copy_from_device()