executor.cpp 36.7 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. */

H
hjchen2 已提交
15
#include "framework/executor.h"
D
dolphin8 已提交
16
#include <algorithm>
17
#include <unordered_map>
18
#include <utility>
W
wangliu 已提交
19
#include <vector>
L
liuruilong 已提交
20
#include "common/enforce.h"
L
liuruilong 已提交
21
#include "common/log.h"
22
#include "framework/context.h"
L
liuruilong 已提交
23
#include "framework/framework.pb-c.h"
L
liuruilong 已提交
24 25
#include "framework/lod_tensor.h"
#include "framework/operator.h"
L
liuruilong 已提交
26
#include "framework/program/program-optimize/program_optimize.h"
L
liuruilong 已提交
27 28 29 30
#include "framework/program/program_desc.h"
#include "framework/program/var_desc.h"
#include "framework/scope.h"
#include "framework/tensor.h"
H
hjchen2 已提交
31
#include "memory/t_malloc.h"
H
hjchen2 已提交
32
#include "pass/memory_optimize.h"
33
#include "pass/model_obfuscate.h"
L
update  
liuruilong 已提交
34 35 36
#ifdef PADDLE_MOBILE_CL
#include "framework/cl/cl_image.h"
#endif
W
wangliu 已提交
37 38

