Device/Algorithms.h at master · SeisSol/Device · GitHub

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
// SPDX-FileCopyrightText: 2020 SeisSol Group
//
// SPDX-License-Identifier: BSD-3-Clause

#ifndef SEISSOLDEVICE_ALGORITHMS_H_
#define SEISSOLDEVICE_ALGORITHMS_H_

#include "AbstractAPI.h"

namespace device {
enum class ReductionType { Add, Max, Min };
class DeviceInstance;

class Algorithms {
  public:
  friend DeviceInstance;
  template <typename AccT, typename VecT>
  void reduceVector(AccT* result,
                    const VecT* buffer,
                    bool overrideResult,
                    size_t size,
                    ReductionType type,
                    void* streamPtr);

  template <typename T>
  void scaleArray(T* devArray, T scalar, size_t numElements, void* streamPtr);

  template <typename T>
  void fillArray(T* devArray, T scalar, size_t numElements, void* streamPtr);

  void incrementalAddI(
      void** out, void* base, size_t increment, size_t numElements, void* streamPtr);

  template <typename T>
  void incrementalAdd(T** out, T* base, size_t increment, size_t numElements, void* streamPtr) {
    incrementalAddI(reinterpret_cast<void**>(out),
                    reinterpret_cast<void*>(base),
                    increment * sizeof(T),
                    numElements,
                    streamPtr);
  }

  template <typename T>
  void setToValue(T** out, T value, size_t elementSize, size_t numElements, void* streamPtr);

  void touchMemoryI(void* ptr, size_t size, bool clean, void* streamPtr);

  template <typename T>
  void touchMemory(T* ptr, size_t size, bool clean, void* streamPtr) {
    touchMemoryI(reinterpret_cast<void*>(ptr), size * sizeof(T), clean, streamPtr);
  }

  void touchBatchedMemoryI(
      void** basePtr, size_t elementSize, size_t numElements, bool clean, void* streamPtr);

  template <typename T>
  void touchBatchedMemory(
      T** basePtr, size_t elementSize, size_t numElements, bool clean, void* streamPtr) {
    touchBatchedMemoryI(
        reinterpret_cast<void**>(basePtr), elementSize * sizeof(T), numElements, clean, streamPtr);
  }

  void streamBatchedDataI(const void** baseSrcPtr,
                          void** baseDstPtr,
                          size_t elementSize,
                          size_t numElements,
                          void* streamPtr);

  template <typename T>
  void streamBatchedData(const T** baseSrcPtr,
                         T** baseDstPtr,
                         size_t elementSize,
                         size_t numElements,
                         void* streamPtr) {
    streamBatchedDataI(reinterpret_cast<const void**>(baseSrcPtr),
                       reinterpret_cast<void**>(baseDstPtr),
                       elementSize * sizeof(T),
                       numElements,
                       streamPtr);
  }

  template <typename T>
  void accumulateBatchedData(const T** baseSrcPtr,
                             T** baseDstPtr,
                             size_t elementSize,
                             size_t numElements,
                             void* streamPtr);

  void copyUniformToScatterI(const void* src,
                             void** dst,
                             size_t srcOffset,
                             size_t copySize,
                             size_t numElements,
                             void* streamPtr);

  void copyScatterToUniformI(const void** src,
                             void* dst,
                             size_t dstOffset,
                             size_t copySize,
                             size_t numElements,
                             void* streamPtr);

  template <typename T>
  void copyUniformToScatter(const T* src,
                            T** dst,
                            size_t srcOffset,
                            size_t copySize,
                            size_t numElements,
                            void* streamPtr) {
    copyUniformToScatterI(reinterpret_cast<const void*>(src),
                          reinterpret_cast<void**>(dst),
                          srcOffset * sizeof(T),
                          copySize * sizeof(T),
                          numElements,
                          streamPtr);
  }

  template <typename T>
  void copyScatterToUniform(const T** src,
                            T* dst,
                            size_t dstOffset,
                            size_t copySize,
                            size_t numElements,
                            void* streamPtr) {
    copyScatterToUniformI(reinterpret_cast<const void**>(src),
                          reinterpret_cast<void*>(dst),
                          dstOffset * sizeof(T),
                          copySize * sizeof(T),
                          numElements,
                          streamPtr);
  }

  template <typename T>
  void compareDataWithHost(const T* hostPtr,
                           const T* devPtr,
                           size_t numElements,
                           const std::string& dataName);

  private:
  void setDeviceApi(AbstractAPI* configuredApi) { api = configuredApi; }
  AbstractAPI* api = nullptr;
};
} // namespace device

#endif // SEISSOLDEVICE_ALGORITHMS_H_