CUDA架构介绍与设计模式解析

文章目录

  • **CUDA**架构介绍与设计模式解析
    • **1** CUDA 介绍
      • CUDA发展历程
      • CUDA主要特性
      • CUDA系统架构
      • CUDA应用场景
      • 编程语言支持
      • CUDA计算过程
        • 线程层次
        • 存储层次
    • **2** CUDA 系统架构
      • 分层架构
      • 并行计算模式
      • 生产-消费者模式
      • 工作池模式
      • 异步编程模式
    • **3** CUDA 中的设计模式
      • 工厂模式
      • 策略模式
      • 观察者模式
      • 适配者模式
      • 迭代器模式

CUDA架构介绍与设计模式解析

1 CUDA 介绍

CUDA发展历程

CUDA 是 NVIDIA 于 2006 年推出的通用并行计算架构，经过多年发展，已成为 GPU 计算的重要标准。

CUDA主要特性

CUDA 提供强大的并行计算能力，具备以下特性：

  • 线程层次结构
  • 扩展了 C/C++ 语言，引入了 GPU 扩展如 kernel 函数
  • 显式的内存层次结构，允许根据计算需求访问内存数据
  • 跨平台支持

CUDA系统架构

CUDA 系统架构由以下三部分构成，为开发者提供丰富的资源和接口：

  • 开发库
  • 驱动
  • 运行期环境

CUDA应用场景

CUDA 最初用于图形渲染，现已广泛应用于：

  • 高性能计算
  • 游戏开发
  • 深度学习等领域

编程语言支持

CUDA 支持多种编程语言，包括：

  • C
  • C++
  • Fortran
  • Java
  • Python等

但本次源码阅读和分析以 C/C++ 为主。

CUDA计算过程

  1. 分配 host 内存并进行数据初始化。
  2. 分配 device 内存，并将数据从 host 拷贝到 device 上。
  3. 调用 CUDA 核函数在 device 上完成指定的运算。
  4. 将 device 上的运算结果拷贝到 host 上。
  5. 释放 device 和 host 上分配的内存。
    在这里插入图片描述
线程层次
  1. Grid：最高级的并行计算单位，由多个线程块（blocks）组成，可同时在 GPU 上执行。
  2. Block：线程块是网格的组成部分，包含多个线程，可协作和共享资源。
  3. Thread：最基本的并行执行单元，存在于线程块内部，每个线程可以独立执行计算任务，根据自身的线程索引执行。
    在这里插入图片描述

优势：

  • 有效管理并行计算资源。
  • 优化数据访问和内存使用。
  • 提高任务并行度和负载均衡。
  • 适应不同的并行计算需求。
存储层次
  1. 全局内存（Global Memory）：GPU 中所有线程都可访问的主要存储区域，用于存储大量数据和程序状态，是主机与设备之间数据传输的主要桥梁。
  2. 常量内存（Constant Memory）：用于存储只读数据，如常数和预计算的表格，具有较高的缓存性能。
  3. 纹理内存（Texture Memory）：存储图像和多维数据，提供高效、灵活的访问方式。
  4. 共享内存（Shared Memory）：位于线程块内部的低延迟、高带宽的存储区域，用于线程块内部的数据共享和通信。
    在这里插入图片描述

2 CUDA 系统架构

分层架构

从体系结构的组成来说，CUDA 包含了三个部分：

  1. 开发库 (Libraries)：它是基于 CUDA 技术所提供的应用开发库。CUDA 包含两个重要的标准数学运算库——CUFFT（离散快速傅立叶变换）和 CUBLAS（基本线性代数子程序库）。这两个数学运算库解决的是典型的大规模的并行计算问题，也是在密集数据计算中非常常见的计算类型。
  2. 运行期环境 (Runtime)：提供了应用开发接口和运行期组件，包括基本数据类型的定义和各类计算、类型转换、内存管理、设备访问和执行调度等函数。例如：
    • 运行时 API：提供了一系列函数，用于执行设备内存分配、内核启动、事件管理、流控制等操作。
    • 核函数：这是在 GPU 上并行执行的函数，由开发者编写，用于执行具体的并行计算任务。
  3. 驱动 (Driver)：驱动程序层位于硬件层之上，是 CUDA 架构中的中间件，负责硬件抽象、资源管理、错误处理、CPU 和 GPU 通信。驱动程序层通过 CUDA 运行时 API 与主机代码交互。
    在这里插入图片描述