namespace paddle_mobile {
39
namespace framework {
40

W
wangliu 已提交
41 42
#pragma mark - executor

43
template <typename Device, typename T>
44 45
void Executor<Device, T>::SetThreadNum(int thread_num, PowerMode power_mode) {
  CPUContext::Context()->set_thread_num(thread_num, power_mode);
46 47
}

48
template <typename Device, typename T>
xiebaiyuan's avatar
xiebaiyuan 已提交
49 50 51 52
Executor<Device, T>::Executor(const Program<Device> &program,
                              paddle_mobile::PaddleMobileConfigInternal config,
                              int batch_size, const bool use_optimize,
                              const bool lod_mode)
53
    : program_(program),
H
hjchen2 已提交
54 55
      batch_size_(batch_size),
      use_optimize_(use_optimize),
xiebaiyuan's avatar
xiebaiyuan 已提交
56 57
      lod_mode_(lod_mode),
      config_(config) {
58 59
  DLOG << "executor in lod mode: " << lod_mode_;

W
wangliu 已提交
60
  Variable *variable_ptr = program_.scope->Var("batch_size");
H
hjchen2 已提交
61
  variable_ptr->SetValue<int>(batch_size);
62 63

  program_desc_ =
Refine  
陈后江 已提交
64
      use_optimize_ ? program_.optimizeProgram : program_.originProgram;
65 66
  PADDLE_MOBILE_ENFORCE(program_desc_ != nullptr,
                        "program_desc_ should not be nullptr");
C
Chon 已提交
67 68
#if !defined(PADDLE_MOBILE_FPGA) && !defined(PADDLE_MOBILE_FPGA_KD) && \
    !defined(PADDLE_MOBILE_CL)
69 70 71
  if (config_.memory_optimization_level != NoMemoryOptimization) {
    pass::MemoryOptPass()(program_desc_.get(), program_.scope.get(),
                          config_.memory_optimization_level);
Y
Yanzhan Yang 已提交
72
  }
73
#endif
74 75 76 77
  // resize feed and fetch list
  // should init feed and fetch variables before infer shape
  InitFeedFetchList();
  const auto &blocks = program_desc_->Blocks();
78 79 80 81 82 83 84 85
  std::shared_ptr<BlockDesc> block_desc = blocks[0];
  std::vector<std::shared_ptr<OpDesc>> ops = block_desc->Ops();
  for (int j = 0; j < ops.size(); ++j) {
    std::shared_ptr<OpDesc> op_desc = ops[j];
    DLOG << "create op: " << op_desc->Type();

    auto op_handler = OpRegistry<Device>::CreateOp(
        op_desc->Type(), op_desc->GetInputs(), op_desc->GetOutputs(),
86
        op_desc->GetAttrMap(), program_.scope.get());
87 88 89 90
    // infer shape to reshape inputs and outputs before predict,
    // but for lod mode, it still need to infer shape in runtime
    if (!lod_mode) {
      op_handler->InferShape();
W
wangliu 已提交
91
    }
92
    ops_of_block0_.push_back(op_handler);
W
wangliu 已提交
93
  }
94 95 96
#ifdef PADDLE_MOBILE_FPGA_V2
  InitQuantMemory();
#endif
W
wangliu 已提交
97
  if (program_.combined) {
L
liuruilong 已提交
98 99 100 101
    InitCombineMemory();
  } else {
    InitMemory();
  }
102
  int count = 0;
103 104 105
  for (auto &op_handler : ops_of_block0_) {
    DLOG << "Initialize op[" << count++ << "]: " << op_handler->Type();
    op_handler->Init();
L
liuruilong 已提交
106
  }
W
wangliu 已提交
107 108
}

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
template <typename Device, typename T>
void Executor<Device, T>::InitFeedFetchList() {
  std::unordered_map<std::string, int> feed_indices, fetch_indices;
  for (const auto &block : program_desc_->Blocks()) {
    for (const auto &op_desc : block->Ops()) {
      if (op_desc->Type() == "feed") {
        std::string name = op_desc->Output("Out")[0];
        feed_indices[name] = op_desc->GetAttr("col").Get<int>();
      } else if (op_desc->Type() == "fetch") {
        std::string name = op_desc->Input("X")[0];
        fetch_indices[name] = op_desc->GetAttr("col").Get<int>();
      }
    }
  }
  feed_indices_.swap(feed_indices);
  fetch_indices_.swap(fetch_indices);

  auto *feed_var = program_.scope->Var("feed");
  auto *feed_list = feed_var->template GetMutable<framework::LoDTensorArray>();
  feed_list->resize(feed_indices_.size());

  auto *fetch_var = program_.scope->Var("fetch");
  auto *fetch_list =
      fetch_var->template GetMutable<framework::LoDTensorArray>();
  fetch_list->resize(fetch_indices_.size());
}

136
template <typename T>
137
static void LoadMemInternal(void **data, LoDTensor *tensor,
138
                            bool quant_uint8 = false) {
Refine  
陈后江 已提交
139
  char **data_buf = reinterpret_cast<char **>(data);
140
  int64_t size = tensor->numel();
141
  T *tensor_data = tensor->mutable_data<T>();
142 143
  if (quant_uint8) {
    // should be moved into operator init function
144 145
    float min_value;
    float max_value;
146 147 148
    memory::Copy(&min_value, *data_buf, sizeof(float));
    memory::Copy(&max_value, *data_buf + sizeof(float), sizeof(float));
    *data_buf += 2 * sizeof(float);
149
    const float factor = (max_value - min_value) / 255.0;
150
    const uint8_t *uint8_data = reinterpret_cast<uint8_t *>(*data_buf);
151 152
    for (int k = 0; k < size; ++k) {
      tensor_data[k] = uint8_data[k] * factor + min_value;
W
wangliu 已提交
153
    }
154
    *data_buf += size * sizeof(uint8_t);
155
  } else {
156 157
    memory::Copy(tensor_data, *data_buf, size * sizeof(T));
    *data_buf += size * sizeof(T);
L
liuruilong 已提交
158
  }
159
}
W
wangliu 已提交
160

161 162 163 164
template <typename Device, typename T>
void Executor<Device, T>::LoadMemory(void **data,
                                     const std::shared_ptr<VarDesc> var_desc,
                                     LoDTensor *tensor) {
165
  char **data_buf = reinterpret_cast<char **>(data);
166
  // version
167
  uint32_t version = *(reinterpret_cast<uint32_t *>(*data_buf));
Refine  
陈后江 已提交
168
  *data_buf += sizeof(uint32_t);
169
  // lod information
H
hjchen2 已提交
170 171
  // uint64_t lod_level = *(reinterpret_cast<uint64_t *>(*data_buf));
  uint64_t lod_level = 0;
Z
zhangyang 已提交
172
  memory::Copy(&lod_level, *data_buf, sizeof(uint64_t));
Refine  
陈后江 已提交
173
  *data_buf += sizeof(uint64_t);
174 175 176 177

  auto *lod = tensor->mutable_lod();
  lod->resize(lod_level);
  for (uint64_t i = 0; i < lod_level; ++i) {
178
    uint64_t size = *(reinterpret_cast<uint64_t *>(*data_buf));
Refine  
陈后江 已提交
179
    *data_buf += sizeof(uint64_t);
180
    std::vector<size_t> tmp_dim(size / sizeof(size_t));
Z
zhangyang 已提交
181
    memory::Copy(tmp_dim.data(), *data_buf, size);
182
    (*lod)[i] = std::move(tmp_dim);
Refine  
陈后江 已提交
183
    *data_buf += size;
W
wangliu 已提交
184
  }
185
  // tensor version
186
  uint32_t tensor_version = *(reinterpret_cast<uint32_t *>(*data_buf));
Refine  
陈后江 已提交
187
  *data_buf += sizeof(uint32_t);
188
  // tensor desc size
189
  int32_t tensor_desc_size = *(reinterpret_cast<int32_t *>(*data_buf));
Refine  
陈后江 已提交
190
  *data_buf += sizeof(int32_t);
191
  // skip tensor desc
Refine  
陈后江 已提交
192
  *data_buf += tensor_desc_size;
193

194 195
  const TensorDesc &tensor_desc = var_desc->Tensor_desc();
  tensor->Resize(make_ddim(tensor_desc.Dims()));
196 197
  // parse tensor from stream
  switch (tensor_desc.DataType()) {
198
    case VARTYPE_TYPE_FP32:
199 200
      LoadMemInternal<float>(reinterpret_cast<void **>(data_buf), tensor,
                             program_.quantification);
W
wangliu 已提交
201
      break;
202
    case VARTYPE_TYPE_INT8:
203
      LoadMemInternal<int8_t>(reinterpret_cast<void **>(data_buf), tensor);
W
wangliu 已提交
204
      break;
205
    case VARTYPE_TYPE_INT32:
206
      LoadMemInternal<int>(reinterpret_cast<void **>(data_buf), tensor);
W
wangliu 已提交
207 208
      break;
    default:
209
      LOG(kLOG_ERROR) << "data type is not supported";
L
liuruilong 已提交
210
  }
W
wangliu 已提交
211 212
}

213 214 215
template <typename Device, typename T>
void Executor<Device, T>::InitMemory() {
  for (const auto &block : program_desc_->Blocks()) {
W
wangliu 已提交
216 217 218 219
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
H
update  
hjchen2 已提交
220
          var->template GetMutable<framework::LoDTensorArray>();
W
wangliu 已提交
221 222
          continue;
        }
H
hjchen2 已提交
223
        DLOG << "init persistable var: " << var_desc->Name();
Refine  
陈后江 已提交
224
        char *origin_data =
Refine  
陈后江 已提交
225
            ReadFileToBuff(program_.model_path + "/" + var_desc->Name());
Refine  
陈后江 已提交
226
        char *data = origin_data;
H
update  
hjchen2 已提交
227
        auto tensor = var->template GetMutable<LoDTensor>();
228 229
        LoadMemory(reinterpret_cast<void **>(&data), var_desc, tensor);
        delete[] origin_data;
W
wangliu 已提交
230
      } else {
231
        DLOG << "init no persistable var: " << var_desc->Name();
H
update  
hjchen2 已提交
232
        varInputMemory(var_desc, var);
W
wangliu 已提交
233 234 235 236 237
      }
    }
  }
}

