test_serde.cc 6.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/* Copyright (c) 2016 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. */

#include <unistd.h>
#include <string>
#include <thread>

19
#include <google/protobuf/text_format.h>
20 21 22 23 24
#include "gtest/gtest.h"
#include "paddle/fluid/framework/lod_tensor.h"
#include "paddle/fluid/framework/tensor_util.h"
#include "paddle/fluid/framework/variable.h"
#include "paddle/fluid/operators/detail/sendrecvop_utils.h"
25
#include "paddle/fluid/operators/detail/variable_response.h"
26 27 28 29 30 31 32 33 34 35
#include "paddle/fluid/operators/math/math_function.h"
#include "paddle/fluid/platform/place.h"
#include "paddle/fluid/string/printf.h"

namespace framework = paddle::framework;
namespace platform = paddle::platform;
namespace operators = paddle::operators;
namespace math = paddle::operators::math;
namespace memory = paddle::memory;

36
void RunSerdeTestSelectedRows(platform::Place place) {
37 38
  platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance();
  auto& ctx = *pool.Get(place);
39 40 41 42 43 44 45

  // serialize var to ByteBuffer
  framework::Variable var;
  auto* slr = var.GetMutable<framework::SelectedRows>();
  auto* tensor = slr->mutable_value();
  auto* rows = slr->mutable_rows();
  tensor->Resize(framework::make_ddim({2, 10}));
46
  tensor->mutable_data<float>(place);
47 48 49 50
  int tensor_numel = 2 * 10;
  math::set_constant(ctx, tensor, 32.7);
  rows->push_back(3);
  rows->push_back(10);
51 52 53 54 55 56 57 58 59 60 61 62

  ::grpc::ByteBuffer msg;
  operators::detail::SerializeToByteBuffer("myvar", &var, ctx, &msg);
  EXPECT_GT(msg.Length(), 0);

  // deserialize
  std::vector<::grpc::Slice> slices;
  (void)msg.Dump(&slices);
  std::string tmp;
  for (const auto& s : slices) {
    tmp.append(reinterpret_cast<const char*>(s.begin()), s.size());
  }
63

64 65
  sendrecv::VariableMessage varmsg;
  EXPECT_TRUE(varmsg.ParseFromString(tmp));
66

67
  EXPECT_EQ(varmsg.varname(), "myvar");
68
  EXPECT_EQ(varmsg.type(), 1);
69 70 71

  const float* tensor_data =
      reinterpret_cast<const float*>(varmsg.serialized().data());
72 73
  const int64_t* rows_data =
      reinterpret_cast<const int64_t*>(varmsg.rows().data());
74
  for (int i = 0; i < tensor_numel; ++i) {
75
    EXPECT_FLOAT_EQ(tensor_data[i], 32.7);
76
  }
77 78
  EXPECT_EQ(rows_data[0], 3);
  EXPECT_EQ(rows_data[1], 10);
79
  // deserialize zero-copy
80 81 82 83
  // framework::Variable var2;
  // operators::detail::DeserializeFromByteBuffer(msg, ctx, &var2);
  framework::Scope scope;
  scope.Var("myvar");
Y
Yancey 已提交
84
  operators::detail::VariableResponse resp(&scope, &ctx);
85 86 87 88 89 90 91
  EXPECT_EQ(resp.Parse(msg), 0);

  framework::Variable* var2 = resp.GetVar();

  auto* slr2 = var2->GetMutable<framework::SelectedRows>();
  auto* tensor2 = slr2->mutable_value();
  auto* rows2 = slr2->mutable_rows();
92 93 94 95 96
  float* tensor_data2 = nullptr;
  framework::Tensor tmp_tensor;

  if (platform::is_gpu_place(ctx.GetPlace())) {
    platform::CPUPlace cpu;
97
    framework::TensorCopy(*tensor2, cpu, &tmp_tensor);
98 99
    tensor_data2 = tmp_tensor.data<float>();
  } else {
100
    tensor_data2 = const_cast<float*>(tensor2->data<float>());
101
  }
102
  const int64_t* rows_data2 = rows2->data();
103

104 105 106 107 108
  for (int i = 0; i < tensor_numel; ++i) {
    EXPECT_FLOAT_EQ(tensor_data2[i], 32.7);
  }
  EXPECT_EQ(rows_data2[0], 3);
  EXPECT_EQ(rows_data2[1], 10);
109 110
}

