Sparse generic functions

Sparse generic functions#

This module contains all sparse generic routines.

The sparse generic routines describe operations that manipulate sparse matrices.

hipsparseAxpby()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    // Number of non-zeros of the sparse vector
 4    int nnz = 3;
 5
 6    // Size of sparse and dense vector
 7    int size = 9;
 8
 9    // Sparse index vector
10    std::vector<int> hxInd = {0, 3, 5};
11
12    // Sparse value vector
13    std::vector<float> hxVal = {1.0f, 2.0f, 3.0f};
14
15    // Dense vector
16    std::vector<float> hy = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
17
18    // Scalar alpha
19    float alpha = 3.7f;
20
21    // Scalar beta
22    float beta = 1.2f;
23
24    // Offload data to device
25    int*   dxInd;
26    float* dxVal;
27    float* dy;
28    HIP_CHECK(hipMalloc((void**)&dxInd, sizeof(int) * nnz));
29    HIP_CHECK(hipMalloc((void**)&dxVal, sizeof(float) * nnz));
30    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * size));
31
32    HIP_CHECK(hipMemcpy(dxInd, hxInd.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
33    HIP_CHECK(hipMemcpy(dxVal, hxVal.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
34    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * size, hipMemcpyHostToDevice));
35
36    hipsparseHandle_t handle;
37    HIPSPARSE_CHECK(hipsparseCreate(&handle));
38
39    // Create sparse vector X
40    hipsparseSpVecDescr_t vecX;
41    HIPSPARSE_CHECK(hipsparseCreateSpVec(
42        &vecX, size, nnz, dxInd, dxVal, HIPSPARSE_INDEX_32I, HIPSPARSE_INDEX_BASE_ZERO, HIP_R_32F));
43
44    // Create dense vector Y
45    hipsparseDnVecDescr_t vecY;
46    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, size, dy, HIP_R_32F));
47
48    // Call axpby to perform y = beta * y + alpha * x
49    HIPSPARSE_CHECK(hipsparseAxpby(handle, &alpha, vecX, &beta, vecY));
50
51    HIPSPARSE_CHECK(hipsparseDnVecGetValues(vecY, (void**)&dy));
52
53    // Copy result back to host
54    HIP_CHECK(hipMemcpy(hy.data(), dy, sizeof(float) * size, hipMemcpyDeviceToHost));
55
56    std::cout << "hy" << std::endl;
57    for(size_t i = 0; i < hy.size(); i++)
58    {
59        std::cout << hy[i] << " ";
60    }
61    std::cout << std::endl;
62
63    // Clear hipSPARSE
64    HIPSPARSE_CHECK(hipsparseDestroySpVec(vecX));
65    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
66    HIPSPARSE_CHECK(hipsparseDestroy(handle));
67
68    // Clear device memory
69    HIP_CHECK(hipFree(dxInd));
70    HIP_CHECK(hipFree(dxVal));
71    HIP_CHECK(hipFree(dy));
72
73    return 0;
74}

hipsparseGather()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    // Number of non-zeros of the sparse vector
 4    int nnz = 3;
 5
 6    // Size of sparse and dense vector
 7    int size = 9;
 8
 9    // Sparse index vector
10    std::vector<int> hxInd = {0, 3, 5};
11
12    // Dense vector
13    std::vector<float> hy = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
14
15    // Offload data to device
16    int*   dxInd;
17    float* dxVal;
18    float* dy;
19    HIP_CHECK(hipMalloc((void**)&dxInd, sizeof(int) * nnz));
20    HIP_CHECK(hipMalloc((void**)&dxVal, sizeof(float) * nnz));
21    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * size));
22
23    HIP_CHECK(hipMemcpy(dxInd, hxInd.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
24    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * size, hipMemcpyHostToDevice));
25
26    hipsparseHandle_t handle;
27    HIPSPARSE_CHECK(hipsparseCreate(&handle));
28
29    // Create sparse vector X
30    hipsparseSpVecDescr_t vecX;
31    HIPSPARSE_CHECK(hipsparseCreateSpVec(
32        &vecX, size, nnz, dxInd, dxVal, HIPSPARSE_INDEX_32I, HIPSPARSE_INDEX_BASE_ZERO, HIP_R_32F));
33
34    // Create dense vector Y
35    hipsparseDnVecDescr_t vecY;
36    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, size, dy, HIP_R_32F));
37
38    // Perform gather
39    HIPSPARSE_CHECK(hipsparseGather(handle, vecY, vecX));
40
41    HIPSPARSE_CHECK(hipsparseSpVecGetValues(vecX, (void**)&dxVal));
42
43    // Copy result back to host
44    std::vector<float> hxVal(nnz, 0.0f);
45    HIP_CHECK(hipMemcpy(hxVal.data(), dxVal, sizeof(float) * nnz, hipMemcpyDeviceToHost));
46
47    // Clear hipSPARSE
48    HIPSPARSE_CHECK(hipsparseDestroySpVec(vecX));
49    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
50    HIPSPARSE_CHECK(hipsparseDestroy(handle));
51
52    // Clear device memory
53    HIP_CHECK(hipFree(dxInd));
54    HIP_CHECK(hipFree(dxVal));
55    HIP_CHECK(hipFree(dy));
56
57    return 0;
58}

hipsparseScatter()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    // Number of non-zeros of the sparse vector
 4    int nnz = 3;
 5
 6    // Size of sparse and dense vector
 7    int size = 9;
 8
 9    // Sparse index vector
10    std::vector<int> hxInd = {0, 3, 5};
11
12    // Sparse value vector
13    std::vector<float> hxVal = {1.0f, 2.0f, 3.0f};
14
15    // Dense vector
16    std::vector<float> hy = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
17
18    // Offload data to device
19    int*   dxInd;
20    float* dxVal;
21    float* dy;
22    HIP_CHECK(hipMalloc((void**)&dxInd, sizeof(int) * nnz));
23    HIP_CHECK(hipMalloc((void**)&dxVal, sizeof(float) * nnz));
24    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * size));
25
26    HIP_CHECK(hipMemcpy(dxInd, hxInd.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
27    HIP_CHECK(hipMemcpy(dxVal, hxVal.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
28    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * size, hipMemcpyHostToDevice));
29
30    hipsparseHandle_t handle;
31    HIPSPARSE_CHECK(hipsparseCreate(&handle));
32
33    // Create sparse vector X
34    hipsparseSpVecDescr_t vecX;
35    HIPSPARSE_CHECK(hipsparseCreateSpVec(
36        &vecX, size, nnz, dxInd, dxVal, HIPSPARSE_INDEX_32I, HIPSPARSE_INDEX_BASE_ZERO, HIP_R_32F));
37
38    // Create dense vector Y
39    hipsparseDnVecDescr_t vecY;
40    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, size, dy, HIP_R_32F));
41
42    // Perform scatter
43    HIPSPARSE_CHECK(hipsparseScatter(handle, vecX, vecY));
44
45    HIPSPARSE_CHECK(hipsparseDnVecGetValues(vecY, (void**)&dy));
46
47    // Copy result back to host
48    HIP_CHECK(hipMemcpy(hy.data(), dy, sizeof(float) * size, hipMemcpyDeviceToHost));
49
50    // Clear hipSPARSE
51    HIPSPARSE_CHECK(hipsparseDestroySpVec(vecX));
52    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
53    HIPSPARSE_CHECK(hipsparseDestroy(handle));
54
55    // Clear device memory
56    HIP_CHECK(hipFree(dxInd));
57    HIP_CHECK(hipFree(dxVal));
58    HIP_CHECK(hipFree(dy));
59
60    return 0;
61}

hipsparseRot()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    // Number of non-zeros of the sparse vector
 4    int nnz = 3;
 5
 6    // Size of sparse and dense vector
 7    int size = 9;
 8
 9    // Sparse index vector
10    std::vector<int> hxInd = {0, 3, 5};
11
12    // Sparse value vector
13    std::vector<float> hxVal = {1.0f, 2.0f, 3.0f};
14
15    // Dense vector
16    std::vector<float> hy = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
17
18    // Scalar c
19    float c = 3.7f;
20
21    // Scalar s
22    float s = 1.2f;
23
24    // Offload data to device
25    int*   dxInd;
26    float* dxVal;
27    float* dy;
28    HIP_CHECK(hipMalloc((void**)&dxInd, sizeof(int) * nnz));
29    HIP_CHECK(hipMalloc((void**)&dxVal, sizeof(float) * nnz));
30    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * size));
31
32    HIP_CHECK(hipMemcpy(dxInd, hxInd.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
33    HIP_CHECK(hipMemcpy(dxVal, hxVal.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
34    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * size, hipMemcpyHostToDevice));
35
36    hipsparseHandle_t handle;
37    HIPSPARSE_CHECK(hipsparseCreate(&handle));
38
39    // Create sparse vector X
40    hipsparseSpVecDescr_t vecX;
41    HIPSPARSE_CHECK(hipsparseCreateSpVec(
42        &vecX, size, nnz, dxInd, dxVal, HIPSPARSE_INDEX_32I, HIPSPARSE_INDEX_BASE_ZERO, HIP_R_32F));
43
44    // Create dense vector Y
45    hipsparseDnVecDescr_t vecY;
46    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, size, dy, HIP_R_32F));
47
48    // Call rot
49    HIPSPARSE_CHECK(hipsparseRot(handle, (void*)&c, (void*)&s, vecX, vecY));
50
51    HIPSPARSE_CHECK(hipsparseSpVecGetValues(vecX, (void**)&dxVal));
52    HIPSPARSE_CHECK(hipsparseDnVecGetValues(vecY, (void**)&dy));
53
54    // Copy result back to host
55    HIP_CHECK(hipMemcpy(hxVal.data(), dxVal, sizeof(float) * nnz, hipMemcpyDeviceToHost));
56    HIP_CHECK(hipMemcpy(hy.data(), dy, sizeof(float) * size, hipMemcpyDeviceToHost));
57
58    // Clear hipSPARSE
59    HIPSPARSE_CHECK(hipsparseDestroySpVec(vecX));
60    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
61    HIPSPARSE_CHECK(hipsparseDestroy(handle));
62
63    // Clear device memory
64    HIP_CHECK(hipFree(dxInd));
65    HIP_CHECK(hipFree(dxVal));
66    HIP_CHECK(hipFree(dy));
67
68    return 0;
69}