并行计算模式

在这里插入图片描述

  1. SIMT (Single Instruction Multiple Threads)：单指令多线程是 CUDA 架构中的重要执行模型，它允许一组线程（称为线程束或 warp）同时执行相同的指令，但处理不同的数据。

    • 每个 warp 包含一定数量的 core 用于执行，warp 是硬件调度的并行的最小单位。
    • 与 CPU 不同的是，GPU 的执行调度单位为 warp，而 CPU 调度可以精细化为单个线程。因为 CPU 同时执行的线程数目比较少，而 GPU 要同时管理成千上万个线程，因此 GPU 一次性调度的是多个线程。
      在这里插入图片描述

  2. Grids, Blocks, Threads：具体到编程层面，程序员可以通过 Grids、Blocks 和 Threads 的编程模型来组织执行的线程：

    • Threads (线程)：是 CUDA 中最小的执行单位。每个线程执行核函数中的指令，并且可以独立处理数据。
    • Blocks (块)：一个 Block 是一组线程的集合，这些线程可以共享一个内存空间。Block 内的线程通过 threadIdx 进行索引。
    • Grids (网格)：Grid 是多个 Block 的集合，构成了核函数调用的全部执行范围。Grid 内的 Block 通过 blockIdx 进行索引。
    • 当启动一个核函数时，CUDA 运行时环境会创建一个 Grid，该 Grid 由多个 Blocks 组成，每个 Block 又包含多个 Threads。

示例代码：

__global__ void vectorAdd(int *A, int *B, int *C, int N) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < N) {
        C[idx] = A[idx] + B[idx];
    }
}
int main() {
    int N = 1000;
    int *A, *B, *C;
    int block_size = 256;
    int grid_size = (N + block_size - 1) / block_size;
    // 分配和初始化设备内存
    cudaMalloc(&A, N * sizeof(int));
    cudaMalloc(&B, N * sizeof(int));
    cudaMalloc(&C, N * sizeof(int));
    // 将数据从主机复制到设备
    cudaMemcpy(A, host_A, N * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(B, host_B, N * sizeof(int), cudaMemcpyHostToDevice);
    // 启动核函数
    vectorAdd<<<grid_size, block_size>>>(A, B, C, N);
    // 等待核函数执行完成
    cudaDeviceSynchronize();
    // 将结果从设备复制回主机
    cudaMemcpy(host_C, C, N * sizeof(int),  cudaMemcpyDeviceToHost);
    // 释放设备内存
    cudaFree(A);
    cudaFree(B);
    cudaFree(C);
    return 0;}

源码分析：

  • 核函数 vectorAdd() 定义了向量加法的操作；
  • int idx = blockIdx.x * blockDim.x + threadIdx.x;：计算出了当前线程的全局索引。blockIdx.x 表示当前线程所在的块的索引，blockDim.x 表示当前块中线程的数量，threadIdx.x 表示当前线程在块内的索引。
  • 在 main 函数中，定义了 Blocks 的数量（grid_size）和每个 Block 的线程数量（block_size），并启动核函数 vectorAdd<<<grid_size, block_size>>>。
  • 核函数中的每个线程都将执行相同的加法操作，但操作不同的数据元素，也就是向量中不同维度的数据。

生产-消费者模式

CUDA 中的生产者-消费者模式用于解决主机（CPU）和设备（GPU）之间的数据传输和计算任务之间的协作。主机（CPU）充当生产者，负责生成指令和数据并将其传输到设备上，而设备（GPU）充当消费者，负责获取数据并执行计算任务。

生产者-消费者模式的主要特点包括：

  • 数据传输：生产者负责生成数据，并将数据传输到设备的内存中。这可以通过 CUDA 的内存复制函数（如 cudaMemcpy）来完成。
  • 计算任务：消费者负责从设备的内存中获取数据，并执行相应的计算任务，通常是通过启动核函数来实现的。
  • 数据同步：CUDA 使用流（Stream）来管理并行执行的操作序列，进行数据同步操作，以确保数据传输和计算任务的正确执行顺序。

示例代码：

#include <iostream>
__global__ void kernel(int *data, int N) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < N) {
        data[idx] *= 2;
    }
}
int main() {
    const int N = 1000;
    int *hostData, *deviceData;
    
    // 分配主机内存并初始化数据
    hostData = new int[N];
    for (int i = 0; i < N; ++i) {
        hostData[i] = i;
    }
    // 分配设备内存
    cudaMalloc(&deviceData, N * sizeof(int));
    // 将数据从主机复制到设备
    cudaMemcpy(deviceData, hostData, N * sizeof(int), cudaMemcpyHostToDevice);
    // 启动核函数，在设备上执行计算任务
    const int blockSize = 256;
    const int gridSize = (N + blockSize - 1) / blockSize;
    kernel<<<gridSize, blockSize>>>(deviceData, N);
    // 将结果从设备复制回主机
    cudaMemcpy(hostData, deviceData, N * sizeof(int), cudaMemcpyDeviceToHost);
    // 打印结果
    for (int i = 0; i < N; ++i) {
        std::cout << hostData[i] << " ";
    }
    std::cout << std::endl;
    // 释放内存
    delete[] hostData;
    cudaFree(deviceData);
    return 0;
}