238 239
template <typename Device, typename T>
void Executor<Device, T>::InitCombineMemory() {
Refine  
陈后江 已提交
240
  char *origin_data = nullptr;
Refine  
陈后江 已提交
241
  bool self_alloc = false;
242
  if (program_.combined_params_buf && program_.combined_params_len) {
243 244
    origin_data = reinterpret_cast<char *>(
        const_cast<uint8_t *>(program_.combined_params_buf));
245 246 247 248
    if (config_.model_obfuscate_key != "") {
      auto obfuscator = pass::ModelObfuscatePass(config_.model_obfuscate_key);
      obfuscator.convert_data(origin_data, program_.combined_params_len);
    }
249
  } else {
Refine  
陈后江 已提交
250
    self_alloc = true;
Refine  
陈后江 已提交
251
    origin_data = ReadFileToBuff(program_.para_path);
252 253 254 255
    if (config_.model_obfuscate_key != "") {
      auto obfuscator = pass::ModelObfuscatePass(config_.model_obfuscate_key);
      obfuscator.convert_data(origin_data, GetFileLength(program_.para_path));
    }
256
  }
Refine  
陈后江 已提交
257 258
  PADDLE_MOBILE_ENFORCE(origin_data != nullptr, "data == nullptr");
  char *data = origin_data;
259
  for (const auto &block : program_desc_->Blocks()) {
L
liuruilong 已提交
260 261 262 263
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
H
update  
hjchen2 已提交
264
          var->template GetMutable<framework::LoDTensorArray>();
L
liuruilong 已提交
265 266
          continue;
        }
L
liuruilong 已提交
267 268

        DLOG << " init combine memory persistable: " << var_desc->Name();
H
update  
hjchen2 已提交
269
        auto tensor = var->template GetMutable<LoDTensor>();
270
        LoadMemory(reinterpret_cast<void **>(&data), var_desc, tensor);
L
liuruilong 已提交
271
      } else {
H
update  
hjchen2 已提交
272 273
        DLOG << " init combine memory no persistable: " << var_desc->Name();
        varInputMemory(var_desc, var);
L
liuruilong 已提交
274 275 276
      }
    }
  }
Refine  
陈后江 已提交
277
  if (self_alloc) {
278
    delete[] origin_data;
Refine  
陈后江 已提交
279 280
  }
  LOG(kLOG_INFO) << "init combine memory finish";
L
liuruilong 已提交
281
}
282

C
Chon 已提交
283 284 285 286 287 288 289 290 291 292 293 294 295 296
static void ClearNoPersistableTensorArray(const framework::ProgramDesc *program,
                                          framework::Scope *scope) {
  for (const auto &block : program->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      if (!var_desc->Persistable() &&
          var_desc->Type() == VARTYPE_TYPE_STEP_LOD_TENSOR_ARRAY) {
        auto var = scope->Var(var_desc->Name());
        auto array = var->template GetMutable<framework::LoDTensorArray>();
        array->resize(1);
      }
    }
  }
}

297 298 299 300 301 302 303 304 305 306 307 308 309 310
static void ClearNoPersistableTensor(const framework::ProgramDesc *program,
                                     framework::Scope *scope) {
  for (const auto &block : program->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      if (!var_desc->Persistable() &&
          var_desc->Type() == VARTYPE_TYPE_LOD_TENSOR) {
        auto var = scope->Var(var_desc->Name());
        auto target_tensor = var->template GetMutable<framework::LoDTensor>();
        target_tensor->reset();
      }
    }
  }
}

L
liuruilong 已提交
311
template <typename Device, typename T>
L
liuruilong 已提交
312
void Executor<Device, T>::InitNoPersistableMemory(const Tensor &input_tensor) {
L
liuruilong 已提交
313 314 315 316 317 318
  for (const auto &block : program_desc_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      auto tensor = var->template GetMutable<LoDTensor>();
      if (var_desc->Persistable()) {
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
H
update  
hjchen2 已提交
319
          var->template GetMutable<framework::LoDTensorArray>();
L
liuruilong 已提交
320 321 322 323 324
          continue;
        }
      } else {
        if (var_desc->Type() == VARTYPE_TYPE_LOD_TENSOR) {
          DDim tensor_dim = tensor->dims();
xiebaiyuan's avatar
xiebaiyuan 已提交
325 326 327 328
          DDim new_dim =
              make_ddim({tensor_dim[0], tensor_dim[1], input_tensor.dims()[2],
                         input_tensor.dims()[3]});
          tensor->Resize(new_dim);
L
liuruilong 已提交
329
          tensor->template mutable_data<T>();
H
update  
hjchen2 已提交
330 331 332
        } else {
          PADDLE_MOBILE_THROW_EXCEPTION("Unsupported var type `%d`",
                                        var_desc->Type());
L
liuruilong 已提交
333 334 335 336 337 338 339 340 341 342
        }
      }
    }
  }

  std::shared_ptr<LoDTensor> output = GetOutput("fetch");
  output->Resize(input_tensor.dims());
  output->mutable_data<T>();
}

