diff options
Diffstat (limited to 'src/common')
| -rw-r--r-- | src/common/AllocatorWrapper.cpp | 65 | ||||
| -rw-r--r-- | src/common/AllocatorWrapper.h | 81 | ||||
| -rw-r--r-- | src/common/IContext.h | 127 | ||||
| -rw-r--r-- | src/common/Types.h | 56 | ||||
| -rw-r--r-- | src/common/utils/Log.h | 80 | ||||
| -rw-r--r-- | src/common/utils/Macros.h | 37 | ||||
| -rw-r--r-- | src/common/utils/Object.h | 65 | ||||
| -rw-r--r-- | src/common/utils/Utils.h | 67 | ||||
| -rw-r--r-- | src/common/utils/Validate.h | 41 |
9 files changed, 619 insertions, 0 deletions
diff --git a/src/common/AllocatorWrapper.cpp b/src/common/AllocatorWrapper.cpp new file mode 100644 index 0000000000..7b5bb34433 --- /dev/null +++ b/src/common/AllocatorWrapper.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include "src/common/AllocatorWrapper.h" +#include "arm_compute/core/Error.h" + +namespace arm_compute +{ +AllocatorWrapper::AllocatorWrapper(const AclAllocator &backing_allocator) noexcept + : _backing_allocator(backing_allocator) +{ +} + +void *AllocatorWrapper::alloc(size_t size) +{ + ARM_COMPUTE_ERROR_ON(_backing_allocator.alloc == nullptr); + return _backing_allocator.alloc(_backing_allocator.user_data, size); +} + +void AllocatorWrapper::free(void *ptr) +{ + ARM_COMPUTE_ERROR_ON(_backing_allocator.free == nullptr); + _backing_allocator.free(_backing_allocator.user_data, ptr); +} + +void *AllocatorWrapper::aligned_alloc(size_t size, size_t alignment) +{ + ARM_COMPUTE_ERROR_ON(_backing_allocator.aligned_alloc == nullptr); + return _backing_allocator.aligned_alloc(_backing_allocator.user_data, size, alignment); +} + +void AllocatorWrapper::aligned_free(void *ptr) +{ + ARM_COMPUTE_ERROR_ON(_backing_allocator.aligned_free == nullptr); + _backing_allocator.aligned_free(_backing_allocator.user_data, ptr); +} + +void AllocatorWrapper::set_user_data(void *user_data) +{ + if(user_data != nullptr) + { + _backing_allocator.user_data = user_data; + } +} +} // namespace arm_compute diff --git a/src/common/AllocatorWrapper.h b/src/common/AllocatorWrapper.h new file mode 100644 index 0000000000..5e1f138f16 --- /dev/null +++ b/src/common/AllocatorWrapper.h @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_ALLOCATORWRAPPER_H +#define SRC_COMMON_ALLOCATORWRAPPER_H + +#include "arm_compute/AclTypes.h" + +namespace arm_compute +{ +/** Default malloc allocator implementation */ +class AllocatorWrapper final +{ +public: + /** Default Constructor + * + * @param[in] backing_allocator Backing memory allocator to be used + */ + AllocatorWrapper(const AclAllocator &backing_allocator) noexcept; + AllocatorWrapper(const AllocatorWrapper &) noexcept = default; + AllocatorWrapper(AllocatorWrapper &&) noexcept = default; + AllocatorWrapper &operator=(const AllocatorWrapper &) noexcept = delete; + AllocatorWrapper &operator=(AllocatorWrapper &&other) noexcept = default; + /** Allocate a chunk of memory of a given size in bytes + * + * @param[in] size Size of memory to allocate in bytes + * + * @return A pointer to the allocated memory if successful else nullptr + */ + void *alloc(size_t size); + /** Free an allocated memory block + * + * @param[in] ptr Pointer to allocated memory + */ + void free(void *ptr); + /** Allocate a chunk of memory of a given size in bytes, + * while honoring a given alignment requirement + * + * @param[in] size Size of memory to allocate in bytes + * @param[in] alignment Alignment requirements + * + * @return A pointer to the allocated memory if successful else nullptr + */ + void *aligned_alloc(size_t size, size_t alignment); + /** Free an aligned memory block + * + * @param[in] ptr Pointer to the memory to release + */ + void aligned_free(void *ptr); + /** Set user data to be used by the allocator + * + * @param[in] user_data User data to be used by the allocator + */ + void set_user_data(void *user_data); + +private: + AclAllocator _backing_allocator; +}; +} // namespace arm_compute + +#endif /* SRC_COMMON_ALLOCATORWRAPPER_H */
\ No newline at end of file diff --git a/src/common/IContext.h b/src/common/IContext.h new file mode 100644 index 0000000000..0d23abd2be --- /dev/null +++ b/src/common/IContext.h @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_ICONTEXT_H +#define SRC_COMMON_ICONTEXT_H + +#include "src/common/Types.h" +#include "src/common/utils/Log.h" +#include "src/common/utils/Object.h" + +#include <atomic> + +struct AclContext_ +{ + arm_compute::detail::Header header{ arm_compute::detail::ObjectType::Context, nullptr }; + +protected: + AclContext_() = default; + ~AclContext_() = default; +}; + +namespace arm_compute +{ +/**< Context interface */ +class IContext : public AclContext_ +{ +public: + IContext(Target target) + : AclContext_(), _target(target), _refcount(0) + { + } + /** Virtual Destructor */ + virtual ~IContext() + { + header.type = detail::ObjectType::Invalid; + }; + /** Target type accessor + * + * @return Target that the context is associated with + */ + Target type() const + { + return _target; + } + /** Increment context refcount */ + void inc_ref() const + { + ++_refcount; + } + /** Decrement context refcount */ + void dec_ref() const + { + --_refcount; + } + /** Reference counter accessor + * + * @return The number of references pointing to this object + */ + int refcount() const + { + return _refcount; + } + /** Checks if an object is valid + * + * @return True if sucessful otherwise false + */ + bool is_valid() const + { + return header.type == detail::ObjectType::Context; + } + +private: + Target _target; /**< Target type of context */ + mutable std::atomic<int> _refcount; /**< Reference counter */ +}; + +/** Extract internal representation of a Context + * + * @param[in] ctx Opaque context pointer + * + * @return The internal representation as an IContext + */ +inline IContext *get_internal(AclContext ctx) +{ + return static_cast<IContext *>(ctx); +} + +namespace detail +{ +/** Check if an internal context is valid + * + * @param[in] ctx Internal context to check + * + * @return A status code + */ +inline StatusCode validate_internal_context(const IContext *ctx) +{ + if(ctx == nullptr || !ctx->is_valid()) + { + ARM_COMPUTE_LOG_ERROR_ACL("Invalid context object"); + return StatusCode::InvalidArgument; + } + return StatusCode::Success; +} +} // namespace detail +} // namespace arm_compute +#endif /* SRC_COMMON_ICONTEXT_H */ diff --git a/src/common/Types.h b/src/common/Types.h new file mode 100644 index 0000000000..60a11b04ec --- /dev/null +++ b/src/common/Types.h @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_TYPES_H_ +#define SRC_COMMON_TYPES_H_ + +#include "arm_compute/AclTypes.h" + +namespace arm_compute +{ +enum class StatusCode +{ + Success = AclSuccess, + RuntimeError = AclRuntimeError, + OutOfMemory = AclOutOfMemory, + Unimplemented = AclUnimplemented, + UnsupportedTarget = AclUnsupportedTarget, + InvalidTarget = AclInvalidTarget, + InvalidArgument = AclInvalidArgument, + UnsupportedConfig = AclUnsupportedConfig, + InvalidObjectState = AclInvalidObjectState, +}; + +enum class Target +{ + Cpu = AclTarget::AclCpu, + GpuOcl = AclTarget::AclGpuOcl, +}; + +enum class ExecutionMode +{ + FastRerun = AclPreferFastRerun, + FastStart = AclPreferFastStart, +}; +} // namespace arm_compute +#endif /* SRC_COMMON_TYPES_H_ */ diff --git a/src/common/utils/Log.h b/src/common/utils/Log.h new file mode 100644 index 0000000000..0d6a50da92 --- /dev/null +++ b/src/common/utils/Log.h @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_LOG_H +#define SRC_COMMON_LOG_H + +#include "arm_compute/core/Error.h" +#include "arm_compute/core/utils/logging/Macros.h" + +#ifdef ARM_COMPUTE_LOGGING_ENABLED +/** Create a logger + * + * @note It will eventually create all default loggers in don't exist + */ +#define ARM_COMPUTE_CREATE_ACL_LOGGER() \ + do \ + { \ + if(arm_compute::logging::LoggerRegistry::get().logger("ComputeLibrary") == nullptr) \ + { \ + arm_compute::logging::LoggerRegistry::get().create_logger("ComputeLibrary", arm_compute::logging::LogLevel::INFO); \ + } \ + } while(false) +#else /* ARM_COMPUTE_LOGGING_ENABLED */ +#define ARM_COMPUTE_CREATE_ACL_LOGGER() +#endif /* ARM_COMPUTE_LOGGING_ENABLED */ +/** Log a message to the logger + * + * @param[in] log_level Logging level + * @param[in] msg Message to log + */ +#define ARM_COMPUTE_LOG_MSG_ACL(log_level, msg) \ + do \ + { \ + ARM_COMPUTE_CREATE_ACL_LOGGER(); \ + ARM_COMPUTE_LOG_MSG("ComputeLibrary", log_level, msg); \ + } while(false) +/** Log a message with format to the logger + * + * @param[in] log_level Logging level + * @param[in] fmt String format (printf style) + * @param[in] ... Message arguments + */ +#define ARM_COMPUTE_LOG_MSG_WITH_FORMAT_ACL(log_level, fmt, ...) \ + do \ + { \ + ARM_COMPUTE_CREATE_ACL_LOGGER(); \ + ARM_COMPUTE_LOG_MSG_WITH_FORMAT("ComputeLibrary", log_level, fmt, __VA_ARGS__); \ + } while(false) +/** Log an error message to the logger + * + * @param[in] msg Message to log + */ +#define ARM_COMPUTE_LOG_ERROR_ACL(msg) \ + do \ + { \ + ARM_COMPUTE_CREATE_ACL_LOGGER(); \ + ARM_COMPUTE_LOG_MSG("ComputeLibrary", arm_compute::logging::LogLevel::ERROR, msg); \ + } while(false) + +#endif /* SRC_COMMON_LOG_H */ diff --git a/src/common/utils/Macros.h b/src/common/utils/Macros.h new file mode 100644 index 0000000000..2e44ea599e --- /dev/null +++ b/src/common/utils/Macros.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_MACROS_H_ +#define SRC_COMMON_MACROS_H_ + +#include "src/common/utils/Utils.h" + +#define ARM_COMPUTE_RETURN_CENUM_ON_FAILURE(status) \ + { \ + if(status != arm_compute::StatusCode::Success) \ + { \ + return arm_compute::utils::as_cenum<AclStatus>(status); \ + } \ + } + +#endif /* SRC_COMMON_MACROS_H_ */ diff --git a/src/common/utils/Object.h b/src/common/utils/Object.h new file mode 100644 index 0000000000..6f56f77d3c --- /dev/null +++ b/src/common/utils/Object.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_OBJECT_H_ +#define SRC_COMMON_OBJECT_H_ + +#include <cstdint> + +namespace arm_compute +{ +// Forward declarations +class IContext; + +namespace detail +{ +/**< Object type enumerations */ +enum class ObjectType : uint32_t +{ + Context = 1, + Queue = 2, + Tensor = 3, + TensorPack = 4, + Operator = 5, + Invalid = 0x56DEAD78 +}; + +/**< API Header meta-data construct used by all opaque constructs */ +struct Header +{ + /** Constructor + * + * @param[in] type_ Object identification type + * @param[in] ctx_ Context to reference + */ + Header(ObjectType type_, IContext *ctx_) + : type(type_), ctx(ctx_) + { + } + + ObjectType type{ ObjectType::Invalid }; + IContext *ctx{ nullptr }; +}; +} // namespace detail +} // namespace arm_compute +#endif /* SRC_COMMON_OBJECT_H_ */ diff --git a/src/common/utils/Utils.h b/src/common/utils/Utils.h new file mode 100644 index 0000000000..9602c32f62 --- /dev/null +++ b/src/common/utils/Utils.h @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SRC_COMMON_UTILS_H +#define SRC_COMMON_UTILS_H + +#include <type_traits> + +namespace arm_compute +{ +namespace utils +{ +/** Convert a strongly typed enum to an old plain c enum + * + * @tparam E Plain old C enum + * @tparam SE Strongly typed resulting enum + * + * @param[in] v Value to convert + * + * @return A corresponding plain old C enumeration + */ +template <typename E, typename SE> +constexpr E as_cenum(SE v) noexcept +{ + return static_cast<E>(static_cast<std::underlying_type_t<SE>>(v)); +} +/** Check if the given value is in the given enum value list + * + * @tparam E The type of the enum + * + * @param[in] check Value to check + * @param[in] list List of enum values to check against + * + * @return True if the given value is found in the list + */ +template <typename E> +bool is_in(E check, std::initializer_list<E> list) +{ + return std::any_of(std::cbegin(list), std::cend(list), [&check](E e) + { + return check == e; + }); +} +} // namespace utils +} // namespace arm_compute + +#endif /* SRC_COMMON_UTILS_H */ diff --git a/src/common/utils/Validate.h b/src/common/utils/Validate.h new file mode 100644 index 0000000000..4e8807273a --- /dev/null +++ b/src/common/utils/Validate.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2020-2021 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef SRC_CORE_COMMON_VALIDATE_H +#define SRC_CORE_COMMON_VALIDATE_H + +#if defined(ARM_COMPUTE_ASSERTS_ENABLED) + +#include <cassert> + +#define ARM_COMPUTE_ASSERT(cond) assert(cond) +#define ARM_COMPUTE_ASSERT_NOT_NULLPTR(ptr) assert((ptr) != nullptr) + +#else /* defined(ARM_COMPUTE_ASSERTS_ENABLED) */ + +#define ARM_COMPUTE_ASSERT(cond) +#define ARM_COMPUTE_ASSERT_NOT_NULLPTR(ptr) + +#endif /* defined(ARM_COMPUTE_ASSERTS_ENABLED) */ +#endif /* SRC_CORE_COMMON_VALIDATE_H */ |