hipsparseSparseToDense_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSparseToDense()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    //     1 0 0 0
 4    // A = 4 2 0 4
 5    //     0 3 7 0
 6    //     9 0 0 1
 7    int m   = 4;
 8    int n   = 4;
 9    int nnz = 8;
10
11    std::vector<int>   hcsrRowPtrA = {0, 1, 4, 6, 8};
12    std::vector<int>   hcsrColIndA = {0, 0, 1, 3, 1, 2, 0, 3};
13    std::vector<float> hcsrValA    = {1.0f, 4.0f, 2.0f, 4.0f, 3.0f, 7.0f, 9.0f, 1.0f};
14
15    int*   dcsrRowPtrA;
16    int*   dcsrColIndA;
17    float* dcsrValA;
18    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrA, sizeof(int) * (m + 1)));
19    HIP_CHECK(hipMalloc((void**)&dcsrColIndA, sizeof(int) * nnz));
20    HIP_CHECK(hipMalloc((void**)&dcsrValA, sizeof(float) * nnz));
21
22    HIP_CHECK(
23        hipMemcpy(dcsrRowPtrA, hcsrRowPtrA.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
24    HIP_CHECK(hipMemcpy(dcsrColIndA, hcsrColIndA.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
25    HIP_CHECK(hipMemcpy(dcsrValA, hcsrValA.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
26
27    float* ddenseB;
28    HIP_CHECK(hipMalloc((void**)&ddenseB, sizeof(float) * m * n));
29
30    hipsparseHandle_t     handle;
31    hipsparseSpMatDescr_t matA;
32    hipsparseDnMatDescr_t matB;
33
34    HIPSPARSE_CHECK(hipsparseCreate(&handle));
35
36    hipsparseIndexType_t rowIdxTypeA = HIPSPARSE_INDEX_32I;
37    hipsparseIndexType_t colIdxTypeA = HIPSPARSE_INDEX_32I;
38    hipDataType          dataTypeA   = HIP_R_32F;
39    hipsparseIndexBase_t idxBaseA    = HIPSPARSE_INDEX_BASE_ZERO;
40
41    // Create sparse matrix A
42    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
43                                       m,
44                                       n,
45                                       nnz,
46                                       dcsrRowPtrA,
47                                       dcsrColIndA,
48                                       dcsrValA,
49                                       rowIdxTypeA,
50                                       colIdxTypeA,
51                                       idxBaseA,
52                                       dataTypeA));
53
54    // Create dense matrix B
55    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matB, m, n, m, ddenseB, HIP_R_32F, HIPSPARSE_ORDER_COL));
56
57    hipsparseSparseToDenseAlg_t alg = HIPSPARSE_SPARSETODENSE_ALG_DEFAULT;
58
59    size_t bufferSize;
60    HIPSPARSE_CHECK(hipsparseSparseToDense_bufferSize(handle, matA, matB, alg, &bufferSize));
61
62    void* tempBuffer;
63    HIP_CHECK(hipMalloc((void**)&tempBuffer, bufferSize));
64
65    // Complete the conversion
66    HIPSPARSE_CHECK(hipsparseSparseToDense(handle, matA, matB, alg, tempBuffer));
67
68    // Copy result back to host
69    std::vector<float> hdenseB(m * n);
70    HIP_CHECK(hipMemcpy(hdenseB.data(), ddenseB, sizeof(float) * m * n, hipMemcpyDeviceToHost));
71
72    // Clear hipSPARSE
73    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matA));
74    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matB));
75    HIPSPARSE_CHECK(hipsparseDestroy(handle));
76
77    // Clear device memory
78    HIP_CHECK(hipFree(dcsrRowPtrA));
79    HIP_CHECK(hipFree(dcsrColIndA));
80    HIP_CHECK(hipFree(dcsrValA));
81    HIP_CHECK(hipFree(ddenseB));
82    HIP_CHECK(hipFree(tempBuffer));
83
84    return 0;
85}

hipsparseDenseToSparse_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseDenseToSparse_analysis()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseDenseToSparse_convert()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    //     1 0 0 0
  4    // A = 4 2 0 4
  5    //     0 3 7 0
  6    //     9 0 0 1
  7    int m = 4;
  8    int n = 4;
  9
 10    std::vector<float> hdenseA = {1.0f,
 11                                  4.0f,
 12                                  0.0f,
 13                                  9.0f,
 14                                  0.0f,
 15                                  2.0f,
 16                                  3.0f,
 17                                  0.0f,
 18                                  0.0f,
 19                                  0.0f,
 20                                  7.0f,
 21                                  0.0f,
 22                                  0.0f,
 23                                  4.0f,
 24                                  0.0f,
 25                                  1.0f};
 26
 27    float* ddenseA;
 28    HIP_CHECK(hipMalloc((void**)&ddenseA, sizeof(float) * m * n));
 29    HIP_CHECK(hipMemcpy(ddenseA, hdenseA.data(), sizeof(float) * m * n, hipMemcpyHostToDevice));
 30
 31    int* dcsrRowPtrB;
 32    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrB, sizeof(int) * (m + 1)));
 33
 34    hipsparseHandle_t     handle;
 35    hipsparseDnMatDescr_t matA;
 36    hipsparseSpMatDescr_t matB;
 37
 38    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 39
 40    // Create dense matrix A
 41    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matA, m, n, m, ddenseA, HIP_R_32F, HIPSPARSE_ORDER_COL));
 42
 43    hipsparseIndexType_t rowIdxTypeB = HIPSPARSE_INDEX_32I;
 44    hipsparseIndexType_t colIdxTypeB = HIPSPARSE_INDEX_32I;
 45    hipDataType          dataTypeB   = HIP_R_32F;
 46    hipsparseIndexBase_t idxBaseB    = HIPSPARSE_INDEX_BASE_ZERO;
 47
 48    // Create sparse matrix B
 49    HIPSPARSE_CHECK(hipsparseCreateCsr(
 50        &matB, m, n, 0, dcsrRowPtrB, NULL, NULL, rowIdxTypeB, colIdxTypeB, idxBaseB, dataTypeB));
 51
 52    hipsparseDenseToSparseAlg_t alg = HIPSPARSE_DENSETOSPARSE_ALG_DEFAULT;
 53
 54    size_t bufferSize;
 55    HIPSPARSE_CHECK(hipsparseDenseToSparse_bufferSize(handle, matA, matB, alg, &bufferSize));
 56
 57    void* tempBuffer;
 58    HIP_CHECK(hipMalloc((void**)&tempBuffer, bufferSize));
 59
 60    // Perform analysis which will determine the number of non-zeros in the CSR matrix
 61    HIPSPARSE_CHECK(hipsparseDenseToSparse_analysis(handle, matA, matB, alg, tempBuffer));
 62
 63    // Grab the non-zero count from the B matrix decriptor
 64    int64_t rows;
 65    int64_t cols;
 66    int64_t nnz;
 67    HIPSPARSE_CHECK(hipsparseSpMatGetSize(matB, &rows, &cols, &nnz));
 68
 69    // Allocate the column indices and values arrays
 70    int*   dcsrColIndB;
 71    float* dcsrValB;
 72    HIP_CHECK(hipMalloc((void**)&dcsrColIndB, sizeof(int) * nnz));
 73    HIP_CHECK(hipMalloc((void**)&dcsrValB, sizeof(float) * nnz));
 74
 75    // Set the newly allocated arrays on the sparse matrix descriptor
 76    HIPSPARSE_CHECK(hipsparseCsrSetPointers(matB, dcsrRowPtrB, dcsrColIndB, dcsrValB));
 77
 78    // Complete the conversion
 79    HIPSPARSE_CHECK(hipsparseDenseToSparse_convert(handle, matA, matB, alg, tempBuffer));
 80
 81    // Copy result back to host
 82    std::vector<int>   hcsrRowPtrB(m + 1);
 83    std::vector<int>   hcsrColIndB(nnz);
 84    std::vector<float> hcsrValB(nnz);
 85    HIP_CHECK(
 86        hipMemcpy(hcsrRowPtrB.data(), dcsrRowPtrB, sizeof(int) * (m + 1), hipMemcpyDeviceToHost));
 87    HIP_CHECK(hipMemcpy(hcsrColIndB.data(), dcsrColIndB, sizeof(int) * nnz, hipMemcpyDeviceToHost));
 88    HIP_CHECK(hipMemcpy(hcsrValB.data(), dcsrValB, sizeof(float) * nnz, hipMemcpyDeviceToHost));
 89
 90    // Clear hipSPARSE
 91    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matA));
 92    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matB));
 93    HIPSPARSE_CHECK(hipsparseDestroy(handle));
 94
 95    // Clear device memory
 96    HIP_CHECK(hipFree(ddenseA));
 97    HIP_CHECK(hipFree(dcsrRowPtrB));
 98    HIP_CHECK(hipFree(dcsrColIndB));
 99    HIP_CHECK(hipFree(dcsrValB));
100    HIP_CHECK(hipFree(tempBuffer));
101
102    return 0;
103}