343 344
template <typename Device, typename T>
bool Executor<Device, T>::varInputMemory(
H
update  
hjchen2 已提交
345
    const std::shared_ptr<VarDesc> &var_desc, Variable *var) const {
346
#ifdef PADDLE_MOBILE_FPGA
H
hjchen2 已提交
347
  framework::LoDTensor *tensor = var->template GetMutable<LoDTensor>();
348 349 350
#ifdef PADDLE_MOBILE_FPGA_V2
  tensor->init(type_id<int8_t>().hash_code());
#else
351
  tensor->init(type_id<float>().hash_code());
352
#endif
353 354
  return true;
#endif
H
update  
hjchen2 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367

  auto type = var_desc->Type();
  if (type == VARTYPE_TYPE_LOD_TENSOR) {
    auto data_type = var_desc->Tensor_desc().DataType();
    framework::LoDTensor *tensor = var->template GetMutable<LoDTensor>();
  } else if (type == VARTYPE_TYPE_STEP_SCOPES) {
    std::vector<framework::Scope *> *step_scopes =
        var->template GetMutable<std::vector<framework::Scope *>>();
  } else if (type == VARTYPE_TYPE_STEP_LOD_TENSOR_ARRAY) {
    framework::LoDTensorArray *tensor_array =
        var->template GetMutable<framework::LoDTensorArray>();
  } else {
    PADDLE_MOBILE_THROW_EXCEPTION("got unhandled var type `%d`", type);
xiebaiyuan's avatar
xiebaiyuan 已提交
368
  }
H
update  
hjchen2 已提交
369
  return true;
xiebaiyuan's avatar
xiebaiyuan 已提交
370
}
L
liuruilong 已提交
371

372 373 374 375 376
template <typename Device, typename T>
PMStatus Executor<Device, T>::Predict(
    const std::vector<std::pair<std::string, Tensor>> &inputs) {
  for (const auto &input : inputs) {
    SetInput(input.second, input.first);
D
dolphin8 已提交
377
  }
378 379 380 381 382 383 384 385
  return this->Predict();
}

template <typename Device, typename T>
PMStatus Executor<Device, T>::Predict(
    const std::vector<std::pair<std::string, LoDTensor>> &inputs) {
  for (const auto &input : inputs) {
    SetInput(input.second, input.first);
D
dolphin8 已提交
386
  }
387
  return this->Predict();
W
wangliu 已提交
388
}
xiebaiyuan's avatar
xiebaiyuan 已提交
389

390 391 392
template <typename Device, typename T>
std::vector<T> Executor<Device, T>::Predict(const std::vector<T> &input,
                                            const std::vector<int64_t> &dims) {
393 394 395 396 397 398 399
  PADDLE_MOBILE_ENFORCE(feed_indices_.size() != 0,
                        "We don't know which tensor should be assign, since no "
                        "feed op found in this model");
  PADDLE_MOBILE_ENFORCE(fetch_indices_.size() != 0,
                        "We don't know which tensor should be fetch out, since "
                        "no fetch op found in this model");
  std::string input_name = feed_indices_.begin()->first;
400
  Tensor feed_tensor(input, make_ddim(dims));
401
  SetInput(feed_tensor, input_name);
402 403
  std::vector<T> output;
  if (this->Predict() == PMSuccess) {
404 405
    std::string output_name = fetch_indices_.begin()->first;
    const auto output_tensor = GetOutput(output_name);
406 407 408 409 410 411
    output.resize(output_tensor->numel());
    memcpy(output.data(), output_tensor->template data<T>(),
           output.size() * sizeof(T));
  }
  return output;
}
xiebaiyuan's avatar
xiebaiyuan 已提交
412

413 414 415
template <typename Device, typename T>
void Executor<Device, T>::SetInput(const Tensor &input,
                                   const std::string &var_name) {
H
hjchen2 已提交
416
  int index = 0;
417
  if (feed_indices_.find(var_name) != feed_indices_.end()) {
H
hjchen2 已提交
418
    index = feed_indices_.find(var_name)->second;
419
  }
H
hjchen2 已提交
420 421 422 423 424 425
  auto *feed_var = program_.scope->Var("feed");
  framework::LoDTensor &target =
      feed_var->template GetMutable<framework::LoDTensorArray>()->at(index);

  target.Resize(input.dims());
  target.ShareDataWith(input);
426
  input_dim_cur_ = input.dims();
427
}
xiebaiyuan's avatar
xiebaiyuan 已提交
428

429 430 431
template <typename Device, typename T>
void Executor<Device, T>::SetInput(const LoDTensor &input,
                                   const std::string &var_name) {
H
hjchen2 已提交
432
  int index = 0;
433
  if (feed_indices_.find(var_name) != feed_indices_.end()) {
H
hjchen2 已提交
434
    index = feed_indices_.find(var_name)->second;
435
  }
H
hjchen2 已提交
436 437 438 439 440 441 442
  auto *feed_var = program_.scope->Var("feed");
  framework::LoDTensor &target =
      feed_var->template GetMutable<framework::LoDTensorArray>()->at(index);

  target.Resize(input.dims());
  target.ShareDataWith(input);
  target.set_lod(input.lod());
443 444 445 446 447
}

template <typename Device, typename T>
std::shared_ptr<LoDTensor> Executor<Device, T>::GetOutput(
    const std::string &var_name) {
448 449 450 451 452 453 454 455 456
  const auto &iter = fetch_indices_.find(var_name);
  if (var_name == "fetch" || iter != fetch_indices_.end()) {
    int index = 0;
    if (iter != fetch_indices_.end()) {
      index = iter->second;
    }
    auto *fetch_var = program_.scope->Var("fetch");
    framework::LoDTensor &target =
        fetch_var->template GetMutable<framework::LoDTensorArray>()->at(index);
H
hjchen2 已提交
457

458 459 460 461 462 463 464
    return std::make_shared<LoDTensor>(target);
  } else {
    auto *fetch_var = program_.scope->Var(var_name);
    framework::LoDTensor *target =
        fetch_var->template GetMutable<framework::LoDTensor>();
    return std::make_shared<LoDTensor>(*target);
  }
465
}
xiebaiyuan's avatar
xiebaiyuan 已提交
466

