Faster texture initialization

Loading bitmap textures was surprisingly inefficient in scalar mode: it
turns out that the bitmap constructor spends a significant portion of
time zero-initializing arrays and copying the texture. This commit
enables/adds move constructors to avoid these unnecessary steps.

Author: wjakob

ext/drjit

@@ -620,7 +620,7 @@ class SunskyEmitter final : public Emitter<Float, Spectrum> {
 
         Spec c1 = 1 + coefs[0] * dr::exp(coefs[1] / (cos_theta + 0.01f));
         Spec chi = (1 + cos_gamma_sqr) /
-                   dr::pow(1 + dr::square(coefs[8]) - 2 * coefs[8] * cos_gamma, 1.5);
+                   dr::pow(1 + dr::square(coefs[8]) - 2 * coefs[8] * cos_gamma, 1.5f);
         Spec c2 = coefs[2] + coefs[3] * dr::exp(coefs[4] * gamma) +
                   coefs[5] * cos_gamma_sqr + coefs[6] * chi +
                   coefs[7] * dr::safe_sqrt(cos_theta);

src/emitters/sunsky.cpp

@@ -15,11 +15,11 @@
 #include <drjit/texture.h>
 
 #if defined(MI_ENABLE_EMBREE)
-#include <embree3/rtcore.h>
+#  include <embree3/rtcore.h>
 #endif
 
 #if defined(MI_ENABLE_CUDA)
-#include "optix/sdfgrid.cuh"
+#  include "optix/sdfgrid.cuh"
 #endif
 
 NAMESPACE_BEGIN(mitsuba)
@@ -164,8 +164,9 @@ class SDFGrid final : public Shape<Float, Spectrum> {
             if (tensor->shape(3) != 1)
                 Throw("SDF grid shape at index 3 is %lu, expected 1",
                       tensor->shape(3));
-            m_grid_texture = InputTexture3f(*tensor, true, true,
-                dr::FilterMode::Linear, dr::WrapMode::Clamp);
+            m_grid_texture = InputTexture3f(
+                (const typename InputTexture3f::TensorXf &) *tensor,
+                true, true, dr::FilterMode::Linear, dr::WrapMode::Clamp);
         } else {
             Throw("The SDF values must be specified with either the "
                   "\"filename\" or \"grid\" parameter!");

src/shapes/sdfgrid.cpp

@@ -322,7 +322,7 @@ class BitmapTexture final : public Texture<Float, Spectrum> {
             m_wrap_mode,
             m_raw,
             m_accel,
-            tensor);
+            std::move(tensor));
     }
 
 private:
@@ -367,35 +367,37 @@ class BitmapTextureImpl : public Texture<Float, Spectrum> {
     using StoredTensorXf         = dr::replace_scalar_t<TensorXf, StoredScalar>;
     using StoredTexture2f        = dr::Texture<StoredType, 2>;
 
+    template <typename Tensor>
     BitmapTextureImpl(const Properties &props,
-            const std::string& name,
-            const ScalarTransform3f& transform,
-            dr::FilterMode filter_mode,
-            dr::WrapMode wrap_mode,
-            bool raw,
-            bool accel,
-            StoredTensorXf& tensor) :
+                      const std::string& name,
+                      const ScalarTransform3f& transform,
+                      dr::FilterMode filter_mode,
+                      dr::WrapMode wrap_mode,
+                      bool raw,
+                      bool accel,
+                      Tensor&& tensor) :
         Texture(props),
         m_name(name),
         m_transform(transform),
         m_accel(accel),
-        m_raw(raw),
-        m_texture(tensor, accel, accel, filter_mode, wrap_mode) {
+        m_raw(raw) {
 
         /* Compute mean without migrating texture data
            i.e. Avoid call to m_texture.tensor() that triggers migration.
            For CUDA-variants, ideally want to solely keep data as CUDA texture
         */
         rebuild_internals(tensor, true, false);
+
+        m_texture = StoredTexture2f(std::forward<Tensor>(tensor), accel, accel,
+                                    filter_mode, wrap_mode);
     }
 
     void traverse(TraversalCallback *callback) override {
         callback->put_parameter("data",  m_texture.tensor(), +ParamFlags::Differentiable);
         callback->put_parameter("to_uv", m_transform,        +ParamFlags::NonDifferentiable);
     }
 
-    void
-    parameters_changed(const std::vector<std::string> &keys = {}) override {
+    void parameters_changed(const std::vector<std::string> &keys = {}) override {
         if (keys.empty() || string::contains(keys, "data")) {
             const size_t channels = m_texture.shape()[2];
             if (channels != 1 && channels != 3)
@@ -801,13 +803,14 @@ class BitmapTextureImpl : public Texture<Float, Spectrum> {
         if (m_transform != ScalarTransform3f())
             dr::make_opaque(m_transform);
 
-        size_t pixel_count = (size_t) dr::prod(resolution());
-        const size_t channels = m_texture.shape()[2];
-        bool range_issue = false;
+        const dr::vector<size_t> &shape = tensor.shape();
+        size_t pixel_count = shape[0] * shape[1],
+               channels    = shape[2];
 
+        bool range_issue = false;
         using FloatStorage = DynamicBuffer<Float>;
         using StoredTypeArray= DynamicBuffer<StoredType>;
-        FloatStorage values = dr::empty<FloatStorage>(pixel_count);
+        FloatStorage values;
 
         if (channels == 3) {
             if constexpr (dr::is_jit_v<Float>) {
@@ -824,7 +827,11 @@ class BitmapTextureImpl : public Texture<Float, Spectrum> {
                     values = luminance(colors_fl);
             } else {
                 StoredScalar* ptr = (StoredScalar*) tensor.data();
-                ScalarFloat *out = values.data(), mean = 0;
+                ScalarFloat *out = nullptr, mean = 0;
+                if (init_distr) {
+                    values = dr::empty<FloatStorage>(pixel_count);
+                    out = values.data();
+                }
 
                 for (size_t i = 0; i < pixel_count; ++i) {
                     Color3f col(ptr[0], ptr[1], ptr[2]);
@@ -836,7 +843,8 @@ class BitmapTextureImpl : public Texture<Float, Spectrum> {
                     else
                         lum = luminance(col);
 
-                    *out++ = lum;
+                    if (init_distr)
+                        *out++ = lum;
                     mean += lum;
                     range_issue |= lum < 0 || lum > 1;
                 }
@@ -848,11 +856,16 @@ class BitmapTextureImpl : public Texture<Float, Spectrum> {
                 values = tensor.array();
             } else {
                 StoredScalar* ptr = (StoredScalar*) tensor.data();
-                ScalarFloat *out = values.data(), mean = 0;
+                ScalarFloat *out = nullptr, mean = 0;
+                if (init_distr) {
+                    values = dr::empty<FloatStorage>(pixel_count);
+                    out = values.data();
+                }
                 for (size_t i = 0; i < pixel_count; ++i) {
                     ScalarFloat value = ptr[i];
-                    *out++ = value;
-                    m_mean += value;
+                    if (init_distr)
+                        *out++ = value;
+                    mean += value;
                     range_issue |= value < 0 || value > 1;
                 }
                 m_mean = mean / pixel_count;