The AI CUDA Engineer 👷

import torch
import torch.nn as nn
import torch.nn.functional as F


def module_fn(
    x: torch.Tensor,
    i2h_weight: torch.Tensor,
    i2h_bias: torch.Tensor,
    h2o_weight: torch.Tensor,
    h2o_bias: torch.Tensor,
    hidden: torch.Tensor,
) -> torch.Tensor:
    """
    Vanilla RNN forward pass

    Args:
        x: Input tensor of shape (batch_size, input_size)
        i2h_weight: Weight tensor for input-to-hidden layer
        i2h_bias: Bias tensor for input-to-hidden layer
        h2o_weight: Weight tensor for hidden-to-output layer
        h2o_bias: Bias tensor for hidden-to-output layer
        hidden: Hidden state tensor

    Returns:
        Output tensor of shape (batch_size, output_size)
    """
    hidden = hidden.to(x.device)
    combined = torch.cat((x, hidden), dim=1)
    hidden = torch.tanh(F.linear(combined, i2h_weight, i2h_bias))
    output = F.linear(hidden, h2o_weight, h2o_bias)
    return output


class Model(nn.Module):
    def __init__(self, input_size: int, hidden_size: int, output_size: int):
        """
        Initialize the Vanilla RNN model.

        :param input_size: The number of input features (int).
        :param hidden_size: The size of the hidden state (int).
        :param output_size: The number of output features (int).
        """
        super(Model, self).__init__()
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        self.hidden = nn.Parameter(torch.randn((batch_size, hidden_size)))

        # Extract parameters from linear layers
        i2h = nn.Linear(input_size + hidden_size, hidden_size)
        self.i2h_weight = nn.Parameter(i2h.weight.data.clone())
        self.i2h_bias = nn.Parameter(i2h.bias.data.clone())

        h2o = nn.Linear(hidden_size, output_size)
        self.h2o_weight = nn.Parameter(h2o.weight.data.clone())
        self.h2o_bias = nn.Parameter(h2o.bias.data.clone())

    def forward(self, x: torch.Tensor, fn=module_fn) -> torch.Tensor:
        return fn(
            x,
            self.i2h_weight,
            self.i2h_bias,
            self.h2o_weight,
            self.h2o_bias,
            self.hidden,
        )


batch_size = 8
input_size = 1024
hidden_size = 256
output_size = 128
sequence_length = 256


def get_inputs():
    return [torch.randn(batch_size, input_size)]


def get_init_inputs():
    return [input_size, hidden_size, output_size]

#include <torch/extension.h>
#include <cuda.h>
#include <cuda_runtime.h>

#define BLOCK_SIZE 256

// Kernel that concatenates x and hidden into combined with shared memory optimization
__global__ void concat_kernel_shared(
    const float* __restrict__ x,
    const float* __restrict__ hidden,
    float* __restrict__ combined,
    const int batch_size,
    const int x_size,
    const int hidden_size
) {
    extern __shared__ float shared_mem[];
    const int total_width = x_size + hidden_size;
    
    // 2D grid mapping: blockIdx.y for batch dimension, blockIdx.x for width dimension
    const int tid = threadIdx.x;
    const int row = blockIdx.y;
    const int col_base = blockIdx.x * blockDim.x;
    const int col = col_base + tid;
    
    if (row < batch_size && col < total_width) {
        const int idx = row * total_width + col;
        if (col < x_size) {
            shared_mem[tid] = x[row * x_size + col];
        } else {
            shared_mem[tid] = hidden[row * hidden_size + (col - x_size)];
        }
        __syncthreads();
        combined[idx] = shared_mem[tid];
    }
}

torch::Tensor module_fn_cuda(
    torch::Tensor x,
    torch::Tensor i2h_weight,
    torch::Tensor i2h_bias,
    torch::Tensor h2o_weight,
    torch::Tensor h2o_bias,
    torch::Tensor hidden
) {
    // Ensure that all tensors are contiguous
    x = x.contiguous();
    i2h_weight = i2h_weight.contiguous();
    i2h_bias = i2h_bias.contiguous();
    h2o_weight = h2o_weight.contiguous();
    h2o_bias = h2o_bias.contiguous();
    hidden = hidden.contiguous();

    const int batch_size = x.size(0);
    const int x_size = x.size(1);
    const int hidden_size = hidden.size(1);
    int total_width = x_size + hidden_size;
    
    auto options = torch::TensorOptions().dtype(x.dtype()).device(x.device());
    auto combined = torch::empty({batch_size, total_width}, options);

    int total_elements = batch_size * total_width;
    int threads = BLOCK_SIZE;
    int blocks = (total_elements + threads - 1) / threads;
    if (blocks > 65535) {
        blocks = 65535;
    }

    // Allocate shared memory dynamically
    size_t shared_mem_size = threads * sizeof(float);

    concat_kernel_shared<<<blocks, threads, shared_mem_size>>>(
        x.data_ptr<float>(),
        hidden.data_ptr<float>(),
        combined.data_ptr<float>(),
        batch_size,
        x_size,
        hidden_size
    );

    // Compute the new hidden state: tanh(linear(combined, i2h_weight, i2h_bias))
    auto hidden_new = torch::tanh(torch::addmm(i2h_bias, combined, i2h_weight.t()));
    // Compute the output: linear(hidden_new, h2o_weight, h2o_bias)
    auto output = torch::addmm(h2o_bias, hidden_new, h2o_weight.t());
    return output;
}

PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
    m.def("forward", &module_fn_cuda, "Module forward (CUDA)");
}