op_registry_test.cc 11.9 KB
Newer Older
D
dzhwinter 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

   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. */

D
dzhwinter 已提交
15
#include <glog/logging.h>
16
#include <gtest/gtest.h>
Q
Qiao Longfei 已提交
17

D
dzhwinter 已提交
18 19
#include "paddle/framework/op_registry.h"

20 21
namespace pd = paddle::framework;

22 23
namespace paddle {
namespace framework {
D
dzhwinter 已提交
24

Y
Yu Yang 已提交
25
class CosineOp : public OperatorBase {
26
 public:
Y
Yu Yang 已提交
27
  using OperatorBase::OperatorBase;
D
dzhwinter 已提交
28
  void Run(const Scope& scope, const platform::Place& place) const override {}
29 30 31 32 33 34 35 36 37 38
};

class CosineOpProtoAndCheckerMaker : public OpProtoAndCheckerMaker {
 public:
  CosineOpProtoAndCheckerMaker(OpProto* proto, OpAttrChecker* op_checker)
      : OpProtoAndCheckerMaker(proto, op_checker) {
    AddInput("input", "input of cosine op");
    AddOutput("output", "output of cosine op");
    AddAttr<float>("scale", "scale of cosine op")
        .SetDefault(1.0)
F
fengjiayi 已提交
39
        .GreaterThan(0.0);
40 41 42 43
    AddComment("This is cos op");
  }
};

Y
Yu Yang 已提交
44 45
class MyTestOp : public OperatorBase {
 public:
Y
Yu Yang 已提交
46
  using OperatorBase::OperatorBase;
D
dzhwinter 已提交
47
  void Run(const Scope& scope, const platform::Place& place) const override {}
48 49 50 51 52 53
};

class MyTestOpProtoAndCheckerMaker : public OpProtoAndCheckerMaker {
 public:
  MyTestOpProtoAndCheckerMaker(OpProto* proto, OpAttrChecker* op_checker)
      : OpProtoAndCheckerMaker(proto, op_checker) {
Y
Yu Yang 已提交
54 55
    AddInput("input", "input of cosine op").AsDuplicable();
    AddOutput("output", "output of cosine op").AsIntermediate();
56 57 58 59 60 61 62 63 64 65 66
    auto my_checker = [](int i) {
      PADDLE_ENFORCE(i % 2 == 0, "'test_attr' must be even!");
    };
    AddAttr<int>("test_attr", "a simple test attribute")
        .AddCustomChecker(my_checker);
    AddComment("This is my_test op");
  }
};
}  // namespace framework
}  // namespace paddle

Y
Yu Yang 已提交
67 68
static void BuildVar(const std::string& param_name,
                     std::initializer_list<const char*> arguments,
69
                     paddle::framework::proto::OpDesc::Var* var) {
Y
Yu Yang 已提交
70 71
  var->set_parameter(param_name);
  for (auto& arg_name : arguments) {
Y
Yu Yang 已提交
72
    var->add_arguments(arg_name);
Y
Yu Yang 已提交
73 74
  }
}
F
fengjiayi 已提交
75 76 77 78
REGISTER_OP_WITHOUT_GRADIENT(cos_sim, paddle::framework::CosineOp,
                             paddle::framework::CosineOpProtoAndCheckerMaker);
REGISTER_OP_WITHOUT_GRADIENT(my_test_op, paddle::framework::MyTestOp,
                             paddle::framework::MyTestOpProtoAndCheckerMaker);
Y
Yu Yang 已提交
79

