1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/*! \file */
/* ************************************************************************
* Copyright (C) 2020 Advanced Micro Devices, Inc. All rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* ************************************************************************ */
#include <hip/hip_runtime_api.h>
#include <iostream>
#include <rocsparse/rocsparse.h>
#define HIP_CHECK(stat) \
{ \
if(stat != hipSuccess) \
{ \
std::cerr << "Error: hip error in line " << __LINE__ << std::endl; \
return -1; \
} \
}
#define ROCSPARSE_CHECK(stat) \
{ \
if(stat != rocsparse_status_success) \
{ \
std::cerr << "Error: rocsparse error in line " << __LINE__ << std::endl; \
return -1; \
} \
}
int main(int argc, char* argv[])
{
// Query device
int ndev;
HIP_CHECK(hipGetDeviceCount(&ndev));
if(ndev < 1)
{
std::cerr << "No HIP device found" << std::endl;
return -1;
}
// Query device properties
hipDeviceProp_t prop;
HIP_CHECK(hipGetDeviceProperties(&prop, 0));
std::cout << "Device: " << prop.name << std::endl;
// rocSPARSE handle
rocsparse_handle handle;
ROCSPARSE_CHECK(rocsparse_create_handle(&handle));
// Print rocSPARSE version and revision
int ver;
char rev[64];
ROCSPARSE_CHECK(rocsparse_get_version(handle, &ver));
ROCSPARSE_CHECK(rocsparse_get_git_rev(handle, rev));
std::cout << "rocSPARSE version: " << ver / 100000 << "." << ver / 100 % 1000 << "."
<< ver % 100 << "-" << rev << std::endl;
// Input data
// Number of non-zeros of the sparse vector
rocsparse_int nnz = 3;
// Sparse index vector
rocsparse_int hx_ind[3] = {0, 3, 5};
// Sparse value vector
double hx_val[3] = {1.0, 2.0, 3.0};
// Dense vector
double hy[9] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0};
// Index base
rocsparse_index_base idx_base = rocsparse_index_base_zero;
// Offload data to device
rocsparse_int* dx_ind;
double* dx_val;
double* dy;
HIP_CHECK(hipMalloc((void**)&dx_ind, sizeof(rocsparse_int) * nnz));
HIP_CHECK(hipMalloc((void**)&dx_val, sizeof(double) * nnz));
HIP_CHECK(hipMalloc((void**)&dy, sizeof(double) * 9));
HIP_CHECK(hipMemcpy(dx_ind, hx_ind, sizeof(rocsparse_int) * nnz, hipMemcpyHostToDevice));
HIP_CHECK(hipMemcpy(dx_val, hx_val, sizeof(double) * nnz, hipMemcpyHostToDevice));
HIP_CHECK(hipMemcpy(dy, hy, sizeof(double) * 9, hipMemcpyHostToDevice));
// Call ddoti to compute the dot product
double dot;
ROCSPARSE_CHECK(rocsparse_ddoti(handle, nnz, dx_val, dx_ind, dy, &dot, idx_base));
// Print result
std::cout << "Dot product: " << dot << std::endl;
// Clear rocSPARSE
ROCSPARSE_CHECK(rocsparse_destroy_handle(handle));
// Clear device memory
HIP_CHECK(hipFree(dx_ind));
HIP_CHECK(hipFree(dx_val));
HIP_CHECK(hipFree(dy));
return 0;
}
|
