enforce.h 23.1 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

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

#pragma once

17 18 19 20 21 22 23 24 25 26 27 28
#ifdef __GNUC__
#include <cxxabi.h>  // for __cxa_demangle
#endif               // __GNUC__

#ifdef PADDLE_WITH_CUDA
#include <cublas_v2.h>
#include <cudnn.h>
#include <curand.h>
#include <thrust/system/cuda/error.h>
#include <thrust/system_error.h>
#endif  // PADDLE_WITH_CUDA

29
#include <fstream>
Y
Yu Yang 已提交
30
#include <iomanip>
31
#include <iostream>
L
liaogang 已提交
32
#include <memory>
33 34 35
#include <sstream>
#include <stdexcept>
#include <string>
S
sneaxiy 已提交
36 37
#include <type_traits>
#include <utility>
38

39
#define GLOG_NO_ABBREVIATED_SEVERITIES  // msvc conflict logging with windows.h
40
#include "glog/logging.h"
41
#include "paddle/fluid/platform/errors.h"
Y
Yi Wang 已提交
42
#include "paddle/fluid/platform/macros.h"
D
dzhwinter 已提交
43
#include "paddle/fluid/platform/port.h"
44 45
#include "paddle/fluid/string/printf.h"
#include "paddle/fluid/string/to_string.h"
46

47
#ifdef PADDLE_WITH_CUDA
Y
Yi Wang 已提交
48 49 50
#include "paddle/fluid/platform/dynload/cublas.h"
#include "paddle/fluid/platform/dynload/cudnn.h"
#include "paddle/fluid/platform/dynload/curand.h"
51
#if !defined(__APPLE__) && defined(PADDLE_WITH_NCCL)
Y
Yi Wang 已提交
52
#include "paddle/fluid/platform/dynload/nccl.h"
Y
Yi Wang 已提交
53 54
#endif  // __APPLE__
#endif  // PADDLE_WITH_CUDA
55 56 57 58

namespace paddle {
namespace platform {

59 60
/** HELPER MACROS AND FUNCTIONS **/

Z
Zeng Jinle 已提交
61 62 63 64
#ifndef PADDLE_MAY_THROW
#define PADDLE_MAY_THROW noexcept(false)
#endif

65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
// Because most enforce conditions would evaluate to true, we can use
// __builtin_expect to instruct the C++ compiler to generate code that
// always forces branch prediction of true.
// This generates faster binary code. __builtin_expect is since C++11.
// For more details, please check https://stackoverflow.com/a/43870188/724872.
#if !defined(_WIN32)
#define UNLIKELY(condition) __builtin_expect(static_cast<bool>(condition), 0)
#else
// there is no equivalent intrinsics in msvc.
#define UNLIKELY(condition) (condition)
#endif

#if !defined(_WIN32)
#define LIKELY(condition) __builtin_expect(static_cast<bool>(condition), 1)
#else
// there is no equivalent intrinsics in msvc.
#define LIKELY(condition) (condition)
#endif

L
liaogang 已提交
84 85 86 87 88 89 90 91 92 93 94
#ifdef __GNUC__
inline std::string demangle(std::string name) {
  int status = -4;  // some arbitrary value to eliminate the compiler warning
  std::unique_ptr<char, void (*)(void*)> res{
      abi::__cxa_demangle(name.c_str(), NULL, NULL, &status), std::free};
  return (status == 0) ? res.get() : name;
}
#else
inline std::string demangle(std::string name) { return name; }
#endif

95 96 97 98 99 100 101 102 103 104 105 106 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 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
namespace details {
template <typename T>
inline constexpr bool IsArithmetic() {
  return std::is_arithmetic<T>::value;
}

template <typename T1, typename T2, bool kIsArithmetic /* = true */>
struct TypeConverterImpl {
  using Type1 = typename std::common_type<T1, T2>::type;
  using Type2 = Type1;
};

template <typename T1, typename T2>
struct TypeConverterImpl<T1, T2, false> {
  using Type1 = T1;
  using Type2 = T2;
};

template <typename T1, typename T2>
struct TypeConverter {
 private:
  static constexpr bool kIsArithmetic =
      IsArithmetic<T1>() && IsArithmetic<T2>();

