One of the goals of designing a high level GPU programming language is to allow the compiler to perform optimizations on your code. One optimization we've been doing for a while in Harlan is one I've been calling "kernel fusion." This is a pretty obvious transformation to do, and many other GPU languages do it. However, kernel fusion comes in several different variants that I'd like to discuss.

Kernel Inlining🔗

Let's consider an example program written in Harlan:

(let ((temp* (kernel ((x x*) (y y*))
               (+ (* x x) (* y y)))))
  (kernel ((t temp*))
    (sqrt t)))

I believe this is the first time I've included Harlan code snippets in my blog, so some introduction is in order. Harlan is a high level language for data parallel computing that I've been working on for a while now as part of my Ph.D. research. You can read our initial paper about Harlan here, although it will be immediately apparent from the drastically different syntax that the language has evolved significantly in that time.

The primary construct for parallelism in Harlan is the kernel form. Syntactically, this looks like Scheme's let, in that it takes a list of variable names and expressions to bind the names to, and then a body describing what computation to do on those variables. The difference is that each of the bound expressions must be a vector, and the result of a kernel is another vector. Furthermore, each input vector must be of the same length, and the result of the kernel will have the same length as its inputs. Kernels operate on parallel, with the body being applied to each corresponding set of elements in the inputs. You can think of kernels as a parallel map or zipWith.

In the example above, if we imagine x* and y* as containing the X and Y coordinates of a set of 2D vectors, then the code snippet calculates the magnitude of each of these vectors. As written, however, we have a couple of obvious inefficiencies. This example allocates space for the result of the first kernel, temp*, which could be significant if x* and y* are very long. Secondly, both kernels are tiny--that is, they have low arithmetic intensity. Arithmetic intensity is a measure of how many arithmetic operations we have for each memory reference. If it is low, we won't be using the full computational power of the GPU.

Fortunately, we can solve both of these problems with the first form of fusion, which I feel is better called kernel inlining. With kernel inlining, we would transform our program into the following:

(kernel ((x x*) (y y*))
  (let ((t (+ (* x x) (* y y))))
    (sqrt t)))

In case it's not clear what happened, we took the body of the first kernel and inserted it into the second kernel. In doing this, we also got rid of the parameters to the second kernel and replaced them with the parameters from the first kernel. Now there is only one kernel, the temp* vector is completely gone, and the arithmetic intensity of the newly fused kernel is higher than we had before.

This transformation is usually a win when it's possible. We may not want to do it if, for example, the temp* array is also referenced somewhere else. Also, while kernels with higher arithmetic intensity tend to work better because there is more computation for the GPU to use to hide memory access latency, it can also increase the number of registers needed by each thread and thereby limit how much parallelism is possible.

2D Kernel Fusion🔗

For the next type of fusion, let's consider the following code that would appear in a hypothetical program to render the Mandelbrot set:

(kernel ((i (iota height)))
  (kernel ((j (iota width)))
    (compute-mandelbrot i j)))

Harlan allows nested kernels like this, but Harlan compiles to OpenCL, which does not support nested kernels. Harlan generally deals with this by sequentializing all but one of the kernels. In this case, we could either transform the out or inner kernel into a loop. However, since the kernels form a grid with no dependencies between them, the compiler can fuse these into a single, two dimensional kernel, which OpenCL does support. The Harlan compiler is able to do this for simple cases like this one.

Kernel Concatenation🔗

Let's look at one more form of fusion, although the Harlan compiler does not currently do this form. Consider a program like this:

(let ((a* (kernel ((i inputs))
            (do-something i)))
      (b* (kernel ((i inputs))
            (do-something-else i))))
  (write-outputs a* b*))

Here we have two kernels that execute in sequence with no dependencies between them. Furthermore, they have the same set of inputs. If we pretend for a moment that Harlan has a multiple return value form, like Scheme's values, we could combine these two kernels as follows:

(let-values (((a* b*) (kernel ((i inputs))
                        (let ((a (do-something i))
                              (b (do-something-else j)))
                          (values a b)))))
  (write-outputs a* b*))

In keeping with the general theme of fusion transformations, we now have only one kernel that performs more work instead of two smaller kernels.


We've looked at three different program transformations that could be called fusion. A key point is that they are transformations, not necessarily optimizations. In my experience, these sorts of transformations almost always improve performance, but that need not always be the case. By combining small pieces of code into larger chunks, we reduce the overhead of launching new kernels and also give the GPU more code to use for overlapping memory accesses with computation. On the other hand, larger code could lead to less efficient instruction cache usage, and also lead to more memory accesses if each thread's working set can no longer fit in registers. It's good to be able to do these transformations, but it's important to benchmark and see what works best for each particular program.