使用ROCm的HIP API向量加法程序

一、向量加法程序

Radeon Open Compute (ROCm) 是一个开源平台，用于加速高性能计算 (HPC) 和机器学习应用程序。它支持包括GPUs在内的多种硬件，并提供HIP (Heterogeneous-compute Interface for Portability) 作为CUDA代码的便捷转换工具。为了提供一个使用ROCm的实例，假设已经在符合要求的硬件上安装了ROCm环境。下面的例子是一个简单的向量加法程序，使用了ROCm的HIP API。

首先，需要编写 HIP 源代码，该代码之后可以被编译运行在 AMD GPU 上。可以创建一个名为 vector_add.cpp 的文件：

#include <hip/hip_runtime.h>
#include <iostream>

#define N 50000

__global__ void vector_add(float *out, float *a, float *b, int n) {
    int index = threadIdx.x + blockIdx.x * blockDim.x;
    if (index < n) {
        out[index] = a[index] + b[index];
    }
}

int main() {
    float *a, *b, *out;
    float *d_a, *d_b, *d_out;

    // 分配host内存
    a = (float*)malloc(sizeof(float) * N);
    b = (float*)malloc(sizeof(float) * N);
    out = (float*)malloc(sizeof(float) * N);

    // 初始化数据
    for (int i = 0; i < N; i++) {
        a[i] = float(i);
        b[i] = float(i);
    }

    // 分配device(GPU)内存
    hipError_t err;  
    err = hipMalloc((void**)&d_a, sizeof(float) * N);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMalloc failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }
        
    err = hipMalloc((void**)&d_b, sizeof(float) * N);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMalloc failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    err = hipMalloc((void**)&d_out, sizeof(float) * N);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMalloc failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    // 将host数据复制到device(GPU)上
    err = hipMemcpy(d_a, a, sizeof(float) * N, hipMemcpyHostToDevice);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMemcpy failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    err = hipMemcpy(d_b, b, sizeof(float) * N, hipMemcpyHostToDevice);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMemcpy failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    // 执行kernel
    int blockSize = 256;
    int gridSize = (int)ceil((float)N/blockSize);
    hipLaunchKernelGGL(vector_add, dim3(gridSize), dim3(blockSize), 0, 0, d_out, d_a, d_b, N);

    // 将计算结果复制回host内存
    err = hipMemcpy(out, d_out, sizeof(float) * N, hipMemcpyDeviceToHost);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipMemcpy failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    // 验证结果
    for (int i = 0; i < N; i++) {
        if (out[i] != a[i] + b[i]) {
            std::cerr << "结果验证失败，索引 " << i << ", " << out[i] << " != " << a[i] + b[i] << std::endl;
            break;
        }
    }

    // 释放内存
    err = hipFree(d_a); 
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipFree failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    err = hipFree(d_b); 
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipFree failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    err = hipFree(d_out);
    if (err != hipSuccess) {
        // 处理错误，比如打印错误信息并退出程序  
        fprintf(stderr, "hipFree failed: %s\n", hipGetErrorString(err));  
        exit(EXIT_FAILURE);  
    }

    free(a); free(b); free(out);

    return 0;
}

接下来可以使用 hipcc 编译器来编译上述程序。hipcc 是一个包装好的编译器，用于将HIP源码编译为可以在准备好的AMD平台上运行的代码：

hipcc vector_add.cpp -o vector_add

编译成功后，可以运行生成的应用程序：

./vector_add

以上代码演示了如何使用HIP编写一个简单的GPU内核，其计算两个向量的逐元素加法。请确保在运行任何这些步骤之前，检查环境是否配置正确，ROCm是否与AMD GPU兼容，并且已正确安装。如果对ROCm更复杂的使用场景感兴趣，可以查看ROCm提供的示例和使用指南。

二、通义灵码

ROCm（Radeon Open Compute Platform）提供了HIP（Heterogeneous-Compute Interface for Portability）API，允许开发者编写高度可移植的代码，能够在AMD GPU和其他异构平台上运行。以下是一个使用HIP API编写的简单向量加法程序示例：

