diff options
Diffstat (limited to 'runtimes/nn/depend/libhidl/base/include')
3 files changed, 0 insertions, 1455 deletions
diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h b/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h deleted file mode 100644 index 39f80f09b..000000000 --- a/runtimes/nn/depend/libhidl/base/include/hidl/HidlInternal.h +++ /dev/null @@ -1,193 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * - * 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 ANDROID_HIDL_INTERNAL_H -#define ANDROID_HIDL_INTERNAL_H - -#include <cstdint> -#include <dirent.h> -#include <functional> -#include <string> -#include <vector> -#include <utility> - -namespace android { -namespace hardware { -namespace details { - -//Templated classes can use the below method -//to avoid creating dependencies on liblog. -void logAlwaysFatal(const char *message); - -// HIDL client/server code should *NOT* use this class. -// -// hidl_pointer wraps a pointer without taking ownership, -// and stores it in a union with a uint64_t. This ensures -// that we always have enough space to store a pointer, -// regardless of whether we're running in a 32-bit or 64-bit -// process. -template<typename T> -struct hidl_pointer { - hidl_pointer() - : _pad(0) { - } - hidl_pointer(T* ptr) : hidl_pointer() { mPointer = ptr; } - hidl_pointer(const hidl_pointer<T>& other) : hidl_pointer() { mPointer = other.mPointer; } - hidl_pointer(hidl_pointer<T>&& other) : hidl_pointer() { *this = std::move(other); } - - hidl_pointer &operator=(const hidl_pointer<T>& other) { - mPointer = other.mPointer; - return *this; - } - hidl_pointer &operator=(hidl_pointer<T>&& other) { - mPointer = other.mPointer; - other.mPointer = nullptr; - return *this; - } - hidl_pointer &operator=(T* ptr) { - mPointer = ptr; - return *this; - } - - operator T*() const { - return mPointer; - } - explicit operator void*() const { // requires explicit cast to avoid ambiguity - return mPointer; - } - T& operator*() const { - return *mPointer; - } - T* operator->() const { - return mPointer; - } - T &operator[](size_t index) { - return mPointer[index]; - } - const T &operator[](size_t index) const { - return mPointer[index]; - } - -private: - union { - T* mPointer; - uint64_t _pad; - }; -}; - -#define HAL_LIBRARY_PATH_SYSTEM_64BIT "/system/lib64/hw/" -#define HAL_LIBRARY_PATH_VNDK_SP_64BIT "/system/lib64/vndk-sp/hw/" -#define HAL_LIBRARY_PATH_VENDOR_64BIT "/vendor/lib64/hw/" -#define HAL_LIBRARY_PATH_ODM_64BIT "/odm/lib64/hw/" -#define HAL_LIBRARY_PATH_SYSTEM_32BIT "/system/lib/hw/" -#define HAL_LIBRARY_PATH_VNDK_SP_32BIT "/system/lib/vndk-sp/hw/" -#define HAL_LIBRARY_PATH_VENDOR_32BIT "/vendor/lib/hw/" -#define HAL_LIBRARY_PATH_ODM_32BIT "/odm/lib/hw/" - -#if defined(__LP64__) -#define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_64BIT -#define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_64BIT -#define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_64BIT -#define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_64BIT -#else -#define HAL_LIBRARY_PATH_SYSTEM HAL_LIBRARY_PATH_SYSTEM_32BIT -#define HAL_LIBRARY_PATH_VNDK_SP HAL_LIBRARY_PATH_VNDK_SP_32BIT -#define HAL_LIBRARY_PATH_VENDOR HAL_LIBRARY_PATH_VENDOR_32BIT -#define HAL_LIBRARY_PATH_ODM HAL_LIBRARY_PATH_ODM_32BIT -#endif - -#if 0 // REF-ANN -// ---------------------------------------------------------------------- -// Class that provides Hidl instrumentation utilities. -struct HidlInstrumentor { - // Event that triggers the instrumentation. e.g. enter of an API call on - // the server/client side, exit of an API call on the server/client side - // etc. - enum InstrumentationEvent { - SERVER_API_ENTRY = 0, - SERVER_API_EXIT, - CLIENT_API_ENTRY, - CLIENT_API_EXIT, - SYNC_CALLBACK_ENTRY, - SYNC_CALLBACK_EXIT, - ASYNC_CALLBACK_ENTRY, - ASYNC_CALLBACK_EXIT, - PASSTHROUGH_ENTRY, - PASSTHROUGH_EXIT, - }; - - // Signature of the instrumentation callback function. - using InstrumentationCallback = std::function<void( - const InstrumentationEvent event, - const char *package, - const char *version, - const char *interface, - const char *method, - std::vector<void *> *args)>; - - explicit HidlInstrumentor( - const std::string &package, - const std::string &insterface); - virtual ~HidlInstrumentor(); - - public: - const std::vector<InstrumentationCallback>& getInstrumentationCallbacks() { - return mInstrumentationCallbacks; - } - bool isInstrumentationEnabled() { return mEnableInstrumentation; } - - protected: - // Set mEnableInstrumentation based on system property - // hal.instrumentation.enable, register/de-register instrumentation - // callbacks if mEnableInstrumentation is true/false. - void configureInstrumentation(bool log=true); - // Function that lookup and dynamically loads the hidl instrumentation - // libraries and registers the instrumentation callback functions. - // - // The instrumentation libraries should be stored under any of the following - // directories: HAL_LIBRARY_PATH_SYSTEM, HAL_LIBRARY_PATH_VNDK_SP, - // HAL_LIBRARY_PATH_VENDOR and HAL_LIBRARY_PATH_ODM. - // The name of instrumentation libraries should follow pattern: - // ^profilerPrefix(.*).profiler.so$ - // - // Each instrumentation library is expected to implement the instrumentation - // function called HIDL_INSTRUMENTATION_FUNCTION. - // - // A no-op for user build. - void registerInstrumentationCallbacks( - std::vector<InstrumentationCallback> *instrumentationCallbacks); - - // Utility function to determine whether a give file is a instrumentation - // library (i.e. the file name follow the expected pattern). - bool isInstrumentationLib(const dirent *file); - - // A list of registered instrumentation callbacks. - std::vector<InstrumentationCallback> mInstrumentationCallbacks; - // Flag whether to enable instrumentation. - bool mEnableInstrumentation; - // Prefix to lookup the instrumentation libraries. - std::string mInstrumentationLibPackage; - // Used for dlsym to load the profiling method for given interface. - std::string mInterfaceName; - -}; -#endif - -} // namespace details -} // namespace hardware -} // namespace android - -#endif // ANDROID_HIDL_INTERNAL_H diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h b/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h deleted file mode 100644 index bc8d56ea7..000000000 --- a/runtimes/nn/depend/libhidl/base/include/hidl/HidlSupport.h +++ /dev/null @@ -1,989 +0,0 @@ -/* - * Copyright (C) 2016 The Android Open Source Project - * - * 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 ANDROID_HIDL_SUPPORT_H -#define ANDROID_HIDL_SUPPORT_H - -#include <cstring> - -#include <string> -#include <iterator> -#include <cutils/native_handle.h> -#include <hidl/HidlInternal.h> -#include <map> -#include <stddef.h> -#include <tuple> -#include <type_traits> -#include <utils/StrongPointer.h> -#include <utils/RefBase.h> - -#if 0 // REF-ANN -#include <algorithm> -#include <array> -#include <iterator> -#include <cutils/native_handle.h> -#include <hidl/HidlInternal.h> -#include <hidl/Status.h> -#include <map> -#include <sstream> -#include <stddef.h> -#include <tuple> -#include <type_traits> -#include <utils/Errors.h> -#include <utils/RefBase.h> -#include <vector> -#endif - -namespace android { - -// this file is included by all hidl interface, so we must forward declare the -// IMemory and IBase types. -namespace hidl { -namespace memory { -namespace V1_0 { - struct IMemory; -}; // namespace V1_0 -}; // namespace manager -}; // namespace hidl - -namespace hidl { -namespace base { -namespace V1_0 { - struct IBase; -}; // namespace V1_0 -}; // namespace base -}; // namespace hidl - -namespace hardware { - -#if 0 // REF-ANN -namespace details { -// Return true on userdebug / eng builds and false on user builds. -bool debuggable(); -} // namespace details - -// hidl_death_recipient is a callback interfaced that can be used with -// linkToDeath() / unlinkToDeath() -struct hidl_death_recipient : public virtual RefBase { - virtual void serviceDied(uint64_t cookie, - const ::android::wp<::android::hidl::base::V1_0::IBase>& who) = 0; -}; - -// hidl_handle wraps a pointer to a native_handle_t in a hidl_pointer, -// so that it can safely be transferred between 32-bit and 64-bit processes. -// The ownership semantics for this are: -// 1) The conversion constructor and assignment operator taking a const native_handle_t* -// do not take ownership of the handle; this is because these operations are usually -// just done for IPC, and cloning by default is a waste of resources. If you want -// a hidl_handle to take ownership, call setTo(handle, true /*shouldOwn*/); -// 2) The copy constructor/assignment operator taking a hidl_handle *DO* take ownership; -// that is because it's not intuitive that this class encapsulates a native_handle_t -// which needs cloning to be valid; in particular, this allows constructs like this: -// hidl_handle copy; -// foo->someHidlCall([&](auto incoming_handle) { -// copy = incoming_handle; -// }); -// // copy and its enclosed file descriptors will remain valid here. -// 3) The move constructor does what you would expect; it only owns the handle if the -// original did. -struct hidl_handle { - hidl_handle(); - ~hidl_handle(); - - hidl_handle(const native_handle_t *handle); - - // copy constructor. - hidl_handle(const hidl_handle &other); - - // move constructor. - hidl_handle(hidl_handle &&other) noexcept; - - // assignment operators - hidl_handle &operator=(const hidl_handle &other); - - hidl_handle &operator=(const native_handle_t *native_handle); - - hidl_handle &operator=(hidl_handle &&other) noexcept; - - void setTo(native_handle_t* handle, bool shouldOwn = false); - - const native_handle_t* operator->() const; - - // implicit conversion to const native_handle_t* - operator const native_handle_t *() const; - - // explicit conversion - const native_handle_t *getNativeHandle() const; -private: - void freeHandle(); - - details::hidl_pointer<const native_handle_t> mHandle __attribute__ ((aligned(8))); - bool mOwnsHandle __attribute ((aligned(8))); -}; -#endif - -struct hidl_string { - hidl_string(); - ~hidl_string(); - - // copy constructor. - hidl_string(const hidl_string &); - // copy from a C-style string. nullptr will create an empty string - hidl_string(const char *); - // copy the first length characters from a C-style string. - hidl_string(const char *, size_t length); - // copy from an std::string. - hidl_string(const std::string &); - - // move constructor. - hidl_string(hidl_string &&) noexcept; - - const char *c_str() const; - size_t size() const; - bool empty() const; - - // copy assignment operator. - hidl_string &operator=(const hidl_string &); - // copy from a C-style string. - hidl_string &operator=(const char *s); - // copy from an std::string. - hidl_string &operator=(const std::string &); - // move assignment operator. - hidl_string &operator=(hidl_string &&other) noexcept; - // cast to std::string. - operator std::string() const; - - void clear(); - - // Reference an external char array. Ownership is _not_ transferred. - // Caller is responsible for ensuring that underlying memory is valid - // for the lifetime of this hidl_string. - void setToExternal(const char *data, size_t size); - - // offsetof(hidl_string, mBuffer) exposed since mBuffer is private. - static const size_t kOffsetOfBuffer; - -private: - details::hidl_pointer<const char> mBuffer; - uint32_t mSize; // NOT including the terminating '\0'. - bool mOwnsBuffer; // if true then mBuffer is a mutable char * - - // copy from data with size. Assume that my memory is freed - // (through clear(), for example) - void copyFrom(const char *data, size_t size); - // move from another hidl_string - void moveFrom(hidl_string &&); -}; - -#define HIDL_STRING_OPERATOR(OP) \ - inline bool operator OP(const hidl_string &hs1, const hidl_string &hs2) { \ - return strcmp(hs1.c_str(), hs2.c_str()) OP 0; \ - } \ - inline bool operator OP(const hidl_string &hs, const char *s) { \ - return strcmp(hs.c_str(), s) OP 0; \ - } \ - inline bool operator OP(const char *s, const hidl_string &hs) { \ - return strcmp(hs.c_str(), s) OP 0; \ - } - -HIDL_STRING_OPERATOR(==) -HIDL_STRING_OPERATOR(!=) -HIDL_STRING_OPERATOR(<) -HIDL_STRING_OPERATOR(<=) -HIDL_STRING_OPERATOR(>) -HIDL_STRING_OPERATOR(>=) - -#undef HIDL_STRING_OPERATOR - -// Send our content to the output stream -std::ostream& operator<<(std::ostream& os, const hidl_string& str); - - -// hidl_memory is a structure that can be used to transfer -// pieces of shared memory between processes. The assumption -// of this object is that the memory remains accessible as -// long as the file descriptors in the enclosed mHandle -// - as well as all of its cross-process dups() - remain opened. -struct hidl_memory { - - hidl_memory() : mHandle(nullptr), mSize(0), mName("") { - } - - /** - * Creates a hidl_memory object, but doesn't take ownership of - * the passed in native_handle_t; callers are responsible for - * making sure the handle remains valid while this object is - * used. - */ - hidl_memory(const std::string &name, const native_handle_t *handle, size_t size) -#if 0 // REF-ANN - hidl_memory(const hidl_string &name, const native_handle_t *handle, size_t size) -#endif - : mHandle(handle), - mSize(size), - mName(name) - {} - - // copy constructor - hidl_memory(const hidl_memory& other) { - *this = other; - } - - // copy assignment - hidl_memory &operator=(const hidl_memory &other) { - if (this != &other) { - mHandle = other.mHandle; - mSize = other.mSize; - mName = other.mName; - } - - return *this; - } - - // move constructor - hidl_memory(hidl_memory&& other) noexcept { - *this = std::move(other); - } - - // move assignment - hidl_memory &operator=(hidl_memory &&other) noexcept { - if (this != &other) { - mHandle = std::move(other.mHandle); - mSize = other.mSize; - mName = std::move(other.mName); - other.mSize = 0; - } - - return *this; - } - - - ~hidl_memory() { - } - - const native_handle_t* handle() const { - return mHandle; - } - - const hidl_string &name() const { - return mName; - } - - uint64_t size() const { - return mSize; - } - - // offsetof(hidl_memory, mHandle) exposed since mHandle is private. - static const size_t kOffsetOfHandle; - // offsetof(hidl_memory, mName) exposed since mHandle is private. - static const size_t kOffsetOfName; - -private: - const native_handle_t *mHandle __attribute__ ((aligned(8))); // TODO-NNRT: This was hidl_handle. - uint64_t mSize __attribute__ ((aligned(8))); - hidl_string mName __attribute__ ((aligned(8))); -#if 0 // REF-ANN - hidl_handle mHandle __attribute__ ((aligned(8))); - uint64_t mSize __attribute__ ((aligned(8))); - hidl_string mName __attribute__ ((aligned(8))); -#endif -}; - -//////////////////////////////////////////////////////////////////////////////// - -template<typename T> -struct hidl_vec { - hidl_vec() - : mBuffer(NULL), - mSize(0), - mOwnsBuffer(true) { - static_assert(hidl_vec<T>::kOffsetOfBuffer == 0, "wrong offset"); - } - - // Note, does not initialize primitive types. - hidl_vec(size_t size) : hidl_vec() { resize(size); } - - hidl_vec(const hidl_vec<T> &other) : hidl_vec() { - *this = other; - } - - hidl_vec(hidl_vec<T> &&other) noexcept - : mOwnsBuffer(false) { - *this = std::move(other); - } - - hidl_vec(const std::initializer_list<T> list) - : mOwnsBuffer(true) { - if (list.size() > UINT32_MAX) { -#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal - details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements."); -#endif - } - mSize = static_cast<uint32_t>(list.size()); - mBuffer = new T[mSize]; - - size_t idx = 0; - for (auto it = list.begin(); it != list.end(); ++it) { - mBuffer[idx++] = *it; - } - } - - hidl_vec(const std::vector<T> &other) : hidl_vec() { - *this = other; - } - - template <typename InputIterator, - typename = typename std::enable_if<std::is_convertible< - typename std::iterator_traits<InputIterator>::iterator_category, - std::input_iterator_tag>::value>::type> - hidl_vec(InputIterator first, InputIterator last) : mOwnsBuffer(true) { - auto size = std::distance(first, last); - if (size > static_cast<int64_t>(UINT32_MAX)) { -#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal - details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements."); -#endif - } - if (size < 0) { -#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal - details::logAlwaysFatal("size can't be negative."); -#endif - } - mSize = static_cast<uint32_t>(size); - mBuffer = new T[mSize]; - - size_t idx = 0; - for (; first != last; ++first) { - mBuffer[idx++] = static_cast<T>(*first); - } - } - - ~hidl_vec() { - if (mOwnsBuffer) { - delete[] mBuffer; - } - mBuffer = NULL; - } - - // Reference an existing array, optionally taking ownership. It is the - // caller's responsibility to ensure that the underlying memory stays - // valid for the lifetime of this hidl_vec. - void setToExternal(T *data, size_t size, bool shouldOwn = false) { - if (mOwnsBuffer) { - delete [] mBuffer; - } - mBuffer = data; - if (size > UINT32_MAX) { -#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal - details::logAlwaysFatal("external vector size exceeds 2^32 elements."); -#endif - } - mSize = static_cast<uint32_t>(size); - mOwnsBuffer = shouldOwn; - } - - T *data() { - return mBuffer; - } - - const T *data() const { - return mBuffer; - } - - T *releaseData() { - if (!mOwnsBuffer && mSize > 0) { - resize(mSize); - } - mOwnsBuffer = false; - return mBuffer; - } - - hidl_vec &operator=(hidl_vec &&other) noexcept { - if (mOwnsBuffer) { - delete[] mBuffer; - } - mBuffer = other.mBuffer; - mSize = other.mSize; - mOwnsBuffer = other.mOwnsBuffer; - other.mOwnsBuffer = false; - return *this; - } - - hidl_vec &operator=(const hidl_vec &other) { - if (this != &other) { - if (mOwnsBuffer) { - delete[] mBuffer; - } - copyFrom(other, other.mSize); - } - - return *this; - } - - // copy from an std::vector. - hidl_vec &operator=(const std::vector<T> &other) { - if (mOwnsBuffer) { - delete[] mBuffer; - } - copyFrom(other, other.size()); - return *this; - } - - // cast to an std::vector. - operator std::vector<T>() const { - std::vector<T> v(mSize); - for (size_t i = 0; i < mSize; ++i) { - v[i] = mBuffer[i]; - } - return v; - } - - // equality check, assuming that T::operator== is defined. - bool operator==(const hidl_vec &other) const { - if (mSize != other.size()) { - return false; - } - for (size_t i = 0; i < mSize; ++i) { - if (!(mBuffer[i] == other.mBuffer[i])) { - return false; - } - } - return true; - } - - // inequality check, assuming that T::operator== is defined. - inline bool operator!=(const hidl_vec &other) const { - return !((*this) == other); - } - - size_t size() const { - return mSize; - } - - T &operator[](size_t index) { - return mBuffer[index]; - } - - const T &operator[](size_t index) const { - return mBuffer[index]; - } - - void resize(size_t size) { - if (size > UINT32_MAX) { -#if 0 // TODO-NNRT : Implement dummy logAlwaysFatal - details::logAlwaysFatal("hidl_vec can't hold more than 2^32 elements."); -#endif - } - T *newBuffer = new T[size]; - - for (size_t i = 0; i < std::min(static_cast<uint32_t>(size), mSize); ++i) { - newBuffer[i] = mBuffer[i]; - } - - if (mOwnsBuffer) { - delete[] mBuffer; - } - mBuffer = newBuffer; - - mSize = static_cast<uint32_t>(size); - mOwnsBuffer = true; - } - - // offsetof(hidl_string, mBuffer) exposed since mBuffer is private. - static const size_t kOffsetOfBuffer = offsetof(hidl_vec<T>, mBuffer); - -private: - // Define std interator interface for walking the array contents - template<bool is_const> - class iter : public std::iterator< - std::random_access_iterator_tag, /* Category */ - T, - ptrdiff_t, /* Distance */ - typename std::conditional<is_const, const T *, T *>::type /* Pointer */, - typename std::conditional<is_const, const T &, T &>::type /* Reference */> - { - using traits = std::iterator_traits<iter>; - using ptr_type = typename traits::pointer; - using ref_type = typename traits::reference; - using diff_type = typename traits::difference_type; - public: - iter(ptr_type ptr) : mPtr(ptr) { } - inline iter &operator++() { mPtr++; return *this; } - inline iter operator++(int) { iter i = *this; mPtr++; return i; } - inline iter &operator--() { mPtr--; return *this; } - inline iter operator--(int) { iter i = *this; mPtr--; return i; } - inline friend iter operator+(diff_type n, const iter &it) { return it.mPtr + n; } - inline iter operator+(diff_type n) const { return mPtr + n; } - inline iter operator-(diff_type n) const { return mPtr - n; } - inline diff_type operator-(const iter &other) const { return mPtr - other.mPtr; } - inline iter &operator+=(diff_type n) { mPtr += n; return *this; } - inline iter &operator-=(diff_type n) { mPtr -= n; return *this; } - inline ref_type operator*() const { return *mPtr; } - inline ptr_type operator->() const { return mPtr; } - inline bool operator==(const iter &rhs) const { return mPtr == rhs.mPtr; } - inline bool operator!=(const iter &rhs) const { return mPtr != rhs.mPtr; } - inline bool operator< (const iter &rhs) const { return mPtr < rhs.mPtr; } - inline bool operator> (const iter &rhs) const { return mPtr > rhs.mPtr; } - inline bool operator<=(const iter &rhs) const { return mPtr <= rhs.mPtr; } - inline bool operator>=(const iter &rhs) const { return mPtr >= rhs.mPtr; } - inline ref_type operator[](size_t n) const { return mPtr[n]; } - private: - ptr_type mPtr; - }; -public: - using iterator = iter<false /* is_const */>; - using const_iterator = iter<true /* is_const */>; - - iterator begin() { return data(); } - iterator end() { return data()+mSize; } - const_iterator begin() const { return data(); } - const_iterator end() const { return data()+mSize; } - -private: - details::hidl_pointer<T> mBuffer; - uint32_t mSize; - bool mOwnsBuffer; - - // copy from an array-like object, assuming my resources are freed. - template <typename Array> - void copyFrom(const Array &data, size_t size) { - mSize = static_cast<uint32_t>(size); - mOwnsBuffer = true; - if (mSize > 0) { - mBuffer = new T[size]; - for (size_t i = 0; i < size; ++i) { - mBuffer[i] = data[i]; - } - } else { - mBuffer = NULL; - } - } -}; - - -#if 0 // REF-ANN -//////////////////////////////////////////////////////////////////////////////// - -namespace details { - - template<size_t SIZE1, size_t... SIZES> - struct product { - static constexpr size_t value = SIZE1 * product<SIZES...>::value; - }; - - template<size_t SIZE1> - struct product<SIZE1> { - static constexpr size_t value = SIZE1; - }; - - template<typename T, size_t SIZE1, size_t... SIZES> - struct std_array { - using type = std::array<typename std_array<T, SIZES...>::type, SIZE1>; - }; - - template<typename T, size_t SIZE1> - struct std_array<T, SIZE1> { - using type = std::array<T, SIZE1>; - }; - - template<typename T, size_t SIZE1, size_t... SIZES> - struct accessor { - - using std_array_type = typename std_array<T, SIZE1, SIZES...>::type; - - explicit accessor(T *base) - : mBase(base) { - } - - accessor<T, SIZES...> operator[](size_t index) { - return accessor<T, SIZES...>( - &mBase[index * product<SIZES...>::value]); - } - - accessor &operator=(const std_array_type &other) { - for (size_t i = 0; i < SIZE1; ++i) { - (*this)[i] = other[i]; - } - return *this; - } - - private: - T *mBase; - }; - - template<typename T, size_t SIZE1> - struct accessor<T, SIZE1> { - - using std_array_type = typename std_array<T, SIZE1>::type; - - explicit accessor(T *base) - : mBase(base) { - } - - T &operator[](size_t index) { - return mBase[index]; - } - - accessor &operator=(const std_array_type &other) { - for (size_t i = 0; i < SIZE1; ++i) { - (*this)[i] = other[i]; - } - return *this; - } - - private: - T *mBase; - }; - - template<typename T, size_t SIZE1, size_t... SIZES> - struct const_accessor { - - using std_array_type = typename std_array<T, SIZE1, SIZES...>::type; - - explicit const_accessor(const T *base) - : mBase(base) { - } - - const_accessor<T, SIZES...> operator[](size_t index) const { - return const_accessor<T, SIZES...>( - &mBase[index * product<SIZES...>::value]); - } - - operator std_array_type() { - std_array_type array; - for (size_t i = 0; i < SIZE1; ++i) { - array[i] = (*this)[i]; - } - return array; - } - - private: - const T *mBase; - }; - - template<typename T, size_t SIZE1> - struct const_accessor<T, SIZE1> { - - using std_array_type = typename std_array<T, SIZE1>::type; - - explicit const_accessor(const T *base) - : mBase(base) { - } - - const T &operator[](size_t index) const { - return mBase[index]; - } - - operator std_array_type() { - std_array_type array; - for (size_t i = 0; i < SIZE1; ++i) { - array[i] = (*this)[i]; - } - return array; - } - - private: - const T *mBase; - }; - -} // namespace details - -//////////////////////////////////////////////////////////////////////////////// - -// A multidimensional array of T's. Assumes that T::operator=(const T &) is defined. -template<typename T, size_t SIZE1, size_t... SIZES> -struct hidl_array { - - using std_array_type = typename details::std_array<T, SIZE1, SIZES...>::type; - - hidl_array() = default; - - // Copies the data from source, using T::operator=(const T &). - hidl_array(const T *source) { - for (size_t i = 0; i < elementCount(); ++i) { - mBuffer[i] = source[i]; - } - } - - // Copies the data from the given std::array, using T::operator=(const T &). - hidl_array(const std_array_type &array) { - details::accessor<T, SIZE1, SIZES...> modifier(mBuffer); - modifier = array; - } - - T *data() { return mBuffer; } - const T *data() const { return mBuffer; } - - details::accessor<T, SIZES...> operator[](size_t index) { - return details::accessor<T, SIZES...>( - &mBuffer[index * details::product<SIZES...>::value]); - } - - details::const_accessor<T, SIZES...> operator[](size_t index) const { - return details::const_accessor<T, SIZES...>( - &mBuffer[index * details::product<SIZES...>::value]); - } - - // equality check, assuming that T::operator== is defined. - bool operator==(const hidl_array &other) const { - for (size_t i = 0; i < elementCount(); ++i) { - if (!(mBuffer[i] == other.mBuffer[i])) { - return false; - } - } - return true; - } - - inline bool operator!=(const hidl_array &other) const { - return !((*this) == other); - } - - using size_tuple_type = std::tuple<decltype(SIZE1), decltype(SIZES)...>; - - static constexpr size_tuple_type size() { - return std::make_tuple(SIZE1, SIZES...); - } - - static constexpr size_t elementCount() { - return details::product<SIZE1, SIZES...>::value; - } - - operator std_array_type() const { - return details::const_accessor<T, SIZE1, SIZES...>(mBuffer); - } - -private: - T mBuffer[elementCount()]; -}; - -// An array of T's. Assumes that T::operator=(const T &) is defined. -template<typename T, size_t SIZE1> -struct hidl_array<T, SIZE1> { - - using std_array_type = typename details::std_array<T, SIZE1>::type; - - hidl_array() = default; - - // Copies the data from source, using T::operator=(const T &). - hidl_array(const T *source) { - for (size_t i = 0; i < elementCount(); ++i) { - mBuffer[i] = source[i]; - } - } - - // Copies the data from the given std::array, using T::operator=(const T &). - hidl_array(const std_array_type &array) : hidl_array(array.data()) {} - - T *data() { return mBuffer; } - const T *data() const { return mBuffer; } - - T &operator[](size_t index) { - return mBuffer[index]; - } - - const T &operator[](size_t index) const { - return mBuffer[index]; - } - - // equality check, assuming that T::operator== is defined. - bool operator==(const hidl_array &other) const { - for (size_t i = 0; i < elementCount(); ++i) { - if (!(mBuffer[i] == other.mBuffer[i])) { - return false; - } - } - return true; - } - - inline bool operator!=(const hidl_array &other) const { - return !((*this) == other); - } - - static constexpr size_t size() { return SIZE1; } - static constexpr size_t elementCount() { return SIZE1; } - - // Copies the data to an std::array, using T::operator=(T). - operator std_array_type() const { - std_array_type array; - for (size_t i = 0; i < SIZE1; ++i) { - array[i] = mBuffer[i]; - } - return array; - } - -private: - T mBuffer[SIZE1]; -}; - -// ---------------------------------------------------------------------- -// Version functions -struct hidl_version { -public: - constexpr hidl_version(uint16_t major, uint16_t minor) : mMajor(major), mMinor(minor) {} - - bool operator==(const hidl_version& other) const { - return (mMajor == other.get_major() && mMinor == other.get_minor()); - } - - bool operator<(const hidl_version& other) const { - return (mMajor < other.get_major() || - (mMajor == other.get_major() && mMinor < other.get_minor())); - } - - bool operator>(const hidl_version& other) const { - return other < *this; - } - - bool operator<=(const hidl_version& other) const { - return !(*this > other); - } - - bool operator>=(const hidl_version& other) const { - return !(*this < other); - } - - constexpr uint16_t get_major() const { return mMajor; } - constexpr uint16_t get_minor() const { return mMinor; } - -private: - uint16_t mMajor; - uint16_t mMinor; -}; - -inline android::hardware::hidl_version make_hidl_version(uint16_t major, uint16_t minor) { - return hidl_version(major,minor); -} - -///////////////////// toString functions - -std::string toString(const void *t); - -// toString alias for numeric types -template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> -inline std::string toString(T t) { - return std::to_string(t); -} - -namespace details { - -template<typename T, typename = typename std::enable_if<std::is_arithmetic<T>::value, T>::type> -inline std::string toHexString(T t, bool prefix = true) { - std::ostringstream os; - if (prefix) { os << std::showbase; } - os << std::hex << t; - return os.str(); -} - -template<> -inline std::string toHexString(uint8_t t, bool prefix) { - return toHexString(static_cast<int32_t>(t), prefix); -} - -template<> -inline std::string toHexString(int8_t t, bool prefix) { - return toHexString(static_cast<int32_t>(t), prefix); -} - -template<typename Array> -std::string arrayToString(const Array &a, size_t size); - -template<size_t SIZE1> -std::string arraySizeToString() { - return std::string{"["} + toString(SIZE1) + "]"; -} - -template<size_t SIZE1, size_t SIZE2, size_t... SIZES> -std::string arraySizeToString() { - return std::string{"["} + toString(SIZE1) + "]" + arraySizeToString<SIZE2, SIZES...>(); -} - -template<typename T, size_t SIZE1> -std::string toString(details::const_accessor<T, SIZE1> a) { - return arrayToString(a, SIZE1); -} - -template<typename Array> -std::string arrayToString(const Array &a, size_t size) { - using android::hardware::toString; - std::string os; - os += "{"; - for (size_t i = 0; i < size; ++i) { - if (i > 0) { - os += ", "; - } - os += toString(a[i]); - } - os += "}"; - return os; -} - -template<typename T, size_t SIZE1, size_t SIZE2, size_t... SIZES> -std::string toString(details::const_accessor<T, SIZE1, SIZE2, SIZES...> a) { - return arrayToString(a, SIZE1); -} - -} //namespace details - -inline std::string toString(const void *t) { - return details::toHexString(reinterpret_cast<uintptr_t>(t)); -} - -// debug string dump. There will be quotes around the string! -inline std::string toString(const hidl_string &hs) { - return std::string{"\""} + hs.c_str() + "\""; -} - -// debug string dump -inline std::string toString(const hidl_handle &hs) { - return toString(hs.getNativeHandle()); -} - -inline std::string toString(const hidl_memory &mem) { - return std::string{"memory {.name = "} + toString(mem.name()) + ", .size = " - + toString(mem.size()) - + ", .handle = " + toString(mem.handle()) + "}"; -} - -inline std::string toString(const sp<hidl_death_recipient> &dr) { - return std::string{"death_recipient@"} + toString(dr.get()); -} - -// debug string dump, assuming that toString(T) is defined. -template<typename T> -std::string toString(const hidl_vec<T> &a) { - std::string os; - os += "[" + toString(a.size()) + "]"; - os += details::arrayToString(a, a.size()); - return os; -} - -template<typename T, size_t SIZE1> -std::string toString(const hidl_array<T, SIZE1> &a) { - return details::arraySizeToString<SIZE1>() - + details::toString(details::const_accessor<T, SIZE1>(a.data())); -} - -template<typename T, size_t SIZE1, size_t SIZE2, size_t... SIZES> -std::string toString(const hidl_array<T, SIZE1, SIZE2, SIZES...> &a) { - return details::arraySizeToString<SIZE1, SIZE2, SIZES...>() - + details::toString(details::const_accessor<T, SIZE1, SIZE2, SIZES...>(a.data())); -} -#endif - -} // namespace hardware -} // namespace android - - -#endif // ANDROID_HIDL_SUPPORT_H diff --git a/runtimes/nn/depend/libhidl/base/include/hidl/Status.h b/runtimes/nn/depend/libhidl/base/include/hidl/Status.h deleted file mode 100644 index f812ebbc9..000000000 --- a/runtimes/nn/depend/libhidl/base/include/hidl/Status.h +++ /dev/null @@ -1,273 +0,0 @@ -/* - * Copyright (C) 2015 The Android Open Source Project - * - * 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 ANDROID_HARDWARE_BINDER_STATUS_H -#define ANDROID_HARDWARE_BINDER_STATUS_H - -#include <cstdint> -#include <sstream> - -#include <hidl/HidlInternal.h> -#include <utils/Errors.h> -#include <utils/StrongPointer.h> - -namespace android { -namespace hardware { - -// An object similar in function to a status_t except that it understands -// how exceptions are encoded in the prefix of a Parcel. Used like: -// -// Parcel data; -// Parcel reply; -// status_t status; -// binder::Status remote_exception; -// if ((status = data.writeInterfaceToken(interface_descriptor)) != OK || -// (status = data.writeInt32(function_input)) != OK) { -// // We failed to write into the memory of our local parcel? -// } -// if ((status = remote()->transact(transaction, data, &reply)) != OK) { -// // Something has gone wrong in the binder driver or libbinder. -// } -// if ((status = remote_exception.readFromParcel(reply)) != OK) { -// // The remote didn't correctly write the exception header to the -// // reply. -// } -// if (!remote_exception.isOk()) { -// // The transaction went through correctly, but the remote reported an -// // exception during handling. -// } -// -class Status final { -public: - // Keep the exception codes in sync with android/os/Parcel.java. - enum Exception { - EX_NONE = 0, - EX_SECURITY = -1, - EX_BAD_PARCELABLE = -2, - EX_ILLEGAL_ARGUMENT = -3, - EX_NULL_POINTER = -4, - EX_ILLEGAL_STATE = -5, - EX_NETWORK_MAIN_THREAD = -6, - EX_UNSUPPORTED_OPERATION = -7, - - // This is special and Java specific; see Parcel.java. - EX_HAS_REPLY_HEADER = -128, - // This is special, and indicates to C++ binder proxies that the - // transaction has failed at a low level. - EX_TRANSACTION_FAILED = -129, - }; - - // A more readable alias for the default constructor. - static Status ok(); - // Authors should explicitly pick whether their integer is: - // - an exception code (EX_* above) - // - status_t - // - // Prefer a generic exception code when possible or a status_t - // for low level transport errors. Service specific errors - // should be at a higher level in HIDL. - static Status fromExceptionCode(int32_t exceptionCode); - static Status fromExceptionCode(int32_t exceptionCode, - const char *message); - static Status fromStatusT(status_t status); - - Status() = default; - ~Status() = default; - - // Status objects are copyable and contain just simple data. - Status(const Status& status) = default; - Status(Status&& status) = default; - Status& operator=(const Status& status) = default; - - // Set one of the pre-defined exception types defined above. - void setException(int32_t ex, const char *message); - // Setting a |status| != OK causes generated code to return |status| - // from Binder transactions, rather than writing an exception into the - // reply Parcel. This is the least preferable way of reporting errors. - void setFromStatusT(status_t status); - - // Get information about an exception. - int32_t exceptionCode() const { return mException; } - const char *exceptionMessage() const { return mMessage.c_str(); } - status_t transactionError() const { - return mException == EX_TRANSACTION_FAILED ? mErrorCode : OK; - } - - bool isOk() const { return mException == EX_NONE; } - - // For debugging purposes only - std::string description() const; - -private: - Status(int32_t exceptionCode, int32_t errorCode); - Status(int32_t exceptionCode, int32_t errorCode, const char *message); - - // If |mException| == EX_TRANSACTION_FAILED, generated code will return - // |mErrorCode| as the result of the transaction rather than write an - // exception to the reply parcel. - // - // Otherwise, we always write |mException| to the parcel. - // If |mException| != EX_NONE, we write |mMessage| as well. - int32_t mException = EX_NONE; - int32_t mErrorCode = 0; - std::string mMessage; -}; // class Status - -// For gtest output logging -std::ostream& operator<< (std::ostream& stream, const Status& s); - -template<typename T> class Return; - -namespace details { - class return_status { - private: - Status mStatus {}; - mutable bool mCheckedStatus = false; - - template <typename T, typename U> - friend Return<U> StatusOf(const Return<T> &other); - protected: - void assertOk() const; - public: - return_status() {} - return_status(Status s) : mStatus(s) {} - - return_status(const return_status &) = delete; - return_status &operator=(const return_status &) = delete; - - return_status(return_status &&other) { - *this = std::move(other); - } - return_status &operator=(return_status &&other); - - ~return_status(); - - bool isOk() const { - mCheckedStatus = true; - return mStatus.isOk(); - } - - // Check if underlying error is DEAD_OBJECT. - // Check mCheckedStatus only if this method returns true. - bool isDeadObject() const { - bool dead = mStatus.transactionError() == DEAD_OBJECT; - - // This way, if you only check isDeadObject your process will - // only be killed for more serious unchecked errors - if (dead) { - mCheckedStatus = true; - } - - return dead; - } - - // For debugging purposes only - std::string description() const { - // Doesn't consider checked. - return mStatus.description(); - } - }; -} // namespace details - -template<typename T> class Return : public details::return_status { -private: - T mVal {}; -public: - Return(T v) : details::return_status(), mVal{v} {} - Return(Status s) : details::return_status(s) {} - - // move-able. - // precondition: "this" has checked status - // postcondition: other is safe to destroy after moving to *this. - Return(Return &&other) = default; - Return &operator=(Return &&) = default; - - ~Return() = default; - - operator T() const { - assertOk(); - return mVal; - } - - T withDefault(T t) { - return isOk() ? mVal : t; - } -}; - -template<typename T> class Return<sp<T>> : public details::return_status { -private: - sp<T> mVal {}; -public: - Return(sp<T> v) : details::return_status(), mVal{v} {} - Return(T* v) : details::return_status(), mVal{v} {} - // Constructors matching a different type (that is related by inheritance) - template<typename U> Return(sp<U> v) : details::return_status(), mVal{v} {} - template<typename U> Return(U* v) : details::return_status(), mVal{v} {} - Return(Status s) : details::return_status(s) {} - - // move-able. - // precondition: "this" has checked status - // postcondition: other is safe to destroy after moving to *this. - Return(Return &&other) = default; - Return &operator=(Return &&) = default; - - ~Return() = default; - - operator sp<T>() const { - assertOk(); - return mVal; - } - - sp<T> withDefault(sp<T> t) { - return isOk() ? mVal : t; - } -}; - - -template<> class Return<void> : public details::return_status { -public: - Return() : details::return_status() {} - Return(Status s) : details::return_status(s) {} - - // move-able. - // precondition: "this" has checked status - // postcondition: other is safe to destroy after moving to *this. - Return(Return &&) = default; - Return &operator=(Return &&) = default; - - ~Return() = default; -}; - -static inline Return<void> Void() { - return Return<void>(); -} - -namespace details { -// Create a Return<U> from the Status of Return<T>. The provided -// Return<T> must have an error status and have it checked. -template <typename T, typename U> -Return<U> StatusOf(const Return<T> &other) { - if (other.mStatus.isOk() || !other.mCheckedStatus) { - details::logAlwaysFatal("cannot call statusOf on an OK Status or an unchecked status"); - } - return Return<U>{other.mStatus}; -} -} // namespace details - -} // namespace hardware -} // namespace android - -#endif // ANDROID_HARDWARE_BINDER_STATUS_H |