Huawei_Technology
/
MindSpore-Serving
Not watched
1
0
Fork 0
Code
Releases 3 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: ca0bb64cd0
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ca0bb64cd0'
${ noResults }
MindSpore-Serving/mindspore_serving/client/cpp/client.cc

470 lines
18 kB
Raw Blame History 

  1. /**

  2.  * Copyright 2020 Huawei Technologies Co., Ltd

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  * http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. 

  17. #include "client/cpp/client.h"

  18. #include <grpcpp/grpcpp.h>

  19. #include <google/protobuf/text_format.h>

  20. #include <algorithm>

  21. #include <unordered_map>

  22. #include <utility>

  23. #include <sstream>

  24. #include "proto/ms_service.pb.h"

  25. #include "proto/ms_service.grpc.pb.h"

  26. 

  27. namespace mindspore {

  28. namespace serving {

  29. namespace client {

  30. 

  31. Status &Status::operator<<(DataType val) {

  32.   std::unordered_map<DataType, std::string> data_type_map = {

  33.     {DT_UINT8, "uint8"},   {DT_UINT16, "uint16"},   {DT_UINT32, "uint32"},   {DT_UINT64, "uint64"},

  34.     {DT_INT8, "int8"},     {DT_INT16, "int16"},     {DT_INT32, "int32"},     {DT_INT64, "int64"},

  35.     {DT_BOOL, "bool"},     {DT_FLOAT16, "float16"}, {DT_FLOAT32, "float32"}, {DT_FLOAT64, "float64"},

  36.     {DT_STRING, "string"}, {DT_BYTES, "bytes"},     {DT_UNKNOWN, "unknown"},

  37.   };

  38.   auto it = data_type_map.find(val);

  39.   if (it == data_type_map.end()) {

  40.     status_msg_ += "unknown";

  41.   } else {

  42.     status_msg_ += it->second;

  43.   }

  44.   return *this;

  45. }

  46. 

  47. Status &operator<<(Status &status, proto::DataType val) {

  48.   std::unordered_map<proto::DataType, std::string> data_type_map = {

  49.     {proto::MS_UINT8, "uint8"},     {proto::MS_UINT16, "uint16"},   {proto::MS_UINT32, "uint32"},

  50.     {proto::MS_UINT64, "uint64"},   {proto::MS_INT8, "int8"},       {proto::MS_INT16, "int16"},

  51.     {proto::MS_INT32, "int32"},     {proto::MS_INT64, "int64"},     {proto::MS_BOOL, "bool"},

  52.     {proto::MS_FLOAT16, "float16"}, {proto::MS_FLOAT32, "float32"}, {proto::MS_FLOAT64, "float64"},

  53.     {proto::MS_STRING, "string"},   {proto::MS_BYTES, "bytes"},     {proto::MS_UNKNOWN, "unknown"},

  54.   };

  55.   auto it = data_type_map.find(val);

  56.   if (it == data_type_map.end()) {

  57.     status << "unknown";

  58.   } else {

  59.     status << it->second;

  60.   }

  61.   return status;

  62. }

  63. 

  64. Status &operator<<(Status &status, grpc::StatusCode val) {

  65.   std::unordered_map<grpc::StatusCode, std::string> data_type_map = {

  66.     {grpc::OK, "OK"},

  67.     {grpc::CANCELLED, "CANCELLED"},

  68.     {grpc::UNKNOWN, "UNKNOWN"},

  69.     {grpc::INVALID_ARGUMENT, "INVALID_ARGUMENT"},

  70.     {grpc::DEADLINE_EXCEEDED, "DEADLINE_EXCEEDED"},

  71.     {grpc::NOT_FOUND, "NOT_FOUND"},

  72.     {grpc::ALREADY_EXISTS, "ALREADY_EXISTS"},

  73.     {grpc::PERMISSION_DENIED, "PERMISSION_DENIED"},

  74.     {grpc::UNAUTHENTICATED, "UNAUTHENTICATED"},

  75.     {grpc::RESOURCE_EXHAUSTED, "RESOURCE_EXHAUSTED"},

  76.     {grpc::FAILED_PRECONDITION, "FAILED_PRECONDITION"},

  77.     {grpc::ABORTED, "ABORTED"},

  78.     {grpc::OUT_OF_RANGE, "OUT_OF_RANGE"},

  79.     {grpc::UNIMPLEMENTED, "UNIMPLEMENTED"},

  80.     {grpc::INTERNAL, "INTERNAL"},

  81.     {grpc::UNAVAILABLE, "UNAVAILABLE"},

  82.     {grpc::DATA_LOSS, "DATA_LOSS"},

  83.   };

  84.   auto it = data_type_map.find(val);

  85.   if (it == data_type_map.end()) {

  86.     status << "unknown";

  87.   } else {

  88.     status << it->second;

  89.   }

  90.   return status;

  91. }

  92. 

  93. Status MutableTensor::SetBytesData(const std::vector<uint8_t> &val) {

  94.   if (mutable_proto_tensor_ == nullptr) {

  95.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  96.   }

  97.   auto proto_shape = mutable_proto_tensor_->mutable_shape();

  98.   proto_shape->add_dims(1);

  99.   mutable_proto_tensor_->set_dtype(proto::MS_BYTES);

  100.   if (val.empty()) {

  101.     return Status(INVALID_INPUTS) << "Input index bytes val len is empty";

  102.   }

  103.   mutable_proto_tensor_->add_bytes_val(val.data(), val.size());

  104.   return SUCCESS;

  105. }

  106. 

  107. Status MutableTensor::SetStrData(const std::string &val) {

  108.   if (mutable_proto_tensor_ == nullptr) {

  109.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  110.   }

  111.   auto proto_shape = mutable_proto_tensor_->mutable_shape();

  112.   proto_shape->add_dims(val.size());

  113.   mutable_proto_tensor_->set_dtype(proto::MS_STRING);

  114.   if (val.empty()) {

  115.     return Status(INVALID_INPUTS) << "string index string val len is empty";

  116.   }

  117.   mutable_proto_tensor_->add_bytes_val(val);

  118.   return SUCCESS;

  119. }

  120. 

  121. Status MutableTensor::SetData(const std::vector<uint8_t> &val, const std::vector<int64_t> &shape) {

  122.   return SetData(val.data(), val.size() * sizeof(uint8_t), shape, DT_UINT8);

  123. }

  124. 

  125. Status MutableTensor::SetData(const std::vector<uint16_t> &val, const std::vector<int64_t> &shape) {

  126.   return SetData(val.data(), val.size() * sizeof(uint16_t), shape, DT_UINT16);

  127. }

  128. 

  129. Status MutableTensor::SetData(const std::vector<uint32_t> &val, const std::vector<int64_t> &shape) {

  130.   return SetData(val.data(), val.size() * sizeof(uint32_t), shape, DT_UINT32);

  131. }

  132. 

  133. Status MutableTensor::SetData(const std::vector<uint64_t> &val, const std::vector<int64_t> &shape) {

  134.   return SetData(val.data(), val.size() * sizeof(uint64_t), shape, DT_UINT64);

  135. }

  136. 

  137. Status MutableTensor::SetData(const std::vector<int8_t> &val, const std::vector<int64_t> &shape) {

  138.   return SetData(val.data(), val.size() * sizeof(int8_t), shape, DT_INT8);

  139. }

  140. 

  141. Status MutableTensor::SetData(const std::vector<int16_t> &val, const std::vector<int64_t> &shape) {

  142.   return SetData(val.data(), val.size() * sizeof(int16_t), shape, DT_INT16);

  143. }

  144. 

  145. Status MutableTensor::SetData(const std::vector<int32_t> &val, const std::vector<int64_t> &shape) {

  146.   return SetData(val.data(), val.size() * sizeof(int32_t), shape, DT_INT32);

  147. }

  148. 

  149. Status MutableTensor::SetData(const std::vector<int64_t> &val, const std::vector<int64_t> &shape) {

  150.   return SetData(val.data(), val.size() * sizeof(int64_t), shape, DT_INT64);

  151. }

  152. 

  153. Status MutableTensor::SetData(const std::vector<bool> &val, const std::vector<int64_t> &shape) {

  154.   std::vector<uint8_t> val_uint8;

  155.   std::transform(val.begin(), val.end(), std::back_inserter(val_uint8),

  156.                  [](bool item) { return static_cast<uint8_t>(item); });

  157.   return SetData(val_uint8.data(), val_uint8.size() * sizeof(bool), shape, DT_BOOL);

  158. }

  159. 

  160. Status MutableTensor::SetData(const std::vector<float> &val, const std::vector<int64_t> &shape) {

  161.   return SetData(val.data(), val.size() * sizeof(float), shape, DT_FLOAT32);

  162. }

  163. 

  164. Status MutableTensor::SetData(const std::vector<double> &val, const std::vector<int64_t> &shape) {

  165.   return SetData(val.data(), val.size() * sizeof(double), shape, DT_FLOAT64);

  166. }

  167. 

  168. Status MutableTensor::SetData(const void *data, size_t data_len, const std::vector<int64_t> &shape,

  169.                               DataType data_type) {

  170.   if (mutable_proto_tensor_ == nullptr) {

  171.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  172.   }

  173.   if (data == nullptr || data_len == 0) {

  174.     return Status(INVALID_INPUTS) << "data cannot be nullptr, or data len cannot be 0";

  175.   }

  176.   mutable_proto_tensor_->set_data(data, data_len);

  177.   auto proto_shape = mutable_proto_tensor_->mutable_shape();

  178. 

  179.   std::unordered_map<DataType, std::pair<proto::DataType, int64_t>> data_type_map = {

  180.     {DT_UINT8, {proto::MS_UINT8, sizeof(uint8_t)}},

  181.     {DT_UINT16, {proto::MS_UINT16, sizeof(uint16_t)}},

  182.     {DT_UINT32, {proto::MS_UINT32, sizeof(uint32_t)}},

  183.     {DT_UINT64, {proto::MS_UINT64, sizeof(uint64_t)}},

  184.     {DT_INT8, {proto::MS_INT8, sizeof(int8_t)}},

  185.     {DT_INT16, {proto::MS_INT16, sizeof(int16_t)}},

  186.     {DT_INT32, {proto::MS_INT32, sizeof(int32_t)}},

  187.     {DT_INT64, {proto::MS_INT64, sizeof(int64_t)}},

  188.     {DT_BOOL, {proto::MS_BOOL, sizeof(bool)}},

  189.     {DT_FLOAT16, {proto::MS_FLOAT16, 2}},

  190.     {DT_FLOAT32, {proto::MS_FLOAT32, 4}},

  191.     {DT_FLOAT64, {proto::MS_FLOAT64, 8}},

  192.   };

  193.   auto it = data_type_map.find(data_type);

  194.   if (it == data_type_map.end()) {

  195.     return Status(INVALID_INPUTS) << "Input unsupported find data type " << data_type;

  196.   }

  197.   mutable_proto_tensor_->set_dtype(it->second.first);

  198. 

  199.   auto shape_str = [](const std::vector<int64_t> &val) noexcept {

  200.     std::stringstream sstream;

  201.     sstream << "[";

  202.     for (size_t i = 0; i < val.size(); i++) {

  203.       sstream << val[i];

  204.       if (i + 1 < val.size()) {

  205.         sstream << ", ";

  206.       }

  207.     }

  208.     sstream << "]";

  209.     return sstream.str();

  210.   };

  211.   int64_t element_cnt = 1;

  212.   for (auto &item : shape) {

  213.     proto_shape->add_dims(item);

  214.     if (item <= 0 || item >= INT64_MAX || INT64_MAX / element_cnt < item) {

  215.       return Status(INVALID_INPUTS) << "Input input shape invalid " << shape_str(shape);

  216.     }

  217.   }

  218.   auto item_size = it->second.second;

  219.   if (static_cast<int64_t>(data_len) / element_cnt < item_size ||

  220.       element_cnt * item_size != static_cast<int64_t>(data_len)) {

  221.     return Status(INVALID_INPUTS) << "Input input shape " << shape_str(shape) << " does not match data len "

  222.                                   << data_len;

  223.   }

  224.   return SUCCESS;

  225. }

  226. 

  227. Status Tensor::GetBytesData(std::vector<uint8_t> *val) const {

  228.   if (val == nullptr) {

  229.     return Status(SYSTEM_ERROR) << "input val cannot be nullptr";

  230.   }

  231.   if (proto_tensor_ == nullptr) {

  232.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  233.   }

  234.   if (proto_tensor_->dtype() != proto::MS_BYTES) {

  235.     return Status(INVALID_INPUTS) << "Output data type is not match, its' real data type is " << proto_tensor_->dtype();

  236.   }

  237.   auto &bytes_data = proto_tensor_->bytes_val();

  238.   if (bytes_data.size() != 1) {

  239.     return Status(INVALID_INPUTS) << "Bytes value type size can only be 1";

  240.   }

  241.   val->resize(bytes_data[0].size());

  242.   memcpy(val->data(), val->data(), bytes_data[0].size());

  243.   return SUCCESS;

  244. }

  245. 

  246. Status Tensor::GetStrData(std::string *val) const {

  247.   if (val == nullptr) {

  248.     return Status(SYSTEM_ERROR) << "input val cannot be nullptr";

  249.   }

  250.   if (proto_tensor_ == nullptr) {

  251.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  252.   }

  253.   if (proto_tensor_->dtype() != proto::MS_STRING) {

  254.     return Status(INVALID_INPUTS) << "Output data type is not match, its' real data type is " << proto_tensor_->dtype();

  255.   }

  256.   auto &bytes_data = proto_tensor_->bytes_val();

  257.   if (bytes_data.size() != 1) {

  258.     return Status(INVALID_INPUTS) << "Bytes value type size can only be 1";

  259.   }

  260.   val->resize(bytes_data[0].size());

  261.   memcpy(val->data(), val->data(), bytes_data[0].size());

  262.   return SUCCESS;

  263. }

  264. 

  265. template <proto::DataType proto_dtype, class DT>

  266. Status GetInputImp(const proto::Tensor *proto_tensor, std::vector<DT> *val) {

  267.   if (val == nullptr) {

  268.     return Status(SYSTEM_ERROR) << "input val cannot be nullptr";

  269.   }

  270.   if (proto_tensor == nullptr) {

  271.     return Status(SYSTEM_ERROR) << "proto tensor cannot be nullptr";

  272.   }

  273.   if (proto_tensor->dtype() != proto_dtype) {

  274.     return Status(INVALID_INPUTS) << "Output data type is not match, its' real data type is " << proto_tensor->dtype();

  275.   }

  276.   auto data = proto_tensor->data().data();

  277.   auto data_len = proto_tensor->data().length();

  278.   val->resize(data_len / sizeof(DT));

  279.   memcpy(val->data(), data, data_len);

  280.   return SUCCESS;

  281. }

  282. 

  283. Status Tensor::GetData(std::vector<uint8_t> *val) const { return GetInputImp<proto::MS_UINT8>(proto_tensor_, val); }

  284. 

  285. Status Tensor::GetData(std::vector<uint16_t> *val) const { return GetInputImp<proto::MS_UINT16>(proto_tensor_, val); }

  286. 

  287. Status Tensor::GetData(std::vector<uint32_t> *val) const { return GetInputImp<proto::MS_UINT32>(proto_tensor_, val); }

  288. 

  289. Status Tensor::GetData(std::vector<uint64_t> *val) const { return GetInputImp<proto::MS_UINT64>(proto_tensor_, val); }

  290. 

  291. Status Tensor::GetData(std::vector<int8_t> *val) const { return GetInputImp<proto::MS_INT8>(proto_tensor_, val); }

  292. 

  293. Status Tensor::GetData(std::vector<int16_t> *val) const { return GetInputImp<proto::MS_INT16>(proto_tensor_, val); }

  294. 

  295. Status Tensor::GetData(std::vector<int32_t> *val) const { return GetInputImp<proto::MS_INT32>(proto_tensor_, val); }

  296. 

  297. Status Tensor::GetData(std::vector<int64_t> *val) const { return GetInputImp<proto::MS_INT64>(proto_tensor_, val); }

  298. 

  299. Status Tensor::GetData(std::vector<bool> *val) const {

  300.   if (val == nullptr) {

  301.     return Status(SYSTEM_ERROR) << "input val cannot be nullptr";

  302.   }

  303.   std::vector<uint8_t> val_uint8;

  304.   Status status = GetInputImp<proto::MS_BOOL>(proto_tensor_, &val_uint8);

  305.   if (!status.IsSuccess()) {

  306.     return status;

  307.   }

  308.   std::transform(val_uint8.begin(), val_uint8.end(), std::back_inserter(*val), [](uint8_t item) { return item != 0; });

  309.   return SUCCESS;

  310. }

  311. 

  312. Status Tensor::GetData(std::vector<float> *val) const { return GetInputImp<proto::MS_FLOAT32>(proto_tensor_, val); }

  313. 

  314. Status Tensor::GetData(std::vector<double> *val) const { return GetInputImp<proto::MS_FLOAT64>(proto_tensor_, val); }

  315. 

  316. Status Tensor::GetFp16Data(std::vector<uint16_t> *val) const {

  317.   return GetInputImp<proto::MS_FLOAT16>(proto_tensor_, val);

  318. }

  319. 

  320. DataType Tensor::GetDataType() const {

  321.   if (proto_tensor_ == nullptr) {

  322.     std::cout << "proto tensor cannot be nullptr" << std::endl;

  323.     return DT_UNKNOWN;

  324.   }

  325.   std::unordered_map<proto::DataType, DataType> data_type_map = {

  326.     {proto::MS_UNKNOWN, DT_UNKNOWN}, {proto::MS_UINT8, DT_UINT8},     {proto::MS_UINT16, DT_UINT16},

  327.     {proto::MS_UINT32, DT_UINT32},   {proto::MS_UINT64, DT_UINT64},   {proto::MS_INT8, DT_INT8},

  328.     {proto::MS_INT16, DT_INT16},     {proto::MS_INT32, DT_INT32},     {proto::MS_INT64, DT_INT64},

  329.     {proto::MS_BOOL, DT_BOOL},       {proto::MS_FLOAT16, DT_FLOAT16}, {proto::MS_FLOAT32, DT_FLOAT32},

  330.     {proto::MS_FLOAT64, DT_FLOAT64}, {proto::MS_STRING, DT_STRING},   {proto::MS_BYTES, DT_BYTES},

  331.   };

  332.   auto it_dt = data_type_map.find(proto_tensor_->dtype());

  333.   if (it_dt == data_type_map.end()) {

  334.     std::cout << "Unsupported data type " << proto_tensor_->dtype() << std::endl;

  335.     return DT_UNKNOWN;

  336.   }

  337.   return it_dt->second;

  338. }

  339. 

  340. std::vector<int64_t> Tensor::GetShape() const {

  341.   if (proto_tensor_ == nullptr) {

  342.     std::cout << "proto tensor cannot be nullptr" << std::endl;

  343.     return std::vector<int64_t>();

  344.   }

  345.   std::vector<int64_t> shape;

  346.   auto &dims = proto_tensor_->shape().dims();

  347.   std::copy(dims.begin(), dims.end(), std::back_inserter(shape));

  348.   return shape;

  349. }

  350. 

  351. Tensor Instance::Get(const std::string &item_name) const {

  352.   if (proto_instance_ == nullptr) {

  353.     std::cout << "proto instance cannot be nullptr" << std::endl;

  354.     return Tensor(nullptr, nullptr);

  355.   }

  356.   auto &items = proto_instance_->items();

  357.   auto it = items.find(item_name);

  358.   if (it == items.end()) {

  359.     std::cout << "Cannot find item name " << item_name << std::endl;

  360.     return Tensor(nullptr, nullptr);

  361.   }

  362.   return Tensor(message_owner_, &it->second);

  363. }

  364. 

  365. bool Instance::HasErrorMsg(int64_t *error_code, std::string *error_msg) const {

  366.   if (error_code == nullptr) {

  367.     return false;

  368.   }

  369.   if (error_msg == nullptr) {

  370.     return false;

  371.   }

  372.   if (error_msg_ == nullptr) {

  373.     return false;

  374.   }

  375.   *error_code = error_msg_->error_code();

  376.   *error_msg = error_msg_->error_msg();

  377.   return true;

  378. }

  379. 

  380. MutableTensor MutableInstance::Add(const std::string &item_name) {

  381.   if (mutable_proto_instance_ == nullptr) {

  382.     std::cout << "proto instance cannot be nullptr" << std::endl;

  383.     return MutableTensor(nullptr, nullptr);

  384.   }

  385.   auto items = mutable_proto_instance_->mutable_items();

  386.   auto &proto_tensor = (*items)[item_name];

  387.   return MutableTensor(message_owner_, &proto_tensor);

  388. }

  389. 

  390. InstancesRequest::InstancesRequest() { request_ = std::make_shared<proto::PredictRequest>(); }

  391. 

  392. MutableInstance InstancesRequest::AddInstance() {

  393.   auto proto_instance = request_->add_instances();

  394.   return MutableInstance(request_, proto_instance);

  395. }

  396. 

  397. InstancesReply::InstancesReply() { reply_ = std::make_shared<proto::PredictReply>(); }

  398. 

  399. std::vector<Instance> InstancesReply::GetResult() const {

  400.   std::vector<Instance> instances;

  401.   auto &proto_instances = reply_->instances();

  402.   auto &proto_error_msgs = reply_->error_msg();

  403.   for (int i = 0; i < proto_instances.size(); i++) {

  404.     auto &proto_instance = proto_instances[i];

  405.     const proto::ErrorMsg *error_msg = nullptr;

  406.     if (proto_error_msgs.size() == 1) {

  407.       error_msg = &proto_error_msgs[0];

  408.     } else if (proto_error_msgs.size() == proto_instances.size() && proto_error_msgs[i].error_code() != 0) {

  409.       error_msg = &proto_error_msgs[i];

  410.     }

  411.     instances.push_back(Instance(reply_, &proto_instance, error_msg));

  412.   }

  413.   return instances;

  414. }

  415. 

  416. class ClientImpl {

  417.  public:

  418.   ClientImpl(const std::string &server_ip, uint64_t server_port) {

  419.     std::string target_str = server_ip + ":" + std::to_string(server_port);

  420.     auto channel = grpc::CreateChannel(target_str, grpc::InsecureChannelCredentials());

  421.     stub_ = proto::MSService::NewStub(channel);

  422.   }

  423.   Status Predict(const proto::PredictRequest &request, proto::PredictReply *reply) {

  424.     if (reply == nullptr) {

  425.       return Status(SYSTEM_ERROR, "ClientImpl::Predict input reply cannot be nullptr");

  426.     }

  427.     grpc::ClientContext context;

  428. 

  429.     // The actual RPC.

  430.     grpc::Status status = stub_->Predict(&context, request, reply);

  431.     if (status.ok()) {

  432.       return SUCCESS;

  433.     } else {

  434.       std::cout << status.error_code() << ": " << status.error_message() << std::endl;

  435.       return Status(FAILED, status.error_message());

  436.     }

  437.   }

  438. 

  439.  private:

  440.   std::unique_ptr<proto::MSService::Stub> stub_;

  441. };

  442. 

  443. Client::Client(const std::string &server_ip, uint64_t server_port, const std::string &servable_name,

  444.                const std::string &method_name, uint64_t version_number)

  445.     : server_ip_(server_ip),

  446.       server_port_(server_port),

  447.       servable_name_(servable_name),

  448.       method_name_(method_name),

  449.       version_number_(version_number),

  450.       impl_(std::make_shared<ClientImpl>(server_ip, server_port)) {}

  451. 

  452. Status Client::SendRequest(const InstancesRequest &request, InstancesReply *reply) {

  453.   if (reply == nullptr) {

  454.     return Status(SYSTEM_ERROR) << "input reply cannot be nullptr";

  455.   }

  456.   proto::PredictRequest *proto_request = request.request_.get();

  457.   proto::PredictReply *proto_reply = reply->reply_.get();

  458.   auto servable_spec = proto_request->mutable_servable_spec();

  459.   servable_spec->set_name(servable_name_);

  460.   servable_spec->set_method_name(method_name_);

  461.   servable_spec->set_version_number(version_number_);

  462. 

  463.   Status result = impl_->Predict(*proto_request, proto_reply);

  464.   return result;

  465. }

  466. 

  467. }  // namespace client

  468. }  // namespace serving

  469. }  // namespace mindspore