【CUDA编程部署教程】第一章:GPU架构与CUDA编程核心 2

1.2 高性能CUDA编程范式

引言

掌握了GPU的底层硬件架构后,下一步是学习如何通过CUDA编程模型来高效地驾驭它。本节将聚焦于三个核心的高性能编程范式,它们是区分CUDA新手与专家的关键分水岭。我们将学习如何利用流(Stream)和事件(Event)来掩盖数据传输延迟,实现计算与I/O的并行流水线;我们将重温并深化共享内存(Shared Memory)的应用,将其作为用户管理的高速缓存来最大化数据复用;最后,我们将介绍CUDA Graphs这一终极武器,以消除CPU启动开销,将应用的延迟推向极致。

1.2.1 CUDA流(Stream)与事件(Event)异步执行

原理简介

在典型的异构计算中,工作流包含三个阶段:1) 将数据从CPU主机拷贝到GPU设备 (H2D),2) 在GPU上执行计算核函数,3) 将结果从GPU设备拷贝回CPU主机 (D2H)。默认情况下,这些操作在所谓的“默认流”中同步或隐式同步执行,即一个操作必须等待前一个完成后才能开始。这导致GPU在数据拷贝时处于空闲状态,CPU在等待GPU计算时也处于空闲状态,造成了严重的资源浪费。

CUDA流(Stream) 是一个GPU操作的有序队列。提交到同一个流的操作按顺序执行,但不同流中的操作可以并行执行(只要硬件资源允许)。通过创建多个流,我们可以构建一个流水线(Pipeline),将数据分割成块(Chunks),让第 N 块数据的计算与第 N+1 块数据的H2D拷贝以及第 N-1 块数据的D2H拷贝同时进行,从而有效隐藏数据传输的延迟。

CUDA事件(Event) 是CUDA流中的标记,可用于精确计时和流间同步。

技术手册:可执行代码

以下程序将通过实验对比三种执行模式的性能:

  1. 同步模式:完全串行执行。

  2. 单流异步模式:展示仅使用异步API但未构建流水线的情况。

  3. 多流异步流水线模式:通过重叠计算和数据传输实现最高性能。

C++

// =================================================================
// 编译指令:
// nvcc -o streams_pipeline streams_pipeline.cu
// =================================================================
#include <iostream>
#include <vector>
#include <cuda_runtime.h>

#define CUDA_CHECK(call) do { \
    cudaError_t err = call; \
    if (err != cudaSuccess) { \
        fprintf(stderr, "CUDA Error: %s:%d, ", __FILE__, __LINE__); \
        fprintf(stderr, "code: %d, reason: %s\n", err, cudaGetErrorString(err)); \
        exit(1); \
    } \
} while(0)

// 一个简单的计算密集型核函数
__global__ void simple_kernel(float* data, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) {
        float val = data[idx];
        for(int i = 0; i < 50; ++i) {
            val = sinf(val) * cosf(val);
        }
        data[idx] = val;
    }
}

