finish cross #9

S1/hli28146_#9/cross_cuda.py

@@ -0,0 +1,99 @@
+import torch
+import torch.nn as nn
+from torch.utils.cpp_extension import load_inline
+
+# C++ 源代码
+cpp_source = """
+#include <torch/extension.h>
+
+torch::Tensor cross_cuda_forward(const torch::Tensor& x, const torch::Tensor& y, int64_t dim);
+"""
+
+# CUDA 源代码
+cuda_source = """
+#include <torch/extension.h>
+#include <cuda_runtime.h>
+
+template <typename T>
+__global__ void cross_kernel_stride(
+    T* output,
+    const T* x,
+    const T* y,
+    const int64_t num_vectors,
+    const int64_t dim_stride,
+    const int64_t slice_stride)
+{{
+    // 每个线程负责一个完整的叉积计算
+    const int64_t idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx >= num_vectors) return;
+
+    // --- 使用 stride 计算基地址 ---
+    const T* x_vec = x + idx * slice_stride;
+    const T* y_vec = y + idx * slice_stride;
+    T* out_vec = output + idx * slice_stride;
+
+    // --- 使用 dim_stride 加载数据到寄存器 ---
+    const T x0 = x_vec[0];
+    const T x1 = x_vec[dim_stride];
+    const T x2 = x_vec[2 * dim_stride];
+    const T y0 = y_vec[0];
+    const T y1 = y_vec[dim_stride];
+    const T y2 = y_vec[2 * dim_stride];
+
+    out_vec[0] = x1 * y2 - x2 * y1;
+    out_vec[dim_stride] = x2 * y0 - x0 * y2;
+    out_vec[2 * dim_stride] = x0 * y1 - x1 * y0;
+}}
+
+torch::Tensor cross_cuda_forward(const torch::Tensor& x, const torch::Tensor& y, int64_t dim) {
+    auto sizes = x.sizes();
+    int ndim = x.dim();
+    if (dim < 0) dim += ndim;
+
+    TORCH_CHECK(x.is_cuda() && y.is_cuda(), "Inputs must be CUDA tensors");
+    TORCH_CHECK(x.sizes() == y.sizes(), "Input shapes must match");
+    TORCH_CHECK(x.is_contiguous() && y.is_contiguous(), "Inputs must be contiguous for this implementation");
+    TORCH_CHECK(sizes[dim] == 3, "Dimension for cross product must be 3");
+
+    // Stride 计算
+    const int64_t dim_stride = x.stride(dim);
+    const int64_t num_vectors = x.numel() / 3;
+
+    // 创建一个临时视图来计算 slice_stride
+    auto x_flat = x.transpose(dim, -1).flatten(0, -2);
+    const int64_t slice_stride = x_flat.stride(0);
+    
+    auto output = torch::empty_like(x);
+    
+    const int block_size = 256;
+    const int num_blocks = (num_vectors + block_size - 1) / block_size;
+
+    AT_DISPATCH_FLOATING_TYPES(x.scalar_type(), "cross_kernel_stride", ([&] {{
+        cross_kernel_stride<scalar_t><<<num_blocks, block_size>>>(
+            output.data_ptr<scalar_t>(),
+            x.data_ptr<scalar_t>(),
+            y.data_ptr<scalar_t>(),
+            num_vectors,
+            dim_stride,
+            slice_stride
+        );
+    }}));
+
+    return output;
+}
+"""
+
+class ModelNew(nn.Module):
+    def __init__(self, dim):
+        super(ModelNew, self).__init__()
+        self.dim = dim
+        self.op = load_inline(
+            name='cross_op_stride',
+            cpp_sources=cpp_source,
+            cuda_sources=cuda_source,
+            functions=['cross_cuda_forward'],
+            verbose=False
+        )
+
+    def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return self.op.cross_cuda_forward(x, y, self.dim)

S1/hli28146_#9/cross_torch.py

