Code refactor: use split variance calculation for mega kernels too.

There is no significant difference in denoised benchmark scenes and
denoising ctests, so might as well make it all consistent.

6 files changed, 25 insertions, 76 deletions

diff --git a/intern/cycles/kernel/filter/filter_prefilter.h b/intern/cycles/kernel/filter/filter_prefilter.h
index 2aeb54a62be..eefcbfea230 100644
--- a/intern/cycles/kernel/filter/filter_prefilter.h
+++ b/intern/cycles/kernel/filter/filter_prefilter.h
@@ -35,8 +35,7 @@ ccl_device void kernel_filter_divide_shadow(int sample,
                                             ccl_global float *bufferVariance,
                                             int4 rect,
                                             int buffer_pass_stride,
-                                            int buffer_denoising_offset,
-                                            bool use_split_variance)
+                                            int buffer_denoising_offset)
 {
 	int xtile = (x < tiles->x[1])? 0: ((x < tiles->x[2])? 1: 2);
 	int ytile = (y < tiles->y[1])? 0: ((y < tiles->y[2])? 1: 2);
@@ -57,10 +56,12 @@ ccl_device void kernel_filter_divide_shadow(int sample,
 	float varB = center_buffer[5];
 	int odd_sample = (sample+1)/2;
 	int even_sample = sample/2;
-	if(use_split_variance) {
-		varA = max(0.0f, varA - unfilteredA[idx]*unfilteredA[idx]*odd_sample);
-		varB = max(0.0f, varB - unfilteredB[idx]*unfilteredB[idx]*even_sample);
-	}
+
+	/* Approximate variance as E[x^2] - 1/N * (E[x])^2, since online variance
+	 * update does not work efficiently with atomics in the kernel. */
+	varA = max(0.0f, varA - unfilteredA[idx]*unfilteredA[idx]*odd_sample);
+	varB = max(0.0f, varB - unfilteredB[idx]*unfilteredB[idx]*even_sample);
+
 	varA /= max(odd_sample - 1, 1);
 	varB /= max(even_sample - 1, 1);
 
@@ -84,8 +85,7 @@ ccl_device void kernel_filter_get_feature(int sample,
                                           ccl_global float *mean,
                                           ccl_global float *variance,
                                           int4 rect, int buffer_pass_stride,
-                                          int buffer_denoising_offset,
-                                          bool use_split_variance)
+                                          int buffer_denoising_offset)
 {
 	int xtile = (x < tiles->x[1])? 0: ((x < tiles->x[2])? 1: 2);
 	int ytile = (y < tiles->y[1])? 0: ((y < tiles->y[2])? 1: 2);
@@ -97,12 +97,9 @@ ccl_device void kernel_filter_get_feature(int sample,
 
 	mean[idx] = center_buffer[m_offset] / sample;
 	if(sample > 1) {
-		if(use_split_variance) {
-			variance[idx] = max(0.0f, (center_buffer[v_offset] - mean[idx]*mean[idx]*sample) / (sample * (sample-1)));
-		}
-		else {
-			variance[idx] = center_buffer[v_offset] / (sample * (sample-1));
-		}
+		/* Approximate variance as E[x^2] - 1/N * (E[x])^2, since online variance
+		 * update does not work efficiently with atomics in the kernel. */
+		variance[idx] = max(0.0f, (center_buffer[v_offset] - mean[idx]*mean[idx]*sample) / (sample * (sample-1)));
 	}
 	else {
 		/* Can't compute variance with single sample, just set it very high. */
diff --git a/intern/cycles/kernel/kernel_passes.h b/intern/cycles/kernel/kernel_passes.h
index fff7f4cfdb7..bd756185e78 100644
--- a/intern/cycles/kernel/kernel_passes.h
+++ b/intern/cycles/kernel/kernel_passes.h
@@ -67,18 +67,7 @@ ccl_device_inline void kernel_write_pass_float_variance(ccl_global float *buffer
 
 	/* The online one-pass variance update that's used for the megakernel can't easily be implemented
 	 * with atomics, so for the split kernel the E[x^2] - 1/N * (E[x])^2 fallback is used. */
-#  ifdef __SPLIT_KERNEL__
 	kernel_write_pass_float(buffer+1, sample, value*value);
-#  else
-	if(sample == 0) {
-		kernel_write_pass_float(buffer+1, sample, 0.0f);
-	}
-	else {
-		float new_mean = buffer[0] * (1.0f / (sample + 1));
-		float old_mean = (buffer[0] - value) * (1.0f / sample);
-		kernel_write_pass_float(buffer+1, sample, (value - new_mean) * (value - old_mean));
-	}
-#  endif
 }
 
 #  if defined(__SPLIT_KERNEL__)
@@ -95,19 +84,7 @@ ccl_device_inline void kernel_write_pass_float3_unaligned(ccl_global float *buff
 ccl_device_inline void kernel_write_pass_float3_variance(ccl_global float *buffer, int sample, float3 value)
 {
 	kernel_write_pass_float3_unaligned(buffer, sample, value);
-#  ifdef __SPLIT_KERNEL__
 	kernel_write_pass_float3_unaligned(buffer+3, sample, value*value);
-#  else
-	if(sample == 0) {
-		kernel_write_pass_float3_unaligned(buffer+3, sample, make_float3(0.0f, 0.0f, 0.0f));
-	}
-	else {
-		float3 sum = make_float3(buffer[0], buffer[1], buffer[2]);
-		float3 new_mean = sum * (1.0f / (sample + 1));
-		float3 old_mean = (sum - value) * (1.0f / sample);
-		kernel_write_pass_float3_unaligned(buffer+3, sample, (value - new_mean) * (value - old_mean));
-	}
-#  endif
 }
 
 ccl_device_inline void kernel_write_denoising_shadow(KernelGlobals *kg, ccl_global float *buffer,
@@ -125,18 +102,7 @@ ccl_device_inline void kernel_write_denoising_shadow(KernelGlobals *kg, ccl_glob
 	kernel_write_pass_float(buffer+1, sample/2, path_total_shaded);
 
 	float value = path_total_shaded / max(path_total, 1e-7f);
-#  ifdef __SPLIT_KERNEL__
 	kernel_write_pass_float(buffer+2, sample/2, value*value);
-#  else
-	if(sample < 2) {
-		kernel_write_pass_float(buffer+2, sample/2, 0.0f);
-	}
-	else {
-		float old_value = (buffer[1] - path_total_shaded) / max(buffer[0] - path_total, 1e-7f);
-		float new_value = buffer[1] / max(buffer[0], 1e-7f);
-		kernel_write_pass_float(buffer+2, sample, (value - new_value) * (value - old_value));
-	}
-#  endif
 }
 #endif /* __DENOISING_FEATURES__ */
 
diff --git a/intern/cycles/kernel/kernels/cpu/filter_cpu.h b/intern/cycles/kernel/kernels/cpu/filter_cpu.h
index 2ed713299fd..bf13ba62806 100644
--- a/intern/cycles/kernel/kernels/cpu/filter_cpu.h
+++ b/intern/cycles/kernel/kernels/cpu/filter_cpu.h
@@ -27,8 +27,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_divide_shadow)(int sample,
                                                      float *bufferV,
                                                      int* prefilter_rect,
                                                      int buffer_pass_stride,
-                                                     int buffer_denoising_offset,
-                                                     bool use_split_variance);
+                                                     int buffer_denoising_offset);
 
 void KERNEL_FUNCTION_FULL_NAME(filter_get_feature)(int sample,
                                                    TilesInfo *tiles,
@@ -40,8 +39,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_get_feature)(int sample,
                                                    float *variance,
                                                    int* prefilter_rect,
                                                    int buffer_pass_stride,
-                                                   int buffer_denoising_offset,
-                                                   bool use_split_variance);
+                                                   int buffer_denoising_offset);
 
 void KERNEL_FUNCTION_FULL_NAME(filter_detect_outliers)(int x, int y,
                                                        ccl_global float *image,
diff --git a/intern/cycles/kernel/kernels/cpu/filter_cpu_impl.h b/intern/cycles/kernel/kernels/cpu/filter_cpu_impl.h
index 8dc1a8d583c..2fbb0ea2bdb 100644
--- a/intern/cycles/kernel/kernels/cpu/filter_cpu_impl.h
+++ b/intern/cycles/kernel/kernels/cpu/filter_cpu_impl.h
@@ -45,8 +45,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_divide_shadow)(int sample,
                                                      float *bufferVariance,
                                                      int* prefilter_rect,
                                                      int buffer_pass_stride,
-                                                     int buffer_denoising_offset,
-                                                     bool use_split_variance)
+                                                     int buffer_denoising_offset)
 {
 #ifdef KERNEL_STUB
 	STUB_ASSERT(KERNEL_ARCH, filter_divide_shadow);
@@ -60,8 +59,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_divide_shadow)(int sample,
 	                            bufferVariance,
 	                            load_int4(prefilter_rect),
 	                            buffer_pass_stride,
-	                            buffer_denoising_offset,
-	                            use_split_variance);
+	                            buffer_denoising_offset);
 #endif
 }
 