int main() {
    int n = 1 << 25; // approx 33 million floats
    size_t bytes = n * sizeof(float);

    // 1. 分配主机内存。使用锁页内存(Pinned Memory)以实现真正的异步H2D/D2H拷贝
    float *h_data;
    CUDA_CHECK(cudaMallocHost(&h_data, bytes));
    for (int i = 0; i < n; ++i) {
        h_data[i] = static_cast<float>(i);
    }
    
    // 分配设备内存
    float* d_data;
    CUDA_CHECK(cudaMalloc(&d_data, bytes));

    // 计时事件
    cudaEvent_t start, stop;
    CUDA_CHECK(cudaEventCreate(&start));
    CUDA_CHECK(cudaEventCreate(&stop));
    float ms;

    int threadsPerBlock = 256;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;

    // --- 模式1: 同步执行 ---
    CUDA_CHECK(cudaEventRecord(start));
    
    CUDA_CHECK(cudaMemcpy(d_data, h_data, bytes, cudaMemcpyHostToDevice));
    simple_kernel<<<blocksPerGrid, threadsPerBlock>>>(d_data, n);
    CUDA_CHECK(cudaMemcpy(h_data, d_data, bytes, cudaMemcpyDeviceToHost));

    CUDA_CHECK(cudaEventRecord(stop));
    CUDA_CHECK(cudaEventSynchronize(stop));
    CUDA_CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::cout << "1. Synchronous Execution Time:         " << ms << " ms" << std::endl;

    // --- 模式2: 单流异步 ---
    // 虽然API是异步的,但由于在同一个流中,操作仍然是串行的
    cudaStream_t stream_single;
    CUDA_CHECK(cudaStreamCreate(&stream_single));
    
    CUDA_CHECK(cudaEventRecord(start));
    
    CUDA_CHECK(cudaMemcpyAsync(d_data, h_data, bytes, cudaMemcpyHostToDevice, stream_single));
    simple_kernel<<<blocksPerGrid, threadsPerBlock, 0, stream_single>>>(d_data, n);
    CUDA_CHECK(cudaMemcpyAsync(h_data, d_data, bytes, cudaMemcpyDeviceToHost, stream_single));

    // 等待流中所有操作完成
    CUDA_CHECK(cudaStreamSynchronize(stream_single));

    CUDA_CHECK(cudaEventRecord(stop));
    CUDA_CHECK(cudaEventSynchronize(stop));
    CUDA_CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::cout << "2. Single Stream Async Time:         " << ms << " ms" << std::endl;
    CUDA_CHECK(cudaStreamDestroy(stream_single));

    // --- 模式3: 多流异步流水线 ---
    int n_streams = 4;
    cudaStream_t streams[n_streams];
    float* d_chunks[n_streams];
    int chunk_size = n / n_streams;
    size_t chunk_bytes = chunk_size * sizeof(float);
    int blocksPerGrid_chunk = (chunk_size + threadsPerBlock - 1) / threadsPerBlock;

    for (int i = 0; i < n_streams; ++i) {
        CUDA_CHECK(cudaStreamCreate(&streams[i]));
        CUDA_CHECK(cudaMalloc(&d_chunks[i], chunk_bytes));
    }

    CUDA_CHECK(cudaEventRecord(start));
    
    // 启动流水线
    for (int i = 0; i < n_streams; ++i) {
        int offset = i * chunk_size;
        // 在第 i 个流上: H2D -> Kernel -> D2H
        CUDA_CHECK(cudaMemcpyAsync(d_chunks[i], h_data + offset, chunk_bytes, cudaMemcpyHostToDevice, streams[i]));
        simple_kernel<<<blocksPerGrid_chunk, threadsPerBlock, 0, streams[i]>>>(d_chunks[i], chunk_size);
        CUDA_CHECK(cudaMemcpyAsync(h_data + offset, d_chunks[i], chunk_bytes, cudaMemcpyDeviceToHost, streams[i]));
    }

    // 同步所有流
    for (int i = 0; i < n_streams; ++i) {
        CUDA_CHECK(cudaStreamSynchronize(streams[i]));
    }
    
    CUDA_CHECK(cudaEventRecord(stop));
    CUDA_CHECK(cudaEventSynchronize(stop));
    CUDA_CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::cout << "3. Multi-Stream Pipeline Time:       " << ms << " ms" << std::endl;

    // 清理
    for (int i = 0; i < n_streams; ++i) {
        CUDA_CHECK(cudaStreamDestroy(streams[i]));
        CUDA_CHECK(cudaFree(d_chunks[i]));
    }
    CUDA_CHECK(cudaFree(d_data));
    CUDA_CHECK(cudaFreeHost(h_data));
    CUDA_CHECK(cudaEventDestroy(start));
    CUDA_CHECK(cudaEventDestroy(stop));

    return 0;
}

分析与预期结果:

  • 模式1和模式2的执行时间约等于 H2D时间 + Kernel时间 + D2H时间 的总和。

  • 模式3的执行时间理论上约等于 max(单次H2D时间, 单次Kernel时间, 单次D2H时间) + 流水线建立和排空时间。您将观察到模式3的时间显著少于前两者,因为它成功地用计算时间“隐藏”了大部分的数据传输时间。注意:使用cudaMallocHost分配锁页内存是实现计算和拷贝重叠的关键。


1.2.2 共享内存(Shared Memory)与访存优化

原理简介