hipsparseSpVV_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpVV()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

 1int main(int argc, char* argv[])
 2{
 3    // Number of non-zeros of the sparse vector
 4    int nnz = 3;
 5
 6    // Size of sparse and dense vector
 7    int size = 9;
 8
 9    // Sparse index vector
10    std::vector<int> hxInd = {0, 3, 5};
11
12    // Sparse value vector
13    std::vector<float> hxVal = {1.0f, 2.0f, 3.0f};
14
15    // Dense vector
16    std::vector<float> hy = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f};
17
18    // Offload data to device
19    int*   dxInd;
20    float* dxVal;
21    float* dy;
22    HIP_CHECK(hipMalloc((void**)&dxInd, sizeof(int) * nnz));
23    HIP_CHECK(hipMalloc((void**)&dxVal, sizeof(float) * nnz));
24    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * size));
25
26    HIP_CHECK(hipMemcpy(dxInd, hxInd.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
27    HIP_CHECK(hipMemcpy(dxVal, hxVal.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
28    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * size, hipMemcpyHostToDevice));
29
30    hipsparseHandle_t handle;
31    HIPSPARSE_CHECK(hipsparseCreate(&handle));
32
33    // Create sparse vector X
34    hipsparseSpVecDescr_t vecX;
35    HIPSPARSE_CHECK(hipsparseCreateSpVec(
36        &vecX, size, nnz, dxInd, dxVal, HIPSPARSE_INDEX_32I, HIPSPARSE_INDEX_BASE_ZERO, HIP_R_32F));
37
38    // Create dense vector Y
39    hipsparseDnVecDescr_t vecY;
40    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, size, dy, HIP_R_32F));
41
42    // Obtain buffer size
43    float  hresult = 0.0f;
44    size_t buffer_size;
45    HIPSPARSE_CHECK(hipsparseSpVV_bufferSize(
46        handle, HIPSPARSE_OPERATION_NON_TRANSPOSE, vecX, vecY, &hresult, HIP_R_32F, &buffer_size));
47
48    void* temp_buffer;
49    HIP_CHECK(hipMalloc(&temp_buffer, buffer_size));
50
51    // SpVV
52    HIPSPARSE_CHECK(hipsparseSpVV(
53        handle, HIPSPARSE_OPERATION_NON_TRANSPOSE, vecX, vecY, &hresult, HIP_R_32F, temp_buffer));
54
55    HIP_CHECK(hipDeviceSynchronize());
56
57    std::cout << "hresult: " << hresult << std::endl;
58
59    // Clear hipSPARSE
60    HIPSPARSE_CHECK(hipsparseDestroySpVec(vecX));
61    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
62    HIPSPARSE_CHECK(hipsparseDestroy(handle));
63
64    // Clear device memory
65    HIP_CHECK(hipFree(dxInd));
66    HIP_CHECK(hipFree(dxVal));
67    HIP_CHECK(hipFree(dy));
68    HIP_CHECK(hipFree(temp_buffer));
69
70    return 0;
71}

hipsparseSpMV_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpMV_preprocess()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpMV()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    // A, x, and y are m×k, k×1, and m×1
  4    int                  m = 3, k = 4;
  5    int                  nnz_A  = 8;
  6    hipsparseOperation_t transA = HIPSPARSE_OPERATION_NON_TRANSPOSE;
  7
  8    // alpha and beta
  9    float alpha = 0.5f;
 10    float beta  = 0.25f;
 11
 12    std::vector<int>   hcsrRowPtr = {0, 3, 5, 8};
 13    std::vector<int>   hcsrColInd = {0, 1, 3, 1, 2, 0, 2, 3};
 14    std::vector<float> hcsrVal    = {1, 2, 3, 4, 5, 6, 7, 8};
 15
 16    std::vector<float> hx(k, 1.0f);
 17    std::vector<float> hy(m, 1.0f);
 18
 19    int*   dcsrRowPtr;
 20    int*   dcsrColInd;
 21    float* dcsrVal;
 22    HIP_CHECK(hipMalloc((void**)&dcsrRowPtr, sizeof(int) * (m + 1)));
 23    HIP_CHECK(hipMalloc((void**)&dcsrColInd, sizeof(int) * nnz_A));
 24    HIP_CHECK(hipMalloc((void**)&dcsrVal, sizeof(float) * nnz_A));
 25
 26    HIP_CHECK(
 27        hipMemcpy(dcsrRowPtr, hcsrRowPtr.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
 28    HIP_CHECK(hipMemcpy(dcsrColInd, hcsrColInd.data(), sizeof(int) * nnz_A, hipMemcpyHostToDevice));
 29    HIP_CHECK(hipMemcpy(dcsrVal, hcsrVal.data(), sizeof(float) * nnz_A, hipMemcpyHostToDevice));
 30
 31    hipsparseHandle_t handle;
 32    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 33
 34    hipsparseSpMatDescr_t matA;
 35    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 36                                       m,
 37                                       k,
 38                                       nnz_A,
 39                                       dcsrRowPtr,
 40                                       dcsrColInd,
 41                                       dcsrVal,
 42                                       HIPSPARSE_INDEX_32I,
 43                                       HIPSPARSE_INDEX_32I,
 44                                       HIPSPARSE_INDEX_BASE_ZERO,
 45                                       HIP_R_32F));
 46
 47    // Allocate memory for the vector x
 48    float* dx;
 49    HIP_CHECK(hipMalloc((void**)&dx, sizeof(float) * k));
 50    HIP_CHECK(hipMemcpy(dx, hx.data(), sizeof(float) * k, hipMemcpyHostToDevice));
 51
 52    hipsparseDnVecDescr_t vecX;
 53    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecX, k, dx, HIP_R_32F));
 54
 55    // Allocate memory for the resulting vector y
 56    float* dy;
 57    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * m));
 58    HIP_CHECK(hipMemcpy(dy, hy.data(), sizeof(float) * m, hipMemcpyHostToDevice));
 59
 60    hipsparseDnMatDescr_t vecY;
 61    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, m, dy, HIP_R_32F));
 62
 63    // Compute buffersize
 64    size_t bufferSize;
 65    HIPSPARSE_CHECK(hipsparseSpMV_bufferSize(handle,
 66                                             transA,
 67                                             &alpha,
 68                                             matA,
 69                                             vecX,
 70                                             &beta,
 71                                             vecY,
 72                                             HIP_R_32F,
 73                                             HIPSPARSE_MV_ALG_DEFAULT,
 74                                             &bufferSize));
 75
 76    void* buffer;
 77    HIP_CHECK(hipMalloc(&buffer, bufferSize));
 78
 79    // Preprocess operation (Optional)
 80    HIPSPARSE_CHECK(hipsparseSpMV_preprocess(handle,
 81                                             transA,
 82                                             &alpha,
 83                                             matA,
 84                                             vecX,
 85                                             &beta,
 86                                             vecY,
 87                                             HIP_R_32F,
 88                                             HIPSPARSE_MV_ALG_DEFAULT,
 89                                             buffer));
 90
 91    // Perform operation
 92    HIPSPARSE_CHECK(hipsparseSpMV(handle,
 93                                  transA,
 94                                  &alpha,
 95                                  matA,
 96                                  vecX,
 97                                  &beta,
 98                                  vecY,
 99                                  HIP_R_32F,
100                                  HIPSPARSE_MV_ALG_DEFAULT,
101                                  buffer));
102
103    // Copy device to host
104    HIP_CHECK(hipMemcpy(hy.data(), dy, sizeof(float) * m, hipMemcpyDeviceToHost));
105
106    // Destroy matrix descriptors and handles
107    HIPSPARSE_CHECK(hipsparseDestroySpMat(matA));
108    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecX));
109    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
110    HIPSPARSE_CHECK(hipsparseDestroy(handle));
111
112    HIP_CHECK(hipFree(buffer));
113    HIP_CHECK(hipFree(dcsrRowPtr));
114    HIP_CHECK(hipFree(dcsrColInd));
115    HIP_CHECK(hipFree(dcsrVal));
116    HIP_CHECK(hipFree(dx));
117    HIP_CHECK(hipFree(dy));
118
119    return 0;
120}