467 468
template <typename Device, typename T>
PMStatus Executor<Device, T>::Predict() {
469
#if _OPENMP
470
  omp_set_num_threads(CPUContext::Context()->get_thread_num());
471
#endif
472 473 474 475
  // clear all no persistable tensor array since write_to_array
  // is always push back a new tensor in the array
  ClearNoPersistableTensorArray(program_desc_.get(), program_.scope.get());

476 477 478 479 480 481 482 483 484 485
  // in lod_mode_, free no persistable memery when input changes smaller.
  if (lod_mode_) {
    if (product(input_dim_cur_) <= 0.7 * product(input_dim_last_)) {
      ClearNoPersistableTensor(program_desc_.get(), program_.scope.get());
      input_dim_last_ = input_dim_cur_;
    } else if (product(input_dim_cur_) > product(input_dim_last_)) {
      input_dim_last_ = input_dim_cur_;
    }
  }

xiebaiyuan's avatar
xiebaiyuan 已提交
486
#ifdef PADDLE_MOBILE_PROFILE
487
  std::vector<ProfInfo> profile(ops_of_block0_.size());
488 489
  struct timespec ts;
  int op_index = 0;
xiebaiyuan's avatar
xiebaiyuan 已提交
490
#endif
491
  for (auto &op_handler : ops_of_block0_) {
xiebaiyuan's avatar
xiebaiyuan 已提交
492
#ifdef PADDLE_MOBILE_PROFILE
493 494
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[op_index].runBegin = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
xiebaiyuan's avatar
xiebaiyuan 已提交
495
#endif
H
hjchen2 已提交
496
    DLOG << "run op: " << op_handler->Type();
497 498 499 500
    if (lod_mode_) {
      op_handler->InferShape();
    }
    op_handler->Run();
xiebaiyuan's avatar
xiebaiyuan 已提交
501
#ifdef PADDLE_MOBILE_PROFILE
502 503 504
    clock_gettime(CLOCK_MONOTONIC, &ts);
    profile[op_index].runEnd = (uint64_t)ts.tv_sec * 1e9 + ts.tv_nsec;
    ++op_index;
xiebaiyuan's avatar
xiebaiyuan 已提交
505 506
#endif
  }
507 508 509 510 511 512 513

#ifdef PADDLE_MOBILE_PROFILE
  PrintProfile(profile);
#endif
  return PMSuccess;
}

xiebaiyuan's avatar
xiebaiyuan 已提交
514
#ifdef PADDLE_MOBILE_PROFILE
515 516 517
template <typename Device, typename T>
void Executor<Device, T>::PrintProfile(
    const vector<Executor<Device, T>::ProfInfo> &profile) const {
xiebaiyuan's avatar
xiebaiyuan 已提交
518 519 520 521
  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;
522 523 524 525 526 527
    if (this->ops_of_block0_[i]->Type() == "conv2d" ||
        this->ops_of_block0_[i]->Type() == "depthwise_conv2d") {
      auto inputs = this->ops_of_block0_[i]->Inputs();

      auto *filter = GetVarValue<ProfileTensorType>("Filter", inputs,
                                                    *(this->program_.scope));
528
      int kernel_size = filter->dims()[2];
529 530
      _tp[this->ops_of_block0_[i]->Type() + "_" +
          std::to_string(kernel_size)] += timeCost;
531
    } else {
532
      _tp[this->ops_of_block0_[i]->Type()] += timeCost;
533
    }
xiebaiyuan's avatar
xiebaiyuan 已提交
534
  }
H
hjchen2 已提交
535
  printf("====================[ profile ]======================\n");
536
  typedef std::pair<std::string, uint64_t> prof_t;
xiebaiyuan's avatar
xiebaiyuan 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
  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);
  }
H
hjchen2 已提交
552
  printf("====================[---------]======================\n");
xiebaiyuan's avatar
xiebaiyuan 已提交
553
}
554
#endif
xiebaiyuan's avatar
xiebaiyuan 已提交
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
template <typename Device, typename T>
void Executor<Device, T>::FeedTensorData(const vector<framework::Tensor> &v) {
  auto input_size = v.size();
  auto *feed_var = program_.scope->Var("feed");

  PADDLE_MOBILE_ENFORCE(input_size == feed_indices_.size(),
                        "input data number not correct");
  for (int i = 0; i < input_size; i++) {
    framework::LoDTensor &target =
        feed_var->template GetMutable<framework::LoDTensorArray>()->at(i);
    target.ShareDataWith(v[input_size - i - 1]);
  }
}

template <typename Device, typename T>
void Executor<Device, T>::GetTensorResults(
    std::vector<framework::Tensor *> *v) {
  auto *fetch_var = program_.scope->Var("fetch");
  auto output_size = fetch_indices_.size();
  for (int i = 0; i < output_size; i++) {
    framework::LoDTensor &target =
        fetch_var->template GetMutable<framework::LoDTensorArray>()->at(i);
    v->push_back(&target);
  }
}

582
#ifdef PADDLE_MOBILE_FPGA
583 584 585 586
template <typename Device, typename T>
void Executor<Device, T>::InjectVariable(const Tensor &t,
                                         std::string var_name) {
  Variable *g_feed_value = program_.scope->Var(var_name);
587
  Tensor *feed_tensor = g_feed_value->template GetMutable<LoDTensor>();
588 589
  feed_tensor->Resize(t.dims());
  feed_tensor->ShareDataWith(t);
590
}
591

592 593
template <typename Device, typename T>
void Executor<Device, T>::FeedData(const Tensor &t) {
Z
zhangyang0701 已提交
594
  InjectVariable(t, "feed0");
595
}
596