共享内存是位于SM芯片上的一小块、由程序员显式管理的高速读写内存。其访问延迟远低于全局内存,与L1缓存相当。当一个算法中存在数据复用时(即同一数据被多个线程多次读取),共享内存就成为性能优化的关键。典型的例子是卷积或模板(Stencil)计算,计算一个点的输出需要其周围邻域的输入。朴素实现会导致每个线程都从全局内存中读取邻域数据,造成大量冗余的全局内存访问。

优化策略是:让一个线程块(Block)协作,先将计算所需的一个数据瓦片(Tile)(包含邻域所需的“光环”或“幽灵”区域)一次性、以合并的方式从全局内存加载到共享内存中。然后,块内所有线程都从极速的共享内存中读取数据进行计算。这样,每个全局内存地址在一个块中只被读取一次,极大地降低了对内存带宽的压力。

技术手册:可执行代码

以下程序实现了一个简单的一维平均模板(每个输出是对应输入及其左右邻居的平均值),并对比了朴素实现与使用共享内存优化的性能。

C++

// =================================================================
// 编译指令:
// nvcc -o shared_memory_stencil shared_memory_stencil.cu
// =================================================================
#include <iostream>
#include <vector>
#include <cuda_runtime.h>
#include <numeric>

#define CUDA_CHECK(call) do { \
    cudaError_t err = call; \
    if (err != cudaSuccess) { \
        fprintf(stderr, "CUDA Error: %s:%d, ", __FILE__, __LINE__); \
        fprintf(stderr, "code: %d, reason: %s\n", err, cudaGetErrorString(err)); \
        exit(1); \
    } \
} while(0)

// 内核1: 朴素实现,从全局内存重复读取
__global__ void naive_stencil(float* out, const float* in, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;

    if (idx > 0 && idx < n - 1) {
        // 每个线程从全局内存读取3次
        float left = in[idx - 1];
        float center = in[idx];
        float right = in[idx + 1];
        out[idx] = (left + center + right) / 3.0f;
    }
}

// 内核2: 使用共享内存优化
// 每个块处理 TILE_SIZE 个元素, 但需要加载 TILE_SIZE + 2 个元素 (左右各一个光环)
#define TILE_SIZE 256
#define BLOCK_SIZE (TILE_SIZE)

__global__ void shared_mem_stencil(float* out, const float* in, int n) {
    // 声明共享内存,大小为块尺寸加上左右光环
    __shared__ float tile[BLOCK_SIZE + 2];

    int g_idx = blockIdx.x * BLOCK_SIZE + threadIdx.x; // 全局索引
    int l_idx = threadIdx.x; // 块内索引

    // 协作加载数据到共享内存
    // 每个线程负责加载一个元素
    if (g_idx < n) {
        tile[l_idx + 1] = in[g_idx];
    }
    // 块内的第一个线程加载左侧光环
    if (l_idx == 0 && g_idx > 0) {
        tile[0] = in[g_idx - 1];
    }
    // 块内的最后一个线程加载右侧光环
    if (l_idx == BLOCK_SIZE - 1 && g_idx < n - 1) {
        tile[BLOCK_SIZE + 1] = in[g_idx + 1];
    }

    __syncthreads(); // 同步,确保所有数据已加载

    // 从共享内存中计算
    if (g_idx > 0 && g_idx < n - 1) {
        float left = tile[l_idx];
        float center = tile[l_idx + 1];
        float right = tile[l_idx + 2];
        out[g_idx] = (left + center + right) / 3.0f;
    }
}

// CPU版本用于验证结果
void cpu_stencil(std::vector<float>& out, const std::vector<float>& in) {
    for (size_t i = 1; i < in.size() - 1; ++i) {
        out[i] = (in[i - 1] + in[i] + in[i + 1]) / 3.0f;
    }
}

