fixed limits for long multi-pass renderings

Author: wjakob

src/render/integrator.cpp

@@ -200,22 +200,22 @@ SamplingIntegrator<Float, Spectrum>::render(Scene *scene,
     } else {
         size_t wavefront_size = (size_t) film_size.x() *
                                 (size_t) film_size.y() * (size_t) spp_per_pass,
-               wavefront_size_limit =
-                   dr::is_llvm_v<Float> ? 0xffffffffu : 0x40000000u;
+               wavefront_size_limit = 0xffffffffu;
 
         if (wavefront_size > wavefront_size_limit) {
-            spp_per_pass /= (uint32_t) ((wavefront_size + wavefront_size_limit - 1) / wavefront_size_limit);
-            n_passes = spp / spp_per_pass;
+            spp_per_pass /=
+                (uint32_t)((wavefront_size + wavefront_size_limit - 1) /
+                           wavefront_size_limit);
+            n_passes       = spp / spp_per_pass;
             wavefront_size = (size_t) film_size.x() * (size_t) film_size.y() *
                              (size_t) spp_per_pass;
 
             Log(Warn,
                 "The requested rendering task involves %zu Monte Carlo "
-                "samples, which exceeds the upper limit of 2^%zu = %zu for "
-                "this variant. Mitsuba will instead split the rendering task "
-                "%zu smaller passes to avoid exceeding the limits.",
-                wavefront_size, dr::log2i(wavefront_size_limit + 1),
-                wavefront_size_limit, n_passes);
+                "samples, which exceeds the upper limit of 2^32 = 4294967296 "
+                "for this variant. Mitsuba will instead split the rendering "
+                "task into %zu smaller passes to avoid exceeding the limits.",
+                wavefront_size, n_passes);
         }
 
         dr::sync_thread(); // Separate from scene initialization (for timings)
@@ -632,22 +632,21 @@ AdjointIntegrator<Float, Spectrum>::render(Scene *scene,
             evaluate = true;
         }
 
-        size_t wavefront_size_limit =
-            dr::is_llvm_v<Float> ? 0xffffffffu : 0x40000000u;
-
+        constexpr size_t wavefront_size_limit = 0xffffffffu;
         if (samples_per_pass > wavefront_size_limit) {
-            spp_per_pass /= (uint32_t) ((samples_per_pass + wavefront_size_limit - 1) / wavefront_size_limit);
+            spp_per_pass /=
+                (uint32_t)((samples_per_pass + wavefront_size_limit - 1) /
+                           wavefront_size_limit);
             n_passes = spp / spp_per_pass;
             samples_per_pass = (size_t) film_size.x() * (size_t) film_size.y() *
                                (size_t) spp_per_pass;
 
             Log(Warn,
                 "The requested rendering task involves %zu Monte Carlo "
-                "samples, which exceeds the upper limit of 2^%zu = %zu for "
-                "this variant. Mitsuba will instead split the rendering task "
-                "%zu smaller passes to avoid exceeding the limits.",
-                samples_per_pass, dr::log2i(wavefront_size_limit + 1),
-                wavefront_size_limit, n_passes);
+                "samples, which exceeds the upper limit of 2^32 = 4294967296 "
+                "for this variant. Mitsuba will instead split the rendering "
+                "task into %zu smaller passes to avoid exceeding the limits.",
+                samples_per_pass, n_passes);
         }
 
         Log(Info, "Starting render job (%ux%u, %u sample%s%s)",

src/render/sampler.cpp

@@ -32,7 +32,7 @@ MI_VARIANT Sampler<Float, Spectrum>::Sampler(const Sampler &sampler)
 MI_VARIANT Sampler<Float, Spectrum>::~Sampler() { }
 
 MI_VARIANT void Sampler<Float, Spectrum>::seed(uint32_t /* seed */,
-                                                uint32_t wavefront_size) {
+                                               uint32_t wavefront_size) {
     if constexpr (dr::is_array_v<Float>) {
         // Only overwrite when specified
         if (wavefront_size != (uint32_t) -1) {

src/samplers/independent.cpp

@@ -68,8 +68,8 @@ template <typename Float, typename Spectrum>
 class IndependentSampler final : public PCG32Sampler<Float, Spectrum> {
 public:
     MI_IMPORT_BASE(PCG32Sampler, m_sample_count, m_base_seed, m_rng, seed,
-                    seeded, m_samples_per_wavefront, m_wavefront_size,
-                    schedule_state)
+                   seeded, m_samples_per_wavefront, m_wavefront_size,
+                   schedule_state)
     MI_IMPORT_TYPES()
 
     IndependentSampler(const Properties &props) : Base(props) { }

src/samplers/stratified.cpp

@@ -67,8 +67,8 @@ template <typename Float, typename Spectrum>
 class StratifiedSampler final : public PCG32Sampler<Float, Spectrum> {
 public:
     MI_IMPORT_BASE(PCG32Sampler, m_sample_count, m_base_seed, m_rng, seeded,
-                    m_samples_per_wavefront, m_dimension_index,
-                    current_sample_index, compute_per_sequence_seed)
+                   m_samples_per_wavefront, m_dimension_index,
+                   current_sample_index, compute_per_sequence_seed)
     MI_IMPORT_TYPES()
 
     StratifiedSampler(const Properties &props) : Base(props) {