C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

algorithm_types.h
1 /* file: algorithm_types.h */
2 /*******************************************************************************
3 * Copyright 2014-2020 Intel Corporation
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *******************************************************************************/
17 
18 /*
19 //++
20 // Implementation of base classes defining algorithm interface.
21 //--
22 */
23 
24 #ifndef __ALGORITHM_TYPES_H__
25 #define __ALGORITHM_TYPES_H__
26 
27 #include "services/daal_defines.h"
28 #include "data_management/data/data_archive.h"
29 #include "data_management/data/data_serialize.h"
30 #include "data_management/data/data_collection.h"
31 #include "services/error_handling.h"
32 
33 namespace daal
34 {
45 namespace algorithms
46 {
47 
51 namespace interface1
52 {
62 struct Parameter
63 {
64  DAAL_NEW_DELETE();
65 
66  Parameter(){}
67  virtual ~Parameter() {}
68 
69  virtual services::Status check() const { return services::Status(); }
70 };
71 
76 class DAAL_EXPORT Argument
77 {
78 public:
79  DAAL_NEW_DELETE();
80 
82  Argument() : idx(0) {}
83 
88  Argument(const size_t n);
89 
90  virtual ~Argument() {};
91 
97  Argument &operator <<(const data_management::SerializationIfacePtr &val)
98  {
99  (*_storage) << val;
100  return *this;
101  }
102 
107  size_t size() const
108  {
109  return _storage->size();
110  }
111 
112 protected:
117  Argument(const Argument& other);
118 
124  const data_management::SerializationIfacePtr &get(size_t index) const;
125 
132  void set(size_t index, const data_management::SerializationIfacePtr &value);
133 
138  void setStorage(const data_management::DataCollectionPtr& storage);
139 
144  static data_management::DataCollectionPtr& getStorage(Argument& a);
145 
150  static const data_management::DataCollectionPtr& getStorage(const Argument& a);
151 
152 
153  template<typename Archive, bool onDeserialize>
154  services::Status serialImpl(Archive *arch)
155  {
156  arch->set(idx);
157  arch->setObj(_storage.get());
158 
159  return services::Status();
160  }
161 
162 private:
163  size_t idx;
164  data_management::DataCollectionPtr _storage;
165 };
166 
171 class SerializableArgument : public data_management::SerializationIface, public Argument
172 {
173 public:
174  DAAL_NEW_DELETE();
175 
177  SerializableArgument() {}
178 
183  SerializableArgument(const size_t n) : Argument(n) {}
184 
185  virtual ~SerializableArgument() {};
186 };
187 
193 class Input : public Argument
194 {
195 public:
196  DAAL_NEW_DELETE();
197 
199  Input() {}
200 
205  Input(const size_t n) : Argument(n) {}
206 
207  virtual ~Input() {};
208 
214  virtual services::Status check(const Parameter *parameter, int method) const { return services::Status(); }
215 
216 protected:
221  Input(const Input& other) : Argument(other){}
222 };
223 
229 class PartialResult : public SerializableArgument
230 {
231 public:
232  DAAL_NEW_DELETE();
233 
235  PartialResult() : _initFlag(false) {};
236 
241  PartialResult(const size_t n) : SerializableArgument(n), _initFlag(false) {}
242 
243  virtual ~PartialResult() {};
244 
248  virtual int getSerializationTag() const { return 0; }
249 
254  bool getInitFlag() { return _initFlag; }
255 
260  void setInitFlag(bool flag) { _initFlag = flag; }
261 
268  virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
269  {
270  return services::Status();
271  }
272 
278  virtual services::Status check(const Parameter *parameter, int method) const { return services::Status(); }
279 
280 private:
281  bool _initFlag;
282 
283 protected:
285  template<typename Archive, bool onDeserialize>
286  services::Status serialImpl(Archive *arch)
287  {
288  Argument::serialImpl<Archive, onDeserialize>(arch);
289 
290  arch->set(_initFlag);
291 
292  return services::Status();
293  }
294  virtual services::Status serializeImpl(data_management::InputDataArchive *archive)
295  {
296  return services::Status();
297  }
298  virtual services::Status deserializeImpl(const data_management::OutputDataArchive *archive)
299  {
300  return services::Status();
301  }
302 };
303 
309 class Result : public SerializableArgument
310 {
311 public:
312  DAAL_NEW_DELETE();
313 
315  Result() {}
316 
321  Result(const size_t n) : SerializableArgument(n) {}
322 
323  virtual ~Result() {};
324 
328  virtual int getSerializationTag() const { return 0; }
329 
336  virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
337  {
338  return services::Status();
339  }
340 
347  virtual services::Status check(const PartialResult *partialResult, const Parameter *parameter, int method) const
348  {
349  return services::Status();
350  }
351 
352 
353 protected:
355  template<typename Archive, bool onDeserialize>
356  services::Status serialImpl(Archive *arch)
357  {
358  Argument::serialImpl<Archive, onDeserialize>(arch);
359 
360  return services::Status();
361  }
362  virtual services::Status serializeImpl(data_management::InputDataArchive *archive)
363  {
364  return services::Status();
365  }
366  virtual services::Status deserializeImpl(const data_management::OutputDataArchive *archive)
367  {
368  return services::Status();
369  }
370 };
371 
376 class DAAL_EXPORT OptionalArgument : public SerializableArgument
377 {
378 public:
379  DECLARE_SERIALIZABLE_TAG();
380 
382  OptionalArgument() : SerializableArgument(0) {}
383 
388  OptionalArgument(const size_t n) : SerializableArgument(n) {}
389 
395  const data_management::SerializationIfacePtr &get(size_t index) const { return SerializableArgument::get(index); }
396 
403  void set(size_t index, const data_management::SerializationIfacePtr &value) { return SerializableArgument::set(index, value); }
404 
405 protected:
407  template<typename Archive, bool onDeserialize>
408  services::Status serialImpl(Archive *arch)
409  {
410  Argument::serialImpl<Archive, onDeserialize>(arch);
411 
412  return services::Status();
413  }
414 
415  services::Status serializeImpl(data_management::InputDataArchive *arch) DAAL_C11_OVERRIDE
416  {
417  serialImpl<data_management::InputDataArchive, false>(arch);
418 
419  return services::Status();
420  }
421 
422  services::Status deserializeImpl(const data_management::OutputDataArchive *arch) DAAL_C11_OVERRIDE
423  {
424  serialImpl<const data_management::OutputDataArchive, true>(arch);
425 
426  return services::Status();
427  }
428 };
429 typedef services::SharedPtr<Input> InputPtr;
430 typedef services::SharedPtr<PartialResult> PartialResultPtr;
431 typedef services::SharedPtr<Result> ResultPtr;
432 typedef services::SharedPtr<OptionalArgument> OptionalArgumentPtr;
433 
435 } // namespace interface1
436 using interface1::Parameter;
437 using interface1::Argument;
438 using interface1::Input;
439 using interface1::InputPtr;
440 using interface1::PartialResult;
441 using interface1::PartialResultPtr;
442 using interface1::Result;
443 using interface1::ResultPtr;
444 using interface1::OptionalArgument;
445 using interface1::OptionalArgumentPtr;
446 
447 }
448 }
449 #endif
daal::algorithms::interface1::Result::Result
Result(const size_t n)
Definition: algorithm_types.h:321
daal::algorithms::interface1::Result::getSerializationTag
virtual int getSerializationTag() const
Definition: algorithm_types.h:328
daal::algorithms::interface1::PartialResult::check
virtual services::Status check(const Parameter *parameter, int method) const
Definition: algorithm_types.h:278
daal::algorithms::interface1::Argument
Base class to represent computation input and output arguments.
Definition: algorithm_types.h:76
daal::algorithms::interface1::OptionalArgument
Base class to represent argument with serialization methods
Definition: algorithm_types.h:376
daal::algorithms::interface1::Result::check
virtual services::Status check(const PartialResult *partialResult, const Parameter *parameter, int method) const
Definition: algorithm_types.h:347
daal::algorithms::interface1::PartialResult::check
virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
Definition: algorithm_types.h:268
daal::algorithms::interface1::Input::Input
Input(const size_t n)
Definition: algorithm_types.h:205
daal::algorithms::interface1::Result
Base class to represent final results of the computation. Algorithm-specific final results are repres...
Definition: algorithm_types.h:309
daal::algorithms::interface1::SerializableArgument::SerializableArgument
SerializableArgument()
Definition: algorithm_types.h:177
daal::algorithms::interface1::OptionalArgument::OptionalArgument
OptionalArgument()
Definition: algorithm_types.h:382
daal::algorithms::interface1::Argument::get
const data_management::SerializationIfacePtr & get(size_t index) const
daal::algorithms::interface1::Argument::set
void set(size_t index, const data_management::SerializationIfacePtr &value)
daal_defines.h
daal::algorithms::interface1::Input
Base class to represent computation input arguments. Algorithm-specific input arguments are represent...
Definition: algorithm_types.h:193
daal::algorithms::interface1::PartialResult::setInitFlag
void setInitFlag(bool flag)
Definition: algorithm_types.h:260
daal::algorithms::interface1::SerializableArgument
Base class to represent argument with serialization methods
Definition: algorithm_types.h:171
daal::algorithms::interface1::OptionalArgument::OptionalArgument
OptionalArgument(const size_t n)
Definition: algorithm_types.h:388
daal::algorithms::interface1::PartialResult::getInitFlag
bool getInitFlag()
Definition: algorithm_types.h:254
daal::algorithms::interface1::Parameter
Base class to represent computation parameters. Algorithm-specific parameters are represented as deri...
Definition: algorithm_types.h:62
daal::algorithms::interface1::Input::check
virtual services::Status check(const Parameter *parameter, int method) const
Definition: algorithm_types.h:214
daal::algorithms::interface1::PartialResult::PartialResult
PartialResult()
Definition: algorithm_types.h:235
daal::algorithms::interface1::OptionalArgument::set
void set(size_t index, const data_management::SerializationIfacePtr &value)
Definition: algorithm_types.h:403
daal::algorithms::interface1::Argument::size
size_t size() const
Definition: algorithm_types.h:107
daal::algorithms::interface1::Result::Result
Result()
Definition: algorithm_types.h:315
daal::algorithms::interface1::Input::Input
Input()
Definition: algorithm_types.h:199
daal::algorithms::interface1::Argument::Argument
Argument()
Definition: algorithm_types.h:82
daal::algorithms::interface1::Result::check
virtual services::Status check(const Input *input, const Parameter *parameter, int method) const
Definition: algorithm_types.h:336
daal::algorithms::interface1::Input::Input
Input(const Input &other)
Definition: algorithm_types.h:221
daal::algorithms::interface1::PartialResult::PartialResult
PartialResult(const size_t n)
Definition: algorithm_types.h:241
daal::algorithms::math::abs::value
Definition: abs_types.h:88
daal::algorithms::interface1::SerializableArgument::SerializableArgument
SerializableArgument(const size_t n)
Definition: algorithm_types.h:183
daal::algorithms::interface1::PartialResult::getSerializationTag
virtual int getSerializationTag() const
Definition: algorithm_types.h:248
daal::algorithms::interface1::PartialResult
Base class to represent partial results of the computation. Algorithm-specific partial results are re...
Definition: algorithm_types.h:229

For more complete information about compiler optimizations, see our Optimization Notice.