hipsparseSpMM_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpMM_preprocess()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpMM()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    // A, B, and C are m×k, k×n, and m×n
  4    int                  m = 3, n = 5, k = 4;
  5    int                  ldb = n, ldc = n;
  6    int                  nnz_A = 8, nnz_B = 20, nnz_C = 15;
  7    hipsparseOperation_t transA = HIPSPARSE_OPERATION_NON_TRANSPOSE;
  8    hipsparseOperation_t transB = HIPSPARSE_OPERATION_NON_TRANSPOSE;
  9    hipsparseOperation_t transC = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 10    hipsparseOrder_t     order  = HIPSPARSE_ORDER_ROW;
 11
 12    // alpha and beta
 13    float alpha = 0.5f;
 14    float beta  = 0.25f;
 15
 16    std::vector<int>   hcsrRowPtr = {0, 3, 5, 8};
 17    std::vector<int>   hcsrColInd = {0, 1, 3, 1, 2, 0, 2, 3};
 18    std::vector<float> hcsrVal    = {1, 2, 3, 4, 5, 6, 7, 8};
 19
 20    std::vector<float> hB(nnz_B, 1.0f);
 21    std::vector<float> hC(nnz_C, 1.0f);
 22
 23    int*   dcsrRowPtr;
 24    int*   dcsrColInd;
 25    float* dcsrVal;
 26    HIP_CHECK(hipMalloc((void**)&dcsrRowPtr, sizeof(int) * (m + 1)));
 27    HIP_CHECK(hipMalloc((void**)&dcsrColInd, sizeof(int) * nnz_A));
 28    HIP_CHECK(hipMalloc((void**)&dcsrVal, sizeof(float) * nnz_A));
 29
 30    HIP_CHECK(
 31        hipMemcpy(dcsrRowPtr, hcsrRowPtr.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
 32    HIP_CHECK(hipMemcpy(dcsrColInd, hcsrColInd.data(), sizeof(int) * nnz_A, hipMemcpyHostToDevice));
 33    HIP_CHECK(hipMemcpy(dcsrVal, hcsrVal.data(), sizeof(float) * nnz_A, hipMemcpyHostToDevice));
 34
 35    hipsparseHandle_t handle;
 36    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 37
 38    hipsparseSpMatDescr_t matA;
 39    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 40                                       m,
 41                                       k,
 42                                       nnz_A,
 43                                       dcsrRowPtr,
 44                                       dcsrColInd,
 45                                       dcsrVal,
 46                                       HIPSPARSE_INDEX_32I,
 47                                       HIPSPARSE_INDEX_32I,
 48                                       HIPSPARSE_INDEX_BASE_ZERO,
 49                                       HIP_R_32F));
 50
 51    // Allocate memory for the matrix B
 52    float* dB;
 53    HIP_CHECK(hipMalloc((void**)&dB, sizeof(float) * nnz_B));
 54    HIP_CHECK(hipMemcpy(dB, hB.data(), sizeof(float) * nnz_B, hipMemcpyHostToDevice));
 55
 56    hipsparseDnMatDescr_t matB;
 57    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matB, k, n, ldb, dB, HIP_R_32F, order));
 58
 59    // Allocate memory for the resulting matrix C
 60    float* dC;
 61    HIP_CHECK(hipMalloc((void**)&dC, sizeof(float) * nnz_C));
 62    HIP_CHECK(hipMemcpy(dC, hC.data(), sizeof(float) * nnz_C, hipMemcpyHostToDevice));
 63
 64    hipsparseDnMatDescr_t matC;
 65    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matC, m, n, ldc, dC, HIP_R_32F, HIPSPARSE_ORDER_ROW));
 66
 67    // Compute buffersize
 68    size_t bufferSize;
 69    HIPSPARSE_CHECK(hipsparseSpMM_bufferSize(handle,
 70                                             transA,
 71                                             transB,
 72                                             &alpha,
 73                                             matA,
 74                                             matB,
 75                                             &beta,
 76                                             matC,
 77                                             HIP_R_32F,
 78                                             HIPSPARSE_MM_ALG_DEFAULT,
 79                                             &bufferSize));
 80
 81    void* buffer;
 82    HIP_CHECK(hipMalloc(&buffer, bufferSize));
 83
 84    // Preprocess operation (Optional)
 85    HIPSPARSE_CHECK(hipsparseSpMM_preprocess(handle,
 86                                             transA,
 87                                             transB,
 88                                             &alpha,
 89                                             matA,
 90                                             matB,
 91                                             &beta,
 92                                             matC,
 93                                             HIP_R_32F,
 94                                             HIPSPARSE_MM_ALG_DEFAULT,
 95                                             buffer));
 96
 97    // Perform operation
 98    HIPSPARSE_CHECK(hipsparseSpMM(handle,
 99                                  transA,
100                                  transB,
101                                  &alpha,
102                                  matA,
103                                  matB,
104                                  &beta,
105                                  matC,
106                                  HIP_R_32F,
107                                  HIPSPARSE_MM_ALG_DEFAULT,
108                                  buffer));
109
110    // Copy device to host
111    HIP_CHECK(hipMemcpy(hC.data(), dC, sizeof(float) * nnz_C, hipMemcpyDeviceToHost));
112
113    // Destroy matrix descriptors and handles
114    HIPSPARSE_CHECK(hipsparseDestroySpMat(matA));
115    HIPSPARSE_CHECK(hipsparseDestroyDnMat(matB));
116    HIPSPARSE_CHECK(hipsparseDestroyDnMat(matC));
117    HIPSPARSE_CHECK(hipsparseDestroy(handle));
118
119    HIP_CHECK(hipFree(buffer));
120    HIP_CHECK(hipFree(dcsrRowPtr));
121    HIP_CHECK(hipFree(dcsrColInd));
122    HIP_CHECK(hipFree(dcsrVal));
123    HIP_CHECK(hipFree(dB));
124    HIP_CHECK(hipFree(dC));
125
126    return 0;
127}

hipsparseSpGEMM_createDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMM_destroyDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMM_workEstimation()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMM_compute()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMM_copy()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    int m    = 2;
  4    int k    = 2;
  5    int n    = 3;
  6    int nnzA = 4;
  7    int nnzB = 4;
  8
  9    float alpha{1.0f};
 10    float beta{0.0f};
 11
 12    hipsparseOperation_t opA         = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 13    hipsparseOperation_t opB         = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 14    hipDataType          computeType = HIP_R_32F;
 15
 16    // A, B, and C are m×k, k×n, and m×n
 17
 18    // A
 19    std::vector<int>   hcsrRowPtrA = {0, 2, 4};
 20    std::vector<int>   hcsrColIndA = {0, 1, 0, 1};
 21    std::vector<float> hcsrValA    = {1.0f, 2.0f, 3.0f, 4.0f};
 22
 23    // B
 24    std::vector<int>   hcsrRowPtrB = {0, 2, 4};
 25    std::vector<int>   hcsrColIndB = {1, 2, 0, 2};
 26    std::vector<float> hcsrValB    = {5.0f, 6.0f, 7.0f, 8.0f};
 27
 28    // Device memory management: Allocate and copy A, B
 29    int*   dcsrRowPtrA;
 30    int*   dcsrColIndA;
 31    float* dcsrValA;
 32    int*   dcsrRowPtrB;
 33    int*   dcsrColIndB;
 34    float* dcsrValB;
 35    int*   dcsrRowPtrC;
 36    int*   dcsrColIndC;
 37    float* dcsrValC;
 38    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrA, (m + 1) * sizeof(int)));
 39    HIP_CHECK(hipMalloc((void**)&dcsrColIndA, nnzA * sizeof(int)));
 40    HIP_CHECK(hipMalloc((void**)&dcsrValA, nnzA * sizeof(float)));
 41    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrB, (k + 1) * sizeof(int)));
 42    HIP_CHECK(hipMalloc((void**)&dcsrColIndB, nnzB * sizeof(int)));
 43    HIP_CHECK(hipMalloc((void**)&dcsrValB, nnzB * sizeof(float)));
 44    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrC, (m + 1) * sizeof(int)));
 45
 46    HIP_CHECK(
 47        hipMemcpy(dcsrRowPtrA, hcsrRowPtrA.data(), (m + 1) * sizeof(int), hipMemcpyHostToDevice));
 48    HIP_CHECK(
 49        hipMemcpy(dcsrColIndA, hcsrColIndA.data(), nnzA * sizeof(int), hipMemcpyHostToDevice));
 50    HIP_CHECK(hipMemcpy(dcsrValA, hcsrValA.data(), nnzA * sizeof(float), hipMemcpyHostToDevice));
 51    HIP_CHECK(
 52        hipMemcpy(dcsrRowPtrB, hcsrRowPtrB.data(), (k + 1) * sizeof(int), hipMemcpyHostToDevice));
 53    HIP_CHECK(
 54        hipMemcpy(dcsrColIndB, hcsrColIndB.data(), nnzB * sizeof(int), hipMemcpyHostToDevice));
 55    HIP_CHECK(hipMemcpy(dcsrValB, hcsrValB.data(), nnzB * sizeof(float), hipMemcpyHostToDevice));
 56
 57    hipsparseSpMatDescr_t matA, matB, matC;
 58
 59    hipsparseHandle_t handle;
 60    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 61
 62    // Create sparse matrix A in CSR format
 63    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 64                                       m,
 65                                       k,
 66                                       nnzA,
 67                                       dcsrRowPtrA,
 68                                       dcsrColIndA,
 69                                       dcsrValA,
 70                                       HIPSPARSE_INDEX_32I,
 71                                       HIPSPARSE_INDEX_32I,
 72                                       HIPSPARSE_INDEX_BASE_ZERO,
 73                                       HIP_R_32F));
 74    HIPSPARSE_CHECK(hipsparseCreateCsr(&matB,
 75                                       k,
 76                                       n,
 77                                       nnzB,
 78                                       dcsrRowPtrB,
 79                                       dcsrColIndB,
 80                                       dcsrValB,
 81                                       HIPSPARSE_INDEX_32I,
 82                                       HIPSPARSE_INDEX_32I,
 83                                       HIPSPARSE_INDEX_BASE_ZERO,
 84                                       HIP_R_32F));
 85    HIPSPARSE_CHECK(hipsparseCreateCsr(&matC,
 86                                       m,
 87                                       n,
 88                                       0,
 89                                       dcsrRowPtrC,
 90                                       NULL,
 91                                       NULL,
 92                                       HIPSPARSE_INDEX_32I,
 93                                       HIPSPARSE_INDEX_32I,
 94                                       HIPSPARSE_INDEX_BASE_ZERO,
 95                                       HIP_R_32F));
 96
 97    hipsparseSpGEMMDescr_t spgemmDesc;
 98    HIPSPARSE_CHECK(hipsparseSpGEMM_createDescr(&spgemmDesc));
 99