 public:
  using Type1 = typename TypeConverterImpl<T1, T2, kIsArithmetic>::Type1;
  using Type2 = typename TypeConverterImpl<T1, T2, kIsArithmetic>::Type2;
};

template <typename T1, typename T2>
using CommonType1 = typename std::add_lvalue_reference<
    typename std::add_const<typename TypeConverter<T1, T2>::Type1>::type>::type;

template <typename T1, typename T2>
using CommonType2 = typename std::add_lvalue_reference<
    typename std::add_const<typename TypeConverter<T1, T2>::Type2>::type>::type;

// Here, we use SFINAE to check whether T can be converted to std::string
template <typename T>
struct CanToString {
 private:
  using YesType = uint8_t;
  using NoType = uint16_t;

  template <typename U>
  static YesType Check(decltype(std::cout << std::declval<U>())) {
    return 0;
  }

  template <typename U>
  static NoType Check(...) {
    return 0;
  }

 public:
  static constexpr bool kValue =
      std::is_same<YesType, decltype(Check<T>(std::cout))>::value;
};

template <bool kCanToString /* = true */>
struct BinaryCompareMessageConverter {
  template <typename T>
  static std::string Convert(const char* expression, const T& value) {
    return expression + std::string(":") + string::to_string(value);
  }
};

template <>
struct BinaryCompareMessageConverter<false> {
  template <typename T>
  static const char* Convert(const char* expression, const T& value) {
    return expression;
  }
};
}  // namespace details

171 172 173 174 175 176
template <typename StrType>
inline std::string GetTraceBackString(StrType&& what, const char* file,
                                      int line) {
  static constexpr int TRACE_STACK_LIMIT = 100;
  std::ostringstream sout;

177 178 179
  sout << "\n\n--------------------------------------------\n";
  sout << "C++ Call Stacks (More useful to developers):";
  sout << "\n--------------------------------------------\n";
180 181 182 183 184
#if !defined(_WIN32)
  void* call_stack[TRACE_STACK_LIMIT];
  auto size = backtrace(call_stack, TRACE_STACK_LIMIT);
  auto symbols = backtrace_symbols(call_stack, size);
  Dl_info info;
185
  int idx = 0;
186 187 188
  for (int i = 0; i < size; ++i) {
    if (dladdr(call_stack[i], &info) && info.dli_sname) {
      auto demangled = demangle(info.dli_sname);
189 190 191 192 193
      std::string path(info.dli_fname);
      // C++ traceback info are from core.so
      if (path.substr(path.length() - 3).compare(".so") == 0) {
        sout << string::Sprintf("%-3d %s\n", idx++, demangled);
      }
194 195 196 197
    }
  }
  free(symbols);
#else
198
  sout << "Windows not support stack backtrace yet.\n";
199
#endif
200 201
  sout << "\n----------------------\nError Message "
          "Summary:\n----------------------\n";
202 203
  sout << string::Sprintf("%s at (%s:%d)", std::forward<StrType>(what), file,
                          line)
204
       << std::endl;
205 206 207
  return sout.str();
}

208 209
inline bool is_error(bool stat) { return !stat; }

210 211 212 213
inline std::string build_ex_string(bool stat, const std::string& msg) {
  return msg;
}

214 215 216 217 218 219 220 221
inline void throw_on_error(bool stat, const std::string& msg) {
#ifndef REPLACE_ENFORCE_GLOG
  throw std::runtime_error(msg);
#else
  LOG(FATAL) << msg;
#endif
}

222 223 224 225 226 227 228
// Note: This Macro can only be used within enforce.h
#define __THROW_ERROR_INTERNAL__(...)                                \
  do {                                                               \
    throw ::paddle::platform::EnforceNotMet(                         \
        ::paddle::string::Sprintf(__VA_ARGS__), __FILE__, __LINE__); \
  } while (0)

229 230
/** ENFORCE EXCEPTION AND MACROS **/

231
struct EnforceNotMet : public std::exception {
232
  EnforceNotMet(std::exception_ptr e, const char* file, int line) {
233
    try {
Y
Yu Yang 已提交
234 235
      std::rethrow_exception(e);
    } catch (std::exception& e) {
236
      err_str_ = GetTraceBackString(e.what(), file, line);
Y
Yu Yang 已提交
237 238
    }
  }
239

240
  EnforceNotMet(const std::string& str, const char* file, int line)
241
      : err_str_(GetTraceBackString(str, file, line)) {}
Y
Yu Yang 已提交
242

243 244 245
  EnforceNotMet(const platform::ErrorSummary& error, const char* file, int line)
      : err_str_(GetTraceBackString(error.ToString(), file, line)) {}

Y
Yu Yang 已提交
246
  const char* what() const noexcept override { return err_str_.c_str(); }
247 248