源码分析：

  • 主机（生产者）生成了一个包含 1000 个整数的数据，并将数据传输到设备上。
  • 设备（消费者）执行了核函数，进行具体的处理。
  • 最后，设备将处理后的数据传输回主机，主机打印出结果。
  • 通过这种方式，实现了主机和设备之间的生产者-消费者模式，充分利用了 GPU 的并行计算能力。

工作池模式

CUDA 中的工作池模式用于管理和调度大量的任务，以实现高效的并行计算。在工作池模式中，任务被组织成一个池子（工作池），并由多个工作线程并行执行。这种模式使得可以在 GPU 上同时处理多个任务，从而充分利用 GPU 的并行计算资源。

工作池模式的关键组件：

  • 任务队列（Task Queue）：用于存储待执行的任务。任务可以是任何需要在 GPU 上执行的操作，例如核函数调用、数据传输等。
  • 工作线程（Worker Threads）：负责从任务队列中获取任务，并执行这些任务。通常，工作线程会持续地从任务队列中获取任务，并在 GPU 上执行这些任务，直到任务队列为空或者达到某个终止条件。
  • 任务调度器（Task Scheduler）：负责调度工作线程的执行。任务调度器通常会根据任务队列的状态和工作线程的负载情况，动态地分配任务给工作线程，以实现任务的均衡分配和高效执行。

示例代码：

// 任务类型
typedef void (*Task)(int *, int);
// 任务队列
std::queue<Task> taskQueue;
std::mutex queueMutex;
std::condition_variable queueCondition;
// 工作线程函数
void workerThread(int *array, int N) {
    while (true) {
        Task task;
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            // 等待任务队列非空
            queueCondition.wait(lock, [](){ return !taskQueue.empty(); });
            // 从任务队列中获取任务
            task = taskQueue.front();
            taskQueue.pop();
        }
        // 执行任务
        task(array, N);
    }
}
// 核函数，将数组中的每个元素乘以2
__global__ void kernel(int *array, int N) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < N) {
        array[idx] *= 2;
    }
}
// 添加任务到任务队列
void addTask(int *array, int N) {
    taskQueue.push(kernel);
    queueCondition.notify_one(); // 唤醒一个工作线程
}
int main() {
    const int N = 1000;
    int *d_array;
    cudaMalloc(&d_array, N * sizeof(int));
    // 定义并行执行的任务数量
    const int numTasks = 10;
    // 创建并启动工作线程
    std::thread threads[numTasks];
    for (int i = 0; i < numTasks; ++i) {
        threads[i] = std::thread(workerThread, d_array, N);
    }
    // 添加多个任务到任务队列
    for (int i = 0; i < numTasks; ++i) {
        addTask(d_array, N);
    }
    // 等待所有工作线程执行完成
    for (int i = 0; i < numTasks; ++i) {
        threads[i].join();
    }
    // 处理执行结果...
    cudaFree(d_array);
    return 0;
}

