executor.cpp 33.5 KB
Newer Older
W
wangliu 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* Copyright (c) 2018 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. */

15
#include "framework/executor.h"
W
wangliu 已提交
16
#include <operators/math/gemm.h>
D
dolphin8 已提交
17
#include <algorithm>
W
wangliu 已提交
18
#include <vector>
L
liuruilong 已提交
19
#include "common/enforce.h"
L
liuruilong 已提交
20
#include "common/log.h"
L
liuruilong 已提交
21
#include "framework/framework.pb-c.h"
L
liuruilong 已提交
22 23
#include "framework/lod_tensor.h"
#include "framework/operator.h"
L
liuruilong 已提交
24
#include "framework/program/program-optimize/program_optimize.h"
L
liuruilong 已提交
25 26 27 28
#include "framework/program/program_desc.h"
#include "framework/program/var_desc.h"
#include "framework/scope.h"
#include "framework/tensor.h"
L
update  
liuruilong 已提交
29

D
dolphin8 已提交
30
#ifdef PADDLE_EXECUTOR_MULTITHREAD
D
dolphin8 已提交
31 32 33 34
#include <queue>
#include <utility>
#include "common/threadpool.h"
#endif
W
wangliu 已提交
35

L
update  
liuruilong 已提交
36 37 38 39
#ifdef PADDLE_MOBILE_CL
#include "framework/cl/cl_image.h"
#endif

Y
yangfei 已提交
40
int debug_to = 4;
L
liuruilong 已提交
41

