用cublas实现行优先矩阵乘法和列优先矩阵乘法

最新推荐文章于 2023-09-01 00:52:59 发布
最新推荐文章于 2023-09-01 00:52:59 发布
阅读量2.7k 收藏 5
点赞数 4
分类专栏： GPU
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25147897/article/details/70806487
版权

引用：http://www.cnblogs.com/scut-fm/p/3756242.html
cublas库是CUDA标准的线代库，但没有专门针对稀疏矩阵的操作。
其中cublasSgemm实现C=α*A*B+β*C功能
函数原型为 
/* GEMM */
CUBLASAPI cublasStatus_t CUBLASWINAPI cublasSgemm_v2 (cublasHandle_t handle, 
                                                      cublasOperation_t transa,
                                                      cublasOperation_t transb, 
                                                      int m,
                                                      int n,
                                                      int k,
                                                      const float *alpha, /* host or device pointer */  
                                                      const float *A, 
                                                      int lda,
                                                      const float *B,
                                                      int ldb, 
                                                      const float *beta, /* host or device pointer */  
                                                      float *C,
                                                      int ldc);
函数中handle为blas库对象
transa 为矩阵A属性参数
transb 为矩阵B属性参数
M A，C行数，即C的高
N B，C列数，即C的宽
K A的列数和B的行数
alpha 运算式的α的地址
A A在显存中的地址
lda A的主维度，所表达的矩阵的高
B B在显存中的地址
ldb B的主维度，所表达的矩阵的高
beta 运算式的β的地址
C C在显存中的地址
ldc C的主维度，所表达的矩阵的高

若列优先计算矩阵乘法
|1 0| * |2 0 3| = |2 0 3|
        |1 1 0|
A     * B       = C
则*alpha=1.0，*β=0.0
列存储形式：
A={1,0}表示矩阵，矩阵宽2，高1
1 0
B={2,1,0,1,3,0}，矩阵宽3，高2
2 0 3
1 1 0
C={2,0,3}，矩阵宽3，高1
2 0 3
ABC均按列存储，所以AB属性设置为CUBLAS_OP_N，得到的C矩阵也是按列存储
MNK分别为1,3,2
lda，ldb，ldc分别为三个矩阵的高，即1,2,1
全部代码如下 
// CUDA runtime 库 + CUBLAS 库
#include "cuda_runtime.h"
#include "cuda_runtime_api.h"
#include "cublas_v2.h"

#include <time.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MyTimer.h"
//本代码实现了cublas的列存储矩阵乘法
//#include <common_functions.h>
/*
|1 0| * |2 0 3| = |2 0 3|
        |1 1 0|
A     * B       = C
cublasSgemm 实现的功能为C = alpha*A*B + beta*C
ABC均为列存储
*/
using namespace std;

// 定义测试矩阵的维度
int const aW = 2;
int const aH = 1;
int const bW = 3;
int const bH = 2;
int const cW = bW;
int const cH = aH;