597
template <typename Device, typename T>
598
void Executor<Device, T>::FeedData(const std::vector<void *> &v) {
599
  auto input_size = v.size();
Z
zhangyang0701 已提交
600
  int index = 0;
601 602 603
  // auto vars = program_.scope->VarContain("feed", &index);
  // PADDLE_MOBILE_ENFORCE(input_size == vars.size(),
  //                    "input data number not correct");
604
  for (int i = 0; i < input_size; i++) {
Z
zhangyang0701 已提交
605
    auto var = program_.scope->Var("feed", i + index);
606 607 608 609 610 611 612 613 614
    auto feed_tensor = var->template GetMutable<LoDTensor>();
    feed_tensor->external_data = v[i];
  }
}

template <typename Device, typename T>
void Executor<Device, T>::GetResults(std::vector<void *> *v) {
  auto output_size = v->size();
  PADDLE_MOBILE_ENFORCE(output_size > 0, "Empty output");
Z
zhangyang0701 已提交
615 616
  int index = 0;
  auto vars = program_.scope->VarContain("fetch", &index);
617 618
  PADDLE_MOBILE_ENFORCE(output_size == vars.size(),
                        "output data number not correct");
619

620
  for (int i = 0; i < output_size; i++) {
Z
zhangyang0701 已提交
621
    auto var = program_.scope->Var("fetch", i + index);
622 623
    auto fetch_tensor = var->template GetMutable<LoDTensor>();
    (*v)[i] = fetch_tensor->template data<float>();
624
  }
625
}
626

627
template <typename Device, typename T>
628 629 630 631
framework::Tensor *Executor<Device, T>::GetTensorByName(
    const std::string &name) {
  auto var = program_.scope->Var(name);
  return var->template GetMutable<LoDTensor>();
H
hjchen2 已提交
632
}
633

634 635
template <typename Device, typename T>
std::shared_ptr<Tensor> Executor<Device, T>::FetchResult(int id) {
636
  auto &ops = ops_of_block0_;
637

Z
zhangyang 已提交
638 639 640 641 642
  PADDLE_MOBILE_ENFORCE(id < (int)ops.size(), "Index out of range");
  auto op = id < 0 ? ops[ops.size() - 1] : ops[id];
  auto output_map = op->Outputs();
  std::vector<std::string> out_keys = op->GetOutKeys();
  PADDLE_MOBILE_ENFORCE(!out_keys.empty(), "this op contains no output");
643 644 645
  auto *output_tensor =
      GetVarValue<LoDTensor>(out_keys[0], output_map, *(program_.scope));
  return std::make_shared<Tensor>(Tensor(*output_tensor));
646
}
647

648 649
template <typename Device, typename T>
void Executor<Device, T>::Predict_From_To(int start, int end) {
650
  auto &ops = ops_of_block0_;
651
  end = end < 0 ? static_cast<int>(ops.size()) : end;
652 653 654 655 656 657 658 659 660 661 662 663
  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 已提交
664
    DLOG << "Running op: " << i << "  " << ops[i]->Type();
665 666 667 668 669 670 671
    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
  }
672
}
673

674 675
template <typename Device, typename T>
void Executor<Device, T>::Predict_From(int start) {
676
  Predict_From_To(start);
677
}
678

679 680
template <typename Device, typename T>
void Executor<Device, T>::Predict_To(int end) {
681
  Predict_From_To(0, end);
682
}
683 684 685 686 687 688
#ifdef PADDLE_MOBILE_FPGA_V2
std::map<std::string, float> LoadQuantValFromFile(std::string filename) {
  std::map<std::string, float> quantValList;
  std::ifstream in;
  in.open(filename, std::ios::in);
  if (!in.is_open()) {
689 690
    // std::cout << "open File Failed." << std::endl;
    DLOG << "open File Failed.";
691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
    exit(-1);
  }

  std::string line;
  while (getline(in, line)) {
    std::string splitStr = " : ";
    std::string::size_type pos;
    pos = line.find(splitStr);
    std::string subStr[2];
    subStr[0] = line.substr(0, pos);
    subStr[1] = line.substr(pos + splitStr.size(), line.size());
    quantValList.insert(std::make_pair(subStr[0], atof(subStr[1].c_str())));
  }
  in.close();
  return quantValList;
}
707

