What is the difference between Kernel Input and Output?

[cadop]

In the runtime reference https://nvidia.github.io/warp/modules/runtime.html#kernels it only mentions

inputs (Sequence) – The input parameters to the kernel (optional)

outputs (Sequence) – The output parameters (optional)

In kernel basics https://nvidia.github.io/warp/basics.html#kernels there is no discussion about Outputs. Instead it says

Because Warp kernels are compiled .... Instead they must read and write data through their input parameters such as arrays.

What is the difference?

If I am trying to update an existing array, such as my_array[tid]+=1, is this an "output", since the array is modified? But it is also an "input" since I am passing an array of data. Is this just a useful name convention that passes arguments in order? The kernel signature doesn't seem to differentiate between them, just order.

[shi-eric]

The only place that I'm aware of where using outputs makes sense is when you're writing kernels that might participate in automatic differentiation. Using both the inputs and outputs keywords can be helpful here to avoid overwrite issues that would result in incorrect gradients. Some of the gradient debugging tools also require the use of the outputs keyword. If you aren't using automatic differentiation, then I would just stick with inputs.

[cadop]

I was searching for this question again when tracing down some bug. I noticed a recent commit on explaining it again:

a7daf72

However, I think it could be a little more explicit in the explanation.

So in the above example, it would be equally valid to write inputs=[a, b, c] but since we are writing to c,
we list it in the outputs argument.

Is it equally valid because with the one exception of the graph, there is no difference, or is it valid for that example.

Is this correct?:

With the exception of "using the :ref:Graph visualization tool", variables that are passed through the inputs parameter are passed by reference, not copied, and any modifications to the inputs will be reflected in the array on the device. This is important for concurrency when subsequent kernels are using the same input array.

[shi-eric]

variables that are passed through the inputs parameter are passed by reference, not copied, and any modifications to the inputs will be reflected in the array on the device

This is only true for arrays. If a kernel accepts a: float and inside the kernel we do a = 0.0, the variable that we passed in as a will be unchanged after the kernel runs. The block is also confusing to me since the With the exception of "using the :ref:Graph visualization tool" part has nothing to do with the rest of block you wrote.

The main point we're trying to make is that there's nothing special about the functionality of the inputs and outputs keywords except if you're trying to use autodiff debugging tools.

[cadop]

Regarding the array vs float, is there a part of the docs that explains this (searching the docs for "reference" doesn't get me very far)? Ex. Struct / Struct of arrays / Mixed type Struct / Array of structs

--
For the :ref:Graph, that was just copied from the original

Unless you are using the :ref:Graph visualization tool<visualizing_computation_graphs>, the outputs argument is optional -- all kernel arguments may be passed as inputs, but for readability it is sometimes useful to distinguish between the kernel arguments that are read from (inputs) and the kernel arguments that are written to (outputs).

[shi-eric]

I agree that we need to add a section in the basics docs that explains the basic CUDA programming model for someone who is new to GPU programming and in a way that makes no reference to C/C++ features. So I think we should avoid talking about "passing by reference" or "passing by value" for the most part, at least not without explaining in more detail since I wouldn't expect Python programmers to understand...

The simplest way I can explain it is: the only variables that kernels can modify are arrays. I think that's true...