W
wangliu 已提交
42
namespace paddle_mobile {
43 44
namespace framework {

W
wangliu 已提交
45 46
using framework::Variable;

L
liuruilong 已提交
47 48
char *Get_binary_data(std::string filename) {
  FILE *file = fopen(filename.c_str(), "rb");
L
liuruilong 已提交
49 50
  PADDLE_MOBILE_ENFORCE(file != nullptr, "can't open file: %s ",
                        filename.c_str());
L
liuruilong 已提交
51
  fseek(file, 0, SEEK_END);
52
  int64_t size = ftell(file);
L
liuruilong 已提交
53 54 55 56
  PADDLE_MOBILE_ENFORCE(size > 0, "size is too small");
  rewind(file);
  char *data = new char[size];
  size_t bytes_read = fread(data, 1, size, file);
L
liuruilong 已提交
57 58
  PADDLE_MOBILE_ENFORCE(bytes_read == size,
                        "read binary file bytes do not match with fseek");
L
liuruilong 已提交
59 60
  fclose(file);
  return data;
W
wangliu 已提交
61 62 63
}

#pragma mark - executor
64

Y
yangfei 已提交
65
template <typename Dtype, Precision P>
L
liuruilong 已提交
66
Executor<Dtype, P>::Executor(const framework::Program<Dtype> p, int batch_size,
xiebaiyuan's avatar
xiebaiyuan 已提交
67
                             bool use_optimize, bool loddable)
Y
yangfei 已提交
68 69 70 71
    : program_(p),
      batch_size_(batch_size),
      use_optimize_(use_optimize),
      loddable_(loddable) {
W
wangliu 已提交
72 73 74 75 76 77 78
  if (use_optimize_) {
    to_predict_program_ = program_.optimizeProgram;
  } else {
    to_predict_program_ = program_.originProgram;
  }
  Variable *variable_ptr = program_.scope->Var("batch_size");
  variable_ptr[0].SetValue<int>(batch_size);
79 80
  PADDLE_MOBILE_ENFORCE(to_predict_program_ != nullptr,
                        "to_predict_program_ == NULL!");
W
wangliu 已提交
81
  const std::vector<std::shared_ptr<framework::BlockDesc>> blocks =
Y
yangfei 已提交
82
      to_predict_program_->Blocks();
D
dolphin8 已提交
83 84 85
#ifdef PADDLE_EXECUTOR_MULTITHREAD
  depManager.resize(blocks.size());
#endif
xiebaiyuan's avatar
xiebaiyuan 已提交
86
  DLOG << "executer in loaddable mode: " << loddable_;
W
wangliu 已提交
87 88 89
  for (int i = 0; i < blocks.size(); ++i) {
    std::shared_ptr<framework::BlockDesc> block_desc = blocks[i];
    std::vector<std::shared_ptr<framework::OpDesc>> ops = block_desc->Ops();
L
liuruilong 已提交
90
    for (int j = 0; j < debug_to; ++j) {
W
wangliu 已提交
91
      std::shared_ptr<framework::OpDesc> op = ops[j];
Z
zhangyang 已提交
92
      DLOG << "create op: " << j << "  " << op->Type();
W
wangliu 已提交
93
      auto op_base = framework::OpRegistry<Dtype>::CreateOp(
Y
yangfei 已提交
94 95
          op->Type(), op->GetInputs(), op->GetOutputs(), op->GetAttrMap(),
          program_.scope);
xiebaiyuan's avatar
xiebaiyuan 已提交
96 97 98 99 100
      // use pre_infershape to pre resize , but if u use an lod mode tensor u
      // need to resize in runtime
      if (!loddable_) {
        op_base->InferShape();
      }
W
wangliu 已提交
101
      ops_of_block_[*block_desc.get()].push_back(op_base);
D
dolphin8 已提交
102 103 104
#ifdef PADDLE_EXECUTOR_MULTITHREAD
      depManager[i].analysisDep(ops_of_block_[*block_desc.get()]);
#endif
W
wangliu 已提交
105
    }
106
    DLOG << "Total " << ops.size() << " ops have been created ";
W
wangliu 已提交
107
  }
W
wangliu 已提交
108
  if (program_.combined) {
L
liuruilong 已提交
109 110 111 112
    InitCombineMemory();
  } else {
    InitMemory();
  }
L
liuruilong 已提交
113
  std::shared_ptr<framework::BlockDesc> to_predict_block =
Y
yangfei 已提交
114
      to_predict_program_->Block(0);
L
liuruilong 已提交
115
  auto &ops = ops_of_block_[*to_predict_block.get()];
Z
zhangyang 已提交
116
  int i = 0;
L
liuruilong 已提交
117
  for (const auto &op : ops) {
Z
zhangyang 已提交
118
    DLOG << "Init op: " << i++ << "  " << op->Type();
L
liuruilong 已提交
119 120
    op->Init();
  }
W
wangliu 已提交
121 122
}

Y
yangfei 已提交
123
template <typename Dtype, Precision P>
W
wangliu 已提交
124
void Executor<Dtype, P>::LoadMemory(const framework::VarDesc var_desc,
125
                                    framework::LoDTensor *tensor, char **data) {
W
wangliu 已提交
126
  // 1. version
127 128 129
  uint32_t version = *reinterpret_cast<uint32_t *>(*data);

  (*data) += sizeof(uint32_t);
W
wangliu 已提交
130 131

  // 2 Lod information
L
liuruilong 已提交
132
  uint64_t *lod_level_ptr = new uint64_t();
133
  memcpy(lod_level_ptr, (*data), sizeof(uint64_t));
L
liuruilong 已提交
134 135
  uint64_t lod_level = *lod_level_ptr;
  delete lod_level_ptr;
136
  (*data) += sizeof(uint64_t);
L
liuruilong 已提交
137

W
wangliu 已提交
138 139 140
  auto &lod = *tensor->mutable_lod();
  lod.resize(lod_level);
  for (uint64_t i = 0; i < lod_level; ++i) {
141 142
    uint64_t size = *reinterpret_cast<uint64_t *>(*data);
    (*data) += sizeof(uint64_t);
W
wangliu 已提交
143
    std::vector<size_t> tmp(size / sizeof(size_t));
L
liuruilong 已提交
144 145

    for (int k = 0; k < tmp.size(); ++k) {
146 147
      tmp[k] = *reinterpret_cast<size_t *>(*data);
      (*data) += sizeof(size_t);
L
liuruilong 已提交
148 149
    }

W
wangliu 已提交
150 151 152 153 154 155 156
    for (auto j : tmp) {
      LOG(kLOG_DEBUG1) << "    lod - " << j;
    }
    lod[i] = tmp;
  }

  // 3. tensor version
157 158
  uint32_t tensor_version = *reinterpret_cast<uint32_t *>(*data);
  (*data) += sizeof(uint32_t);
W
wangliu 已提交
159 160

  // 4. tensor desc
161 162
  int32_t size = *reinterpret_cast<int32_t *>(*data);
  (*data) += sizeof(int32_t);
L
liuruilong 已提交
163

W
wangliu 已提交
164
  std::unique_ptr<char[]> buf(new char[size]);
L
liuruilong 已提交
165
  for (int m = 0; m < size; ++m) {
166
    buf.get()[m] = (*data)[m];
L
liuruilong 已提交
167
  }
168
  (*data) += (sizeof(char) * size);
W
wangliu 已提交
169 170 171 172 173 174 175 176 177

  const framework::TensorDesc &desc = var_desc.Tensor_desc();
  int memory_size = 1;
  for (auto l : desc.Dims()) {
    memory_size *= l;
  }

  tensor->Resize(framework::make_ddim(desc.Dims()));

178
  void *memory = nullptr;
W
wangliu 已提交
179 180 181 182 183 184 185 186 187 188 189 190 191
  int type_size = 0;
  switch (desc.DataType()) {
    case framework::VARTYPE_TYPE_FP16:
      type_size = 2;
      break;
    case framework::VARTYPE_TYPE_FP32:
      type_size = 4;
      memory = tensor->mutable_data<float>();
      break;
    case framework::VARTYPE_TYPE_FP64:
      type_size = 8;
      break;
    case framework::VARTYPE_TYPE_INT32:
xiebaiyuan's avatar
xiebaiyuan 已提交
192
      memory = tensor->mutable_data<int32_t>();
W
wangliu 已提交
193 194 195 196 197 198 199 200 201 202 203
      type_size = 4;
      break;
    case framework::VARTYPE_TYPE_INT64:
      type_size = 8;
      break;
    case framework::VARTYPE_TYPE_BOOL:
      type_size = 1;
      break;
    default:
      break;
  }
W
wangliu 已提交
204 205 206 207 208 209 210 211
  if (program_.quantification) {
    float min_value;
    float max_value;

    memcpy(&min_value, *data, sizeof(float));
    memcpy(&max_value, *data + sizeof(float), sizeof(float));
    *data += 2 * sizeof(float);
    const float factor = (max_value - min_value) / 255.0;
H
hanbuhe 已提交
212
    uint8_t *uint8_data = reinterpret_cast<uint8_t *>(*data);
W
wangliu 已提交
213 214 215 216 217
    for (int k = 0; k < memory_size; ++k) {
      static_cast<float *>(memory)[k] = uint8_data[k] * factor + min_value;
    }
    *data += (memory_size * sizeof(uint8_t));
  } else {
218 219 220 221 222 223 224 225
    for (int n = 0; n < memory_size; n++) {
      float value;
      memcpy(&value, *data + n * type_size, type_size);
      if (value < 1e-30 && value > -1e-30) {
        static_cast<float *>(memory)[n] = 0.0;
      } else {
        static_cast<float *>(memory)[n] = value;
      }
W
wangliu 已提交
226 227
    }
    (*data) += (sizeof(char) * memory_size * type_size);
L
liuruilong 已提交
228
  }
W
wangliu 已提交
229 230
}

Y
yangfei 已提交
231
template <typename Dtype, Precision P>
W
wangliu 已提交
232 233 234 235 236 237 238 239 240
void Executor<Dtype, P>::InitMemory() {
  for (const auto &block : to_predict_program_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
        auto tensor = var->template GetMutable<framework::LoDTensor>();
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
          continue;
        }
L
liuruilong 已提交
241

L
liuruilong 已提交
242
        char *origin_data =
Y
yangfei 已提交
243
            Get_binary_data(program_.model_path + "/" + var_desc->Name());
L
liuruilong 已提交
244
        char *data = origin_data;
245
        LoadMemory(*var_desc, tensor, &data);
L
liuruilong 已提交
246

L
liuruilong 已提交
247
        delete origin_data;
W
wangliu 已提交
248 249
      } else {
        if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
xiebaiyuan's avatar
xiebaiyuan 已提交
250 251 252 253 254 255
          bool is_mute_match;
          framework::LoDTensor *tensor = nullptr;

          is_mute_match = varInputMemory(var_desc, var, tensor);

          PADDLE_MOBILE_ENFORCE(
Y
yangfei 已提交
256 257 258
              is_mute_match,
              "got unhandled var_desc->Tensor_desc().DataType(): %d",
              var_desc->Tensor_desc().DataType());
W
wangliu 已提交
259 260 261 262 263 264
        }
      }
    }
  }
}

