This is missing a description about what it is, and what a lower or higher value accomplishes.

This description could be extended to describe in which cases you might want to increase this, which problem it solves.

soft_max could be 4096 here, but hard max should be the same as samples I think ((1 << 24)).

Ideally adding this pass should not be done in the Blender integration, but somehow automatically when adaptive sampling is enabled in the integrator.

It could be done similar to the denoising passes that do not need to be output I think.

No need to use bitmask here for effiency. Better to be clear with something like:

const int adaptive_sample_step = 4;
(sample % adaptive_samples_step ==  adaptive_samples_step - 1)

Also would prefer to have this code in a separate function.

if (task.integrator_adaptive && adaptive_sample_stop(tile, sample)) {
  tile.sample = end_sample;
  break
}

Same goes for other devices.

Put in a separate function, like,

if (task.integrator_adaptive) {
  adaptive_sample_scale(tile, kg);
}

Further there seems to be some duplication of logic between devices here. I think kernel_adaptive_post_adjust could be kept private to the kernel, and instead add this in kernel_adaptive_sampling.h and use it for all devices.

ccl_device_inline void kernel_adaptive_scale_sample(KernelGlobals *kg, ccl_global float *buffer, int start_sample, int sample)
{
  if (buffer[kernel_data.film.pass_sample_count] < 0.0f) {
    buffer[kernel_data.film.pass_sample_count] = -buffer[kernel_data.film.pass_sample_count];
    float sample_multiplier = sample / max((float)start_sample + 1.0f,
                                           buffer[kernel_data.film.pass_sample_count]);
    if (sample_multiplier != 1.0f) {
      kernel_adaptive_post_adjust(&kg, buffer, sample_multiplier);
    }
  }
  else {
    kernel_adaptive_post_adjust(&kg, buffer, sample / (sample - 1.0f));
  }
}

It's a problem that different GPUs will have a different number of samples at which it checks the stopping criterion. That makes both CPU + GPU rendering, or rendering on a farm with CPU and GPUs not work well.

Solving this is tricky though, the bigger the tile size the more fine grained adaptive stopping we can do. Rendering multiple small tiles at once could help to some extent, but there are performance and memory usage reasons to prefer small tiles too.

I think we could commit this as is, but mention it in the release notes at least, and try to find a solution after this is committed.

In path termination we use sqrt() to approximate a typical view transform, or alternatively interpreted to be more conservative in dark areas.

I guess it's worth trying something simple like that. Doesn't have to be done for the first commit.

This is ok for now, but later on we should probably do some refactoring so this doesn't duplicate so much logic from kernel_passes.h, I made a note about that in T72293.

Put these in kernel_types.h for use in integrator.c.

Also, knowing that the max number of samples is 4096, sample_is_even could be optimized by leaving out most of the terms, though not sure if that's performance critical.

Can you add a CMJ feature and #ifdef __PMJ__ for code like this?

Convenient for testing and maybe adaptive compilation in the future.

Put this in a pmj_sample_1D utility function.

Put this in a pmj_sample_2D utility function.

Why is this specific to the combined pass, not sure why that would need to be treated different than other passes?

I don't these should be a use_adaptive_sampling boolean here. This would force the PMJ pattern to be used, which I think is better than assuming that PMJ means adaptive sampling.

Use constants from kernel_types.h instead here.

It would be good to have a comment here explaining why this uses a fixed number of samples, and perhaps what might be done to improve it in the future.