100    void*  dBuffer1    = NULL;
101    void*  dBuffer2    = NULL;
102    size_t bufferSize1 = 0;
103    size_t bufferSize2 = 0;
104
105    // Determine size of first user allocated buffer
106    HIPSPARSE_CHECK(hipsparseSpGEMM_workEstimation(handle,
107                                                   opA,
108                                                   opB,
109                                                   &alpha,
110                                                   matA,
111                                                   matB,
112                                                   &beta,
113                                                   matC,
114                                                   computeType,
115                                                   HIPSPARSE_SPGEMM_DEFAULT,
116                                                   spgemmDesc,
117                                                   &bufferSize1,
118                                                   NULL));
119    HIP_CHECK(hipMalloc((void**)&dBuffer1, bufferSize1));
120
121    // Inspect the matrices A and B to determine the number of intermediate product in
122    // C = alpha * A * B
123    HIPSPARSE_CHECK(hipsparseSpGEMM_workEstimation(handle,
124                                                   opA,
125                                                   opB,
126                                                   &alpha,
127                                                   matA,
128                                                   matB,
129                                                   &beta,
130                                                   matC,
131                                                   computeType,
132                                                   HIPSPARSE_SPGEMM_DEFAULT,
133                                                   spgemmDesc,
134                                                   &bufferSize1,
135                                                   dBuffer1));
136
137    // Determine size of second user allocated buffer
138    HIPSPARSE_CHECK(hipsparseSpGEMM_compute(handle,
139                                            opA,
140                                            opB,
141                                            &alpha,
142                                            matA,
143                                            matB,
144                                            &beta,
145                                            matC,
146                                            computeType,
147                                            HIPSPARSE_SPGEMM_DEFAULT,
148                                            spgemmDesc,
149                                            &bufferSize2,
150                                            NULL));
151    HIP_CHECK(hipMalloc((void**)&dBuffer2, bufferSize2));
152
153    // Compute C = alpha * A * B and store result in temporary buffers
154    HIPSPARSE_CHECK(hipsparseSpGEMM_compute(handle,
155                                            opA,
156                                            opB,
157                                            &alpha,
158                                            matA,
159                                            matB,
160                                            &beta,
161                                            matC,
162                                            computeType,
163                                            HIPSPARSE_SPGEMM_DEFAULT,
164                                            spgemmDesc,
165                                            &bufferSize2,
166                                            dBuffer2));
167
168    // Get matrix C non-zero entries C_nnz1
169    int64_t C_num_rows1, C_num_cols1, C_nnz1;
170    HIPSPARSE_CHECK(hipsparseSpMatGetSize(matC, &C_num_rows1, &C_num_cols1, &C_nnz1));
171
172    // Allocate the CSR structures for the matrix C
173    HIP_CHECK(hipMalloc((void**)&dcsrColIndC, C_nnz1 * sizeof(int)));
174    HIP_CHECK(hipMalloc((void**)&dcsrValC, C_nnz1 * sizeof(float)));
175
176    // Update matC with the new pointers
177    HIPSPARSE_CHECK(hipsparseCsrSetPointers(matC, dcsrRowPtrC, dcsrColIndC, dcsrValC));
178
179    // Copy the final products to the matrix C
180    HIPSPARSE_CHECK(hipsparseSpGEMM_copy(handle,
181                                         opA,
182                                         opB,
183                                         &alpha,
184                                         matA,
185                                         matB,
186                                         &beta,
187                                         matC,
188                                         computeType,
189                                         HIPSPARSE_SPGEMM_DEFAULT,
190                                         spgemmDesc));
191
192    std::vector<int>   hcsrRowPtrC(m + 1);
193    std::vector<int>   hcsrColIndC(C_nnz1);
194    std::vector<float> hcsrValC(C_nnz1);
195
196    // Copy back to the host
197    HIP_CHECK(
198        hipMemcpy(hcsrRowPtrC.data(), dcsrRowPtrC, sizeof(int) * (m + 1), hipMemcpyDeviceToHost));
199    HIP_CHECK(
200        hipMemcpy(hcsrColIndC.data(), dcsrColIndC, sizeof(int) * C_nnz1, hipMemcpyDeviceToHost));
201    HIP_CHECK(hipMemcpy(hcsrValC.data(), dcsrValC, sizeof(float) * C_nnz1, hipMemcpyDeviceToHost));
202
203    std::cout << "C" << std::endl;
204    for(int i = 0; i < m; i++)
205    {
206        int start = hcsrRowPtrC[i];
207        int end   = hcsrRowPtrC[i + 1];
208
209        std::vector<float> temp(n, 0.0f);
210        for(int j = start; j < end; j++)
211        {
212            temp[hcsrColIndC[j]] = hcsrValC[j];
213        }
214
215        for(int j = 0; j < n; j++)
216        {
217            std::cout << temp[j] << " ";
218        }
219        std::cout << std::endl;
220    }
221    std::cout << std::endl;
222
223    // Destroy matrix descriptors and handles
224    HIPSPARSE_CHECK(hipsparseSpGEMM_destroyDescr(spgemmDesc));
225    HIPSPARSE_CHECK(hipsparseDestroySpMat(matA));
226    HIPSPARSE_CHECK(hipsparseDestroySpMat(matB));
227    HIPSPARSE_CHECK(hipsparseDestroySpMat(matC));
228    HIPSPARSE_CHECK(hipsparseDestroy(handle));
229
230    // Free device memory
231    HIP_CHECK(hipFree(dBuffer1));
232    HIP_CHECK(hipFree(dBuffer2));
233
234    return 0;
235}