708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
template <typename Device, typename T>
void Executor<Device, T>::InitQuantMemory() {
  std::string quantValFilePath;
  if (program_.combined) {
    quantValFilePath = program_.para_path;
    quantValFilePath =
        quantValFilePath.substr(0, (quantValFilePath.length() - 6));
    quantValFilePath = quantValFilePath + "scale";
  } else {
    quantValFilePath = program_.model_path + "/scale";
  }
  std::map<std::string, float> quantValList =
      LoadQuantValFromFile(quantValFilePath);
  auto ops = ops_of_block0_;
  for (int id = 0; id < ops.size(); id++) {
    auto op = ops[id];
    auto input_keys = op->GetInputKeys();
    auto inputs = op->Inputs();
    for (auto key = input_keys.begin(); key != input_keys.end(); key++) {
      auto inputs_vars = inputs[*key];
      int count = inputs_vars.size();
      for (int i = 0; i < count; i++) {
730 731 732 733 734 735
        if (inputs_vars[i] != "feed") {
          auto tensor = GetTensorByName(inputs_vars[i]);
          tensor->scale[0] = quantValList[inputs_vars[i]];
          DLOG << "input variance name : " << inputs_vars[i]
               << ", scale value : " << tensor->scale[0];
        }
736 737 738 739 740 741 742 743
      }
    }
    auto output_keys = op->GetOutKeys();
    auto outputs = op->Outputs();
    for (auto key = output_keys.begin(); key != output_keys.end(); key++) {
      auto outputs_vars = outputs[*key];
      int count = outputs_vars.size();
      for (int i = 0; i < count; i++) {
744 745 746 747 748 749
        if (outputs_vars[i] != "fetch") {
          auto tensor = GetTensorByName(outputs_vars[i]);
          tensor->scale[0] = quantValList[outputs_vars[i]];
          DLOG << "output variance name : " << outputs_vars[i]
               << ", scale value : " << tensor->scale[0];
        }
750 751 752 753 754 755
      }
    }
  }
}
#endif
#endif
Y
yangfei 已提交
756
#ifdef PADDLE_MOBILE_CL
xiebaiyuan's avatar
xiebaiyuan 已提交
757 758
template <>
void Executor<GPU_CL, float>::InitNoPersistableMemory(
759
    const Tensor &input_tensor) {
xiebaiyuan's avatar
xiebaiyuan 已提交
760 761 762 763 764 765 766
  DLOG << "CL InitNoPersistableMemory ";
  for (const auto &block : program_desc_->Blocks()) {
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());

      if (var_desc->Persistable()) {
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
767
          var->template GetMutable<framework::LoDTensorArray>();
xiebaiyuan's avatar
xiebaiyuan 已提交
768 769 770 771
          continue;
        }
      } else {
        if (var_desc->Type() == VARTYPE_TYPE_LOD_TENSOR) {
772
          auto cl_image = var->template GetMutable<CLImage>();
xiebaiyuan's avatar
xiebaiyuan 已提交
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790
          cl_context context = program_.scope->GetCLScpoe()->Context();
          cl_command_queue command_queue =
              program_.scope->GetCLScpoe()->CommandQueue();

          DDim tensor_dim = cl_image->dims();
          DDim new_dim =
              make_ddim({tensor_dim[0], tensor_dim[1], input_tensor.dims()[2],
                         input_tensor.dims()[3]});
          cl_image->Resize(new_dim);
          cl_image->InitEmptyImage(context, command_queue, new_dim);
        }
      }
    }
  }
  std::shared_ptr<LoDTensor> output = GetOutput("fetch");
  output->Resize(input_tensor.dims());
  output->mutable_data<float>();
}
H
hjchen2 已提交
791

xiebaiyuan's avatar
xiebaiyuan 已提交
792 793 794
template <>
void Executor<GPU_CL, float>::SetInput(const Tensor &input,
                                       const std::string &var_name) {
H
hjchen2 已提交
795 796 797 798 799 800 801
  int index = 0;
  if (feed_indices_.find(var_name) != feed_indices_.end()) {
    index = feed_indices_.find(var_name)->second;
  }
  auto *feed_var = program_.scope->Var("feed");
  framework::LoDTensor *target_tensor =
      &(feed_var->template GetMutable<framework::LoDTensorArray>()->at(index));
xiebaiyuan's avatar
xiebaiyuan 已提交
802 803 804 805 806

  DLOG << "config_.load_when_predict   " << config_.load_when_predict;
  DLOG << "target_tensor->IsInitialized() " << target_tensor->IsInitialized();
  DLOG << "target_tensor->dims()   " << target_tensor->dims();
  DLOG << "input.dims()   " << input.dims();
807
  DLOG << "input_dim_last_   " << input_dim_last_;
xiebaiyuan's avatar
xiebaiyuan 已提交
808
  if (config_.load_when_predict) {
xiebaiyuan's avatar
xiebaiyuan 已提交
809
    if (input_dim_last_ != input.dims()) {
810 811 812
      DLOG << "SetInput ---- > resize1";
      target_tensor->Resize(input.dims());
      target_tensor->mutable_data<float>();
xiebaiyuan's avatar
xiebaiyuan 已提交
813 814 815 816 817 818 819 820
      InitNoPersistableMemory(*target_tensor);
    }
  } else {
    DLOG << "SetInput ---- > resize2";
    target_tensor->Resize(input.dims());
    DLOG << "SetInput ---- > ShareDataWith";
  }
  target_tensor->ShareDataWith(input);
821 822
  auto &dim = input.dims();
  input_dim_last_ = static_cast<DDim>(dim);
xiebaiyuan's avatar
xiebaiyuan 已提交
823 824
}

825 826 827
template <typename Device, typename T>
void Executor<Device, T>::LoadMemory(const VarDesc var_desc, float *tensorInput,
                                     char **data) {}
L
liuruilong 已提交
828

Y
yangfei 已提交
829
template <>
H
hjchen2 已提交
830 831
void Executor<GPU_CL, float>::LoadMemory(const VarDesc var_desc,
                                         float *tensorInput, char **data) {
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
  // 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);

869
  const TensorDesc &desc = var_desc.Tensor_desc();
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
  int memory_size = 1;
  for (auto l : desc.Dims()) {
    memory_size *= l;
  }

  void *memory = nullptr;
  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);
  }
}
904