#include <hip/hip_runtime.h>
#include <iostream>

#define VECTOR_SIZE 1024  // 向量长度

// 定义向量加法的内核函数
__global__ void vectorAdd(float* A, float* B, float* C) {
    int idx = threadIdx.x + blockIdx.x * blockDim.x;
    if (idx < VECTOR_SIZE) {
        C[idx] = A[idx] + B[idx];
    }
}

int main() {
    float* h_A;  // 主机侧向量A
    float* h_B;  // 主机侧向量B
    float* h_C;  // 主机侧结果向量C（用于验证）

    float* d_A;  // 设备侧向量A
    float* d_B;  // 设备侧向量B
    float* d_C;  // 设备侧结果向量C

    size_t size = VECTOR_SIZE * sizeof(float);

    // 分配主机内存并初始化向量
    h_A = new float[VECTOR_SIZE];
    h_B = new float[VECTOR_SIZE];
    h_C = new float[VECTOR_SIZE];

    for (size_t i = 0; i < VECTOR_SIZE; ++i) {
        h_A[i] = static_cast<float>(i);
        h_B[i] = static_cast<float>(i * 2);
    }

    // 分配设备内存
    hipMalloc(&d_A, size);
    hipMalloc(&d_B, size);
    hipMalloc(&d_C, size);

    // 将主机内存数据复制到设备
    hipMemcpy(d_A, h_A, size, hipMemcpyHostToDevice);
    hipMemcpy(d_B, h_B, size, hipMemcpyHostToDevice);

    // 定义并启动内核
    dim3 blockSize(256);  // 每块256个线程
    dim3 gridSize((VECTOR_SIZE + blockSize.x - 1) / blockSize.x);  // 计算所需网格数
    vectorAdd<<<gridSize, blockSize>>>(d_A, d_B, d_C);

    // 将设备计算结果复制回主机
    hipMemcpy(h_C, d_C, size, hipMemcpyDeviceToHost);

    // 验证结果
    bool resultCorrect = true;
    for (size_t i = 0; i < VECTOR_SIZE; ++i) {
        if (h_C[i] != h_A[i] + h_B[i]) {
            resultCorrect = false;
            break;
        }
    }

    std::cout << "Vector addition test " << (resultCorrect ? "PASSED" : "FAILED") << std::endl;

    // 释放资源
    hipFree(d_A);
    hipFree(d_B);
    hipFree(d_C);
    delete[] h_A;
    delete[] h_B;
    delete[] h_C;

    return 0;
}

三、文心一言

HIP (Heterogeneous-compute Interface for Portability) 是一个用于简化在AMD GPU上编程的接口，它提供了类似于CUDA的编程模型，使得开发者可以更容易地将CUDA代码迁移到HIP上，以在AMD GPU上运行。

下面是一个简单的HIP程序示例，用于执行向量加法。请注意，这个示例假设你已经安装并配置了ROCm和HIP环境。

首先，你需要创建一个HIP源文件（例如，vector_add.hip），并写入以下代码：

#include <hip/hip_runtime.h>  
#include <hip/hip_vector_types.h>  
  
__global__ void vector_add(float* A, float* B, float* C, int N) {  
    int i = hipBlockIdx_x * hipBlockDim_x + hipThreadIdx_x;  
    if (i < N) {  
        C[i] = A[i] + B[i];  
    }  
}  
  
int main(void) {  
    const int N = 1 << 20; // 1M elements  
    const size_t size = N * sizeof(float);  
  
    // Allocate Unified Memory – accessible from CPU or GPU  
    float *A, *B, *C;  
    hipMallocManaged(&A, size);  
    hipMallocManaged(&B, size);  
    hipMallocManaged(&C, size);  
  
    // Initialize data on the host  
    for (int i = 0; i < N; i++) {  
        A[i] = 1.0f;  
        B[i] = 2.0f;  
    }  
  
    // Run kernel on 1M elements on the GPU  
    hipLaunchKernelGGL((vector_add), dim3(N/256, 1, 1), dim3(256, 1, 1), 0, 0, A, B, C, N);  
  
    // Wait for GPU to finish before accessing on host  
    hipDeviceSynchronize();  
  
    // Verify results  
    for (int i = 0; i < N; i++) {  
        if (C[i] != 3.0f) {  
            printf("Error at element %d: %f != 3.0f\n", i, C[i]);  
            return -1;  
        }  
    }  
  
    printf("Test PASSED\n");  
  
    // Free memory  
    hipFree(A);  
    hipFree(B);  
    hipFree(C);  
  
    return 0;  
}