int main() {
    int n = 1 << 24;
    size_t bytes = n * sizeof(float);

    std::vector<float> h_in(n);
    for (int i = 0; i < n; ++i) h_in[i] = (float)i;
    std::vector<float> h_out_naive(n, 0);
    std::vector<float> h_out_shared(n, 0);

    float *d_in, *d_out;
    CUDA_CHECK(cudaMalloc(&d_in, bytes));
    CUDA_CHECK(cudaMalloc(&d_out, bytes));
    CUDA_CHECK(cudaMemcpy(d_in, h_in.data(), bytes, cudaMemcpyHostToDevice));

    cudaEvent_t start, stop;
    CUDA_CHECK(cudaEventCreate(&start));
    CUDA_CHECK(cudaEventCreate(&stop));
    float ms;
    
    // --- 测试 Naive Kernel ---
    int threadsPerBlock = 256;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;
    
    CUDA_CHECK(cudaEventRecord(start));
    naive_stencil<<<blocksPerGrid, threadsPerBlock>>>(d_out, d_in, n);
    CUDA_CHECK(cudaEventRecord(stop));
    CUDA_CHECK(cudaEventSynchronize(stop));
    CUDA_CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::cout << "Naive Stencil Kernel Time:       " << ms << " ms" << std::endl;
    CUDA_CHECK(cudaMemcpy(h_out_naive.data(), d_out, bytes, cudaMemcpyDeviceToHost));


    // --- 测试 Shared Memory Kernel ---
    // 注意块大小现在固定为BLOCK_SIZE
    blocksPerGrid = (n + BLOCK_SIZE - 1) / BLOCK_SIZE;
    
    CUDA_CHECK(cudaEventRecord(start));
    shared_mem_stencil<<<blocksPerGrid, BLOCK_SIZE>>>(d_out, d_in, n);
    CUDA_CHECK(cudaEventRecord(stop));
    CUDA_CHECK(cudaEventSynchronize(stop));
    CUDA_CHECK(cudaEventElapsedTime(&ms, start, stop));
    std::cout << "Shared Memory Stencil Kernel Time: " << ms << " ms" << std::endl;
    CUDA_CHECK(cudaMemcpy(h_out_shared.data(), d_out, bytes, cudaMemcpyDeviceToHost));

    // --- 验证结果 ---
    std::vector<float> h_out_cpu(n, 0);
    cpu_stencil(h_out_cpu, h_in);
    bool success = true;
    for(int i=1; i < n-1; ++i) {
        if (fabs(h_out_cpu[i] - h_out_shared[i]) > 1e-5) {
            success = false;
            break;
        }
    }
    std::cout << "Verification: " << (success ? "SUCCESS" : "FAILED") << std::endl;

    // 清理
    cudaFree(d_in);
    cudaFree(d_out);
    cudaEventDestroy(start);
    cudaEventDestroy(stop);
    
    return 0;
}

分析与预期结果: 您将观察到,Shared Memory Stencil Kernel 的执行时间远少于 Naive Stencil Kernel。在朴素版本中,对于 n 个元素的计算,大约发生了 3*n 次全局内存读取。在优化版本中,每个元素平均只被从全局内存读取约 (TILE_SIZE + 2) / TILE_SIZE 次,约等于1次。这种对全局内存访问量的巨大削减,直接转化为性能的大幅提升。


1.2.3 CUDA Graphs:消除启动开销

原理简介

对于由一系列计算量小、执行速度快的核函数组成的工作流,CPU通过CUDA API逐个启动这些核函数的**启动开销(Launch Overhead)**本身可能会成为性能瓶颈。这个开销包括驱动程序调用、参数验证、将启动指令推送到GPU等步骤,通常需要几微秒(μs)的时间。如果一个核函数在GPU上只执行1μs,那么整个流程的绝大部分时间都耗费在了CPU的启动上。

CUDA Graphs 提供了一种“一次定义,多次运行”的机制来解决这个问题。它允许我们将一系列CUDA操作(核函数启动、内存拷贝等)捕获(Capture)到一个图中。一旦图被定义和实例化(Instantiate),我们就可以用一个API调用来**启动(Launch)**整个图的执行。这绕过了逐个核函数的启动路径,将CPU开销降至几乎为零,对于需要极低延迟的循环工作流至关重要。

技术手册:可执行代码

以下程序定义了一个包含三个微小内核的简单工作流,并对比了在循环中传统启动与使用CUDA Graph启动的CPU端总耗时。

C++

// =================================================================
// 编译指令:
// nvcc -o cuda_graphs cuda_graphs.cu
// =================================================================
#include <iostream>
#include <vector>
#include <chrono>
#include <cuda_runtime.h>

