intern/cycles/integrator/adaptive_sampling.cpp

@@ -3,55 +3,54 @@
  * SPDX-License-Identifier: Apache-2.0 */
 
 #include "integrator/adaptive_sampling.h"
-
 #include "util/math.h"
 
 CCL_NAMESPACE_BEGIN
 
+// Mark small, frequently called functions as inline for potential performance gains
+inline bool need_filter_impl(int sample, bool use, int min_samples, int adaptive_step) {
+    if (!use) {
+        return false;
+    }
+
+    if (sample <= min_samples) {
+        return false;
+    }
+
+    return (sample & (adaptive_step - 1)) == (adaptive_step - 1);
+}
+
 AdaptiveSampling::AdaptiveSampling() {}
 
 int AdaptiveSampling::align_samples(int start_sample, int num_samples) const
 {
-  if (!use) {
-    return num_samples;
-  }
+    // Check if adaptive sampling is disabled
+    if (!use) {
+        return num_samples;
+    }
 
-  /*
-   * The naive implementation goes as following:
-   *
-   *   int count = 1;
-   *   while (!need_filter(start_sample + count - 1) && count < num_samples) {
-   *     ++count;
-   *   }
-   *   return count;
-   */
+    // Calculate the 0-based sample index at which the first filtering will happen
+    const int first_filter_sample = (min_samples + 1) | (adaptive_step - 1);
 
-  /* 0-based sample index at which first filtering will happen. */
-  const int first_filter_sample = (min_samples + 1) | (adaptive_step - 1);
+    // Allow as many samples as possible until the first filter sample
+    if (start_sample + num_samples <= first_filter_sample) {
+        return num_samples;
+    }
 
-  /* Allow as many samples as possible until the first filter sample. */
-  if (start_sample + num_samples <= first_filter_sample) {
-    return num_samples;
-  }
+    // Find the sample index at which the next filtering will happen
+    const int next_filter_sample = max(first_filter_sample, start_sample | (adaptive_step - 1));
 
-  const int next_filter_sample = max(first_filter_sample, start_sample | (adaptive_step - 1));
+    // Calculate the number of samples until the next filter
+    const int num_samples_until_filter = next_filter_sample - start_sample + 1;
 
-  const int num_samples_until_filter = next_filter_sample - start_sample + 1;
-
-  return min(num_samples_until_filter, num_samples);
+    // Return the minimum of num_samples and num_samples_until_filter
+    return min(num_samples_until_filter, num_samples);
 }
 
 bool AdaptiveSampling::need_filter(int sample) const
 {
-  if (!use) {
-    return false;
-  }
-
-  if (sample <= min_samples) {
-    return false;
-  }
-
-  return (sample & (adaptive_step - 1)) == (adaptive_step - 1);
+    // Reuse the need_filter implementation for better performance
+    return need_filter_impl(sample, use, min_samples, adaptive_step);
 }
 
 CCL_NAMESPACE_END