hipsparseSpGEMMreuse_workEstimation()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMMreuse_nnz()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMMreuse_copy()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpGEMMreuse_compute()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    int m    = 2;
  4    int k    = 2;
  5    int n    = 3;
  6    int nnzA = 4;
  7    int nnzB = 4;
  8
  9    float alpha{1.0f};
 10    float beta{0.0f};
 11
 12    hipsparseOperation_t opA         = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 13    hipsparseOperation_t opB         = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 14    hipDataType          computeType = HIP_R_32F;
 15
 16    // A, B, and C are m×k, k×n, and m×n
 17
 18    // A
 19    std::vector<int>   hcsrRowPtrA = {0, 2, 4};
 20    std::vector<int>   hcsrColIndA = {0, 1, 0, 1};
 21    std::vector<float> hcsrValA    = {1.0f, 2.0f, 3.0f, 4.0f};
 22
 23    // B
 24    std::vector<int>   hcsrRowPtrB = {0, 2, 4};
 25    std::vector<int>   hcsrColIndB = {1, 2, 0, 2};
 26    std::vector<float> hcsrValB    = {5.0f, 6.0f, 7.0f, 8.0f};
 27
 28    // Device memory management: Allocate and copy A, B
 29    int*   dcsrRowPtrA;
 30    int*   dcsrColIndA;
 31    float* dcsrValA;
 32    int*   dcsrRowPtrB;
 33    int*   dcsrColIndB;
 34    float* dcsrValB;
 35    int*   dcsrRowPtrC;
 36    int*   dcsrColIndC;
 37    float* dcsrValC;
 38    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrA, (m + 1) * sizeof(int)));
 39    HIP_CHECK(hipMalloc((void**)&dcsrColIndA, nnzA * sizeof(int)));
 40    HIP_CHECK(hipMalloc((void**)&dcsrValA, nnzA * sizeof(float)));
 41    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrB, (k + 1) * sizeof(int)));
 42    HIP_CHECK(hipMalloc((void**)&dcsrColIndB, nnzB * sizeof(int)));
 43    HIP_CHECK(hipMalloc((void**)&dcsrValB, nnzB * sizeof(float)));
 44    HIP_CHECK(hipMalloc((void**)&dcsrRowPtrC, (m + 1) * sizeof(int)));
 45
 46    HIP_CHECK(
 47        hipMemcpy(dcsrRowPtrA, hcsrRowPtrA.data(), (m + 1) * sizeof(int), hipMemcpyHostToDevice));
 48    HIP_CHECK(
 49        hipMemcpy(dcsrColIndA, hcsrColIndA.data(), nnzA * sizeof(int), hipMemcpyHostToDevice));
 50    HIP_CHECK(hipMemcpy(dcsrValA, hcsrValA.data(), nnzA * sizeof(float), hipMemcpyHostToDevice));
 51    HIP_CHECK(
 52        hipMemcpy(dcsrRowPtrB, hcsrRowPtrB.data(), (k + 1) * sizeof(int), hipMemcpyHostToDevice));
 53    HIP_CHECK(
 54        hipMemcpy(dcsrColIndB, hcsrColIndB.data(), nnzB * sizeof(int), hipMemcpyHostToDevice));
 55    HIP_CHECK(hipMemcpy(dcsrValB, hcsrValB.data(), nnzB * sizeof(float), hipMemcpyHostToDevice));
 56
 57    hipsparseHandle_t     handle = NULL;
 58    hipsparseSpMatDescr_t matA, matB, matC;
 59    void*                 dBuffer1    = NULL;
 60    void*                 dBuffer2    = NULL;
 61    void*                 dBuffer3    = NULL;
 62    void*                 dBuffer4    = NULL;
 63    void*                 dBuffer5    = NULL;
 64    size_t                bufferSize1 = 0;
 65    size_t                bufferSize2 = 0;
 66    size_t                bufferSize3 = 0;
 67    size_t                bufferSize4 = 0;
 68    size_t                bufferSize5 = 0;
 69
 70    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 71
 72    // Create sparse matrix A in CSR format
 73    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 74                                       m,
 75                                       k,
 76                                       nnzA,
 77                                       dcsrRowPtrA,
 78                                       dcsrColIndA,
 79                                       dcsrValA,
 80                                       HIPSPARSE_INDEX_32I,
 81                                       HIPSPARSE_INDEX_32I,
 82                                       HIPSPARSE_INDEX_BASE_ZERO,
 83                                       HIP_R_32F));
 84    HIPSPARSE_CHECK(hipsparseCreateCsr(&matB,
 85                                       k,
 86                                       n,
 87                                       nnzB,
 88                                       dcsrRowPtrB,
 89                                       dcsrColIndB,
 90                                       dcsrValB,
 91                                       HIPSPARSE_INDEX_32I,
 92                                       HIPSPARSE_INDEX_32I,
 93                                       HIPSPARSE_INDEX_BASE_ZERO,
 94                                       HIP_R_32F));
 95    HIPSPARSE_CHECK(hipsparseCreateCsr(&matC,
 96                                       m,
 97                                       n,
 98                                       0,
 99                                       dcsrRowPtrC,
100                                       NULL,
101                                       NULL,
102                                       HIPSPARSE_INDEX_32I,
103                                       HIPSPARSE_INDEX_32I,
104                                       HIPSPARSE_INDEX_BASE_ZERO,
105                                       HIP_R_32F));
106
107    hipsparseSpGEMMDescr_t spgemmDesc;
108    HIPSPARSE_CHECK(hipsparseSpGEMM_createDescr(&spgemmDesc));
109
110    // Determine size of first user allocated buffer
111    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_workEstimation(handle,
112                                                        opA,
113                                                        opB,
114                                                        matA,
115                                                        matB,
116                                                        matC,
117                                                        HIPSPARSE_SPGEMM_DEFAULT,
118                                                        spgemmDesc,
119                                                        &bufferSize1,
120                                                        NULL));
121
122    HIP_CHECK(hipMalloc((void**)&dBuffer1, bufferSize1));
123
124    // Inspect the matrices A and B to determine the number of intermediate product in
125    // C = alpha * A * B
126    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_workEstimation(handle,
127                                                        opA,
128                                                        opB,
129                                                        matA,
130                                                        matB,
131                                                        matC,
132                                                        HIPSPARSE_SPGEMM_DEFAULT,
133                                                        spgemmDesc,
134                                                        &bufferSize1,
135                                                        dBuffer1));
136
137    // Determine size of second, third, and fourth user allocated buffer
138    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_nnz(handle,
139                                             opA,
140                                             opB,
141                                             matA,
142                                             matB,
143                                             matC,
144                                             HIPSPARSE_SPGEMM_DEFAULT,
145                                             spgemmDesc,
146                                             &bufferSize2,
147                                             NULL,
148                                             &bufferSize3,
149                                             NULL,
150                                             &bufferSize4,
151                                             NULL));
152
153    HIP_CHECK(hipMalloc((void**)&dBuffer2, bufferSize2));
154    HIP_CHECK(hipMalloc((void**)&dBuffer3, bufferSize3));
155    HIP_CHECK(hipMalloc((void**)&dBuffer4, bufferSize4));
156
157    // Compute sparsity pattern of C matrix and store in temporary buffers
158    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_nnz(handle,
159                                             opA,
160                                             opB,
161                                             matA,
162                                             matB,
163                                             matC,
164                                             HIPSPARSE_SPGEMM_DEFAULT,
165                                             spgemmDesc,
166                                             &bufferSize2,
167                                             dBuffer2,
168                                             &bufferSize3,
169                                             dBuffer3,
170                                             &bufferSize4,
171                                             dBuffer4));
172
173    // We can now free buffer 1 and 2
174    HIP_CHECK(hipFree(dBuffer1));
175    HIP_CHECK(hipFree(dBuffer2));
176
177    // Get matrix C non-zero entries nnzC
178    int64_t rowsC, colsC, nnzC;
179    HIPSPARSE_CHECK(hipsparseSpMatGetSize(matC, &rowsC, &colsC, &nnzC));
180
181    // Allocate matrix C
182    HIP_CHECK(hipMalloc((void**)&dcsrColIndC, sizeof(int) * nnzC));
183    HIP_CHECK(hipMalloc((void**)&dcsrValC, sizeof(float) * nnzC));
184
185    // Update matC with the new pointers. The C values array can be filled with data here
186    // which is used if beta != 0.
187    HIPSPARSE_CHECK(hipsparseCsrSetPointers(matC, dcsrRowPtrC, dcsrColIndC, dcsrValC));
188
189    // Determine size of fifth user allocated buffer
190    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_copy(handle,
191                                              opA,
192                                              opB,
193                                              matA,
194                                              matB,
195                                              matC,
196                                              HIPSPARSE_SPGEMM_DEFAULT,
197                                              spgemmDesc,
198                                              &bufferSize5,
199                                              NULL));
200
201    HIP_CHECK(hipMalloc((void**)&dBuffer5, bufferSize5));
202
203    // Copy data from temporary buffers to the newly allocated C matrix
204    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_copy(handle,
205                                              opA,
206                                              opB,
207                                              matA,
208                                              matB,
209                                              matC,
210                                              HIPSPARSE_SPGEMM_DEFAULT,
211                                              spgemmDesc,
212                                              &bufferSize5,
213                                              dBuffer5));
214
215    // We can now free buffer 3
216    HIP_CHECK(hipFree(dBuffer3));
217
218    // Compute C' = alpha * A * B + beta * C
219    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_compute(handle,
220                                                 opA,
221                                                 opB,
222                                                 &alpha,
223                                                 matA,
224                                                 matB,
225                                                 &beta,
226                                                 matC,
227                                                 computeType,
228                                                 HIPSPARSE_SPGEMM_DEFAULT,
229                                                 spgemmDesc));
230
231    // Copy results back to host if required
232    std::vector<int>   hcsrRowPtrC(m + 1);
233    std::vector<int>   hcsrColIndC(nnzC);
234    std::vector<float> hcsrValC(nnzC);
235    HIP_CHECK(
236        hipMemcpy(hcsrRowPtrC.data(), dcsrRowPtrC, sizeof(int) * (m + 1), hipMemcpyDeviceToHost));
237    HIP_CHECK(
238        hipMemcpy(hcsrColIndC.data(), dcsrColIndC, sizeof(int) * nnzC, hipMemcpyDeviceToHost));
239    HIP_CHECK(hipMemcpy(hcsrValC.data(), dcsrValC, sizeof(float) * nnzC, hipMemcpyDeviceToHost));
240
241    // Update dcsrValA, dcsrValB with new values
242    for(size_t i = 0; i < hcsrValA.size(); i++)
243    {
244        hcsrValA[i] = 1.0f;
245    }
246    for(size_t i = 0; i < hcsrValB.size(); i++)
247    {
248        hcsrValB[i] = 2.0f;
249    }
250
251    HIP_CHECK(hipMemcpy(dcsrValA, hcsrValA.data(), sizeof(float) * nnzA, hipMemcpyHostToDevice));
252    HIP_CHECK(hipMemcpy(dcsrValB, hcsrValB.data(), sizeof(float) * nnzB, hipMemcpyHostToDevice));
253
254    // Compute C' = alpha * A * B + beta * C again with the new A and B values
255    HIPSPARSE_CHECK(hipsparseSpGEMMreuse_compute(handle,
256                                                 opA,
257                                                 opB,
258                                                 &alpha,
259                                                 matA,
260                                                 matB,
261                                                 &beta,
262                                                 matC,
263                                                 computeType,
264                                                 HIPSPARSE_SPGEMM_DEFAULT,
265                                                 spgemmDesc));
266
267    // Copy results back to host if required
268    HIP_CHECK(
269        hipMemcpy(hcsrRowPtrC.data(), dcsrRowPtrC, sizeof(int) * (m + 1), hipMemcpyDeviceToHost));
270    HIP_CHECK(
271        hipMemcpy(hcsrColIndC.data(), dcsrColIndC, sizeof(int) * nnzC, hipMemcpyDeviceToHost));
272    HIP_CHECK(hipMemcpy(hcsrValC.data(), dcsrValC, sizeof(float) * nnzC, hipMemcpyDeviceToHost));
273
274    // Destroy matrix descriptors and handles
275    HIPSPARSE_CHECK(hipsparseSpGEMM_destroyDescr(spgemmDesc));
276    HIPSPARSE_CHECK(hipsparseDestroySpMat(matA));
277    HIPSPARSE_CHECK(hipsparseDestroySpMat(matB));
278    HIPSPARSE_CHECK(hipsparseDestroySpMat(matC));
279    HIPSPARSE_CHECK(hipsparseDestroy(handle));
280
281    // Free device memory
282    HIP_CHECK(hipFree(dBuffer4));
283    HIP_CHECK(hipFree(dBuffer5));
284    HIP_CHECK(hipFree(dcsrRowPtrA));
285    HIP_CHECK(hipFree(dcsrColIndA));
286    HIP_CHECK(hipFree(dcsrValA));
287    HIP_CHECK(hipFree(dcsrRowPtrB));
288    HIP_CHECK(hipFree(dcsrColIndB));
289    HIP_CHECK(hipFree(dcsrValB));
290    HIP_CHECK(hipFree(dcsrRowPtrC));
291    HIP_CHECK(hipFree(dcsrColIndC));
292    HIP_CHECK(hipFree(dcsrValC));
293
294    return 0;
295}

