This seems to be almost exact copy of rgb_ramp_lookup(). Think it should be possible to introduce svm_ramp_util.h with implementation of ramp lookup understandable by both kernel and SVM compiler.

This doesn't follow Cycles code style.

As stated at the top, this is an almost exact copy of the similar function for OSL - the reason for it being that the SVM code is way too ugly to be easily understood, and even uses float4 which the nodes definitely don't. The only changes here are the function header, call to ramp.size() and the 'f' suffix to all the floating point constants.

Incidentally, speaking of code duplication, that osl function is itself copied verbatim in two osl files, despite osl evidently supporting include.

Since it's essentially the same code, potentially this curves function can be merged with the original OSL version with some #defines and #ifdefs - OSL apparently is supposed to support full C preprocessor. Of course, sharing C++ and OSL code is a bit suspect.

It shouldn't be hard to make some changes to SVM code to make rgb_ramp_lookup() re-usable here. Could be an inlined utility function to which we pass pointer to a points array and stride in that array.

In fact, you might ignore the fact that rgb_ramp_lookup() operates with float4 and use component after the lookup is done. This is a single-run operation anyway, it's not so much extra evaluation and it works fast enough to be used from kernel even.

Or even go a step forward and make svm_node_rgb_curves() usable here, so it saves duplication in constant_fold() as well.

I'm all against increasing duplication factor here.

The problem is that SVM uses fetch_node_float, which uses kernel_tex_fetch. We can do something like this to make the SVM function reusable, but it's not pretty:

#if !(defined(__KERNEL_CPU__) || defined(__KERNEL_GPU__))
#define KernelGlobals float3
#define fetch_node_float(kg, offset) kg[offset]
#endif

Or do something like:

svm_ramp_util.h:

ccl_device_inline svm_rgb_do_lookup(float4 *values, ...) {
  ...
  // Do all the lookup logic here, using `values[x]` instead of fetch.
  ..
}

svm_ramp.h:
ccl_device_inline svm_rgb_lookup(KernelGlobals *kg, ...) {
  return svm_rgb_do_lookup(&fetch_node_float(kg, 0), ...)
}

ccl_device_inline svm_rgb_do_lookup(float4 *values, ...) {

How would this work given that the array in nodes contains float3?

You just replace float4 with float3. I don't have source handy to give exact snippet, just giving idea hoping that one would extend it further.

&fetch_node_float(kg, 0) can't work on the GPU when the SVM nodes are stored in a texture. I'd like this code to be deduplicated too, but I'm not sure there's a simple way to do it here.

We could change the SVM nodes from texture storage to array storage on all GPUs, so that you can pass an array pointer always. This might have a performance impact on some of the older CUDA GPUs and requires some deeper changes in the device code.

It would be interesting to investigate doing constant folding generically, for example compiling and evaluating a single SVM node, or adding some extra abstraction that lets us share code for constant folding, SVM and maybe even OSL.

But those are bigger changes which I don't think should block this patch.