general_response_op.cpp 6.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14
// Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
//
// 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.

M
MRXLT 已提交
15
#include "core/general-server/op/general_response_op.h"
16
#include <unistd.h>
17 18 19 20
#include <algorithm>
#include <iostream>
#include <memory>
#include <sstream>
21
#include "core/general-server/op/general_infer_helper.h"
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
#include "core/predictor/framework/infer.h"
#include "core/predictor/framework/memory.h"
#include "core/predictor/framework/resource.h"
#include "core/util/include/timer.h"

namespace baidu {
namespace paddle_serving {
namespace serving {

using baidu::paddle_serving::Timer;
using baidu::paddle_serving::predictor::MempoolWrapper;
using baidu::paddle_serving::predictor::general_model::Tensor;
using baidu::paddle_serving::predictor::general_model::Response;
using baidu::paddle_serving::predictor::general_model::Request;
using baidu::paddle_serving::predictor::general_model::FetchInst;
using baidu::paddle_serving::predictor::InferManager;
using baidu::paddle_serving::predictor::PaddleGeneralModelConfig;

40
int GeneralResponseOp::inference() {
M
MRXLT 已提交
41
  const GeneralBlob *input_blob = get_depend_argument<GeneralBlob>(pre_name());
G
guru4elephant 已提交
42

43
  if (!input_blob) {
M
MRXLT 已提交
44
    LOG(ERROR) << "Failed mutable depended argument, op: " << pre_name();
45 46 47
    return -1;
  }

48
  const TensorVector *in = &input_blob->tensor_vector;
49
  int batch_size = input_blob->GetBatchSize();
50

51
  VLOG(2) << "input batch size: " << batch_size;
52 53 54

  const Request *req = dynamic_cast<const Request *>(get_request_message());

G
guru4elephant 已提交
55 56 57 58 59
  Timer timeline;
  // double response_time = 0.0;
  // timeline.Start();
  int64_t start = timeline.TimeStampUS();

60 61 62
  VLOG(2) << "start to call load general model_conf op";
  baidu::paddle_serving::predictor::Resource &resource =
      baidu::paddle_serving::predictor::Resource::instance();
M
MRXLT 已提交
63

64 65 66 67 68 69 70 71 72 73
  VLOG(2) << "get resource pointer done.";
  std::shared_ptr<PaddleGeneralModelConfig> model_config =
      resource.get_general_model_config();

  std::vector<int> fetch_index;
  fetch_index.resize(req->fetch_var_names_size());
  for (int i = 0; i < req->fetch_var_names_size(); ++i) {
    fetch_index[i] =
        model_config->_fetch_alias_name_to_index[req->fetch_var_names(i)];
  }
M
MRXLT 已提交
74

75 76 77
  // response inst with only fetch_var_names
  Response *res = mutable_data<Response>();

78
  // to let the client know which server the current response comes from
B
barrierye 已提交
79 80 81
  int server_pid = static_cast<int>(getpid());
  VLOG(2) << "getpid: " << server_pid;
  res->set_server_pid(server_pid);
82

83 84
  for (int i = 0; i < batch_size; ++i) {
    FetchInst *fetch_inst = res->add_insts();
M
MRXLT 已提交
85
    for (auto &idx : fetch_index) {
86 87 88 89 90 91 92 93
      Tensor *tensor = fetch_inst->add_tensor_array();
      // currently only response float tensor or lod_tensor
      tensor->set_elem_type(1);
      if (model_config->_is_lod_fetch[idx]) {
        VLOG(2) << "out[" << idx << " is lod_tensor";
        tensor->add_shape(-1);
      } else {
        VLOG(2) << "out[" << idx << "] is tensor";
94
        for (int k = 1; k < in->at(idx).shape.size(); ++k) {
M
MRXLT 已提交
95
          VLOG(2) << "shape[" << k - 1 << "]: " << in->at(idx).shape[k];
96
          tensor->add_shape(in->at(idx).shape[k]);
97 98 99 100 101 102
        }
      }
    }
  }

  int var_idx = 0;
M
MRXLT 已提交
103
  for (auto &idx : fetch_index) {
104
    int cap = 1;
105 106
    for (int j = 1; j < in->at(idx).shape.size(); ++j) {
      cap *= in->at(idx).shape[j];
107
    }
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    if (in->at(idx).dtype == paddle::PaddleDType::INT64) {
      int64_t *data_ptr = static_cast<int64_t *>(in->at(idx).data.data());
      if (model_config->_is_lod_fetch[idx]) {
        for (int j = 0; j < batch_size; ++j) {
          for (int k = in->at(idx).lod[0][j]; k < in->at(idx).lod[0][j + 1];
               k++) {
            FetchInst *fetch_p = res->mutable_insts(j);
            fetch_p->mutable_tensor_array(var_idx)->add_int64_data(data_ptr[k]);
          }
        }
      } else {
        int var_size = in->at(idx).shape[0];
        if (var_size == batch_size) {
          for (int j = 0; j < batch_size; ++j) {
            for (int k = j * cap; k < (j + 1) * cap; ++k) {
              FetchInst *fetch_p = res->mutable_insts(j);
              fetch_p->mutable_tensor_array(var_idx)->add_int64_data(
                  data_ptr[k]);
            }
          }
        } else {
          for (int j = 0; j < batch_size; ++j) {
            FetchInst *fetch_p = res->mutable_insts(j);
B
barrierye 已提交
131
            fetch_p->mutable_tensor_array(var_idx)->add_int64_data(data_ptr[0]);
132
          }
133 134
        }
      }
135 136 137 138
      var_idx++;
    } else if (in->at(idx).dtype == paddle::PaddleDType::FLOAT32) {
      float *data_ptr = static_cast<float *>(in->at(idx).data.data());
      if (model_config->_is_lod_fetch[idx]) {
M
MRXLT 已提交
139
        for (int j = 0; j < batch_size; ++j) {
140 141 142 143
          for (int k = in->at(idx).lod[0][j]; k < in->at(idx).lod[0][j + 1];
               k++) {
            FetchInst *fetch_p = res->mutable_insts(j);
            fetch_p->mutable_tensor_array(var_idx)->add_float_data(data_ptr[k]);
M
MRXLT 已提交
144 145 146
          }
        }
      } else {
147 148 149 150
        int var_size = in->at(idx).shape[0];
        if (var_size == batch_size) {
          for (int j = 0; j < batch_size; ++j) {
            for (int k = j * cap; k < (j + 1) * cap; ++k) {
B
barrierye 已提交
151
              FetchInst *fetch_p = res->mutable_insts(j);
152 153 154 155 156 157
              fetch_p->mutable_tensor_array(var_idx)->add_float_data(
                  data_ptr[k]);
            }
          }
        } else {
          for (int j = 0; j < batch_size; ++j) {
B
barrierye 已提交
158 159
            FetchInst *fetch_p = res->mutable_insts(j);
            fetch_p->mutable_tensor_array(var_idx)->add_float_data(data_ptr[0]);
160
          }
161 162
        }
      }
163
      var_idx++;
164 165
    }
  }
G
guru4elephant 已提交
166

167 168 169 170 171 172 173 174 175
  if (req->profile_server()) {
    int64_t end = timeline.TimeStampUS();
    VLOG(2) << "p size for input blob: " << input_blob->p_size;
    for (int i = 0; i < input_blob->p_size; ++i) {
      res->add_profile_time(input_blob->time_stamp[i]);
    }
    // TODO(guru4elephant): find more elegant way to do this
    res->add_profile_time(start);
    res->add_profile_time(end);
G
guru4elephant 已提交
176 177
  }

178 179
  return 0;
}
180 181

DEFINE_OP(GeneralResponseOp);
182 183 184 185

}  // namespace serving
}  // namespace paddle_serving
}  // namespace baidu