binary.h 3.97 KB
Newer Older
1
2
3
#ifndef __INFINIOP_BINARY_H__
#define __INFINIOP_BINARY_H__

4
#include "../operator.h"
5
6
7
#include "../tensor.h"
#include <numeric>

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
/**
 * 该类的设计基于 matmul.h 中 YdrMaster 设计的 DESCRIPTOR 宏。
 */

#define BINARY_DESCRIPTOR(OP, NAMESPACE)                  \
                                                          \
    namespace op::OP::NAMESPACE {                         \
    class Descriptor final : public InfiniopDescriptor {  \
        struct Opaque;                                    \
        Opaque *_opaque;                                  \
        infiniDtype_t _dtype;                             \
        op::binary::BinaryInfo _info;                     \
                                                          \
        Descriptor(                                       \
            infiniDtype_t dtype,                          \
            op::binary::BinaryInfo info,                  \
            Opaque *opaque,                               \
            infiniDevice_t device_type,                   \
            int device_id)                                \
            : InfiniopDescriptor{device_type, device_id}, \
              _opaque(opaque),                            \
              _dtype(dtype),                              \
              _info(info) {}                              \
                                                          \
    public:                                               \
        ~Descriptor();                                    \
                                                          \
        static infiniStatus_t create(                     \
            infiniopHandle_t handle,                      \
            Descriptor **desc_ptr,                        \
            infiniopTensorDescriptor_t c_desc,            \
            infiniopTensorDescriptor_t a_desc,            \
            infiniopTensorDescriptor_t b_desc);           \
                                                          \
        infiniStatus_t calculate(                         \
            void *c,                                      \
            const void *a,                                \
            const void *b,                                \
            void *stream) const;                          \
    };                                                    \
    }

50
51
52
53
54
55
namespace op::binary {

// Stores metadata for binary operations on CPU
struct BinaryInfo {
    size_t c_data_size;
    size_t ndim;
56
    bool contiguous;
57
58
59
60
61
62
63
    bool broadcasted;
    std::vector<size_t> c_shape;
    std::vector<size_t> a_shape;
    std::vector<size_t> b_shape;
    std::vector<ptrdiff_t> c_strides;
    std::vector<ptrdiff_t> a_strides;
    std::vector<ptrdiff_t> b_strides;
64
};
65

66
67
68
69
inline infiniStatus_t createBinaryInfo(BinaryInfo &info,
                                       infiniopTensorDescriptor_t c_desc,
                                       infiniopTensorDescriptor_t a_desc,
                                       infiniopTensorDescriptor_t b_desc) {
70

71
72
    if (!c_desc || !a_desc || !b_desc) {
        return INFINI_STATUS_BAD_PARAM;
73
    }
74

75
    info.c_data_size = c_desc->numel();
76
77
78
79
    info.ndim = c_desc->ndim();
    info.contiguous = c_desc->isContiguous() && a_desc->isContiguous() && b_desc->isContiguous();

    // Destination cannot have broadcast setup
80
    if (c_desc->hasBroadcastDim()) {
81
82
83
        return INFINI_STATUS_BAD_TENSOR_STRIDES;
    }
    const bool ndim_match = (c_desc->ndim() == a_desc->ndim()) && (c_desc->ndim() == b_desc->ndim());
84
    info.broadcasted = !info.contiguous && (!ndim_match || a_desc->hasBroadcastDim() || b_desc->hasBroadcastDim());
85

86
87
88
89
90
91
    info.c_shape = std::move(c_desc->shape());
    info.a_shape = std::move(a_desc->shape());
    info.b_shape = std::move(b_desc->shape());
    info.c_strides = std::move(c_desc->strides());
    info.a_strides = std::move(a_desc->strides());
    info.b_strides = std::move(b_desc->strides());
92
93
94
95

    return INFINI_STATUS_SUCCESS;
}

96
97
98
} // namespace op::binary

#endif // __INFINIOP_BINARY_H__