源码分析：

  • 在 main 中创建一组任务和工作线程。
  • 每个工作线程不断地从任务队列中获取任务，并在 GPU 上执行这些任务，直到任务队列为空。

异步编程模式

CUDA 中的异步编程模式是指，在主机和设备之间并行执行多个任务，从而提高了整体的计算和数据传输效率。

CUDA 中异步编程模式的特点：

  • 并行执行：允许主机和设备之间同时执行多个任务，从而避免了在等待一个任务完成时的空闲时间，提高了整体的计算和数据传输效率。
  • 任务调度：CUDA 运行时会自动管理和调度异步任务的执行顺序，以最大程度地利用 GPU 的并行计算资源，减少任务之间的等待时间。
  • 流控制：开发者可以通过 CUDA 中的流（Stream）对异步任务进行组织和管理。通过流控制，开发者可以控制任务的执行顺序，以及任务之间的依赖关系，从而实现更复杂的并行计算和数据传输操作。

示例代码：

#include <iostream>
__global__ void kernel(int *array, int N) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;
    if (idx < N) {
        array[idx] *= 2;
    }
}
int main() {
    const int N = 1000;
    int *d_array;
    cudaMalloc(&d_array, N * sizeof(int));
    // 创建一个流
    cudaStream_t stream;
    cudaStreamCreate(&stream);
    // 异步启动核函数
    kernel<<<(N + 255) / 256, 256, 0, stream>>>(d_array, N);
    // 主机代码继续执行其他任务...
    // 等待流中的核函数执行完成
    cudaStreamSynchronize(stream);
    // 处理核函数执行结果...
    // 释放流
    cudaStreamDestroy(stream);
    cudaFree(d_array);
    return 0;
}

源码分析：

  • 主机创建一个流，并把核函数绑定到这个流实现异步启动，这样主机可以继续执行其他任务。
  • 然后，主机通过 cudaStreamSynchronize 函数等待流中的核函数执行完成，以确保可以安全地处理核函数的执行结果。
  • 通过异步编程模式，主机和设备之间实现了并行执行，提高了整体的计算和数据传输效率。

3 CUDA 中的设计模式

工厂模式

工厂模式（Factory Pattern）是一种常用的软件设计模式，属于创建型模式。其核心思想是通过工厂类中的一个共用方法来处理对象的创建，将对象的创建和对象的使用分离开来，以便于达到扩展性高、耦合度低的目的。

工厂模式的基本组成：

  1. 产品 (Product)：定义了产品的接口。
  2. 具体产品 (Concrete Product)：实现了产品接口的具体类。
  3. 工厂 (Factory)：提供了一个创建产品的方法，可以返回不同类型的产品对象。

内存分配函数 cudaMalloc

示例代码：

#include <stdio.h>
#include <cuda_runtime.h>
int main() {
  int size = 1024 * sizeof(int);
  int *d_array;
  // 使用工厂模式的 cudaMalloc 在设备上分配内存
  cudaMalloc((void**)&d_array, size);
  // 内存分配成功后，可以在设备上使用 d_array

  // ...
  cudaFree(d_array); // 释放设备内存
  return 0;
}

源码分析：

  • cudaMalloc 函数是 CUDA Runtime API 提供的内存分配函数，其定义如下：
cudaError_t cudaMalloc(void** devPtr, size_t size);
  • devPtr 是一个指向设备内存指针的指针，在函数调用后将指向分配的设备内存。
  • size 是要分配的内存大小（字节数）。
  • 函数返回 cudaError_t 类型的错误码，表示函数执行的状态。

策略模式

策略模式（Strategy Pattern）是一种定义一系列算法的软件设计模式，它属于行为型模式。策略模式允许客户端在运行时根据需要选择不同的算法，而不需要修改客户端代码。其目的是将算法的使用从算法的实现中分离出来，让两者之间不相互依赖，从而提高程序的灵活性和可扩展性。