@@ -74,8 +72,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_get_feature)(int sample,
                                                    float *mean, float *variance,
                                                    int* prefilter_rect,
                                                    int buffer_pass_stride,
-                                                   int buffer_denoising_offset,
-                                                   bool use_split_variance)
+                                                   int buffer_denoising_offset)
 {
 #ifdef KERNEL_STUB
 	STUB_ASSERT(KERNEL_ARCH, filter_get_feature);
@@ -86,8 +83,7 @@ void KERNEL_FUNCTION_FULL_NAME(filter_get_feature)(int sample,
 	                          mean, variance,
 	                          load_int4(prefilter_rect),
 	                          buffer_pass_stride,
-	                          buffer_denoising_offset,
-	                          use_split_variance);
+	                          buffer_denoising_offset);
 #endif
 }
 
diff --git a/intern/cycles/kernel/kernels/cuda/filter.cu b/intern/cycles/kernel/kernels/cuda/filter.cu
index 009c3fde9d5..c8172355a7f 100644
--- a/intern/cycles/kernel/kernels/cuda/filter.cu
+++ b/intern/cycles/kernel/kernels/cuda/filter.cu
@@ -37,8 +37,7 @@ kernel_cuda_filter_divide_shadow(int sample,
                                  float *bufferVariance,
                                  int4 prefilter_rect,
                                  int buffer_pass_stride,
-                                 int buffer_denoising_offset,
-                                 bool use_split_variance)
+                                 int buffer_denoising_offset)
 {
 	int x = prefilter_rect.x + blockDim.x*blockIdx.x + threadIdx.x;
 	int y = prefilter_rect.y + blockDim.y*blockIdx.y + threadIdx.y;
@@ -53,8 +52,7 @@ kernel_cuda_filter_divide_shadow(int sample,
 		                            bufferVariance,
 		                            prefilter_rect,
 		                            buffer_pass_stride,
-		                            buffer_denoising_offset,
-		                            use_split_variance);
+		                            buffer_denoising_offset);
 	}
 }
 