在这个示例中，vector_add 是一个GPU内核函数，用于执行向量加法。main 函数中首先分配了统一内存（Unified Memory），这是一种HIP和ROCm支持的特性，允许CPU和GPU无缝地访问同一块内存区域。然后，初始化数据并调用HIP内核。最后，验证结果并释放内存。

编译这个程序，你需要使用hipcc编译器，它是专门为HIP设计的。编译命令可能类似于：

hipcc -o vector_add vector_add.hip

确保你的环境变量和路径已经配置好，以便hipcc可以找到ROCm和HIP相关的库和头文件。

运行编译后的程序：

./vector_add

如果一切正常，你应该会看到“Test PASSED”的输出，表示向量加法已经成功执行。

请注意，HIP和ROCm的API和功能可能会随着版本的更新而发生变化，因此请确保查阅最新的官方文档以获取最准确的信息。

四、讯飞星火

以下是一个使用ROCm的HIP API进行向量加法的程序示例：

#include <iostream>
#include <vector>
#include <hip/hip_runtime.h>

__global__ void vectorAdd(const float* A, const float* B, float* C, int numElements) {
    int i = blockDim.x * blockIdx.x + threadIdx.x;
    if (i < numElements) {
        C[i] = A[i] + B[i];
    }
}

int main() {
    int numElements = 50000;
    size_t size = numElements * sizeof(float);

    float* h_A = new float[numElements];
    float* h_B = new float[numElements];
    float* h_C = new float[numElements];

    for (int i = 0; i < numElements; ++i) {
        h_A[i] = static_cast<float>(i);
        h_B[i] = static_cast<float>(i * 2);
    }

    float* d_A = nullptr;
    float* d_B = nullptr;
    float* d_C = nullptr;

    hipMalloc((void**)&d_A, size);
    hipMalloc((void**)&d_B, size);
    hipMalloc((void**)&d_C, size);

    hipMemcpy(d_A, h_A, size, hipMemcpyHostToDevice);
    hipMemcpy(d_B, h_B, size, hipMemcpyHostToDevice);

    dim3 dimBlock(256);
    dim3 dimGrid((numElements + dimBlock.x - 1) / dimBlock.x);

    hipLaunchKernelGGL(vectorAdd, dimGrid, dimBlock, 0, 0, d_A, d_B, d_C, numElements);

    hipMemcpy(h_C, d_C, size, hipMemcpyDeviceToHost);

    for (int i = 0; i < numElements; ++i) {
        if (fabs(h_A[i] + h_B[i] - h_C[i]) > 1e-5) {
            std::cout << "Result verification failed at element " << i << std::endl;
            break;
        }
    }

    delete[] h_A;
    delete[] h_B;
    delete[] h_C;

    hipFree(d_A);
    hipFree(d_B);
    hipFree(d_C);

    return 0;
}

这个程序首先创建了三个大小为`numElements`的浮点数数组`h_A`、`h_B`和`h_C`，并将`h_A`和`h_B`的元素分别设置为连续的整数。然后，它使用HIP API分配设备内存并将主机数据复制到设备上。接下来，它定义了一个名为`vectorAdd`的CUDA内核函数，该函数将两个输入向量相加并将结果存储在输出向量中。最后，它将计算结果从设备复制回主机，并验证结果的正确性。如果结果验证失败，则输出错误信息。最后，它释放了所有分配的内存。

五、Kimi