#define CUDA_CHECK(call) do { \
    cudaError_t err = call; \
    if (err != cudaSuccess) { \
        fprintf(stderr, "CUDA Error: %s:%d, ", __FILE__, __LINE__); \
        fprintf(stderr, "code: %d, reason: %s\n", err, cudaGetErrorString(err)); \
        exit(1); \
    } \
} while(0)

// 三个非常快的核函数
__global__ void add_one(float* data, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) data[idx] += 1.0f;
}
__global__ void mul_two(float* data, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) data[idx] *= 2.0f;
}
__global__ void sub_three(float* data, int n) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < n) data[idx] -= 3.0f;
}

int main() {
    int n = 1 << 10; // 使用小数据量以凸显启动开销
    size_t bytes = n * sizeof(float);
    int iterations = 10000;

    std::vector<float> h_data(n, 1.0f);
    float *d_data;
    CUDA_CHECK(cudaMalloc(&d_data, bytes));
    
    int threadsPerBlock = 128;
    int blocksPerGrid = (n + threadsPerBlock - 1) / threadsPerBlock;

    // --- 模式1: 传统循环启动 ---
    CUDA_CHECK(cudaMemcpy(d_data, h_data.data(), bytes, cudaMemcpyHostToDevice));
    
    auto start_cpu = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < iterations; ++i) {
        add_one<<<blocksPerGrid, threadsPerBlock>>>(d_data, n);
        mul_two<<<blocksPerGrid, threadsPerBlock>>>(d_data, n);
        sub_three<<<blocksPerGrid, threadsPerBlock>>>(d_data, n);
    }
    // 需要同步以确保所有GPU工作完成,才能准确计时
    CUDA_CHECK(cudaDeviceSynchronize());
    
    auto stop_cpu = std::chrono::high_resolution_clock::now();
    auto duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(stop_cpu - start_cpu).count();
    std::cout << "1. Traditional Loop CPU Time:      " << duration_ms << " ms" << std::endl;

    // --- 模式2: CUDA Graph ---
    CUDA_CHECK(cudaMemcpy(d_data, h_data.data(), bytes, cudaMemcpyHostToDevice));

    cudaGraph_t graph;
    cudaGraphExec_t instance;
    cudaStream_t stream;
    CUDA_CHECK(cudaStreamCreate(&stream));

    // -- 捕获Graph --
    CUDA_CHECK(cudaStreamBeginCapture(stream, cudaStreamCaptureModeGlobal));
    
    // 将工作流定义一次
    add_one<<<blocksPerGrid, threadsPerBlock, 0, stream>>>(d_data, n);
    mul_two<<<blocksPerGrid, threadsPerBlock, 0, stream>>>(d_data, n);
    sub_three<<<blocksPerGrid, threadsPerBlock, 0, stream>>>(d_data, n);

    CUDA_CHECK(cudaStreamEndCapture(stream, &graph));

    // -- 实例化Graph --
    CUDA_CHECK(cudaGraphInstantiate(&instance, graph, NULL, NULL, 0));

    // -- 循环启动Graph --
    start_cpu = std::chrono::high_resolution_clock::now();

    for (int i = 0; i < iterations; ++i) {
        CUDA_CHECK(cudaGraphLaunch(instance, stream));
    }
    // 等待Graph流完成
    CUDA_CHECK(cudaStreamSynchronize(stream));

    stop_cpu = std::chrono::high_resolution_clock::now();
    duration_ms = std::chrono::duration_cast<std::chrono::milliseconds>(stop_cpu - start_cpu).count();
    std::cout << "2. CUDA Graph Loop CPU Time:         " << duration_ms << " ms" << std::endl;

    // 验证结果
    float final_result;
    CUDA_CHECK(cudaMemcpy(&final_result, d_data, sizeof(float), cudaMemcpyDeviceToHost));
    // 预期结果: (1.0f + 1) * 2 - 3 = 1.0f
    std::cout << "Verification: final value is " << final_result << " (expected 1.0)" << std::endl;

    // --- 清理 ---
    CUDA_CHECK(cudaGraphExecDestroy(instance));
    CUDA_CHECK(cudaGraphDestroy(graph));
    CUDA_CHECK(cudaStreamDestroy(stream));
    CUDA_CHECK(cudaFree(d_data));

    return 0;
}