80
TEST(OpRegistry, CreateOp) {
81
  paddle::framework::proto::OpDesc op_desc;
82
  op_desc.set_type("cos_sim");
Y
Yu Yang 已提交
83 84
  BuildVar("input", {"aa"}, op_desc.add_inputs());
  BuildVar("output", {"bb"}, op_desc.add_outputs());
85

Q
Qiao Longfei 已提交
86
  float scale = 3.3;
87 88
  auto attr = op_desc.mutable_attrs()->Add();
  attr->set_name("scale");
89
  attr->set_type(paddle::framework::proto::AttrType::FLOAT);
Q
Qiao Longfei 已提交
90
  attr->set_f(scale);
91

92
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
Y
Yu Yang 已提交
93
  paddle::framework::Scope scope;
D
dzhwinter 已提交
94 95
  paddle::platform::CPUPlace cpu_place;
  op->Run(scope, cpu_place);
Y
Yu Yang 已提交
96
  float scale_get = op->Attr<float>("scale");
Q
Qiao Longfei 已提交
97
  ASSERT_EQ(scale_get, scale);
98 99 100
}

TEST(OpRegistry, IllegalAttr) {
101
  paddle::framework::proto::OpDesc op_desc;
102
  op_desc.set_type("cos_sim");
Y
Yu Yang 已提交
103 104
  BuildVar("input", {"aa"}, op_desc.add_inputs());
  BuildVar("output", {"bb"}, op_desc.add_outputs());
105 106 107

  auto attr = op_desc.mutable_attrs()->Add();
  attr->set_name("scale");
108
  attr->set_type(paddle::framework::proto::AttrType::FLOAT);
109 110 111 112
  attr->set_f(-2.0);

  bool caught = false;
  try {
113
    paddle::framework::OpRegistry::CreateOp(op_desc);
Y
Yu Yang 已提交
114
  } catch (paddle::platform::EnforceNotMet err) {
115 116 117 118 119 120 121 122 123 124 125
    caught = true;
    std::string msg = "larger_than check fail";
    const char* err_msg = err.what();
    for (size_t i = 0; i < msg.length(); ++i) {
      ASSERT_EQ(err_msg[i], msg[i]);
    }
  }
  ASSERT_TRUE(caught);
}

TEST(OpRegistry, DefaultValue) {
126
  paddle::framework::proto::OpDesc op_desc;
127
  op_desc.set_type("cos_sim");
Y
Yu Yang 已提交
128 129
  BuildVar("input", {"aa"}, op_desc.add_inputs());
  BuildVar("output", {"bb"}, op_desc.add_outputs());
130

Q
Qiao Longfei 已提交
131 132
  ASSERT_TRUE(op_desc.IsInitialized());

133
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
Y
Yu Yang 已提交
134
  paddle::framework::Scope scope;
D
dzhwinter 已提交
135 136
  paddle::platform::CPUPlace cpu_place;
  op->Run(scope, cpu_place);
Y
Yu Yang 已提交
137
  ASSERT_EQ(op->Attr<float>("scale"), 1.0);
138 139 140
}

TEST(OpRegistry, CustomChecker) {
141
  paddle::framework::proto::OpDesc op_desc;
142
  op_desc.set_type("my_test_op");
Y
Yu Yang 已提交
143 144
  BuildVar("input", {"ii"}, op_desc.add_inputs());
  BuildVar("output", {"oo"}, op_desc.add_outputs());
145 146 147 148

  // attr 'test_attr' is not set
  bool caught = false;
  try {
149
    paddle::framework::OpRegistry::CreateOp(op_desc);
Y
Yu Yang 已提交
150
  } catch (paddle::platform::EnforceNotMet err) {
151 152 153 154 155 156 157 158 159 160 161 162
    caught = true;
    std::string msg = "Attribute 'test_attr' is required!";
    const char* err_msg = err.what();
    for (size_t i = 0; i < msg.length(); ++i) {
      ASSERT_EQ(err_msg[i], msg[i]);
    }
  }
  ASSERT_TRUE(caught);

  // set 'test_attr' set to an illegal value
  auto attr = op_desc.mutable_attrs()->Add();
  attr->set_name("test_attr");
163
  attr->set_type(paddle::framework::proto::AttrType::INT);
164 165 166
  attr->set_i(3);
  caught = false;
  try {
167
    paddle::framework::OpRegistry::CreateOp(op_desc);
Y
Yu Yang 已提交
168
  } catch (paddle::platform::EnforceNotMet err) {
169 170 171 172 173 174 175 176 177 178 179 180 181
    caught = true;
    std::string msg = "'test_attr' must be even!";
    const char* err_msg = err.what();
    for (size_t i = 0; i < msg.length(); ++i) {
      ASSERT_EQ(err_msg[i], msg[i]);
    }
  }
  ASSERT_TRUE(caught);

  // set 'test_attr' set to a legal value
  op_desc.mutable_attrs()->Clear();
  attr = op_desc.mutable_attrs()->Add();
  attr->set_name("test_attr");
182
  attr->set_type(paddle::framework::proto::AttrType::INT);
183
  attr->set_i(4);
184
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);
D
dzhwinter 已提交
185
  paddle::platform::CPUPlace cpu_place;