Y
yangfei 已提交
905
template <>
906 907
void Executor<GPU_CL, float>::InitMemory() {
  for (const auto &block : program_desc_->Blocks()) {
Y
yangfei 已提交
908 909 910
    for (const auto &var_desc : block->Vars()) {
      auto var = program_.scope->Var(var_desc->Name());
      if (var_desc->Persistable()) {
L
liuruilong 已提交
911
        CLImage *cl_image = nullptr;
Y
yangfei 已提交
912
        if (var_desc->Name() == "feed" || var_desc->Name() == "fetch") {
H
hjchen2 已提交
913
          var->template GetMutable<framework::LoDTensorArray>();
Y
yangfei 已提交
914
          continue;
L
liuruilong 已提交
915
        } else {
916
          cl_image = var->template GetMutable<CLImage>();
Y
yangfei 已提交
917
        }
L
liuruilong 已提交
918

Y
yangfei 已提交
919
        char *origin_data =
L
liuruilong 已提交
920
            ReadFileToBuff(program_.model_path + "/" + var_desc->Name());
921
        char *data = origin_data;
Y
yangfei 已提交
922
        cl_context context = program_.scope->GetCLScpoe()->Context();
923
        const TensorDesc &desc = var_desc->Tensor_desc();
924 925 926 927 928
        int numel = 1;
        for (auto l : desc.Dims()) {
          numel *= l;
        }
        DLOG << var_desc->Name();
Y
yangfei 已提交
929
        float *tensorInput = static_cast<float *>(
930 931
            paddle_mobile::memory::Alloc(sizeof(float) * numel));
        LoadMemory(*var_desc, tensorInput, &data);
Y
yangfei 已提交
932

933
        DDim ddim = make_ddim(desc.Dims());
Y
yangfei 已提交
934

L
liuruilong 已提交
935 936
        // has not init
        cl_image->SetTensorData(tensorInput, ddim);
Y
yangfei 已提交
937

938
        delete origin_data;
Y
yangfei 已提交
939
        paddle_mobile::memory::Free(tensorInput);
940
      } else {
941 942
        if (var_desc->Type() == VARTYPE_TYPE_LOD_TENSOR) {
          auto cl_image = var->template GetMutable<CLImage>();
943
          cl_context context = program_.scope->GetCLScpoe()->Context();
L
liuruilong 已提交
944 945
          cl_command_queue command_queue =
              program_.scope->GetCLScpoe()->CommandQueue();
Y
yangfei 已提交
946

947 948 949
          const TensorDesc &desc = var_desc->Tensor_desc();
          //          DDim ddim = make_ddim(desc.Dims());
          DDim ddim = cl_image->dims();
950
          DLOG << var_desc->Name();
L
liuruilong 已提交
951
          cl_image->InitEmptyImage(context, command_queue, ddim);
952
        }
Y
yangfei 已提交
953 954 955 956
      }
    }
  }
}
957

Y
yangfei 已提交
958
template <>
959
void Executor<GPU_CL, float>::InitCombineMemory() {
xiebaiyuan's avatar
xiebaiyuan 已提交
960 961
  DLOG << "CL InitCombineMemory---- "
       << "config_.load_when_predict: " << config_.load_when_predict;
Y
yangfei 已提交
962 963
  char *origin_data = nullptr;
  bool self_alloc = false;
Y
yangfei 已提交
964 965
  if (program_.combined_params_buf && program_.combined_params_len) {
    LOG(kLOG_INFO) << "use outter memory";
966
    origin_data = reinterpret_cast<char *>(program_.combined_params_buf);
967 968 969 970
    if (config_.model_obfuscate_key != "") {
      auto obfuscator = pass::ModelObfuscatePass(config_.model_obfuscate_key);
      obfuscator.convert_data(origin_data, program_.combined_params_len);
    }
Y
yangfei 已提交
971 972
  } else {
    LOG(kLOG_INFO) << " begin init combine memory";
Y
yangfei 已提交
973
    self_alloc = true;
L
liuruilong 已提交
974
    origin_data = ReadFileToBuff(program_.para_path);
975 976 977 978
    if (config_.model_obfuscate_key != "") {
      auto obfuscator = pass::ModelObfuscatePass(config_.model_obfuscate_key);
      obfuscator.convert_data(origin_data, GetFileLength(program_.para_path));
    }
Y
yangfei 已提交
979 980
  }
  PADDLE_MOBILE_ENFORCE(origin_data != nullptr, "origin_data==nullptr!!!");
981
  float *data = reinterpret_cast<float *>(origin_data);
Y
yangfei 已提交
982

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

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

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

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

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

1011 1012
        paddle_mobile::memory::Free(tensorInput);
      } else {
1013
        auto cl_image = var->template GetMutable<CLImage>();
Y
yangfei 已提交
1014
        cl_context context = program_.scope->GetCLScpoe()->Context();
L
liuruilong 已提交
1015 1016
        cl_command_queue command_queue =
            program_.scope->GetCLScpoe()->CommandQueue();
1017 1018
        const TensorDesc &desc = var_desc->Tensor_desc();
        DDim ddim = cl_image->dims();
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
        bool shouldResize = true;
        if (ddim.size() > 4) {
          for (int i = 0; i < ddim.size() - 4; ++i) {
            if (ddim[i] != 0) {
              shouldResize = false;
              break;
            }
          }
          if (shouldResize) {
            std::vector<int64_t> temp_intput_dims;
            temp_intput_dims.reserve(static_cast<size_t>(4));
            for (int i = ddim.size() - 4; i < ddim.size(); ++i) {
              temp_intput_dims.push_back(ddim[i]);
            }
            ddim = framework::make_ddim(temp_intput_dims);
          }
        }
1036
        //  DDim ddim = make_ddim(desc.Dims());
L
liuruilong 已提交
1037
        cl_image->InitEmptyImage(context, command_queue, ddim);
Y
yangfei 已提交
1038 1039 1040
      }
    }
  }
Y
yangfei 已提交
1041
  if (self_alloc) {
1042
    delete data;
Y
yangfei 已提交
1043
  }
Y
yangfei 已提交
1044
  LOG(kLOG_INFO) << " end init combine memory ";
1045
}
Y
yangfei 已提交
1046 1047 1048

#endif

1049
template class Executor<CPU, float>;
Y
yangfei 已提交
1050

1051
template class Executor<FPGA, float>;
W
wangliu 已提交
1052

1053
template class Executor<GPU_CL, float>;
Y
yangfei 已提交
1054

1055
template class Executor<GPU_MALI, float>;
Y
yangfei 已提交
1056 1057

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