分析与预期结果: 您将看到一个惊人的性能差异:CUDA Graph Loop CPU Time 可能只有几毫秒,而 Traditional Loop CPU Time 可能需要数百甚至数千毫秒。这是因为在传统循环中,CPU在 iterations * 3 次核函数启动上花费了大量时间。而在CUDA Graph模式下,CPU只在循环中调用了iterations次cudaGraphLaunch,这是一个开销极低的API。这证明了CUDA Graphs在消除重复工作流的启动开销方面的绝对优势。

CPU与GPU并行计算本质差异:从硬件架构到CUDA编程实战 并行计算是现代AI与高性能计算的基石,其核心在于理解CPU与GPU截然不同的并行模型——CPU专注低延迟的串行逻辑与复杂控制,GPU则依赖高吞吐的SIMT(单指令多线程)架构处理海量同构任务。这种差异直接决定了内存管理、线程调度、数据迁移等关键机制的设计逻辑,也解释了为何torch.cuda.is_available()返回True却nvidia-smi显存占用异常、为何cudaMemcpy报invalid argument、以及为何FunASR在AMD GPU上因算子不兼容而fallback至CPU。掌握 阅读详情

相关推荐

GPU并行计算从入门到精通:核心架构、CUDA编程与性能优化全解析

并行计算是现代高性能计算的核心技术,其基本原理是通过同时执行多个计算任务来大幅提升处理速度。在硬件层面,GPU凭借其数千个流处理器核心和层次化的内存架构,成为处理大规模数据并行任务的理想平台。这一技术价值在于能够高效应对人工智能训练、科学模拟和图形渲染等对算力要求极高的场景。理解GPU的SM(流多处理器)、线程束调度以及全局内存与共享内存的差异,是进行有效编程和优化的基础。例如,在部署PyTorch进行大模型微调或解决GPU利用率低下问题时,掌握CUDA编程模型中的网格与线程块组织、内存合并访问以及使用Ns

weixin_33924312的博客 384

【CUDA编程部署教程】第一章:GPU架构与CUDA编程核心 1

我们将剖析现代GPU的计算心脏——流式多处理器(SM),理解其独特的Warp执行模型,探索Tensor Core带来的革命性矩阵运算加速,并深入探讨决定性能命脉的内存体系。当必须访问全局内存时,则必须遵循**合并访问(Coalesced Access)**的原则,即让一个Warp内的32个线程访问连续的内存地址,从而让硬件将多次访问合并为一次高效的内存事务,以充分利用带宽。SM的调度器以Warp为单位分派指令,在一个Warp内,所有32个线程在同一时刻执行完全相同的指令,但处理的数据不同,这种模型被称为。

VectorShift的博客 224

GPU编程实战:Java平台下的GPU-Yard教程

本文还有配套的精品资源,点击获取 简介:GPU-Yard项目旨在为Java开发者提供GPU编程的平台和资源,包括使用JCuda等库进行GPU计算。该项目介绍了GPU的基本概念、CUDA编程基础、JCuda库的使用教程,以及并行编程技巧和性能优化。它还涵盖了具体的实例代码和跨平台部署问题,帮助开发者提升数据密集型计算任务的性能,具有广泛的应用前景。 1. GPU编程...

weixin_35829279的博客 2345

5分钟搞定!用扣子空间LinkReaderPlugin快速搭建网页内容抓取机器人(附Python复现代码)

本文详细介绍了如何利用扣子空间的LinkReaderPlugin快速搭建网页内容抓取机器人,仅需5分钟即可完成配置。通过Python复现代码和可视化工作流,开发者可以轻松实现智能网页抓取,提升数据采集效率。文章还探讨了与RAG工作流的集成方案及性能优化技巧,适用于金融监控、电商追踪等多种场景。

study的专栏 1094

Python通用编程规范-09 安全编程规范