Y
yangfei 已提交
265
template <typename Dtype, Precision P>
L
liuruilong 已提交
266
void Executor<Dtype, P>::InitCombineMemory() {
267 268 269
  char *origin_data;
  if (program_.combined_params_buf && program_.combined_params_len) {
    LOG(kLOG_INFO) << "use outter memory";
270
    origin_data = reinterpret_cast<char *>(program_.combined_params_buf);
271 272 273 274 275
  } else {
    LOG(kLOG_INFO) << " begin init combine memory";
    origin_data = Get_binary_data(program_.para_path);
  }
  PADDLE_MOBILE_ENFORCE(origin_data != nullptr, "origin_data==nullptr!!!");
L
liuruilong 已提交
276
  char *data = origin_data;
L
liuruilong 已提交
277 278 279 280 281 282 283 284
  for (const auto &block : to_predict_program_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
        auto tensor = var->template GetMutable<framework::LoDTensor>();
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
          continue;
        }
285
        LoadMemory(*var_desc, tensor, &data);
L
liuruilong 已提交
286 287
      } else {
        if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
xiebaiyuan's avatar
xiebaiyuan 已提交
288 289 290 291 292 293
          bool is_mute_match = false;
          framework::LoDTensor *tensor;

          is_mute_match = varInputMemory(var_desc, var, tensor);

          PADDLE_MOBILE_ENFORCE(
Y
yangfei 已提交
294 295 296
              is_mute_match,
              "got unhandled var_desc->Tensor_desc().DataType(): %d",
              var_desc->Tensor_desc().DataType());
L
liuruilong 已提交
297 298 299 300 301
        }
      }
    }
  }
  delete origin_data;
L
liuruilong 已提交
302
  LOG(kLOG_INFO) << " end init combine memory ";
L
liuruilong 已提交
303
}
L
liuruilong 已提交
304

Y
yangfei 已提交
305
template <typename Dtype, Precision P>
xiebaiyuan's avatar
xiebaiyuan 已提交
306
bool Executor<Dtype, P>::varInputMemory(
Y
yangfei 已提交
307 308
    const std::shared_ptr<framework::VarDesc> &var_desc, Variable *var,
    framework::LoDTensor *tensor) const {
xiebaiyuan's avatar
xiebaiyuan 已提交
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
  bool is_mute_match = false;
  switch (var_desc->Tensor_desc().DataType()) {
    case framework::VARTYPE_TYPE_FP16: {
      break;
    }

    case framework::VARTYPE_TYPE_FP32: {
      tensor = var->template GetMutable<framework::LoDTensor>();
      tensor->template mutable_data<Ptype>();
      is_mute_match = true;
      break;
    }

    case framework::VARTYPE_TYPE_FP64: {
      break;
    }

    case framework::VARTYPE_TYPE_INT32: {
xiebaiyuan's avatar
xiebaiyuan 已提交
327 328 329
      tensor = var->template GetMutable<framework::LoDTensor>();
      tensor->template mutable_data<int32_t>();
      is_mute_match = true;
xiebaiyuan's avatar
xiebaiyuan 已提交
330 331 332 333 334 335 336 337 338 339 340 341 342
      break;
    }

    case framework::VARTYPE_TYPE_INT64: {
      tensor = var->template GetMutable<framework::LoDTensor>();
      tensor->template mutable_data<int64_t>();
      is_mute_match = true;
      break;
    }
    case framework::VARTYPE_TYPE_BOOL: {
      break;
    }

Y
yangfei 已提交
343
    default: { break; }
xiebaiyuan's avatar
xiebaiyuan 已提交
344 345 346 347
  }

  return is_mute_match;
}
L
liuruilong 已提交
348

