spla
cpu_v_emult.hpp
Go to the documentation of this file.
1 /**********************************************************************************/
2 /* This file is part of spla project */
3 /* https://github.com/JetBrains-Research/spla */
4 /**********************************************************************************/
5 /* MIT License */
6 /* */
7 /* Copyright (c) 2023 SparseLinearAlgebra */
8 /* */
9 /* Permission is hereby granted, free of charge, to any person obtaining a copy */
10 /* of this software and associated documentation files (the "Software"), to deal */
11 /* in the Software without restriction, including without limitation the rights */
12 /* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell */
13 /* copies of the Software, and to permit persons to whom the Software is */
14 /* furnished to do so, subject to the following conditions: */
15 /* */
16 /* The above copyright notice and this permission notice shall be included in all */
17 /* copies or substantial portions of the Software. */
18 /* */
19 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR */
20 /* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, */
21 /* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE */
22 /* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER */
23 /* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, */
24 /* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE */
25 /* SOFTWARE. */
26 /**********************************************************************************/
27 
28 #ifndef SPLA_CPU_V_EMULT_HPP
29 #define SPLA_CPU_V_EMULT_HPP
30 
31 #include <schedule/schedule_tasks.hpp>
32 
33 #include <core/dispatcher.hpp>
34 #include <core/registry.hpp>
35 #include <core/top.hpp>
36 #include <core/tscalar.hpp>
37 #include <core/ttype.hpp>
38 #include <core/tvector.hpp>
39 
40 namespace spla {
41 
42  template<typename T>
43  class Algo_v_emult_cpu final : public RegistryAlgo {
44  public:
45  ~Algo_v_emult_cpu() override = default;
46 
47  std::string get_name() override {
48  return "v_emult";
49  }
50 
51  std::string get_description() override {
52  return "sequential element-wise mult vector operation";
53  }
54 
55  Status execute(const DispatchContext& ctx) override {
56  auto t = ctx.task.template cast_safe<ScheduleTask_v_emult>();
57  ref_ptr<TVector<T>> u = t->u.template cast_safe<TVector<T>>();
58  ref_ptr<TVector<T>> v = t->v.template cast_safe<TVector<T>>();
59 
60  if (u->is_valid(FormatVector::CpuCoo) && v->is_valid(FormatVector::CpuCoo)) {
61  return execute_spNsp(ctx);
62  }
63  if (u->is_valid(FormatVector::CpuCoo) && v->is_valid(FormatVector::CpuDense)) {
64  return execute_spNdn(ctx);
65  }
66  if (u->is_valid(FormatVector::CpuDense) && v->is_valid(FormatVector::CpuCoo)) {
67  return execute_dnNsp(ctx);
68  }
69 
70  return execute_spNsp(ctx);
71  }
72 
73  private:
74  Status execute_spNsp(const DispatchContext& ctx) {
75  TIME_PROFILE_SCOPE("cpu/vector_emult_spNsp");
76 
77  auto t = ctx.task.template cast_safe<ScheduleTask_v_emult>();
78  ref_ptr<TVector<T>> r = t->r.template cast_safe<TVector<T>>();
79  ref_ptr<TVector<T>> u = t->u.template cast_safe<TVector<T>>();
80  ref_ptr<TVector<T>> v = t->v.template cast_safe<TVector<T>>();
81  ref_ptr<TOpBinary<T, T, T>> op = t->op.template cast_safe<TOpBinary<T, T, T>>();
82 
83  r->validate_wd(FormatVector::CpuCoo);
84  u->validate_rw(FormatVector::CpuCoo);
85  v->validate_rw(FormatVector::CpuCoo);
86 
87  CpuCooVec<T>* p_r = r->template get<CpuCooVec<T>>();
88  const CpuCooVec<T>* p_u = u->template get<CpuCooVec<T>>();
89  const CpuCooVec<T>* p_v = v->template get<CpuCooVec<T>>();
90  const auto& function = op->function;
91 
92  assert(p_r->Ai.empty());
93  assert(p_r->Ax.empty());
94 
95  const auto u_count = p_u->values;
96  const auto v_count = p_v->values;
97  uint u_iter = 0;
98  uint v_iter = 0;
99 
100  while (u_iter < u_count && v_iter < v_count) {
101  if (p_u->Ai[u_iter] < p_v->Ai[v_iter]) {
102  u_iter += 1;
103  } else if (p_v->Ai[v_iter] < p_u->Ai[u_iter]) {
104  v_iter += 1;
105  } else {
106  p_r->values += 1;
107  p_r->Ai.push_back(p_u->Ai[u_iter]);
108  p_r->Ax.push_back(function(p_u->Ax[u_iter], p_v->Ax[v_iter]));
109  u_iter += 1;
110  v_iter += 1;
111  }
112  }
113 
114  return Status::Ok;
115  }
116  Status execute_spNdn(const DispatchContext& ctx) {
117  TIME_PROFILE_SCOPE("cpu/vector_emult_spNdn");
118 
119  auto t = ctx.task.template cast_safe<ScheduleTask_v_emult>();
120  ref_ptr<TVector<T>> r = t->r.template cast_safe<TVector<T>>();
121  ref_ptr<TVector<T>> u = t->u.template cast_safe<TVector<T>>();
122  ref_ptr<TVector<T>> v = t->v.template cast_safe<TVector<T>>();
123  ref_ptr<TOpBinary<T, T, T>> op = t->op.template cast_safe<TOpBinary<T, T, T>>();
124 
125  r->validate_wd(FormatVector::CpuCoo);
126  u->validate_rw(FormatVector::CpuCoo);
127  v->validate_rw(FormatVector::CpuDense);
128 
129  CpuCooVec<T>* p_r = r->template get<CpuCooVec<T>>();
130  const CpuCooVec<T>* p_u = u->template get<CpuCooVec<T>>();
131  const CpuDenseVec<T>* p_v = v->template get<CpuDenseVec<T>>();
132  const auto& function = op->function;
133  const auto skip = v->get_fill_value();
134 
135  assert(p_r->Ai.empty());
136  assert(p_r->Ax.empty());
137 
138  for (uint k = 0; k < p_u->values; k++) {
139  const uint i = p_u->Ai[k];
140 
141  if (p_v->Ax[i] != skip) {
142  p_r->values += 1;
143  p_r->Ai.push_back(i);
144  p_r->Ax.push_back(function(p_u->Ax[k], p_v->Ax[i]));
145  }
146  }
147 
148  return Status::Ok;
149  }
150  Status execute_dnNsp(const DispatchContext& ctx) {
151  TIME_PROFILE_SCOPE("cpu/vector_emult_dnNsp");
152 
153  auto t = ctx.task.template cast_safe<ScheduleTask_v_emult>();
154  ref_ptr<TVector<T>> r = t->r.template cast_safe<TVector<T>>();
155  ref_ptr<TVector<T>> u = t->u.template cast_safe<TVector<T>>();
156  ref_ptr<TVector<T>> v = t->v.template cast_safe<TVector<T>>();
157  ref_ptr<TOpBinary<T, T, T>> op = t->op.template cast_safe<TOpBinary<T, T, T>>();
158 
159  r->validate_wd(FormatVector::CpuCoo);
160  u->validate_rw(FormatVector::CpuDense);
161  v->validate_rw(FormatVector::CpuCoo);
162 
163  CpuCooVec<T>* p_r = r->template get<CpuCooVec<T>>();
164  const CpuDenseVec<T>* p_u = u->template get<CpuDenseVec<T>>();
165  const CpuCooVec<T>* p_v = v->template get<CpuCooVec<T>>();
166  const auto& function = op->function;
167  const auto skip = u->get_fill_value();
168 
169  assert(p_r->Ai.empty());
170  assert(p_r->Ax.empty());
171 
172  for (uint k = 0; k < p_v->values; k++) {
173  const uint i = p_v->Ai[k];
174 
175  if (p_u->Ax[i] != skip) {
176  p_r->values += 1;
177  p_r->Ai.push_back(i);
178  p_r->Ax.push_back(function(p_u->Ax[i], p_v->Ax[k]));
179  }
180  }
181 
182  return Status::Ok;
183  }
184  };
185 
186 }// namespace spla
187 
188 #endif//SPLA_CPU_V_EMULT_HPP
Status
Status of library operation execution.
spla::Algo_v_emult_cpu
Definition: cpu_v_emult.hpp:43
spla::Algo_v_emult_cpu::~Algo_v_emult_cpu
~Algo_v_emult_cpu() override=default
spla::Algo_v_emult_cpu::get_description
std::string get_description() override
Definition: cpu_v_emult.hpp:51
spla::Algo_v_emult_cpu::execute
Status execute(const DispatchContext &ctx) override
Definition: cpu_v_emult.hpp:55
spla::Algo_v_emult_cpu::get_name
std::string get_name() override
Definition: cpu_v_emult.hpp:47
spla::CpuCooVec
CPU list-of-coordinates sparse vector representation.
Definition: cpu_formats.hpp:90
spla::CpuCooVec::Ai
std::vector< uint > Ai
Definition: cpu_formats.hpp:96
spla::CpuCooVec::Ax
std::vector< T > Ax
Definition: cpu_formats.hpp:97
spla::RegistryAlgo
Algorithm suitable to process schedule task based on task string key.
Definition: registry.hpp:66
spla::TDecoration::values
uint values
Definition: tdecoration.hpp:58
spla::ref_ptr
Automates reference counting and behaves as shared smart pointer.
Definition: ref.hpp:117
spla::uint
std::uint32_t uint
Library index and size type.
Definition: config.hpp:56
spla::FormatVector::CpuDense
@ CpuDense
spla::FormatVector::CpuCoo
@ CpuCoo
spla::Status::Ok
@ Ok
spla
Definition: algorithm.hpp:37
schedule_tasks.hpp
spla::DispatchContext
Execution context of a single task.
Definition: dispatcher.hpp:46
spla::DispatchContext::task
ref_ptr< ScheduleTask > task
Definition: dispatcher.hpp:48
TIME_PROFILE_SCOPE
#define TIME_PROFILE_SCOPE(name)
Definition: time_profiler.hpp:92
Generated by doxygen 1.9.1