enforce.h 7.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/* 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. */

#pragma once

Y
Yu Yang 已提交
17
#include <execinfo.h>
18
#include <paddle/string/printf.h>
Y
Yu Yang 已提交
19
#include <iomanip>
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#include <sstream>
#include <stdexcept>
#include <string>

#ifndef PADDLE_ONLY_CPU

#include "paddle/platform/dynload/cublas.h"
#include "paddle/platform/dynload/cudnn.h"
#include "paddle/platform/dynload/curand.h"

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

#endif  // PADDLE_ONLY_CPU

namespace paddle {
namespace platform {

41 42 43 44
struct EnforceNotMet : public std::exception {
  std::exception_ptr exp_;
  std::string err_str_;
  EnforceNotMet(std::exception_ptr e, const char* f, int l) : exp_(e) {
Y
Yu Yang 已提交
45
    static constexpr int TRACE_STACK_LIMIT = 100;
46 47 48
    try {
      std::rethrow_exception(exp_);
    } catch (const std::exception& exp) {
Y
Yu Yang 已提交
49 50 51 52 53 54 55 56 57 58 59
      std::ostringstream sout;
      sout << string::Sprintf("%s at [%s:%d]", exp.what(), f, l) << std::endl;
      sout << "Call Stacks: " << std::endl;
      void* call_stack[TRACE_STACK_LIMIT];
      int sz = backtrace(call_stack, TRACE_STACK_LIMIT);
      auto line = backtrace_symbols(call_stack, sz);
      for (int i = 0; i < sz; ++i) {
        sout << line[i] << std::endl;
      }
      free(line);
      err_str_ = sout.str();
60 61 62 63 64 65
    }
  }

