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
|
#include <gtest/gtest.h>
#include <sstream>
#include <c10/core/Device.h>
#include <torch/csrc/lazy/backend/backend_device.h>
#include <torch/csrc/lazy/ts_backend/ts_backend_impl.h>
#include <torch/torch.h>
namespace torch {
namespace lazy {
TEST(BackendDeviceTest, BackendDeviceType) {
auto type = BackendDeviceType();
EXPECT_EQ(type.type, 0);
EXPECT_STREQ(type.toString().c_str(), "Unknown");
}
TEST(BackendDeviceTest, Basic1) {
auto device = BackendDevice();
EXPECT_EQ(device.ordinal(), 0);
if (std::getenv("LTC_TS_CUDA") != nullptr) {
EXPECT_EQ(device.type(), 1);
EXPECT_STREQ(device.toString().c_str(), "CUDA0");
} else {
EXPECT_EQ(device.type(), 0);
EXPECT_STREQ(device.toString().c_str(), "CPU0");
}
}
TEST(BackendDeviceTest, Basic2) {
auto type = std::make_shared<BackendDeviceType>();
type->type = 1;
auto device = BackendDevice(std::move(type), 1);
EXPECT_EQ(device.type(), 1);
EXPECT_EQ(device.ordinal(), 1);
EXPECT_STREQ(device.toString().c_str(), "Unknown1");
}
TEST(BackendDeviceTest, Basic3) {
struct TestType : public BackendDeviceType {
std::string toString() const override {
return "Test";
}
};
auto device = BackendDevice(std::make_shared<TestType>(), 1);
EXPECT_EQ(device.type(), 0);
EXPECT_EQ(device.ordinal(), 1);
EXPECT_STREQ(device.toString().c_str(), "Test1");
}
TEST(BackendDeviceTest, Basic4) {
// Seems weird to have setters in BackendImplInterface given getBackend()
// returns a const pointer.
auto default_type = getBackend()->GetDefaultDeviceType();
auto default_ordinal = getBackend()->GetDefaultDeviceOrdinal();
const_cast<BackendImplInterface*>(getBackend())
->SetDefaultDeviceType(static_cast<int8_t>(c10::kCUDA));
const_cast<BackendImplInterface*>(getBackend())->SetDefaultDeviceOrdinal(1);
auto device = BackendDevice();
EXPECT_EQ(device.type(), 1);
EXPECT_EQ(device.ordinal(), 1);
EXPECT_STREQ(device.toString().c_str(), "CUDA1");
const_cast<BackendImplInterface*>(getBackend())
->SetDefaultDeviceType(default_type->type);
const_cast<BackendImplInterface*>(getBackend())
->SetDefaultDeviceOrdinal(default_ordinal);
}
TEST(BackendDeviceTest, Compare) {
auto type = std::make_shared<BackendDeviceType>();
type->type = 1;
auto device1 = BackendDevice(std::make_shared<BackendDeviceType>(), 1);
auto device2 = BackendDevice(std::move(type), 0);
auto device3 = BackendDevice(std::make_shared<BackendDeviceType>(), 2);
auto device4 = BackendDevice(std::make_shared<BackendDeviceType>(), 1);
EXPECT_NE(device1, device2);
EXPECT_NE(device1, device3);
EXPECT_EQ(device1, device4);
EXPECT_LT(device1, device2);
EXPECT_LT(device1, device3);
}
TEST(BackendDeviceTest, Ostream) {
auto device = BackendDevice();
std::stringstream ss;
ss << device;
EXPECT_EQ(device.toString(), ss.str());
}
TEST(BackendDeviceTest, FromAten) {
auto device = c10::Device(c10::kCPU);
EXPECT_THROW(atenDeviceToBackendDevice(device), c10::Error);
device = c10::Device(c10::kLazy);
#ifndef FBCODE_CAFFE2
auto backend_device = atenDeviceToBackendDevice(device);
#else
// Lazy Tensor is disabled in FBCODE until addressing non-virtual methods
// (e.g. sizes) in TensorImpl
EXPECT_THROW(atenDeviceToBackendDevice(device), c10::Error);
#endif // FBCODE_CAFFE2
}
TEST(BackendDeviceTest, ToAten) {
auto device = backendDeviceToAtenDevice(BackendDevice());
EXPECT_EQ(device.type(), c10::kLazy);
EXPECT_TRUE(device.has_index());
EXPECT_EQ(device.index(), 0);
}
// TODO(alanwaketan): Update the following test once we have TorchScript backend
// upstreamed.
TEST(BackendDeviceTest, GetBackendDevice1) {
auto tensor = torch::rand({0, 1, 3, 0});
EXPECT_FALSE(GetBackendDevice(tensor));
}
TEST(BackendDeviceTest, GetBackendDevice2) {
auto tensor1 = torch::rand({0, 1, 3, 0});
auto tensor2 = torch::rand({0, 1, 3, 0});
// TODO(alanwaketan): Cover the test case for GetBackendDevice().
EXPECT_FALSE(GetBackendDevice(tensor1, tensor2));
}
} // namespace lazy
} // namespace torch
|