  std::string err_str_;
249 250
};

251 252 253 254 255 256
#define PADDLE_THROW(...)                                                   \
  do {                                                                      \
    throw ::paddle::platform::EnforceNotMet(                                \
        ::paddle::platform::ErrorSummary(__VA_ARGS__), __FILE__, __LINE__); \
  } while (0)

257 258 259 260
#if defined(__CUDA_ARCH__)
// For cuda, the assertions can affect performance and it is therefore
// recommended to disable them in production code
// https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#assertion
261 262 263 264 265 266 267
#define PADDLE_ENFORCE(_IS_NOT_ERROR, __FORMAT, ...)                         \
  do {                                                                       \
    if (!(_IS_NOT_ERROR)) {                                                  \
      printf("Error: %s:%d Assertion `%s` failed. " __FORMAT "\n", __FILE__, \
             __LINE__, #_IS_NOT_ERROR, ##__VA_ARGS__);                       \
      asm("trap;");                                                          \
    }                                                                        \
268 269
  } while (0)
#else
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284
#define PADDLE_ENFORCE(COND, ...)                                           \
  do {                                                                      \
    auto __cond__ = (COND);                                                 \
    if (UNLIKELY(::paddle::platform::is_error(__cond__))) {                 \
      try {                                                                 \
        ::paddle::platform::throw_on_error(                                 \
            __cond__,                                                       \
            ::paddle::platform::build_ex_string(                            \
                __cond__,                                                   \
                ::paddle::platform::ErrorSummary(__VA_ARGS__).ToString())); \
      } catch (...) {                                                       \
        throw ::paddle::platform::EnforceNotMet(std::current_exception(),   \
                                                __FILE__, __LINE__);        \
      }                                                                     \
    }                                                                       \
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
  } while (0)
#endif

/*
 * Some enforce helpers here, usage:
 *    int a = 1;
 *    int b = 2;
 *    PADDLE_ENFORCE_EQ(a, b);
 *
 *    will raise an expression described as follows:
 *    "Expected input a == b, but received a(1) != b(2)."
 *      with detailed stack information.
 *
 *    extra messages is also supported, for example:
 *    PADDLE_ENFORCE(a, b, "some simple enforce failed between %d numbers", 2)
 */
301

302 303 304
#define PADDLE_ENFORCE_NOT_NULL(__VAL, ...)                          \
  do {                                                               \
    if (UNLIKELY(nullptr == (__VAL))) {                              \
305
      __THROW_ERROR_INTERNAL__(                                      \
306 307 308
          "%s\n  [Hint: " #__VAL " should not be null.]",            \
          ::paddle::platform::ErrorSummary(__VA_ARGS__).ToString()); \
    }                                                                \
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326
  } while (0)

#define __PADDLE_BINARY_COMPARE(__VAL1, __VAL2, __CMP, __INV_CMP, ...)         \
  do {                                                                         \
    auto __val1 = (__VAL1);                                                    \
    auto __val2 = (__VAL2);                                                    \
    using __TYPE1__ = decltype(__val1);                                        \
    using __TYPE2__ = decltype(__val2);                                        \
    using __COMMON_TYPE1__ =                                                   \
        ::paddle::platform::details::CommonType1<__TYPE1__, __TYPE2__>;        \
    using __COMMON_TYPE2__ =                                                   \
        ::paddle::platform::details::CommonType2<__TYPE1__, __TYPE2__>;        \
    bool __is_not_error = (static_cast<__COMMON_TYPE1__>(__val1))__CMP(        \
        static_cast<__COMMON_TYPE2__>(__val2));                                \
    if (UNLIKELY(!__is_not_error)) {                                           \
      constexpr bool __kCanToString__ =                                        \
          ::paddle::platform::details::CanToString<__TYPE1__>::kValue &&       \
          ::paddle::platform::details::CanToString<__TYPE2__>::kValue;         \
327
      __THROW_ERROR_INTERNAL__(                                                \
328 329 330 331
          "%s\n  [Hint: Expected %s " #__CMP                                   \
          " %s, but received %s " #__INV_CMP " %s.]",                          \
          ::paddle::platform::ErrorSummary(__VA_ARGS__).ToString(), #__VAL1,   \
          #__VAL2, ::paddle::platform::details::BinaryCompareMessageConverter< \
332
                       __kCanToString__>::Convert(#__VAL1, __val1),            \
333 334
          ::paddle::platform::details::BinaryCompareMessageConverter<          \
              __kCanToString__>::Convert(#__VAL2, __val2));                    \
335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
    }                                                                          \
  } while (0)

#define PADDLE_ENFORCE_EQ(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, ==, !=, __VA_ARGS__)
#define PADDLE_ENFORCE_NE(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, !=, ==, __VA_ARGS__)
#define PADDLE_ENFORCE_GT(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, >, <=, __VA_ARGS__)
#define PADDLE_ENFORCE_GE(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, >=, <, __VA_ARGS__)
#define PADDLE_ENFORCE_LT(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, <, >=, __VA_ARGS__)
#define PADDLE_ENFORCE_LE(__VAL0, __VAL1, ...) \
  __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, <=, >, __VA_ARGS__)

351 352
/** EXTENDED TOOL FUNCTIONS WITH CHECKING **/

353 354 355 356 357 358 359 360 361 362 363 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
/*
 * Summary: This macro is used to get Variable or internal type
 *   data (such as LoDTensor or SelectedRows) of the Input and
 *   Output in op, generally used when call scope.FindVar(Input/
 *   Output("Name")) or ctx.Input<LoDTensor>().
 *   Firstly this macro check whether the obtained pointer is null,
 *   and then return data if it is not null.
 *
 * Note: This macro is only suitable for specific scenarios and
 *   does not intended to be widely used. If it cannot meet the
 *   requirements, please use other PADDLE_ENFORCE** check macro.
 *
 * Parameters:
 *     __PTR: pointer
 *     __ROLE: (string), Input or Output
 *     __NAME: (string), Input or Output name
 *     __OP_TYPE: (string), the op type
 *  
 * Return: The data pointed to by the pointer.
 *
 * Examples:
 *    GET_DATA_SAFELY(ctx.Input<LoDTensor>("X"), "Input", "X", "Mul");
*/
#define GET_DATA_SAFELY(__PTR, __ROLE, __NAME, __OP_TYPE)                   \
  (([&]() -> std::add_lvalue_reference<decltype(*(__PTR))>::type {          \
    auto* ptr = (__PTR);                                                    \
    if (UNLIKELY(nullptr == ptr)) {                                         \
      __THROW_ERROR_INTERNAL__(                                             \
          "%s\n  [Hint: pointer " #__PTR " should not be null.]",           \
          paddle::platform::errors::NotFound(                               \
              "Unable to get %s data of %s %s in operator %s. "             \
              "Possible reasons are:\n"                                     \
              "  1. The %s is not the %s of operator %s;\n"                 \
              "  2. The %s has no corresponding variable passed in;\n"      \
              "  3. The %s corresponding variable is not initialized.",     \
              paddle::platform::demangle(                                   \
                  typeid(std::add_lvalue_reference<decltype(*ptr)>::type)   \
                      .name()),                                             \
              __ROLE, __NAME, __OP_TYPE, __NAME, __ROLE, __OP_TYPE, __NAME, \
              __NAME)                                                       \
              .ToString());                                                 \
    }                                                                       \
    return *ptr;                                                            \
  })())

398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418
/*
 * Summary: This macro is used to check whether op has specified
 * Input or Output Variables. Because op's Input and Output
 * checking are written similarly, so abstract this macro.
 *
 * Parameters:
 *     __EXPR: (bool), the bool expression
 *     __ROLE: (string), Input or Output
 *     __NAME: (string), Input or Output name
 *     __OP_TYPE: (string), the op type
 *
 * Examples:
 *    OP_INOUT_CHECK(ctx->HasInput("X"), "Input", "X", "Mul");
*/
#define OP_INOUT_CHECK(__EXPR, __ROLE, __NAME, __OP_TYPE)                   \
  do {                                                                      \
    PADDLE_ENFORCE_EQ(__EXPR, true, paddle::platform::errors::NotFound(     \
                                        "No %s(%s) found for %s operator.", \
                                        __ROLE, __NAME, __OP_TYPE));        \
  } while (0)

419 420
/** OTHER EXCEPTION AND ENFORCE **/

421 422
struct EOFException : public std::exception {
  std::string err_str_;
423 424
  EOFException(const char* err_msg, const char* file, int line) {
    err_str_ = string::Sprintf("%s at [%s:%d]", err_msg, file, line);
425 426
  }

427
  const char* what() const noexcept override { return err_str_.c_str(); }
428 429
};

430 431 432 433 434
#define PADDLE_THROW_EOF()                                                     \
  do {                                                                         \
    throw ::paddle::platform::EOFException("There is no next data.", __FILE__, \
                                           __LINE__);                          \
  } while (0)
435

436 437 438 439 440
#define PADDLE_THROW_BAD_ALLOC(...)                                         \
  do {                                                                      \
    throw ::paddle::memory::allocation::BadAlloc(                           \
        ::paddle::platform::ErrorSummary(__VA_ARGS__).ToString(), __FILE__, \
        __LINE__);                                                          \
441
  } while (0)
M
minqiyang 已提交
442

443
/** CUDA PADDLE ENFORCE FUNCTIONS AND MACROS **/
L
liaogang 已提交
444

445
#ifdef PADDLE_WITH_CUDA
446

S
sneaxiy 已提交
447
inline bool is_error(cudaError_t e) { return e != cudaSuccess; }
M
minqiyang 已提交
448

449 450 451 452
inline std::string build_ex_string(cudaError_t e, const std::string& msg) {
  return msg;
}

S
sneaxiy 已提交
453
inline void throw_on_error(cudaError_t e, const std::string& msg) {
454
#ifndef REPLACE_ENFORCE_GLOG
S
sneaxiy 已提交
455
  throw thrust::system_error(e, thrust::cuda_category(), msg);
456
#else
S
sneaxiy 已提交
457
  LOG(FATAL) << msg;
458
#endif
M
minqiyang 已提交
459 460 461 462
}

inline bool is_error(curandStatus_t stat) {
  return stat != CURAND_STATUS_SUCCESS;
463 464
}

465 466 467 468 469
inline std::string build_ex_string(curandStatus_t stat,
                                   const std::string& msg) {
  return msg;
}

S
sneaxiy 已提交
470
inline void throw_on_error(curandStatus_t stat, const std::string& msg) {
471
#ifndef REPLACE_ENFORCE_GLOG
M
minqiyang 已提交
472
  throw thrust::system_error(cudaErrorLaunchFailure, thrust::cuda_category(),
S
sneaxiy 已提交
473
                             msg);
474
#else
S
sneaxiy 已提交
475
  LOG(FATAL) << msg;
476
#endif
M
minqiyang 已提交
477 478 479 480
}

inline bool is_error(cudnnStatus_t stat) {
  return stat != CUDNN_STATUS_SUCCESS;
481 482
}

483
inline std::string build_ex_string(cudnnStatus_t stat, const std::string& msg) {
484 485
  return msg + "\n  [Hint: " + platform::dynload::cudnnGetErrorString(stat) +
         "]";
486 487
}

S
sneaxiy 已提交
488
inline void throw_on_error(cudnnStatus_t stat, const std::string& msg) {
489
#ifndef REPLACE_ENFORCE_GLOG
490
  throw std::runtime_error(msg);
491
#else
492
  LOG(FATAL) << msg;
493
#endif
M
minqiyang 已提交
494 495 496 497
}

inline bool is_error(cublasStatus_t stat) {
  return stat != CUBLAS_STATUS_SUCCESS;
498 499
}

500 501
inline std::string build_ex_string(cublasStatus_t stat,
                                   const std::string& msg) {
L
liaogang 已提交
502
  std::string err;
M
minqiyang 已提交
503
  if (stat == CUBLAS_STATUS_NOT_INITIALIZED) {
504
    err = "CUBLAS_STATUS_NOT_INITIALIZED";
505
  } else if (stat == CUBLAS_STATUS_ALLOC_FAILED) {
506
    err = "CUBLAS_STATUS_ALLOC_FAILED";
507
  } else if (stat == CUBLAS_STATUS_INVALID_VALUE) {
508
    err = "CUBLAS_STATUS_INVALID_VALUE";
509
  } else if (stat == CUBLAS_STATUS_ARCH_MISMATCH) {
510
    err = "CUBLAS_STATUS_ARCH_MISMATCH";
511
  } else if (stat == CUBLAS_STATUS_MAPPING_ERROR) {
512
    err = "CUBLAS_STATUS_MAPPING_ERROR";
513
  } else if (stat == CUBLAS_STATUS_EXECUTION_FAILED) {
514
    err = "CUBLAS_STATUS_EXECUTION_FAILED";
515
  } else if (stat == CUBLAS_STATUS_INTERNAL_ERROR) {
516
    err = "CUBLAS_STATUS_INTERNAL_ERROR";
517
  } else if (stat == CUBLAS_STATUS_NOT_SUPPORTED) {
518
    err = "CUBLAS_STATUS_NOT_SUPPORTED";
519
  } else if (stat == CUBLAS_STATUS_LICENSE_ERROR) {
520
    err = "CUBLAS_STATUS_LICENSE_ERROR";
521
  }
522
  return msg + "\n  [Hint: " + err + "]";
523 524 525
}

inline void throw_on_error(cublasStatus_t stat, const std::string& msg) {
526
#ifndef REPLACE_ENFORCE_GLOG
527
  throw std::runtime_error(msg);
528
#else
529
  LOG(FATAL) << msg;
530
#endif
531 532
}

533
#if !defined(__APPLE__) && defined(PADDLE_WITH_NCCL)
S
sneaxiy 已提交
534 535 536 537
inline bool is_error(ncclResult_t nccl_result) {
  return nccl_result != ncclSuccess;
}

538 539 540 541 542 543 544
inline std::string build_ex_string(ncclResult_t nccl_result,
                                   const std::string& msg) {
  return msg + "\n  [" + platform::dynload::ncclGetErrorString(nccl_result) +
         "]";
}

inline void throw_on_error(ncclResult_t nccl_result, const std::string& msg) {
545
#ifndef REPLACE_ENFORCE_GLOG
546
  throw std::runtime_error(msg);
547
#else
548
  LOG(FATAL) << msg;
549
#endif
Y
Yu Yang 已提交
550
}
D
dzhwinter 已提交
551
#endif  // __APPLE__ and windows
552

553
#endif  // PADDLE_WITH_CUDA
554

555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
#ifdef PADDLE_WITH_CUDA
namespace details {

template <typename T>
struct CudaStatusType {};

#define DEFINE_CUDA_STATUS_TYPE(type, success_value) \
  template <>                                        \
  struct CudaStatusType<type> {                      \
    using Type = type;                               \
    static constexpr Type kSuccess = success_value;  \
  }

DEFINE_CUDA_STATUS_TYPE(cudaError_t, cudaSuccess);
DEFINE_CUDA_STATUS_TYPE(curandStatus_t, CURAND_STATUS_SUCCESS);
DEFINE_CUDA_STATUS_TYPE(cudnnStatus_t, CUDNN_STATUS_SUCCESS);
DEFINE_CUDA_STATUS_TYPE(cublasStatus_t, CUBLAS_STATUS_SUCCESS);

573
#if !defined(__APPLE__) && defined(PADDLE_WITH_NCCL)
574 575 576 577
DEFINE_CUDA_STATUS_TYPE(ncclResult_t, ncclSuccess);
#endif

}  // namespace details
578
#endif  // PADDLE_WITH_CUDA
M
minqiyang 已提交
579

580
#ifdef PADDLE_WITH_CUDA
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
#define PADDLE_ENFORCE_CUDA_SUCCESS(COND, ...)                              \
  do {                                                                      \
    auto __cond__ = (COND);                                                 \
    using __CUDA_STATUS_TYPE__ = decltype(__cond__);                        \
    constexpr auto __success_type__ =                                       \
        ::paddle::platform::details::CudaStatusType<                        \
            __CUDA_STATUS_TYPE__>::kSuccess;                                \
    if (UNLIKELY(__cond__ != __success_type__)) {                           \
      try {                                                                 \
        ::paddle::platform::throw_on_error(                                 \
            __cond__,                                                       \
            ::paddle::platform::build_ex_string(                            \
                __cond__,                                                   \
                ::paddle::platform::ErrorSummary(__VA_ARGS__).ToString())); \
      } catch (...) {                                                       \
        throw ::paddle::platform::EnforceNotMet(std::current_exception(),   \
                                                __FILE__, __LINE__);        \
      }                                                                     \
    }                                                                       \
600 601 602
  } while (0)

#undef DEFINE_CUDA_STATUS_TYPE
603
#endif  // PADDLE_WITH_CUDA
S
add EQ  
Superjom 已提交
604

605 606
}  // namespace platform
}  // namespace paddle