Y
yangfei 已提交
349
template <typename Dtype, Precision P>
W
wangliu 已提交
350
std::shared_ptr<framework::Tensor> Executor<Dtype, P>::Predict(
Y
yangfei 已提交
351
    const framework::Tensor &t) {
W
wangliu 已提交
352 353
  framework::Variable *g_feed_value = program_.scope->Var("feed");
  framework::Tensor *feed_tensor =
Y
yangfei 已提交
354
      g_feed_value->GetMutable<framework::LoDTensor>();
W
wangliu 已提交
355 356 357
  feed_tensor->Resize(t.dims());
  feed_tensor->ShareDataWith(t);
  std::shared_ptr<framework::BlockDesc> to_predict_block =
Y
yangfei 已提交
358
      to_predict_program_->Block(0);
D
dolphin8 已提交
359
  auto &ops = ops_of_block_[*to_predict_block.get()];
xiebaiyuan's avatar
xiebaiyuan 已提交
360

D
dolphin8 已提交
361
#ifdef PADDLE_MOBILE_PROFILE
D
dolphin8 已提交
362
  std::vector<ProfInfo> profile(ops.size());
D
dolphin8 已提交
363
#endif
D
dolphin8 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402
#ifdef PADDLE_EXECUTOR_MULTITHREAD
  std::mutex m;
  std::condition_variable cv;
  std::queue<int> next;
  next.push(0);
  int rsize = ops.size();
  std::vector<int> status(rsize, 0);
  auto &threadPool = ThreadPool::getThreadPool();
  auto &dep = depManager[0];
  auto finishF = [&ops, &m, &cv, &next, &status, &rsize, &dep](int opi) {
    std::lock_guard<std::mutex> lk(m);
    rsize--;
    status[opi] = 2;
    for (int i : dep.getNext(opi)) {
      bool ok = true;
      for (int j : dep.getDeps(i)) {
        if (status[j] != 2) {
          ok = false;
          break;
        }
      }
      if (ok && (status[i] == 0)) {
        next.push(i);
      }
    }
    cv.notify_one();
  };
  for (;;) {
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [&next, &rsize] { return rsize == 0 || !next.empty(); });
    if (rsize == 0) {
      break;
    }
    while (next.size() > 0) {
      int opi = next.front();
      next.pop();
      status[opi] = 1;
      threadPool.enqueue([opi, &ops, &finishF, &profile] {
        auto &op = ops[opi];
D
dolphin8 已提交
403
#ifdef PADDLE_MOBILE_PROFILE
D
dolphin8 已提交
404 405 406 407
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        profile[opi].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
        profile[opi].tid = ThreadPool::getThreadPoolThreadId();
D
dolphin8 已提交
408
#endif
D
dolphin8 已提交
409
        ops[opi]->Run();
D
dolphin8 已提交
410
#ifdef PADDLE_MOBILE_PROFILE
D
dolphin8 已提交
411 412
        clock_gettime(CLOCK_MONOTONIC, &ts);
        profile[opi].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
D
dolphin8 已提交
413
#endif
D
dolphin8 已提交
414 415 416
        finishF(opi);
      });
    }
W
wangliu 已提交
417
  }
D
dolphin8 已提交
418
#else
L
liuruilong 已提交
419
  for (int i = 0; i < debug_to; i++) {
D
dolphin8 已提交
420
#ifdef PADDLE_MOBILE_PROFILE
D
dolphin8 已提交
421 422 423 424
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
L
liuruilong 已提交
425
    // to Run
D
dolphin8 已提交
426 427 428 429 430
    ops[i]->Run();
#ifdef PADDLE_MOBILE_PROFILE
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
D
dolphin8 已提交
431 432
  }
#endif
L
liuruilong 已提交
433 434

  DLOG << " predict return nullptr";
L
liuruilong 已提交
435

L
liuruilong 已提交
436
  return nullptr;
L
liuruilong 已提交
437

W
wangliu 已提交
438 439 440 441 442
  auto last_op = ops.rbegin();
  auto output_map = (*last_op)->Outputs();
  std::vector<std::string> out_keys = (*last_op)->GetOutKeys();
  PADDLE_MOBILE_ENFORCE(out_keys.size() > 0, "the last op contains no output");
  framework::LoDTensor *output_tensor =
Y
yangfei 已提交
443 444
      framework::GetVarValue<framework::LoDTensor>(out_keys[0], output_map,
                                                   *(program_.scope));
D
dolphin8 已提交
445 446
#ifdef PADDLE_MOBILE_PROFILE
#ifdef PADDLE_EXECUTOR_MULTITHREAD
447 448
  // TODO(haipeng): expose profile info as an interface, user can get them to
  // analysis
D
dolphin8 已提交
449 450 451 452 453 454 455 456 457 458 459 460 461 462
  //      the performance of their deepnet.
  FILE *df = fopen("net.dot", "w");
  fprintf(df, "digraph {\n");
  for (int i = 0; i < ops.size(); i++) {
    for (int j : dep.getNext(i)) {
      fprintf(df, "op_%d -> op_%d\n", i, j);
    }
  }
  for (int i = 0; i < ops.size(); i++) {
    fprintf(df, "op_%d[label=\"%s (%d)\"]\n", i, ops[i]->Type().c_str(), i);
  }
  fprintf(df, "}\n");
  fclose(df);
#endif
463
  //  FILE *pf = fopen("profile.out", "w");
D
dolphin8 已提交
464 465 466 467 468
  std::unordered_map<std::string, uint64_t> _tp;
  for (int i = 0; i < profile.size(); i++) {
    const auto &pInfo = profile[i];
    uint64_t timeCost = pInfo.runEnd - pInfo.runBegin;
    _tp[ops[i]->Type()] += timeCost;
L
liuruilong 已提交
469 470 471
    //    fprintf(pf, "%d\t%s\t%d\t%llu\t%llu\t%llu\n", i,
    //    ops[i]->Type().c_str(),
    //            pInfo.tid, pInfo.runBegin, pInfo.runEnd, timeCost);
D
dolphin8 已提交
472
  }
473
  //  fclose(pf);
D
dolphin8 已提交
474 475 476 477 478 479 480 481 482 483 484 485 486
  printf("====================[ profile ]======================\n");
  using prof_t = std::pair<std::string, uint64_t>;
  std::vector<prof_t> _tv(_tp.begin(), _tp.end());
  uint64_t _ptotal = 0;
  for (auto const &p : _tv) {
    _ptotal += p.second;
  }
  auto compf = [](const prof_t &a, const prof_t &b) {
    return a.second > b.second;
  };
  std::sort(_tv.begin(), _tv.end(), compf);
  _tv.push_back(std::make_pair("total", _ptotal));
  for (auto const &p : _tv) {
487 488 489
    printf("%-16s\t%-10.0f\t%-2.4f\n", p.first.c_str(),
           static_cast<float>(p.second),
           static_cast<float>(p.second) / _ptotal * 100.0);
D
dolphin8 已提交
490 491 492
  }
  printf("====================[---------]======================\n");
#endif
L
liuruilong 已提交
493
  return std::make_shared<framework::Tensor>(framework::Tensor(*output_tensor));
