TinyInfiniTensor/src/core/tensor.cc at 7501db8e2fdf5ac027b02d62c1e6dfdfd81b5bdb · InfiniTensor/TinyInfiniTensor · 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
#include "core/tensor.h"
#include "core/blob.h"
#include "core/operator.h"
#include "core/runtime.h"
#include <cstring>
#include <numeric>

namespace infini {

    TensorObj::TensorObj(Shape shape_, DataType dtype, Runtime runtime)
        : dim(shape_.size()), dtype(dtype), runtime(runtime), shape(std::move(shape_)),
          _size(std::accumulate(shape.begin(), shape.end(), 1, std::multiplies{})) {}

    string TensorObj::toString() const
    {
        // Convert data pointer to string
        std::stringstream ss;
        if (data != nullptr)
            ss << data->getPtr<void *>();
        else
            ss << "nullptr data";
        string ret = "Tensor " + std::to_string(guid) + ", Fuid " +
                     std::to_string(fuid) + ", shape " + vecToString(shape) +
                     ", dtype " + dtype.toString() + ", " + runtime->toString() +
                     ", " + ss.str() + "\n";
        vector<UidBaseType> targetGuids;
        for (const auto &op : targets) {
            if (auto lockedOp = op.lock()) {
                targetGuids.emplace_back(lockedOp->getGuid());
            }
        }
        if (auto o = source.lock())
            ret += ", source " + std::to_string(o->getGuid());
        else
            ret += ", source None";
        ret += ", targets " + vecToString(targetGuids);
        return ret;
    }

void TensorObj::setShape(Shape shape_) {
    shape = shape_;
    size_t size = std::accumulate(shape.begin(), shape.end(), 1,
                                  [](auto acc, auto x) { return acc * x; });
    _size = size;
}

void TensorObj::printData() const {
    IT_ASSERT(data != nullptr);
    if (!runtime->isCpu())
        IT_TODO_HALT();

#define TRY_PRINT(N)                                                           \
    if (dtype == DataType(N))                                                  \
        std::cout << dataToString<DT<N>::t>() << std::endl;

    TRY_PRINT(0)           // fmt: new line
    else TRY_PRINT(1)      //
        else TRY_PRINT(2)  //
        else TRY_PRINT(3)  //
        else TRY_PRINT(4)  //
        else TRY_PRINT(5)  //
        else TRY_PRINT(6)  //
        else TRY_PRINT(7)  //
        else TRY_PRINT(8)  //
        else TRY_PRINT(9)  //
        else TRY_PRINT(10) //
        else TRY_PRINT(11) //
        else TRY_PRINT(12) //
        else TRY_PRINT(13) //
        else TRY_PRINT(16) //
        else IT_TODO_HALT();

#undef TRY_PRINT
}

bool TensorObj::equalData(const Tensor &rhs, double relativeError) const {
    IT_ASSERT(data != nullptr);
    IT_ASSERT(rhs->data != nullptr);
    IT_ASSERT(getDType() == rhs->getDType());
    IT_ASSERT(runtime->isCpu());
    IT_ASSERT(rhs->getRuntime()->isCpu());
    if (size() != rhs->size())
        return false;

#define TEST_EQUAL(N)                                                          \
    if (dtype == DataType(N))                                                  \
        return equalDataImpl(getRawDataPtr<DT<N>::t *>(),                      \
                             rhs->getRawDataPtr<DT<N>::t *>(), size(),         \
                             relativeError);

    TEST_EQUAL(0)           // fmt: new line
    else TEST_EQUAL(1)      //
        else TEST_EQUAL(2)  //
        else TEST_EQUAL(3)  //
        else TEST_EQUAL(4)  //
        else TEST_EQUAL(5)  //
        else TEST_EQUAL(6)  //
        else TEST_EQUAL(7)  //
        else TEST_EQUAL(8)  //
        else TEST_EQUAL(9)  //
        else TEST_EQUAL(10) //
        else TEST_EQUAL(11) //
        else TEST_EQUAL(12) //
        else TEST_EQUAL(13) //
        else TEST_EQUAL(16) //
        else IT_TODO_HALT();

#undef TEST_EQUAL
}

void TensorObj::setData(
    const std::function<void(void *, size_t, DataType)> &generator) const {
    IT_ASSERT(data != nullptr);
    generator(getRawDataPtr<void *>(), size(), dtype);
}

void TensorObj::setDataBlob(const Blob &blob) { this->data = blob; }

}; // namespace infini