-
Notifications
You must be signed in to change notification settings - Fork 16
Expand file tree
/
Copy pathcl_algo_registry.cpp
More file actions
110 lines (93 loc) · 6.86 KB
/
cl_algo_registry.cpp
File metadata and controls
110 lines (93 loc) · 6.86 KB
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
/**********************************************************************************/
/* This file is part of spla project */
/* https://github.com/SparseLinearAlgebra/spla */
/**********************************************************************************/
/* MIT License */
/* */
/* Copyright (c) 2023 SparseLinearAlgebra */
/* */
/* 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 "cl_algo_registry.hpp"
#include <core/registry.hpp>
#include <core/top.hpp>
#include <opencl/cl_m_extract_row.hpp>
#include <opencl/cl_m_reduce.hpp>
#include <opencl/cl_mxmT_masked.hpp>
#include <opencl/cl_mxv.hpp>
#include <opencl/cl_v_assign.hpp>
#include <opencl/cl_v_count_mf.hpp>
#include <opencl/cl_v_eadd.hpp>
#include <opencl/cl_v_eadd_fdb.hpp>
#include <opencl/cl_v_emult.hpp>
#include <opencl/cl_v_map.hpp>
#include <opencl/cl_v_reduce.hpp>
#include <opencl/cl_vxm.hpp>
namespace spla {
void register_algo_cl(class Registry* g_registry) {
// algorthm v_count_mf
g_registry->add(MAKE_KEY_CL_0("v_count_mf", INT), std::make_shared<Algo_v_count_mf_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_count_mf", UINT), std::make_shared<Algo_v_count_mf_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_count_mf", FLOAT), std::make_shared<Algo_v_count_mf_cl<T_FLOAT>>());
// algorthm v_map
g_registry->add(MAKE_KEY_CL_0("v_map", INT), std::make_shared<Algo_v_map_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_map", UINT), std::make_shared<Algo_v_map_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_map", FLOAT), std::make_shared<Algo_v_map_cl<T_FLOAT>>());
// algorthm v_reduce
g_registry->add(MAKE_KEY_CL_0("v_reduce", INT), std::make_shared<Algo_v_reduce_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_reduce", UINT), std::make_shared<Algo_v_reduce_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_reduce", FLOAT), std::make_shared<Algo_v_reduce_cl<T_FLOAT>>());
// algorthm v_eadd
g_registry->add(MAKE_KEY_CL_0("v_eadd", INT), std::make_shared<Algo_v_eadd_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_eadd", UINT), std::make_shared<Algo_v_eadd_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_eadd", FLOAT), std::make_shared<Algo_v_eadd_cl<T_FLOAT>>());
// algorthm v_eadd_fdb
g_registry->add(MAKE_KEY_CL_0("v_eadd_fdb", INT), std::make_shared<Algo_v_eadd_fdb_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_eadd_fdb", UINT), std::make_shared<Algo_v_eadd_fdb_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_eadd_fdb", FLOAT), std::make_shared<Algo_v_eadd_fdb_cl<T_FLOAT>>());
// algorthm v_assign_masked
g_registry->add(MAKE_KEY_CL_0("v_assign_masked", INT), std::make_shared<Algo_v_assign_masked_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_assign_masked", UINT), std::make_shared<Algo_v_assign_masked_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_assign_masked", FLOAT), std::make_shared<Algo_v_assign_masked_cl<T_FLOAT>>());
// algorthm m_reduce
g_registry->add(MAKE_KEY_CL_0("m_reduce", INT), std::make_shared<Algo_m_reduce_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("m_reduce", UINT), std::make_shared<Algo_m_reduce_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("m_reduce", FLOAT), std::make_shared<Algo_m_reduce_cl<T_FLOAT>>());
// algorthm mxv_masked
g_registry->add(MAKE_KEY_CL_0("mxv_masked", INT), std::make_shared<Algo_mxv_masked_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("mxv_masked", UINT), std::make_shared<Algo_mxv_masked_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("mxv_masked", FLOAT), std::make_shared<Algo_mxv_masked_cl<T_FLOAT>>());
// algorthm vxm_masked
g_registry->add(MAKE_KEY_CL_0("vxm_masked", INT), std::make_shared<Algo_vxm_masked_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("vxm_masked", UINT), std::make_shared<Algo_vxm_masked_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("vxm_masked", FLOAT), std::make_shared<Algo_vxm_masked_cl<T_FLOAT>>());
// algorthm mxmT_masked
g_registry->add(MAKE_KEY_CL_0("mxmT_masked", INT), std::make_shared<Algo_mxmT_masked_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("mxmT_masked", UINT), std::make_shared<Algo_mxmT_masked_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("mxmT_masked", FLOAT), std::make_shared<Algo_mxmT_masked_cl<T_FLOAT>>());
// algorthm m_extract_row
g_registry->add(MAKE_KEY_CL_0("m_extract_row", INT), std::make_shared<Algo_m_extract_row_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("m_extract_row", UINT), std::make_shared<Algo_m_extract_row_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("m_extract_row", FLOAT), std::make_shared<Algo_m_extract_row_cl<T_FLOAT>>());
// algorthm v_emult
g_registry->add(MAKE_KEY_CL_0("v_emult", INT), std::make_shared<Algo_v_emult_cl<T_INT>>());
g_registry->add(MAKE_KEY_CL_0("v_emult", UINT), std::make_shared<Algo_v_emult_cl<T_UINT>>());
g_registry->add(MAKE_KEY_CL_0("v_emult", FLOAT), std::make_shared<Algo_v_emult_cl<T_FLOAT>>());
}
}// namespace spla