W
wangliu 已提交
494
}
xiebaiyuan's avatar
xiebaiyuan 已提交
495

Y
yangfei 已提交
496
template <typename Dtype, Precision P>
xiebaiyuan's avatar
xiebaiyuan 已提交
497
std::shared_ptr<framework::LoDTensor> Executor<Dtype, P>::PredictLod(
Y
yangfei 已提交
498
    const framework::LoDTensor &t) {
xiebaiyuan's avatar
xiebaiyuan 已提交
499 500
  framework::Variable *g_feed_value = program_.scope->Var("feed");
  framework::LoDTensor *feed_tensor =
Y
yangfei 已提交
501
      g_feed_value->GetMutable<framework::LoDTensor>();
xiebaiyuan's avatar
xiebaiyuan 已提交
502 503 504 505 506
  feed_tensor->Resize(t.dims());
  feed_tensor->ShareDataWith(t);
  feed_tensor->set_lod(t.lod());

  std::shared_ptr<framework::BlockDesc> to_predict_block =
Y
yangfei 已提交
507
      to_predict_program_->Block(0);
xiebaiyuan's avatar
xiebaiyuan 已提交
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591

  auto &ops = ops_of_block_[*to_predict_block.get()];

#ifdef PADDLE_MOBILE_PROFILE
  std::vector<ProfInfo> profile(ops.size());
#endif
#ifdef PADDLE_EXECUTOR_MULTITHREAD
  std::mutex m;
  std::condition_variable cv;
  std::queue<int> next;
  next.push(0);
  int rsize = ops.size();
  std::vector<int> status(rsize, 0);
  auto &threadPool = ThreadPool::getThreadPool();
  auto &dep = depManager[0];
  auto finishF = [&ops, &m, &cv, &next, &status, &rsize, &dep](int opi) {
    std::lock_guard<std::mutex> lk(m);
    rsize--;
    status[opi] = 2;
    for (int i : dep.getNext(opi)) {
      bool ok = true;
      for (int j : dep.getDeps(i)) {
        if (status[j] != 2) {
          ok = false;
          break;
        }
      }
      if (ok && (status[i] == 0)) {
        next.push(i);
      }
    }
    cv.notify_one();
  };
  for (;;) {
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [&next, &rsize] { return rsize == 0 || !next.empty(); });
    if (rsize == 0) {
      break;
    }
    while (next.size() > 0) {
      int opi = next.front();
      next.pop();
      status[opi] = 1;
      threadPool.enqueue([opi, &ops, &finishF, &profile] {
        auto &op = ops[opi];
#ifdef PADDLE_MOBILE_PROFILE
        struct timespec ts;
        clock_gettime(CLOCK_MONOTONIC, &ts);
        profile[opi].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
        profile[opi].tid = ThreadPool::getThreadPoolThreadId();
#endif
        ops[opi]->Run();
#ifdef PADDLE_MOBILE_PROFILE
        clock_gettime(CLOCK_MONOTONIC, &ts);
        profile[opi].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
        finishF(opi);
      });
    }
  }
#else
  for (int i = 0; i < ops.size(); i++) {
#ifdef PADDLE_MOBILE_PROFILE
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
    if (loddable_) {
      ops[i]->InferShape();
    }
    // to Run
    ops[i]->Run();
#ifdef PADDLE_MOBILE_PROFILE
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
  }
#endif
  auto last_op = ops.rbegin();

  auto output_map = (*last_op)->Outputs();
  std::vector<std::string> out_keys = (*last_op)->GetOutKeys();
  PADDLE_MOBILE_ENFORCE(out_keys.size() > 0, "the last op contains no output");
  framework::LoDTensor *output_tensor =
Y
yangfei 已提交
592 593
      framework::GetVarValue<framework::LoDTensor>(out_keys[0], output_map,
                                                   *(program_.scope));
xiebaiyuan's avatar
xiebaiyuan 已提交
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642
#ifdef PADDLE_MOBILE_PROFILE
#ifdef PADDLE_EXECUTOR_MULTITHREAD
  // TODO(haipeng): expose profile info as an interface, user can get them to
  // analysis
  //      the performance of their deepnet.
  FILE *df = fopen("net.dot", "w");
  fprintf(df, "digraph {\n");
  for (int i = 0; i < ops.size(); i++) {
    for (int j : dep.getNext(i)) {
      fprintf(df, "op_%d -> op_%d\n", i, j);
    }
  }
  for (int i = 0; i < ops.size(); i++) {
    fprintf(df, "op_%d[label=\"%s (%d)\"]\n", i, ops[i]->Type().c_str(), i);
  }
  fprintf(df, "}\n");
  fclose(df);
#endif
  //  FILE *pf = fopen("profile.out", "w");
  std::unordered_map<std::string, uint64_t> _tp;
  for (int i = 0; i < profile.size(); i++) {
    const auto &pInfo = profile[i];
    uint64_t timeCost = pInfo.runEnd - pInfo.runBegin;
    _tp[ops[i]->Type()] += timeCost;
    //    fprintf(pf, "%d\t%s\t%d\t%llu\t%llu\t%llu\n", i,
    //    ops[i]->Type().c_str(),
    //            pInfo.tid, pInfo.runBegin, pInfo.runEnd, timeCost);
  }
  //  fclose(pf);
  printf("====================[ profile ]======================\n");
  using prof_t = std::pair<std::string, uint64_t>;
  std::vector<prof_t> _tv(_tp.begin(), _tp.end());
  uint64_t _ptotal = 0;
  for (auto const &p : _tv) {
    _ptotal += p.second;
  }
  auto compf = [](const prof_t &a, const prof_t &b) {
    return a.second > b.second;
  };
  std::sort(_tv.begin(), _tv.end(), compf);
  _tv.push_back(std::make_pair("total", _ptotal));
  for (auto const &p : _tv) {
    printf("%-16s\t%-10.0f\t%-2.4f\n", p.first.c_str(),
           static_cast<float>(p.second),
           static_cast<float>(p.second) / _ptotal * 100.0);
  }
  printf("====================[---------]======================\n");
