Star787
689
代码
代码
Issues186
Pull Requests205
Actions
项目讨论
Wiki
分析
Star787
689
已合并
fix(Operation): modify cosh arch35 impl #5364
chenbl创建于 11 天前
fix(Operation): modify cosh arch35 impl #5364
已合并
chenbl创建于 11 天前
从chenbl/pypto_newfix/cosh合入到cann/pyptomaster
共 22 个文件变更+4822-3909
Mdocs/zh/api/operation/pypto-bitwise_and.md+3-13
@@ -30,8 +30,8 @@ bitwise_and(input: Tensor, other: Union[Tensor, int]) -> Tensor
30 30 
31| 参数名 | 输入/输出 | 说明 |31| 参数名 | 输入/输出 | 说明 |
32|---------|-----------|----------------------------------------------------------------------|32|---------|-----------|----------------------------------------------------------------------|
33-| input | 输入 | 源操作数。<br>支持的类型为：Tensor。不同型号支持的数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |33+| input | 输入 | 源操作数。<br>支持的类型为：Tensor。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
34-| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。不同型号支持的数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |34+| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
35 35 
36## 返回值说明36## 返回值说明
37 37 
@@ -40,17 +40,7 @@ bitwise_and(input: Tensor, other: Union[Tensor, int]) -> Tensor
40## 约束说明40## 约束说明
41 41 
421. input和other都为Tensor时，数据类型应该相同。421. input和other都为Tensor时，数据类型应该相同。
43-2. Tensor数据类型说明：43+2. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
44- <!-- npu="950" id4 -->
45- - Ascend 950PR/Ascend 950DT：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_INT32
46- <!-- end id4 -->
47- <!-- npu="A3" id5 -->
48- - Atlas A3 训练系列产品/Atlas A3 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
49- <!-- end id5 -->
50- <!-- npu="910b" id6 -->
51- - Atlas A2 训练系列产品/Atlas A2 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
52- <!-- end id6 -->
53-3. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
54 44 
55## 调用示例45## 调用示例
56 46 
Mdocs/zh/api/operation/pypto-bitwise_not.md+2-12
@@ -30,7 +30,7 @@ bitwise_not(input: Tensor) -> Tensor
30 30 
31| 参数名 | 输入/输出 | 说明 |31| 参数名 | 输入/输出 | 说明 |
32|---------|-----------|----------------------------------------------------------------------|32|---------|-----------|----------------------------------------------------------------------|
33-| input | 输入 | 源操作数。<br>支持的类型为：Tensor。不同型号支持的Tensor数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维；Shape Size不大于2147483647（即INT32_MAX）。 |33+| input | 输入 | 源操作数。<br>支持的类型为：Tensor。Tensor支持的数据类型为：DT_BOOL，DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维；Shape Size不大于2147483647（即INT32_MAX）。 |
34 34 
35## 返回值说明35## 返回值说明
36 36 
@@ -38,17 +38,7 @@ bitwise_not(input: Tensor) -> Tensor
38 38 
39## 约束说明39## 约束说明
40 40 
41-1. Tensor数据类型说明：41+1. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
42- <!-- npu="950" id4 -->
43- - Ascend 950PR/Ascend 950DT：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_INT32，DT_BOOL
44- <!-- end id4 -->
45- <!-- npu="A3" id5 -->
46- - Atlas A3 训练系列产品/Atlas A3 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_BOOL
47- <!-- end id5 -->
48- <!-- npu="910b" id6 -->
49- - Atlas A2 训练系列产品/Atlas A2 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_BOOL
50- <!-- end id6 -->
51-2. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
52 42 
53## 调用示例43## 调用示例
54 44 
Mdocs/zh/api/operation/pypto-bitwise_or.md+3-13
@@ -30,8 +30,8 @@ bitwise_or(input: Tensor, other: Union[Tensor, int]) -> Tensor
30 30 
31| 参数名 | 输入/输出 | 说明 |31| 参数名 | 输入/输出 | 说明 |
32|---------|-----------|----------------------------------------------------------------------|32|---------|-----------|----------------------------------------------------------------------|
33-| input | 输入 | 源操作数。<br>支持的类型为：Tensor。不同型号支持的数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |33+| input | 输入 | 源操作数。<br>支持的类型为：Tensor。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
34-| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。不同型号支持的数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |34+| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
35 35 
36## 返回值说明36## 返回值说明
37 37 
@@ -40,17 +40,7 @@ bitwise_or(input: Tensor, other: Union[Tensor, int]) -> Tensor
40## 约束说明40## 约束说明
41 41 
421. input和other都为Tensor时，数据类型应该相同。421. input和other都为Tensor时，数据类型应该相同。
43-2. Tensor数据类型说明：43+2. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
44- <!-- npu="950" id4 -->
45- - Ascend 950PR/Ascend 950DT：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_INT32
46- <!-- end id4 -->
47- <!-- npu="A3" id5 -->
48- - Atlas A3 训练系列产品/Atlas A3 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
49- <!-- end id5 -->
50- <!-- npu="910b" id6 -->
51- - Atlas A2 训练系列产品/Atlas A2 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
52- <!-- end id6 -->
53-3. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
54 44 
55## 调用示例45## 调用示例
56 46 
Mdocs/zh/api/operation/pypto-bitwise_xor.md+3-13
@@ -30,8 +30,8 @@ bitwise_xor(input: Tensor, other: Union[Tensor, int]) -> Tensor
30 30 
31| 参数名 | 输入/输出 | 说明 |31| 参数名 | 输入/输出 | 说明 |
32|---------|-----------|----------------------------------------------------------------------|32|---------|-----------|----------------------------------------------------------------------|
33-| input | 输入 | 源操作数。<br>支持的类型为：Tensor。不同型号支持的数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |33+| input | 输入 | 源操作数。<br>支持的类型为：Tensor。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
34-| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。不同型号支持的Tensor数据类型有所差异，详细请参见[约束说明](#约束说明)。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |34+| other | 输入 | 源操作数。<br>支持的类型为int以及Tensor类型。<br>Tensor支持的数据类型为：DT_INT8，DT_UINT8，DT_INT16，DT_UINT16，DT_INT32，DT_UINT32。<br>不支持空Tensor；Shape仅支持1-4维，支持多维度广播到相同形状；Shape Size不大于2147483647（即INT32_MAX）。 |
35 35 
36## 返回值说明36## 返回值说明
37 37 
@@ -41,17 +41,7 @@ bitwise_xor(input: Tensor, other: Union[Tensor, int]) -> Tensor
41 41 
421. input和other都为Tensor时，数据类型应该相同。421. input和other都为Tensor时，数据类型应该相同。
432. 由于存在临时内存使用，TileShape大小有额外约束，假设TileShape为\[a,b,c,d\]，那么a\*b\*c\*d\*sizeof\(input\) + a\*b\*c\*d\*sizeof\(other\) + a\*b\*c\*d\*sizeof\(input\) < UB。432. 由于存在临时内存使用，TileShape大小有额外约束，假设TileShape为\[a,b,c,d\]，那么a\*b\*c\*d\*sizeof\(input\) + a\*b\*c\*d\*sizeof\(other\) + a\*b\*c\*d\*sizeof\(input\) < UB。
44-3. Tensor数据类型说明：44+3. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
45- <!-- npu="950" id4 -->
46- - Ascend 950PR/Ascend 950DT：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8，DT_INT32
47- <!-- end id4 -->
48- <!-- npu="A3" id5 -->
49- - Atlas A3 训练系列产品/Atlas A3 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
50- <!-- end id5 -->
51- <!-- npu="910b" id6 -->
52- - Atlas A2 训练系列产品/Atlas A2 推理系列产品：DT_INT16，DT_UINT16，DT_INT8，DT_UINT8
53- <!-- end id6 -->
54-4. Tensor类型输入不支持`TileOpFormat.TILEOP_NZ`格式。
55 45 
56## 调用示例46## 调用示例
57 47 
Mframework/src/interface/operation/vector/binary.cpp+18-24
@@ -531,10 +531,9 @@ Tensor BitwiseAnd(const Tensor& self, const Tensor& other)
531 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseAnd");531 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseAnd");
532 532 
533 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEAND");533 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEAND");
534- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};534+ static const std::unordered_set<DataType> BITWISE_AND_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
535- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};535+ DT_UINT16, DT_INT32, DT_UINT32};
536- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);536+ CheckTensorDataType(self.GetStorage(), BITWISE_AND_TYPES, "BITWISEAND");
537- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEAND");
538 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEAND>, *Program::GetInstance().GetCurrentFunction(), self, other);537 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEAND>, *Program::GetInstance().GetCurrentFunction(), self, other);
539}538}
540 539 
@@ -545,10 +544,9 @@ Tensor BitwiseOr(const Tensor& self, const Tensor& other)
545 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseOr");544 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseOr");
546 545 
547 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEOR");546 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEOR");
548- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};547+ static const std::unordered_set<DataType> BITWISE_OR_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
549- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};548+ DT_UINT16, DT_INT32, DT_UINT32};
550- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);549+ CheckTensorDataType(self.GetStorage(), BITWISE_OR_TYPES, "BITWISEOR");
551- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEOR");
552 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEOR>, *Program::GetInstance().GetCurrentFunction(), self, other);550 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEOR>, *Program::GetInstance().GetCurrentFunction(), self, other);
553}551}
554 552 
@@ -559,10 +557,9 @@ Tensor BitwiseXor(const Tensor& self, const Tensor& other)
559 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseXor");557 CheckTensorFormat(other.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseXor");
560 558 
561 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEXOR");559 CheckTensorsDataTypeConsistency(self.GetStorage(), other.GetStorage(), "BITWISEXOR");
562- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};560+ static const std::unordered_set<DataType> BITWISE_XOR_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
563- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};561+ DT_UINT16, DT_INT32, DT_UINT32};
564- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);562+ CheckTensorDataType(self.GetStorage(), BITWISE_XOR_TYPES, "BITWISEXOR");
565- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEXOR");
566 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEXOR>, *Program::GetInstance().GetCurrentFunction(), self, other);563 RETURN_CALL(BinaryOperation<BinaryOpType::BITWISEXOR>, *Program::GetInstance().GetCurrentFunction(), self, other);
567}564}
568 565 
@@ -1083,10 +1080,9 @@ Tensor BitwiseAnd(const Tensor& self, const Element& other)
1083 DECLARE_TRACER();1080 DECLARE_TRACER();
1084 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseAnd");1081 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseAnd");
1085 1082 
1086- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};1083+ static const std::unordered_set<DataType> BITWISE_AND_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
1087- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};1084+ DT_UINT16, DT_INT32, DT_UINT32};
1088- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);1085+ CheckTensorDataType(self.GetStorage(), BITWISE_AND_TYPES, "BITWISEAND");
1089- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEAND");
1090 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEAND>, *Program::GetInstance().GetCurrentFunction(),1086 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEAND>, *Program::GetInstance().GetCurrentFunction(),
1091 self.GetStorage(), other);1087 self.GetStorage(), other);
1092}1088}
@@ -1096,10 +1092,9 @@ Tensor BitwiseOr(const Tensor& self, const Element& other)
1096 DECLARE_TRACER();1092 DECLARE_TRACER();
1097 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseOr");1093 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseOr");
1098 1094 
1099- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};1095+ static const std::unordered_set<DataType> BITWISE_OR_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
1100- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};1096+ DT_UINT16, DT_INT32, DT_UINT32};
1101- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);1097+ CheckTensorDataType(self.GetStorage(), BITWISE_OR_TYPES, "BITWISEOR");
1102- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEOR");
1103 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEOR>, *Program::GetInstance().GetCurrentFunction(),1098 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEOR>, *Program::GetInstance().GetCurrentFunction(),
1104 self.GetStorage(), other);1099 self.GetStorage(), other);
1105}1100}
@@ -1109,10 +1104,9 @@ Tensor BitwiseXor(const Tensor& self, const Element& other)
1109 DECLARE_TRACER();1104 DECLARE_TRACER();
1110 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseXor");1105 CheckTensorFormat(self.GetStorage(), {TileOpFormat::TILEOP_NZ}, "BitwiseXor");
1111 1106 
1112- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};1107+ static const std::unordered_set<DataType> BITWISE_XOR_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
1113- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};1108+ DT_UINT16, DT_INT32, DT_UINT32};
1114- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);1109+ CheckTensorDataType(self.GetStorage(), BITWISE_XOR_TYPES, "BITWISEXOR");
1115- CheckTensorDataType(self.GetStorage(), supportedTypes, "BITWISEXOR");
1116 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEXOR>, *Program::GetInstance().GetCurrentFunction(),1110 RETURN_CALL(BinaryOperationScalar<BinaryOpType::BITWISEXOR>, *Program::GetInstance().GetCurrentFunction(),
1117 self.GetStorage(), other);1111 self.GetStorage(), other);
1118}1112}
Mframework/src/interface/operation/vector/unary.cpp+5-5
@@ -285,10 +285,9 @@ Tensor BitwiseNot(const Tensor& self)
285 if (self.GetDataType() == DT_BOOL) {285 if (self.GetDataType() == DT_BOOL) {
286 return LogicalNot(self);286 return LogicalNot(self);
287 }287 }
288- static const std::unordered_set<DataType> BITWISE_A2A3_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8};288+ static const std::unordered_set<DataType> BITWISE_NOT_TYPES = {DT_INT8, DT_UINT8, DT_INT16,
289- static const std::unordered_set<DataType> BITWISE_A5_TYPES = {DT_INT16, DT_UINT16, DT_INT8, DT_UINT8, DT_INT32};289+ DT_UINT16, DT_INT32, DT_UINT32};
290- const auto& supportedTypes = GetSupportedDataTypesByArch(BITWISE_A2A3_TYPES, BITWISE_A5_TYPES);290+ CheckTensorDataType(self.GetStorage(), BITWISE_NOT_TYPES, "BitwiseNot");
291- CheckTensorDataType(self.GetStorage(), supportedTypes, "BitwiseNot");
292 RETURN_CALL(UnaryOperation<UnaryOpType::BITWISENOT>, *Program::GetInstance().GetCurrentFunction(),291 RETURN_CALL(UnaryOperation<UnaryOpType::BITWISENOT>, *Program::GetInstance().GetCurrentFunction(),
293 self.GetStorage());292 self.GetStorage());
294}293}
@@ -909,7 +908,8 @@ REGISTER_OPERATION_TILED_FUNC(OP_ISNAN, Opcode::OP_ISNAN, IsNanOperationTileFunc
909REGISTER_OPERATION_TILED_FUNC(OP_HUB, Opcode::OP_HUB, HubOperationTileFunc);908REGISTER_OPERATION_TILED_FUNC(OP_HUB, Opcode::OP_HUB, HubOperationTileFunc);
910REGISTER_OPERATION_TILED_FUNC(OP_SINH, Opcode::OP_SINH,909REGISTER_OPERATION_TILED_FUNC(OP_SINH, Opcode::OP_SINH,
911 (Fp32AlignedTmpUnaryOperationTileFunc<UnaryOpType::SINH, NUM_VALUE_4>));910 (Fp32AlignedTmpUnaryOperationTileFunc<UnaryOpType::SINH, NUM_VALUE_4>));
912-REGISTER_OPERATION_TILED_FUNC(OP_COSH, Opcode::OP_COSH, (Fp32AlignedTmpUnaryOperationTileFunc<UnaryOpType::COSH, 1>));911+REGISTER_OPERATION_TILED_FUNC(OP_COSH, Opcode::OP_COSH,
912+ (Fp32AlignedTmpUnaryOperationTileFunc<UnaryOpType::COSH, NUM_VALUE_3>));
913REGISTER_OPERATION_TILED_FUNC(OP_ATANH, Opcode::OP_ATANH, AtanhOperationTileFunc);913REGISTER_OPERATION_TILED_FUNC(OP_ATANH, Opcode::OP_ATANH, AtanhOperationTileFunc);
914REGISTER_OPERATION_TILED_FUNC(OP_ERF, Opcode::OP_ERF, ErfOperationTileFunc);914REGISTER_OPERATION_TILED_FUNC(OP_ERF, Opcode::OP_ERF, ErfOperationTileFunc);
915REGISTER_OPERATION_TILED_FUNC(OP_PACK, Opcode::OP_PACK, PackOperationTileFunc);915REGISTER_OPERATION_TILED_FUNC(OP_PACK, Opcode::OP_PACK, PackOperationTileFunc);
Mframework/src/interface/tileop/vector/unary.h+131-36
@@ -20,6 +20,7 @@
20#include "utils/tile_tensor.h"20#include "utils/tile_tensor.h"
21 21 
22#include <cmath>22#include <cmath>
23+#include <limits>
23 24 
24TILEOP void SyncV()25TILEOP void SyncV()
25{26{
@@ -868,6 +869,86 @@ TILEOP void TSinh(T0 dst, T1 src, T2 tmp)
868 }869 }
869}870}
870 871 
872+#ifdef __DAV_V220
873+template <typename T0, typename T1, typename T2>
874+TILEOP void TCoshCompute(T0 dstTile, T1 srcTile, T2 tmpTile)
875+{
876+ constexpr float SCALAR_ZERO_POINT_FIVE = 0.5f;
877+ constexpr float SCALAR_NEGATIVE_ONE_POINT_FIVE = -1.5f;
878+ 
879+ // cosh(x) = 0.5 * (exp(x / 2) + exp(-3 * x / 2)) * exp(x / 2)
880+ pto::TABS(tmpTile, srcTile);
881+ SyncV();
882+ pto::TMULS(dstTile, tmpTile, SCALAR_NEGATIVE_ONE_POINT_FIVE);
883+ SyncV();
884+ pto::TMULS(tmpTile, tmpTile, SCALAR_ZERO_POINT_FIVE);
885+ SyncV();
886+ pto::TEXP<pto::ExpAlgorithm::HIGH_PRECISION>(tmpTile, tmpTile);
887+ SyncV();
888+ pto::TEXP<pto::ExpAlgorithm::HIGH_PRECISION>(dstTile, dstTile);
889+ SyncV();
890+ pto::TADD(dstTile, dstTile, tmpTile);
891+ SyncV();
892+ pto::TMULS(dstTile, dstTile, SCALAR_ZERO_POINT_FIVE);
893+ SyncV();
894+ pto::TMUL(dstTile, dstTile, tmpTile);
895+ SyncV();
896+}
897+#else
898+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
899+TILEOP void TCoshCompute(T0 dstTile, T1 srcTile, T2 tmp0Tile, T3 tmp1Tile, T4 tmp2Tile, T5 tmp0IntTile, T6 tmp2MaskTile)
900+{
901+ constexpr float kLog2e = 1.442695041f;
902+ constexpr float kNegLn2Hi = -0.6931471825f;
903+ constexpr float kLn2Lo = 1.9046542e-9f;
904+ constexpr float kExpMagic = 12583037.0f;
905+ constexpr int32_t kFp32MantissaBits = 23;
906+ constexpr float kNClamp = 126.0f;
907+ constexpr float kHalfInv8 = 0.125f;
908+ constexpr float kTwo = 2.0f;
909+ constexpr float kOvfThreshold = 90.0f;
910+ constexpr float kInf = std::numeric_limits<float>::infinity();
911+ 
912+ // ax = abs(x), temporarily stored in dstTile.
913+ pto::TABS(dstTile, srcTile);
914+ // n = trunc(ax * log2(e))
915+ pto::TMULS(tmp0Tile, dstTile, kLog2e);
916+ pto::TCVT(tmp0Tile, tmp0Tile, pto::RoundMode::CAST_TRUNC);
917+ // n = min(n, 126)
918+ pto::TMINS(tmp0Tile, tmp0Tile, kNClamp);
919+ // r = ax
920+ pto::TADDS(tmp1Tile, dstTile, 0.0f);
921+ // r += n * (-ln2_hi)
922+ pto::TMULS(tmp2Tile, tmp0Tile, 0.0f);
923+ pto::TADDS(tmp2Tile, tmp2Tile, kNegLn2Hi);
924+ pto::TMULADDDST(tmp1Tile, tmp0Tile, tmp2Tile);
925+ // r += n * (+ln2_lo)
926+ pto::TMULS(tmp2Tile, tmp2Tile, 0.0f);
927+ pto::TADDS(tmp2Tile, tmp2Tile, kLn2Lo);
928+ pto::TMULADDDST(tmp1Tile, tmp0Tile, tmp2Tile);
929+ // p2 = 2^(n - 2)
930+ pto::TADDS(tmp0Tile, tmp0Tile, kExpMagic);
931+ pto::TSHLS(tmp0IntTile, tmp0IntTile, kFp32MantissaBits);
932+ // er = exp(r) * p2 = exp(ax) / 4
933+ pto::TEXP(tmp1Tile, tmp1Tile);
934+ pto::TMUL(tmp1Tile, tmp1Tile, tmp0Tile);
935+ // Generate the overflow mask before overwriting ax in dstTile.
936+ // NaN >= 90 is false, so the naturally computed NaN is preserved.
937+ pto::TCMPS(tmp2MaskTile, dstTile, kOvfThreshold, pto::CmpMode::GE);
938+ // dst = 0.125 / er
939+ pto::TRECIP(dstTile, tmp1Tile);
940+ pto::TMULS(dstTile, dstTile, kHalfInv8);
941+ // tmp0 = 2 * er
942+ pto::TMULS(tmp0Tile, tmp1Tile, kTwo);
943+ // dst = 2 * er + 0.125 / er
944+ pto::TADD(dstTile, tmp0Tile, dstTile);
945+ pto::TADDS(tmp0Tile, tmp0Tile, kInf);
946+ // Select +inf on overflow; otherwise preserve the regular result.
947+ // er in tmp1Tile is dead and can be used as TSEL scratch.
948+ pto::TSEL(dstTile, tmp2MaskTile, tmp0Tile, dstTile, tmp1Tile);
949+}
950+#endif
951+ 
871#define OP_TILE_OP_COSH TCosh952#define OP_TILE_OP_COSH TCosh
872template <typename T0, typename T1, typename T2>953template <typename T0, typename T1, typename T2>
873TILEOP void TCosh(T0 dst, T1 src, T2 tmp)954TILEOP void TCosh(T0 dst, T1 src, T2 tmp)
@@ -879,45 +960,62 @@ TILEOP void TCosh(T0 dst, T1 src, T2 tmp)
879 auto dstShape3 = dstLayout.template GetShapeDim<DIM_4TH, MAX_DIMS>();960 auto dstShape3 = dstLayout.template GetShapeDim<DIM_4TH, MAX_DIMS>();
880 auto dstShape4 = dstLayout.template GetShapeDim<DIM_5TH, MAX_DIMS>();961 auto dstShape4 = dstLayout.template GetShapeDim<DIM_5TH, MAX_DIMS>();
881 962 
882- constexpr float SCALAR_ZERO_POINT_FIVE = 0.5f;
883- constexpr float SCALAR_NEGATIVE_ONE_POINT_FIVE = -1.5f;
884- 
885 constexpr auto tileH = TileOp::GetTensorTileShapeDim<T0, DIM_4TH, MAX_DIMS>();963 constexpr auto tileH = TileOp::GetTensorTileShapeDim<T0, DIM_4TH, MAX_DIMS>();
886 constexpr auto tileW = TileOp::GetTensorTileShapeDim<T0, DIM_5TH, MAX_DIMS>();964 constexpr auto tileW = TileOp::GetTensorTileShapeDim<T0, DIM_5TH, MAX_DIMS>();
887 constexpr auto dstTypeSize = sizeof(typename T0::Type);965 constexpr auto dstTypeSize = sizeof(typename T0::Type);
966+ constexpr auto tileShapeSize = TileOp::GetAnyAxisMergeResult<
967+ DIM_1ST, Std::tuple_size<typename T0::TileShape>::value, typename T0::TileShape>();
888 968 
889 using DataTileDefine = pto::Tile<pto::TileType::Vec, typename T0::Type, tileH, tileW, pto::BLayout::RowMajor, -1,969 using DataTileDefine = pto::Tile<pto::TileType::Vec, typename T0::Type, tileH, tileW, pto::BLayout::RowMajor, -1,
890 -1>;970 -1>;
971+ 
891 DataTileDefine dstTile(dstShape3, dstShape4);972 DataTileDefine dstTile(dstShape3, dstShape4);
892 DataTileDefine srcTile(dstShape3, dstShape4);973 DataTileDefine srcTile(dstShape3, dstShape4);
974+ 
975+#ifdef __DAV_V220
893 DataTileDefine tmpTile(dstShape3, dstShape4);976 DataTileDefine tmpTile(dstShape3, dstShape4);
977+#else
978+ 
979+ using IntTileDefine = pto::Tile<pto::TileType::Vec, int32_t, tileH, tileW, pto::BLayout::RowMajor, -1, -1>;
980+ 
981+ using MaskTileDefine = pto::Tile<pto::TileType::Vec, uint8_t, tileH, tileW * sizeof(float), pto::BLayout::RowMajor,
982+ -1, -1>;
983+ 
984+ DataTileDefine tmp0Tile(dstShape3, dstShape4);
985+ DataTileDefine tmp1Tile(dstShape3, dstShape4);
986+ DataTileDefine tmp2Tile(dstShape3, dstShape4);
987+ IntTileDefine tmp0IntTile(dstShape3, dstShape4);
988+ MaskTileDefine tmp2MaskTile(dstShape3, dstShape4);
989+#endif
894 990 
895 for (LoopVar n0Index = 0; n0Index < dstShape0; n0Index++) {991 for (LoopVar n0Index = 0; n0Index < dstShape0; n0Index++) {
896 for (LoopVar n1Index = 0; n1Index < dstShape1; n1Index++) {992 for (LoopVar n1Index = 0; n1Index < dstShape1; n1Index++) {
897 for (LoopVar n2Index = 0; n2Index < dstShape2; n2Index++) {993 for (LoopVar n2Index = 0; n2Index < dstShape2; n2Index++) {
898 auto tileOffsets = TileOffset(n0Index, n1Index, n2Index);994 auto tileOffsets = TileOffset(n0Index, n1Index, n2Index);
899 auto srcOffset = GenTileOffset(src, tileOffsets);995 auto srcOffset = GenTileOffset(src, tileOffsets);
900- pto::TASSIGN(dstTile, (uint64_t)(dst.GetAddr() + srcOffset * dstTypeSize));996+ auto dstOffset = GenTileOffset(dst, tileOffsets);
901- pto::TASSIGN(srcTile, (uint64_t)(src.GetAddr() + srcOffset * dstTypeSize));
902- pto::TASSIGN(tmpTile, (uint64_t)(tmp.GetAddr() + srcOffset * dstTypeSize));
903 997 
904- // cosh(x) = 1/2 * (e^{x/2} + e^{-3x/2}) * e^{x/2}998+ pto::TASSIGN(dstTile, static_cast<uint64_t>(dst.GetAddr() + dstOffset * dstTypeSize));
905- pto::TABS(tmpTile, srcTile);999+ pto::TASSIGN(srcTile, static_cast<uint64_t>(src.GetAddr() + srcOffset * dstTypeSize));
906- SyncV();1000+ 
907- pto::TMULS(dstTile, tmpTile, SCALAR_NEGATIVE_ONE_POINT_FIVE);1001+#ifdef __DAV_V220
908- SyncV();1002+ pto::TASSIGN(tmpTile, static_cast<uint64_t>(tmp.GetAddr() + dstOffset * dstTypeSize));
909- pto::TMULS(tmpTile, tmpTile, SCALAR_ZERO_POINT_FIVE);1003+ 
910- SyncV();1004+ TCoshCompute(dstTile, srcTile, tmpTile);
911- pto::TEXP<pto::ExpAlgorithm::HIGH_PRECISION>(tmpTile, tmpTile);1005+#else
912- SyncV();1006+ auto tmp0Addr = static_cast<uint64_t>(tmp.GetAddr() + dstOffset * dstTypeSize);
913- pto::TEXP<pto::ExpAlgorithm::HIGH_PRECISION>(dstTile, dstTile);1007+ auto tmp1Addr = static_cast<uint64_t>(tmp.GetAddr() + (dstOffset + tileShapeSize) * dstTypeSize);
914- SyncV();1008+ auto tmp2Addr = static_cast<uint64_t>(tmp.GetAddr() + (dstOffset + 2 * tileShapeSize) * dstTypeSize);
915- pto::TADD(dstTile, dstTile, tmpTile);1009+ 
916- SyncV();1010+ pto::TASSIGN(tmp0Tile, tmp0Addr);
917- pto::TMULS(dstTile, dstTile, SCALAR_ZERO_POINT_FIVE);1011+ pto::TASSIGN(tmp1Tile, tmp1Addr);
918- SyncV();1012+ pto::TASSIGN(tmp2Tile, tmp2Addr);
919- pto::TMUL(dstTile, dstTile, tmpTile);1013+ 
920- SyncV();1014+ pto::TASSIGN(tmp0IntTile, tmp0Addr);
1015+ pto::TASSIGN(tmp2MaskTile, tmp2Addr);
1016+ 
1017+ TCoshCompute(dstTile, srcTile, tmp0Tile, tmp1Tile, tmp2Tile, tmp0IntTile, tmp2MaskTile);
1018+#endif
921 }1019 }
922 }1020 }
923 }1021 }
@@ -1765,19 +1863,18 @@ TILEOP void TASinh(T0 dst, T1 src, T2 tmp)
1765 1863 
1766 pto::TABS(tmp0Tile, srcTile); // |x|1864 pto::TABS(tmp0Tile, srcTile); // |x|
1767 SyncV();1865 SyncV();
1768- pto::TDIVS<pto::DivAlgorithm::HIGH_PRECISION>(tmp1Tile, CONST_ONE, tmp0Tile); // 1/|x|1866+ pto::TDIVS(tmp1Tile, CONST_ONE, tmp0Tile); // 1/|x|
1769 SyncV();1867 SyncV();
1770 pto::TMUL(tmp2Tile, tmp1Tile, tmp1Tile); // 1/(|x|)^21868 pto::TMUL(tmp2Tile, tmp1Tile, tmp1Tile); // 1/(|x|)^2
1771 SyncV();1869 SyncV();
1772 1870 
1773 pto::TADDS(tmp3Tile, tmp2Tile, CONST_ONE); // 1 + 1/(|x|)^21871 pto::TADDS(tmp3Tile, tmp2Tile, CONST_ONE); // 1 + 1/(|x|)^2
1774 SyncV();1872 SyncV();
1775- pto::TSQRT<pto::SqrtAlgorithm::HIGH_PRECISION>(tmp3Tile, tmp3Tile); // sqrt(1 + 1/(|x|)^2)1873+ pto::TSQRT(tmp3Tile, tmp3Tile); // sqrt(1 + 1/(|x|)^2)
1776 SyncV();1874 SyncV();
1777 pto::TADD(tmp1Tile, tmp3Tile, tmp1Tile); // sqrt(1 + 1/(|x|)^2) + 1/|x|1875 pto::TADD(tmp1Tile, tmp3Tile, tmp1Tile); // sqrt(1 + 1/(|x|)^2) + 1/|x|
1778 SyncV();1876 SyncV();
1779- pto::TDIV<pto::DivAlgorithm::HIGH_PRECISION>(tmp1Tile, tmp0Tile,1877+ pto::TDIV(tmp1Tile, tmp0Tile, tmp1Tile); // |x| / (sqrt(1 + 1/(|x|)^2) + 1/|x|)
1780- tmp1Tile); // |x| / (sqrt(1 + 1/(|x|)^2) + 1/|x|)
1781 SyncV();1878 SyncV();
1782 pto::TADD(tmp1Tile, tmp0Tile, tmp1Tile); // r = |x| + |x| / (sqrt(1 + 1/(|x|)^2) + 1/|x|)1879 pto::TADD(tmp1Tile, tmp0Tile, tmp1Tile); // r = |x| + |x| / (sqrt(1 + 1/(|x|)^2) + 1/|x|)
1783 SyncV();1880 SyncV();
@@ -1791,15 +1888,14 @@ TILEOP void TASinh(T0 dst, T1 src, T2 tmp)
1791 pto::TMINS(dstTile, dstTile, CONST_COMPARE_VALUE_MAX);1888 pto::TMINS(dstTile, dstTile, CONST_COMPARE_VALUE_MAX);
1792 SyncV();1889 SyncV();
1793 1890 
1794- pto::TLOG<pto::LogAlgorithm::HIGH_PRECISION>(tmp3Tile, tmp3Tile); // log(r + 1)1891+ pto::TLOG(tmp3Tile, tmp3Tile); // log(r + 1)
1795 SyncV();1892 SyncV();
1796 pto::TMUL(tmp1Tile, tmp1Tile, tmp3Tile); // r * log(r + 1)1893 pto::TMUL(tmp1Tile, tmp1Tile, tmp3Tile); // r * log(r + 1)
1797 SyncV();1894 SyncV();
1798- pto::TDIV<pto::DivAlgorithm::HIGH_PRECISION>(tmp1Tile, tmp1Tile,1895+ pto::TDIV(tmp1Tile, tmp1Tile, dstTile); // r * log(r + 1) / clamp(r, s_min, s_max)
1799- dstTile); // r * log(r + 1) / clamp(r, s_min, s_max)
1800 SyncV();1896 SyncV();
1801 1897 
1802- pto::TLOG<pto::LogAlgorithm::HIGH_PRECISION>(tmp3Tile, tmp0Tile); // log(|x|)1898+ pto::TLOG(tmp3Tile, tmp0Tile); // log(|x|)
1803 SyncV();1899 SyncV();
1804 pto::TADDS(tmp3Tile, tmp3Tile, CONST_LOG_TWO_VALUE); // log(|x|) + log21900 pto::TADDS(tmp3Tile, tmp3Tile, CONST_LOG_TWO_VALUE); // log(|x|) + log2
1805 SyncV();1901 SyncV();
@@ -1876,7 +1972,7 @@ TILEOP void TACosh(T0 dst, T1 src, T2 tmp)
1876 SyncV();1972 SyncV();
1877 pto::TADD(tmp1Tile, tmp1Tile, tmp2Tile); // t^2 + 2t1973 pto::TADD(tmp1Tile, tmp1Tile, tmp2Tile); // t^2 + 2t
1878 SyncV();1974 SyncV();
1879- pto::TSQRT<pto::SqrtAlgorithm::HIGH_PRECISION>(tmp1Tile, tmp1Tile); // sqrt(t^2 + 2t)1975+ pto::TSQRT(tmp1Tile, tmp1Tile); // sqrt(t^2 + 2t)
1880 SyncV();1976 SyncV();
1881 pto::TADD(tmp1Tile, tmp1Tile, tmp0Tile); // t + sqrt(t^2 + 2t) = r1977 pto::TADD(tmp1Tile, tmp1Tile, tmp0Tile); // t + sqrt(t^2 + 2t) = r
1882 SyncV();1978 SyncV();
@@ -1890,15 +1986,14 @@ TILEOP void TACosh(T0 dst, T1 src, T2 tmp)
1890 pto::TMINS(tmp0Tile, tmp0Tile, CONST_COMPARE_VALUE_MAX);1986 pto::TMINS(tmp0Tile, tmp0Tile, CONST_COMPARE_VALUE_MAX);
1891 SyncV();1987 SyncV();
1892 1988 
1893- pto::TLOG<pto::LogAlgorithm::HIGH_PRECISION>(dstTile, tmp2Tile); // log(r + 1)1989+ pto::TLOG(dstTile, tmp2Tile); // log(r + 1)
1894 SyncV();1990 SyncV();
1895 pto::TMUL(dstTile, dstTile, tmp1Tile); // r * log(r + 1)1991 pto::TMUL(dstTile, dstTile, tmp1Tile); // r * log(r + 1)
1896 SyncV();1992 SyncV();
1897- pto::TDIV<pto::DivAlgorithm::HIGH_PRECISION>(dstTile, dstTile,1993+ pto::TDIV(dstTile, dstTile, tmp0Tile); // r * log(r + 1) / clamp(r, s_min, s_max)
1898- tmp0Tile); // r * log(r + 1) / clamp(r, s_min, s_max)
1899 SyncV();1994 SyncV();
1900 1995 
1901- pto::TLOG<pto::LogAlgorithm::HIGH_PRECISION>(tmp0Tile, srcTile); // log(x)1996+ pto::TLOG(tmp0Tile, srcTile); // log(x)
1902 SyncV();1997 SyncV();
1903 pto::TADDS(tmp0Tile, tmp0Tile, CONST_LOG_TWO_VALUE); // log(x) + log(2)1998 pto::TADDS(tmp0Tile, tmp0Tile, CONST_LOG_TWO_VALUE); // log(x) + log(2)
1904 SyncV();1999 SyncV();
Mframework/tests/st/operation/python/vector_operator_golden.py+5-4
@@ -1317,12 +1317,13 @@ def gen_bitwise_not_op_golden(case_name: str, output: Path, case_index: int = No
1317 def golden_func(inputs: list, _config: dict):1317 def golden_func(inputs: list, _config: dict):
1318 assert len(inputs) > 0, "inputs must contain at least one element"1318 assert len(inputs) > 0, "inputs must contain at least one element"
1319 x = torch.tensor(inputs[0])1319 x = torch.tensor(inputs[0])
1320- if x.dtype == torch.uint16:1320+ if x.dtype in [torch.uint16, torch.uint32]:
1321- x.numpy()1321+ x_np = x.numpy()
1322- y = np.bitwise_not(x)1322+ y = np.bitwise_not(x_np)
1323+ return [y]
1323 else:1324 else:
1324 y = torch.bitwise_not(x)1325 y = torch.bitwise_not(x)
1325- return [y.numpy()]1326+ return [y.numpy()]
1326 1327 
1327 logging.debug("Case(%s), Golden creating...", case_name)1328 logging.debug("Case(%s), Golden creating...", case_name)
1328 return gen_op_golden("BitwiseNot", golden_func, output, case_index)1329 return gen_op_golden("BitwiseNot", golden_func, output, case_index)
Mframework/tests/st/operation/test_case/BitwiseAnd_st_test_cases.csv+1-0
@@ -14,3 +14,4 @@ BitwiseAnd_4D_unalign_1,"[17, 7, 1, 3], [17, 7, 5, 3]","uint16, uint16","ND, ND"
14BitwiseAnd_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"14BitwiseAnd_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"
15BitwiseAnd_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"15BitwiseAnd_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"
16BitwiseAnd_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"16BitwiseAnd_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"
17+BitwiseAnd_test_4,"[32, 32], [32, 32]","uint32, uint32","ND, ND","[0, 65535], [0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]"
Mframework/tests/st/operation/test_case/BitwiseAnd_st_test_cases.json+1023-951
@@ -1,952 +1,1024 @@
1-{1+{
2- "test_cases": [2+ "test_cases": [
3- {3+ {
4- "case_index": 0,4+ "case_index": 0,
5- "case_name": "BitwiseAnd_2D_align_0",5+ "case_name": "BitwiseAnd_2D_align_0",
6- "operation": "BitwiseAnd",6+ "operation": "BitwiseAnd",
7- "input_tensors": [7+ "input_tensors": [
8- {8+ {
9- "name": "input0",9+ "name": "input0",
10- "shape": [10+ "shape": [
11- 32,11+ 32,
12- 3212+ 32
13- ],13+ ],
14- "dtype": "int16",14+ "dtype": "int16",
15- "format": "ND",15+ "format": "ND",
16- "need_trans": false,16+ "need_trans": false,
17- "data_range": {17+ "data_range": {
18- "min": 0,18+ "min": 0,
19- "max": 6553519+ "max": 65535
20- }20+ }
21- },21+ },
22- {22+ {
23- "name": "input1",23+ "name": "input1",
24- "shape": [24+ "shape": [
25- 32,25+ 32,
26- 3226+ 32
27- ],27+ ],
28- "dtype": "int16",28+ "dtype": "int16",
29- "format": "ND",29+ "format": "ND",
30- "need_trans": false,30+ "need_trans": false,
31- "data_range": {31+ "data_range": {
32- "min": 0,32+ "min": 0,
33- "max": 6553533+ "max": 65535
34- }34+ }
35- }35+ }
36- ],36+ ],
37- "output_tensors": [37+ "output_tensors": [
38- {38+ {
39- "name": "output0",39+ "name": "output0",
40- "shape": [40+ "shape": [
41- 32,41+ 32,
42- 3242+ 32
43- ],43+ ],
44- "dtype": "int16",44+ "dtype": "int16",
45- "format": "ND",45+ "format": "ND",
46- "need_trans": false46+ "need_trans": false
47- }47+ }
48- ],48+ ],
49- "view_shape": [49+ "view_shape": [
50- 16,50+ 16,
51- 1651+ 16
52- ],52+ ],
53- "tile_shape": [53+ "tile_shape": [
54- 16,54+ 16,
55- 1655+ 16
56- ],56+ ],
57- "params": {57+ "params": {
58- "on_board": true,58+ "on_board": true,
59- "func_id": -159+ "func_id": -1
60- },60+ },
61- "index": 061+ "index": 0
62- },62+ },
63- {63+ {
64- "case_index": 1,64+ "case_index": 1,
65- "case_name": "BitwiseAnd_2D_align_1",65+ "case_name": "BitwiseAnd_2D_align_1",
66- "operation": "BitwiseAnd",66+ "operation": "BitwiseAnd",
67- "input_tensors": [67+ "input_tensors": [
68- {68+ {
69- "name": "input0",69+ "name": "input0",
70- "shape": [70+ "shape": [
71- 1,71+ 1,
72- 3272+ 32
73- ],73+ ],
74- "dtype": "uint16",74+ "dtype": "uint16",
75- "format": "ND",75+ "format": "ND",
76- "need_trans": false,76+ "need_trans": false,
77- "data_range": {77+ "data_range": {
78- "min": 0,78+ "min": 0,
79- "max": 6553579+ "max": 65535
80- }80+ }
81- },81+ },
82- {82+ {
83- "name": "input1",83+ "name": "input1",
84- "shape": [84+ "shape": [
85- 32,85+ 32,
86- 3286+ 32
87- ],87+ ],
88- "dtype": "uint16",88+ "dtype": "uint16",
89- "format": "ND",89+ "format": "ND",
90- "need_trans": false,90+ "need_trans": false,
91- "data_range": {91+ "data_range": {
92- "min": 0,92+ "min": 0,
93- "max": 6553593+ "max": 65535
94- }94+ }
95- }95+ }
96- ],96+ ],
97- "output_tensors": [97+ "output_tensors": [
98- {98+ {
99- "name": "output0",99+ "name": "output0",
100- "shape": [100+ "shape": [
101- 32,101+ 32,
102- 32102+ 32
103- ],103+ ],
104- "dtype": "uint16",104+ "dtype": "uint16",
105- "format": "ND",105+ "format": "ND",
106- "need_trans": false106+ "need_trans": false
107- }107+ }
108- ],108+ ],
109- "view_shape": [109+ "view_shape": [
110- 16,110+ 16,
111- 16111+ 16
112- ],112+ ],
113- "tile_shape": [113+ "tile_shape": [
114- 16,114+ 16,
115- 16115+ 16
116- ],116+ ],
117- "params": {117+ "params": {
118- "on_board": true,118+ "on_board": true,
119- "func_id": -1119+ "func_id": -1
120- },120+ },
121- "index": 1121+ "index": 1
122- },122+ },
123- {123+ {
124- "case_index": 2,124+ "case_index": 2,
125- "case_name": "BitwiseAnd_2D_unalign_0",125+ "case_name": "BitwiseAnd_2D_unalign_0",
126- "operation": "BitwiseAnd",126+ "operation": "BitwiseAnd",
127- "input_tensors": [127+ "input_tensors": [
128- {128+ {
129- "name": "input0",129+ "name": "input0",
130- "shape": [130+ "shape": [
131- 17,131+ 17,
132- 31132+ 31
133- ],133+ ],
134- "dtype": "int16",134+ "dtype": "int16",
135- "format": "ND",135+ "format": "ND",
136- "need_trans": false,136+ "need_trans": false,
137- "data_range": {137+ "data_range": {
138- "min": 0,138+ "min": 0,
139- "max": 255139+ "max": 255
140- }140+ }
141- },141+ },
142- {142+ {
143- "name": "input1",143+ "name": "input1",
144- "shape": [144+ "shape": [
145- 17,145+ 17,
146- 31146+ 31
147- ],147+ ],
148- "dtype": "int16",148+ "dtype": "int16",
149- "format": "ND",149+ "format": "ND",
150- "need_trans": false,150+ "need_trans": false,
151- "data_range": {151+ "data_range": {
152- "min": 0,152+ "min": 0,
153- "max": 255153+ "max": 255
154- }154+ }
155- }155+ }
156- ],156+ ],
157- "output_tensors": [157+ "output_tensors": [
158- {158+ {
159- "name": "output0",159+ "name": "output0",
160- "shape": [160+ "shape": [
161- 17,161+ 17,
162- 31162+ 31
163- ],163+ ],
164- "dtype": "int16",164+ "dtype": "int16",
165- "format": "ND",165+ "format": "ND",
166- "need_trans": false166+ "need_trans": false
167- }167+ }
168- ],168+ ],
169- "view_shape": [169+ "view_shape": [
170- 8,170+ 8,
171- 16171+ 16
172- ],172+ ],
173- "tile_shape": [173+ "tile_shape": [
174- 16,174+ 16,
175- 16175+ 16
176- ],176+ ],
177- "params": {177+ "params": {
178- "on_board": true,178+ "on_board": true,
179- "func_id": -1179+ "func_id": -1
180- },180+ },
181- "index": 2181+ "index": 2
182- },182+ },
183- {183+ {
184- "case_index": 3,184+ "case_index": 3,
185- "case_name": "BitwiseAnd_2D_unalign_1",185+ "case_name": "BitwiseAnd_2D_unalign_1",
186- "operation": "BitwiseAnd",186+ "operation": "BitwiseAnd",
187- "input_tensors": [187+ "input_tensors": [
188- {188+ {
189- "name": "input0",189+ "name": "input0",
190- "shape": [190+ "shape": [
191- 17,191+ 17,
192- 1192+ 1
193- ],193+ ],
194- "dtype": "uint16",194+ "dtype": "uint16",
195- "format": "ND",195+ "format": "ND",
196- "need_trans": false,196+ "need_trans": false,
197- "data_range": {197+ "data_range": {
198- "min": 0,198+ "min": 0,
199- "max": 65535199+ "max": 65535
200- }200+ }
201- },201+ },
202- {202+ {
203- "name": "input1",203+ "name": "input1",
204- "shape": [204+ "shape": [
205- 17,205+ 17,
206- 31206+ 31
207- ],207+ ],
208- "dtype": "uint16",208+ "dtype": "uint16",
209- "format": "ND",209+ "format": "ND",
210- "need_trans": false,210+ "need_trans": false,
211- "data_range": {211+ "data_range": {
212- "min": 0,212+ "min": 0,
213- "max": 65535213+ "max": 65535
214- }214+ }
215- }215+ }
216- ],216+ ],
217- "output_tensors": [217+ "output_tensors": [
218- {218+ {
219- "name": "output0",219+ "name": "output0",
220- "shape": [220+ "shape": [
221- 17,221+ 17,
222- 31222+ 31
223- ],223+ ],
224- "dtype": "uint16",224+ "dtype": "uint16",
225- "format": "ND",225+ "format": "ND",
226- "need_trans": false226+ "need_trans": false
227- }227+ }
228- ],228+ ],
229- "view_shape": [229+ "view_shape": [
230- 8,230+ 8,
231- 16231+ 16
232- ],232+ ],
233- "tile_shape": [233+ "tile_shape": [
234- 16,234+ 16,
235- 16235+ 16
236- ],236+ ],
237- "params": {237+ "params": {
238- "on_board": true,238+ "on_board": true,
239- "func_id": -1239+ "func_id": -1
240- },240+ },
241- "index": 3241+ "index": 3
242- },242+ },
243- {243+ {
244- "case_index": 4,244+ "case_index": 4,
245- "case_name": "BitwiseAnd_3D_align_0",245+ "case_name": "BitwiseAnd_3D_align_0",
246- "operation": "BitwiseAnd",246+ "operation": "BitwiseAnd",
247- "input_tensors": [247+ "input_tensors": [
248- {248+ {
249- "name": "input0",249+ "name": "input0",
250- "shape": [250+ "shape": [
251- 32,251+ 32,
252- 16,252+ 16,
253- 8253+ 8
254- ],254+ ],
255- "dtype": "int16",255+ "dtype": "int16",
256- "format": "ND",256+ "format": "ND",
257- "need_trans": false,257+ "need_trans": false,
258- "data_range": {258+ "data_range": {
259- "min": 0,259+ "min": 0,
260- "max": 255260+ "max": 255
261- }261+ }
262- },262+ },
263- {263+ {
264- "name": "input1",264+ "name": "input1",
265- "shape": [265+ "shape": [
266- 32,266+ 32,
267- 16,267+ 16,
268- 8268+ 8
269- ],269+ ],
270- "dtype": "int16",270+ "dtype": "int16",
271- "format": "ND",271+ "format": "ND",
272- "need_trans": false,272+ "need_trans": false,
273- "data_range": {273+ "data_range": {
274- "min": 0,274+ "min": 0,
275- "max": 255275+ "max": 255
276- }276+ }
277- }277+ }
278- ],278+ ],
279- "output_tensors": [279+ "output_tensors": [
280- {280+ {
281- "name": "output0",281+ "name": "output0",
282- "shape": [282+ "shape": [
283- 32,283+ 32,
284- 16,284+ 16,
285- 8285+ 8
286- ],286+ ],
287- "dtype": "int16",287+ "dtype": "int16",
288- "format": "ND",288+ "format": "ND",
289- "need_trans": false289+ "need_trans": false
290- }290+ }
291- ],291+ ],
292- "view_shape": [292+ "view_shape": [
293- 16,293+ 16,
294- 8,294+ 8,
295- 4295+ 4
296- ],296+ ],
297- "tile_shape": [297+ "tile_shape": [
298- 16,298+ 16,
299- 16,299+ 16,
300- 16300+ 16
301- ],301+ ],
302- "params": {302+ "params": {
303- "on_board": true,303+ "on_board": true,
304- "func_id": -1304+ "func_id": -1
305- },305+ },
306- "index": 4306+ "index": 4
307- },307+ },
308- {308+ {
309- "case_index": 5,309+ "case_index": 5,
310- "case_name": "BitwiseAnd_3D_align_1",310+ "case_name": "BitwiseAnd_3D_align_1",
311- "operation": "BitwiseAnd",311+ "operation": "BitwiseAnd",
312- "input_tensors": [312+ "input_tensors": [
313- {313+ {
314- "name": "input0",314+ "name": "input0",
315- "shape": [315+ "shape": [
316- 32,316+ 32,
317- 1,317+ 1,
318- 8318+ 8
319- ],319+ ],
320- "dtype": "uint16",320+ "dtype": "uint16",
321- "format": "ND",321+ "format": "ND",
322- "need_trans": false,322+ "need_trans": false,
323- "data_range": {323+ "data_range": {
324- "min": 0,324+ "min": 0,
325- "max": 65535325+ "max": 65535
326- }326+ }
327- },327+ },
328- {328+ {
329- "name": "input1",329+ "name": "input1",
330- "shape": [330+ "shape": [
331- 32,331+ 32,
332- 16,332+ 16,
333- 8333+ 8
334- ],334+ ],
335- "dtype": "uint16",335+ "dtype": "uint16",
336- "format": "ND",336+ "format": "ND",
337- "need_trans": false,337+ "need_trans": false,
338- "data_range": {338+ "data_range": {
339- "min": 0,339+ "min": 0,
340- "max": 65535340+ "max": 65535
341- }341+ }
342- }342+ }
343- ],343+ ],
344- "output_tensors": [344+ "output_tensors": [
345- {345+ {
346- "name": "output0",346+ "name": "output0",
347- "shape": [347+ "shape": [
348- 32,348+ 32,
349- 16,349+ 16,
350- 8350+ 8
351- ],351+ ],
352- "dtype": "uint16",352+ "dtype": "uint16",
353- "format": "ND",353+ "format": "ND",
354- "need_trans": false354+ "need_trans": false
355- }355+ }
356- ],356+ ],
357- "view_shape": [357+ "view_shape": [
358- 16,358+ 16,
359- 8,359+ 8,
360- 4360+ 4
361- ],361+ ],
362- "tile_shape": [362+ "tile_shape": [
363- 16,363+ 16,
364- 16,364+ 16,
365- 16365+ 16
366- ],366+ ],
367- "params": {367+ "params": {
368- "on_board": true,368+ "on_board": true,
369- "func_id": -1369+ "func_id": -1
370- },370+ },
371- "index": 5371+ "index": 5
372- },372+ },
373- {373+ {
374- "case_index": 6,374+ "case_index": 6,
375- "case_name": "BitwiseAnd_3D_unalign_0",375+ "case_name": "BitwiseAnd_3D_unalign_0",
376- "operation": "BitwiseAnd",376+ "operation": "BitwiseAnd",
377- "input_tensors": [377+ "input_tensors": [
378- {378+ {
379- "name": "input0",379+ "name": "input0",
380- "shape": [380+ "shape": [
381- 33,381+ 33,
382- 15,382+ 15,
383- 9383+ 9
384- ],384+ ],
385- "dtype": "int16",385+ "dtype": "int16",
386- "format": "ND",386+ "format": "ND",
387- "need_trans": false,387+ "need_trans": false,
388- "data_range": {388+ "data_range": {
389- "min": 0,389+ "min": 0,
390- "max": 255390+ "max": 255
391- }391+ }
392- },392+ },
393- {393+ {
394- "name": "input1",394+ "name": "input1",
395- "shape": [395+ "shape": [
396- 33,396+ 33,
397- 15,397+ 15,
398- 9398+ 9
399- ],399+ ],
400- "dtype": "int16",400+ "dtype": "int16",
401- "format": "ND",401+ "format": "ND",
402- "need_trans": false,402+ "need_trans": false,
403- "data_range": {403+ "data_range": {
404- "min": 0,404+ "min": 0,
405- "max": 255405+ "max": 255
406- }406+ }
407- }407+ }
408- ],408+ ],
409- "output_tensors": [409+ "output_tensors": [
410- {410+ {
411- "name": "output0",411+ "name": "output0",
412- "shape": [412+ "shape": [
413- 33,413+ 33,
414- 15,414+ 15,
415- 9415+ 9
416- ],416+ ],
417- "dtype": "int16",417+ "dtype": "int16",
418- "format": "ND",418+ "format": "ND",
419- "need_trans": false419+ "need_trans": false
420- }420+ }
421- ],421+ ],
422- "view_shape": [422+ "view_shape": [
423- 16,423+ 16,
424- 8,424+ 8,
425- 4425+ 4
426- ],426+ ],
427- "tile_shape": [427+ "tile_shape": [
428- 16,428+ 16,
429- 16,429+ 16,
430- 16430+ 16
431- ],431+ ],
432- "params": {432+ "params": {
433- "on_board": true,433+ "on_board": true,
434- "func_id": -1434+ "func_id": -1
435- },435+ },
436- "index": 6436+ "index": 6
437- },437+ },
438- {438+ {
439- "case_index": 7,439+ "case_index": 7,
440- "case_name": "BitwiseAnd_3D_unalign_1",440+ "case_name": "BitwiseAnd_3D_unalign_1",
441- "operation": "BitwiseAnd",441+ "operation": "BitwiseAnd",
442- "input_tensors": [442+ "input_tensors": [
443- {443+ {
444- "name": "input0",444+ "name": "input0",
445- "shape": [445+ "shape": [
446- 1,446+ 1,
447- 15,447+ 15,
448- 9448+ 9
449- ],449+ ],
450- "dtype": "uint16",450+ "dtype": "uint16",
451- "format": "ND",451+ "format": "ND",
452- "need_trans": false,452+ "need_trans": false,
453- "data_range": {453+ "data_range": {
454- "min": 0,454+ "min": 0,
455- "max": 65535455+ "max": 65535
456- }456+ }
457- },457+ },
458- {458+ {
459- "name": "input1",459+ "name": "input1",
460- "shape": [460+ "shape": [
461- 33,461+ 33,
462- 15,462+ 15,
463- 9463+ 9
464- ],464+ ],
465- "dtype": "uint16",465+ "dtype": "uint16",
466- "format": "ND",466+ "format": "ND",
467- "need_trans": false,467+ "need_trans": false,
468- "data_range": {468+ "data_range": {
469- "min": 0,469+ "min": 0,
470- "max": 65535470+ "max": 65535
471- }471+ }
472- }472+ }
473- ],473+ ],
474- "output_tensors": [474+ "output_tensors": [
475- {475+ {
476- "name": "output0",476+ "name": "output0",
477- "shape": [477+ "shape": [
478- 33,478+ 33,
479- 15,479+ 15,
480- 9480+ 9
481- ],481+ ],
482- "dtype": "uint16",482+ "dtype": "uint16",
483- "format": "ND",483+ "format": "ND",
484- "need_trans": false484+ "need_trans": false
485- }485+ }
486- ],486+ ],
487- "view_shape": [487+ "view_shape": [
488- 16,488+ 16,
489- 8,489+ 8,
490- 4490+ 4
491- ],491+ ],
492- "tile_shape": [492+ "tile_shape": [
493- 16,493+ 16,
494- 16,494+ 16,
495- 16495+ 16
496- ],496+ ],
497- "params": {497+ "params": {
498- "on_board": true,498+ "on_board": true,
499- "func_id": -1499+ "func_id": -1
500- },500+ },
501- "index": 7501+ "index": 7
502- },502+ },
503- {503+ {
504- "case_index": 8,504+ "case_index": 8,
505- "case_name": "BitwiseAnd_4D_align_0",505+ "case_name": "BitwiseAnd_4D_align_0",
506- "operation": "BitwiseAnd",506+ "operation": "BitwiseAnd",
507- "input_tensors": [507+ "input_tensors": [
508- {508+ {
509- "name": "input0",509+ "name": "input0",
510- "shape": [510+ "shape": [
511- 16,511+ 16,
512- 8,512+ 8,
513- 4,513+ 4,
514- 2514+ 2
515- ],515+ ],
516- "dtype": "int16",516+ "dtype": "int16",
517- "format": "ND",517+ "format": "ND",
518- "need_trans": false,518+ "need_trans": false,
519- "data_range": {519+ "data_range": {
520- "min": 0,520+ "min": 0,
521- "max": 255521+ "max": 255
522- }522+ }
523- },523+ },
524- {524+ {
525- "name": "input1",525+ "name": "input1",
526- "shape": [526+ "shape": [
527- 16,527+ 16,
528- 8,528+ 8,
529- 4,529+ 4,
530- 2530+ 2
531- ],531+ ],
532- "dtype": "int16",532+ "dtype": "int16",
533- "format": "ND",533+ "format": "ND",
534- "need_trans": false,534+ "need_trans": false,
535- "data_range": {535+ "data_range": {
536- "min": 0,536+ "min": 0,
537- "max": 255537+ "max": 255
538- }538+ }
539- }539+ }
540- ],540+ ],
541- "output_tensors": [541+ "output_tensors": [
542- {542+ {
543- "name": "output0",543+ "name": "output0",
544- "shape": [544+ "shape": [
545- 16,545+ 16,
546- 8,546+ 8,
547- 4,547+ 4,
548- 2548+ 2
549- ],549+ ],
550- "dtype": "int16",550+ "dtype": "int16",
551- "format": "ND",551+ "format": "ND",
552- "need_trans": false552+ "need_trans": false
553- }553+ }
554- ],554+ ],
555- "view_shape": [555+ "view_shape": [
556- 8,556+ 8,
557- 4,557+ 4,
558- 2,558+ 2,
559- 1559+ 1
560- ],560+ ],
561- "tile_shape": [561+ "tile_shape": [
562- 16,562+ 16,
563- 16,563+ 16,
564- 16,564+ 16,
565- 16565+ 16
566- ],566+ ],
567- "params": {567+ "params": {
568- "on_board": true,568+ "on_board": true,
569- "func_id": -1569+ "func_id": -1
570- },570+ },
571- "index": 8571+ "index": 8
572- },572+ },
573- {573+ {
574- "case_index": 9,574+ "case_index": 9,
575- "case_name": "BitwiseAnd_4D_align_1",575+ "case_name": "BitwiseAnd_4D_align_1",
576- "operation": "BitwiseAnd",576+ "operation": "BitwiseAnd",
577- "input_tensors": [577+ "input_tensors": [
578- {578+ {
579- "name": "input0",579+ "name": "input0",
580- "shape": [580+ "shape": [
581- 16,581+ 16,
582- 1,582+ 1,
583- 4,583+ 4,
584- 2584+ 2
585- ],585+ ],
586- "dtype": "uint16",586+ "dtype": "uint16",
587- "format": "ND",587+ "format": "ND",
588- "need_trans": false,588+ "need_trans": false,
589- "data_range": {589+ "data_range": {
590- "min": 0,590+ "min": 0,
591- "max": 65535591+ "max": 65535
592- }592+ }
593- },593+ },
594- {594+ {
595- "name": "input1",595+ "name": "input1",
596- "shape": [596+ "shape": [
597- 16,597+ 16,
598- 8,598+ 8,
599- 4,599+ 4,
600- 2600+ 2
601- ],601+ ],
602- "dtype": "uint16",602+ "dtype": "uint16",
603- "format": "ND",603+ "format": "ND",
604- "need_trans": false,604+ "need_trans": false,
605- "data_range": {605+ "data_range": {
606- "min": 0,606+ "min": 0,
607- "max": 65535607+ "max": 65535
608- }608+ }
609- }609+ }
610- ],610+ ],
611- "output_tensors": [611+ "output_tensors": [
612- {612+ {
613- "name": "output0",613+ "name": "output0",
614- "shape": [614+ "shape": [
615- 16,615+ 16,
616- 8,616+ 8,
617- 4,617+ 4,
618- 2618+ 2
619- ],619+ ],
620- "dtype": "uint16",620+ "dtype": "uint16",
621- "format": "ND",621+ "format": "ND",
622- "need_trans": false622+ "need_trans": false
623- }623+ }
624- ],624+ ],
625- "view_shape": [625+ "view_shape": [
626- 8,626+ 8,
627- 4,627+ 4,
628- 2,628+ 2,
629- 1629+ 1
630- ],630+ ],
631- "tile_shape": [631+ "tile_shape": [
632- 16,632+ 16,
633- 16,633+ 16,
634- 16,634+ 16,
635- 16635+ 16
636- ],636+ ],
637- "params": {637+ "params": {
638- "on_board": true,638+ "on_board": true,
639- "func_id": -1639+ "func_id": -1
640- },640+ },
641- "index": 9641+ "index": 9
642- },642+ },
643- {643+ {
644- "case_index": 10,644+ "case_index": 10,
645- "case_name": "BitwiseAnd_4D_unalign_0",645+ "case_name": "BitwiseAnd_4D_unalign_0",
646- "operation": "BitwiseAnd",646+ "operation": "BitwiseAnd",
647- "input_tensors": [647+ "input_tensors": [
648- {648+ {
649- "name": "input0",649+ "name": "input0",
650- "shape": [650+ "shape": [
651- 17,651+ 17,
652- 7,652+ 7,
653- 5,653+ 5,
654- 3654+ 3
655- ],655+ ],
656- "dtype": "int16",656+ "dtype": "int16",
657- "format": "ND",657+ "format": "ND",
658- "need_trans": false,658+ "need_trans": false,
659- "data_range": {659+ "data_range": {
660- "min": 0,660+ "min": 0,
661- "max": 255661+ "max": 255
662- }662+ }
663- },663+ },
664- {664+ {
665- "name": "input1",665+ "name": "input1",
666- "shape": [666+ "shape": [
667- 17,667+ 17,
668- 7,668+ 7,
669- 5,669+ 5,
670- 3670+ 3
671- ],671+ ],
672- "dtype": "int16",672+ "dtype": "int16",
673- "format": "ND",673+ "format": "ND",
674- "need_trans": false,674+ "need_trans": false,
675- "data_range": {675+ "data_range": {
676- "min": 0,676+ "min": 0,
677- "max": 255677+ "max": 255
678- }678+ }
679- }679+ }
680- ],680+ ],
681- "output_tensors": [681+ "output_tensors": [
682- {682+ {
683- "name": "output0",683+ "name": "output0",
684- "shape": [684+ "shape": [
685- 17,685+ 17,
686- 7,686+ 7,
687- 5,687+ 5,
688- 3688+ 3
689- ],689+ ],
690- "dtype": "int16",690+ "dtype": "int16",
691- "format": "ND",691+ "format": "ND",
692- "need_trans": false692+ "need_trans": false
693- }693+ }
694- ],694+ ],
695- "view_shape": [695+ "view_shape": [
696- 8,696+ 8,
697- 4,697+ 4,
698- 2,698+ 2,
699- 1699+ 1
700- ],700+ ],
701- "tile_shape": [701+ "tile_shape": [
702- 16,702+ 16,
703- 16,703+ 16,
704- 16,704+ 16,
705- 16705+ 16
706- ],706+ ],
707- "params": {707+ "params": {
708- "on_board": true,708+ "on_board": true,
709- "func_id": -1709+ "func_id": -1
710- },710+ },
711- "index": 10711+ "index": 10
712- },712+ },
713- {713+ {
714- "case_index": 11,714+ "case_index": 11,
715- "case_name": "BitwiseAnd_4D_unalign_1",715+ "case_name": "BitwiseAnd_4D_unalign_1",
716- "operation": "BitwiseAnd",716+ "operation": "BitwiseAnd",
717- "input_tensors": [717+ "input_tensors": [
718- {718+ {
719- "name": "input0",719+ "name": "input0",
720- "shape": [720+ "shape": [
721- 17,721+ 17,
722- 7,722+ 7,
723- 1,723+ 1,
724- 3724+ 3
725- ],725+ ],
726- "dtype": "uint16",726+ "dtype": "uint16",
727- "format": "ND",727+ "format": "ND",
728- "need_trans": false,728+ "need_trans": false,
729- "data_range": {729+ "data_range": {
730- "min": 0,730+ "min": 0,
731- "max": 65535731+ "max": 65535
732- }732+ }
733- },733+ },
734- {734+ {
735- "name": "input1",735+ "name": "input1",
736- "shape": [736+ "shape": [
737- 17,737+ 17,
738- 7,738+ 7,
739- 5,739+ 5,
740- 3740+ 3
741- ],741+ ],
742- "dtype": "uint16",742+ "dtype": "uint16",
743- "format": "ND",743+ "format": "ND",
744- "need_trans": false,744+ "need_trans": false,
745- "data_range": {745+ "data_range": {
746- "min": 0,746+ "min": 0,
747- "max": 65535747+ "max": 65535
748- }748+ }
749- }749+ }
750- ],750+ ],
751- "output_tensors": [751+ "output_tensors": [
752- {752+ {
753- "name": "output0",753+ "name": "output0",
754- "shape": [754+ "shape": [
755- 17,755+ 17,
756- 7,756+ 7,
757- 5,757+ 5,
758- 3758+ 3
759- ],759+ ],
760- "dtype": "uint16",760+ "dtype": "uint16",
761- "format": "ND",761+ "format": "ND",
762- "need_trans": false762+ "need_trans": false
763- }763+ }
764- ],764+ ],
765- "view_shape": [765+ "view_shape": [
766- 8,766+ 8,
767- 4,767+ 4,
768- 2,768+ 2,
769- 1769+ 1
770- ],770+ ],
771- "tile_shape": [771+ "tile_shape": [
772- 16,772+ 16,
773- 16,773+ 16,
774- 16,774+ 16,
775- 16775+ 16
776- ],776+ ],
777- "params": {777+ "params": {
778- "on_board": true,778+ "on_board": true,
779- "func_id": -1779+ "func_id": -1
780- },780+ },
781- "index": 11781+ "index": 11
782- },782+ },
783- {783+ {
784- "case_index": 12,784+ "case_index": 12,
785- "case_name": "BitwiseAnd_test_1",785+ "case_name": "BitwiseAnd_test_1",
786- "operation": "BitwiseAnd",786+ "operation": "BitwiseAnd",
787- "input_tensors": [787+ "input_tensors": [
788- {788+ {
789- "name": "input0",789+ "name": "input0",
790- "shape": [790+ "shape": [
791- 32,791+ 32,
792- 32792+ 32
793- ],793+ ],
794- "dtype": "int8",794+ "dtype": "int8",
795- "data_range": {795+ "format": "ND",
796- "min": -10,796+ "need_trans": false,
797- "max": 10797+ "data_range": {
798- },798+ "min": -10,
799- "format": "ND"799+ "max": 10
800- },800+ }
801- {801+ },
802- "name": "input1",802+ {
803- "shape": [803+ "name": "input1",
804- 32,804+ "shape": [
805- 32805+ 32,
806- ],806+ 32
807- "dtype": "int8",807+ ],
808- "data_range": {808+ "dtype": "int8",
809- "min": -10,809+ "format": "ND",
810- "max": 10810+ "need_trans": false,
811- },811+ "data_range": {
812- "format": "ND"812+ "min": -10,
813- }813+ "max": 10
814- ],814+ }
815- "output_tensors": [815+ }
816- {816+ ],
817- "name": "output0",817+ "output_tensors": [
818- "shape": [818+ {
819- 32,819+ "name": "output0",
820- 32820+ "shape": [
821- ],821+ 32,
822- "dtype": "int8",822+ 32
823- "format": "ND"823+ ],
824- }824+ "dtype": "int8",
825- ],825+ "format": "ND",
826- "view_shape": [826+ "need_trans": false
827- 16,827+ }
828- 16828+ ],
829- ],829+ "view_shape": [
830- "tile_shape": [830+ 16,
831- 16,831+ 16
832- 16832+ ],
833- ],833+ "tile_shape": [
834- "params": {834+ 16,
835- "func_id": -1835+ 16
836- },836+ ],
837- "index": 12837+ "params": {
838- },838+ "on_board": true,
839- {839+ "func_id": -1
840- "case_index": 13,840+ },
841- "case_name": "BitwiseAnd_test_2",841+ "index": 12
842- "operation": "BitwiseAnd",842+ },
843- "input_tensors": [843+ {
844- {844+ "case_index": 13,
845- "name": "input0",845+ "case_name": "BitwiseAnd_test_2",
846- "shape": [846+ "operation": "BitwiseAnd",
847- 32,847+ "input_tensors": [
848- 32848+ {
849- ],849+ "name": "input0",
850- "dtype": "uint8",850+ "shape": [
851- "data_range": {851+ 32,
852- "min": -10,852+ 32
853- "max": 10853+ ],
854- },854+ "dtype": "uint8",
855- "format": "ND"855+ "format": "ND",
856- },856+ "need_trans": false,
857- {857+ "data_range": {
858- "name": "input1",858+ "min": -10,
859- "shape": [859+ "max": 10
860- 32,860+ }
861- 32861+ },
862- ],862+ {
863- "dtype": "uint8",863+ "name": "input1",
864- "data_range": {864+ "shape": [
865- "min": -10,865+ 32,
866- "max": 10866+ 32
867- },867+ ],
868- "format": "ND"868+ "dtype": "uint8",
869- }869+ "format": "ND",
870- ],870+ "need_trans": false,
871- "output_tensors": [871+ "data_range": {
872- {872+ "min": -10,
873- "name": "output0",873+ "max": 10
874- "shape": [874+ }
875- 32,875+ }
876- 32876+ ],
877- ],877+ "output_tensors": [
878- "dtype": "uint8",878+ {
879- "format": "ND"879+ "name": "output0",
880- }880+ "shape": [
881- ],881+ 32,
882- "view_shape": [882+ 32
883- 16,883+ ],
884- 16884+ "dtype": "uint8",
885- ],885+ "format": "ND",
886- "tile_shape": [886+ "need_trans": false
887- 16,887+ }
888- 16888+ ],
889- ],889+ "view_shape": [
890- "params": {890+ 16,
891- "func_id": -1891+ 16
892- },892+ ],
893- "index": 13893+ "tile_shape": [
894- },894+ 16,
895- {895+ 16
896- "case_index": 14,896+ ],
897- "case_name": "BitwiseAnd_test_3",897+ "params": {
898- "operation": "BitwiseAnd",898+ "on_board": true,
899- "input_tensors": [899+ "func_id": -1
900- {900+ },
901- "name": "input0",901+ "index": 13
902- "shape": [902+ },
903- 32,903+ {
904- 32904+ "case_index": 14,
905- ],905+ "case_name": "BitwiseAnd_test_3",
906- "dtype": "int32",906+ "operation": "BitwiseAnd",
907- "data_range": {907+ "input_tensors": [
908- "min": -1000,908+ {
909- "max": 1000909+ "name": "input0",
910- },910+ "shape": [
911- "format": "ND"911+ 32,
912- },912+ 32
913- {913+ ],
914- "name": "input1",914+ "dtype": "int32",
915- "shape": [915+ "format": "ND",
916- 32,916+ "need_trans": false,
917- 32917+ "data_range": {
918- ],918+ "min": -1000,
919- "dtype": "int32",919+ "max": 1000
920- "data_range": {920+ }
921- "min": -1000,921+ },
922- "max": 1000922+ {
923- },923+ "name": "input1",
924- "format": "ND"924+ "shape": [
925- }925+ 32,
926- ],926+ 32
927- "output_tensors": [927+ ],
928- {928+ "dtype": "int32",
929- "name": "output0",929+ "format": "ND",
930- "shape": [930+ "need_trans": false,
931- 32,931+ "data_range": {
932- 32932+ "min": -1000,
933- ],933+ "max": 1000
934- "dtype": "int32",934+ }
935- "format": "ND"935+ }
936- }936+ ],
937- ],937+ "output_tensors": [
938- "view_shape": [938+ {
939- 16,939+ "name": "output0",
940- 16940+ "shape": [
941- ],941+ 32,
942- "tile_shape": [942+ 32
943- 16,943+ ],
944- 16944+ "dtype": "int32",
945- ],945+ "format": "ND",
946- "params": {946+ "need_trans": false
947- "func_id": -1947+ }
948- },948+ ],
949- "index": 14949+ "view_shape": [
950- }950+ 16,
951- ]951+ 16
952+ ],
953+ "tile_shape": [
954+ 16,
955+ 16
956+ ],
957+ "params": {
958+ "on_board": true,
959+ "func_id": -1
960+ },
961+ "index": 14
962+ },
963+ {
964+ "case_index": 15,
965+ "case_name": "BitwiseAnd_test_4",
966+ "operation": "BitwiseAnd",
967+ "input_tensors": [
968+ {
969+ "name": "input0",
970+ "shape": [
971+ 32,
972+ 32
973+ ],
974+ "dtype": "uint32",
975+ "format": "ND",
976+ "need_trans": false,
977+ "data_range": {
978+ "min": 0,
979+ "max": 65535
980+ }
981+ },
982+ {
983+ "name": "input1",
984+ "shape": [
985+ 32,
986+ 32
987+ ],
988+ "dtype": "uint32",
989+ "format": "ND",
990+ "need_trans": false,
991+ "data_range": {
992+ "min": 0,
993+ "max": 65535
994+ }
995+ }
996+ ],
997+ "output_tensors": [
998+ {
999+ "name": "output0",
1000+ "shape": [
1001+ 32,
1002+ 32
1003+ ],
1004+ "dtype": "uint32",
1005+ "format": "ND",
1006+ "need_trans": false
1007+ }
1008+ ],
1009+ "view_shape": [
1010+ 16,
1011+ 16
1012+ ],
1013+ "tile_shape": [
1014+ 16,
1015+ 16
1016+ ],
1017+ "params": {
1018+ "on_board": true,
1019+ "func_id": -1
1020+ },
1021+ "index": 15
1022+ }
1023+ ]
952}1024}
Mframework/tests/st/operation/test_case/BitwiseAnds_st_test_cases.csv+4-0
@@ -11,3 +11,7 @@ BitwiseAnd_scalar_4D_align_0,"[16, 8, 4, 2]",int16,ND,"[0, 255]","[16, 8, 4, 2]"
11BitwiseAnd_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint1611BitwiseAnd_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint16
12BitwiseAnd_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int1612BitwiseAnd_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int16
13BitwiseAnd_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint1613BitwiseAnd_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint16
14+BitwiseAnd_scalar_int8,"[32, 32]",int8,ND,"[-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]",-3,int8
15+BitwiseAnd_scalar_uint8,"[32, 32]",uint8,ND,"[0, 255]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]",240,uint8
16+BitwiseAnd_scalar_int32,"[32, 32]",int32,ND,"[-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]",-257,int32
17+BitwiseAnd_scalar_uint32,"[32, 32]",uint32,ND,"[0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]",65535,uint32
Mframework/tests/st/operation/test_case/BitwiseAnds_st_test_cases.json+192-0
@@ -623,6 +623,198 @@
623 "func_id": -1623 "func_id": -1
624 },624 },
625 "index": 11625 "index": 11
626+ },
627+ {
628+ "case_index": 12,
629+ "case_name": "BitwiseAnd_scalar_int8",
630+ "operation": "BitwiseAnds",
631+ "input_tensors": [
632+ {
633+ "name": "input0",
634+ "shape": [
635+ 32,
636+ 32
637+ ],
638+ "dtype": "int8",
639+ "format": "ND",
640+ "need_trans": false,
641+ "data_range": {
642+ "min": -10,
643+ "max": 10
644+ }
645+ }
646+ ],
647+ "output_tensors": [
648+ {
649+ "name": "output0",
650+ "shape": [
651+ 32,
652+ 32
653+ ],
654+ "dtype": "int8",
655+ "format": "ND",
656+ "need_trans": false
657+ }
658+ ],
659+ "view_shape": [
660+ 16,
661+ 16
662+ ],
663+ "tile_shape": [
664+ 16,
665+ 16
666+ ],
667+ "params": {
668+ "scalar": -3,
669+ "scalar_type": "int8",
670+ "on_board": true,
671+ "func_id": -1
672+ },
673+ "index": 12
674+ },
675+ {
676+ "case_index": 13,
677+ "case_name": "BitwiseAnd_scalar_uint8",
678+ "operation": "BitwiseAnds",
679+ "input_tensors": [
680+ {
681+ "name": "input0",
682+ "shape": [
683+ 32,
684+ 32
685+ ],
686+ "dtype": "uint8",
687+ "format": "ND",
688+ "need_trans": false,
689+ "data_range": {
690+ "min": 0,
691+ "max": 255
692+ }
693+ }
694+ ],
695+ "output_tensors": [
696+ {
697+ "name": "output0",
698+ "shape": [
699+ 32,
700+ 32
701+ ],
702+ "dtype": "uint8",
703+ "format": "ND",
704+ "need_trans": false
705+ }
706+ ],
707+ "view_shape": [
708+ 16,
709+ 16
710+ ],
711+ "tile_shape": [
712+ 16,
713+ 16
714+ ],
715+ "params": {
716+ "scalar": 240,
717+ "scalar_type": "uint8",
718+ "on_board": true,
719+ "func_id": -1
720+ },
721+ "index": 13
722+ },
723+ {
724+ "case_index": 14,
725+ "case_name": "BitwiseAnd_scalar_int32",
726+ "operation": "BitwiseAnds",
727+ "input_tensors": [
728+ {
729+ "name": "input0",
730+ "shape": [
731+ 32,
732+ 32
733+ ],
734+ "dtype": "int32",
735+ "format": "ND",
736+ "need_trans": false,
737+ "data_range": {
738+ "min": -1000,
739+ "max": 1000
740+ }
741+ }
742+ ],
743+ "output_tensors": [
744+ {
745+ "name": "output0",
746+ "shape": [
747+ 32,
748+ 32
749+ ],
750+ "dtype": "int32",
751+ "format": "ND",
752+ "need_trans": false
753+ }
754+ ],
755+ "view_shape": [
756+ 16,
757+ 16
758+ ],
759+ "tile_shape": [
760+ 16,
761+ 16
762+ ],
763+ "params": {
764+ "scalar": -257,
765+ "scalar_type": "int32",
766+ "on_board": true,
767+ "func_id": -1
768+ },
769+ "index": 14
770+ },
771+ {
772+ "case_index": 15,
773+ "case_name": "BitwiseAnd_scalar_uint32",
774+ "operation": "BitwiseAnds",
775+ "input_tensors": [
776+ {
777+ "name": "input0",
778+ "shape": [
779+ 32,
780+ 32
781+ ],
782+ "dtype": "uint32",
783+ "format": "ND",
784+ "need_trans": false,
785+ "data_range": {
786+ "min": 0,
787+ "max": 65535
788+ }
789+ }
790+ ],
791+ "output_tensors": [
792+ {
793+ "name": "output0",
794+ "shape": [
795+ 32,
796+ 32
797+ ],
798+ "dtype": "uint32",
799+ "format": "ND",
800+ "need_trans": false
801+ }
802+ ],
803+ "view_shape": [
804+ 16,
805+ 16
806+ ],
807+ "tile_shape": [
808+ 16,
809+ 16
810+ ],
811+ "params": {
812+ "scalar": 65535,
813+ "scalar_type": "uint32",
814+ "on_board": true,
815+ "func_id": -1
816+ },
817+ "index": 15
626 }818 }
627 ]819 ]
628}820}
Mframework/tests/st/operation/test_case/BitwiseNot_st_test_cases.csv+1-0
@@ -18,3 +18,4 @@ BitwiseNot_test_16,"[1, 100, 100, 1]",int16,ND,"[-32768, 32767]","[1, 100, 100,
18BitwiseNot_test_17,"[32, 32]",int8,ND,"[-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"18BitwiseNot_test_17,"[32, 32]",int8,ND,"[-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"
19BitwiseNot_test_18,"[32, 32]",uint8,ND,"[-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"19BitwiseNot_test_18,"[32, 32]",uint8,ND,"[-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"
20BitwiseNot_test_19,"[32, 32]",int32,ND,"[-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"20BitwiseNot_test_19,"[32, 32]",int32,ND,"[-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"
21+BitwiseNot_test_20,"[32, 32]",uint32,ND,"[0, 1000]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]"
Mframework/tests/st/operation/test_case/BitwiseNot_st_test_cases.json+991-936
@@ -1,937 +1,992 @@
1-{1+{
2- "test_cases": [2+ "test_cases": [
3- {3+ {
4- "case_index": 0,4+ "case_index": 0,
5- "case_name": "BitwiseNot_test_1",5+ "case_name": "BitwiseNot_test_1",
6- "operation": "BitwiseNot",6+ "operation": "BitwiseNot",
7- "input_tensors": [7+ "input_tensors": [
8- {8+ {
9- "name": "input0",9+ "name": "input0",
10- "shape": [10+ "shape": [
11- 32,11+ 32,
12- 3212+ 32
13- ],13+ ],
14- "dtype": "int16",14+ "dtype": "int16",
15- "format": "ND",15+ "format": "ND",
16- "need_trans": false,16+ "need_trans": false,
17- "data_range": {17+ "data_range": {
18- "min": 0,18+ "min": 0,
19- "max": 3219+ "max": 32
20- }20+ }
21- }21+ }
22- ],22+ ],
23- "output_tensors": [23+ "output_tensors": [
24- {24+ {
25- "name": "output0",25+ "name": "output0",
26- "shape": [26+ "shape": [
27- 32,27+ 32,
28- 3228+ 32
29- ],29+ ],
30- "dtype": "int16",30+ "dtype": "int16",
31- "format": "ND",31+ "format": "ND",
32- "need_trans": false32+ "need_trans": false
33- }33+ }
34- ],34+ ],
35- "view_shape": [35+ "view_shape": [
36- 16,36+ 16,
37- 1637+ 16
38- ],38+ ],
39- "tile_shape": [39+ "tile_shape": [
40- 16,40+ 16,
41- 1641+ 16
42- ],42+ ],
43- "params": {43+ "params": {
44- "on_board": true,44+ "on_board": true,
45- "func_id": -145+ "func_id": -1
46- },46+ },
47- "index": 047+ "index": 0
48- },48+ },
49- {49+ {
50- "case_index": 1,50+ "case_index": 1,
51- "case_name": "BitwiseNot_test_2",51+ "case_name": "BitwiseNot_test_2",
52- "operation": "BitwiseNot",52+ "operation": "BitwiseNot",
53- "input_tensors": [53+ "input_tensors": [
54- {54+ {
55- "name": "input0",55+ "name": "input0",
56- "shape": [56+ "shape": [
57- 64,57+ 64,
58- 4858+ 48
59- ],59+ ],
60- "dtype": "uint16",60+ "dtype": "uint16",
61- "format": "ND",61+ "format": "ND",
62- "need_trans": false,62+ "need_trans": false,
63- "data_range": {63+ "data_range": {
64- "min": 0,64+ "min": 0,
65- "max": 6553565+ "max": 65535
66- }66+ }
67- }67+ }
68- ],68+ ],
69- "output_tensors": [69+ "output_tensors": [
70- {70+ {
71- "name": "output0",71+ "name": "output0",
72- "shape": [72+ "shape": [
73- 64,73+ 64,
74- 4874+ 48
75- ],75+ ],
76- "dtype": "uint16",76+ "dtype": "uint16",
77- "format": "ND",77+ "format": "ND",
78- "need_trans": false78+ "need_trans": false
79- }79+ }
80- ],80+ ],
81- "view_shape": [81+ "view_shape": [
82- 32,82+ 32,
83- 2483+ 24
84- ],84+ ],
85- "tile_shape": [85+ "tile_shape": [
86- 32,86+ 32,
87- 2487+ 24
88- ],88+ ],
89- "params": {89+ "params": {
90- "on_board": true,90+ "on_board": true,
91- "func_id": -191+ "func_id": -1
92- },92+ },
93- "index": 193+ "index": 1
94- },94+ },
95- {95+ {
96- "case_index": 2,96+ "case_index": 2,
97- "case_name": "BitwiseNot_test_3",97+ "case_name": "BitwiseNot_test_3",
98- "operation": "BitwiseNot",98+ "operation": "BitwiseNot",
99- "input_tensors": [99+ "input_tensors": [
100- {100+ {
101- "name": "input0",101+ "name": "input0",
102- "shape": [102+ "shape": [
103- 33,103+ 33,
104- 31104+ 31
105- ],105+ ],
106- "dtype": "bool",106+ "dtype": "bool",
107- "format": "ND",107+ "format": "ND",
108- "need_trans": false,108+ "need_trans": false,
109- "data_range": {109+ "data_range": {
110- "min": 0,110+ "min": 0,
111- "max": 1111+ "max": 1
112- }112+ }
113- }113+ }
114- ],114+ ],
115- "output_tensors": [115+ "output_tensors": [
116- {116+ {
117- "name": "output0",117+ "name": "output0",
118- "shape": [118+ "shape": [
119- 33,119+ 33,
120- 31120+ 31
121- ],121+ ],
122- "dtype": "bool",122+ "dtype": "bool",
123- "format": "ND",123+ "format": "ND",
124- "need_trans": false124+ "need_trans": false
125- }125+ }
126- ],126+ ],
127- "view_shape": [127+ "view_shape": [
128- 17,128+ 17,
129- 16129+ 16
130- ],130+ ],
131- "tile_shape": [131+ "tile_shape": [
132- 17,132+ 17,
133- 16133+ 16
134- ],134+ ],
135- "params": {135+ "params": {
136- "on_board": true,136+ "on_board": true,
137- "func_id": -1137+ "func_id": -1
138- },138+ },
139- "index": 2139+ "index": 2
140- },140+ },
141- {141+ {
142- "case_index": 3,142+ "case_index": 3,
143- "case_name": "BitwiseNot_test_4",143+ "case_name": "BitwiseNot_test_4",
144- "operation": "BitwiseNot",144+ "operation": "BitwiseNot",
145- "input_tensors": [145+ "input_tensors": [
146- {146+ {
147- "name": "input0",147+ "name": "input0",
148- "shape": [148+ "shape": [
149- 128,149+ 128,
150- 96150+ 96
151- ],151+ ],
152- "dtype": "int16",152+ "dtype": "int16",
153- "format": "ND",153+ "format": "ND",
154- "need_trans": false,154+ "need_trans": false,
155- "data_range": {155+ "data_range": {
156- "min": -32768,156+ "min": -32768,
157- "max": 32767157+ "max": 32767
158- }158+ }
159- }159+ }
160- ],160+ ],
161- "output_tensors": [161+ "output_tensors": [
162- {162+ {
163- "name": "output0",163+ "name": "output0",
164- "shape": [164+ "shape": [
165- 128,165+ 128,
166- 96166+ 96
167- ],167+ ],
168- "dtype": "int16",168+ "dtype": "int16",
169- "format": "ND",169+ "format": "ND",
170- "need_trans": false170+ "need_trans": false
171- }171+ }
172- ],172+ ],
173- "view_shape": [173+ "view_shape": [
174- 64,174+ 64,
175- 48175+ 48
176- ],176+ ],
177- "tile_shape": [177+ "tile_shape": [
178- 64,178+ 64,
179- 48179+ 48
180- ],180+ ],
181- "params": {181+ "params": {
182- "on_board": true,182+ "on_board": true,
183- "func_id": -1183+ "func_id": -1
184- },184+ },
185- "index": 3185+ "index": 3
186- },186+ },
187- {187+ {
188- "case_index": 4,188+ "case_index": 4,
189- "case_name": "BitwiseNot_test_5",189+ "case_name": "BitwiseNot_test_5",
190- "operation": "BitwiseNot",190+ "operation": "BitwiseNot",
191- "input_tensors": [191+ "input_tensors": [
192- {192+ {
193- "name": "input0",193+ "name": "input0",
194- "shape": [194+ "shape": [
195- 47,195+ 47,
196- 53196+ 53
197- ],197+ ],
198- "dtype": "uint16",198+ "dtype": "uint16",
199- "format": "ND",199+ "format": "ND",
200- "need_trans": false,200+ "need_trans": false,
201- "data_range": {201+ "data_range": {
202- "min": 0,202+ "min": 0,
203- "max": 1000203+ "max": 1000
204- }204+ }
205- }205+ }
206- ],206+ ],
207- "output_tensors": [207+ "output_tensors": [
208- {208+ {
209- "name": "output0",209+ "name": "output0",
210- "shape": [210+ "shape": [
211- 47,211+ 47,
212- 53212+ 53
213- ],213+ ],
214- "dtype": "uint16",214+ "dtype": "uint16",
215- "format": "ND",215+ "format": "ND",
216- "need_trans": false216+ "need_trans": false
217- }217+ }
218- ],218+ ],
219- "view_shape": [219+ "view_shape": [
220- 24,220+ 24,
221- 27221+ 27
222- ],222+ ],
223- "tile_shape": [223+ "tile_shape": [
224- 24,224+ 24,
225- 27225+ 27
226- ],226+ ],
227- "params": {227+ "params": {
228- "on_board": true,228+ "on_board": true,
229- "func_id": -1229+ "func_id": -1
230- },230+ },
231- "index": 4231+ "index": 4
232- },232+ },
233- {233+ {
234- "case_index": 5,234+ "case_index": 5,
235- "case_name": "BitwiseNot_test_6",235+ "case_name": "BitwiseNot_test_6",
236- "operation": "BitwiseNot",236+ "operation": "BitwiseNot",
237- "input_tensors": [237+ "input_tensors": [
238- {238+ {
239- "name": "input0",239+ "name": "input0",
240- "shape": [240+ "shape": [
241- 150,241+ 150,
242- 120,242+ 120,
243- 2243+ 2
244- ],244+ ],
245- "dtype": "int16",245+ "dtype": "int16",
246- "format": "ND",246+ "format": "ND",
247- "need_trans": false,247+ "need_trans": false,
248- "data_range": {248+ "data_range": {
249- "min": -32768,249+ "min": -32768,
250- "max": 32767250+ "max": 32767
251- }251+ }
252- }252+ }
253- ],253+ ],
254- "output_tensors": [254+ "output_tensors": [
255- {255+ {
256- "name": "output0",256+ "name": "output0",
257- "shape": [257+ "shape": [
258- 150,258+ 150,
259- 120,259+ 120,
260- 2260+ 2
261- ],261+ ],
262- "dtype": "int16",262+ "dtype": "int16",
263- "format": "ND",263+ "format": "ND",
264- "need_trans": false264+ "need_trans": false
265- }265+ }
266- ],266+ ],
267- "view_shape": [267+ "view_shape": [
268- 75,268+ 75,
269- 60,269+ 60,
270- 2270+ 2
271- ],271+ ],
272- "tile_shape": [272+ "tile_shape": [
273- 75,273+ 75,
274- 60,274+ 60,
275- 2275+ 2
276- ],276+ ],
277- "params": {277+ "params": {
278- "on_board": true,278+ "on_board": true,
279- "func_id": -1279+ "func_id": -1
280- },280+ },
281- "index": 5281+ "index": 5
282- },282+ },
283- {283+ {
284- "case_index": 6,284+ "case_index": 6,
285- "case_name": "BitwiseNot_test_7",285+ "case_name": "BitwiseNot_test_7",
286- "operation": "BitwiseNot",286+ "operation": "BitwiseNot",
287- "input_tensors": [287+ "input_tensors": [
288- {288+ {
289- "name": "input0",289+ "name": "input0",
290- "shape": [290+ "shape": [
291- 32,291+ 32,
292- 32,292+ 32,
293- 3293+ 3
294- ],294+ ],
295- "dtype": "uint16",295+ "dtype": "uint16",
296- "format": "ND",296+ "format": "ND",
297- "need_trans": false,297+ "need_trans": false,
298- "data_range": {298+ "data_range": {
299- "min": 0,299+ "min": 0,
300- "max": 65535300+ "max": 65535
301- }301+ }
302- }302+ }
303- ],303+ ],
304- "output_tensors": [304+ "output_tensors": [
305- {305+ {
306- "name": "output0",306+ "name": "output0",
307- "shape": [307+ "shape": [
308- 32,308+ 32,
309- 32,309+ 32,
310- 3310+ 3
311- ],311+ ],
312- "dtype": "uint16",312+ "dtype": "uint16",
313- "format": "ND",313+ "format": "ND",
314- "need_trans": false314+ "need_trans": false
315- }315+ }
316- ],316+ ],
317- "view_shape": [317+ "view_shape": [
318- 16,318+ 16,
319- 16,319+ 16,
320- 3320+ 3
321- ],321+ ],
322- "tile_shape": [322+ "tile_shape": [
323- 16,323+ 16,
324- 16,324+ 16,
325- 3325+ 3
326- ],326+ ],
327- "params": {327+ "params": {
328- "on_board": true,328+ "on_board": true,
329- "func_id": -1329+ "func_id": -1
330- },330+ },
331- "index": 6331+ "index": 6
332- },332+ },
333- {333+ {
334- "case_index": 7,334+ "case_index": 7,
335- "case_name": "BitwiseNot_test_8",335+ "case_name": "BitwiseNot_test_8",
336- "operation": "BitwiseNot",336+ "operation": "BitwiseNot",
337- "input_tensors": [337+ "input_tensors": [
338- {338+ {
339- "name": "input0",339+ "name": "input0",
340- "shape": [340+ "shape": [
341- 32,341+ 32,
342- 16,342+ 16,
343- 4343+ 4
344- ],344+ ],
345- "dtype": "bool",345+ "dtype": "bool",
346- "format": "ND",346+ "format": "ND",
347- "need_trans": false,347+ "need_trans": false,
348- "data_range": {348+ "data_range": {
349- "min": 0,349+ "min": 0,
350- "max": 1350+ "max": 1
351- }351+ }
352- }352+ }
353- ],353+ ],
354- "output_tensors": [354+ "output_tensors": [
355- {355+ {
356- "name": "output0",356+ "name": "output0",
357- "shape": [357+ "shape": [
358- 32,358+ 32,
359- 16,359+ 16,
360- 4360+ 4
361- ],361+ ],
362- "dtype": "bool",362+ "dtype": "bool",
363- "format": "ND",363+ "format": "ND",
364- "need_trans": false364+ "need_trans": false
365- }365+ }
366- ],366+ ],
367- "view_shape": [367+ "view_shape": [
368- 16,368+ 16,
369- 8,369+ 8,
370- 4370+ 4
371- ],371+ ],
372- "tile_shape": [372+ "tile_shape": [
373- 16,373+ 16,
374- 8,374+ 8,
375- 4375+ 4
376- ],376+ ],
377- "params": {377+ "params": {
378- "on_board": true,378+ "on_board": true,
379- "func_id": -1379+ "func_id": -1
380- },380+ },
381- "index": 7381+ "index": 7
382- },382+ },
383- {383+ {
384- "case_index": 8,384+ "case_index": 8,
385- "case_name": "BitwiseNot_test_9",385+ "case_name": "BitwiseNot_test_9",
386- "operation": "BitwiseNot",386+ "operation": "BitwiseNot",
387- "input_tensors": [387+ "input_tensors": [
388- {388+ {
389- "name": "input0",389+ "name": "input0",
390- "shape": [390+ "shape": [
391- 65,391+ 65,
392- 33,392+ 33,
393- 2393+ 2
394- ],394+ ],
395- "dtype": "int16",395+ "dtype": "int16",
396- "format": "ND",396+ "format": "ND",
397- "need_trans": false,397+ "need_trans": false,
398- "data_range": {398+ "data_range": {
399- "min": -100,399+ "min": -100,
400- "max": 100400+ "max": 100
401- }401+ }
402- }402+ }
403- ],403+ ],
404- "output_tensors": [404+ "output_tensors": [
405- {405+ {
406- "name": "output0",406+ "name": "output0",
407- "shape": [407+ "shape": [
408- 65,408+ 65,
409- 33,409+ 33,
410- 2410+ 2
411- ],411+ ],
412- "dtype": "int16",412+ "dtype": "int16",
413- "format": "ND",413+ "format": "ND",
414- "need_trans": false414+ "need_trans": false
415- }415+ }
416- ],416+ ],
417- "view_shape": [417+ "view_shape": [
418- 33,418+ 33,
419- 17,419+ 17,
420- 2420+ 2
421- ],421+ ],
422- "tile_shape": [422+ "tile_shape": [
423- 33,423+ 33,
424- 17,424+ 17,
425- 2425+ 2
426- ],426+ ],
427- "params": {427+ "params": {
428- "on_board": true,428+ "on_board": true,
429- "func_id": -1429+ "func_id": -1
430- },430+ },
431- "index": 8431+ "index": 8
432- },432+ },
433- {433+ {
434- "case_index": 9,434+ "case_index": 9,
435- "case_name": "BitwiseNot_test_10",435+ "case_name": "BitwiseNot_test_10",
436- "operation": "BitwiseNot",436+ "operation": "BitwiseNot",
437- "input_tensors": [437+ "input_tensors": [
438- {438+ {
439- "name": "input0",439+ "name": "input0",
440- "shape": [440+ "shape": [
441- 128,441+ 128,
442- 64,442+ 64,
443- 1443+ 1
444- ],444+ ],
445- "dtype": "uint16",445+ "dtype": "uint16",
446- "format": "ND",446+ "format": "ND",
447- "need_trans": false,447+ "need_trans": false,
448- "data_range": {448+ "data_range": {
449- "min": 0,449+ "min": 0,
450- "max": 5000450+ "max": 5000
451- }451+ }
452- }452+ }
453- ],453+ ],
454- "output_tensors": [454+ "output_tensors": [
455- {455+ {
456- "name": "output0",456+ "name": "output0",
457- "shape": [457+ "shape": [
458- 128,458+ 128,
459- 64,459+ 64,
460- 1460+ 1
461- ],461+ ],
462- "dtype": "uint16",462+ "dtype": "uint16",
463- "format": "ND",463+ "format": "ND",
464- "need_trans": false464+ "need_trans": false
465- }465+ }
466- ],466+ ],
467- "view_shape": [467+ "view_shape": [
468- 64,468+ 64,
469- 32,469+ 32,
470- 1470+ 1
471- ],471+ ],
472- "tile_shape": [472+ "tile_shape": [
473- 64,473+ 64,
474- 32,474+ 32,
475- 1475+ 1
476- ],476+ ],
477- "params": {477+ "params": {
478- "on_board": true,478+ "on_board": true,
479- "func_id": -1479+ "func_id": -1
480- },480+ },
481- "index": 9481+ "index": 9
482- },482+ },
483- {483+ {
484- "case_index": 10,484+ "case_index": 10,
485- "case_name": "BitwiseNot_test_11",485+ "case_name": "BitwiseNot_test_11",
486- "operation": "BitwiseNot",486+ "operation": "BitwiseNot",
487- "input_tensors": [487+ "input_tensors": [
488- {488+ {
489- "name": "input0",489+ "name": "input0",
490- "shape": [490+ "shape": [
491- 16,491+ 16,
492- 32,492+ 32,
493- 24,493+ 24,
494- 2494+ 2
495- ],495+ ],
496- "dtype": "int16",496+ "dtype": "int16",
497- "format": "ND",497+ "format": "ND",
498- "need_trans": false,498+ "need_trans": false,
499- "data_range": {499+ "data_range": {
500- "min": -32768,500+ "min": -32768,
501- "max": 32767501+ "max": 32767
502- }502+ }
503- }503+ }
504- ],504+ ],
505- "output_tensors": [505+ "output_tensors": [
506- {506+ {
507- "name": "output0",507+ "name": "output0",
508- "shape": [508+ "shape": [
509- 16,509+ 16,
510- 32,510+ 32,
511- 24,511+ 24,
512- 2512+ 2
513- ],513+ ],
514- "dtype": "int16",514+ "dtype": "int16",
515- "format": "ND",515+ "format": "ND",
516- "need_trans": false516+ "need_trans": false
517- }517+ }
518- ],518+ ],
519- "view_shape": [519+ "view_shape": [
520- 8,520+ 8,
521- 16,521+ 16,
522- 12,522+ 12,
523- 2523+ 2
524- ],524+ ],
525- "tile_shape": [525+ "tile_shape": [
526- 8,526+ 8,
527- 16,527+ 16,
528- 12,528+ 12,
529- 2529+ 2
530- ],530+ ],
531- "params": {531+ "params": {
532- "on_board": true,532+ "on_board": true,
533- "func_id": -1533+ "func_id": -1
534- },534+ },
535- "index": 10535+ "index": 10
536- },536+ },
537- {537+ {
538- "case_index": 11,538+ "case_index": 11,
539- "case_name": "BitwiseNot_test_12",539+ "case_name": "BitwiseNot_test_12",
540- "operation": "BitwiseNot",540+ "operation": "BitwiseNot",
541- "input_tensors": [541+ "input_tensors": [
542- {542+ {
543- "name": "input0",543+ "name": "input0",
544- "shape": [544+ "shape": [
545- 8,545+ 8,
546- 16,546+ 16,
547- 32,547+ 32,
548- 3548+ 3
549- ],549+ ],
550- "dtype": "uint16",550+ "dtype": "uint16",
551- "format": "ND",551+ "format": "ND",
552- "need_trans": false,552+ "need_trans": false,
553- "data_range": {553+ "data_range": {
554- "min": 0,554+ "min": 0,
555- "max": 65535555+ "max": 65535
556- }556+ }
557- }557+ }
558- ],558+ ],
559- "output_tensors": [559+ "output_tensors": [
560- {560+ {
561- "name": "output0",561+ "name": "output0",
562- "shape": [562+ "shape": [
563- 8,563+ 8,
564- 16,564+ 16,
565- 32,565+ 32,
566- 3566+ 3
567- ],567+ ],
568- "dtype": "uint16",568+ "dtype": "uint16",
569- "format": "ND",569+ "format": "ND",
570- "need_trans": false570+ "need_trans": false
571- }571+ }
572- ],572+ ],
573- "view_shape": [573+ "view_shape": [
574- 4,574+ 4,
575- 8,575+ 8,
576- 16,576+ 16,
577- 3577+ 3
578- ],578+ ],
579- "tile_shape": [579+ "tile_shape": [
580- 4,580+ 4,
581- 8,581+ 8,
582- 16,582+ 16,
583- 3583+ 3
584- ],584+ ],
585- "params": {585+ "params": {
586- "on_board": true,586+ "on_board": true,
587- "func_id": -1587+ "func_id": -1
588- },588+ },
589- "index": 11589+ "index": 11
590- },590+ },
591- {591+ {
592- "case_index": 12,592+ "case_index": 12,
593- "case_name": "BitwiseNot_test_13",593+ "case_name": "BitwiseNot_test_13",
594- "operation": "BitwiseNot",594+ "operation": "BitwiseNot",
595- "input_tensors": [595+ "input_tensors": [
596- {596+ {
597- "name": "input0",597+ "name": "input0",
598- "shape": [598+ "shape": [
599- 4,599+ 4,
600- 8,600+ 8,
601- 16,601+ 16,
602- 4602+ 4
603- ],603+ ],
604- "dtype": "bool",604+ "dtype": "bool",
605- "format": "ND",605+ "format": "ND",
606- "need_trans": false,606+ "need_trans": false,
607- "data_range": {607+ "data_range": {
608- "min": 0,608+ "min": 0,
609- "max": 1609+ "max": 1
610- }610+ }
611- }611+ }
612- ],612+ ],
613- "output_tensors": [613+ "output_tensors": [
614- {614+ {
615- "name": "output0",615+ "name": "output0",
616- "shape": [616+ "shape": [
617- 4,617+ 4,
618- 8,618+ 8,
619- 16,619+ 16,
620- 4620+ 4
621- ],621+ ],
622- "dtype": "bool",622+ "dtype": "bool",
623- "format": "ND",623+ "format": "ND",
624- "need_trans": false624+ "need_trans": false
625- }625+ }
626- ],626+ ],
627- "view_shape": [627+ "view_shape": [
628- 2,628+ 2,
629- 4,629+ 4,
630- 8,630+ 8,
631- 4631+ 4
632- ],632+ ],
633- "tile_shape": [633+ "tile_shape": [
634- 2,634+ 2,
635- 4,635+ 4,
636- 8,636+ 8,
637- 4637+ 4
638- ],638+ ],
639- "params": {639+ "params": {
640- "on_board": true,640+ "on_board": true,
641- "func_id": -1641+ "func_id": -1
642- },642+ },
643- "index": 12643+ "index": 12
644- },644+ },
645- {645+ {
646- "case_index": 13,646+ "case_index": 13,
647- "case_name": "BitwiseNot_test_14",647+ "case_name": "BitwiseNot_test_14",
648- "operation": "BitwiseNot",648+ "operation": "BitwiseNot",
649- "input_tensors": [649+ "input_tensors": [
650- {650+ {
651- "name": "input0",651+ "name": "input0",
652- "shape": [652+ "shape": [
653- 9,653+ 9,
654- 17,654+ 17,
655- 33,655+ 33,
656- 2656+ 2
657- ],657+ ],
658- "dtype": "int16",658+ "dtype": "int16",
659- "format": "ND",659+ "format": "ND",
660- "need_trans": false,660+ "need_trans": false,
661- "data_range": {661+ "data_range": {
662- "min": -500,662+ "min": -500,
663- "max": 500663+ "max": 500
664- }664+ }
665- }665+ }
666- ],666+ ],
667- "output_tensors": [667+ "output_tensors": [
668- {668+ {
669- "name": "output0",669+ "name": "output0",
670- "shape": [670+ "shape": [
671- 9,671+ 9,
672- 17,672+ 17,
673- 33,673+ 33,
674- 2674+ 2
675- ],675+ ],
676- "dtype": "int16",676+ "dtype": "int16",
677- "format": "ND",677+ "format": "ND",
678- "need_trans": false678+ "need_trans": false
679- }679+ }
680- ],680+ ],
681- "view_shape": [681+ "view_shape": [
682- 5,682+ 5,
683- 9,683+ 9,
684- 17,684+ 17,
685- 2685+ 2
686- ],686+ ],
687- "tile_shape": [687+ "tile_shape": [
688- 5,688+ 5,
689- 9,689+ 9,
690- 17,690+ 17,
691- 2691+ 2
692- ],692+ ],
693- "params": {693+ "params": {
694- "on_board": true,694+ "on_board": true,
695- "func_id": -1695+ "func_id": -1
696- },696+ },
697- "index": 13697+ "index": 13
698- },698+ },
699- {699+ {
700- "case_index": 14,700+ "case_index": 14,
701- "case_name": "BitwiseNot_test_15",701+ "case_name": "BitwiseNot_test_15",
702- "operation": "BitwiseNot",702+ "operation": "BitwiseNot",
703- "input_tensors": [703+ "input_tensors": [
704- {704+ {
705- "name": "input0",705+ "name": "input0",
706- "shape": [706+ "shape": [
707- 10,707+ 10,
708- 20,708+ 20,
709- 30,709+ 30,
710- 1710+ 1
711- ],711+ ],
712- "dtype": "uint16",712+ "dtype": "uint16",
713- "format": "ND",713+ "format": "ND",
714- "need_trans": false,714+ "need_trans": false,
715- "data_range": {715+ "data_range": {
716- "min": 0,716+ "min": 0,
717- "max": 10000717+ "max": 10000
718- }718+ }
719- }719+ }
720- ],720+ ],
721- "output_tensors": [721+ "output_tensors": [
722- {722+ {
723- "name": "output0",723+ "name": "output0",
724- "shape": [724+ "shape": [
725- 10,725+ 10,
726- 20,726+ 20,
727- 30,727+ 30,
728- 1728+ 1
729- ],729+ ],
730- "dtype": "uint16",730+ "dtype": "uint16",
731- "format": "ND",731+ "format": "ND",
732- "need_trans": false732+ "need_trans": false
733- }733+ }
734- ],734+ ],
735- "view_shape": [735+ "view_shape": [
736- 5,736+ 5,
737- 10,737+ 10,
738- 15,738+ 15,
739- 1739+ 1
740- ],740+ ],
741- "tile_shape": [741+ "tile_shape": [
742- 5,742+ 5,
743- 10,743+ 10,
744- 15,744+ 15,
745- 1745+ 1
746- ],746+ ],
747- "params": {747+ "params": {
748- "on_board": true,748+ "on_board": true,
749- "func_id": -1749+ "func_id": -1
750- },750+ },
751- "index": 14751+ "index": 14
752- },752+ },
753- {753+ {
754- "case_index": 15,754+ "case_index": 15,
755- "case_name": "BitwiseNot_test_16",755+ "case_name": "BitwiseNot_test_16",
756- "operation": "BitwiseNot",756+ "operation": "BitwiseNot",
757- "input_tensors": [757+ "input_tensors": [
758- {758+ {
759- "name": "input0",759+ "name": "input0",
760- "shape": [760+ "shape": [
761- 1,761+ 1,
762- 100,762+ 100,
763- 100,763+ 100,
764- 1764+ 1
765- ],765+ ],
766- "dtype": "int16",766+ "dtype": "int16",
767- "format": "ND",767+ "format": "ND",
768- "need_trans": false,768+ "need_trans": false,
769- "data_range": {769+ "data_range": {
770- "min": -32768,770+ "min": -32768,
771- "max": 32767771+ "max": 32767
772- }772+ }
773- }773+ }
774- ],774+ ],
775- "output_tensors": [775+ "output_tensors": [
776- {776+ {
777- "name": "output0",777+ "name": "output0",
778- "shape": [778+ "shape": [
779- 1,779+ 1,
780- 100,780+ 100,
781- 100,781+ 100,
782- 1782+ 1
783- ],783+ ],
784- "dtype": "int16",784+ "dtype": "int16",
785- "format": "ND",785+ "format": "ND",
786- "need_trans": false786+ "need_trans": false
787- }787+ }
788- ],788+ ],
789- "view_shape": [789+ "view_shape": [
790- 1,790+ 1,
791- 50,791+ 50,
792- 50,792+ 50,
793- 1793+ 1
794- ],794+ ],
795- "tile_shape": [795+ "tile_shape": [
796- 1,796+ 1,
797- 50,797+ 50,
798- 50,798+ 50,
799- 1799+ 1
800- ],800+ ],
801- "params": {801+ "params": {
802- "on_board": true,802+ "on_board": true,
803- "func_id": -1803+ "func_id": -1
804- },804+ },
805- "index": 15805+ "index": 15
806- },806+ },
807- {807+ {
808- "case_index": 16,808+ "case_index": 16,
809- "case_name": "BitwiseNot_test_17",809+ "case_name": "BitwiseNot_test_17",
810- "operation": "BitwiseNot",810+ "operation": "BitwiseNot",
811- "input_tensors": [811+ "input_tensors": [
812- {812+ {
813- "name": "input0",813+ "name": "input0",
814- "shape": [814+ "shape": [
815- 32,815+ 32,
816- 32816+ 32
817- ],817+ ],
818- "dtype": "int8",818+ "dtype": "int8",
819- "data_range": {819+ "format": "ND",
820- "min": -10,820+ "need_trans": false,
821- "max": 10821+ "data_range": {
822- },822+ "min": -10,
823- "format": "ND"823+ "max": 10
824- }824+ }
825- ],825+ }
826- "output_tensors": [826+ ],
827- {827+ "output_tensors": [
828- "name": "output0",828+ {
829- "shape": [829+ "name": "output0",
830- 32,830+ "shape": [
831- 32831+ 32,
832- ],832+ 32
833- "dtype": "int8",833+ ],
834- "format": "ND"834+ "dtype": "int8",
835- }835+ "format": "ND",
836- ],836+ "need_trans": false
837- "view_shape": [837+ }
838- 16,838+ ],
839- 16839+ "view_shape": [
840- ],840+ 16,
841- "tile_shape": [841+ 16
842- 16,842+ ],
843- 16843+ "tile_shape": [
844- ],844+ 16,
845- "params": {845+ 16
846- "func_id": -1846+ ],
847- },847+ "params": {
848- "index": 16848+ "on_board": true,
849- },849+ "func_id": -1
850- {850+ },
851- "case_index": 17,851+ "index": 16
852- "case_name": "BitwiseNot_test_18",852+ },
853- "operation": "BitwiseNot",853+ {
854- "input_tensors": [854+ "case_index": 17,
855- {855+ "case_name": "BitwiseNot_test_18",
856- "name": "input0",856+ "operation": "BitwiseNot",
857- "shape": [857+ "input_tensors": [
858- 32,858+ {
859- 32859+ "name": "input0",
860- ],860+ "shape": [
861- "dtype": "uint8",861+ 32,
862- "data_range": {862+ 32
863- "min": -10,863+ ],
864- "max": 10864+ "dtype": "uint8",
865- },865+ "format": "ND",
866- "format": "ND"866+ "need_trans": false,
867- }867+ "data_range": {
868- ],868+ "min": -10,
869- "output_tensors": [869+ "max": 10
870- {870+ }
871- "name": "output0",871+ }
872- "shape": [872+ ],
873- 32,873+ "output_tensors": [
874- 32874+ {
875- ],875+ "name": "output0",
876- "dtype": "uint8",876+ "shape": [
877- "format": "ND"877+ 32,
878- }878+ 32
879- ],879+ ],
880- "view_shape": [880+ "dtype": "uint8",
881- 16,881+ "format": "ND",
882- 16882+ "need_trans": false
883- ],883+ }
884- "tile_shape": [884+ ],
885- 16,885+ "view_shape": [
886- 16886+ 16,
887- ],887+ 16
888- "params": {888+ ],
889- "func_id": -1889+ "tile_shape": [
890- },890+ 16,
891- "index": 17891+ 16
892- },892+ ],
893- {893+ "params": {
894- "case_index": 18,894+ "on_board": true,
895- "case_name": "BitwiseNot_test_19",895+ "func_id": -1
896- "operation": "BitwiseNot",896+ },
897- "input_tensors": [897+ "index": 17
898- {898+ },
899- "name": "input0",899+ {
900- "shape": [900+ "case_index": 18,
901- 32,901+ "case_name": "BitwiseNot_test_19",
902- 32902+ "operation": "BitwiseNot",
903- ],903+ "input_tensors": [
904- "dtype": "int32",904+ {
905- "data_range": {905+ "name": "input0",
906- "min": -1000,906+ "shape": [
907- "max": 1000907+ 32,
908- },908+ 32
909- "format": "ND"909+ ],
910- }910+ "dtype": "int32",
911- ],911+ "format": "ND",
912- "output_tensors": [912+ "need_trans": false,
913- {913+ "data_range": {
914- "name": "output0",914+ "min": -1000,
915- "shape": [915+ "max": 1000
916- 32,916+ }
917- 32917+ }
918- ],918+ ],
919- "dtype": "int32",919+ "output_tensors": [
920- "format": "ND"920+ {
921- }921+ "name": "output0",
922- ],922+ "shape": [
923- "view_shape": [923+ 32,
924- 16,924+ 32
925- 16925+ ],
926- ],926+ "dtype": "int32",
927- "tile_shape": [927+ "format": "ND",
928- 16,928+ "need_trans": false
929- 16929+ }
930- ],930+ ],
931- "params": {931+ "view_shape": [
932- "func_id": -1932+ 16,
933- },933+ 16
934- "index": 18934+ ],
935- }935+ "tile_shape": [
936- ]936+ 16,
937+ 16
938+ ],
939+ "params": {
940+ "on_board": true,
941+ "func_id": -1
942+ },
943+ "index": 18
944+ },
945+ {
946+ "case_index": 19,
947+ "case_name": "BitwiseNot_test_20",
948+ "operation": "BitwiseNot",
949+ "input_tensors": [
950+ {
951+ "name": "input0",
952+ "shape": [
953+ 32,
954+ 32
955+ ],
956+ "dtype": "uint32",
957+ "format": "ND",
958+ "need_trans": false,
959+ "data_range": {
960+ "min": 0,
961+ "max": 1000
962+ }
963+ }
964+ ],
965+ "output_tensors": [
966+ {
967+ "name": "output0",
968+ "shape": [
969+ 32,
970+ 32
971+ ],
972+ "dtype": "uint32",
973+ "format": "ND",
974+ "need_trans": false
975+ }
976+ ],
977+ "view_shape": [
978+ 16,
979+ 16
980+ ],
981+ "tile_shape": [
982+ 16,
983+ 16
984+ ],
985+ "params": {
986+ "on_board": true,
987+ "func_id": -1
988+ },
989+ "index": 19
990+ }
991+ ]
937}992}
Mframework/tests/st/operation/test_case/BitwiseOr_st_test_cases.csv+1-0
@@ -14,3 +14,4 @@ BitwiseOr_4D_unalign_1,"[17, 7, 1, 3], [17, 7, 5, 3]","uint16, uint16","ND, ND",
14BitwiseOr_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"14BitwiseOr_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"
15BitwiseOr_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"15BitwiseOr_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"
16BitwiseOr_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"16BitwiseOr_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"
17+BitwiseOr_test_4,"[32, 32], [32, 32]","uint32, uint32","ND, ND","[0, 65535], [0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]"
Mframework/tests/st/operation/test_case/BitwiseOr_st_test_cases.json+1023-951
@@ -1,952 +1,1024 @@
1-{1+{
2- "test_cases": [2+ "test_cases": [
3- {3+ {
4- "case_index": 0,4+ "case_index": 0,
5- "case_name": "BitwiseOr_2D_align_0",5+ "case_name": "BitwiseOr_2D_align_0",
6- "operation": "BitwiseOr",6+ "operation": "BitwiseOr",
7- "input_tensors": [7+ "input_tensors": [
8- {8+ {
9- "name": "input0",9+ "name": "input0",
10- "shape": [10+ "shape": [
11- 32,11+ 32,
12- 3212+ 32
13- ],13+ ],
14- "dtype": "int16",14+ "dtype": "int16",
15- "format": "ND",15+ "format": "ND",
16- "need_trans": false,16+ "need_trans": false,
17- "data_range": {17+ "data_range": {
18- "min": 0,18+ "min": 0,
19- "max": 6553519+ "max": 65535
20- }20+ }
21- },21+ },
22- {22+ {
23- "name": "input1",23+ "name": "input1",
24- "shape": [24+ "shape": [
25- 32,25+ 32,
26- 3226+ 32
27- ],27+ ],
28- "dtype": "int16",28+ "dtype": "int16",
29- "format": "ND",29+ "format": "ND",
30- "need_trans": false,30+ "need_trans": false,
31- "data_range": {31+ "data_range": {
32- "min": 0,32+ "min": 0,
33- "max": 6553533+ "max": 65535
34- }34+ }
35- }35+ }
36- ],36+ ],
37- "output_tensors": [37+ "output_tensors": [
38- {38+ {
39- "name": "output0",39+ "name": "output0",
40- "shape": [40+ "shape": [
41- 32,41+ 32,
42- 3242+ 32
43- ],43+ ],
44- "dtype": "int16",44+ "dtype": "int16",
45- "format": "ND",45+ "format": "ND",
46- "need_trans": false46+ "need_trans": false
47- }47+ }
48- ],48+ ],
49- "view_shape": [49+ "view_shape": [
50- 16,50+ 16,
51- 1651+ 16
52- ],52+ ],
53- "tile_shape": [53+ "tile_shape": [
54- 16,54+ 16,
55- 1655+ 16
56- ],56+ ],
57- "params": {57+ "params": {
58- "on_board": true,58+ "on_board": true,
59- "func_id": -159+ "func_id": -1
60- },60+ },
61- "index": 061+ "index": 0
62- },62+ },
63- {63+ {
64- "case_index": 1,64+ "case_index": 1,
65- "case_name": "BitwiseOr_2D_align_1",65+ "case_name": "BitwiseOr_2D_align_1",
66- "operation": "BitwiseOr",66+ "operation": "BitwiseOr",
67- "input_tensors": [67+ "input_tensors": [
68- {68+ {
69- "name": "input0",69+ "name": "input0",
70- "shape": [70+ "shape": [
71- 1,71+ 1,
72- 3272+ 32
73- ],73+ ],
74- "dtype": "uint16",74+ "dtype": "uint16",
75- "format": "ND",75+ "format": "ND",
76- "need_trans": false,76+ "need_trans": false,
77- "data_range": {77+ "data_range": {
78- "min": 0,78+ "min": 0,
79- "max": 6553579+ "max": 65535
80- }80+ }
81- },81+ },
82- {82+ {
83- "name": "input1",83+ "name": "input1",
84- "shape": [84+ "shape": [
85- 32,85+ 32,
86- 3286+ 32
87- ],87+ ],
88- "dtype": "uint16",88+ "dtype": "uint16",
89- "format": "ND",89+ "format": "ND",
90- "need_trans": false,90+ "need_trans": false,
91- "data_range": {91+ "data_range": {
92- "min": 0,92+ "min": 0,
93- "max": 6553593+ "max": 65535
94- }94+ }
95- }95+ }
96- ],96+ ],
97- "output_tensors": [97+ "output_tensors": [
98- {98+ {
99- "name": "output0",99+ "name": "output0",
100- "shape": [100+ "shape": [
101- 32,101+ 32,
102- 32102+ 32
103- ],103+ ],
104- "dtype": "uint16",104+ "dtype": "uint16",
105- "format": "ND",105+ "format": "ND",
106- "need_trans": false106+ "need_trans": false
107- }107+ }
108- ],108+ ],
109- "view_shape": [109+ "view_shape": [
110- 16,110+ 16,
111- 16111+ 16
112- ],112+ ],
113- "tile_shape": [113+ "tile_shape": [
114- 16,114+ 16,
115- 16115+ 16
116- ],116+ ],
117- "params": {117+ "params": {
118- "on_board": true,118+ "on_board": true,
119- "func_id": -1119+ "func_id": -1
120- },120+ },
121- "index": 1121+ "index": 1
122- },122+ },
123- {123+ {
124- "case_index": 2,124+ "case_index": 2,
125- "case_name": "BitwiseOr_2D_unalign_0",125+ "case_name": "BitwiseOr_2D_unalign_0",
126- "operation": "BitwiseOr",126+ "operation": "BitwiseOr",
127- "input_tensors": [127+ "input_tensors": [
128- {128+ {
129- "name": "input0",129+ "name": "input0",
130- "shape": [130+ "shape": [
131- 17,131+ 17,
132- 31132+ 31
133- ],133+ ],
134- "dtype": "int16",134+ "dtype": "int16",
135- "format": "ND",135+ "format": "ND",
136- "need_trans": false,136+ "need_trans": false,
137- "data_range": {137+ "data_range": {
138- "min": 0,138+ "min": 0,
139- "max": 255139+ "max": 255
140- }140+ }
141- },141+ },
142- {142+ {
143- "name": "input1",143+ "name": "input1",
144- "shape": [144+ "shape": [
145- 17,145+ 17,
146- 31146+ 31
147- ],147+ ],
148- "dtype": "int16",148+ "dtype": "int16",
149- "format": "ND",149+ "format": "ND",
150- "need_trans": false,150+ "need_trans": false,
151- "data_range": {151+ "data_range": {
152- "min": 0,152+ "min": 0,
153- "max": 255153+ "max": 255
154- }154+ }
155- }155+ }
156- ],156+ ],
157- "output_tensors": [157+ "output_tensors": [
158- {158+ {
159- "name": "output0",159+ "name": "output0",
160- "shape": [160+ "shape": [
161- 17,161+ 17,
162- 31162+ 31
163- ],163+ ],
164- "dtype": "int16",164+ "dtype": "int16",
165- "format": "ND",165+ "format": "ND",
166- "need_trans": false166+ "need_trans": false
167- }167+ }
168- ],168+ ],
169- "view_shape": [169+ "view_shape": [
170- 8,170+ 8,
171- 16171+ 16
172- ],172+ ],
173- "tile_shape": [173+ "tile_shape": [
174- 16,174+ 16,
175- 16175+ 16
176- ],176+ ],
177- "params": {177+ "params": {
178- "on_board": true,178+ "on_board": true,
179- "func_id": -1179+ "func_id": -1
180- },180+ },
181- "index": 2181+ "index": 2
182- },182+ },
183- {183+ {
184- "case_index": 3,184+ "case_index": 3,
185- "case_name": "BitwiseOr_2D_unalign_1",185+ "case_name": "BitwiseOr_2D_unalign_1",
186- "operation": "BitwiseOr",186+ "operation": "BitwiseOr",
187- "input_tensors": [187+ "input_tensors": [
188- {188+ {
189- "name": "input0",189+ "name": "input0",
190- "shape": [190+ "shape": [
191- 17,191+ 17,
192- 1192+ 1
193- ],193+ ],
194- "dtype": "uint16",194+ "dtype": "uint16",
195- "format": "ND",195+ "format": "ND",
196- "need_trans": false,196+ "need_trans": false,
197- "data_range": {197+ "data_range": {
198- "min": 0,198+ "min": 0,
199- "max": 65535199+ "max": 65535
200- }200+ }
201- },201+ },
202- {202+ {
203- "name": "input1",203+ "name": "input1",
204- "shape": [204+ "shape": [
205- 17,205+ 17,
206- 31206+ 31
207- ],207+ ],
208- "dtype": "uint16",208+ "dtype": "uint16",
209- "format": "ND",209+ "format": "ND",
210- "need_trans": false,210+ "need_trans": false,
211- "data_range": {211+ "data_range": {
212- "min": 0,212+ "min": 0,
213- "max": 65535213+ "max": 65535
214- }214+ }
215- }215+ }
216- ],216+ ],
217- "output_tensors": [217+ "output_tensors": [
218- {218+ {
219- "name": "output0",219+ "name": "output0",
220- "shape": [220+ "shape": [
221- 17,221+ 17,
222- 31222+ 31
223- ],223+ ],
224- "dtype": "uint16",224+ "dtype": "uint16",
225- "format": "ND",225+ "format": "ND",
226- "need_trans": false226+ "need_trans": false
227- }227+ }
228- ],228+ ],
229- "view_shape": [229+ "view_shape": [
230- 8,230+ 8,
231- 16231+ 16
232- ],232+ ],
233- "tile_shape": [233+ "tile_shape": [
234- 16,234+ 16,
235- 16235+ 16
236- ],236+ ],
237- "params": {237+ "params": {
238- "on_board": true,238+ "on_board": true,
239- "func_id": -1239+ "func_id": -1
240- },240+ },
241- "index": 3241+ "index": 3
242- },242+ },
243- {243+ {
244- "case_index": 4,244+ "case_index": 4,
245- "case_name": "BitwiseOr_3D_align_0",245+ "case_name": "BitwiseOr_3D_align_0",
246- "operation": "BitwiseOr",246+ "operation": "BitwiseOr",
247- "input_tensors": [247+ "input_tensors": [
248- {248+ {
249- "name": "input0",249+ "name": "input0",
250- "shape": [250+ "shape": [
251- 32,251+ 32,
252- 16,252+ 16,
253- 8253+ 8
254- ],254+ ],
255- "dtype": "int16",255+ "dtype": "int16",
256- "format": "ND",256+ "format": "ND",
257- "need_trans": false,257+ "need_trans": false,
258- "data_range": {258+ "data_range": {
259- "min": 0,259+ "min": 0,
260- "max": 255260+ "max": 255
261- }261+ }
262- },262+ },
263- {263+ {
264- "name": "input1",264+ "name": "input1",
265- "shape": [265+ "shape": [
266- 32,266+ 32,
267- 16,267+ 16,
268- 8268+ 8
269- ],269+ ],
270- "dtype": "int16",270+ "dtype": "int16",
271- "format": "ND",271+ "format": "ND",
272- "need_trans": false,272+ "need_trans": false,
273- "data_range": {273+ "data_range": {
274- "min": 0,274+ "min": 0,
275- "max": 255275+ "max": 255
276- }276+ }
277- }277+ }
278- ],278+ ],
279- "output_tensors": [279+ "output_tensors": [
280- {280+ {
281- "name": "output0",281+ "name": "output0",
282- "shape": [282+ "shape": [
283- 32,283+ 32,
284- 16,284+ 16,
285- 8285+ 8
286- ],286+ ],
287- "dtype": "int16",287+ "dtype": "int16",
288- "format": "ND",288+ "format": "ND",
289- "need_trans": false289+ "need_trans": false
290- }290+ }
291- ],291+ ],
292- "view_shape": [292+ "view_shape": [
293- 16,293+ 16,
294- 8,294+ 8,
295- 4295+ 4
296- ],296+ ],
297- "tile_shape": [297+ "tile_shape": [
298- 16,298+ 16,
299- 16,299+ 16,
300- 16300+ 16
301- ],301+ ],
302- "params": {302+ "params": {
303- "on_board": true,303+ "on_board": true,
304- "func_id": -1304+ "func_id": -1
305- },305+ },
306- "index": 4306+ "index": 4
307- },307+ },
308- {308+ {
309- "case_index": 5,309+ "case_index": 5,
310- "case_name": "BitwiseOr_3D_align_1",310+ "case_name": "BitwiseOr_3D_align_1",
311- "operation": "BitwiseOr",311+ "operation": "BitwiseOr",
312- "input_tensors": [312+ "input_tensors": [
313- {313+ {
314- "name": "input0",314+ "name": "input0",
315- "shape": [315+ "shape": [
316- 32,316+ 32,
317- 1,317+ 1,
318- 8318+ 8
319- ],319+ ],
320- "dtype": "uint16",320+ "dtype": "uint16",
321- "format": "ND",321+ "format": "ND",
322- "need_trans": false,322+ "need_trans": false,
323- "data_range": {323+ "data_range": {
324- "min": 0,324+ "min": 0,
325- "max": 65535325+ "max": 65535
326- }326+ }
327- },327+ },
328- {328+ {
329- "name": "input1",329+ "name": "input1",
330- "shape": [330+ "shape": [
331- 32,331+ 32,
332- 16,332+ 16,
333- 8333+ 8
334- ],334+ ],
335- "dtype": "uint16",335+ "dtype": "uint16",
336- "format": "ND",336+ "format": "ND",
337- "need_trans": false,337+ "need_trans": false,
338- "data_range": {338+ "data_range": {
339- "min": 0,339+ "min": 0,
340- "max": 65535340+ "max": 65535
341- }341+ }
342- }342+ }
343- ],343+ ],
344- "output_tensors": [344+ "output_tensors": [
345- {345+ {
346- "name": "output0",346+ "name": "output0",
347- "shape": [347+ "shape": [
348- 32,348+ 32,
349- 16,349+ 16,
350- 8350+ 8
351- ],351+ ],
352- "dtype": "uint16",352+ "dtype": "uint16",
353- "format": "ND",353+ "format": "ND",
354- "need_trans": false354+ "need_trans": false
355- }355+ }
356- ],356+ ],
357- "view_shape": [357+ "view_shape": [
358- 16,358+ 16,
359- 8,359+ 8,
360- 4360+ 4
361- ],361+ ],
362- "tile_shape": [362+ "tile_shape": [
363- 16,363+ 16,
364- 16,364+ 16,
365- 16365+ 16
366- ],366+ ],
367- "params": {367+ "params": {
368- "on_board": true,368+ "on_board": true,
369- "func_id": -1369+ "func_id": -1
370- },370+ },
371- "index": 5371+ "index": 5
372- },372+ },
373- {373+ {
374- "case_index": 6,374+ "case_index": 6,
375- "case_name": "BitwiseOr_3D_unalign_0",375+ "case_name": "BitwiseOr_3D_unalign_0",
376- "operation": "BitwiseOr",376+ "operation": "BitwiseOr",
377- "input_tensors": [377+ "input_tensors": [
378- {378+ {
379- "name": "input0",379+ "name": "input0",
380- "shape": [380+ "shape": [
381- 33,381+ 33,
382- 15,382+ 15,
383- 9383+ 9
384- ],384+ ],
385- "dtype": "int16",385+ "dtype": "int16",
386- "format": "ND",386+ "format": "ND",
387- "need_trans": false,387+ "need_trans": false,
388- "data_range": {388+ "data_range": {
389- "min": 0,389+ "min": 0,
390- "max": 255390+ "max": 255
391- }391+ }
392- },392+ },
393- {393+ {
394- "name": "input1",394+ "name": "input1",
395- "shape": [395+ "shape": [
396- 33,396+ 33,
397- 15,397+ 15,
398- 9398+ 9
399- ],399+ ],
400- "dtype": "int16",400+ "dtype": "int16",
401- "format": "ND",401+ "format": "ND",
402- "need_trans": false,402+ "need_trans": false,
403- "data_range": {403+ "data_range": {
404- "min": 0,404+ "min": 0,
405- "max": 255405+ "max": 255
406- }406+ }
407- }407+ }
408- ],408+ ],
409- "output_tensors": [409+ "output_tensors": [
410- {410+ {
411- "name": "output0",411+ "name": "output0",
412- "shape": [412+ "shape": [
413- 33,413+ 33,
414- 15,414+ 15,
415- 9415+ 9
416- ],416+ ],
417- "dtype": "int16",417+ "dtype": "int16",
418- "format": "ND",418+ "format": "ND",
419- "need_trans": false419+ "need_trans": false
420- }420+ }
421- ],421+ ],
422- "view_shape": [422+ "view_shape": [
423- 16,423+ 16,
424- 8,424+ 8,
425- 4425+ 4
426- ],426+ ],
427- "tile_shape": [427+ "tile_shape": [
428- 16,428+ 16,
429- 16,429+ 16,
430- 16430+ 16
431- ],431+ ],
432- "params": {432+ "params": {
433- "on_board": true,433+ "on_board": true,
434- "func_id": -1434+ "func_id": -1
435- },435+ },
436- "index": 6436+ "index": 6
437- },437+ },
438- {438+ {
439- "case_index": 7,439+ "case_index": 7,
440- "case_name": "BitwiseOr_3D_unalign_1",440+ "case_name": "BitwiseOr_3D_unalign_1",
441- "operation": "BitwiseOr",441+ "operation": "BitwiseOr",
442- "input_tensors": [442+ "input_tensors": [
443- {443+ {
444- "name": "input0",444+ "name": "input0",
445- "shape": [445+ "shape": [
446- 1,446+ 1,
447- 15,447+ 15,
448- 9448+ 9
449- ],449+ ],
450- "dtype": "uint16",450+ "dtype": "uint16",
451- "format": "ND",451+ "format": "ND",
452- "need_trans": false,452+ "need_trans": false,
453- "data_range": {453+ "data_range": {
454- "min": 0,454+ "min": 0,
455- "max": 65535455+ "max": 65535
456- }456+ }
457- },457+ },
458- {458+ {
459- "name": "input1",459+ "name": "input1",
460- "shape": [460+ "shape": [
461- 33,461+ 33,
462- 15,462+ 15,
463- 9463+ 9
464- ],464+ ],
465- "dtype": "uint16",465+ "dtype": "uint16",
466- "format": "ND",466+ "format": "ND",
467- "need_trans": false,467+ "need_trans": false,
468- "data_range": {468+ "data_range": {
469- "min": 0,469+ "min": 0,
470- "max": 65535470+ "max": 65535
471- }471+ }
472- }472+ }
473- ],473+ ],
474- "output_tensors": [474+ "output_tensors": [
475- {475+ {
476- "name": "output0",476+ "name": "output0",
477- "shape": [477+ "shape": [
478- 33,478+ 33,
479- 15,479+ 15,
480- 9480+ 9
481- ],481+ ],
482- "dtype": "uint16",482+ "dtype": "uint16",
483- "format": "ND",483+ "format": "ND",
484- "need_trans": false484+ "need_trans": false
485- }485+ }
486- ],486+ ],
487- "view_shape": [487+ "view_shape": [
488- 16,488+ 16,
489- 8,489+ 8,
490- 4490+ 4
491- ],491+ ],
492- "tile_shape": [492+ "tile_shape": [
493- 16,493+ 16,
494- 16,494+ 16,
495- 16495+ 16
496- ],496+ ],
497- "params": {497+ "params": {
498- "on_board": true,498+ "on_board": true,
499- "func_id": -1499+ "func_id": -1
500- },500+ },
501- "index": 7501+ "index": 7
502- },502+ },
503- {503+ {
504- "case_index": 8,504+ "case_index": 8,
505- "case_name": "BitwiseOr_4D_align_0",505+ "case_name": "BitwiseOr_4D_align_0",
506- "operation": "BitwiseOr",506+ "operation": "BitwiseOr",
507- "input_tensors": [507+ "input_tensors": [
508- {508+ {
509- "name": "input0",509+ "name": "input0",
510- "shape": [510+ "shape": [
511- 16,511+ 16,
512- 8,512+ 8,
513- 4,513+ 4,
514- 2514+ 2
515- ],515+ ],
516- "dtype": "int16",516+ "dtype": "int16",
517- "format": "ND",517+ "format": "ND",
518- "need_trans": false,518+ "need_trans": false,
519- "data_range": {519+ "data_range": {
520- "min": 0,520+ "min": 0,
521- "max": 255521+ "max": 255
522- }522+ }
523- },523+ },
524- {524+ {
525- "name": "input1",525+ "name": "input1",
526- "shape": [526+ "shape": [
527- 16,527+ 16,
528- 8,528+ 8,
529- 4,529+ 4,
530- 2530+ 2
531- ],531+ ],
532- "dtype": "int16",532+ "dtype": "int16",
533- "format": "ND",533+ "format": "ND",
534- "need_trans": false,534+ "need_trans": false,
535- "data_range": {535+ "data_range": {
536- "min": 0,536+ "min": 0,
537- "max": 255537+ "max": 255
538- }538+ }
539- }539+ }
540- ],540+ ],
541- "output_tensors": [541+ "output_tensors": [
542- {542+ {
543- "name": "output0",543+ "name": "output0",
544- "shape": [544+ "shape": [
545- 16,545+ 16,
546- 8,546+ 8,
547- 4,547+ 4,
548- 2548+ 2
549- ],549+ ],
550- "dtype": "int16",550+ "dtype": "int16",
551- "format": "ND",551+ "format": "ND",
552- "need_trans": false552+ "need_trans": false
553- }553+ }
554- ],554+ ],
555- "view_shape": [555+ "view_shape": [
556- 8,556+ 8,
557- 4,557+ 4,
558- 2,558+ 2,
559- 1559+ 1
560- ],560+ ],
561- "tile_shape": [561+ "tile_shape": [
562- 16,562+ 16,
563- 16,563+ 16,
564- 16,564+ 16,
565- 16565+ 16
566- ],566+ ],
567- "params": {567+ "params": {
568- "on_board": true,568+ "on_board": true,
569- "func_id": -1569+ "func_id": -1
570- },570+ },
571- "index": 8571+ "index": 8
572- },572+ },
573- {573+ {
574- "case_index": 9,574+ "case_index": 9,
575- "case_name": "BitwiseOr_4D_align_1",575+ "case_name": "BitwiseOr_4D_align_1",
576- "operation": "BitwiseOr",576+ "operation": "BitwiseOr",
577- "input_tensors": [577+ "input_tensors": [
578- {578+ {
579- "name": "input0",579+ "name": "input0",
580- "shape": [580+ "shape": [
581- 16,581+ 16,
582- 1,582+ 1,
583- 4,583+ 4,
584- 2584+ 2
585- ],585+ ],
586- "dtype": "uint16",586+ "dtype": "uint16",
587- "format": "ND",587+ "format": "ND",
588- "need_trans": false,588+ "need_trans": false,
589- "data_range": {589+ "data_range": {
590- "min": 0,590+ "min": 0,
591- "max": 65535591+ "max": 65535
592- }592+ }
593- },593+ },
594- {594+ {
595- "name": "input1",595+ "name": "input1",
596- "shape": [596+ "shape": [
597- 16,597+ 16,
598- 8,598+ 8,
599- 4,599+ 4,
600- 2600+ 2
601- ],601+ ],
602- "dtype": "uint16",602+ "dtype": "uint16",
603- "format": "ND",603+ "format": "ND",
604- "need_trans": false,604+ "need_trans": false,
605- "data_range": {605+ "data_range": {
606- "min": 0,606+ "min": 0,
607- "max": 65535607+ "max": 65535
608- }608+ }
609- }609+ }
610- ],610+ ],
611- "output_tensors": [611+ "output_tensors": [
612- {612+ {
613- "name": "output0",613+ "name": "output0",
614- "shape": [614+ "shape": [
615- 16,615+ 16,
616- 8,616+ 8,
617- 4,617+ 4,
618- 2618+ 2
619- ],619+ ],
620- "dtype": "uint16",620+ "dtype": "uint16",
621- "format": "ND",621+ "format": "ND",
622- "need_trans": false622+ "need_trans": false
623- }623+ }
624- ],624+ ],
625- "view_shape": [625+ "view_shape": [
626- 8,626+ 8,
627- 4,627+ 4,
628- 2,628+ 2,
629- 1629+ 1
630- ],630+ ],
631- "tile_shape": [631+ "tile_shape": [
632- 16,632+ 16,
633- 16,633+ 16,
634- 16,634+ 16,
635- 16635+ 16
636- ],636+ ],
637- "params": {637+ "params": {
638- "on_board": true,638+ "on_board": true,
639- "func_id": -1639+ "func_id": -1
640- },640+ },
641- "index": 9641+ "index": 9
642- },642+ },
643- {643+ {
644- "case_index": 10,644+ "case_index": 10,
645- "case_name": "BitwiseOr_4D_unalign_0",645+ "case_name": "BitwiseOr_4D_unalign_0",
646- "operation": "BitwiseOr",646+ "operation": "BitwiseOr",
647- "input_tensors": [647+ "input_tensors": [
648- {648+ {
649- "name": "input0",649+ "name": "input0",
650- "shape": [650+ "shape": [
651- 17,651+ 17,
652- 7,652+ 7,
653- 5,653+ 5,
654- 3654+ 3
655- ],655+ ],
656- "dtype": "int16",656+ "dtype": "int16",
657- "format": "ND",657+ "format": "ND",
658- "need_trans": false,658+ "need_trans": false,
659- "data_range": {659+ "data_range": {
660- "min": 0,660+ "min": 0,
661- "max": 255661+ "max": 255
662- }662+ }
663- },663+ },
664- {664+ {
665- "name": "input1",665+ "name": "input1",
666- "shape": [666+ "shape": [
667- 17,667+ 17,
668- 7,668+ 7,
669- 5,669+ 5,
670- 3670+ 3
671- ],671+ ],
672- "dtype": "int16",672+ "dtype": "int16",
673- "format": "ND",673+ "format": "ND",
674- "need_trans": false,674+ "need_trans": false,
675- "data_range": {675+ "data_range": {
676- "min": 0,676+ "min": 0,
677- "max": 255677+ "max": 255
678- }678+ }
679- }679+ }
680- ],680+ ],
681- "output_tensors": [681+ "output_tensors": [
682- {682+ {
683- "name": "output0",683+ "name": "output0",
684- "shape": [684+ "shape": [
685- 17,685+ 17,
686- 7,686+ 7,
687- 5,687+ 5,
688- 3688+ 3
689- ],689+ ],
690- "dtype": "int16",690+ "dtype": "int16",
691- "format": "ND",691+ "format": "ND",
692- "need_trans": false692+ "need_trans": false
693- }693+ }
694- ],694+ ],
695- "view_shape": [695+ "view_shape": [
696- 8,696+ 8,
697- 4,697+ 4,
698- 2,698+ 2,
699- 1699+ 1
700- ],700+ ],
701- "tile_shape": [701+ "tile_shape": [
702- 16,702+ 16,
703- 16,703+ 16,
704- 16,704+ 16,
705- 16705+ 16
706- ],706+ ],
707- "params": {707+ "params": {
708- "on_board": true,708+ "on_board": true,
709- "func_id": -1709+ "func_id": -1
710- },710+ },
711- "index": 10711+ "index": 10
712- },712+ },
713- {713+ {
714- "case_index": 11,714+ "case_index": 11,
715- "case_name": "BitwiseOr_4D_unalign_1",715+ "case_name": "BitwiseOr_4D_unalign_1",
716- "operation": "BitwiseOr",716+ "operation": "BitwiseOr",
717- "input_tensors": [717+ "input_tensors": [
718- {718+ {
719- "name": "input0",719+ "name": "input0",
720- "shape": [720+ "shape": [
721- 17,721+ 17,
722- 7,722+ 7,
723- 1,723+ 1,
724- 3724+ 3
725- ],725+ ],
726- "dtype": "uint16",726+ "dtype": "uint16",
727- "format": "ND",727+ "format": "ND",
728- "need_trans": false,728+ "need_trans": false,
729- "data_range": {729+ "data_range": {
730- "min": 0,730+ "min": 0,
731- "max": 65535731+ "max": 65535
732- }732+ }
733- },733+ },
734- {734+ {
735- "name": "input1",735+ "name": "input1",
736- "shape": [736+ "shape": [
737- 17,737+ 17,
738- 7,738+ 7,
739- 5,739+ 5,
740- 3740+ 3
741- ],741+ ],
742- "dtype": "uint16",742+ "dtype": "uint16",
743- "format": "ND",743+ "format": "ND",
744- "need_trans": false,744+ "need_trans": false,
745- "data_range": {745+ "data_range": {
746- "min": 0,746+ "min": 0,
747- "max": 65535747+ "max": 65535
748- }748+ }
749- }749+ }
750- ],750+ ],
751- "output_tensors": [751+ "output_tensors": [
752- {752+ {
753- "name": "output0",753+ "name": "output0",
754- "shape": [754+ "shape": [
755- 17,755+ 17,
756- 7,756+ 7,
757- 5,757+ 5,
758- 3758+ 3
759- ],759+ ],
760- "dtype": "uint16",760+ "dtype": "uint16",
761- "format": "ND",761+ "format": "ND",
762- "need_trans": false762+ "need_trans": false
763- }763+ }
764- ],764+ ],
765- "view_shape": [765+ "view_shape": [
766- 8,766+ 8,
767- 4,767+ 4,
768- 2,768+ 2,
769- 1769+ 1
770- ],770+ ],
771- "tile_shape": [771+ "tile_shape": [
772- 16,772+ 16,
773- 16,773+ 16,
774- 16,774+ 16,
775- 16775+ 16
776- ],776+ ],
777- "params": {777+ "params": {
778- "on_board": true,778+ "on_board": true,
779- "func_id": -1779+ "func_id": -1
780- },780+ },
781- "index": 11781+ "index": 11
782- },782+ },
783- {783+ {
784- "case_index": 12,784+ "case_index": 12,
785- "case_name": "BitwiseOr_test_1",785+ "case_name": "BitwiseOr_test_1",
786- "operation": "BitwiseOr",786+ "operation": "BitwiseOr",
787- "input_tensors": [787+ "input_tensors": [
788- {788+ {
789- "name": "input0",789+ "name": "input0",
790- "shape": [790+ "shape": [
791- 32,791+ 32,
792- 32792+ 32
793- ],793+ ],
794- "dtype": "int8",794+ "dtype": "int8",
795- "data_range": {795+ "format": "ND",
796- "min": -10,796+ "need_trans": false,
797- "max": 10797+ "data_range": {
798- },798+ "min": -10,
799- "format": "ND"799+ "max": 10
800- },800+ }
801- {801+ },
802- "name": "input1",802+ {
803- "shape": [803+ "name": "input1",
804- 32,804+ "shape": [
805- 32805+ 32,
806- ],806+ 32
807- "dtype": "int8",807+ ],
808- "data_range": {808+ "dtype": "int8",
809- "min": -10,809+ "format": "ND",
810- "max": 10810+ "need_trans": false,
811- },811+ "data_range": {
812- "format": "ND"812+ "min": -10,
813- }813+ "max": 10
814- ],814+ }
815- "output_tensors": [815+ }
816- {816+ ],
817- "name": "output0",817+ "output_tensors": [
818- "shape": [818+ {
819- 32,819+ "name": "output0",
820- 32820+ "shape": [
821- ],821+ 32,
822- "dtype": "int8",822+ 32
823- "format": "ND"823+ ],
824- }824+ "dtype": "int8",
825- ],825+ "format": "ND",
826- "view_shape": [826+ "need_trans": false
827- 16,827+ }
828- 16828+ ],
829- ],829+ "view_shape": [
830- "tile_shape": [830+ 16,
831- 16,831+ 16
832- 16832+ ],
833- ],833+ "tile_shape": [
834- "params": {834+ 16,
835- "func_id": -1835+ 16
836- },836+ ],
837- "index": 12837+ "params": {
838- },838+ "on_board": true,
839- {839+ "func_id": -1
840- "case_index": 13,840+ },
841- "case_name": "BitwiseOr_test_2",841+ "index": 12
842- "operation": "BitwiseOr",842+ },
843- "input_tensors": [843+ {
844- {844+ "case_index": 13,
845- "name": "input0",845+ "case_name": "BitwiseOr_test_2",
846- "shape": [846+ "operation": "BitwiseOr",
847- 32,847+ "input_tensors": [
848- 32848+ {
849- ],849+ "name": "input0",
850- "dtype": "uint8",850+ "shape": [
851- "data_range": {851+ 32,
852- "min": -10,852+ 32
853- "max": 10853+ ],
854- },854+ "dtype": "uint8",
855- "format": "ND"855+ "format": "ND",
856- },856+ "need_trans": false,
857- {857+ "data_range": {
858- "name": "input1",858+ "min": -10,
859- "shape": [859+ "max": 10
860- 32,860+ }
861- 32861+ },
862- ],862+ {
863- "dtype": "uint8",863+ "name": "input1",
864- "data_range": {864+ "shape": [
865- "min": -10,865+ 32,
866- "max": 10866+ 32
867- },867+ ],
868- "format": "ND"868+ "dtype": "uint8",
869- }869+ "format": "ND",
870- ],870+ "need_trans": false,
871- "output_tensors": [871+ "data_range": {
872- {872+ "min": -10,
873- "name": "output0",873+ "max": 10
874- "shape": [874+ }
875- 32,875+ }
876- 32876+ ],
877- ],877+ "output_tensors": [
878- "dtype": "uint8",878+ {
879- "format": "ND"879+ "name": "output0",
880- }880+ "shape": [
881- ],881+ 32,
882- "view_shape": [882+ 32
883- 16,883+ ],
884- 16884+ "dtype": "uint8",
885- ],885+ "format": "ND",
886- "tile_shape": [886+ "need_trans": false
887- 16,887+ }
888- 16888+ ],
889- ],889+ "view_shape": [
890- "params": {890+ 16,
891- "func_id": -1891+ 16
892- },892+ ],
893- "index": 13893+ "tile_shape": [
894- },894+ 16,
895- {895+ 16
896- "case_index": 14,896+ ],
897- "case_name": "BitwiseOr_test_3",897+ "params": {
898- "operation": "BitwiseOr",898+ "on_board": true,
899- "input_tensors": [899+ "func_id": -1
900- {900+ },
901- "name": "input0",901+ "index": 13
902- "shape": [902+ },
903- 32,903+ {
904- 32904+ "case_index": 14,
905- ],905+ "case_name": "BitwiseOr_test_3",
906- "dtype": "int32",906+ "operation": "BitwiseOr",
907- "data_range": {907+ "input_tensors": [
908- "min": -1000,908+ {
909- "max": 1000909+ "name": "input0",
910- },910+ "shape": [
911- "format": "ND"911+ 32,
912- },912+ 32
913- {913+ ],
914- "name": "input1",914+ "dtype": "int32",
915- "shape": [915+ "format": "ND",
916- 32,916+ "need_trans": false,
917- 32917+ "data_range": {
918- ],918+ "min": -1000,
919- "dtype": "int32",919+ "max": 1000
920- "data_range": {920+ }
921- "min": -1000,921+ },
922- "max": 1000922+ {
923- },923+ "name": "input1",
924- "format": "ND"924+ "shape": [
925- }925+ 32,
926- ],926+ 32
927- "output_tensors": [927+ ],
928- {928+ "dtype": "int32",
929- "name": "output0",929+ "format": "ND",
930- "shape": [930+ "need_trans": false,
931- 32,931+ "data_range": {
932- 32932+ "min": -1000,
933- ],933+ "max": 1000
934- "dtype": "int32",934+ }
935- "format": "ND"935+ }
936- }936+ ],
937- ],937+ "output_tensors": [
938- "view_shape": [938+ {
939- 16,939+ "name": "output0",
940- 16940+ "shape": [
941- ],941+ 32,
942- "tile_shape": [942+ 32
943- 16,943+ ],
944- 16944+ "dtype": "int32",
945- ],945+ "format": "ND",
946- "params": {946+ "need_trans": false
947- "func_id": -1947+ }
948- },948+ ],
949- "index": 14949+ "view_shape": [
950- }950+ 16,
951- ]951+ 16
952+ ],
953+ "tile_shape": [
954+ 16,
955+ 16
956+ ],
957+ "params": {
958+ "on_board": true,
959+ "func_id": -1
960+ },
961+ "index": 14
962+ },
963+ {
964+ "case_index": 15,
965+ "case_name": "BitwiseOr_test_4",
966+ "operation": "BitwiseOr",
967+ "input_tensors": [
968+ {
969+ "name": "input0",
970+ "shape": [
971+ 32,
972+ 32
973+ ],
974+ "dtype": "uint32",
975+ "format": "ND",
976+ "need_trans": false,
977+ "data_range": {
978+ "min": 0,
979+ "max": 65535
980+ }
981+ },
982+ {
983+ "name": "input1",
984+ "shape": [
985+ 32,
986+ 32
987+ ],
988+ "dtype": "uint32",
989+ "format": "ND",
990+ "need_trans": false,
991+ "data_range": {
992+ "min": 0,
993+ "max": 65535
994+ }
995+ }
996+ ],
997+ "output_tensors": [
998+ {
999+ "name": "output0",
1000+ "shape": [
1001+ 32,
1002+ 32
1003+ ],
1004+ "dtype": "uint32",
1005+ "format": "ND",
1006+ "need_trans": false
1007+ }
1008+ ],
1009+ "view_shape": [
1010+ 16,
1011+ 16
1012+ ],
1013+ "tile_shape": [
1014+ 16,
1015+ 16
1016+ ],
1017+ "params": {
1018+ "on_board": true,
1019+ "func_id": -1
1020+ },
1021+ "index": 15
1022+ }
1023+ ]
952}1024}
Mframework/tests/st/operation/test_case/BitwiseOrs_st_test_cases.csv+4-0
@@ -11,3 +11,7 @@ BitwiseOr_scalar_4D_align_0,"[16, 8, 4, 2]",int16,ND,"[0, 255]","[16, 8, 4, 2]",
11BitwiseOr_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint1611BitwiseOr_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint16
12BitwiseOr_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int1612BitwiseOr_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int16
13BitwiseOr_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint1613BitwiseOr_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint16
14+BitwiseOr_scalar_int8,"[32, 32]",int8,ND,"[-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]",-3,int8
15+BitwiseOr_scalar_uint8,"[32, 32]",uint8,ND,"[0, 255]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]",240,uint8
16+BitwiseOr_scalar_int32,"[32, 32]",int32,ND,"[-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]",-257,int32
17+BitwiseOr_scalar_uint32,"[32, 32]",uint32,ND,"[0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]",65535,uint32
Mframework/tests/st/operation/test_case/BitwiseOrs_st_test_cases.json+192-0
@@ -623,6 +623,198 @@
623 "func_id": -1623 "func_id": -1
624 },624 },
625 "index": 11625 "index": 11
626+ },
627+ {
628+ "case_index": 12,
629+ "case_name": "BitwiseOr_scalar_int8",
630+ "operation": "BitwiseOrs",
631+ "input_tensors": [
632+ {
633+ "name": "input0",
634+ "shape": [
635+ 32,
636+ 32
637+ ],
638+ "dtype": "int8",
639+ "format": "ND",
640+ "need_trans": false,
641+ "data_range": {
642+ "min": -10,
643+ "max": 10
644+ }
645+ }
646+ ],
647+ "output_tensors": [
648+ {
649+ "name": "output0",
650+ "shape": [
651+ 32,
652+ 32
653+ ],
654+ "dtype": "int8",
655+ "format": "ND",
656+ "need_trans": false
657+ }
658+ ],
659+ "view_shape": [
660+ 16,
661+ 16
662+ ],
663+ "tile_shape": [
664+ 16,
665+ 16
666+ ],
667+ "params": {
668+ "scalar": -3,
669+ "scalar_type": "int8",
670+ "on_board": true,
671+ "func_id": -1
672+ },
673+ "index": 12
674+ },
675+ {
676+ "case_index": 13,
677+ "case_name": "BitwiseOr_scalar_uint8",
678+ "operation": "BitwiseOrs",
679+ "input_tensors": [
680+ {
681+ "name": "input0",
682+ "shape": [
683+ 32,
684+ 32
685+ ],
686+ "dtype": "uint8",
687+ "format": "ND",
688+ "need_trans": false,
689+ "data_range": {
690+ "min": 0,
691+ "max": 255
692+ }
693+ }
694+ ],
695+ "output_tensors": [
696+ {
697+ "name": "output0",
698+ "shape": [
699+ 32,
700+ 32
701+ ],
702+ "dtype": "uint8",
703+ "format": "ND",
704+ "need_trans": false
705+ }
706+ ],
707+ "view_shape": [
708+ 16,
709+ 16
710+ ],
711+ "tile_shape": [
712+ 16,
713+ 16
714+ ],
715+ "params": {
716+ "scalar": 240,
717+ "scalar_type": "uint8",
718+ "on_board": true,
719+ "func_id": -1
720+ },
721+ "index": 13
722+ },
723+ {
724+ "case_index": 14,
725+ "case_name": "BitwiseOr_scalar_int32",
726+ "operation": "BitwiseOrs",
727+ "input_tensors": [
728+ {
729+ "name": "input0",
730+ "shape": [
731+ 32,
732+ 32
733+ ],
734+ "dtype": "int32",
735+ "format": "ND",
736+ "need_trans": false,
737+ "data_range": {
738+ "min": -1000,
739+ "max": 1000
740+ }
741+ }
742+ ],
743+ "output_tensors": [
744+ {
745+ "name": "output0",
746+ "shape": [
747+ 32,
748+ 32
749+ ],
750+ "dtype": "int32",
751+ "format": "ND",
752+ "need_trans": false
753+ }
754+ ],
755+ "view_shape": [
756+ 16,
757+ 16
758+ ],
759+ "tile_shape": [
760+ 16,
761+ 16
762+ ],
763+ "params": {
764+ "scalar": -257,
765+ "scalar_type": "int32",
766+ "on_board": true,
767+ "func_id": -1
768+ },
769+ "index": 14
770+ },
771+ {
772+ "case_index": 15,
773+ "case_name": "BitwiseOr_scalar_uint32",
774+ "operation": "BitwiseOrs",
775+ "input_tensors": [
776+ {
777+ "name": "input0",
778+ "shape": [
779+ 32,
780+ 32
781+ ],
782+ "dtype": "uint32",
783+ "format": "ND",
784+ "need_trans": false,
785+ "data_range": {
786+ "min": 0,
787+ "max": 65535
788+ }
789+ }
790+ ],
791+ "output_tensors": [
792+ {
793+ "name": "output0",
794+ "shape": [
795+ 32,
796+ 32
797+ ],
798+ "dtype": "uint32",
799+ "format": "ND",
800+ "need_trans": false
801+ }
802+ ],
803+ "view_shape": [
804+ 16,
805+ 16
806+ ],
807+ "tile_shape": [
808+ 16,
809+ 16
810+ ],
811+ "params": {
812+ "scalar": 65535,
813+ "scalar_type": "uint32",
814+ "on_board": true,
815+ "func_id": -1
816+ },
817+ "index": 15
626 }818 }
627 ]819 ]
628}820}
Mframework/tests/st/operation/test_case/BitwiseXor_st_test_cases.csv+1-0
@@ -14,3 +14,4 @@ BitwiseXor_4D_unalign_1,"[17, 7, 1, 3], [17, 7, 5, 3]","uint16, uint16","ND, ND"
14BitwiseXor_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"14BitwiseXor_test_1,"[32, 32], [32, 32]","int8, int8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]"
15BitwiseXor_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"15BitwiseXor_test_2,"[32, 32], [32, 32]","uint8, uint8","ND, ND","[-10, 10], [-10, 10]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]"
16BitwiseXor_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"16BitwiseXor_test_3,"[32, 32], [32, 32]","int32, int32","ND, ND","[-1000, 1000], [-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]"
17+BitwiseXor_test_4,"[32, 32], [32, 32]","uint32, uint32","ND, ND","[0, 65535], [0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]"
Mframework/tests/st/operation/test_case/BitwiseXor_st_test_cases.json+1023-951
@@ -1,952 +1,1024 @@
1-{1+{
2- "test_cases": [2+ "test_cases": [
3- {3+ {
4- "case_index": 0,4+ "case_index": 0,
5- "case_name": "BitwiseXor_2D_align_0",5+ "case_name": "BitwiseXor_2D_align_0",
6- "operation": "BitwiseXor",6+ "operation": "BitwiseXor",
7- "input_tensors": [7+ "input_tensors": [
8- {8+ {
9- "name": "input0",9+ "name": "input0",
10- "shape": [10+ "shape": [
11- 32,11+ 32,
12- 3212+ 32
13- ],13+ ],
14- "dtype": "int16",14+ "dtype": "int16",
15- "format": "ND",15+ "format": "ND",
16- "need_trans": false,16+ "need_trans": false,
17- "data_range": {17+ "data_range": {
18- "min": 0,18+ "min": 0,
19- "max": 6553519+ "max": 65535
20- }20+ }
21- },21+ },
22- {22+ {
23- "name": "input1",23+ "name": "input1",
24- "shape": [24+ "shape": [
25- 32,25+ 32,
26- 3226+ 32
27- ],27+ ],
28- "dtype": "int16",28+ "dtype": "int16",
29- "format": "ND",29+ "format": "ND",
30- "need_trans": false,30+ "need_trans": false,
31- "data_range": {31+ "data_range": {
32- "min": 0,32+ "min": 0,
33- "max": 6553533+ "max": 65535
34- }34+ }
35- }35+ }
36- ],36+ ],
37- "output_tensors": [37+ "output_tensors": [
38- {38+ {
39- "name": "output0",39+ "name": "output0",
40- "shape": [40+ "shape": [
41- 32,41+ 32,
42- 3242+ 32
43- ],43+ ],
44- "dtype": "int16",44+ "dtype": "int16",
45- "format": "ND",45+ "format": "ND",
46- "need_trans": false46+ "need_trans": false
47- }47+ }
48- ],48+ ],
49- "view_shape": [49+ "view_shape": [
50- 16,50+ 16,
51- 1651+ 16
52- ],52+ ],
53- "tile_shape": [53+ "tile_shape": [
54- 16,54+ 16,
55- 1655+ 16
56- ],56+ ],
57- "params": {57+ "params": {
58- "on_board": true,58+ "on_board": true,
59- "func_id": -159+ "func_id": -1
60- },60+ },
61- "index": 061+ "index": 0
62- },62+ },
63- {63+ {
64- "case_index": 1,64+ "case_index": 1,
65- "case_name": "BitwiseXor_2D_align_1",65+ "case_name": "BitwiseXor_2D_align_1",
66- "operation": "BitwiseXor",66+ "operation": "BitwiseXor",
67- "input_tensors": [67+ "input_tensors": [
68- {68+ {
69- "name": "input0",69+ "name": "input0",
70- "shape": [70+ "shape": [
71- 1,71+ 1,
72- 3272+ 32
73- ],73+ ],
74- "dtype": "uint16",74+ "dtype": "uint16",
75- "format": "ND",75+ "format": "ND",
76- "need_trans": false,76+ "need_trans": false,
77- "data_range": {77+ "data_range": {
78- "min": 0,78+ "min": 0,
79- "max": 6553579+ "max": 65535
80- }80+ }
81- },81+ },
82- {82+ {
83- "name": "input1",83+ "name": "input1",
84- "shape": [84+ "shape": [
85- 32,85+ 32,
86- 3286+ 32
87- ],87+ ],
88- "dtype": "uint16",88+ "dtype": "uint16",
89- "format": "ND",89+ "format": "ND",
90- "need_trans": false,90+ "need_trans": false,
91- "data_range": {91+ "data_range": {
92- "min": 0,92+ "min": 0,
93- "max": 6553593+ "max": 65535
94- }94+ }
95- }95+ }
96- ],96+ ],
97- "output_tensors": [97+ "output_tensors": [
98- {98+ {
99- "name": "output0",99+ "name": "output0",
100- "shape": [100+ "shape": [
101- 32,101+ 32,
102- 32102+ 32
103- ],103+ ],
104- "dtype": "uint16",104+ "dtype": "uint16",
105- "format": "ND",105+ "format": "ND",
106- "need_trans": false106+ "need_trans": false
107- }107+ }
108- ],108+ ],
109- "view_shape": [109+ "view_shape": [
110- 16,110+ 16,
111- 16111+ 16
112- ],112+ ],
113- "tile_shape": [113+ "tile_shape": [
114- 16,114+ 16,
115- 16115+ 16
116- ],116+ ],
117- "params": {117+ "params": {
118- "on_board": true,118+ "on_board": true,
119- "func_id": -1119+ "func_id": -1
120- },120+ },
121- "index": 1121+ "index": 1
122- },122+ },
123- {123+ {
124- "case_index": 2,124+ "case_index": 2,
125- "case_name": "BitwiseXor_2D_unalign_0",125+ "case_name": "BitwiseXor_2D_unalign_0",
126- "operation": "BitwiseXor",126+ "operation": "BitwiseXor",
127- "input_tensors": [127+ "input_tensors": [
128- {128+ {
129- "name": "input0",129+ "name": "input0",
130- "shape": [130+ "shape": [
131- 17,131+ 17,
132- 31132+ 31
133- ],133+ ],
134- "dtype": "int16",134+ "dtype": "int16",
135- "format": "ND",135+ "format": "ND",
136- "need_trans": false,136+ "need_trans": false,
137- "data_range": {137+ "data_range": {
138- "min": 0,138+ "min": 0,
139- "max": 255139+ "max": 255
140- }140+ }
141- },141+ },
142- {142+ {
143- "name": "input1",143+ "name": "input1",
144- "shape": [144+ "shape": [
145- 17,145+ 17,
146- 31146+ 31
147- ],147+ ],
148- "dtype": "int16",148+ "dtype": "int16",
149- "format": "ND",149+ "format": "ND",
150- "need_trans": false,150+ "need_trans": false,
151- "data_range": {151+ "data_range": {
152- "min": 0,152+ "min": 0,
153- "max": 255153+ "max": 255
154- }154+ }
155- }155+ }
156- ],156+ ],
157- "output_tensors": [157+ "output_tensors": [
158- {158+ {
159- "name": "output0",159+ "name": "output0",
160- "shape": [160+ "shape": [
161- 17,161+ 17,
162- 31162+ 31
163- ],163+ ],
164- "dtype": "int16",164+ "dtype": "int16",
165- "format": "ND",165+ "format": "ND",
166- "need_trans": false166+ "need_trans": false
167- }167+ }
168- ],168+ ],
169- "view_shape": [169+ "view_shape": [
170- 8,170+ 8,
171- 16171+ 16
172- ],172+ ],
173- "tile_shape": [173+ "tile_shape": [
174- 16,174+ 16,
175- 16175+ 16
176- ],176+ ],
177- "params": {177+ "params": {
178- "on_board": true,178+ "on_board": true,
179- "func_id": -1179+ "func_id": -1
180- },180+ },
181- "index": 2181+ "index": 2
182- },182+ },
183- {183+ {
184- "case_index": 3,184+ "case_index": 3,
185- "case_name": "BitwiseXor_2D_unalign_1",185+ "case_name": "BitwiseXor_2D_unalign_1",
186- "operation": "BitwiseXor",186+ "operation": "BitwiseXor",
187- "input_tensors": [187+ "input_tensors": [
188- {188+ {
189- "name": "input0",189+ "name": "input0",
190- "shape": [190+ "shape": [
191- 17,191+ 17,
192- 1192+ 1
193- ],193+ ],
194- "dtype": "uint16",194+ "dtype": "uint16",
195- "format": "ND",195+ "format": "ND",
196- "need_trans": false,196+ "need_trans": false,
197- "data_range": {197+ "data_range": {
198- "min": 0,198+ "min": 0,
199- "max": 65535199+ "max": 65535
200- }200+ }
201- },201+ },
202- {202+ {
203- "name": "input1",203+ "name": "input1",
204- "shape": [204+ "shape": [
205- 17,205+ 17,
206- 31206+ 31
207- ],207+ ],
208- "dtype": "uint16",208+ "dtype": "uint16",
209- "format": "ND",209+ "format": "ND",
210- "need_trans": false,210+ "need_trans": false,
211- "data_range": {211+ "data_range": {
212- "min": 0,212+ "min": 0,
213- "max": 65535213+ "max": 65535
214- }214+ }
215- }215+ }
216- ],216+ ],
217- "output_tensors": [217+ "output_tensors": [
218- {218+ {
219- "name": "output0",219+ "name": "output0",
220- "shape": [220+ "shape": [
221- 17,221+ 17,
222- 31222+ 31
223- ],223+ ],
224- "dtype": "uint16",224+ "dtype": "uint16",
225- "format": "ND",225+ "format": "ND",
226- "need_trans": false226+ "need_trans": false
227- }227+ }
228- ],228+ ],
229- "view_shape": [229+ "view_shape": [
230- 8,230+ 8,
231- 16231+ 16
232- ],232+ ],
233- "tile_shape": [233+ "tile_shape": [
234- 16,234+ 16,
235- 16235+ 16
236- ],236+ ],
237- "params": {237+ "params": {
238- "on_board": true,238+ "on_board": true,
239- "func_id": -1239+ "func_id": -1
240- },240+ },
241- "index": 3241+ "index": 3
242- },242+ },
243- {243+ {
244- "case_index": 4,244+ "case_index": 4,
245- "case_name": "BitwiseXor_3D_align_0",245+ "case_name": "BitwiseXor_3D_align_0",
246- "operation": "BitwiseXor",246+ "operation": "BitwiseXor",
247- "input_tensors": [247+ "input_tensors": [
248- {248+ {
249- "name": "input0",249+ "name": "input0",
250- "shape": [250+ "shape": [
251- 32,251+ 32,
252- 16,252+ 16,
253- 8253+ 8
254- ],254+ ],
255- "dtype": "int16",255+ "dtype": "int16",
256- "format": "ND",256+ "format": "ND",
257- "need_trans": false,257+ "need_trans": false,
258- "data_range": {258+ "data_range": {
259- "min": 0,259+ "min": 0,
260- "max": 255260+ "max": 255
261- }261+ }
262- },262+ },
263- {263+ {
264- "name": "input1",264+ "name": "input1",
265- "shape": [265+ "shape": [
266- 32,266+ 32,
267- 16,267+ 16,
268- 8268+ 8
269- ],269+ ],
270- "dtype": "int16",270+ "dtype": "int16",
271- "format": "ND",271+ "format": "ND",
272- "need_trans": false,272+ "need_trans": false,
273- "data_range": {273+ "data_range": {
274- "min": 0,274+ "min": 0,
275- "max": 255275+ "max": 255
276- }276+ }
277- }277+ }
278- ],278+ ],
279- "output_tensors": [279+ "output_tensors": [
280- {280+ {
281- "name": "output0",281+ "name": "output0",
282- "shape": [282+ "shape": [
283- 32,283+ 32,
284- 16,284+ 16,
285- 8285+ 8
286- ],286+ ],
287- "dtype": "int16",287+ "dtype": "int16",
288- "format": "ND",288+ "format": "ND",
289- "need_trans": false289+ "need_trans": false
290- }290+ }
291- ],291+ ],
292- "view_shape": [292+ "view_shape": [
293- 16,293+ 16,
294- 8,294+ 8,
295- 4295+ 4
296- ],296+ ],
297- "tile_shape": [297+ "tile_shape": [
298- 16,298+ 16,
299- 16,299+ 16,
300- 16300+ 16
301- ],301+ ],
302- "params": {302+ "params": {
303- "on_board": true,303+ "on_board": true,
304- "func_id": -1304+ "func_id": -1
305- },305+ },
306- "index": 4306+ "index": 4
307- },307+ },
308- {308+ {
309- "case_index": 5,309+ "case_index": 5,
310- "case_name": "BitwiseXor_3D_align_1",310+ "case_name": "BitwiseXor_3D_align_1",
311- "operation": "BitwiseXor",311+ "operation": "BitwiseXor",
312- "input_tensors": [312+ "input_tensors": [
313- {313+ {
314- "name": "input0",314+ "name": "input0",
315- "shape": [315+ "shape": [
316- 32,316+ 32,
317- 1,317+ 1,
318- 8318+ 8
319- ],319+ ],
320- "dtype": "uint16",320+ "dtype": "uint16",
321- "format": "ND",321+ "format": "ND",
322- "need_trans": false,322+ "need_trans": false,
323- "data_range": {323+ "data_range": {
324- "min": 0,324+ "min": 0,
325- "max": 65535325+ "max": 65535
326- }326+ }
327- },327+ },
328- {328+ {
329- "name": "input1",329+ "name": "input1",
330- "shape": [330+ "shape": [
331- 32,331+ 32,
332- 16,332+ 16,
333- 8333+ 8
334- ],334+ ],
335- "dtype": "uint16",335+ "dtype": "uint16",
336- "format": "ND",336+ "format": "ND",
337- "need_trans": false,337+ "need_trans": false,
338- "data_range": {338+ "data_range": {
339- "min": 0,339+ "min": 0,
340- "max": 65535340+ "max": 65535
341- }341+ }
342- }342+ }
343- ],343+ ],
344- "output_tensors": [344+ "output_tensors": [
345- {345+ {
346- "name": "output0",346+ "name": "output0",
347- "shape": [347+ "shape": [
348- 32,348+ 32,
349- 16,349+ 16,
350- 8350+ 8
351- ],351+ ],
352- "dtype": "uint16",352+ "dtype": "uint16",
353- "format": "ND",353+ "format": "ND",
354- "need_trans": false354+ "need_trans": false
355- }355+ }
356- ],356+ ],
357- "view_shape": [357+ "view_shape": [
358- 16,358+ 16,
359- 8,359+ 8,
360- 4360+ 4
361- ],361+ ],
362- "tile_shape": [362+ "tile_shape": [
363- 16,363+ 16,
364- 16,364+ 16,
365- 16365+ 16
366- ],366+ ],
367- "params": {367+ "params": {
368- "on_board": true,368+ "on_board": true,
369- "func_id": -1369+ "func_id": -1
370- },370+ },
371- "index": 5371+ "index": 5
372- },372+ },
373- {373+ {
374- "case_index": 6,374+ "case_index": 6,
375- "case_name": "BitwiseXor_3D_unalign_0",375+ "case_name": "BitwiseXor_3D_unalign_0",
376- "operation": "BitwiseXor",376+ "operation": "BitwiseXor",
377- "input_tensors": [377+ "input_tensors": [
378- {378+ {
379- "name": "input0",379+ "name": "input0",
380- "shape": [380+ "shape": [
381- 33,381+ 33,
382- 15,382+ 15,
383- 9383+ 9
384- ],384+ ],
385- "dtype": "int16",385+ "dtype": "int16",
386- "format": "ND",386+ "format": "ND",
387- "need_trans": false,387+ "need_trans": false,
388- "data_range": {388+ "data_range": {
389- "min": 0,389+ "min": 0,
390- "max": 255390+ "max": 255
391- }391+ }
392- },392+ },
393- {393+ {
394- "name": "input1",394+ "name": "input1",
395- "shape": [395+ "shape": [
396- 33,396+ 33,
397- 15,397+ 15,
398- 9398+ 9
399- ],399+ ],
400- "dtype": "int16",400+ "dtype": "int16",
401- "format": "ND",401+ "format": "ND",
402- "need_trans": false,402+ "need_trans": false,
403- "data_range": {403+ "data_range": {
404- "min": 0,404+ "min": 0,
405- "max": 255405+ "max": 255
406- }406+ }
407- }407+ }
408- ],408+ ],
409- "output_tensors": [409+ "output_tensors": [
410- {410+ {
411- "name": "output0",411+ "name": "output0",
412- "shape": [412+ "shape": [
413- 33,413+ 33,
414- 15,414+ 15,
415- 9415+ 9
416- ],416+ ],
417- "dtype": "int16",417+ "dtype": "int16",
418- "format": "ND",418+ "format": "ND",
419- "need_trans": false419+ "need_trans": false
420- }420+ }
421- ],421+ ],
422- "view_shape": [422+ "view_shape": [
423- 16,423+ 16,
424- 8,424+ 8,
425- 4425+ 4
426- ],426+ ],
427- "tile_shape": [427+ "tile_shape": [
428- 16,428+ 16,
429- 16,429+ 16,
430- 16430+ 16
431- ],431+ ],
432- "params": {432+ "params": {
433- "on_board": true,433+ "on_board": true,
434- "func_id": -1434+ "func_id": -1
435- },435+ },
436- "index": 6436+ "index": 6
437- },437+ },
438- {438+ {
439- "case_index": 7,439+ "case_index": 7,
440- "case_name": "BitwiseXor_3D_unalign_1",440+ "case_name": "BitwiseXor_3D_unalign_1",
441- "operation": "BitwiseXor",441+ "operation": "BitwiseXor",
442- "input_tensors": [442+ "input_tensors": [
443- {443+ {
444- "name": "input0",444+ "name": "input0",
445- "shape": [445+ "shape": [
446- 1,446+ 1,
447- 15,447+ 15,
448- 9448+ 9
449- ],449+ ],
450- "dtype": "uint16",450+ "dtype": "uint16",
451- "format": "ND",451+ "format": "ND",
452- "need_trans": false,452+ "need_trans": false,
453- "data_range": {453+ "data_range": {
454- "min": 0,454+ "min": 0,
455- "max": 65535455+ "max": 65535
456- }456+ }
457- },457+ },
458- {458+ {
459- "name": "input1",459+ "name": "input1",
460- "shape": [460+ "shape": [
461- 33,461+ 33,
462- 15,462+ 15,
463- 9463+ 9
464- ],464+ ],
465- "dtype": "uint16",465+ "dtype": "uint16",
466- "format": "ND",466+ "format": "ND",
467- "need_trans": false,467+ "need_trans": false,
468- "data_range": {468+ "data_range": {
469- "min": 0,469+ "min": 0,
470- "max": 65535470+ "max": 65535
471- }471+ }
472- }472+ }
473- ],473+ ],
474- "output_tensors": [474+ "output_tensors": [
475- {475+ {
476- "name": "output0",476+ "name": "output0",
477- "shape": [477+ "shape": [
478- 33,478+ 33,
479- 15,479+ 15,
480- 9480+ 9
481- ],481+ ],
482- "dtype": "uint16",482+ "dtype": "uint16",
483- "format": "ND",483+ "format": "ND",
484- "need_trans": false484+ "need_trans": false
485- }485+ }
486- ],486+ ],
487- "view_shape": [487+ "view_shape": [
488- 16,488+ 16,
489- 8,489+ 8,
490- 4490+ 4
491- ],491+ ],
492- "tile_shape": [492+ "tile_shape": [
493- 16,493+ 16,
494- 16,494+ 16,
495- 16495+ 16
496- ],496+ ],
497- "params": {497+ "params": {
498- "on_board": true,498+ "on_board": true,
499- "func_id": -1499+ "func_id": -1
500- },500+ },
501- "index": 7501+ "index": 7
502- },502+ },
503- {503+ {
504- "case_index": 8,504+ "case_index": 8,
505- "case_name": "BitwiseXor_4D_align_0",505+ "case_name": "BitwiseXor_4D_align_0",
506- "operation": "BitwiseXor",506+ "operation": "BitwiseXor",
507- "input_tensors": [507+ "input_tensors": [
508- {508+ {
509- "name": "input0",509+ "name": "input0",
510- "shape": [510+ "shape": [
511- 16,511+ 16,
512- 8,512+ 8,
513- 4,513+ 4,
514- 2514+ 2
515- ],515+ ],
516- "dtype": "int16",516+ "dtype": "int16",
517- "format": "ND",517+ "format": "ND",
518- "need_trans": false,518+ "need_trans": false,
519- "data_range": {519+ "data_range": {
520- "min": 0,520+ "min": 0,
521- "max": 255521+ "max": 255
522- }522+ }
523- },523+ },
524- {524+ {
525- "name": "input1",525+ "name": "input1",
526- "shape": [526+ "shape": [
527- 16,527+ 16,
528- 8,528+ 8,
529- 4,529+ 4,
530- 2530+ 2
531- ],531+ ],
532- "dtype": "int16",532+ "dtype": "int16",
533- "format": "ND",533+ "format": "ND",
534- "need_trans": false,534+ "need_trans": false,
535- "data_range": {535+ "data_range": {
536- "min": 0,536+ "min": 0,
537- "max": 255537+ "max": 255
538- }538+ }
539- }539+ }
540- ],540+ ],
541- "output_tensors": [541+ "output_tensors": [
542- {542+ {
543- "name": "output0",543+ "name": "output0",
544- "shape": [544+ "shape": [
545- 16,545+ 16,
546- 8,546+ 8,
547- 4,547+ 4,
548- 2548+ 2
549- ],549+ ],
550- "dtype": "int16",550+ "dtype": "int16",
551- "format": "ND",551+ "format": "ND",
552- "need_trans": false552+ "need_trans": false
553- }553+ }
554- ],554+ ],
555- "view_shape": [555+ "view_shape": [
556- 8,556+ 8,
557- 4,557+ 4,
558- 2,558+ 2,
559- 1559+ 1
560- ],560+ ],
561- "tile_shape": [561+ "tile_shape": [
562- 16,562+ 16,
563- 16,563+ 16,
564- 16,564+ 16,
565- 16565+ 16
566- ],566+ ],
567- "params": {567+ "params": {
568- "on_board": true,568+ "on_board": true,
569- "func_id": -1569+ "func_id": -1
570- },570+ },
571- "index": 8571+ "index": 8
572- },572+ },
573- {573+ {
574- "case_index": 9,574+ "case_index": 9,
575- "case_name": "BitwiseXor_4D_align_1",575+ "case_name": "BitwiseXor_4D_align_1",
576- "operation": "BitwiseXor",576+ "operation": "BitwiseXor",
577- "input_tensors": [577+ "input_tensors": [
578- {578+ {
579- "name": "input0",579+ "name": "input0",
580- "shape": [580+ "shape": [
581- 16,581+ 16,
582- 1,582+ 1,
583- 4,583+ 4,
584- 2584+ 2
585- ],585+ ],
586- "dtype": "uint16",586+ "dtype": "uint16",
587- "format": "ND",587+ "format": "ND",
588- "need_trans": false,588+ "need_trans": false,
589- "data_range": {589+ "data_range": {
590- "min": 0,590+ "min": 0,
591- "max": 65535591+ "max": 65535
592- }592+ }
593- },593+ },
594- {594+ {
595- "name": "input1",595+ "name": "input1",
596- "shape": [596+ "shape": [
597- 16,597+ 16,
598- 8,598+ 8,
599- 4,599+ 4,
600- 2600+ 2
601- ],601+ ],
602- "dtype": "uint16",602+ "dtype": "uint16",
603- "format": "ND",603+ "format": "ND",
604- "need_trans": false,604+ "need_trans": false,
605- "data_range": {605+ "data_range": {
606- "min": 0,606+ "min": 0,
607- "max": 65535607+ "max": 65535
608- }608+ }
609- }609+ }
610- ],610+ ],
611- "output_tensors": [611+ "output_tensors": [
612- {612+ {
613- "name": "output0",613+ "name": "output0",
614- "shape": [614+ "shape": [
615- 16,615+ 16,
616- 8,616+ 8,
617- 4,617+ 4,
618- 2618+ 2
619- ],619+ ],
620- "dtype": "uint16",620+ "dtype": "uint16",
621- "format": "ND",621+ "format": "ND",
622- "need_trans": false622+ "need_trans": false
623- }623+ }
624- ],624+ ],
625- "view_shape": [625+ "view_shape": [
626- 8,626+ 8,
627- 4,627+ 4,
628- 2,628+ 2,
629- 1629+ 1
630- ],630+ ],
631- "tile_shape": [631+ "tile_shape": [
632- 16,632+ 16,
633- 16,633+ 16,
634- 16,634+ 16,
635- 16635+ 16
636- ],636+ ],
637- "params": {637+ "params": {
638- "on_board": true,638+ "on_board": true,
639- "func_id": -1639+ "func_id": -1
640- },640+ },
641- "index": 9641+ "index": 9
642- },642+ },
643- {643+ {
644- "case_index": 10,644+ "case_index": 10,
645- "case_name": "BitwiseXor_4D_unalign_0",645+ "case_name": "BitwiseXor_4D_unalign_0",
646- "operation": "BitwiseXor",646+ "operation": "BitwiseXor",
647- "input_tensors": [647+ "input_tensors": [
648- {648+ {
649- "name": "input0",649+ "name": "input0",
650- "shape": [650+ "shape": [
651- 17,651+ 17,
652- 7,652+ 7,
653- 5,653+ 5,
654- 3654+ 3
655- ],655+ ],
656- "dtype": "int16",656+ "dtype": "int16",
657- "format": "ND",657+ "format": "ND",
658- "need_trans": false,658+ "need_trans": false,
659- "data_range": {659+ "data_range": {
660- "min": 0,660+ "min": 0,
661- "max": 255661+ "max": 255
662- }662+ }
663- },663+ },
664- {664+ {
665- "name": "input1",665+ "name": "input1",
666- "shape": [666+ "shape": [
667- 17,667+ 17,
668- 7,668+ 7,
669- 5,669+ 5,
670- 3670+ 3
671- ],671+ ],
672- "dtype": "int16",672+ "dtype": "int16",
673- "format": "ND",673+ "format": "ND",
674- "need_trans": false,674+ "need_trans": false,
675- "data_range": {675+ "data_range": {
676- "min": 0,676+ "min": 0,
677- "max": 255677+ "max": 255
678- }678+ }
679- }679+ }
680- ],680+ ],
681- "output_tensors": [681+ "output_tensors": [
682- {682+ {
683- "name": "output0",683+ "name": "output0",
684- "shape": [684+ "shape": [
685- 17,685+ 17,
686- 7,686+ 7,
687- 5,687+ 5,
688- 3688+ 3
689- ],689+ ],
690- "dtype": "int16",690+ "dtype": "int16",
691- "format": "ND",691+ "format": "ND",
692- "need_trans": false692+ "need_trans": false
693- }693+ }
694- ],694+ ],
695- "view_shape": [695+ "view_shape": [
696- 8,696+ 8,
697- 4,697+ 4,
698- 2,698+ 2,
699- 1699+ 1
700- ],700+ ],
701- "tile_shape": [701+ "tile_shape": [
702- 16,702+ 16,
703- 16,703+ 16,
704- 16,704+ 16,
705- 16705+ 16
706- ],706+ ],
707- "params": {707+ "params": {
708- "on_board": true,708+ "on_board": true,
709- "func_id": -1709+ "func_id": -1
710- },710+ },
711- "index": 10711+ "index": 10
712- },712+ },
713- {713+ {
714- "case_index": 11,714+ "case_index": 11,
715- "case_name": "BitwiseXor_4D_unalign_1",715+ "case_name": "BitwiseXor_4D_unalign_1",
716- "operation": "BitwiseXor",716+ "operation": "BitwiseXor",
717- "input_tensors": [717+ "input_tensors": [
718- {718+ {
719- "name": "input0",719+ "name": "input0",
720- "shape": [720+ "shape": [
721- 17,721+ 17,
722- 7,722+ 7,
723- 1,723+ 1,
724- 3724+ 3
725- ],725+ ],
726- "dtype": "uint16",726+ "dtype": "uint16",
727- "format": "ND",727+ "format": "ND",
728- "need_trans": false,728+ "need_trans": false,
729- "data_range": {729+ "data_range": {
730- "min": 0,730+ "min": 0,
731- "max": 65535731+ "max": 65535
732- }732+ }
733- },733+ },
734- {734+ {
735- "name": "input1",735+ "name": "input1",
736- "shape": [736+ "shape": [
737- 17,737+ 17,
738- 7,738+ 7,
739- 5,739+ 5,
740- 3740+ 3
741- ],741+ ],
742- "dtype": "uint16",742+ "dtype": "uint16",
743- "format": "ND",743+ "format": "ND",
744- "need_trans": false,744+ "need_trans": false,
745- "data_range": {745+ "data_range": {
746- "min": 0,746+ "min": 0,
747- "max": 65535747+ "max": 65535
748- }748+ }
749- }749+ }
750- ],750+ ],
751- "output_tensors": [751+ "output_tensors": [
752- {752+ {
753- "name": "output0",753+ "name": "output0",
754- "shape": [754+ "shape": [
755- 17,755+ 17,
756- 7,756+ 7,
757- 5,757+ 5,
758- 3758+ 3
759- ],759+ ],
760- "dtype": "uint16",760+ "dtype": "uint16",
761- "format": "ND",761+ "format": "ND",
762- "need_trans": false762+ "need_trans": false
763- }763+ }
764- ],764+ ],
765- "view_shape": [765+ "view_shape": [
766- 8,766+ 8,
767- 4,767+ 4,
768- 2,768+ 2,
769- 1769+ 1
770- ],770+ ],
771- "tile_shape": [771+ "tile_shape": [
772- 16,772+ 16,
773- 16,773+ 16,
774- 16,774+ 16,
775- 16775+ 16
776- ],776+ ],
777- "params": {777+ "params": {
778- "on_board": true,778+ "on_board": true,
779- "func_id": -1779+ "func_id": -1
780- },780+ },
781- "index": 11781+ "index": 11
782- },782+ },
783- {783+ {
784- "case_index": 12,784+ "case_index": 12,
785- "case_name": "BitwiseXor_test_1",785+ "case_name": "BitwiseXor_test_1",
786- "operation": "BitwiseXor",786+ "operation": "BitwiseXor",
787- "input_tensors": [787+ "input_tensors": [
788- {788+ {
789- "name": "input0",789+ "name": "input0",
790- "shape": [790+ "shape": [
791- 32,791+ 32,
792- 32792+ 32
793- ],793+ ],
794- "dtype": "int8",794+ "dtype": "int8",
795- "data_range": {795+ "format": "ND",
796- "min": -10,796+ "need_trans": false,
797- "max": 10797+ "data_range": {
798- },798+ "min": -10,
799- "format": "ND"799+ "max": 10
800- },800+ }
801- {801+ },
802- "name": "input1",802+ {
803- "shape": [803+ "name": "input1",
804- 32,804+ "shape": [
805- 32805+ 32,
806- ],806+ 32
807- "dtype": "int8",807+ ],
808- "data_range": {808+ "dtype": "int8",
809- "min": -10,809+ "format": "ND",
810- "max": 10810+ "need_trans": false,
811- },811+ "data_range": {
812- "format": "ND"812+ "min": -10,
813- }813+ "max": 10
814- ],814+ }
815- "output_tensors": [815+ }
816- {816+ ],
817- "name": "output0",817+ "output_tensors": [
818- "shape": [818+ {
819- 32,819+ "name": "output0",
820- 32820+ "shape": [
821- ],821+ 32,
822- "dtype": "int8",822+ 32
823- "format": "ND"823+ ],
824- }824+ "dtype": "int8",
825- ],825+ "format": "ND",
826- "view_shape": [826+ "need_trans": false
827- 16,827+ }
828- 16828+ ],
829- ],829+ "view_shape": [
830- "tile_shape": [830+ 16,
831- 16,831+ 16
832- 16832+ ],
833- ],833+ "tile_shape": [
834- "params": {834+ 16,
835- "func_id": -1835+ 16
836- },836+ ],
837- "index": 12837+ "params": {
838- },838+ "on_board": true,
839- {839+ "func_id": -1
840- "case_index": 13,840+ },
841- "case_name": "BitwiseXor_test_2",841+ "index": 12
842- "operation": "BitwiseXor",842+ },
843- "input_tensors": [843+ {
844- {844+ "case_index": 13,
845- "name": "input0",845+ "case_name": "BitwiseXor_test_2",
846- "shape": [846+ "operation": "BitwiseXor",
847- 32,847+ "input_tensors": [
848- 32848+ {
849- ],849+ "name": "input0",
850- "dtype": "uint8",850+ "shape": [
851- "data_range": {851+ 32,
852- "min": -10,852+ 32
853- "max": 10853+ ],
854- },854+ "dtype": "uint8",
855- "format": "ND"855+ "format": "ND",
856- },856+ "need_trans": false,
857- {857+ "data_range": {
858- "name": "input1",858+ "min": -10,
859- "shape": [859+ "max": 10
860- 32,860+ }
861- 32861+ },
862- ],862+ {
863- "dtype": "uint8",863+ "name": "input1",
864- "data_range": {864+ "shape": [
865- "min": -10,865+ 32,
866- "max": 10866+ 32
867- },867+ ],
868- "format": "ND"868+ "dtype": "uint8",
869- }869+ "format": "ND",
870- ],870+ "need_trans": false,
871- "output_tensors": [871+ "data_range": {
872- {872+ "min": -10,
873- "name": "output0",873+ "max": 10
874- "shape": [874+ }
875- 32,875+ }
876- 32876+ ],
877- ],877+ "output_tensors": [
878- "dtype": "uint8",878+ {
879- "format": "ND"879+ "name": "output0",
880- }880+ "shape": [
881- ],881+ 32,
882- "view_shape": [882+ 32
883- 16,883+ ],
884- 16884+ "dtype": "uint8",
885- ],885+ "format": "ND",
886- "tile_shape": [886+ "need_trans": false
887- 16,887+ }
888- 16888+ ],
889- ],889+ "view_shape": [
890- "params": {890+ 16,
891- "func_id": -1891+ 16
892- },892+ ],
893- "index": 13893+ "tile_shape": [
894- },894+ 16,
895- {895+ 16
896- "case_index": 14,896+ ],
897- "case_name": "BitwiseXor_test_3",897+ "params": {
898- "operation": "BitwiseXor",898+ "on_board": true,
899- "input_tensors": [899+ "func_id": -1
900- {900+ },
901- "name": "input0",901+ "index": 13
902- "shape": [902+ },
903- 32,903+ {
904- 32904+ "case_index": 14,
905- ],905+ "case_name": "BitwiseXor_test_3",
906- "dtype": "int32",906+ "operation": "BitwiseXor",
907- "data_range": {907+ "input_tensors": [
908- "min": -1000,908+ {
909- "max": 1000909+ "name": "input0",
910- },910+ "shape": [
911- "format": "ND"911+ 32,
912- },912+ 32
913- {913+ ],
914- "name": "input1",914+ "dtype": "int32",
915- "shape": [915+ "format": "ND",
916- 32,916+ "need_trans": false,
917- 32917+ "data_range": {
918- ],918+ "min": -1000,
919- "dtype": "int32",919+ "max": 1000
920- "data_range": {920+ }
921- "min": -1000,921+ },
922- "max": 1000922+ {
923- },923+ "name": "input1",
924- "format": "ND"924+ "shape": [
925- }925+ 32,
926- ],926+ 32
927- "output_tensors": [927+ ],
928- {928+ "dtype": "int32",
929- "name": "output0",929+ "format": "ND",
930- "shape": [930+ "need_trans": false,
931- 32,931+ "data_range": {
932- 32932+ "min": -1000,
933- ],933+ "max": 1000
934- "dtype": "int32",934+ }
935- "format": "ND"935+ }
936- }936+ ],
937- ],937+ "output_tensors": [
938- "view_shape": [938+ {
939- 16,939+ "name": "output0",
940- 16940+ "shape": [
941- ],941+ 32,
942- "tile_shape": [942+ 32
943- 16,943+ ],
944- 16944+ "dtype": "int32",
945- ],945+ "format": "ND",
946- "params": {946+ "need_trans": false
947- "func_id": -1947+ }
948- },948+ ],
949- "index": 14949+ "view_shape": [
950- }950+ 16,
951- ]951+ 16
952+ ],
953+ "tile_shape": [
954+ 16,
955+ 16
956+ ],
957+ "params": {
958+ "on_board": true,
959+ "func_id": -1
960+ },
961+ "index": 14
962+ },
963+ {
964+ "case_index": 15,
965+ "case_name": "BitwiseXor_test_4",
966+ "operation": "BitwiseXor",
967+ "input_tensors": [
968+ {
969+ "name": "input0",
970+ "shape": [
971+ 32,
972+ 32
973+ ],
974+ "dtype": "uint32",
975+ "format": "ND",
976+ "need_trans": false,
977+ "data_range": {
978+ "min": 0,
979+ "max": 65535
980+ }
981+ },
982+ {
983+ "name": "input1",
984+ "shape": [
985+ 32,
986+ 32
987+ ],
988+ "dtype": "uint32",
989+ "format": "ND",
990+ "need_trans": false,
991+ "data_range": {
992+ "min": 0,
993+ "max": 65535
994+ }
995+ }
996+ ],
997+ "output_tensors": [
998+ {
999+ "name": "output0",
1000+ "shape": [
1001+ 32,
1002+ 32
1003+ ],
1004+ "dtype": "uint32",
1005+ "format": "ND",
1006+ "need_trans": false
1007+ }
1008+ ],
1009+ "view_shape": [
1010+ 16,
1011+ 16
1012+ ],
1013+ "tile_shape": [
1014+ 16,
1015+ 16
1016+ ],
1017+ "params": {
1018+ "on_board": true,
1019+ "func_id": -1
1020+ },
1021+ "index": 15
1022+ }
1023+ ]
952}1024}
Mframework/tests/st/operation/test_case/BitwiseXors_st_test_cases.csv+4-0
@@ -11,3 +11,7 @@ BitwiseXor_scalar_4D_align_0,"[16, 8, 4, 2]",int16,ND,"[0, 255]","[16, 8, 4, 2]"
11BitwiseXor_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint1611BitwiseXor_scalar_4D_align_1,"[16, 8, 4, 2]",uint16,ND,"[0, 65535]","[16, 8, 4, 2]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",78,uint16
12BitwiseXor_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int1612BitwiseXor_scalar_4D_unalign_0,"[17, 7, 5, 3]",int16,ND,"[0, 255]","[17, 7, 5, 3]",int16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",-2,int16
13BitwiseXor_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint1613BitwiseXor_scalar_4D_unalign_1,"[17, 7, 5, 3]",uint16,ND,"[0, 65535]","[17, 7, 5, 3]",uint16,ND,"[8, 4, 2, 1]","[16, 16, 16, 16]",58,uint16
14+BitwiseXor_scalar_int8,"[32, 32]",int8,ND,"[-10, 10]","[32, 32]",int8,ND,"[16, 16]","[16, 16]",-3,int8
15+BitwiseXor_scalar_uint8,"[32, 32]",uint8,ND,"[0, 255]","[32, 32]",uint8,ND,"[16, 16]","[16, 16]",240,uint8
16+BitwiseXor_scalar_int32,"[32, 32]",int32,ND,"[-1000, 1000]","[32, 32]",int32,ND,"[16, 16]","[16, 16]",-257,int32
17+BitwiseXor_scalar_uint32,"[32, 32]",uint32,ND,"[0, 65535]","[32, 32]",uint32,ND,"[16, 16]","[16, 16]",65535,uint32
Mframework/tests/st/operation/test_case/BitwiseXors_st_test_cases.json+192-0
@@ -623,6 +623,198 @@
623 "func_id": -1623 "func_id": -1
624 },624 },
625 "index": 11625 "index": 11
626+ },
627+ {
628+ "case_index": 12,
629+ "case_name": "BitwiseXor_scalar_int8",
630+ "operation": "BitwiseXors",
631+ "input_tensors": [
632+ {
633+ "name": "input0",
634+ "shape": [
635+ 32,
636+ 32
637+ ],
638+ "dtype": "int8",
639+ "format": "ND",
640+ "need_trans": false,
641+ "data_range": {
642+ "min": -10,
643+ "max": 10
644+ }
645+ }
646+ ],
647+ "output_tensors": [
648+ {
649+ "name": "output0",
650+ "shape": [
651+ 32,
652+ 32
653+ ],
654+ "dtype": "int8",
655+ "format": "ND",
656+ "need_trans": false
657+ }
658+ ],
659+ "view_shape": [
660+ 16,
661+ 16
662+ ],
663+ "tile_shape": [
664+ 16,
665+ 16
666+ ],
667+ "params": {
668+ "scalar": -3,
669+ "scalar_type": "int8",
670+ "on_board": true,
671+ "func_id": -1
672+ },
673+ "index": 12
674+ },
675+ {
676+ "case_index": 13,
677+ "case_name": "BitwiseXor_scalar_uint8",
678+ "operation": "BitwiseXors",
679+ "input_tensors": [
680+ {
681+ "name": "input0",
682+ "shape": [
683+ 32,
684+ 32
685+ ],
686+ "dtype": "uint8",
687+ "format": "ND",
688+ "need_trans": false,
689+ "data_range": {
690+ "min": 0,
691+ "max": 255
692+ }
693+ }
694+ ],
695+ "output_tensors": [
696+ {
697+ "name": "output0",
698+ "shape": [
699+ 32,
700+ 32
701+ ],
702+ "dtype": "uint8",
703+ "format": "ND",
704+ "need_trans": false
705+ }
706+ ],
707+ "view_shape": [
708+ 16,
709+ 16
710+ ],
711+ "tile_shape": [
712+ 16,
713+ 16
714+ ],
715+ "params": {
716+ "scalar": 240,
717+ "scalar_type": "uint8",
718+ "on_board": true,
719+ "func_id": -1
720+ },
721+ "index": 13
722+ },
723+ {
724+ "case_index": 14,
725+ "case_name": "BitwiseXor_scalar_int32",
726+ "operation": "BitwiseXors",
727+ "input_tensors": [
728+ {
729+ "name": "input0",
730+ "shape": [
731+ 32,
732+ 32
733+ ],
734+ "dtype": "int32",
735+ "format": "ND",
736+ "need_trans": false,
737+ "data_range": {
738+ "min": -1000,
739+ "max": 1000
740+ }
741+ }
742+ ],
743+ "output_tensors": [
744+ {
745+ "name": "output0",
746+ "shape": [
747+ 32,
748+ 32
749+ ],
750+ "dtype": "int32",
751+ "format": "ND",
752+ "need_trans": false
753+ }
754+ ],
755+ "view_shape": [
756+ 16,
757+ 16
758+ ],
759+ "tile_shape": [
760+ 16,
761+ 16
762+ ],
763+ "params": {
764+ "scalar": -257,
765+ "scalar_type": "int32",
766+ "on_board": true,
767+ "func_id": -1
768+ },
769+ "index": 14
770+ },
771+ {
772+ "case_index": 15,
773+ "case_name": "BitwiseXor_scalar_uint32",
774+ "operation": "BitwiseXors",
775+ "input_tensors": [
776+ {
777+ "name": "input0",
778+ "shape": [
779+ 32,
780+ 32
781+ ],
782+ "dtype": "uint32",
783+ "format": "ND",
784+ "need_trans": false,
785+ "data_range": {
786+ "min": 0,
787+ "max": 65535
788+ }
789+ }
790+ ],
791+ "output_tensors": [
792+ {
793+ "name": "output0",
794+ "shape": [
795+ 32,
796+ 32
797+ ],
798+ "dtype": "uint32",
799+ "format": "ND",
800+ "need_trans": false
801+ }
802+ ],
803+ "view_shape": [
804+ 16,
805+ 16
806+ ],
807+ "tile_shape": [
808+ 16,
809+ 16
810+ ],
811+ "params": {
812+ "scalar": 65535,
813+ "scalar_type": "uint32",
814+ "on_board": true,
815+ "func_id": -1
816+ },
817+ "index": 15
626 }818 }
627 ]819 ]
628}820}