策略模式的基本组成：

  1. 策略 (Strategy)：定义所有支持的算法的公共接口。
  2. 具体策略 (Concrete Strategy)：实现了策略接口的具体算法类。
  3. 环境 (Context)：持有一个策略类的引用，用该策略的接口来与之交互。

示例代码：

#include <iostream>
#include <cuda_runtime.h>
class ParallelizationStrategy {
public:
    virtual void execute(int* data, int size) const = 0;
    virtual ~ParallelizationStrategy() {}
};
class ThreadPerElementStrategy : public ParallelizationStrategy {//基于线程的并行化
public:
    virtual void execute(int* data, int size) const override {
        // Execute algorithm with one thread per element
        int idx = threadIdx.x + blockIdx.x * blockDim.x;
        if (idx < size) {
            // Do computation
        }
    }
};
class ThreadBlockStrategy : public ParallelizationStrategy {//基于线程块的并行化
public:
    virtual void execute(int* data, int size) const override {
        // Execute algorithm with one thread per block
        int idx = blockIdx.x;
        if (idx < size) {
            // Do computation
        }
    }
};
class Kernel {
private:
    ParallelizationStrategy* strategy;

public:
    Kernel(ParallelizationStrategy* strat) : strategy(strat) {}

    void run(int* data, int size) const {
        strategy->execute(data, size);
    }
};
int main() {
    const int dataSize = 1000;
    int* data;
    cudaMalloc(&data, dataSize * sizeof(int));

    ThreadPerElementStrategy perElementStrategy;
    Kernel kernel1(&perElementStrategy);
    kernel1.run(data, dataSize);

    ThreadBlockStrategy blockStrategy;
    Kernel kernel2(&blockStrategy);
    kernel2.run(data, dataSize);

    cudaFree(data);
    return 0;
}

源码分析：

在主函数中创建了两个不同的Kernel对象，分别使用不同的策略来执行内核函数。这样就实现了在运行时选择不同的算法行为，而不需要改变客户端代码的逻辑。

观察者模式

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了对象之间的一对多依赖关系。当一个对象（被观察者）的状态发生变化时，所有依赖它的对象（观察者）都会收到通知并自动更新。这种模式常用于事件驱动的系统，以实现松耦合。

观察者模式的基本组成：

  1. 主题 (Subject)：维护了一个观察者列表，并能够触发观察者列表中的所有观察者。
  2. 观察者 (Observer)：定义了一个更新接口，用以更新状态。
  3. 具体主题 (Concrete Subject)：实现了主题，具体通知观察者。
  4. 具体观察者 (Concrete Observer)：实现了观察者的更新接口，以反映主题的状态。

CUDA 事件可以用来监视核函数执行的状态，并在完成时通知主机。

示例代码：

cudaEvent_t event;
cudaEventCreate(&event); // 创建事件
myKernel<<<numBlocks, threadsPerBlock>>>();//核函数执行
cudaEventRecord(event); // 记录事件，核函数执行完成后触发事件
cudaEventSynchronize(event); // 等待事件完成
// 处理事件完成后的逻辑
…

适配者模式

迭代器模式（Iterator Pattern）是软件设计中的一种常用行为型模式，它允许客户端在不暴露其底层数据结构的情况下，顺序访问聚合对象中的元素。迭代器模式定义了一个数据访问接口，用于在元素之间进行导航，而不依赖于聚合对象的具体类。

迭代器模式的基本组成：

  1. 迭代器 (Iterator)：定义了访问和遍历元素的接口。
  2. 具体迭代器 (Concrete Iterator)：实现了迭代器接口，跟踪当前访问的位置。
  3. 聚合 (Aggregate)：定义了一个创建迭代器的方法。
  4. 具体聚合 (Concrete Aggregate)：实现了创建具体迭代器的方法。

有两个版本的核函数，它们执行相同的操作，但是实现方式不同。在主机代码中使用一个统一的接口来调用这些核函数，而不需要关心它们的具体实现细节。

示例代码：

// 核函数版本1