ROCm（Radeon Open Compute）是一个开源的计算平台，旨在为AMD GPU提供高性能的计算能力。HIP（Heterogeneous-compute Interface for Portability）是ROCm的一个C/C++运行时API，它允许开发者编写可在多种计算设备上运行的代码，包括CPU和GPU。
下面是一个使用ROCm的HIP API实现的简单向量加法程序示例。这个程序将创建两个向量，将它们相加，并输出结果。

#include <hip/hip_runtime.h>
#include <iostream>

__global__ void vectorAdd(const float *A, const float *B, float *C, int N) {
    int i = hipBlockIdx.x * hipBlockDim.x + hipThreadIdx.x;
    if (i < N) {
        C[i] = A[i] + B[i];
    }
}

int main() {
    int N = 1 << 10; // 向量大小
    size_t size = N * sizeof(float);

    float *h_A, *h_B, *h_C;
    float *d_A, *d_B, *d_C;

    // 分配主机内存
    h_A = new float[N];
    h_B = new float[N];
    h_C = new float[N];

    // 初始化主机向量
    for (int i = 0; i < N; i++) {
        h_A[i] = i;
        h_B[i] = i * 2;
    }

    // 分配设备内存
    hipMalloc((void **)&d_A, size);
    hipMalloc((void **)&d_B, size);
    hipMalloc((void **)&d_C, size);

    // 将主机向量复制到设备
    hipMemcpy(d_A, h_A, size, hipMemcpyHostToDevice);
    hipMemcpy(d_B, h_B, size, hipMemcpyHostToDevice);

    // 启动核函数
    hipLaunchKernelGGL(vectorAdd, dim3((N + 255) / 256), dim3(256), 0, 0, d_A, d_B, d_C, N);

    // 将结果从设备复制回主机
    hipMemcpy(h_C, d_C, size, hipMemcpyDeviceToHost);

    // 验证结果
    for (int i = 0; i < N; i++) {
        if (h_C[i] != (h_A[i] + h_B[i])) {
            std::cout << "Error: C[" << i << "] != A[" << i << "] + B[" << i << "]" << std::endl;
            break;
        }
    }

    // 释放设备内存
    hipFree(d_A);
    hipFree(d_B);
    hipFree(d_C);

    // 释放主机内存
    delete[] h_A;
    delete[] h_B;
    delete[] h_C;

    return 0;
}

在这个程序中，我们首先定义了一个名为`vectorAdd`的核函数，它将在GPU上执行。然后在`main`函数中，我们分配了主机和设备的内存，初始化了两个向量，并将它们复制到设备内存中。
接下来，我们调用`hipLaunchKernelGGL`函数来启动核函数。核函数执行后，我们将结果从设备内存复制回主机内存，并验证结果是否正确。
最后，我们释放了所有分配的内存资源。

要编译和运行这个程序，你需要安装ROCm软件平台，并使用`hipcc`编译器。例如，你可以使用以下命令来编译这个程序：

hipcc -o vector_add vector_add.cu
./vector_add

请注意，这个程序是一个基本的示例，实际使用时可能需要根据具体情况进行调整。此外，为了提高性能，你可能需要调整线程块大小和网格大小等参数。

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

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

相关文章

广佛站点导航助手小程序产品使用说明书

广佛站点导航助手小程序产品使用说明书

一、产品简介 广佛站点导航助手小程序是一款专为广佛地区用户设计的地铁导航工具。通过获取用户的实时位置信息&#xff0c;小程序能够迅速定位并展示离用户最近的三个地铁站点。用户可以通过本小程序轻松查找地铁站点&#xff0c;规划出行路线&#xff0c;提高出行效率。 二、…
阅读更多...
SDK-0.7.8-Release-实体管理 - ApiHug-Release

SDK-0.7.8-Release-实体管理 - ApiHug-Release

&#x1f917; ApiHug {Postman|Swagger|Api...} 快↑ 准√ 省↓ GitHub - apihug/apihug.com: All abou the Apihug apihug.com: 有爱&#xff0c;有温度&#xff0c;有质量&#xff0c;有信任ApiHug - API design Copilot - IntelliJ IDEs Plugin | Marketplace 更多精彩…
阅读更多...
Linux：环境基础开发工具使用

Linux：环境基础开发工具使用