int main()
{
    // 定义状态变量
    cublasStatus_t status;

    // 在 内存 中为将要计算的矩阵开辟空间
    float *h_A = (float*)malloc (aW*aH*sizeof(float));
    float *h_B = (float*)malloc (bW*bH*sizeof(float));

    // 在 内存 中为将要存放运算结果的矩阵开辟空间
    float *h_C = (float*)malloc (cW*cH*sizeof(float));

    // 为待运算矩阵的元素赋值
    h_A[0]=1; h_A[1]=0;
    h_B[0]=2; h_B[1]=1; h_B[2]=0; h_B[3]=1; h_B[4]=3; h_B[5]=0;

    // 打印待测试的矩阵
    cout << "矩阵 A :" << endl;
    for (int i=0; i<aW*aH; i++){
        cout << h_A[i] << " ";
        if ((i+1)%aW == 0) cout << endl;
    }
    cout << endl;
    cout << "矩阵 B :" << endl;//按照行优先打印的，不正确
    for (int i=0; i<bW*bH; i++){
        cout << h_B[i] << " ";
        if ((i+1)%bW == 0) cout << endl;
    }
    cout << endl;

    /*
    ** GPU 计算矩阵相乘
    */

    // 创建并初始化 CUBLAS 库对象
    cublasHandle_t handle;
    status = cublasCreate(&handle);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        if (status == CUBLAS_STATUS_NOT_INITIALIZED) {
            cout << "CUBLAS 对象实例化出错" << endl;
        }
        getchar ();
        return EXIT_FAILURE;
    }

    float *d_A, *d_B, *d_C;
    // 在 显存 中为将要计算的矩阵开辟空间
    cudaMalloc (
        (void**)&d_A,    // 指向开辟的空间的指针
        aW*aH * sizeof(float)    //　需要开辟空间的字节数
    );
    cudaMalloc (
        (void**)&d_B,
        bW*bH * sizeof(float)
    );

    // 在 显存 中为将要存放运算结果的矩阵开辟空间
    cudaMalloc (
        (void**)&d_C,
        cW*cH * sizeof(float)
    );

    // 将矩阵数据传递进 显存 中已经开辟好了的空间
    cublasSetVector (
        aW*aH,    // 要存入显存的元素个数
        sizeof(float),    // 每个元素大小
        h_A,    // 主机端起始地址
        1,    // 连续元素之间的存储间隔
        d_A,    // GPU 端起始地址
        1    // 连续元素之间的存储间隔
    );
    cublasSetVector (
        bW*bH,
        sizeof(float),
        h_B,
        1,
        d_B,
        1
    );

    // 同步函数
    cudaThreadSynchronize();

    Timer myTimer;
    myTimer.start();
    // 传递进矩阵相乘函数中的参数，具体含义请参考函数手册。
    float a=1; float b=0;
    // 矩阵相乘。该函数必然将数组解析成列优先数组
    cublasSgemm (
        handle,    // blas 库对象
        CUBLAS_OP_N,    // 矩阵 A 属性参数
        CUBLAS_OP_N,    // 矩阵 B 属性参数
        cH,    // A, C 的行数
        cW,    // B, C 的列数
        aW,    // A 的列数和 B 的行数
        &a,    // 运算式的 α 值
        d_A,    // A 在显存中的地址
        aH,    // lda
        d_B,    // B 在显存中的地址
        bH,    // ldb
        &b,    // 运算式的 β 值
        d_C,    // C 在显存中的地址(结果矩阵)
        cH    // ldc
    );
    // 同步函数
    cudaThreadSynchronize();
    myTimer.stop();
    printf("use: %lf\n", myTimer.getElapsedTime());

    // 从 显存 中取出运算结果至 内存中去
    cublasGetVector (
        cW*cH,    //  要取出元素的个数
        sizeof(float),    // 每个元素大小
        d_C,    // GPU 端起始地址
        1,    // 连续元素之间的存储间隔
        h_C,    // 主机端起始地址
        1    // 连续元素之间的存储间隔
    );

    // 打印运算结果
    cout << "计算结果的转置 ( (A*B)的转置 )：" << endl;

    for (int i=0;i<cW*cH; i++){
            cout << h_C[i] << " ";
            if ((i+1)%cW == 0) cout << endl;
    }

    // 清理掉使用过的内存
    free (h_A);
    free (h_B);
    free (h_C);
    cudaFree (d_A);
    cudaFree (d_B);
    cudaFree (d_C);

    // 释放 CUBLAS 库对象
    cublasDestroy (handle);

    getchar();

    return 0;
}
C语言中行优先是更加习惯的使用，因此，在介绍下使用cublas实现行优先矩阵乘法的方法
C=A*B则C'=B'*A'
行存储形式：
A={1,0}表示矩阵，矩阵宽2，高1
1 0
B={2,0,3,1,1,0}，矩阵宽3，高2
2 0 3
1 1 0
C={2,0,3}，矩阵宽3，高1
2 0 3
ABC均按行存储
我们设置AB属性为CUBLAS_OP_N，cublas将AB按照列优先解析，并将A按宽1高2，B按宽2高3，C按宽1高3的方式设置。
则cublas认为B是
2 1
0 1
3 0
即B的转置，AC同理
那么计算C=A*B时，我们按照上面设置将参数传入cublasSgemm函数，得到的即为C'=B'*A'即实现了行优先存储乘法（行优先和列优先在计算时，输入输出矩阵数据分别按照行优先和列优先给出，赋值时宽高不必做转换，该是什么就是什么，但
cublasSgemm函数中的宽高需要改成其转置，A和B也要互换，具体看代码）
行优先存储全部代码如下 
/*
 * cublasLearn.cpp
 *
 *  Created on: 2017年4月6日
 *      Author: wjt
 */