__global__ void kernelVersion1(int *data, int value) {
  int tid = threadIdx.x + blockIdx.x * blockDim.x;
  if (tid < size) {
    data[tid] += value;
  }
}
// 核函数版本2
__global__ void kernelVersion2(int *data, int value) {
  int tid = threadIdx.x + blockIdx.x * blockDim.x;
  atomicAdd(&data[tid], value); // 使用原子操作来更新数据
}
// 核函数版本1的适配器
class KernelLauncherV1 : public IKernelLauncher {
public:
    void launch(int *data, int value, int size) override {
        kernelVersion1<<<...>>>(data, value);
    }
};
// 核函数版本2的适配器
class KernelLauncherV2 : public IKernelLauncher {
public:
    void launch(int *data, int value, int size) override {
        kernelVersion2<<<...>>>(data, value);
    }
};
int main() {
    int *data; // 假设已经分配和初始化了设备内存
    int value = 10;
    int size = 1024;

    // 根据需要选择使用哪个版本的核函数
    std::unique_ptr<IKernelLauncher> launcher;
    if (useVersion1) {
        launcher = std::make_unique<KernelLauncherV1>();
    } else {
        launcher = std::make_unique<KernelLauncherV2>();
    }

    // 使用适配器接口调用核函数
    launcher->launch(data, value, size);

    cudaDeviceSynchronize(); // 等待GPU完成工作
    // ... 后续处理 ...

    return 0;
}

源码分析：

在上述CUDA适配器模式的示例中，其创建了一个抽象的IKernelLauncher接口，该接口定义了启动核函数的通用方法launch。这个接口允许我们通过统一的调用方式来执行不同的核函数实现，而不必在主机代码中硬编码每个核函数的具体调用。

迭代器模式

迭代器模式（Iterator Pattern）是软件设计中的一种常用行为型模式，它允许客户端在不暴露其底层数据结构的情况下，顺序访问聚合对象中的元素。迭代器模式定义了一个数据访问接口，用于在元素之间进行导航，而不依赖于聚合对象的具体类。

迭代器模式的基本组成：

  1. 迭代器 (Iterator)：定义了访问和遍历元素的接口，通常包含 next(), prev(), first(), last(), isDone() 和 currentItem() 等方法。
  2. 具体迭代器 (Concrete Iterator)：实现了迭代器接口，跟踪当前访问的位置，并在内部维护一个指向聚合对象中某个位置的引用。
  3. 聚合 (Aggregate)：定义了一个创建迭代器的方法，通常是一个 createIterator() 方法，用于返回一个迭代器的实例。
  4. 具体聚合 (Concrete Aggregate)：实现了创建具体迭代器的方法，返回一个具体迭代器的实例，该实例能够遍历具体聚合中的所有元素。

Ps:迭代器模式在CUDA中不是直接应用的，因为CUDA的编程模型主要关注于如何高效地映射并行计算到GPU上。迭代器模式在CUDA中的一种可能应用场景：遍历设备内存中的数组。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/583767.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

电脑技巧：推荐一款非常好用的媒体播放器PotPlayer

电脑技巧：推荐一款非常好用的媒体播放器PotPlayer

目录 一、 软件简介 二、功能介绍 2.1 格式兼容性强 2.2 高清播放与硬件加速 2.3 自定义皮肤与界面布局 2.4 多音轨切换与音效增强 2.5 字幕支持与编辑 2.6 视频截图与录像 2.7 网络流媒体播放 三、软件特色 四、使用技巧 五、总结 一、 软件简介 PotPlayer播放器 …
阅读更多...
【MATLAB源码-第201期】基于matlab的黏菌群优化算法(SMA)无人机三维路径规划，输出做短路径图和适应度曲线

【MATLAB源码-第201期】基于matlab的黏菌群优化算法(SMA)无人机三维路径规划，输出做短路径图和适应度曲线

操作环境&#xff1a; MATLAB 2022a 1、算法描述 黏菌优化算法&#xff08;Slime Mould Algorithm, SMA&#xff09;是一种新颖的启发式优化方法&#xff0c;其灵感来源于自然界中的真菌——黏菌。这种算法模拟了黏菌在寻找食物时的行为和网络形成策略。在本文中&#xff0c…
阅读更多...
【Linux】yum、vim