文章目录 前言1.Linux下的软件安装1.1 什么是软件包1.2 如何安装软件1.3 如何卸载软件 2.vim2.1 vim的基本概念2.2 vim的基本操作2.3 vim正常模式命令集2.4 vim末行模式命令集2.5 vim的操作总结 3.Linux下的编译器&#xff1a;gcc3.1 gcc的使用3.2 gcc是如何工作的3.2.1 预处理…
阅读更多...
Micromamba 安装与使用

Micromamba 安装与使用

文章目录 一、安装 MicromambaWindows安装使用 Micromamba 一、安装 Micromamba Micromamba 是一个静态链接的 C 可执行文件&#xff0c;在 Windows 上就是一个 micromamba.exe 文件&#xff0c;下载下来就直接可以用&#xff0c;甚至都不需要专门安装。唯一需要做的就是设置 …
阅读更多...
Python编程的十大好用工具！

Python编程的十大好用工具！

Python一直以来都是程序员们的首选编程语言之一&#xff0c;其灵活性和功能强大的库使其成为解决各种问题的理想选择。在本文中&#xff0c;我们将介绍Python编程的终极十大工具&#xff0c;这些工具可以帮助您在各种领域取得成功&#xff0c;无论您是初学者还是经验丰富的开发…
阅读更多...
python数据分析学什么东西

python数据分析学什么东西

前言 大家好&#xff0c;小编为大家解答python数据分析重点要学什么的问题。很多人还不知道python数据分析需要什么基础&#xff0c;现在让我们一起来看看吧&#xff01; 数据分析人人都有必要掌握一点&#xff0c;哪怕只是思维也行。下面探讨Python数据分析需要学习的知识范…
阅读更多...
JavaScript-2.对话框、函数、数组、Date、DOM

JavaScript-2.对话框、函数、数组、Date、DOM

对话框 window对象封装了三个对话框用于与用户交互 提示框&#xff1a;alert(title);确认框&#xff1a;confirm(title);输入框&#xff1a;prompt(title); 确认框 包含两个按钮“确认”/“取消”&#xff0c;点击确定时&#xff0c;返回值为true // 确认框 var bool con…
阅读更多...
微服务项目——谷粒商城

微服务项目——谷粒商城

文章目录 一、项目简介&#xff08;一&#xff09;完整的微服务架构详细解释——微服务划分图&#xff08;二&#xff09;电商模式1.B2B 模式2.B2C 模式3.C2B 模式4.C2C 模式5.o2o 模式2.谷粒商城 &#xff08;三&#xff09;项目技术&特色&#xff08;四&#xff09;项目前…
阅读更多...
Transformer 结构浅析

Transformer 结构浅析

Transformer 结构浅析 文章目录 Transformer 结构浅析Transformer 网络结构编码器位置编码多头注意力层Add&NormFeed Forward 解码器带掩码的多头注意力层多头注意力层 预测 Transformer 网络结构 Transformer模型的网络结构如图&#xff0c;且transformer结构主要分为两部…
阅读更多...
Linux使用docker安装RocketMQ并登录管理界面

Linux使用docker安装RocketMQ并登录管理界面

Linux使用docker安装RocketMQ并登录管理界面 1、创建 /opt/rocketmq/docker-compose.yml和/opt/rocketmq/broker.conf两个配置文件 2、docker-compose.yml&#xff0c;并配置管理页面端口为8090 version: 3.5 services:rmqnamesrv:image: foxiswho/rocketmq:servercontainer_…
阅读更多...
“栈”顶到底是高地址还是低地址？

“栈”顶到底是高地址还是低地址？

栈的增长方向永远是从杯底到杯顶&#xff0c;所以对于栈来说上面是栈底下面是栈顶&#xff0c;而对于堆来说&#xff0c;上面是堆顶下面是堆底。栈是连续分配内存的&#xff0c;如果给一个数组或对象分配内存&#xff0c;栈会选择还没分配的最小的内存地址给数组&#xff0c;在…
阅读更多...
20240327-1-评测指标面试题

20240327-1-评测指标面试题