  const char* what() const noexcept { return err_str_.c_str(); }
};

L
liaogang 已提交
66 67 68 69 70
// 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.
71 72
#define UNLIKELY(condition) __builtin_expect(static_cast<bool>(condition), 0)

73 74 75 76
template <typename... Args>
inline typename std::enable_if<sizeof...(Args) != 0, void>::type throw_on_error(
    int stat, const Args&... args) {
  if (UNLIKELY(!(stat))) {
77
    throw std::runtime_error(string::Sprintf(args...));
78 79 80
  }
}

81 82 83
#ifndef PADDLE_ONLY_CPU

template <typename... Args>
84 85
inline typename std::enable_if<sizeof...(Args) != 0, void>::type throw_on_error(
    cudaError_t e, const Args&... args) {
L
liaogang 已提交
86
  if (UNLIKELY(e)) {
87 88
    throw thrust::system_error(e, thrust::cuda_category(),
                               string::Sprintf(args...));
89 90 91 92
  }
}

template <typename... Args>
93 94
inline typename std::enable_if<sizeof...(Args) != 0, void>::type throw_on_error(
    curandStatus_t stat, const Args&... args) {
95
  if (stat != CURAND_STATUS_SUCCESS) {
96 97
    throw thrust::system_error(cudaErrorLaunchFailure, thrust::cuda_category(),
                               string::Sprintf(args...));
98 99 100 101
  }
}

template <typename... Args>
102 103
inline typename std::enable_if<sizeof...(Args) != 0, void>::type throw_on_error(
    cudnnStatus_t stat, const Args&... args) {
104 105 106
  if (stat == CUDNN_STATUS_SUCCESS) {
    return;
  } else {
107 108
    throw std::runtime_error(platform::dynload::cudnnGetErrorString(stat) +
                             string::Sprintf(args...));
109 110 111 112
  }
}

template <typename... Args>
113 114
inline typename std::enable_if<sizeof...(Args) != 0, void>::type throw_on_error(
    cublasStatus_t stat, const Args&... args) {
L
liaogang 已提交
115
  std::string err;
116 117 118
  if (stat == CUBLAS_STATUS_SUCCESS) {
    return;
  } else if (stat == CUBLAS_STATUS_NOT_INITIALIZED) {
L
liaogang 已提交
119
    err = "CUBLAS: not initialized, ";
120
  } else if (stat == CUBLAS_STATUS_ALLOC_FAILED) {
L
liaogang 已提交
121
    err = "CUBLAS: alloc failed, ";
122
  } else if (stat == CUBLAS_STATUS_INVALID_VALUE) {
L
liaogang 已提交
123
    err = "CUBLAS: invalid value, ";
124
  } else if (stat == CUBLAS_STATUS_ARCH_MISMATCH) {
L
liaogang 已提交
125
    err = "CUBLAS: arch mismatch, ";
126
  } else if (stat == CUBLAS_STATUS_MAPPING_ERROR) {
L
liaogang 已提交
127
    err = "CUBLAS: mapping error, ";
128
  } else if (stat == CUBLAS_STATUS_EXECUTION_FAILED) {
L
liaogang 已提交
129
    err = "CUBLAS: execution failed, ";
130
  } else if (stat == CUBLAS_STATUS_INTERNAL_ERROR) {
L
liaogang 已提交
131
    err = "CUBLAS: internal error, ";
132
  } else if (stat == CUBLAS_STATUS_NOT_SUPPORTED) {
L
liaogang 已提交
133
    err = "CUBLAS: not supported, ";
134
  } else if (stat == CUBLAS_STATUS_LICENSE_ERROR) {
L
liaogang 已提交
135
    err = "CUBLAS: license error, ";
136
  }
137
  throw std::runtime_error(err + string::Sprintf(args...));
138 139 140 141
}

#endif  // PADDLE_ONLY_CPU

L
liaogang 已提交
142 143 144 145 146
template <typename T>
inline void throw_on_error(T e) {
  throw_on_error(e, "");
}

Q
qijun 已提交
147 148 149 150 151 152
#define PADDLE_THROW(...)                                              \
  do {                                                                 \
    throw ::paddle::platform::EnforceNotMet(                           \
        std::make_exception_ptr(                                       \
            std::runtime_error(paddle::string::Sprintf(__VA_ARGS__))), \
        __FILE__, __LINE__);                                           \
L
liaogang 已提交
153 154
  } while (0)

155 156 157 158 159 160 161 162
#define PADDLE_ENFORCE(...)                                             \
  do {                                                                  \
    try {                                                               \
      ::paddle::platform::throw_on_error(__VA_ARGS__);                  \
    } catch (...) {                                                     \
      throw ::paddle::platform::EnforceNotMet(std::current_exception(), \
                                              __FILE__, __LINE__);      \
    }                                                                   \
163 164
  } while (0)

S
Superjom 已提交
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193
/*
 * Some enforce helpers here, usage:
 *    int a = 1;
 *    int b = 2;
 *    PADDLE_ENFORCE_EQ(a, b);
 *
 *    will raise an expression described as follows:
 *    "enforce a == b failed, 1 != 2" with detailed stack infomation.
 *
 *    extra messages is also supported, for example:
 *    PADDLE_ENFORCE(a, b, "some simple enforce failed between %d numbers", 2)
 */

#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__)

// if two values have different data types, choose a compatible type for them.
template <typename T1, typename T2>
struct CompatibleType {
S
Superjom 已提交
194
  static const bool t1_to_t2 = std::is_convertible<T1, T2>::value;
S
Superjom 已提交
195 196 197 198 199 200 201 202 203
  typedef typename std::conditional<t1_to_t2, T2, T1>::type type;
};

#define __PADDLE_BINARY_COMPARE(__VAL0, __VAL1, __CMP, __INV_CMP, ...)        \
  PADDLE_ENFORCE(__COMPATIBLE_TYPE(__VAL0, __VAL1, __VAL0)                    \
                     __CMP __COMPATIBLE_TYPE(__VAL0, __VAL1, __VAL1),         \
                 "enforce %s " #__CMP " %s failed, %s " #__INV_CMP " %s\n%s", \
                 #__VAL0, #__VAL1, std::to_string(__VAL0),                    \
                 std::to_string(__VAL1),                                      \
S
Superjom 已提交
204
                 paddle::string::Sprintf("" __VA_ARGS__));
S
add EQ  
Superjom 已提交
205

S
Superjom 已提交
206 207 208 209
#define __COMPATIBLE_TYPE(__VAL0, __VAL1, __VAL)              \
  typename paddle::platform::CompatibleType<decltype(__VAL0), \
                                            decltype(__VAL1)>::type(__VAL)

210 211
}  // namespace platform
}  // namespace paddle
反馈
建议
客服 返回
顶部