【Linux】yum、vim

&#x1f308;个人主页&#xff1a;秦jh__https://blog.csdn.net/qinjh_?spm1010.2135.3001.5343&#x1f525; 系列专栏&#xff1a;https://blog.csdn.net/qinjh_/category_12625432.html 目录 Linux 软件包管理器 yum 什么是软件包 查看软件包 如何安装软件 如何卸载软…
阅读更多...
网络安全的重要性及人才需求

网络安全的重要性及人才需求

安全现在是大趋势&#xff0c;说是铁饭碗也不为过&#xff0c;就业前景好&#xff0c;方向多比传统计算机行业就业舒服点。但是大厂依然是985&#xff0c;211的天下&#xff0c;是双非能进大厂的&#xff0c;只是凤毛麟角。前提是你的能力可以让公司忽略你的学历。 以2023年为…
阅读更多...
【华为】VRRP的实验配置

【华为】VRRP的实验配置

【华为】VRRP的实验配置 实验需求拓扑LSW 3LSW 1基础配置VRRPDHCPOSPF默认路由 LSW 2基本配置VRRPDHCPOSPF默认路由 R1ISPPC1PC2 测试上网VRRP实验需求监视端口 配置文档 实验需求 ① 该公司有市场部和技术部&#xff0c;分别划在VLAN 10 和 VLAN 20里面 ② 此时为了网络的稳…
阅读更多...
万兆以太网MAC设计（12）万兆UDP协议栈上板与主机网卡通信

万兆以太网MAC设计（12）万兆UDP协议栈上板与主机网卡通信

文章目录 一、设置IP以及MAC二、上板效果2.1、板卡与主机数据回环测试2.2、板卡满带宽发送数据 一、设置IP以及MAC 顶层模块设置源MAC地址 module XC7Z100_Top#(parameter P_SRC_MAC 48h01_02_03_04_05_06,parameter P_DST_MAC 48hff_ff_ff_ff_ff_ff )(input …
阅读更多...
双目深度估计原理立体视觉

双目深度估计原理立体视觉

双目深度估计原理&立体视觉 0. 写在前面1. 双目估计的大致步骤2. 理想双目系统的深度估计公式推导3. 双目标定公式推导4. 极线校正理论推导 0. 写在前面 双目深度估计是通过两个相机的对同一个点的视差来得到给该点的深度。 标准系统的双目深度估计的公式推导需要满足:1)两…
阅读更多...
ASR语音转录Prompt优化

ASR语音转录Prompt优化

ASR语音转录Prompt优化 一、前言 在ASR转录的时候&#xff0c;我们能很明显的感受到有时候语音识别不是很准确&#xff0c;这过程中常见的文本错误主要可以归纳为以下几类&#xff1a; 同音错误&#xff08;Homophone Errors&#xff09; 同音错误发生在不同词语发音相似或相…
阅读更多...
Modelsim自动仿真平台的搭建

Modelsim自动仿真平台的搭建

Modelsim自动仿真平台的搭建 如果要搭建自动仿真平台脚本那就需要更改下面3个文件。run_simulation.bat、complie.do和wave.do文件。注&#xff1a;前提是安装了modulsim并且配置好了环境变量&#xff0c;这里不过多介绍。 一、下面是run_simulation.bat文件的内容 : 注释的…
阅读更多...
MySQL-查询数据-练习

MySQL-查询数据-练习

练习 1.创建一个查询&#xff0c;显示收入超过 12,000 的雇员的名字和薪水。 select LAST_NAME,SALARY from employees where SALARY > 12000;2.创建一个查询&#xff0c;显示雇员号为 176 的雇员的名字和部门号。 select LAST_NAME,DEPARTMENT_ID from employees where …
阅读更多...
前端vue如何生成二维码

前端vue如何生成二维码

有时候有需要链接直接生成二维码在手机上看的需求&#xff0c;比如下载&#xff0c;比如信息&#xff0c;比如excel 下面先引入包 import QRCode from qrcode; 然后上代码 // 将res转换成二维码const qrCodeData JSON.stringify(res); // 将res转换为字符串作为二维码数据// …
阅读更多...
WebSocket 全面解析

