From 37de10eebd995816b2186782a0c95d95d470e216 Mon Sep 17 00:00:00 2001 From: liuzhongkai Date: Fri, 27 Nov 2020 10:36:26 +0800 Subject: [PATCH] add tensorlist op --- mindspore/lite/nnacl/tensorlist_parameter.h | 30 ++ mindspore/lite/schema/ops.fbs | 3 + .../populate/tensorlistfromtensor_populate.cc | 42 +++ .../populate/tensorlistgetitem_populate.cc | 41 +++ .../populate/tensorlistreserve_populate.cc | 41 +++ .../ops/populate/tensorliststack_populate.cc | 41 +++ mindspore/lite/src/ops/tensor_list.cc | 314 ++++++++++++++++++ mindspore/lite/src/ops/tensor_list.h | 75 +++++ .../kernel/arm/fp32/TensorListFromTensor.cc | 124 +++++++ .../kernel/arm/fp32/TensorListFromTensor.h | 54 +++ .../kernel/arm/fp32/TensorListGetItem.cc | 101 ++++++ .../kernel/arm/fp32/TensorListGetItem.h | 45 +++ .../kernel/arm/fp32/TensorListReserve.cc | 82 +++++ .../kernel/arm/fp32/TensorListReserve.h | 44 +++ .../kernel/arm/fp32/TensorListStack.cc | 122 +++++++ .../runtime/kernel/arm/fp32/TensorListStack.h | 48 +++ 16 files changed, 1207 insertions(+) create mode 100644 mindspore/lite/nnacl/tensorlist_parameter.h create mode 100644 mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc create mode 100644 mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc create mode 100644 mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc create mode 100644 mindspore/lite/src/ops/populate/tensorliststack_populate.cc create mode 100644 mindspore/lite/src/ops/tensor_list.cc create mode 100644 mindspore/lite/src/ops/tensor_list.h create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.cc create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.h create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.cc create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.h create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.cc create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.h create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.cc create mode 100644 mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.h diff --git a/mindspore/lite/nnacl/tensorlist_parameter.h b/mindspore/lite/nnacl/tensorlist_parameter.h new file mode 100644 index 0000000000..3f2295bf3b --- /dev/null +++ b/mindspore/lite/nnacl/tensorlist_parameter.h @@ -0,0 +1,30 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINDSPORE_LITE_NNACL_TENSORLIST_PARAMETER_H_ +#define MINDSPORE_LITE_NNACL_TENSORLIST_PARAMETER_H_ + +#include "nnacl/op_base.h" +#include "ir/dtype/type_id.h" + +typedef struct TensorListParameter { + OpParameter op_parameter_; + mindspore::TypeId shape_type_; + mindspore::TypeId element_dtype_; + int num_element_; +} TensorListParameter; + +#endif // MINDSPORE_LITE_NNACL_ARG_TENSORLIST_PARAMETER_H_ diff --git a/mindspore/lite/schema/ops.fbs b/mindspore/lite/schema/ops.fbs index 7512f0ddc5..c705a15b92 100644 --- a/mindspore/lite/schema/ops.fbs +++ b/mindspore/lite/schema/ops.fbs @@ -1152,6 +1152,8 @@ table Partial { } table TensorListFromTensor { + elementDType : int; + shapeType : int; } table TensorListStack { @@ -1164,6 +1166,7 @@ table TensorListGetItem { } table TensorListSetItem { + elementDType : int; } table TensorListReserve { diff --git a/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc new file mode 100644 index 0000000000..b37d3c92b0 --- /dev/null +++ b/mindspore/lite/src/ops/populate/tensorlistfromtensor_populate.cc @@ -0,0 +1,42 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "nnacl/tensorlist_parameter.h" +#include "src/ops/primitive_c.h" +#include "src/ops/populate/populate_register.h" +#include "src/ops/tensor_list.h" + +namespace mindspore { +namespace lite { +OpParameter *PopulateTensorListFromTensorParameter(const mindspore::lite::PrimitiveC *primitive) { + TensorListParameter *TensorList_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (TensorList_param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(TensorList_param, 0, sizeof(TensorListParameter)); + TensorList_param->op_parameter_.type_ = primitive->Type(); + auto tensorList = + reinterpret_cast(const_cast(primitive)); + TensorList_param->shape_type_ = tensorList->GetShapeType(); + TensorList_param->element_dtype_ = tensorList->GetElementDType(); + return reinterpret_cast(TensorList_param); +} +Registry TensorListFromTensorParameterRegistry(schema::PrimitiveType_TensorListFromTensor, + PopulateTensorListFromTensorParameter); + +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc new file mode 100644 index 0000000000..6d75b5d990 --- /dev/null +++ b/mindspore/lite/src/ops/populate/tensorlistgetitem_populate.cc @@ -0,0 +1,41 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "src/ops/tensor_list.h" +#include "src/ops/primitive_c.h" +#include "src/ops/populate/populate_register.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore { +namespace lite { +OpParameter *PopulateTensorListGetItemParameter(const mindspore::lite::PrimitiveC *primitive) { + TensorListParameter *getItem_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (getItem_param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(getItem_param, 0, sizeof(TensorListParameter)); + getItem_param->op_parameter_.type_ = primitive->Type(); + auto getItem = + reinterpret_cast(const_cast(primitive)); + getItem_param->element_dtype_ = getItem->GetElementDType(); + return reinterpret_cast(getItem_param); +} +Registry TensorListGetItemParameterRegistry(schema::PrimitiveType_TensorListGetItem, + PopulateTensorListGetItemParameter); + +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc new file mode 100644 index 0000000000..6ffce6d8de --- /dev/null +++ b/mindspore/lite/src/ops/populate/tensorlistreserve_populate.cc @@ -0,0 +1,41 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "src/ops/tensor_list.h" +#include "src/ops/primitive_c.h" +#include "src/ops/populate/populate_register.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore { +namespace lite { +OpParameter *PopulateTensorListReserveParameter(const mindspore::lite::PrimitiveC *primitive) { + TensorListParameter *reserve_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (reserve_param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(reserve_param, 0, sizeof(TensorListParameter)); + reserve_param->op_parameter_.type_ = primitive->Type(); + auto reserve = + reinterpret_cast(const_cast(primitive)); + reserve_param->element_dtype_ = reserve->GetElementDType(); + return reinterpret_cast(reserve_param); +} +Registry TensorListReserveParameterRegistry(schema::PrimitiveType_TensorListReserve, + PopulateTensorListReserveParameter); + +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/populate/tensorliststack_populate.cc b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc new file mode 100644 index 0000000000..e0413e202d --- /dev/null +++ b/mindspore/lite/src/ops/populate/tensorliststack_populate.cc @@ -0,0 +1,41 @@ +/** + * Copyright 2019-2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "src/ops/tensor_list.h" +#include "src/ops/primitive_c.h" +#include "src/ops/populate/populate_register.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore { +namespace lite { +OpParameter *PopulateTensorListStackParameter(const mindspore::lite::PrimitiveC *primitive) { + TensorListParameter *stack_param = reinterpret_cast(malloc(sizeof(TensorListParameter))); + if (stack_param == nullptr) { + MS_LOG(ERROR) << "malloc TensorListParameter failed."; + return nullptr; + } + memset(stack_param, 0, sizeof(TensorListParameter)); + stack_param->op_parameter_.type_ = primitive->Type(); + auto stack = + reinterpret_cast(const_cast(primitive)); + stack_param->element_dtype_ = stack->GetElementDType(); + stack_param->num_element_ = stack->GetNumElements(); + return reinterpret_cast(stack_param); +} +Registry TensorListStackParameterRegistry(schema::PrimitiveType_TensorListStack, PopulateTensorListStackParameter); + +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/tensor_list.cc b/mindspore/lite/src/ops/tensor_list.cc new file mode 100644 index 0000000000..f7c5ba96b1 --- /dev/null +++ b/mindspore/lite/src/ops/tensor_list.cc @@ -0,0 +1,314 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "src/ops/tensor_list.h" + +#ifndef PRIMITIVE_WRITEABLE +#include "src/ops/ops_register.h" +#endif + +using mindspore::schema::Format_NC; + +namespace mindspore { +namespace lite { + +int TensorListFromTensor::InferShape(std::vector inputs_, std::vector outputs_) { + // inputs0:tensor + // inputs1: element_shape + // outputs0: vector.size() dtype + // outputs1: element_shape + // outputs2-n: vector + auto input = inputs_[0]; + MS_ASSERT(input != nullptr); + std::vector in_shape = input->shape(); + int dim0 = in_shape[0]; + if (dim0 <= 0) { + MS_LOG(ERROR) << "inputs_[0] dim0:" << dim0 << " must greater than 0"; + return RET_ERROR; + } + std::vector out_shape(in_shape.begin() + 1, in_shape.end()); + int out_vec_size = outputs_.size() - 2; + if (out_vec_size != dim0) { + MS_LOG(ERROR) << "outputs_.size() - 2:" << out_vec_size << "must be equal to dim0:" << dim0; + return RET_ERROR; + } + for (int i = 0; i < dim0; ++i) { + auto output = outputs_[i + 2]; + MS_ASSERT(output != nullptr); + output->set_data_type(input->data_type()); + output->set_shape(out_shape); + } + + auto output = outputs_[0]; // vector.size(), tensorlist.dtype + MS_ASSERT(output != nullptr); + output->set_data_type(kNumberTypeInt); + output->set_shape(std::vector(1, 2)); // one element.value = 2 + + output = outputs_[1]; // element_shape tensor + MS_ASSERT(output != nullptr); + output->set_data_type(inputs_[1]->data_type()); + output->set_format(inputs_[1]->format()); + output->set_shape(inputs_[1]->shape()); + + return RET_OK; +} + +bool TensorListGetItem::IsFullyDefined(const std::vector &shape) const { + for (size_t i = 0; i < shape.size(); ++i) { + if (shape[i] < 0) { + return false; + } + } + return true; +} + +int TensorListGetItem::InferShape(std::vector inputs_, std::vector outputs_) { + int in_vec_size = inputs_.size(); + auto input0 = inputs_[0]; + MS_ASSERT(input0 != nullptr); + auto in0_ptr = reinterpret_cast(input0->data_c()); + if (in_vec_size != in0_ptr[0] + 4) { + MS_LOG(ERROR) << "inputs_.size():" << in_vec_size << " must be equal to:" << in0_ptr[0] + 4; + return RET_ERROR; + } + auto get_index = inputs_[in0_ptr[0] + 2]; + MS_ASSERT(get_index != nullptr); + index_ = reinterpret_cast(get_index->data_c())[0]; + if (index_ < 0 || index_ > in0_ptr[0]) { + MS_LOG(ERROR) << "index_:" << index_ << "must in [0, " << in0_ptr[0] << "]"; + return RET_ERROR; + } + auto input_index = inputs_[index_ + 2]; + MS_ASSERT(input_index != nullptr); + auto output = outputs_.front(); + MS_ASSERT(output != nullptr); + if (input_index->data_type() != kTypeUnknown) { + output->set_format(input_index->format()); + output->set_data_type(input_index->data_type()); + output->set_shape(input_index->shape()); + } else { + auto ele_shape_tensor = inputs_[in0_ptr[0] + 3]; + MS_ASSERT(ele_shape_tensor != nullptr); + auto ele_shape_type = ele_shape_tensor->data_type(); + if (ele_shape_type != kNumberTypeInt) { + MS_LOG(ERROR) << "ele_shape_tensor.data_type():" << ele_shape_type + << " must be \"kNumberTypeInt\":" << kNumberTypeInt; + return RET_ERROR; + } + auto shape_ptr = reinterpret_cast(ele_shape_tensor->data_c()); + for (int i = 0; i < ele_shape_tensor->ElementsNum(); ++i) { + element_shape_.push_back(shape_ptr[i]); + } + if (!IsFullyDefined(element_shape_)) { + for (int i = 0; i < in0_ptr[0]; ++i) { + auto input = inputs_[i + 2]; + if (input->data_type() != kTypeUnknown) { + std::vector tmp = input->shape(); + for (size_t j = 0; j < tmp.size(); ++j) { + element_shape_[j] = element_shape_[j] >= 0 ? element_shape_[j] : tmp[j]; + } + } + } + } + if (!IsFullyDefined(element_shape_)) { + MS_LOG(ERROR) << "ele_shape_tensor Is Not FullyDefined!"; + return RET_ERROR; + } + element_dtype_ = GetElementDType(); + output->set_data_type(element_dtype_); + output->set_shape(element_shape_); + } + return RET_OK; +} +#ifdef PRIMITIVE_WRITEABLE +TypeId TensorListFromTensor::GetElementDType() const { + return (TypeId)(this->primitive_->value.AsTensorListFromTensor()->elementDType); +} + +TypeId TensorListFromTensor::GetShapeType() const { + return (TypeId)(this->primitive_->value.AsTensorListFromTensor()->shapeType); +} + +TypeId TensorListGetItem::GetElementDType() const { + return (TypeId)(this->primitive_->value.AsTensorListGetItem()->elementDType); +} +TypeId TensorListReserve::GetElementDType() const { + return (TypeId)(this->primitive_->value.AsTensorListReserve()->elementDType); +} + +TypeId TensorListStack::GetElementDType() const { + return (TypeId)(this->primitive_->value.AsTensorListStack()->elementDType); +} + +int TensorListStack::GetNumElements() const { return this->primitive_->value.AsTensorListStack()->numElements; } + +#else +TypeId TensorListFromTensor::GetElementDType() const { + return (TypeId)(this->primitive_->value_as_TensorListFromTensor()->elementDType()); +} + +TypeId TensorListFromTensor::GetShapeType() const { + return (TypeId)(this->primitive_->value_as_TensorListFromTensor()->shapeType()); +} + +TypeId TensorListGetItem::GetElementDType() const { + return (TypeId)(this->primitive_->value_as_TensorListGetItem()->elementDType()); +} +TypeId TensorListReserve::GetElementDType() const { + return (TypeId)(this->primitive_->value_as_TensorListReserve()->elementDType()); +} + +TypeId TensorListStack::GetElementDType() const { + return (TypeId)(this->primitive_->value_as_TensorListStack()->elementDType()); +} + +int TensorListStack::GetNumElements() const { return this->primitive_->value_as_TensorListStack()->numElements(); } +#endif + +int TensorListReserve::InferShape(std::vector inputs_, std::vector outputs_) { + // input0: element_shape_tensor + // input1: num_elements + auto input0 = inputs_.front(); + MS_ASSERT(input0 != nullptr); + auto ele_shape_type = input0->data_type(); + if (ele_shape_type != kNumberTypeInt) { + MS_LOG(ERROR) << "ele_shape_tensor.data_type():" << ele_shape_type + << " must be \"kNumberTypeInt\":" << kNumberTypeInt; + return RET_ERROR; + } + auto input1 = inputs_[1]; + MS_ASSERT(input1 != nullptr); + auto num_ele_type = input1->data_type(); + if (num_ele_type != kNumberTypeInt) { + MS_LOG(ERROR) << "num_ele_tensor.data_type():" << num_ele_type << " must be \"kNumberTypeInt\":" << kNumberTypeInt; + return RET_ERROR; + } + int num_elements = reinterpret_cast(input1->data_c())[0]; + auto out_vec_size = outputs_.size(); + if (out_vec_size != (size_t)(num_elements + 2)) { + MS_LOG(ERROR) << "outputs_.size():" << out_vec_size << " must be equal to:" << num_elements + 2; + return RET_ERROR; + } + + for (int i = 0; i < num_elements; ++i) { + auto output = outputs_[i + 2]; + MS_ASSERT(output != nullptr); + output->set_data_type(kTypeUnknown); + output->set_shape(std::vector(1, 0)); // shape = [0] + } + + auto output = outputs_[0]; // vector.size(), tensorlist.dtype + MS_ASSERT(output != nullptr); + output->set_data_type(kNumberTypeInt); + output->set_shape(std::vector(1, 2)); // one element.value = 2 + + output = outputs_[1]; // element_shape tensor + MS_ASSERT(output != nullptr); + output->set_data_type(input0->data_type()); + output->set_format(input0->format()); + output->set_shape(input0->shape()); + return RET_OK; +} + +bool TensorListStack::IsFullyDefined(const std::vector &shape) const { + for (size_t i = 0; i < shape.size(); ++i) { + if (shape[i] < 0) { + return false; + } + } + return true; +} + +int TensorListStack::InferShape(std::vector inputs_, std::vector outputs_) { + // input0: tensorlist + // input[inputs_.size() - 1]: element_shape + auto input0 = inputs_.front(); + MS_ASSERT(input0 != nullptr); + auto input0_ptr = reinterpret_cast(input0->data_c()); + int vec_in_size = inputs_.size(); + if (vec_in_size != input0_ptr[0] + 3) { + MS_LOG(ERROR) << "inputs_.size():" << vec_in_size << " must be equal:" << input0_ptr[0] + 3; + return RET_ERROR; + } + auto ele_shape = inputs_[input0_ptr[0] + 2]; // element shape + MS_ASSERT(ele_shape != nullptr); + auto ele_shape_ptr = reinterpret_cast(ele_shape->data_c()); + for (int i = 0; ele_shape->ElementsNum(); ++i) { + output_shape_.push_back(ele_shape_ptr[i]); + } + std::vector tensorlist_shape; + MS_ASSERT(inputs_[1] != nullptr); + auto input1_ptr = reinterpret_cast(inputs_[1]->data_c()); + for (int i = 0; i < inputs_[1]->ElementsNum(); ++i) { + tensorlist_shape.push_back(input1_ptr[i]); + } + auto status = MergeShape(tensorlist_shape); + if (status == RET_ERROR) { + MS_LOG(ERROR) << "Merge tensorlist_shape is error!"; + return RET_ERROR; + } + if (!IsFullyDefined(output_shape_)) { + MS_LOG(ERROR) << "element_shape Is Not FullyDefined!"; + return RET_ERROR; + } + if (!IsFullyDefined(tensorlist_shape)) { + for (int i = 0; i < input0_ptr[0]; ++i) { // get tensorlist every tensor + auto tensor_tmp = inputs_[i + 2]; + MS_ASSERT(tensor_tmp != nullptr); + if (tensor_tmp->data_type() != kTypeUnknown) { + status = MergeShape(tensor_tmp->shape()); + if (status == RET_ERROR) { + MS_LOG(ERROR) << "Merge inputs_[" << i + 2 << "] is error!"; + return RET_ERROR; + } + } + } + } + auto output = outputs_.front(); + MS_ASSERT(output != nullptr); + output->set_format(Format_NC); + output->set_data_type(static_cast(input0_ptr[1])); + output->set_shape(std::vector( + 1, input0_ptr[0] * std::accumulate(output_shape_.begin(), output_shape_.end(), 1LL, std::multiplies()))); + return RET_OK; +} + +int TensorListStack::MergeShape(const std::vector &shape) { + size_t dim0 = shape.size(); + size_t dim1 = output_shape_.size(); + if (dim1 >= unKnownRank_) { + output_shape_ = shape; + return RET_OK; + } + if (dim1 != dim0) { + MS_LOG(ERROR) << "shape.size():" << dim1 << " must be equal output_shape_.size():" << dim0; + return RET_ERROR; + } + for (size_t i = 0; i < dim0; ++i) { + int dim0_size = shape[i]; + int dim1_size = output_shape_[i]; + if (dim0_size >= 0 && dim1_size >= 0 && dim0_size != dim1_size) { + MS_LOG(ERROR) << "shape[" << i << "]:" << dim0_size << " is incompatible with output_shape_[" << i + << "]:" << dim1_size; + return RET_ERROR; + } + int tmp_size = dim1_size >= 0 ? dim1_size : dim0_size; + output_shape_[i] = tmp_size; + } + return RET_OK; +} +} // namespace lite +} // namespace mindspore diff --git a/mindspore/lite/src/ops/tensor_list.h b/mindspore/lite/src/ops/tensor_list.h new file mode 100644 index 0000000000..623df82a41 --- /dev/null +++ b/mindspore/lite/src/ops/tensor_list.h @@ -0,0 +1,75 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include +#include "src/ops/primitive_c.h" +#include "ir/dtype/type_id.h" + +using mindspore::schema::Format; +using mindspore::schema::Format_NC; + +#ifndef LITE_MINDSPORE_LITE_C_OPS_TENSORLISTFROMTENSOR_H_ +#define LITE_MINDSPORE_LITE_C_OPS_TENSORLISTFROMTENSOR_H_ +namespace mindspore { +namespace lite { + +class TensorListFromTensor : public PrimitiveC { + public: + TypeId GetElementDType() const; + TypeId GetShapeType() const; + TensorListFromTensor() = default; + bool IsCompatibleShape(std::vector inputs_); + int InferShape(std::vector inputs_, std::vector outputs_) override; +}; + +class TensorListReserve : public PrimitiveC { + public: + TensorListReserve() = default; + TypeId GetElementDType() const; + int InferShape(std::vector inputs_, std::vector outputs_) override; +}; + +class TensorListGetItem : public PrimitiveC { + public: + TensorListGetItem() = default; + TypeId GetElementDType() const; + bool IsFullyDefined(const std::vector &shape) const; + int InferShape(std::vector inputs_, std::vector outputs_) override; + + private: + int index_ = -1; + TypeId element_dtype_ = kTypeUnknown; + std::vector element_shape_; +}; + +class TensorListStack : public PrimitiveC { + public: + // tensor:input, element_dtype, num_elements(default=-1:reprent any tensor dim0), element_shape + TensorListStack() = default; + TypeId GetElementDType() const; + int GetNumElements() const; + bool IsFullyDefined(const std::vector &shape) const; + int MergeShape(const std::vector &shape); + int InferShape(std::vector inputs_, std::vector outputs_) override; + + private: + size_t unKnownRank_ = 255; + std::vector output_shape_; +}; +} // namespace lite +} // namespace mindspore + +#endif // LITE_MINDSPORE_LITE_C_OPS_TENSORLISTFROMTENSOR_H_ diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.cc new file mode 100644 index 0000000000..4efb19cc7c --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.cc @@ -0,0 +1,124 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "include/errorcode.h" +#include "src/kernel_registry.h" +#include "src/runtime/kernel/arm/fp32/TensorListFromTensor.h" +#include "src/runtime/runtime_api.h" + +using mindspore::kernel::KERNEL_ARCH::kCPU; +using mindspore::lite::KernelRegistrar; +using mindspore::lite::RET_ERROR; +using mindspore::lite::RET_NULL_PTR; +using mindspore::lite::RET_OK; +using mindspore::schema::PrimitiveType_TensorListFromTensor; + +namespace mindspore::kernel { + +bool TensorListFromTensorCPUKernel::IsCompatibleShape() { + if (input1_->data_type() != kNumberTypeInt) { // element_shape + MS_LOG(ERROR) << "in_tensors_[1] data type is must be \"kNumberTypeInt\", but now is:" << input1_->data_type(); + return false; + } + int in1_ele_num = input1_->ElementsNum(); + std::vector tensor_shape = input0_->shape(); + if (static_cast(tensor_shape.size() - 1) != in1_ele_num) { + MS_LOG(ERROR) << "in_tensors_[0].shape() - 1:" << tensor_shape.size() - 1 + << " must be equal in_tensors_[1].ElementsNum():" << in1_ele_num; + return false; + } + int *elements_shape = reinterpret_cast(input1_->data_c()); // element shape in tensor data + for (int i = 0; i < in1_ele_num; ++i) { + const int dim0 = tensor_shape[i + 1]; + const int dim1 = *(elements_shape + i); + if (dim0 >= 0 && dim1 >= 0 && dim0 != dim1) { + MS_LOG(ERROR) << "input0_->shape()[" << i + 1 << "]:" << dim0 << " is not equal input1_->data_c()[" << i + << "]:" << dim1; + return false; + } + } + return true; +} + +int TensorListFromTensorCPUKernel::Init() { + input0_ = in_tensors_[0]; // row tensor + input1_ = in_tensors_[1]; // element_shape tensor + output0_ = out_tensors_[0]; + output1_ = out_tensors_[1]; + return IsCompatibleShape(); +} + +int TensorListFromTensorCPUKernel::ReSize() { return RET_OK; } + +int TensorListFromTensorCPUKernel::Run() { + int dim0 = input0_->shape()[0]; + size_t devision_dim0 = input0_->ElementsNum() / dim0; + auto out0_ptr = reinterpret_cast(output0_->MutableData()); + *out0_ptr = dim0; + *(out0_ptr + 1) = input0_->data_type(); + auto status = output1_->CopyTensorData(*input1_); + if (status == RET_ERROR) { + MS_LOG(ERROR) << "copy tensor data failed!"; + return RET_ERROR; + } + if (dim0 != static_cast(out_tensors_.size() - 2)) { + MS_LOG(ERROR) << "out_tensors_.size() - 2:[" << out_tensors_.size() - 2 + << "] must be equal in_tensors_[0].shape()[0]:[" << dim0 << "]"; + return RET_ERROR; + } + auto in_ptr = reinterpret_cast(input0_); + size_t index = 0; + for (int i = 0; i < dim0; ++i) { + auto out_ptr = reinterpret_cast(out_tensors_[i + 2]->MutableData()); + memcpy(out_ptr, in_ptr + index, devision_dim0 * sizeof(float)); + index += devision_dim0; + } + return RET_OK; +} + +kernel::LiteKernel *CpuTensorListFromTensorFp32KernelCreator(const std::vector &inputs, + const std::vector &outputs, + OpParameter *op_parameter, const lite::InnerContext *ctx, + const kernel::KernelKey &desc, + const mindspore::lite::PrimitiveC *primitive) { + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Input op_parameter is nullptr!"; + return nullptr; + } + if (ctx == nullptr) { + MS_LOG(ERROR) << "Input context is nullptr!"; + free(op_parameter); + return nullptr; + } + MS_ASSERT(desc.type == schema::PrimitiveType_TensorListFromTensor); + op_parameter->thread_num_ = ctx->thread_num_; + auto *kernel = new (std::nothrow) TensorListFromTensorCPUKernel(op_parameter, inputs, outputs, ctx, primitive); + if (kernel == nullptr) { + MS_LOG(ERROR) << "new TensorListFromTensorCPUKernel fail!"; + free(op_parameter); + return nullptr; + } + auto ret = kernel->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: " + << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); + delete kernel; + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListFromTensor, CpuTensorListFromTensorFp32KernelCreator) +} // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.h b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.h new file mode 100644 index 0000000000..dcd1c6f68a --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListFromTensor.h @@ -0,0 +1,54 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTFROMTENSOR_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTFROMTENSOR_H_ + +#include +#include "src/lite_kernel.h" +#include "schema/model_generated.h" + +namespace mindspore::kernel { +class TensorListFromTensorCPUKernel : public LiteKernel { + public: + /* + * input0:tensor + * input1:element_shape + * output0:tensorlist.size() and dty pe + * output2~n:tensor + * output1:element_shape(tensorlist shape) + */ + TensorListFromTensorCPUKernel(OpParameter *parameter, const std::vector &inputs, + const std::vector &outputs, const lite::InnerContext *ctx, + const mindspore::lite::PrimitiveC *primitive) + : LiteKernel(parameter, inputs, outputs, ctx, primitive) {} + ~TensorListFromTensorCPUKernel() = default; + + int Init() override; + int ReSize() override; + int Run() override; + bool IsCompatibleShape(); + + private: + std::vector output_shape_; + lite::Tensor *output0_ = nullptr; + lite::Tensor *output1_ = nullptr; + lite::Tensor *input0_ = nullptr; + lite::Tensor *input1_ = nullptr; +}; +} // namespace mindspore::kernel + +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTFROMTENSOR_H_ diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.cc new file mode 100644 index 0000000000..cca1a46566 --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.cc @@ -0,0 +1,101 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include "include/errorcode.h" +#include "include/ms_tensor.h" +#include "src/kernel_registry.h" +#include "src/runtime/kernel/arm/fp32/TensorListGetItem.h" +#include "src/runtime/runtime_api.h" + +using mindspore::kernel::KERNEL_ARCH::kCPU; +using mindspore::lite::KernelRegistrar; +using mindspore::lite::RET_ERROR; +using mindspore::lite::RET_NULL_PTR; +using mindspore::lite::RET_OK; +using mindspore::schema::PrimitiveType_TensorListGetItem; + +namespace mindspore::kernel { + +int TensorListGetItemCPUKernel::Init() { + auto input0 = reinterpret_cast(in_tensors_[0]->data_c()); + size_t dim0 = *input0; + int in_dtype = *(input0 + 1); + if (dtype_ != in_dtype) { + MS_LOG(ERROR) << "op dtype:" << dtype_ << " is not equal in_tensors dtype:" << in_dtype; + return RET_ERROR; + } + index_ = *(reinterpret_cast(in_tensors_[dim0 + 2]->data_c())); + if (index_ < 0) { + MS_LOG(ERROR) << "index tensor:[" << index_ << "] must be greater than or equal to 0"; + return RET_ERROR; + } + if (index_ > dim0) { + MS_LOG(ERROR) << "index tensor:[" << index_ << "] must be less than dim0:" << dim0; + return RET_ERROR; + } + index_ += 2; + return RET_OK; +} + +int TensorListGetItemCPUKernel::Run() { + if (in_tensors_[index_]->data_type() != kTypeUnknown) { + auto status = out_tensors_[0]->CopyTensorData(*in_tensors_[index_]); // tensorlist shape + if (status == RET_ERROR) { + MS_LOG(ERROR) << "copy tensor data failed!"; + return RET_ERROR; + } + } else { + // reset 0 and dtype = dtype_ + auto out_ptr = reinterpret_cast(out_tensors_[0]->MutableData()); + memset(out_ptr, 0, lite::DataTypeSize(dtype_) * out_tensors_[0]->ElementsNum()); + } + return RET_OK; +} + +int TensorListGetItemCPUKernel::ReSize() { return RET_OK; } + +kernel::LiteKernel *CpuTensorListGetItemFp32KernelCreator(const std::vector &inputs, + const std::vector &outputs, + OpParameter *op_parameter, const lite::InnerContext *ctx, + const kernel::KernelKey &desc, + const mindspore::lite::PrimitiveC *primitive) { + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Input op_parameter is nullptr!"; + return nullptr; + } + if (ctx == nullptr) { + MS_LOG(ERROR) << "Input context is nullptr!"; + free(op_parameter); + return nullptr; + } + MS_ASSERT(desc.type == schema::PrimitiveType_TensorListGetItem); + auto *kernel = new (std::nothrow) TensorListGetItemCPUKernel(op_parameter, inputs, outputs, ctx, primitive); + if (kernel == nullptr) { + MS_LOG(ERROR) << "new TensorListGetItemCPUKernel fail!"; + free(op_parameter); + return nullptr; + } + auto ret = kernel->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: " + << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); + delete kernel; + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListGetItem, CpuTensorListGetItemFp32KernelCreator) +} // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.h b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.h new file mode 100644 index 0000000000..976a9359b5 --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListGetItem.h @@ -0,0 +1,45 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTGETITEM_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTGETITEM_H_ + +#include +#include "src/lite_kernel.h" +#include "schema/model_generated.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore::kernel { +class TensorListGetItemCPUKernel : public LiteKernel { + public: + TensorListGetItemCPUKernel(OpParameter *parameter, const std::vector &inputs, + const std::vector &outputs, const lite::InnerContext *ctx, + const mindspore::lite::PrimitiveC *primitive) + : LiteKernel(parameter, inputs, outputs, ctx, primitive), + dtype_(reinterpret_cast(parameter)->element_dtype_) {} + ~TensorListGetItemCPUKernel() = default; + + int Init() override; + int ReSize() override; + int Run() override; + + private: + size_t index_ = 0; + TypeId dtype_ = kTypeUnknown; +}; +} // namespace mindspore::kernel + +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTGETITEM_H_ diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.cc new file mode 100644 index 0000000000..dee63f9c11 --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.cc @@ -0,0 +1,82 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "include/errorcode.h" +#include "src/kernel_registry.h" +#include "src/runtime/kernel/arm/fp32/TensorListReserve.h" + +using mindspore::kernel::KERNEL_ARCH::kCPU; +using mindspore::lite::KernelRegistrar; +using mindspore::lite::RET_ERROR; +using mindspore::lite::RET_NULL_PTR; +using mindspore::lite::RET_OK; +using mindspore::schema::PrimitiveType_TensorListReserve; + +namespace mindspore::kernel { + +int TensorListReserveCPUKernel::Init() { return RET_OK; } + +int TensorListReserveCPUKernel::Run() { + auto out0_ptr = reinterpret_cast(out_tensors_[0]->MutableData()); // tensorlist size() and dtype + out0_ptr[0] = reinterpret_cast(in_tensors_[0]->data_c())[0]; // num_elements + out0_ptr[1] = element_dtype_; + auto status = out_tensors_[1]->CopyTensorData(*in_tensors_[1]); // elements_shape + if (status == RET_ERROR) { + MS_LOG(ERROR) << "copy tensor data failed!"; + return RET_ERROR; + } + if (static_cast(out_tensors_.size() - 2) != out0_ptr[0]) { + MS_LOG(ERROR) << "out_tensors_.size() - 2:" << out_tensors_.size() - 2 + << " must be equal num_elements:" << out0_ptr[0]; + } + return RET_OK; +} + +int TensorListReserveCPUKernel::ReSize() { return RET_OK; } + +kernel::LiteKernel *CpuTensorListReserveFp32KernelCreator(const std::vector &inputs, + const std::vector &outputs, + OpParameter *op_parameter, const lite::InnerContext *ctx, + const kernel::KernelKey &desc, + const mindspore::lite::PrimitiveC *primitive) { + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Input op_parameter is nullptr!"; + return nullptr; + } + if (ctx == nullptr) { + MS_LOG(ERROR) << "Input context is nullptr!"; + free(op_parameter); + return nullptr; + } + MS_ASSERT(desc.type == schema::PrimitiveType_TensorListSetItem); + auto *kernel = new (std::nothrow) TensorListReserveCPUKernel(op_parameter, inputs, outputs, ctx, primitive); + if (kernel == nullptr) { + MS_LOG(ERROR) << "new TensorListReserveCPUKernel fail!"; + free(op_parameter); + return nullptr; + } + auto ret = kernel->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: " + << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); + delete kernel; + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListReserve, CpuTensorListReserveFp32KernelCreator) +} // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.h b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.h new file mode 100644 index 0000000000..a501290288 --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListReserve.h @@ -0,0 +1,44 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTRESERVE_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTRESERVE_H_ + +#include +#include "src/lite_kernel.h" +#include "schema/model_generated.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore::kernel { +class TensorListReserveCPUKernel : public LiteKernel { + public: + TensorListReserveCPUKernel(OpParameter *parameter, const std::vector &inputs, + const std::vector &outputs, const lite::InnerContext *ctx, + const mindspore::lite::PrimitiveC *primitive) + : LiteKernel(parameter, inputs, outputs, ctx, primitive), + element_dtype_(reinterpret_cast(parameter)->element_dtype_) {} + ~TensorListReserveCPUKernel() = default; + + int Init() override; + int ReSize() override; + int Run() override; + + private: + int element_dtype_ = 0; +}; +} // namespace mindspore::kernel + +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTRESERVE_H_ diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.cc b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.cc new file mode 100644 index 0000000000..c5c6c35f37 --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.cc @@ -0,0 +1,122 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include +#include "include/errorcode.h" +#include "ir/dtype/type_id.h" +#include "src/kernel_registry.h" +#include "src/runtime/kernel/arm/fp32/TensorListStack.h" + +using mindspore::kernel::KERNEL_ARCH::kCPU; +using mindspore::lite::KernelRegistrar; +using mindspore::lite::RET_ERROR; +using mindspore::lite::RET_NULL_PTR; +using mindspore::lite::RET_OK; +using mindspore::schema::PrimitiveType_TensorListStack; + +namespace mindspore::kernel { + +int TensorListStackCPUKernel::CheckParam() { + auto in0_dtype = in_tensors_[0]->data_type(); + if (in0_dtype != kNumberTypeInt) { + MS_LOG(ERROR) << "in_tensors_[0]->data_type():" << in0_dtype + << " must be equal \"kNumberTypeInt\":" << kNumberTypeInt; + } + auto in0_ptr = reinterpret_cast(in_tensors_[0]->data_c()); + if (in0_ptr[1] != dtype_) { + MS_LOG(ERROR) << "in_tensors_[0].data_type:[" << in0_ptr[1] << "] must be equal " + << "param.data_type:[" << dtype_ << "]"; + return RET_ERROR; + } + if (num_element_ != -1 && in0_ptr[0] != num_element_) { + MS_LOG(ERROR) << "in_tensors_[0].dim0:[" << in0_ptr[0] << "] must be equal " + << "param.elements_num:[" << num_element_ << "]"; + return RET_ERROR; + } + num_element_ = in0_ptr[0]; + return RET_OK; +} + +int TensorListStackCPUKernel::Init() { + output0_ = out_tensors_[0]; + if (output0_->format() != schema::Format_NC) { // shape().size() = 2 + MS_LOG(ERROR) << "out_tensor_[0] format must be \"Format:NC\", but now is:" << output0_->format(); + return RET_ERROR; + } + int dim0 = output0_->shape()[0]; + if (dim0 != 1) { // dim0 must be 1 + MS_LOG(ERROR) << "out_tensor_[0] dim0 must be 1, but now is:" << dim0; + return RET_ERROR; + } + return CheckParam(); +} + +int TensorListStackCPUKernel::Run() { + size_t in_ele_num = 0; + for (int i = 0; i < num_element_; ++i) { + in_ele_num += in_tensors_[i + 2]->ElementsNum(); + } + size_t out_ele_num = out_tensors_[0]->ElementsNum(); + if (in_ele_num > out_ele_num) { + MS_LOG(ERROR) << "out_tensors_[0]->ElementsNum():" << out_ele_num << "must greater than or equal to in_ele_num" + << in_ele_num; + return RET_ERROR; + } + size_t index = 0; + auto out_ptr = reinterpret_cast(out_tensors_[0]->MutableData()); + for (int i = 0; i < num_element_; ++i) { + auto in_ptr = reinterpret_cast(in_tensors_[i + 2]->data_c()); + size_t in_size = in_tensors_[i + 2]->ElementsNum(); + memcpy(out_ptr + index, in_ptr, in_size * sizeof(float)); + index += in_size; + } + return RET_OK; +} + +int TensorListStackCPUKernel::ReSize() { return RET_OK; } + +kernel::LiteKernel *CpuTensorListStackFp32KernelCreator(const std::vector &inputs, + const std::vector &outputs, + OpParameter *op_parameter, const lite::InnerContext *ctx, + const kernel::KernelKey &desc, + const mindspore::lite::PrimitiveC *primitive) { + if (op_parameter == nullptr) { + MS_LOG(ERROR) << "Input op_parameter is nullptr!"; + return nullptr; + } + if (ctx == nullptr) { + MS_LOG(ERROR) << "Input context is nullptr!"; + free(op_parameter); + return nullptr; + } + MS_ASSERT(desc.type == schema::PrimitiveType_TensorListStack); + auto *kernel = new (std::nothrow) TensorListStackCPUKernel(op_parameter, inputs, outputs, ctx, primitive); + if (kernel == nullptr) { + MS_LOG(ERROR) << "new TensorListStackCPUKernel fail!"; + free(op_parameter); + return nullptr; + } + auto ret = kernel->Init(); + if (ret != RET_OK) { + MS_LOG(ERROR) << "Init kernel failed! name: " << op_parameter->name_ << ", type: " + << schema::EnumNamePrimitiveType(static_cast(op_parameter->type_)); + delete kernel; + return nullptr; + } + return kernel; +} + +REG_KERNEL(kCPU, kNumberTypeFloat32, PrimitiveType_TensorListStack, CpuTensorListStackFp32KernelCreator) +} // namespace mindspore::kernel diff --git a/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.h b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.h new file mode 100644 index 0000000000..09da76ea6e --- /dev/null +++ b/mindspore/lite/src/runtime/kernel/arm/fp32/TensorListStack.h @@ -0,0 +1,48 @@ +/** + * Copyright 2020 Huawei Technologies Co., Ltd + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTSTACK_H_ +#define MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTSTACK_H_ + +#include +#include "src/lite_kernel.h" +#include "schema/model_generated.h" +#include "nnacl/tensorlist_parameter.h" + +namespace mindspore::kernel { +class TensorListStackCPUKernel : public LiteKernel { + public: + TensorListStackCPUKernel(OpParameter *parameter, const std::vector &inputs, + const std::vector &outputs, const lite::InnerContext *ctx, + const mindspore::lite::PrimitiveC *primitive) + : LiteKernel(parameter, inputs, outputs, ctx, primitive), + num_element_(reinterpret_cast(parameter)->num_element_), + dtype_(reinterpret_cast(parameter)->element_dtype_) {} + ~TensorListStackCPUKernel() = default; + + int Init() override; + int ReSize() override; + int Run() override; + int CheckParam(); + + private: + int num_element_ = -1; + TypeId dtype_ = kTypeUnknown; + lite::Tensor *output0_ = nullptr; +}; +} // namespace mindspore::kernel + +#endif // MINDSPORE_LITE_SRC_RUNTIME_KERNEL_ARM_FP32_TENSORLISTSTACK_H_