@@ -68,8 +66,7 @@ kernel_cuda_filter_get_feature(int sample,
                                float *variance,
                                int4 prefilter_rect,
                                int buffer_pass_stride,
-                               int buffer_denoising_offset,
-                               bool use_split_variance)
+                               int buffer_denoising_offset)
 {
 	int x = prefilter_rect.x + blockDim.x*blockIdx.x + threadIdx.x;
 	int y = prefilter_rect.y + blockDim.y*blockIdx.y + threadIdx.y;
@@ -81,8 +78,7 @@ kernel_cuda_filter_get_feature(int sample,
 		                          mean, variance,
 		                          prefilter_rect,
 		                          buffer_pass_stride,
-		                          buffer_denoising_offset,
-		                          use_split_variance);
+		                          buffer_denoising_offset);
 	}
 }
 
diff --git a/intern/cycles/kernel/kernels/opencl/filter.cl b/intern/cycles/kernel/kernels/opencl/filter.cl
index f015ac47d8a..7a7b596a350 100644
--- a/intern/cycles/kernel/kernels/opencl/filter.cl
+++ b/intern/cycles/kernel/kernels/opencl/filter.cl
@@ -31,8 +31,7 @@ __kernel void kernel_ocl_filter_divide_shadow(int sample,
                                               ccl_global float *bufferVariance,
                                               int4 prefilter_rect,
                                               int buffer_pass_stride,
-                                              int buffer_denoising_offset,
-                                              char use_split_variance)
+                                              int buffer_denoising_offset)
 {
 	int x = prefilter_rect.x + get_global_id(0);
 	int y = prefilter_rect.y + get_global_id(1);
@@ -47,8 +46,7 @@ __kernel void kernel_ocl_filter_divide_shadow(int sample,
 		                            bufferVariance,
 		                            prefilter_rect,
 		                            buffer_pass_stride,
-		                            buffer_denoising_offset,
-		                            use_split_variance);
+		                            buffer_denoising_offset);
 	}
 }
 
@@ -60,8 +58,7 @@ __kernel void kernel_ocl_filter_get_feature(int sample,
                                             ccl_global float *variance,
                                             int4 prefilter_rect,
                                             int buffer_pass_stride,
-                                            int buffer_denoising_offset,
-                                            char use_split_variance)
+                                            int buffer_denoising_offset)
 {
 	int x = prefilter_rect.x + get_global_id(0);
 	int y = prefilter_rect.y + get_global_id(1);
@@ -73,8 +70,7 @@ __kernel void kernel_ocl_filter_get_feature(int sample,
 		                          mean, variance,
 		                          prefilter_rect,
 		                          buffer_pass_stride,
-		                          buffer_denoising_offset,
-		                          use_split_variance);
+		                          buffer_denoising_offset);
 	}
 }