1 / 1

L1 Normalization as a CUDA Kernel

Linear AlgebraGPU Programming

Medium

Implement L1 normalization of a 1D vector on the GPU. For each element of the input array, compute:

\text{output}[i] = \frac{\text{input}[i]}{\sum_{j=0}^{N-1} |\text{input}[j]|}

The kernel must first perform a reduction over $|\text{input}|$ to compute the denominator, then divide each element by that sum. The output array has the same length as the input.

Function Arguments

$\texttt{input}$ : device pointer to $N$ float values.
$\texttt{output}$ : device pointer to $N$ float slots that receive the L1-normalized values.
$\texttt{N}$ : number of elements in $\texttt{input}$ and $\texttt{output}$ .

Loading visualization...

Examples

Input: input = [1, 2, 3, 4]

Output: [0.1, 0.2, 0.3, 0.4]

The sum of absolute values is $10$ , so each element is divided by $10$ .

Input: input = [-1, 2, -3]

Output: [-0.1667, 0.3333, -0.5]

The sum of absolute values is $6$ , so each element is divided by $6$ while keeping its sign.

Hint 1

Compute the denominator in a separate reduction kernel before the divide pass. A shared-memory tree reduction followed by atomicAdd into a single device float is a clean pattern.

Hint 2

fabsf gives the per-element absolute value. Zero the scratch sum with cudaMemset before launching the reduction so the atomics accumulate from a clean baseline.

Hint 3

Once the sum is on the device, a second elementwise kernel can read the scratch scalar and write input[i] / sum into output[i].

Requirements

Export $\texttt{extern "C" void solve(const float* input, float* output, int N)}$ with the exact signature.
Treat $\texttt{input}$ and $\texttt{output}$ as device pointers; do not $\texttt{cudaMemcpy}$ them.
Compute the sum of absolute values across the entire array, then divide each element by that scalar.
Call $\texttt{cudaDeviceSynchronize}$ before $\texttt{solve}$ returns and free any scratch device memory you allocate.

Constraints

$1 \le N \le 10^7$ .
All values fit in 32-bit float.
The sum $\sum_j |\text{input}[j]|$ is guaranteed to be strictly positive (no all-zero inputs).
The $\texttt{solve}$ signature must not change.

Try Similar Problems

CUDA Dot Product: Multi-Block ReductionMedium L2 Normalization as a CUDA KernelMedium RMS Normalization as a CUDA KernelMedium Layer Normalization as a CUDA KernelMedium Matrix Multiplication as a CUDA KernelMedium Cosine Similarity as a CUDA KernelMedium Matrix-Vector Multiplication as a CUDA KernelMedium Argmax as a CUDA KernelMedium Mean and Variance as a CUDA KernelMedium Argmin as a CUDA KernelMedium Outer Product as a CUDA KernelEasy Tiled Matrix Multiplication as a CUDA KernelHard

L1 Normalization as a CUDA Kernel

Linear AlgebraGPU Programming

Medium

Implement L1 normalization of a 1D vector on the GPU. For each element of the input array, compute:

\text{output}[i] = \frac{\text{input}[i]}{\sum_{j=0}^{N-1} |\text{input}[j]|}

The kernel must first perform a reduction over $|\text{input}|$ to compute the denominator, then divide each element by that sum. The output array has the same length as the input.

Function Arguments

$\texttt{input}$ : device pointer to $N$ float values.
$\texttt{output}$ : device pointer to $N$ float slots that receive the L1-normalized values.
$\texttt{N}$ : number of elements in $\texttt{input}$ and $\texttt{output}$ .

Loading visualization...

Examples

Input: input = [1, 2, 3, 4]

Output: [0.1, 0.2, 0.3, 0.4]

The sum of absolute values is $10$ , so each element is divided by $10$ .

Input: input = [-1, 2, -3]

Output: [-0.1667, 0.3333, -0.5]

The sum of absolute values is $6$ , so each element is divided by $6$ while keeping its sign.

Hint 1

Compute the denominator in a separate reduction kernel before the divide pass. A shared-memory tree reduction followed by atomicAdd into a single device float is a clean pattern.

Hint 2

fabsf gives the per-element absolute value. Zero the scratch sum with cudaMemset before launching the reduction so the atomics accumulate from a clean baseline.

Hint 3

Once the sum is on the device, a second elementwise kernel can read the scratch scalar and write input[i] / sum into output[i].

Requirements

Export $\texttt{extern "C" void solve(const float* input, float* output, int N)}$ with the exact signature.
Treat $\texttt{input}$ and $\texttt{output}$ as device pointers; do not $\texttt{cudaMemcpy}$ them.
Compute the sum of absolute values across the entire array, then divide each element by that scalar.
Call $\texttt{cudaDeviceSynchronize}$ before $\texttt{solve}$ returns and free any scratch device memory you allocate.

Constraints

$1 \le N \le 10^7$ .
All values fit in 32-bit float.
The sum $\sum_j |\text{input}[j]|$ is guaranteed to be strictly positive (no all-zero inputs).
The $\texttt{solve}$ signature must not change.

Try Similar Problems

input =

Accepts: array

Function Arguments

Examples

Requirements

Constraints

Kernel performance

L1 Normalization as a CUDA Kernel

Function Arguments

Examples

Requirements

Constraints

Kernel performance