Skip to content

Commit 6190625

Browse files
shoumikhinfacebook-github-bot
shoumikhin
authored and
facebook-github-bot
committed
Handle uint types.
Summary: . Differential Revision: D84516559
1 parent 9560800 commit 6190625

4 files changed

Lines changed: 166 additions & 4 deletions

File tree

‎extension/apple/ExecuTorch/Exported/ExecuTorchTensor.mm‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -271,7 +271,7 @@ - (NSString *)description {
271271
ET_CHECK_MSG(false, "Unsupported dtype in description");
272272
}
273273
} ctx;
274-
ET_SWITCH_REALHBBF16_TYPES(
274+
ET_SWITCH_REALHBBF16_AND_UINT_TYPES(
275275
static_cast<ScalarType>(_tensor->scalar_type()),
276276
ctx,
277277
"description",

‎extension/tensor/tensor_ptr.h‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -123,7 +123,7 @@ inline TensorPtr make_tensor_ptr(
123123
}
124124
} ctx;
125125

126-
ET_SWITCH_REALHBBF16_TYPES(type, ctx, "make_tensor_ptr", CTYPE, [&] {
126+
ET_SWITCH_REALHBBF16_AND_UINT_TYPES(type, ctx, "make_tensor_ptr", CTYPE, [&] {
127127
std::transform(
128128
data.begin(),
129129
data.end(),

‎extension/tensor/tensor_ptr_maker.cpp‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -96,7 +96,7 @@ TensorPtr random_strided(
9696
}
9797
} ctx;
9898

99-
ET_SWITCH_REALHBBF16_TYPES(type, ctx, "random_strided", CTYPE, [&] {
99+
ET_SWITCH_REALHBBF16_AND_UINT_TYPES(type, ctx, "random_strided", CTYPE, [&] {
100100
std::generate_n(tensor->mutable_data_ptr<CTYPE>(), tensor->numel(), [&]() {
101101
return static_cast<CTYPE>(distribution(gen));
102102
});
@@ -138,7 +138,7 @@ TensorPtr full_strided(
138138
}
139139
} ctx;
140140

141-
ET_SWITCH_REALHBBF16_TYPES(type, ctx, "full_strided", CTYPE, [&] {
141+
ET_SWITCH_REALHBBF16_AND_UINT_TYPES(type, ctx, "full_strided", CTYPE, [&] {
142142
CTYPE value;
143143
ET_EXTRACT_SCALAR(fill_value, value);
144144
std::fill(

‎extension/tensor/test/tensor_ptr_test.cpp‎

Lines changed: 162 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1073,3 +1073,165 @@ TEST_F(TensorPtrTest, TensorDataCastingInvalidCast) {
10731073
},
10741074
"");
10751075
}
1076+
1077+
TEST_F(TensorPtrTest, TensorDataOnlyUInt16Type) {
1078+
std::vector<uint16_t> data = {1u, 65535u, 42u, 0u};
1079+
auto tensor = make_tensor_ptr(std::move(data));
1080+
EXPECT_EQ(tensor->dim(), 1);
1081+
EXPECT_EQ(tensor->size(0), 4);
1082+
EXPECT_EQ(tensor->strides()[0], 1);
1083+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt16);
1084+
auto ptr = tensor->const_data_ptr<uint16_t>();
1085+
EXPECT_EQ(ptr[0], 1u);
1086+
EXPECT_EQ(ptr[1], 65535u);
1087+
EXPECT_EQ(ptr[2], 42u);
1088+
EXPECT_EQ(ptr[3], 0u);
1089+
}
1090+
1091+
TEST_F(TensorPtrTest, TensorDataOnlyUInt32Type) {
1092+
std::vector<uint32_t> data = {0u, 123u, 4000000000u};
1093+
auto tensor = make_tensor_ptr(std::move(data));
1094+
EXPECT_EQ(tensor->dim(), 1);
1095+
EXPECT_EQ(tensor->size(0), 3);
1096+
EXPECT_EQ(tensor->strides()[0], 1);
1097+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt32);
1098+
auto ptr = tensor->const_data_ptr<uint32_t>();
1099+
EXPECT_EQ(ptr[0], 0u);
1100+
EXPECT_EQ(ptr[1], 123u);
1101+
EXPECT_EQ(ptr[2], 4000000000u);
1102+
}
1103+
1104+
TEST_F(TensorPtrTest, TensorDataOnlyUInt64Type) {
1105+
std::vector<uint64_t> data = {0ull, 1ull, 9000000000000000000ull};
1106+
auto tensor = make_tensor_ptr(std::move(data));
1107+
EXPECT_EQ(tensor->dim(), 1);
1108+
EXPECT_EQ(tensor->size(0), 3);
1109+
EXPECT_EQ(tensor->strides()[0], 1);
1110+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt64);
1111+
auto ptr = tensor->const_data_ptr<uint64_t>();
1112+
EXPECT_EQ(ptr[0], 0ull);
1113+
EXPECT_EQ(ptr[1], 1ull);
1114+
EXPECT_EQ(ptr[2], 9000000000000000000ull);
1115+
}
1116+
1117+
TEST_F(TensorPtrTest, TensorUint8dataUInt32Type) {
1118+
std::vector<uint32_t> values = {1u, 4000000000u, 123u};
1119+
const auto* bytes = reinterpret_cast<const uint8_t*>(values.data());
1120+
std::vector<uint8_t> raw(bytes, bytes + values.size() * sizeof(uint32_t));
1121+
auto tensor = make_tensor_ptr(
1122+
{3}, std::move(raw), executorch::aten::ScalarType::UInt32);
1123+
EXPECT_EQ(tensor->dim(), 1);
1124+
EXPECT_EQ(tensor->size(0), 3);
1125+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt32);
1126+
auto ptr = tensor->const_data_ptr<uint32_t>();
1127+
EXPECT_EQ(ptr[0], 1u);
1128+
EXPECT_EQ(ptr[1], 4000000000u);
1129+
EXPECT_EQ(ptr[2], 123u);
1130+
}
1131+
1132+
TEST_F(TensorPtrTest, TensorUint8dataUInt64Type) {
1133+
std::vector<uint64_t> values = {0ull, 42ull, 9000000000000000000ull};
1134+
const auto* bytes = reinterpret_cast<const uint8_t*>(values.data());
1135+
std::vector<uint8_t> raw(bytes, bytes + values.size() * sizeof(uint64_t));
1136+
auto tensor = make_tensor_ptr(
1137+
{3}, std::move(raw), executorch::aten::ScalarType::UInt64);
1138+
EXPECT_EQ(tensor->dim(), 1);
1139+
EXPECT_EQ(tensor->size(0), 3);
1140+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt64);
1141+
auto ptr = tensor->const_data_ptr<uint64_t>();
1142+
EXPECT_EQ(ptr[0], 0ull);
1143+
EXPECT_EQ(ptr[1], 42ull);
1144+
EXPECT_EQ(ptr[2], 9000000000000000000ull);
1145+
}
1146+
1147+
TEST_F(TensorPtrTest, TensorUint8dataSizeMismatchUInt32ExpectDeath) {
1148+
std::vector<uint8_t> data(3 * executorch::aten::elementSize(
1149+
executorch::aten::ScalarType::UInt32) - 1);
1150+
ET_EXPECT_DEATH(
1151+
{ auto _ = make_tensor_ptr({3}, std::move(data)); }, "");
1152+
}
1153+
1154+
TEST_F(TensorPtrTest, TensorUint8dataSizeMismatchUInt64ExpectDeath) {
1155+
std::vector<uint8_t> data(2 * executorch::aten::elementSize(
1156+
executorch::aten::ScalarType::UInt64) + 1);
1157+
ET_EXPECT_DEATH(
1158+
{ auto _ = make_tensor_ptr({2}, std::move(data)); }, "");
1159+
}
1160+
1161+
TEST_F(TensorPtrTest, TensorDataCastingFromInt32ToUInt16) {
1162+
std::vector<int32_t> data = {-1, 65535, 65536, -65536};
1163+
auto tensor = make_tensor_ptr(
1164+
std::move(data), executorch::aten::ScalarType::UInt16);
1165+
EXPECT_EQ(tensor->dim(), 1);
1166+
EXPECT_EQ(tensor->size(0), 4);
1167+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt16);
1168+
auto ptr = tensor->const_data_ptr<uint16_t>();
1169+
EXPECT_EQ(ptr[0], static_cast<uint16_t>(-1));
1170+
EXPECT_EQ(ptr[1], static_cast<uint16_t>(65535));
1171+
EXPECT_EQ(ptr[2], static_cast<uint16_t>(65536));
1172+
EXPECT_EQ(ptr[3], static_cast<uint16_t>(-65536));
1173+
}
1174+
1175+
TEST_F(TensorPtrTest, TensorDataCastingFromUInt32ToFloat) {
1176+
std::vector<uint32_t> data = {0u, 123u, 4000000000u};
1177+
auto tensor =
1178+
make_tensor_ptr(std::move(data), executorch::aten::ScalarType::Float);
1179+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::Float);
1180+
auto ptr = tensor->const_data_ptr<float>();
1181+
EXPECT_FLOAT_EQ(ptr[0], 0.0f);
1182+
EXPECT_FLOAT_EQ(ptr[1], 123.0f);
1183+
EXPECT_FLOAT_EQ(ptr[2], 4000000000.0f);
1184+
}
1185+
1186+
TEST_F(TensorPtrTest, TensorDataCastingFromFloatToUInt32) {
1187+
std::vector<float> data = {1.0f, 2.0f};
1188+
auto tensor =
1189+
make_tensor_ptr(std::move(data), executorch::aten::ScalarType::UInt32);
1190+
1191+
EXPECT_EQ(tensor->dim(), 1);
1192+
EXPECT_EQ(tensor->size(0), 2);
1193+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt32);
1194+
1195+
auto ptr = tensor->const_data_ptr<uint32_t>();
1196+
EXPECT_EQ(ptr[0], 1u);
1197+
EXPECT_EQ(ptr[1], 2u);
1198+
}
1199+
1200+
TEST_F(TensorPtrTest, MakeTensorPtrFromExistingTensorUInt32) {
1201+
std::vector<uint32_t> data = {10u, 20u, 30u, 40u};
1202+
auto tensor = make_tensor_ptr({2, 2}, data);
1203+
auto alias = make_tensor_ptr(tensor);
1204+
EXPECT_EQ(alias->dim(), 2);
1205+
EXPECT_EQ(alias->size(0), 2);
1206+
EXPECT_EQ(alias->size(1), 2);
1207+
EXPECT_EQ(alias->scalar_type(), executorch::aten::ScalarType::UInt32);
1208+
EXPECT_EQ(alias->const_data_ptr<uint32_t>(), tensor->const_data_ptr<uint32_t>());
1209+
}
1210+
1211+
TEST_F(TensorPtrTest, CloneTensorPtrFromExistingTensorUInt32) {
1212+
std::vector<uint32_t> data = {10u, 20u, 30u, 40u};
1213+
auto tensor = make_tensor_ptr({2, 2}, std::move(data));
1214+
auto cloned = clone_tensor_ptr(tensor);
1215+
EXPECT_EQ(cloned->dim(), 2);
1216+
EXPECT_EQ(cloned->size(0), 2);
1217+
EXPECT_EQ(cloned->size(1), 2);
1218+
EXPECT_EQ(cloned->scalar_type(), executorch::aten::ScalarType::UInt32);
1219+
EXPECT_NE(cloned->const_data_ptr<uint32_t>(), tensor->const_data_ptr<uint32_t>());
1220+
auto ptr = cloned->const_data_ptr<uint32_t>();
1221+
EXPECT_EQ(ptr[0], 10u);
1222+
EXPECT_EQ(ptr[3], 40u);
1223+
}
1224+
1225+
TEST_F(TensorPtrTest, Tensor2DUInt16OwningData) {
1226+
std::vector<uint16_t> data = {1u, 2u, 3u, 4u, 5u, 6u};
1227+
auto tensor = make_tensor_ptr({2, 3}, std::move(data));
1228+
EXPECT_EQ(tensor->dim(), 2);
1229+
EXPECT_EQ(tensor->size(0), 2);
1230+
EXPECT_EQ(tensor->size(1), 3);
1231+
EXPECT_EQ(tensor->strides()[0], 3);
1232+
EXPECT_EQ(tensor->strides()[1], 1);
1233+
EXPECT_EQ(tensor->scalar_type(), executorch::aten::ScalarType::UInt16);
1234+
auto ptr = tensor->const_data_ptr<uint16_t>();
1235+
EXPECT_EQ(ptr[0], 1u);
1236+
EXPECT_EQ(ptr[5], 6u);
1237+
}

0 commit comments

Comments
 (0)