hipsparseSDDMM_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSDDMM_preprocess()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSDDMM()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    // hipSPARSE handle
  4    hipsparseHandle_t handle;
  5    HIPSPARSE_CHECK(hipsparseCreate(&handle));
  6
  7    __half halpha = 1.0;
  8    __half hbeta  = 0.0;
  9
 10    // A, B, and C are mxk, kxn, and mxn
 11    int m    = 4;
 12    int k    = 3;
 13    int n    = 2;
 14    int nnzC = 5;
 15
 16    //     2  3  -1
 17    // A = 0  2   1
 18    //     0  0   5
 19    //     0 -2 0.5
 20
 21    //      0  4
 22    // B =  1  0
 23    //     -2  0.5
 24
 25    //      1 0            1 0
 26    // C =  2 3   spy(C) = 1 1
 27    //      0 0            0 0
 28    //      4 5            1 1
 29
 30    std::vector<__half> hA = {2.0, 3.0, -1.0, 0.0, 2.0, 1.0, 0.0, 0.0, 5.0, 0.0, -2.0, 0.5};
 31    std::vector<__half> hB = {0.0, 4.0, 1.0, 0.0, -2.0, 0.5};
 32
 33    std::vector<int>    hcsr_row_ptrC = {0, 1, 3, 3, 5};
 34    std::vector<int>    hcsr_col_indC = {0, 0, 1, 0, 1};
 35    std::vector<__half> hcsr_valC     = {1.0, 2.0, 3.0, 4.0, 5.0};
 36
 37    __half* dA = nullptr;
 38    __half* dB = nullptr;
 39    HIP_CHECK(hipMalloc((void**)&dA, sizeof(__half) * m * k));
 40    HIP_CHECK(hipMalloc((void**)&dB, sizeof(__half) * k * n));
 41
 42    int*    dcsr_row_ptrC = nullptr;
 43    int*    dcsr_col_indC = nullptr;
 44    __half* dcsr_valC     = nullptr;
 45    HIP_CHECK(hipMalloc((void**)&dcsr_row_ptrC, sizeof(int) * (m + 1)));
 46    HIP_CHECK(hipMalloc((void**)&dcsr_col_indC, sizeof(int) * nnzC));
 47    HIP_CHECK(hipMalloc((void**)&dcsr_valC, sizeof(__half) * nnzC));
 48
 49    HIP_CHECK(hipMemcpy(dA, hA.data(), sizeof(__half) * m * k, hipMemcpyHostToDevice));
 50    HIP_CHECK(hipMemcpy(dB, hB.data(), sizeof(__half) * k * n, hipMemcpyHostToDevice));
 51
 52    HIP_CHECK(hipMemcpy(
 53        dcsr_row_ptrC, hcsr_row_ptrC.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
 54    HIP_CHECK(
 55        hipMemcpy(dcsr_col_indC, hcsr_col_indC.data(), sizeof(int) * nnzC, hipMemcpyHostToDevice));
 56    HIP_CHECK(hipMemcpy(dcsr_valC, hcsr_valC.data(), sizeof(__half) * nnzC, hipMemcpyHostToDevice));
 57
 58    hipsparseDnMatDescr_t matA;
 59    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matA, m, k, k, dA, HIP_R_16F, HIPSPARSE_ORDER_ROW));
 60
 61    hipsparseDnMatDescr_t matB;
 62    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matB, k, n, n, dB, HIP_R_16F, HIPSPARSE_ORDER_ROW));
 63
 64    hipsparseSpMatDescr_t matC;
 65    HIPSPARSE_CHECK(hipsparseCreateCsr(&matC,
 66                                       m,
 67                                       n,
 68                                       nnzC,
 69                                       dcsr_row_ptrC,
 70                                       dcsr_col_indC,
 71                                       dcsr_valC,
 72                                       HIPSPARSE_INDEX_32I,
 73                                       HIPSPARSE_INDEX_32I,
 74                                       HIPSPARSE_INDEX_BASE_ZERO,
 75                                       HIP_R_16F));
 76
 77    size_t buffer_size = 0;
 78    HIPSPARSE_CHECK(hipsparseSDDMM_bufferSize(handle,
 79                                              HIPSPARSE_OPERATION_NON_TRANSPOSE,
 80                                              HIPSPARSE_OPERATION_NON_TRANSPOSE,
 81                                              &halpha,
 82                                              matA,
 83                                              matB,
 84                                              &hbeta,
 85                                              matC,
 86                                              HIP_R_16F,
 87                                              HIPSPARSE_SDDMM_ALG_DEFAULT,
 88                                              &buffer_size));
 89
 90    void* dbuffer = nullptr;
 91    HIP_CHECK(hipMalloc((void**)&dbuffer, buffer_size));
 92
 93    HIPSPARSE_CHECK(hipsparseSDDMM_preprocess(handle,
 94                                              HIPSPARSE_OPERATION_NON_TRANSPOSE,
 95                                              HIPSPARSE_OPERATION_NON_TRANSPOSE,
 96                                              &halpha,
 97                                              matA,
 98                                              matB,
 99                                              &hbeta,
100                                              matC,
101                                              HIP_R_16F,
102                                              HIPSPARSE_SDDMM_ALG_DEFAULT,
103                                              dbuffer));
104
105    HIPSPARSE_CHECK(hipsparseSDDMM(handle,
106                                   HIPSPARSE_OPERATION_NON_TRANSPOSE,
107                                   HIPSPARSE_OPERATION_NON_TRANSPOSE,
108                                   &halpha,
109                                   matA,
110                                   matB,
111                                   &hbeta,
112                                   matC,
113                                   HIP_R_16F,
114                                   HIPSPARSE_SDDMM_ALG_DEFAULT,
115                                   dbuffer));
116
117    HIP_CHECK(hipMemcpy(
118        hcsr_row_ptrC.data(), dcsr_row_ptrC, sizeof(int) * (m + 1), hipMemcpyDeviceToHost));
119    HIP_CHECK(
120        hipMemcpy(hcsr_col_indC.data(), dcsr_col_indC, sizeof(int) * nnzC, hipMemcpyDeviceToHost));
121    HIP_CHECK(hipMemcpy(hcsr_valC.data(), dcsr_valC, sizeof(__half) * nnzC, hipMemcpyDeviceToHost));
122
123    std::cout << "C" << std::endl;
124    for(int i = 0; i < m; i++)
125    {
126        int start = hcsr_row_ptrC[i];
127        int end   = hcsr_row_ptrC[i + 1];
128
129        std::vector<__half> temp(n, 0.0);
130        for(int j = start; j < end; j++)
131        {
132            temp[hcsr_col_indC[j]] = hcsr_valC[j];
133        }
134
135        for(int j = 0; j < n; j++)
136        {
137            std::cout << static_cast<float>(temp[j]) << " ";
138        }
139        std::cout << std::endl;
140    }
141    std::cout << std::endl;
142
143    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matA));
144    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matB));
145    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matC));
146    HIPSPARSE_CHECK(hipsparseDestroy(handle));
147
148    HIP_CHECK(hipFree(dA));
149    HIP_CHECK(hipFree(dB));
150    HIP_CHECK(hipFree(dcsr_row_ptrC));
151    HIP_CHECK(hipFree(dcsr_col_indC));
152    HIP_CHECK(hipFree(dcsr_valC));
153    HIP_CHECK(hipFree(dbuffer));
154
155    return 0;
156}

hipsparseSpSV_createDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSV_destroyDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSV_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSV_analysis()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSV_solve()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    //     1 0 0 0
  4    // A = 4 2 0 0
  5    //     0 3 7 0
  6    //     0 0 0 1
  7    int m = 4;
  8
  9    std::vector<int>   hcsr_row_ptr = {0, 1, 3, 5, 6};
 10    std::vector<int>   hcsr_col_ind = {0, 0, 1, 1, 2, 3};
 11    std::vector<float> hcsr_val     = {1, 4, 2, 3, 7, 1};
 12    std::vector<float> hx(m, 1.0f);
 13    std::vector<float> hy(m, 0.0f);
 14
 15    // Scalar alpha
 16    float alpha = 1.0f;
 17
 18    int nnz = hcsr_row_ptr[m] - hcsr_row_ptr[0];
 19
 20    // Offload data to device
 21    int*   dcsr_row_ptr;
 22    int*   dcsr_col_ind;
 23    float* dcsr_val;
 24    float* dx;
 25    float* dy;
 26    HIP_CHECK(hipMalloc((void**)&dcsr_row_ptr, sizeof(int) * (m + 1)));
 27    HIP_CHECK(hipMalloc((void**)&dcsr_col_ind, sizeof(int) * nnz));
 28    HIP_CHECK(hipMalloc((void**)&dcsr_val, sizeof(float) * nnz));
 29    HIP_CHECK(hipMalloc((void**)&dx, sizeof(float) * m));
 30    HIP_CHECK(hipMalloc((void**)&dy, sizeof(float) * m));
 31
 32    HIP_CHECK(
 33        hipMemcpy(dcsr_row_ptr, hcsr_row_ptr.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
 34    HIP_CHECK(
 35        hipMemcpy(dcsr_col_ind, hcsr_col_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
 36    HIP_CHECK(hipMemcpy(dcsr_val, hcsr_val.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
 37    HIP_CHECK(hipMemcpy(dx, hx.data(), sizeof(float) * m, hipMemcpyHostToDevice));
 38
 39    hipsparseHandle_t     handle;
 40    hipsparseSpMatDescr_t matA;
 41    hipsparseDnVecDescr_t vecX;
 42    hipsparseDnVecDescr_t vecY;
 43
 44    hipsparseIndexType_t row_idx_type = HIPSPARSE_INDEX_32I;
 45    hipsparseIndexType_t col_idx_type = HIPSPARSE_INDEX_32I;
 46    hipDataType          data_type    = HIP_R_32F;
 47    hipDataType          computeType  = HIP_R_32F;
 48    hipsparseIndexBase_t idx_base     = HIPSPARSE_INDEX_BASE_ZERO;
 49    hipsparseOperation_t trans        = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 50
 51    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 52
 53    // Create sparse matrix A
 54    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 55                                       m,
 56                                       m,
 57                                       nnz,
 58                                       dcsr_row_ptr,
 59                                       dcsr_col_ind,
 60                                       dcsr_val,
 61                                       row_idx_type,
 62                                       col_idx_type,
 63                                       idx_base,
 64                                       data_type));
 65
 66    // Create dense vector X
 67    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecX, m, dx, data_type));
 68
 69    // Create dense vector Y
 70    HIPSPARSE_CHECK(hipsparseCreateDnVec(&vecY, m, dy, data_type));
 71
 72    hipsparseSpSVDescr_t descr;
 73    HIPSPARSE_CHECK(hipsparseSpSV_createDescr(&descr));
 74
 75    // Call spsv to get buffer size
 76    size_t buffer_size;
 77    HIPSPARSE_CHECK(hipsparseSpSV_bufferSize(handle,
 78                                             trans,
 79                                             &alpha,
 80                                             matA,
 81                                             vecX,
 82                                             vecY,
 83                                             computeType,
 84                                             HIPSPARSE_SPSV_ALG_DEFAULT,
 85                                             descr,
 86                                             &buffer_size));
 87
 88    void* temp_buffer;
 89    HIP_CHECK(hipMalloc((void**)&temp_buffer, buffer_size));
 90
 91    // Call spsv to perform analysis
 92    HIPSPARSE_CHECK(hipsparseSpSV_analysis(handle,
 93                                           trans,
 94                                           &alpha,
 95                                           matA,
 96                                           vecX,
 97                                           vecY,
 98                                           computeType,
 99                                           HIPSPARSE_SPSV_ALG_DEFAULT,
100                                           descr,
101                                           temp_buffer));
102
103    // Call spsv to perform computation
104    HIPSPARSE_CHECK(hipsparseSpSV_solve(
105        handle, trans, &alpha, matA, vecX, vecY, computeType, HIPSPARSE_SPSV_ALG_DEFAULT, descr));
106
107    // Copy result back to host
108    HIP_CHECK(hipMemcpy(hy.data(), dy, sizeof(float) * m, hipMemcpyDeviceToHost));
109
110    // Clear hipSPARSE
111    HIPSPARSE_CHECK(hipsparseSpSV_destroyDescr(descr));
112    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matA));
113    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecX));
114    HIPSPARSE_CHECK(hipsparseDestroyDnVec(vecY));
115    HIPSPARSE_CHECK(hipsparseDestroy(handle));
116
117    // Clear device memory
118    HIP_CHECK(hipFree(dcsr_row_ptr));
119    HIP_CHECK(hipFree(dcsr_col_ind));
120    HIP_CHECK(hipFree(dcsr_val));
121    HIP_CHECK(hipFree(dx));
122    HIP_CHECK(hipFree(dy));
123    HIP_CHECK(hipFree(temp_buffer));
124
125    return 0;
126}