// CUDA runtime 库 + CUBLAS 库
#include "cuda_runtime.h"
#include "cuda_runtime_api.h"
#include "cublas_v2.h"

#include <time.h>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "MyTimer.h"
//本代码实现了cublas的行存储矩阵乘法
//#include <common_functions.h>
/*
|1 0| * |2 0 3| = |2 0 3|
        |1 1 0|
A     * B       = C
cublasSgemm 实现的功能为C = alpha*A*B + beta*C
ABC均为列存储
*/
using namespace std;

// 定义测试矩阵的维度
int const aW = 2;
int const aH = 1;
int const bW = 3;
int const bH = 2;
int const cW = bW;
int const cH = aH;

int main()
{
    // 定义状态变量
    cublasStatus_t status;

    // 在 内存 中为将要计算的矩阵开辟空间
    float *h_A = (float*)malloc (aW*aH*sizeof(float));
    float *h_B = (float*)malloc (bW*bH*sizeof(float));

    // 在 内存 中为将要存放运算结果的矩阵开辟空间
    float *h_C = (float*)malloc (cW*cH*sizeof(float));

    // 为待运算矩阵的元素赋值
    h_A[0]=1; h_A[1]=0;
    h_B[0]=2; h_B[1]=0; h_B[2]=3; h_B[3]=1; h_B[4]=1; h_B[5]=0;

    // 打印待测试的矩阵
    cout << "矩阵 A :" << endl;
    for (int i=0; i<aW*aH; i++){
        cout << h_A[i] << " ";
        if ((i+1)%aW == 0) cout << endl;
    }
    cout << endl;
    cout << "矩阵 B :" << endl;
    for (int i=0; i<bW*bH; i++){
        cout << h_B[i] << " ";
        if ((i+1)%bW == 0) cout << endl;
    }
    cout << endl;

    /*
    ** GPU 计算矩阵相乘
    */

    // 创建并初始化 CUBLAS 库对象
    cublasHandle_t handle;
    status = cublasCreate(&handle);

    if (status != CUBLAS_STATUS_SUCCESS)
    {
        if (status == CUBLAS_STATUS_NOT_INITIALIZED) {
            cout << "CUBLAS 对象实例化出错" << endl;
        }
        getchar ();
        return EXIT_FAILURE;
    }

    float *d_A, *d_B, *d_C;
    // 在 显存 中为将要计算的矩阵开辟空间
    cudaMalloc (
        (void**)&d_A,    // 指向开辟的空间的指针
        aW*aH * sizeof(float)    //　需要开辟空间的字节数
    );
    cudaMalloc (
        (void**)&d_B,
        bW*bH * sizeof(float)
    );

    // 在 显存 中为将要存放运算结果的矩阵开辟空间
    cudaMalloc (
        (void**)&d_C,
        cW*cH * sizeof(float)
    );

    // 将矩阵数据传递进 显存 中已经开辟好了的空间
    cublasSetVector (
        aW*aH,    // 要存入显存的元素个数
        sizeof(float),    // 每个元素大小
        h_A,    // 主机端起始地址
        1,    // 连续元素之间的存储间隔
        d_A,    // GPU 端起始地址
        1    // 连续元素之间的存储间隔
    );
    cublasSetVector (
        bW*bH,
        sizeof(float),
        h_B,
        1,
        d_B,
        1
    );

    // 同步函数
    cudaThreadSynchronize();

    Timer myTimer;
    myTimer.start();
    // 传递进矩阵相乘函数中的参数，具体含义请参考函数手册。
    float a=1; float b=0;
    // 矩阵相乘。该函数必然将数组解析成列优先数组
    cublasSgemm (
        handle,    // blas 库对象
        CUBLAS_OP_N,    // 矩阵 A 属性参数
        CUBLAS_OP_N,    // 矩阵 B 属性参数
        bW,    // A, C 的行数
        aH,    // B, C 的列数
        bH,    // A 的列数和 B 的行数
        &a,    // 运算式的 α 值
        d_B,    // A 在显存中的地址
        bW,    // lda
        d_A,    // B 在显存中的地址
        aW,    // ldb
        &b,    // 运算式的 β 值
        d_C,    // C 在显存中的地址(结果矩阵)
        cW    // ldc
    );
    // 同步函数
    cudaThreadSynchronize();
    myTimer.stop();
    printf("use: %lf\n", myTimer.getElapsedTime());

    // 从 显存 中取出运算结果至 内存中去
    cublasGetVector (
        cW*cH,    //  要取出元素的个数
        sizeof(float),    // 每个元素大小
        d_C,    // GPU 端起始地址
        1,    // 连续元素之间的存储间隔
        h_C,    // 主机端起始地址
        1    // 连续元素之间的存储间隔
    );

    // 打印运算结果
    cout << "计算结果的转置 ( (A*B)的转置 )：" << endl;

    for (int i=0;i<cW*cH; i++){
            cout << h_C[i] << " ";
            if ((i+1)%cW == 0) cout << endl;
    }

    // 清理掉使用过的内存
    free (h_A);
    free (h_B);
    free (h_C);
    cudaFree (d_A);
    cudaFree (d_B);
    cudaFree (d_C);

    // 释放 CUBLAS 库对象
    cublasDestroy (handle);

    getchar();

    return 0;
}