#endif
  return std::make_shared<framework::LoDTensor>(
Y
yangfei 已提交
643
      framework::LoDTensor(*output_tensor));
xiebaiyuan's avatar
xiebaiyuan 已提交
644 645
}

Y
yangfei 已提交
646
template <typename Dtype, Precision P>
W
wangliu 已提交
647
std::shared_ptr<framework::Tensor> Executor<Dtype, P>::Predict(
Y
yangfei 已提交
648
    const framework::Tensor &t, int block_id) {
W
wangliu 已提交
649
  return Predict(t);
W
wangliu 已提交
650 651
}

Y
yangfei 已提交
652
template <typename Dtype, Precision P>
L
liuruilong 已提交
653
std::vector<typename Executor<Dtype, P>::Ptype> Executor<Dtype, P>::Predict(
Y
yangfei 已提交
654
    const std::vector<Ptype> &input, const std::vector<int64_t> &dims) {
W
wangliu 已提交
655
  framework::Tensor tensor(input, framework::make_ddim(dims));
W
wangliu 已提交
656
  std::shared_ptr<framework::Tensor> output_tensor = Predict(tensor, 0);
L
liuruilong 已提交
657 658
  if (output_tensor != nullptr) {
    Executor<Dtype, P>::Ptype *output_ptr =
L
liuruilong 已提交
659
        output_tensor->data<typename Executor<Dtype, P>::Ptype>();
L
liuruilong 已提交
660 661 662 663 664 665 666 667
    std::vector<typename Executor<Dtype, P>::Ptype> result_vector;
    for (int j = 0; j < output_tensor->numel(); ++j) {
      result_vector.push_back(output_ptr[j]);
    }
    return result_vector;
  } else {
    DLOG << "return  empty vector";
    return {};
W
wangliu 已提交
668
  }
W
wangliu 已提交
669 670
}

671
#ifdef PADDLE_MOBILE_FPGA
672

673
template <typename Dtype, Precision P>
674 675 676
void Executor<Dtype, P>::InjectVariable(const framework::Tensor &t,
                                        string var_name) {
  framework::Variable *g_feed_value = program_.scope->Var(var_name);
677 678 679 680
  framework::Tensor *feed_tensor =
      g_feed_value->GetMutable<framework::LoDTensor>();
  feed_tensor->Resize(t.dims());
  feed_tensor->ShareDataWith(t);
681
}
682

683 684 685
template <typename Dtype, Precision P>
void Executor<Dtype, P>::FeedData(const framework::Tensor &t) {
  InjectVariable(t, "feed");
686
}
687

688
template <typename Dtype, Precision P>
689
std::shared_ptr<framework::Tensor> Executor<Dtype, P>::FetchResult(int id) {
690 691 692
  std::shared_ptr<framework::BlockDesc> to_predict_block =
      to_predict_program_->Block(0);
  auto &ops = ops_of_block_[*to_predict_block.get()];
693 694 695 696 697

  PADDLE_MOBILE_ENFORCE(id < ops.size(), "Index out of range");
  auto last_op = id < 0 ? ops[ops.size() - 1] : ops[id];
  auto output_map = last_op->Outputs();
  std::vector<std::string> out_keys = last_op->GetOutKeys();
698 699 700 701
  PADDLE_MOBILE_ENFORCE(!out_keys.empty(), "the last op contains no output");
  auto *output_tensor = framework::GetVarValue<framework::LoDTensor>(
      out_keys[0], output_map, *(program_.scope));
  return std::make_shared<framework::Tensor>(framework::Tensor(*output_tensor));
702
}
703 704 705 706 707 708

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_From_To(int start, int end) {
  std::shared_ptr<framework::BlockDesc> to_predict_block =
      to_predict_program_->Block(0);
  auto &ops = ops_of_block_[*to_predict_block.get()];
709
  end = end < 0 ? static_cast<int>(ops.size()) : end;
710 711 712 713 714 715 716 717 718 719 720 721
  PADDLE_MOBILE_ENFORCE(start >= 0 && start < end && end <= ops.size(),
                        "start or end parameter is wrong");

#ifdef PADDLE_MOBILE_PROFILE
  std::vector<ProfInfo> profile(ops.size());
#endif
  for (int i = start; i < end; i++) {
#ifdef PADDLE_MOBILE_PROFILE
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
Z
zhangyang 已提交
722
    DLOG << "Running op: " << i << "  " << ops[i]->Type();
723 724 725 726 727 728 729
    ops[i]->Run();

#ifdef PADDLE_MOBILE_PROFILE
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
  }
730
}
731 732 733 734

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_From(int start) {
  Predict_From_To(start);
735
}
736 737 738 739

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_To(int end) {
  Predict_From_To(0, end);
740
}
741 742
#endif

Y
yangfei 已提交
743 744 745 746 747 748 749 750 751 752
#ifdef PADDLE_MOBILE_FPGA

template <typename Dtype, Precision P>
void Executor<Dtype, P>::InjectVariable(const framework::Tensor &t,
                                        string var_name) {
  framework::Variable *g_feed_value = program_.scope->Var(var_name);
  framework::Tensor *feed_tensor =
      g_feed_value->GetMutable<framework::LoDTensor>();
  feed_tensor->Resize(t.dims());
  feed_tensor->ShareDataWith(t);
753
}
Y
yangfei 已提交
754 755 756 757

template <typename Dtype, Precision P>
void Executor<Dtype, P>::FeedData(const framework::Tensor &t) {
  InjectVariable(t, "feed");
758
}
Y
yangfei 已提交
759 760 761 762 763 764 765 766 767 768 769 770 771 772 773