Y
Yu Yang 已提交
186
  paddle::framework::Scope scope;
D
dzhwinter 已提交
187
  op->Run(scope, cpu_place);
Y
Yu Yang 已提交
188
  int test_attr = op->Attr<int>("test_attr");
Q
Qiao Longfei 已提交
189
  ASSERT_EQ(test_attr, 4);
Q
Qiao Longfei 已提交
190
}
191 192 193 194 195 196 197 198 199 200

class CosineOpComplete : public paddle::framework::CosineOp {
 public:
  DEFINE_OP_CONSTRUCTOR(CosineOpComplete, paddle::framework::CosineOp);
  DEFINE_OP_CLONE_METHOD(CosineOpComplete);
};

TEST(OperatorRegistrar, Test) {
  using namespace paddle::framework;
  OperatorRegistrar<CosineOpComplete, CosineOpProtoAndCheckerMaker> reg("cos");
201
}
D
dzhwinter 已提交
202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220

namespace paddle {
namespace framework {

class OpKernelTestMaker : public OpProtoAndCheckerMaker {
 public:
  OpKernelTestMaker(OpProto* proto, OpAttrChecker* op_checker)
      : OpProtoAndCheckerMaker(proto, op_checker) {
    AddComment("NoGradOp, same input output. no Grad");
  }
};

class OpWithKernelTest : public OperatorWithKernel {
 public:
  using OperatorWithKernel::OperatorWithKernel;

 protected:
  void InferShape(InferShapeContext* ctx) const override {}

221
  framework::OpKernelType GetExpectedKernelType(
D
dzhwinter 已提交
222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
      const framework::ExecutionContext& ctx) const override {
    return framework::OpKernelType(proto::DataType::FP32, ctx.device_context());
  }
};

template <typename DeviceContext, typename T>
class OpKernelTest : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const {}
};

}  // namespace framework
}  // namespace paddle

REGISTER_OP_WITHOUT_GRADIENT(op_with_kernel,
                             paddle::framework::OpWithKernelTest,
                             paddle::framework::OpKernelTestMaker);
REGISTER_OP_CPU_KERNEL(
    op_with_kernel,
    paddle::framework::OpKernelTest<paddle::platform::CPUDeviceContext, float>);

REGISTER_OP_CUDA_KERNEL(op_with_kernel,
                        paddle::framework::OpKernelTest<
                            paddle::platform::CUDADeviceContext, float>);

TEST(OperatorRegistrar, CPU) {
  paddle::framework::proto::OpDesc op_desc;
  paddle::platform::CPUPlace cpu_place;
  paddle::framework::Scope scope;

  op_desc.set_type("op_with_kernel");
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);

  op->Run(scope, cpu_place);
}

TEST(OperatorRegistrar, CUDA) {
  paddle::framework::proto::OpDesc op_desc;
  paddle::platform::CUDAPlace cuda_place(0);
  paddle::framework::Scope scope;

  op_desc.set_type("op_with_kernel");
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);

  op->Run(scope, cuda_place);
}
D
dzhwinter 已提交
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285

static int op_test_value = 0;

using paddle::platform::DeviceContext;
using paddle::platform::CPUDeviceContext;
using paddle::platform::CUDADeviceContext;