lalalala256
关注
专栏目录
cublas,tensorcore矩阵乘法基本介绍
forrestguang的博客
11-14 476
CαopAopBβCCαopAopB))βC，这里的运算符op决定是否转置。这里首先说明，cublasSgemm专门处理float类型的二维矩阵乘法，针对其他类型的矩阵，cublas有类似的函数接口cublasDgemm：处理double类型矩阵cublasCgemm：处理cuComplex类型矩阵cublasZgemm：处理cuDoubleComplex类型矩阵cublasHgemm：处理__half类型的矩阵。
C++矩阵乘法计算 || GPU && CPU 实现
春江水暖鸭先知
09-03 5288
废话 使用英伟达加速矩阵运算一般使用cublas库进行操作，在cublas库中，使用cublasSgemv()和cublasSgemm()分别进行矩阵向量间的乘法运算与矩阵矩阵间的乘法运算。本文将具体的解释上述两个函数的参数以及具体的应用例子。参照官方解释 矩阵乘法函数解释 仅仅使用单精度(float)进行解释，若想尝试双精度(double),可以进入官网查看相应函数. ...
使用cublas实现矩阵乘法
davidhopper的博客
03-16 1918
里面解释得非常直观详细。我刚开始没搞清楚这个差异，结果始终不对，还以为数据复制出了问题，直到查到这篇博客后才豁然开朗。），当然可以自己写核函数，但效率不如CUDA自带的。设备（device）代码包含调试信息，主机（host）代码包含调试信息，请大家熟悉C++的编码方式。使用CUDA写一个矩阵乘法。，在GPU中实际计算的是。唯一值得注意的地方是，因此，在CPU中计算。，而不是使用C语言函数。使用C++17标准。
利用cuda的cublas库实现任意矩阵的乘法
怀梦远航的专栏
05-20 5672
使用cublas库的相关函数做矩阵乘法时，应当注意两点：一是cublas的中数据时按里存储的，二是，要注意矩阵是在GPU端产生的还是CPU端产生的。 在cublas库中，实现矩阵的乘法有有以上两个函数，分别完成单精度和双精度的矩阵乘法运算。完成的是以下运算（具体可以参看SDK文档） 特别小心：ld(leading dimension)的意思，对于矩阵在由cublas的随
【代码分析】cublasSgemm 矩阵乘法详解
HaoBBNuanMM的博客
11-13 4125
目录 前言 预备知识 cublasSgemm 函数 求解C=AxB 不使用cublasSgemmtransa与transb参数 示例程序 使用cublasSgemmtransa与transb参数 示例程序 前言 cublasSgemm是NVcublas库的矩阵相乘API，由于cublas中矩阵的存储是列优先，所以cublasSgemm API的参数让新手一头雾水，经...
cublas_学习笔记2
courage的专栏
03-14 5478
由于cublas为了更大的适应Fortan语言，二维数据的存储采用以列优先的方式，这与C/C++中，行优先的存储方式不同。由于本人的研究是数据的来源是C代码得到的，为了加速矩阵的运算效率，利用cublas来完成。本文档提出了一种有效的解决方案。 为了更好的说明，以函数cublasSgemm的实现C= A*B为例。接口cublasSgemm 实现的功能为C = alpha*A*B + b
CUDAArray的数据存储顺序
轩令的技术博客
08-10 1134
cuda数据排序方式
CUBLAS是用于在GPU进行高性能线性代数计算的函数库，提供了矩阵和向量操作函数，例如矩阵相乘、向量相乘等
02-18
丰富的功能：CUBLAS库包含了完整的BLAS（Basic Linear Algebra Subroutines）函数集，可以进行各种线性代数运算，如矩阵乘法、向量运算等。 易于使用：CUBLAS库提供了友好的API接口，使得用户可以方便地调用库中的...
用gpu进行矩阵乘法
最新发布
08-08
3. **优化的数据布局**：为了减少内存访问（称为“纹理绑定”），GPU需要矩阵按特定的顺序存储，例如Row-major（行优先）或Column-major（列优先），这取决于硬件支持和优化库的选择。 4. **矩阵分解和分块**：大...
cuda 矩阵乘法函数之cublasSgemm
u011460059的博客
02-22 5005
在使用CUDA的cuBLAS库中矩阵乘法函数cublasSgemm时，注意到cuda其中的二维矩阵的储存是“**按列储存**”，一天都处于蒙蔽状态，查了很多资料，按所得结果情况，总结出如下几条。 一、获得按行存储的结果由博文：http://blog.csdn.net/xfortius/article/details/9225799收到启发：比如，我们想求C=A*B这个矩阵运算，其中A={{1,1},
cublas中执行矩阵乘法运算的函数 首先要注意的是cublas使用的是以列为主的存储方式，和c/c++中的以行为主的方式是不一样的。处理方法可参考下面的注释代码
摄心神，致虚极，守静笃
07-24 1515
cublas中执行矩阵乘法运算的函数 首先要注意的是cublas使用的是以列为主的存储方式，和c/c++中的以行为主的方式是不一样的。处理方法可参考下面的注释代码 cublas中执行矩阵乘法运算的函数 首先要注意的是cublas使用的是以列为主的存储方式，和c/c++中的以行为主的方式是不一样的。处理方法可参考下面的注释代码 // SOME PRECAUTIONS:
CUBLAS变量解释（1）
HPC&Geophysics攻城狮
01-14 782
变量类型：cublasOperation_t  解释：该类型表明输入的密集矩阵的形式，其值有 CUBLAS_OP_N（非转置）;CUBLAS_OP_T（转置）; CUBLAS_OP_C（共轭转置）。该函数对应于BLAS（FORTRAN版）的变量字符'N'或'n'(非转置,即正常形式的矩阵)，T'或't'(转置矩阵);'C'或'c'(共轭转置矩阵，对应的是复数矩阵）。
cuda中用cublas库做矩阵乘法
weixin_33708432的博客
01-12 698
这里矩阵C=A*B，原始文档给的公式是C=alpha*A*B+beta*C，所以这里alpha=1，beta=0。 主要使用cublasSgemm这个函数，这个函数的第二个参数有三种类型，这里CUBLAS_OP_N求出来矩阵结果是按行排列，所以不需要转置了。 如果用CUBLAS_OP_T参数求得的结果是按列排列，做成C形式的矩阵应该还需要转置一下，并且后面跟的参数也不太一样，这个参数我就没再尝...
cublasSgemm处理C中按行存储的矩阵乘法
随风秀舞（diyoosjtu）
11-02 3112
由于cublas为了更大的适应Fortan语言，二维数据的存储采用以列优先的方式，这与C/C++中，行优先的存储方式不同。由于本人的研究是数据的来源是C代码得到的，为了加速矩阵的运算效率，利用cublas来完成。本文档提出了一种有效的解决方案。     为了更好的说明，以函数cublasSgemm的实现C= A*B为例。接口cublasSgemm 实现的功能为C = alpha*A*B + be
CUBLAS库入门教程（从环境配置讲起）
A_water_的博客
09-01 6371
CUBLAS库是NVIDIA CUDA用于线性代数计算的库。使用CUBLAS库的原因是我不想去直接写核函数。（当然，你还是得学习核函数该怎么写。但是人家写好的肯定比我自己写的更准确！)
行优先和列优先
feng__shuai的博客
12-04 2252
千里之行，始于足下，勿在浮沙筑高台。意思就是矩阵按照行优先的顺序排列，直接用图比较好说明，下面是我们纸面上的矩阵。 而实际存在计算机内存上必须是一维的，行优先就是下面这样： 列优先是下面存储方式。 其实二维转一维一定会丢失位置信息，为了能够从一维数据复原到二维，必须要给一些信息： 其实理解这个代码，只要把A,B转置一下就很容易理解了：下图本A, B, C按照正常的排序理解，但是在做值对应的时候很容易晕。 下面这样理解就容易的多：
cublas中的矩阵运算
热门推荐
l691899397的博客
08-17 1万+
Cublas是一个可以与cuda一同使用的函数库，它提供了多种矩阵运算的API，但是它列主序的存储方式却让人十分疑惑，今天我就以cublas中的矩阵乘法运算简单说一下我的理解。 Cublas中的矩阵乘法运算函数有5个，分别是cublasSgemm、cublasDgemm、cublasCgemm、cublasZgemm、cublasHgemm，分别包括了不同数据类型的计算，比如单精度浮点、双精度浮
cublasSgemm函数
12-15 5070
cublasStatus_t cublasSgemm ( cublasHandle_t handle, cublasOperation_t transa, cublasOperation_t transb, int m, int n, int k, const float *alpha, /* host or device pointer */ const float *A, int ld
CUDA: 共享存储器实现矩阵相乘
923723914
10-13 552
共享存储器使用__shared__限定词分配。 　　相关阅读： CUDA编程接口：运行初始化与设备存储器 　　CUDA编程接口：使用nvcc编译器的兼容性 　　CUDA编程接口：如何用nvcc编译CUDA程序 　　CUDA编程模型：存储器层次和异构编程 　　CUDA编程模型：内核与线程层次概述 　　正如在前面的文章提到的，共享存储器应当比全局存储器更快，详细内容将在后续文章中介绍。任何用访问共...
写一段用cublas库进行批处理矩阵乘法的代码
07-10
以下是使用CUBLAS库进行批处理矩阵乘法的示例代码： ```c #include #include #include #include &lt;cublas_v2.h> #define N 3 // 矩阵大小 #define BATCH_SIZE 2 // 批处理大小 void printMatrix(float* matrix,...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值