Scan Accumulation Type Consistency

[MrBurmark]

Among our different back-end implementations the type used to accumulate the intermediate values of a scan differs.
This result is inconsistent scan results between different back-ends when using input and output containers with different value types.
For example scanning over an array of 16-bit int inputs and storing into a array of 32-bit int outputs could lead to truncation of the accumulated values to 16-bits despite the output being able to store 32-bits.
The behavior should be made to consistently use the output type for the accumulation type.

We default out initial values to the type from the input container.
https://github.com/LLNL/RAJA/blob/develop/include/RAJA/pattern/scan.hpp#L262
We use the type of the output container to accumulate in the sequential backend.
https://github.com/LLNL/RAJA/blob/develop/include/RAJA/policy/sequential/scan.hpp#L146
Cub uses the type of the output container to accumulate for the cuda backend.
https://github.com/dmlc/cub/blob/05eb57faa0a4cac37c2a86fdf4b4dc865a95a1a3/cub/agent/agent_scan.cuh#L110
Rocprim uses the type of the input container to accumulate for the hip backend.
https://github.com/ROCm/rocPRIM/blob/develop/rocprim/include/rocprim/device/device_scan.hpp#L653

[MrBurmark]

Looking into this more closely all the released versions of rocprim don't have a AccType template argument as of rocm 6.1.0. Though this template argument does exist on rocprim develop. So it doesn't look like we can fix this in RAJA until a future version of rocm. @gunney1

[gunney1]

@MrBurmark Do we have the template argument in a released rocprim yet?

[MrBurmark]

It looks like it has existed since rocm 6.2, though it still defaults to the input type. https://github.com/ROCm/rocPRIM/blob/rocm-6.2.0/rocprim/include/rocprim/device/device_scan.hpp#L653

[MrBurmark]

Looking at this more closely, it looks like inclusive scan has this problem but exclusive scan does not. Exclusive scan uses the type of the initial value for its intermediate values. @gunney1 can you use exclusive scan instead?

[gunney1]

Sure. So the type of the initial value is the output type, not the input type?

[MrBurmark]

The initial value should be whatever type you want the accumulated intermediate value to be. The values will be read as the input type, converted to the intermediate type, accumulated as the intermediate type across all the inputs, converted to the output type, and written as the output type.

In essence exclusive scan is implemented something like this.

template < typename InputType, typename OutputType, typename AccumulationType>
void exclusive_scan(const InputType* input, OutputType* output, IndexType size, AccumulationType init_value)
{
  AccumulationType value = init_value;
  for (IndexType i = 0; i < size; ++i) {
    output[i] = static_cast<OutputType>(value);
    InputType input_value = input[i];
    value += static_cast<AccumulationType>(input_value);
  }
}

[rhornung67]

@MrBurmark has rocm support changed so that we can resolve this issue?