1.9 安全编程规范 1.9.1 异常行为 1.9.1.1 禁止抑制或者忽略已检查异常 【说明】: 编码人员常常会通过一个空的或者无意义的catch块来抑制捕获的已检查异常。每一个catch块都应该确保程序只会在继续有效的情况下才会继续运行下去。因此,catch块必须要么从异常情况中恢复,要么重新抛出适合当前catch块上下文的另一个异常以允许最邻近的外层try-catch语句块来进行恢复工作。异常会打断应用原本预期的控制流程。例如,try块中位于异常发生点之后的任何表达式和语句都不会被执行。因此,异常必须

zhao12501的博客 2872

RaiDrive+AList保姆级教程:5分钟搞定OneDrive/百度网盘挂载到本地(附WebDAV配置)

本文提供RaiDrive+AList的保姆级教程,5分钟内实现将OneDrive/百度网盘挂载到本地的详细步骤,包括WebDAV配置。通过AList统一转换云存储协议,RaiDrive虚拟磁盘挂载,显著提升多网盘管理效率,适合需要跨平台操作文件的用户。

weixin_28331555的博客 459

WGS-84 ECEF ENU 坐标系学习记录

地球坐标系固定在地球上而随地球一起在空间做公转和自转运动,因此地球上任一固定点在地球坐标系的坐标就不会由于地球旋转而变化。地心地固直角坐标系和大地坐标系都属于这种坐标系。 一、 几种坐标系 地心地固直角坐标系(ECEF)坐标系 其原点为地球的质心,x轴延伸通过本初子午线(0度经度)和赤道(0deglatitude)的交点。 z轴延伸通过的北极(即,与地球旋转轴重合)。 y轴完成右手坐标系,穿...

YYshuangshuang的博客 1万+

Cartool实战:手把手教你完成静息态EEG微状态分析的组水平聚类与模板匹配

本文详细解析了使用Cartool进行静息态EEG微状态分析的组水平聚类与模板匹配全流程。从数据准备、算法选择到参数优化,提供了k-means与T-AAHC算法的实操建议,帮助研究者避开常见陷阱,获得可靠分析结果。特别针对最优类别数确定、模板匹配参数设置等核心环节进行深入探讨,适用于认知神经科学领域的EEG微状态研究。

weixin_31220401的博客 263

费斯托SPAN压力传感器的调试

本体为压力传感器,检测气压大小,通过设置参数,在上电上气时对气压进行判断,进而通过自身逻辑的判断,控制传感器的通断,进而控制机械部位的工作与运行;通电之后为如下图所示的样子有三个按键ABEdit键(编辑键、确认键)两步即可轻松连接。

大小曲奇的博客 1万+

腾讯游戏安全组件运行异常的全面解决方案

在使用腾讯游戏时,玩家可能会遭遇游戏安全组件运行异常的问题,这不仅影响游戏的正常启动,还可能在游戏过程中引发一系列问题。本文将详细介绍解决腾讯游戏安全组件运行异常的几种方法,帮助玩家重拾游戏乐趣。腾讯游戏安全组件运行异常是一个复杂的问题,可能涉及服务设置、游戏更新、系统环境优化以及硬件与驱动检查等多个方面。最后,希望本文能帮助玩家顺利解决腾讯游戏安全组件运行异常的问题,让玩家能够无忧无虑地享受游戏带来的乐趣。首先,我们需要从系统的服务管理入手,检查与游戏安全组件相关的服务是否正常运行。

nntxthml的博客 5820

C# 上位机之海康工业相机开发(SDK)实战教程

海康工业相机的C#开发核心是基于MVS SDK的“初始化→枚举→连接→采集→释放”流程,其中图像回调处理和格式转换是关键。严格按照SDK文档处理设备类型(网口/USB)和像素格式;及时释放图像资源,避免内存泄漏;错误码是排查问题的重要依据(可参考SDK中的“错误码说明”文档)。掌握这些基础后,可结合机器视觉算法(如OpenCV)实现缺陷检测、尺寸测量等高级功能,构建完整的工业视觉系统。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 3842

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

上一篇: 【CUDA编程部署教程】第一章:GPU架构与CUDA编程核心 1
下一篇: 【CUDA编程部署教程】第二章:TensorRT标准工作流
VectorShift
博客等级 码龄1年 1842粉丝 1109原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

VectorShift

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值