hipsparseSpSM_createDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSM_destroyDescr()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSM_bufferSize()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSM_analysis()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

hipsparseSpSM_solve()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

  1int main(int argc, char* argv[])
  2{
  3    //     1 0 0 0
  4    // A = 4 2 0 0
  5    //     0 3 7 0
  6    //     0 0 0 1
  7    int m = 4;
  8    int n = 2;
  9
 10    std::vector<int>   hcsr_row_ptr = {0, 1, 3, 5, 6};
 11    std::vector<int>   hcsr_col_ind = {0, 0, 1, 1, 2, 3};
 12    std::vector<float> hcsr_val     = {1, 4, 2, 3, 7, 1};
 13    std::vector<float> hB(m * n);
 14    std::vector<float> hC(m * n);
 15
 16    for(int i = 0; i < n; i++)
 17    {
 18        for(int j = 0; j < m; j++)
 19        {
 20            hB[m * i + j] = static_cast<float>(i + 1);
 21        }
 22    }
 23
 24    // Scalar alpha
 25    float alpha = 1.0f;
 26
 27    int nnz = hcsr_row_ptr[m] - hcsr_row_ptr[0];
 28
 29    // Offload data to device
 30    int*   dcsr_row_ptr;
 31    int*   dcsr_col_ind;
 32    float* dcsr_val;
 33    float* dB;
 34    float* dC;
 35    HIP_CHECK(hipMalloc((void**)&dcsr_row_ptr, sizeof(int) * (m + 1)));
 36    HIP_CHECK(hipMalloc((void**)&dcsr_col_ind, sizeof(int) * nnz));
 37    HIP_CHECK(hipMalloc((void**)&dcsr_val, sizeof(float) * nnz));
 38    HIP_CHECK(hipMalloc((void**)&dB, sizeof(float) * m * n));
 39    HIP_CHECK(hipMalloc((void**)&dC, sizeof(float) * m * n));
 40
 41    HIP_CHECK(
 42        hipMemcpy(dcsr_row_ptr, hcsr_row_ptr.data(), sizeof(int) * (m + 1), hipMemcpyHostToDevice));
 43    HIP_CHECK(
 44        hipMemcpy(dcsr_col_ind, hcsr_col_ind.data(), sizeof(int) * nnz, hipMemcpyHostToDevice));
 45    HIP_CHECK(hipMemcpy(dcsr_val, hcsr_val.data(), sizeof(float) * nnz, hipMemcpyHostToDevice));
 46    HIP_CHECK(hipMemcpy(dB, hB.data(), sizeof(float) * m * n, hipMemcpyHostToDevice));
 47
 48    hipsparseHandle_t     handle;
 49    hipsparseSpMatDescr_t matA;
 50    hipsparseDnMatDescr_t matB;
 51    hipsparseDnMatDescr_t matC;
 52
 53    hipsparseIndexType_t row_idx_type = HIPSPARSE_INDEX_32I;
 54    hipsparseIndexType_t col_idx_type = HIPSPARSE_INDEX_32I;
 55    hipDataType          dataType     = HIP_R_32F;
 56    hipDataType          computeType  = HIP_R_32F;
 57    hipsparseIndexBase_t idxBase      = HIPSPARSE_INDEX_BASE_ZERO;
 58    hipsparseOperation_t transA       = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 59    hipsparseOperation_t transB       = HIPSPARSE_OPERATION_NON_TRANSPOSE;
 60
 61    HIPSPARSE_CHECK(hipsparseCreate(&handle));
 62
 63    // Create sparse matrix A
 64    HIPSPARSE_CHECK(hipsparseCreateCsr(&matA,
 65                                       m,
 66                                       m,
 67                                       nnz,
 68                                       dcsr_row_ptr,
 69                                       dcsr_col_ind,
 70                                       dcsr_val,
 71                                       row_idx_type,
 72                                       col_idx_type,
 73                                       idxBase,
 74                                       dataType));
 75
 76    // Create dense matrix B
 77    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matB, m, n, m, dB, dataType, HIPSPARSE_ORDER_COL));
 78
 79    // Create dense matrix C
 80    HIPSPARSE_CHECK(hipsparseCreateDnMat(&matC, m, n, m, dC, dataType, HIPSPARSE_ORDER_COL));
 81
 82    hipsparseSpSMDescr_t descr;
 83    HIPSPARSE_CHECK(hipsparseSpSM_createDescr(&descr));
 84
 85    // Call SpSM to get buffer size
 86    size_t buffer_size;
 87    HIPSPARSE_CHECK(hipsparseSpSM_bufferSize(handle,
 88                                             transA,
 89                                             transB,
 90                                             &alpha,
 91                                             matA,
 92                                             matB,
 93                                             matC,
 94                                             computeType,
 95                                             HIPSPARSE_SPSM_ALG_DEFAULT,
 96                                             descr,
 97                                             &buffer_size));
 98
 99    void* temp_buffer;
100    HIP_CHECK(hipMalloc((void**)&temp_buffer, buffer_size));
101
102    // Call SpSM to perform analysis
103    HIPSPARSE_CHECK(hipsparseSpSM_analysis(handle,
104                                           transA,
105                                           transB,
106                                           &alpha,
107                                           matA,
108                                           matB,
109                                           matC,
110                                           computeType,
111                                           HIPSPARSE_SPSM_ALG_DEFAULT,
112                                           descr,
113                                           temp_buffer));
114
115    // Call SpSM to perform computation
116    HIPSPARSE_CHECK(hipsparseSpSM_solve(handle,
117                                        transA,
118                                        transB,
119                                        &alpha,
120                                        matA,
121                                        matB,
122                                        matC,
123                                        computeType,
124                                        HIPSPARSE_SPSM_ALG_DEFAULT,
125                                        descr,
126                                        temp_buffer));
127
128    // Copy result back to host
129    HIP_CHECK(hipMemcpy(hC.data(), dC, sizeof(float) * m * n, hipMemcpyDeviceToHost));
130
131    // Clear hipSPARSE
132    HIPSPARSE_CHECK(hipsparseSpSM_destroyDescr(descr));
133    HIPSPARSE_CHECK(hipsparseDestroyMatDescr(matA));
134    HIPSPARSE_CHECK(hipsparseDestroyDnMat(matB));
135    HIPSPARSE_CHECK(hipsparseDestroyDnMat(matC));
136    HIPSPARSE_CHECK(hipsparseDestroy(handle));
137
138    // Clear device memory
139    HIP_CHECK(hipFree(dcsr_row_ptr));
140    HIP_CHECK(hipFree(dcsr_col_ind));
141    HIP_CHECK(hipFree(dcsr_val));
142    HIP_CHECK(hipFree(dB));
143    HIP_CHECK(hipFree(dC));
144    HIP_CHECK(hipFree(temp_buffer));
145
146    return 0;
147}

hipsparseSpSM_solve_ex()#

Warning

doxygenfunction: Cannot find file: /home/docs/checkouts/readthedocs.org/user_builds/advanced-micro-devices-hipsparse/checkouts/7.13.0-preview/projects/hipsparse/docs/doxygen/xml/index.xml

Contents