111
void RunTestLodTensor(platform::Place place, int from_type = 0) {
112 113
  // serialize var to ByteBuffer
  framework::Variable var;
114 115 116 117 118 119 120 121
  auto* tensor = var.GetMutable<framework::LoDTensor>();
  tensor->Resize(framework::make_ddim({4, 8, 4, 2}));
  framework::LoD lod;
  lod.push_back(framework::Vector<size_t>({1, 3, 8}));
  tensor->set_lod(lod);
  int tensor_numel = 4 * 8 * 4 * 2;
  platform::DeviceContextPool& pool = platform::DeviceContextPool::Instance();
  auto& ctx = *pool.Get(place);
122
  tensor->mutable_data<float>(place);
123
  math::set_constant(ctx, tensor, 31.9);
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

  ::grpc::ByteBuffer msg;
  operators::detail::SerializeToByteBuffer("myvar", &var, ctx, &msg);
  EXPECT_GT(msg.Length(), 0);

  // deserialize
  std::vector<::grpc::Slice> slices;
  (void)msg.Dump(&slices);
  std::string tmp;
  for (const auto& s : slices) {
    tmp.append(reinterpret_cast<const char*>(s.begin()), s.size());
  }
  sendrecv::VariableMessage varmsg;
  EXPECT_TRUE(varmsg.ParseFromString(tmp));
  EXPECT_EQ(varmsg.varname(), "myvar");
139 140 141 142 143 144 145 146 147
  EXPECT_EQ(varmsg.type(), 0);
  EXPECT_EQ(varmsg.dims()[0], 4);
  EXPECT_EQ(varmsg.dims()[1], 8);
  EXPECT_EQ(varmsg.dims()[2], 4);
  EXPECT_EQ(varmsg.dims()[3], 2);
  EXPECT_EQ(varmsg.lod_level(), 1);
  EXPECT_EQ(varmsg.lod(0).lod_data(0), 1);
  EXPECT_EQ(varmsg.lod(0).lod_data(1), 3);
  EXPECT_EQ(varmsg.lod(0).lod_data(2), 8);
148 149 150 151

  const float* tensor_data =
      reinterpret_cast<const float*>(varmsg.serialized().data());
  for (int i = 0; i < tensor_numel; ++i) {
152
    EXPECT_FLOAT_EQ(tensor_data[i], 31.9);
153
  }
154 155 156 157 158 159 160 161 162 163 164 165

  // message binary
  std::string str;
  varmsg.SerializeToString(&str);

  // message bytebuffer
  ::grpc::Slice slices_2[1];
  int num_slices = 1;
  slices_2[0] = ::grpc::Slice(str.length());
  memcpy(const_cast<uint8_t*>(slices_2[0].begin()), str.c_str(), str.length());
  ::grpc::ByteBuffer bytebuffer2(&slices_2[0], num_slices);

166
  // deserialize zero-copy
167 168
  framework::Scope scope;
  scope.Var("myvar");
Y
Yancey 已提交
169
  operators::detail::VariableResponse resp(&scope, &ctx);
170 171 172 173 174
  if (from_type == 0) {
    EXPECT_EQ(resp.Parse(msg), 0);
  } else {
    EXPECT_EQ(resp.Parse(bytebuffer2), 0);
  }
175

176 177 178
  framework::Variable* var2 = resp.GetVar();

  auto tensor2 = var2->Get<framework::LoDTensor>();
179 180 181 182 183
  float* tensor_data2 = nullptr;
  framework::Tensor tmp_tensor;

  if (platform::is_gpu_place(ctx.GetPlace())) {
    platform::CPUPlace cpu;
184
    framework::TensorCopy(tensor2, cpu, &tmp_tensor);
185 186
    tensor_data2 = tmp_tensor.data<float>();
  } else {
187
    tensor_data2 = const_cast<float*>(tensor2.data<float>());
188 189
  }

190 191 192 193 194 195 196
  EXPECT_EQ(varmsg.lod_level(), 1);
  EXPECT_EQ(varmsg.lod(0).lod_data(0), 1);
  EXPECT_EQ(varmsg.lod(0).lod_data(1), 3);
  EXPECT_EQ(varmsg.lod(0).lod_data(2), 8);
  for (int i = 0; i < tensor_numel; ++i) EXPECT_FLOAT_EQ(tensor_data2[i], 31.9);
}

Y
Yancey 已提交
197 198
TEST(LodTensor, Run) {
  platform::CPUPlace place;
199 200
  RunTestLodTensor(place);
  RunTestLodTensor(place, 1);
Y
Yancey 已提交
201 202
#ifdef PADDLE_WITH_CUDA
  platform::CUDAPlace place;
203 204
  RunTestLodTensor(place);
  RunTestLodTensor(place, 1);
Y
Yancey 已提交
205
#endif
206 207
}

Y
Yancey 已提交
208
TEST(SelectedRows, Run) {
209 210
  platform::CPUPlace place;
  RunSerdeTestSelectedRows(place);
211

Y
Yancey 已提交
212
#ifdef PADDLE_WITH_CUDA
213 214
  platform::CUDAPlace place;
  RunSerdeTestSelectedRows(place);
Y
Yancey 已提交
215
#endif
216
}