评测指标面试题 metric主要用来评测机器学习模型的好坏程度,不同的任务应该选择不同的评价指标,分类,回归和排序问题应该选择不同的评价函数. 不同的问题应该不同对待,即使都是分类问题也不应该唯评价函数论,不同问题不同分析. 回归(Regression) 平均绝对误差(MAE) 平均绝对…
阅读更多...
Android 车载应用开发概述

Android 车载应用开发概述

前言 介绍 Android 车载应用开发 文章目录 前言一、Android Automotive OS 概述二、Android Automotive OS 架构三、常见的车载应用1、系统应用1&#xff09;SystemUI是什么开发工作 2&#xff09;Launcher是什么开发工作 3&#xff09;Settings是什么开发工作 4&#xff09;多…
阅读更多...
使用UDP实现TCP的功能，会带来什么好处？

使用UDP实现TCP的功能，会带来什么好处？

比较孤陋寡闻&#xff0c;只知道QUIC TCPQUIC握手延迟TCP需要三次握手TLS握手三次握手TLS握手放在一起&#xff0c;实现0RTT头阻塞问题TCP丢失保文&#xff0c;会影响所有的应用数据包基于UDP封装传输层Stream&#xff0c;Stream内部保序&#xff0c;Stream之间不存在相互影响…
阅读更多...
实时智能应答3D数字人搭建2

实时智能应答3D数字人搭建2

先看效果&#xff1a; 3d数字人讲黑洞 根据艾媒咨询数据&#xff0c;2021年&#xff0c;中国虚拟人核心产业规模达到62.2亿元&#xff0c;带动市场规模达到1074.9亿元&#xff1b;2025年&#xff0c;这一数据预计将达到480.6亿元与6402.7亿元&#xff0c;同比增长迅猛。数字人可…
阅读更多...
C语言：指针详解（1）

C语言：指针详解（1）

目录 一、内存和地址 1.内存 2.究竟该如何理解编址 二、指针变量和地址 1.取地址操作符(&) 2.解引用操作符(*) 3.指针变量的大小 三、指针变量类型的意义 1.指针的解引用 2.指针-整数 3.void*指针 四、const修饰指针 1.const修饰变量 2.const修饰指针变量 五…
阅读更多...
C语言 | Leetcode C语言题解之第19题删除链表的倒数第N个结点

C语言 | Leetcode C语言题解之第19题删除链表的倒数第N个结点

题目&#xff1a; 题解&#xff1a; struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {struct ListNode* dummy malloc(sizeof(struct ListNode));dummy->val 0, dummy->next head;struct ListNode* first head;struct ListNode* second dummy;f…
阅读更多...
CSS核心样式-02-盒模型属性及扩展应用

CSS核心样式-02-盒模型属性及扩展应用

目录 三、盒模型属性 常见盒模型区域 盒模型图 盒模型五大属性 1. 宽度 width 2. 高度 height 3. 内边距 padding 四值法 三值法 二值法 单值法 案例 4. 边框 border 按照属性值的类型划分为三个单一属性 ①线宽 border-width ②线型 border-style ③边框颜色 bo…
阅读更多...
网页端HTML使用MQTTJs订阅RabbitＭＱ数据

网页端HTML使用MQTTJs订阅RabbitＭＱ数据

最近在做一个公司的日志组件时有一个问题难住了我。今天问题终于解决了。由于在解决问题中&#xff0c;在网上也查了很多资料都没有一个完整的实例可以参考。所以本着无私分享的目的记录一下完整的解决过程和实例。 需求&#xff1a;做一个统一日志系统可以查看日志列表和一个可…
阅读更多...
数据——关键生产要素

数据——关键生产要素

数据作为数字经济时代的关键生产要素&#xff0c;逐步融入生产生活各方面&#xff0c;深刻影响并重构着经济社会运行和社会治理&#xff0c;已成为影响未来发展的关键战略性资源。近年来&#xff0c;我国高度重视发展数字经济、数据要素及其市场化配置改革&#xff0c;发布了一…
阅读更多...
最新文章

Copyright @ 2022~2023