You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
907 lines
38 KiB
907 lines
38 KiB
/**
|
|
* Copyright 2020 Huawei Technologies Co., Ltd
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef GE_COMMON_MATH_MATH_UTIL_H_
|
|
#define GE_COMMON_MATH_MATH_UTIL_H_
|
|
|
|
#include <climits>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
|
|
#include "common/fp16_t.h"
|
|
#include "framework/common/debug/log.h"
|
|
#include "framework/common/fmk_error_codes.h"
|
|
|
|
namespace ge {
|
|
/// @ingroup math_util
|
|
/// @brief check whether int32 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckIntAddOverflow(int a, int b) {
|
|
if (((b > 0) && (a > (INT_MAX - b))) || ((b < 0) && (a < (INT_MIN - b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int8 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckInt8AddOverflow(int8_t a, int8_t b) {
|
|
if (((b > 0) && (a > (INT8_MAX - b))) || ((b < 0) && (a < (INT8_MIN - b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int16 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckInt16AddOverflow(int16_t a, int16_t b) {
|
|
if (((b > 0) && (a > (INT16_MAX - b))) || ((b < 0) && (a < (INT16_MIN - b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int32 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckInt32AddOverflow(int32_t a, int32_t b) {
|
|
if (((b > 0) && (a > (INT32_MAX - b))) || ((b < 0) && (a < (INT32_MIN - b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int64 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckInt64AddOverflow(int64_t a, int64_t b) {
|
|
if (((b > 0) && (a > (INT64_MAX - b))) || ((b < 0) && (a < (INT64_MIN - b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint8 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckUint8AddOverflow(uint8_t a, uint8_t b) {
|
|
if (a > (UINT8_MAX - b)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint16 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckUint16AddOverflow(uint16_t a, uint16_t b) {
|
|
if (a > (UINT16_MAX - b)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint32 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckUint32AddOverflow(uint32_t a, uint32_t b) {
|
|
if (a > (UINT32_MAX - b)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint64 addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckUint64AddOverflow(uint64_t a, uint64_t b) {
|
|
if (a > (UINT64_MAX - b)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether fp16_t addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFp16AddOverflow(fp16_t a, fp16_t b) {
|
|
fp16_t result = static_cast<fp16_t>(a) + static_cast<fp16_t>(b);
|
|
if (FP16_IS_INVALID(result.val)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether float addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFloatAddOverflow(float a, float b) {
|
|
if (std::isfinite(static_cast<float>(a) + static_cast<float>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether double addition can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckDoubleAddOverflow(double a, double b) {
|
|
if (std::isfinite(static_cast<double>(a) + static_cast<double>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckIntSubOverflow(int a, int b) {
|
|
if (((b > 0) && (a < (INT_MIN + b))) || ((b < 0) && (a > (INT_MAX + b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int8 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckInt8SubOverflow(int8_t a, int8_t b) {
|
|
if (((b > 0) && (a < (INT8_MIN + b))) || ((b < 0) && (a > (INT8_MAX + b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int16 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckInt16SubOverflow(int16_t a, int16_t b) {
|
|
if (((b > 0) && (a < (INT16_MIN + b))) || ((b < 0) && (a > (INT16_MAX + b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int32 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckInt32SubOverflow(int32_t a, int32_t b) {
|
|
if (((b > 0) && (a < (INT32_MIN + b))) || ((b < 0) && (a > (INT32_MAX + b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int64 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckInt64SubOverflow(int64_t a, int64_t b) {
|
|
if (((b > 0) && (a < (INT64_MIN + b))) || ((b < 0) && (a > (INT64_MAX + b)))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint8 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckUint8SubOverflow(uint8_t a, uint8_t b) {
|
|
if (a < b) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint16 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckUint16SubOverflow(uint16_t a, uint16_t b) {
|
|
if (a < b) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint32 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckUint32SubOverflow(uint32_t a, uint32_t b) {
|
|
if (a < b) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint64 subtraction can result in overflow
|
|
/// @param [in] a subtrahend
|
|
/// @param [in] b minuend
|
|
/// @return Status
|
|
inline Status CheckUint64SubOverflow(uint64_t a, uint64_t b) {
|
|
if (a < b) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether fp16_t subtraction can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFp16SubOverflow(fp16_t a, fp16_t b) {
|
|
fp16_t result = static_cast<fp16_t>(a) - static_cast<fp16_t>(b);
|
|
if (FP16_IS_INVALID(result.val)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether float subtraction can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFloatSubOverflow(float a, float b) {
|
|
if (std::isfinite(static_cast<float>(a) - static_cast<float>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether double subtraction can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckDoubleSubOverflow(double a, double b) {
|
|
if (std::isfinite(static_cast<double>(a) - static_cast<double>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckIntMulOverflow(int a, int b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int8 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckInt8MulOverflow(int8_t a, int8_t b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT8_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT8_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT8_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT8_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int16 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckInt16MulOverflow(int16_t a, int16_t b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT16_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT16_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT16_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT16_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int32 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckInt32MulOverflow(int32_t a, int32_t b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT32_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT32_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT32_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT32_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
///
|
|
/// @ingroup math_util
|
|
/// @brief check whether int64 int32 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
///
|
|
inline Status CheckInt64Int32MulOverflow(int64_t a, int32_t b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT64_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT64_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT64_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT64_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
/// @ingroup math_util
|
|
/// @brief check whether int64 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status Int64MulCheckOverflow(int64_t a, int64_t b) {
|
|
if (a > 0) {
|
|
if (b > 0) {
|
|
if (a > (INT64_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (b < (INT64_MIN / a)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
} else {
|
|
if (b > 0) {
|
|
if (a < (INT64_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if ((a != 0) && (b < (INT64_MAX / a))) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int64 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckInt64Uint32MulOverflow(int64_t a, uint32_t b) {
|
|
if (a == 0 || b == 0) {
|
|
return SUCCESS;
|
|
}
|
|
if (a > 0) {
|
|
if (a > (INT64_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
} else {
|
|
if (a < (INT64_MIN / b)) {
|
|
return FAILED;
|
|
}
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint8 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckUint8MulOverflow(uint8_t a, uint8_t b) {
|
|
if (a == 0 || b == 0) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (a > (UINT8_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint16 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckUint16MulOverflow(uint16_t a, uint16_t b) {
|
|
if (a == 0 || b == 0) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (a > (UINT16_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint32 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckUint32MulOverflow(uint32_t a, uint32_t b) {
|
|
if (a == 0 || b == 0) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (a > (UINT32_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether uint64 multiplication can result in overflow
|
|
/// @param [in] a multiplicator
|
|
/// @param [in] b multiplicator
|
|
/// @return Status
|
|
inline Status CheckUint64MulOverflow(uint64_t a, uint64_t b) {
|
|
if (a == 0 || b == 0) {
|
|
return SUCCESS;
|
|
}
|
|
|
|
if (a > (UINT64_MAX / b)) {
|
|
return FAILED;
|
|
}
|
|
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether fp16_t multiplication can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFp16MulOverflow(fp16_t a, fp16_t b) {
|
|
fp16_t result = static_cast<fp16_t>(a) * static_cast<fp16_t>(b);
|
|
if (FP16_IS_INVALID(result.val)) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether float multiplication can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckFloatMulOverflow(float a, float b) {
|
|
if (std::isfinite(static_cast<float>(a) * static_cast<float>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether double multiplication can result in overflow
|
|
/// @param [in] a addend
|
|
/// @param [in] b addend
|
|
/// @return Status
|
|
inline Status CheckDoubleMulOverflow(double a, double b) {
|
|
if (std::isfinite(static_cast<double>(a) * static_cast<double>(b)) == false) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int division can result in overflow
|
|
/// @param [in] a dividend
|
|
/// @param [in] b divisor
|
|
/// @return Status
|
|
inline Status CheckIntDivOverflow(int a, int b) {
|
|
if ((b == 0) || ((a == INT_MIN) && (b == -1))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
/// @ingroup math_util
|
|
/// @brief check whether int32 division can result in overflow
|
|
/// @param [in] a dividend
|
|
/// @param [in] b divisor
|
|
/// @return Status
|
|
inline Status CheckInt32DivOverflow(int32_t a, int32_t b) {
|
|
if ((b == 0) || ((a == INT32_MIN) && (b == -1))) {
|
|
return FAILED;
|
|
}
|
|
return SUCCESS;
|
|
}
|
|
|
|
#define FMK_INT_ADDCHECK(a, b) \
|
|
if (ge::CheckIntAddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int %d and %d addition can result in overflow!", static_cast<int>(a), \
|
|
static_cast<int>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT8_ADDCHECK(a, b) \
|
|
if (ge::CheckInt8AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int8 %d and %d addition can result in overflow!", static_cast<int8_t>(a), \
|
|
static_cast<int8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT16_ADDCHECK(a, b) \
|
|
if (ge::CheckInt16AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int16 %d and %d addition can result in overflow!", static_cast<int16_t>(a), \
|
|
static_cast<int16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT32_ADDCHECK(a, b) \
|
|
if (ge::CheckInt32AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int32 %d and %d addition can result in overflow!", static_cast<int32_t>(a), \
|
|
static_cast<int32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT64_ADDCHECK(a, b) \
|
|
if (ge::CheckInt64AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int64 %ld and %ld addition can result in overflow!", static_cast<int64_t>(a), \
|
|
static_cast<int64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT8_ADDCHECK(a, b) \
|
|
if (ge::CheckUint8AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint8 %u and %u addition can result in overflow!", static_cast<uint8_t>(a), \
|
|
static_cast<uint8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT16_ADDCHECK(a, b) \
|
|
if (ge::CheckUint16AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("UINT16 %u and %u addition can result in overflow!", static_cast<uint16_t>(a), \
|
|
static_cast<uint16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT32_ADDCHECK(a, b) \
|
|
if (ge::CheckUint32AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint32 %u and %u addition can result in overflow!", static_cast<uint32_t>(a), \
|
|
static_cast<uint32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT64_ADDCHECK(a, b) \
|
|
if (ge::CheckUint64AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint64 %lu and %lu addition can result in overflow!", static_cast<uint64_t>(a), \
|
|
static_cast<uint64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FP16_ADDCHECK(a, b) \
|
|
if (ge::CheckFp16AddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Fp16 %f and %f addition can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FLOAT_ADDCHECK(a, b) \
|
|
if (ge::CheckFloatAddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Float %f and %f addition can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_DOUBLE_ADDCHECK(a, b) \
|
|
if (ge::CheckDoubleAddOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Double %lf and %lf addition can result in overflow!", static_cast<double>(a), \
|
|
static_cast<double>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT_SUBCHECK(a, b) \
|
|
if (ge::CheckIntSubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int %d and %d subtraction can result in overflow!", static_cast<int>(a), \
|
|
static_cast<int>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT8_SUBCHECK(a, b) \
|
|
if (ge::CheckInt8SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int8 %d and %d subtraction can result in overflow!", static_cast<int8_t>(a), \
|
|
static_cast<int8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT16_SUBCHECK(a, b) \
|
|
if (ge::CheckInt16SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int16 %d and %d subtraction can result in overflow!", static_cast<int16_t>(a), \
|
|
static_cast<int16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT32_SUBCHECK(a, b) \
|
|
if (ge::CheckInt32SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int32 %d and %d subtraction can result in overflow!", static_cast<int32_t>(a), \
|
|
static_cast<int32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT64_SUBCHECK(a, b) \
|
|
if (ge::CheckInt64SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int64 %ld and %ld subtraction can result in overflow!", static_cast<int64_t>(a), \
|
|
static_cast<int64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT8_SUBCHECK(a, b) \
|
|
if (ge::CheckUint8SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint8 %u and %u subtraction can result in overflow!", static_cast<uint8_t>(a), \
|
|
static_cast<uint8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT16_SUBCHECK(a, b) \
|
|
if (ge::CheckUint16SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint16 %u and %u subtraction can result in overflow!", static_cast<uint16_t>(a), \
|
|
static_cast<uint16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT32_SUBCHECK(a, b) \
|
|
if (ge::CheckUint32SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint32 %u and %u subtraction can result in overflow!", static_cast<uint32_t>(a), \
|
|
static_cast<uint32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT64_SUBCHECK(a, b) \
|
|
if (ge::CheckUint64SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint64 %lu and %lu subtraction can result in overflow!", static_cast<uint64_t>(a), \
|
|
static_cast<uint64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FP16_SUBCHECK(a, b) \
|
|
if (ge::CheckFp16SubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Fp16 %f and %f subtraction can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FLOAT_SUBCHECK(a, b) \
|
|
if (ge::CheckFloatSubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Float %f and %f subtraction can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_DOUBLE_SUBCHECK(a, b) \
|
|
if (ge::CheckDoubleSubOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Double %lf and %lf subtraction can result in overflow!", static_cast<double>(a), \
|
|
static_cast<double>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT_MULCHECK(a, b) \
|
|
if (ge::CheckIntMulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int %d and %d multiplication can result in overflow!", static_cast<int>(a), \
|
|
static_cast<int>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT8_MULCHECK(a, b) \
|
|
if (ge::CheckInt8MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int8 %d and %d multiplication can result in overflow!", static_cast<int8_t>(a), \
|
|
static_cast<int8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT16_MULCHECK(a, b) \
|
|
if (ge::CheckInt16MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int16 %d and %d multiplication can result in overflow!", static_cast<int16_t>(a), \
|
|
static_cast<int16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT32_MULCHECK(a, b) \
|
|
if (ge::CheckInt32MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int32 %d and %d multiplication can result in overflow!", static_cast<int32_t>(a), \
|
|
static_cast<int32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT64_MULCHECK(a, b) \
|
|
if (ge::Int64MulCheckOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int64 %ld and %ld multiplication can result in overflow!", static_cast<int64_t>(a), \
|
|
static_cast<int64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT8_MULCHECK(a, b) \
|
|
if (ge::CheckUint8MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint8 %u and %u multiplication can result in overflow!", static_cast<uint8_t>(a), \
|
|
static_cast<uint8_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT16_MULCHECK(a, b) \
|
|
if (ge::CheckUint16MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint16 %u and %u multiplication can result in overflow!", static_cast<uint16_t>(a), \
|
|
static_cast<uint16_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT32_MULCHECK(a, b) \
|
|
if (ge::CheckUint32MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint32 %u and %u multiplication can result in overflow!", static_cast<uint32_t>(a), \
|
|
static_cast<uint32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_UINT64_MULCHECK(a, b) \
|
|
if (ge::CheckUint64MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Uint64 %lu and %lu multiplication can result in overflow!", static_cast<uint64_t>(a), \
|
|
static_cast<uint64_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FP16_MULCHECK(a, b) \
|
|
if (ge::CheckFp16MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Fp16 %f and %f multiplication can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FLOAT_MULCHECK(a, b) \
|
|
if (ge::CheckFloatMulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Float %f and %f multiplication can result in overflow!", static_cast<float>(a), \
|
|
static_cast<float>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_DOUBLE_MULCHECK(a, b) \
|
|
if (ge::CheckDoubleMulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Double %lf and %lf multiplication can result in overflow!", static_cast<double>(a), \
|
|
static_cast<double>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT_DIVCHECK(a, b) \
|
|
if (CheckIntDivOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int %d and %d division can result in overflow!", static_cast<int>(a), \
|
|
static_cast<int>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT32_DIVCHECK(a, b) \
|
|
if (CheckInt32DivOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int32 %d and %d division can result in overflow!", static_cast<int32_t>(a), \
|
|
static_cast<int32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_INT64_UINT32_MULCHECK(a, b) \
|
|
if (ge::CheckInt64Uint32MulOverflow((a), (b)) != SUCCESS) { \
|
|
GELOGW("Int64 %ld and Uint32 %u multiplication can result in overflow!", static_cast<int64_t>(a), \
|
|
static_cast<uint32_t>(b)); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FP16_ZEROCHECK(a) \
|
|
if (fabs(a) < DBL_EPSILON || a < 0) { \
|
|
GELOGW("Fp16 %f can not less than or equal to zero! ", a); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_FLOAT_ZEROCHECK(a) \
|
|
if (fabs(a) < FLT_EPSILON || a < 0) { \
|
|
GELOGW("Float %f can not less than or equal to zero! ", a); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
|
|
#define FMK_DOUBLE_ZEROCHECK(a) \
|
|
if (fabs(a) < DBL_EPSILON || a < 0) { \
|
|
GELOGW("Double %lf can not less than or equal to zero! ", a); \
|
|
return INTERNAL_ERROR; \
|
|
}
|
|
} // namespace ge
|
|
#endif // GE_COMMON_MATH_MATH_UTIL_H_
|