template <typename Dtype, Precision P>
std::shared_ptr<framework::Tensor> Executor<Dtype, P>::FetchResult(int id) {
  std::shared_ptr<framework::BlockDesc> to_predict_block =
      to_predict_program_->Block(0);
  auto &ops = ops_of_block_[*to_predict_block.get()];

  PADDLE_MOBILE_ENFORCE(id < ops.size(), "Index out of range");
  auto last_op = id < 0 ? ops[ops.size() - 1] : ops[id];
  auto output_map = last_op->Outputs();
  std::vector<std::string> out_keys = last_op->GetOutKeys();
  PADDLE_MOBILE_ENFORCE(!out_keys.empty(), "the last op contains no output");
  auto *output_tensor = framework::GetVarValue<framework::LoDTensor>(
      out_keys[0], output_map, *(program_.scope));
  return std::make_shared<framework::Tensor>(framework::Tensor(*output_tensor));
774
}
Y
yangfei 已提交
775 776 777 778 779 780

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_From_To(int start, int end) {
  std::shared_ptr<framework::BlockDesc> to_predict_block =
      to_predict_program_->Block(0);
  auto &ops = ops_of_block_[*to_predict_block.get()];
781
  end = end < 0 ? static_cast<int>(ops.size()) : end;
Y
yangfei 已提交
782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
  PADDLE_MOBILE_ENFORCE(start >= 0 && start < end && end <= ops.size(),
                        "start or end parameter is wrong");

#ifdef PADDLE_MOBILE_PROFILE
  std::vector<ProfInfo> profile(ops.size());
#endif
  for (int i = start; i < end; i++) {
#ifdef PADDLE_MOBILE_PROFILE
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
    DLOG << "Running op: " << i << "  " << ops[i]->Type();
    ops[i]->Run();

#ifdef PADDLE_MOBILE_PROFILE
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[i].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
#endif
  }
802
}
Y
yangfei 已提交
803 804 805 806

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_From(int start) {
  Predict_From_To(start);
807
}
Y
yangfei 已提交
808 809 810 811

template <typename Dtype, Precision P>
void Executor<Dtype, P>::Predict_To(int end) {
  Predict_From_To(0, end);
812
}
Y
yangfei 已提交
813 814 815
#endif

#ifdef PADDLE_MOBILE_CL
Y
yangfei 已提交
816
template <>
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
void Executor<GPU_CL, Precision::FP32>::LoadMemory(
    const framework::VarDesc var_desc, float *tensorInput, char **data) {
  // 1. version
  uint32_t version = *reinterpret_cast<uint32_t *>(*data);

  (*data) += sizeof(uint32_t);

  // 2 Lod information
  uint64_t *lod_level_ptr = new uint64_t();
  memcpy(lod_level_ptr, (*data), sizeof(uint64_t));
  uint64_t lod_level = *lod_level_ptr;
  delete lod_level_ptr;
  (*data) += sizeof(uint64_t);

  for (uint64_t i = 0; i < lod_level; ++i) {
    uint64_t size = *reinterpret_cast<uint64_t *>(*data);
    (*data) += sizeof(uint64_t);
    std::vector<size_t> tmp(size / sizeof(size_t));

    for (int k = 0; k < tmp.size(); ++k) {
      tmp[k] = *reinterpret_cast<size_t *>(*data);
      (*data) += sizeof(size_t);
    }
  }

  // 3. tensor version
  uint32_t tensor_version = *reinterpret_cast<uint32_t *>(*data);
  (*data) += sizeof(uint32_t);

  // 4. tensor desc
  int32_t size = *reinterpret_cast<int32_t *>(*data);
  (*data) += sizeof(int32_t);

  std::unique_ptr<char[]> buf(new char[size]);
  for (int m = 0; m < size; ++m) {
    buf.get()[m] = (*data)[m];
  }
  (*data) += (sizeof(char) * size);

  const framework::TensorDesc &desc = var_desc.Tensor_desc();
  int memory_size = 1;
  for (auto l : desc.Dims()) {
    memory_size *= l;
  }

  void *memory = nullptr;
  //            int type_size = 0;
  //            switch (desc.DataType()) {
  //                case framework::VARTYPE_TYPE_FP16:
  //                    type_size = 2;
  //                    break;
  //                case framework::VARTYPE_TYPE_FP32:
  //                    type_size = 4;
  //                    memory = tensor->mutable_data<float>();
  //                    break;
  //                case framework::VARTYPE_TYPE_FP64:
  //                    type_size = 8;
  //                    break;
  //                case framework::VARTYPE_TYPE_INT32:
  //                    memory = tensor->mutable_data<int32_t>();
  //                    type_size = 4;
  //                    break;
  //                case framework::VARTYPE_TYPE_INT64:
  //                    type_size = 8;
  //                    break;
  //                case framework::VARTYPE_TYPE_BOOL:
  //                    type_size = 1;
  //                    break;
  //                default:
  //                    break;
  //            }
  int type_size = 4;
  memory = tensorInput;
  if (program_.quantification) {
    float min_value;
    float max_value;

    memcpy(&min_value, *data, sizeof(float));
    memcpy(&max_value, *data + sizeof(float), sizeof(float));
    *data += 2 * sizeof(float);
    const float factor = (max_value - min_value) / 255.0;
    uint8_t *uint8_data = reinterpret_cast<uint8_t *>(*data);
    for (int k = 0; k < memory_size; ++k) {
      static_cast<float *>(memory)[k] = uint8_data[k] * factor + min_value;
    }
    *data += (memory_size * sizeof(uint8_t));
  } else {
    for (int n = 0; n < memory_size; n++) {
      float value;
      memcpy(&value, *data + n * type_size, type_size);
      if (value < 1e-30 && value > -1e-30) {
        static_cast<float *>(memory)[n] = 0.0;
      } else {
        static_cast<float *>(memory)[n] = value;
      }
    }
    (*data) += (sizeof(char) * memory_size * type_size);
  }
}
916