WebSocket 全面解析

&#x1f31f; 引言 WebSocket&#xff0c;一个让实时通信变得轻而易举的神器&#xff0c;它打破了传统HTTP协议的限制&#xff0c;实现了浏览器与服务器间的全双工通信。想象一下&#xff0c;即时消息、在线游戏、实时股票报价…这一切都离不开WebSocket的魔力&#x1f4ab;。…
阅读更多...
xLua热更新解决方案

xLua热更新解决方案

图中灰色的无法实现热更新&#xff0c;而Lua代码可以打包成AB包&#xff0c;并上传到资源服务器&#xff0c; 当进入游戏检测是否有资源需要更新&#xff0c;需要则会从资源服务器下载。 学习目标 1.导入xLua框架 2.C#调用Lua 3.Lua调用C# 4.xLua热补丁 xLua框架导入和AB…
阅读更多...
什么是网络安全等级保护测评（等保测评）？

什么是网络安全等级保护测评（等保测评）？

什么是网络安全等级保护测评&#xff08;等保测评&#xff09;呢&#xff1f;今天永恒无限就为大家介绍下网络安全等级保护测评&#xff08;等保测评&#xff09; 网络安全等级保护测评&#xff08;等保测评&#xff09;是指对信息和信息系统按照重要性等级进行的保护测评。它…
阅读更多...
爱普生晶振在物联网LoRa通讯中的应用

爱普生晶振在物联网LoRa通讯中的应用

LoRa 是LPWAN通信技术中的一种&#xff0c;是美国Semtech公司采用和推广的一种基于扩频技术的超远距离无线传输方案。这一方案改变了以往关于传输距离与功耗的折衷考虑方式&#xff0c;为用户提供一种简单的能实现远距离、长电池寿命、大容量的系统&#xff0c;进而扩展传感网络…
阅读更多...
C语言：项目实践（贪吃蛇）

C语言：项目实践（贪吃蛇）

前言&#xff1a; 相信大家都玩过贪吃蛇这款游戏吧&#xff0c;贪吃蛇是久负盛名的游戏&#xff0c;它也和俄罗斯方块&#xff0c;扫雷等游戏位列经典游戏的行列&#xff0c;那贪吃蛇到底是怎么实现的呢&#xff1f; 今天&#xff0c;我就用C语言带着大家一起来实现一下这款游戏…
阅读更多...
Golang Colly爬取图片gorm存储数据

Golang Colly爬取图片gorm存储数据

语言：Golang 库：Iris/Colly/gorm 运行结果 text/html; charset=utf-8 It is image 20240429222029_0_0.jpg Saved file: images\20240429222029_0_0.jpg text/html; charset=utf-8 It is image 20240429222030_1_0.jpg Saved file: images\20240429222030_1_0.jpg It is ima…
阅读更多...
String类1⃣️

String类1⃣️

目录 预备知识 1.string成员函数 1.string() 2.string (const char* s); 3.string (size_t n, char c); 4.string (const string& str);&#xff08;拷贝构造&#xff09; 2.string类对象的容量操作 1.size length 2.max_size 3.resize 4.capacity 5.empty 6…
阅读更多...
【leetcode面试经典150题】78.二叉树中的最大路径和（C++）

【leetcode面试经典150题】78.二叉树中的最大路径和（C++）

【leetcode面试经典150题】专栏系列将为准备暑期实习生以及秋招的同学们提高在面试时的经典面试算法题的思路和想法。本专栏将以一题多解和精简算法思路为主&#xff0c;题解使用C语言。&#xff08;若有使用其他语言的同学也可了解题解思路&#xff0c;本质上语法内容一致&…
阅读更多...
元数据管理在态势感知系统的应用

元数据管理在态势感知系统的应用

在当今信息爆炸的时代&#xff0c;数据量呈指数级增长&#xff0c;如何高效地管理和利用这些数据成为了各行各业所面临的重要问题。在网络安全领域&#xff0c;态势感知系统作为一种重要的安全防御工具&#xff0c;承担着及时发现、分析和应对安全威胁的重任。 然而&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023