@@ -0,0 +1,27 @@
+import torch
+import torch.nn as nn
+
+# --- 用于基准测试的配置 ---
+BATCH_SIZE = 512
+VECTORS = 8192
+SHAPE = (BATCH_SIZE, VECTORS, 3)
+DIM = -1
+
+class Model(nn.Module):
+    """
+    使用 PyTorch 内置的 torch.linalg.cross 作为基准模型。
+    """
+    def __init__(self, dim):
+        super(Model, self).__init__()
+        self.dim = dim
+    
+    def forward(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+        return torch.linalg.cross(x, y, dim=self.dim)
+
+def get_inputs():
+    x = torch.randn(SHAPE, dtype=torch.float32)
+    y = torch.randn(SHAPE, dtype=torch.float32)
+    return [x.contiguous(), y.contiguous()]
+
+def get_init_inputs():
+    return [DIM]

S1/hli28146_#9/prompt.txt

@@ -0,0 +1,47 @@
+Write a custom CUDA kernel to optimize `torch.linalg.cross`.
+
+The operation computes the cross product of two 3-dimensional vectors, batched over all other dimensions. The core formula for the output vector `c` from input vectors `a` and `b` is `c_1 = a_2*b_3 - a_3*b_2`, `c_2 = a_3*b_1 - a_1*b_3`, `c_3 = a_1*b_2 - a_2*b_1`.
+
+**Problem Analysis:**
+`torch.linalg.cross` is a classic memory-bandwidth-bound operation. Its arithmetic intensity is very low (9 floating-point operations per 9 floats of memory I/O). A potential PyTorch implementation might involve slicing, element-wise multiplication, and subtraction, which could create intermediate tensors and add overhead. Even with a fused kernel, the overhead of the general PyTorch dispatcher can be significant for such a lightweight operation.
+
+**Optimization Strategy: Fused "One-Thread-per-Product" Kernel**
+
+The strategy is to create a minimalist, fully-fused CUDA kernel that maps the cross-product logic directly to the hardware with minimal overhead.
+
+1.  **Parallelism Model**: The kernel is launched with one thread for every cross product to be computed. If the input shape is `(..., 3)`, the number of threads is `input.numel() / 3`. Each thread is completely independent.
+
+2.  **Fully Fused In-Register Computation**: Each thread is responsible for one entire cross product calculation:
+    a. It computes the base address for its assigned 3-element input vectors in `x` and `y`.
+    b. It loads all 6 required float values (3 from `x`, 3 from `y`) from global memory directly into its private registers.
+    c. It performs all 6 multiplications and 3 subtractions entirely within registers, which is extremely fast.
+    d. It writes the 3 resulting float values directly to the correct locations in the output tensor.
+
+3.  **Elimination of Overhead**: This approach constitutes a single pass over the data. It completely eliminates any intermediate tensors and bypasses the PyTorch dispatcher's general-purpose machinery, leading to a kernel whose performance is almost exclusively limited by the GPU's raw memory bandwidth.
+  
+Here's an example to show you the syntax of inline embedding custom CUDA operators in torch: The example given architecture is:   
+  
+```python
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+class Model(nn.Module):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def forward(self, a, b):
+        return a + b
+
+
+def get_inputs():
+    # randomly generate input tensors based on the model architecture
+    a = torch.randn(1, 128).cuda()
+    b = torch.randn(1, 128).cuda()
+    return [a, b]
+
+
+def get_init_inputs():
+    # randomly generate tensors required for initialization based on the model architecture
+    return []

S1/hli28146_#9/run_code.py

@@ -0,0 +1,74 @@
+###########################################################
+# 性能和精度验证程序
+###########################################################
+import torch
+import torch.nn as nn
+import time
+from cross_torch import Model,get_inputs,get_init_inputs
+from cross_cuda import ModelNew
+
+def run_benchmark():
+    # 检查 CUDA 是否可用
+    if not torch.cuda.is_available():
+        print("CUDA 不可用，请确保您有可用的 NVIDIA GPU 并已正确安装 PyTorch CUDA 版本。")
+        return
+    else:
+        device = torch.device("cuda")
+
+    # 初始化模型
+    init_inputs = get_init_inputs()
+    init_inputs = [
+        x.cuda(device=device) if isinstance(x, torch.Tensor) else x for x in init_inputs
+    ]
+    inputs = get_inputs()
+    inputs = [
+        x.cuda(device=device) if isinstance(x, torch.Tensor) else x for x in inputs
+    ]
+
+    torch_model = Model(*init_inputs).cuda()
+    cuda_model = ModelNew(*init_inputs).cuda()
+
+    torch_model.eval()
+    cuda_model.eval()
+
+    print("-------------------- 精度对齐验证 --------------------")
+    with torch.no_grad():
+        output_torch = torch_model( *inputs)
+        output_cuda = cuda_model(*inputs)
+
+    precision_flag = torch.allclose(output_torch, output_cuda,rtol=1e-03)
+    if precision_flag:
+        print("✅ 精度对齐：两个模型的输出结果非常接近。")
+    else:
+        print("❌ 精度不一致！")
+        
+    print("\n-------------------- 性能加速比测试 --------------------")
+    num_iterations = 100 
+    
+    # PyTorch 模型计时
+    torch.cuda.synchronize()
+    start_time = time.time()
+    for _ in range(num_iterations):
+        _ = torch_model(*inputs)
+    torch.cuda.synchronize()
+    torch_time = (time.time() - start_time) / num_iterations
+    
+    # 自定义 CUDA 内核计时
+    torch.cuda.synchronize()
+    start_time = time.time()
+    for _ in range(num_iterations):
+        _ = cuda_model(*inputs)
+    torch.cuda.synchronize()
+    cuda_time = (time.time() - start_time) / num_iterations
+    
+    print(f"PyTorch torch.relu 平均执行时间: {torch_time:.6f} 秒")
+    print(f"自定义 CUDA 内核 平均执行时间: {cuda_time:.6f} 秒")
+    speedup = 0
+    if cuda_time > 0:
+        speedup = torch_time / cuda_time
+        print(f"加速比 (Speedup): {speedup:.2f}x")
+    else:
+        print("CUDA 内核执行时间为0，无法计算加速比。")
+    return precision_flag,speedup
+if __name__ == "__main__":
+    precision_flag,speedup = run_benchmark()