Y
yangfei 已提交
917 918 919 920 921 922
template <>
void Executor<GPU_CL, Precision::FP32>::InitMemory() {
  for (const auto &block : to_predict_program_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
L
liuruilong 已提交
923
        CLImage *cl_image = nullptr;
Y
yangfei 已提交
924
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
L
liuruilong 已提交
925
          var->template GetMutable<framework::LoDTensor>();
Y
yangfei 已提交
926
          continue;
L
liuruilong 已提交
927 928
        } else {
          cl_image = var->template GetMutable<framework::CLImage>();
Y
yangfei 已提交
929
        }
L
liuruilong 已提交
930

Y
yangfei 已提交
931 932
        char *origin_data =
            Get_binary_data(program_.model_path + "/" + var_desc->Name());
933
        char *data = origin_data;
Y
yangfei 已提交
934
        cl_context context = program_.scope->GetCLScpoe()->Context();
935 936 937 938 939 940
        const framework::TensorDesc &desc = var_desc->Tensor_desc();
        int numel = 1;
        for (auto l : desc.Dims()) {
          numel *= l;
        }
        DLOG << var_desc->Name();
Y
yangfei 已提交
941
        float *tensorInput = static_cast<float *>(
942 943
            paddle_mobile::memory::Alloc(sizeof(float) * numel));
        LoadMemory(*var_desc, tensorInput, &data);
Y
yangfei 已提交
944 945

        framework::DDim ddim = framework::make_ddim(desc.Dims());
Y
yangfei 已提交
946

L
liuruilong 已提交
947 948
        // has not init
        cl_image->SetTensorData(tensorInput, ddim);
Y
yangfei 已提交
949

950
        delete origin_data;
Y
yangfei 已提交
951
        //        paddle_mobile::memory::Free(tensorInput);
952 953 954 955
      } else {
        if (var_desc->Type() == framework::VARTYPE_TYPE_LOD_TENSOR) {
          auto cl_image = var->template GetMutable<framework::CLImage>();
          cl_context context = program_.scope->GetCLScpoe()->Context();
Y
yangfei 已提交
956
          cl_command_queue command_queue = program_.scope->GetCLScpoe()->CommandQueue();
Y
yangfei 已提交
957

958
          const framework::TensorDesc &desc = var_desc->Tensor_desc();
Y
yangfei 已提交
959 960
          //          framework::DDim ddim = framework::make_ddim(desc.Dims());
          framework::DDim ddim = cl_image->dims();
961
          DLOG << var_desc->Name();
Y
yangfei 已提交
962
          cl_image->InitEmptyImage(context,command_queue, ddim);
963
        }
Y
yangfei 已提交
964 965 966 967
      }
    }
  }
}
968

Y
yangfei 已提交
969 970 971 972 973
template <>
void Executor<GPU_CL, Precision::FP32>::InitCombineMemory() {
  char *origin_data;
  if (program_.combined_params_buf && program_.combined_params_len) {
    LOG(kLOG_INFO) << "use outter memory";
974
    origin_data = reinterpret_cast<char *>(program_.combined_params_buf);
Y
yangfei 已提交
975 976 977 978 979
  } else {
    LOG(kLOG_INFO) << " begin init combine memory";
    origin_data = Get_binary_data(program_.para_path);
  }
  PADDLE_MOBILE_ENFORCE(origin_data != nullptr, "origin_data==nullptr!!!");
980
  float *data = reinterpret_cast<float *>(origin_data);
Y
yangfei 已提交
981 982 983 984 985

  for (const auto &block : to_predict_program_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
L
liuruilong 已提交
986
        CLImage *cl_image = nullptr;
Y
yangfei 已提交
987
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
L
liuruilong 已提交
988
          var->template GetMutable<framework::LoDTensor>();
Y
yangfei 已提交
989
          continue;
L
liuruilong 已提交
990 991
        } else {
          cl_image = var->template GetMutable<framework::CLImage>();
Y
yangfei 已提交
992 993 994 995
        }

        cl_context context = program_.scope->GetCLScpoe()->Context();

Y
yangfei 已提交
996
        const framework::TensorDesc &desc = var_desc->Tensor_desc();
Y
yangfei 已提交
997
        framework::DDim ddim = framework::make_ddim(desc.Dims());
Y
yangfei 已提交
998 999 1000 1001 1002

        int numel = 1;
        for (int i = 0; i < ddim.size(); i++) {
          numel = numel * ddim[i];
        }
1003 1004 1005
        float *tensorInput = static_cast<float *>(
            paddle_mobile::memory::Alloc(sizeof(float) * numel));
        LoadMemory(*var_desc, tensorInput, &origin_data);
L
liuruilong 已提交
1006 1007 1008 1009

        // has not init
        cl_image->SetTensorData(tensorInput, ddim);

1010 1011
        paddle_mobile::memory::Free(tensorInput);
      } else {
Y
yangfei 已提交
1012 1013
        auto cl_image = var->template GetMutable<framework::CLImage>();
        cl_context context = program_.scope->GetCLScpoe()->Context();
Y
yangfei 已提交
1014
        cl_command_queue command_queue = program_.scope->GetCLScpoe()->CommandQueue();
Y
yangfei 已提交
1015
        const framework::TensorDesc &desc = var_desc->Tensor_desc();
Y
yangfei 已提交
1016 1017
        framework::DDim ddim = cl_image->dims();
        //        framework::DDim ddim = framework::make_ddim(desc.Dims());
Y
yangfei 已提交
1018
        cl_image->InitEmptyImage(context, command_queue,ddim);
Y
yangfei 已提交
1019 1020 1021 1022 1023
      }
    }
  }
  delete origin_data;
  LOG(kLOG_INFO) << " end init combine memory ";
1024
}
Y
yangfei 已提交
1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036

#endif

template class Executor<CPU, Precision::FP32>;

template class Executor<FPGA, Precision::FP32>;

template class Executor<GPU_CL, Precision::FP32>;

template class Executor<GPU_MALI, Precision::FP32>;

}  // namespace framework
W
wangliu 已提交
1037
}  // namespace paddle_mobile