namespace paddle {
namespace framework {

class OpWithMultiKernelTest : public OperatorWithKernel {
 public:
  using OperatorWithKernel::OperatorWithKernel;

 protected:
  void InferShape(InferShapeContext* ctx) const override {}

  framework::OpKernelType GetExpectedKernelType(
286 287 288 289
      const framework::ExecutionContext& ctx) const override {
    return framework::OpKernelType(
        proto::DataType::FP32, platform::CUDAPlace(0), DataLayout::kAnyLayout,
        framework::LibraryType::kCUDNN);
D
dzhwinter 已提交
290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368
  }
};

template <typename DeviceContext, typename T>
class OpMultiKernelTest : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const;
};

template <typename T>
class OpMultiKernelTest<CPUDeviceContext, T>
    : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const {
    ++op_test_value;
  }
};

template <typename T>
class OpMultiKernelTest<CUDADeviceContext, T>
    : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const {
    --op_test_value;
  }
};

template <typename DeviceContext, typename T>
class OpMultiKernelTest2 : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const;
};

template <typename T>
class OpMultiKernelTest2<CPUDeviceContext, T>
    : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const {
    op_test_value += 10;
  }
};

template <typename T>
class OpMultiKernelTest2<CUDADeviceContext, T>
    : public paddle::framework::OpKernel<T> {
 public:
  void Compute(const paddle::framework::ExecutionContext& ctx) const {
    op_test_value -= 10;
  }
};

}  // namespace framework
}  // namespace paddle

REGISTER_OP_WITHOUT_GRADIENT(op_with_multi_kernel,
                             paddle::framework::OpWithMultiKernelTest,
                             paddle::framework::OpKernelTestMaker);
REGISTER_OP_KERNEL(
    op_with_multi_kernel, CPU, paddle::platform::CPUPlace,
    paddle::framework::OpMultiKernelTest<CPUDeviceContext, float>);
REGISTER_OP_KERNEL(
    op_with_multi_kernel, MKLDNN, paddle::platform::CPUPlace,
    paddle::framework::OpMultiKernelTest2<CPUDeviceContext, float>);
REGISTER_OP_KERNEL(
    op_with_multi_kernel, CUDA, paddle::platform::CUDAPlace,
    paddle::framework::OpMultiKernelTest<CUDADeviceContext, float>);
REGISTER_OP_KERNEL(
    op_with_multi_kernel, CUDNN, paddle::platform::CUDAPlace,
    paddle::framework::OpMultiKernelTest2<CUDADeviceContext, float>);

TEST(OperatorRegistrar, OpWithMultiKernel) {
  paddle::framework::proto::OpDesc op_desc;
  paddle::platform::CUDAPlace cuda_place(0);
  paddle::platform::CPUPlace cpu_place;
  paddle::framework::Scope scope;

  op_desc.set_type("op_with_multi_kernel");
  auto op = paddle::framework::OpRegistry::CreateOp(op_desc);

369
  // TODO(qiao) add priority back
D
dzhwinter 已提交
370 371 372 373 374 375 376 377 378
  // use all available kernels
  paddle::framework::UseALL();
  op->Run(scope, cuda_place);
  EXPECT_EQ(op_test_value, -10);

  // remove cuda kernels
  paddle::framework::UseCPU();
  op->Run(scope, cpu_place);

Q
qiaolongfei 已提交
379
  EXPECT_EQ(op_test_value, -9);
D
dzhwinter 已提交
380 381 382 383 384

  // add cuda kernels
  paddle::framework::UseCUDA();
  op->Run(scope, cuda_place);

Q
qiaolongfei 已提交
385
  EXPECT_EQ(op_test_value, -10);
D
dzhwinter 已提交
386 387 388 389

  // use cudnn kernel
  paddle::framework::UseCUDNN();
  op->Run(scope, cuda_place);
Q
qiaolongfei 已提交
390
  EXPECT_EQ(op_test_value, -20);
D
dzhwinter 已提交
391
}