diff options
Diffstat (limited to 'include/google/protobuf/arena.h')
| -rw-r--r-- | include/google/protobuf/arena.h | 851 |
1 files changed, 0 insertions, 851 deletions
diff --git a/include/google/protobuf/arena.h b/include/google/protobuf/arena.h deleted file mode 100644 index 3b5f16c389..0000000000 --- a/include/google/protobuf/arena.h +++ /dev/null @@ -1,851 +0,0 @@ -// Protocol Buffers - Google's data interchange format -// Copyright 2008 Google Inc. All rights reserved. -// https://developers.google.com/protocol-buffers/ -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// This file defines an Arena allocator for better allocation performance. - -#ifndef GOOGLE_PROTOBUF_ARENA_H__ -#define GOOGLE_PROTOBUF_ARENA_H__ - - -#include <limits> -#include <type_traits> -#include <utility> -#if defined(_MSC_VER) && !defined(_LIBCPP_STD_VER) && !_HAS_EXCEPTIONS -// Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0. -#include <exception> -#include <typeinfo> -namespace std { -using type_info = ::type_info; -} -#else -#include <typeinfo> -#endif - -#include <type_traits> -#include <google/protobuf/arena_impl.h> -#include <google/protobuf/port.h> - -// Must be included last. -#include <google/protobuf/port_def.inc> - -#ifdef SWIG -#error "You cannot SWIG proto headers" -#endif - -namespace google { -namespace protobuf { - -struct ArenaOptions; // defined below -class Arena; // defined below -class Message; // defined in message.h -class MessageLite; -template <typename Key, typename T> -class Map; - -namespace arena_metrics { - -void EnableArenaMetrics(ArenaOptions* options); - -} // namespace arena_metrics - -namespace TestUtil { -class ReflectionTester; // defined in test_util.h -} // namespace TestUtil - -namespace internal { - -struct ArenaTestPeer; // defined in arena_test_util.h -class InternalMetadata; // defined in metadata_lite.h -class LazyField; // defined in lazy_field.h -class EpsCopyInputStream; // defined in parse_context.h -class RepeatedPtrFieldBase; // defined in repeated_ptr_field.h - -template <typename Type> -class GenericTypeHandler; // defined in repeated_field.h - -inline PROTOBUF_ALWAYS_INLINE -void* AlignTo(void* ptr, size_t align) { - return reinterpret_cast<void*>( - (reinterpret_cast<uintptr_t>(ptr) + align - 1) & (~align + 1)); -} - -// Templated cleanup methods. -template <typename T> -void arena_destruct_object(void* object) { - reinterpret_cast<T*>(object)->~T(); -} - -template <bool destructor_skippable, typename T> -struct ObjectDestructor { - constexpr static void (*destructor)(void*) = &arena_destruct_object<T>; -}; - -template <typename T> -struct ObjectDestructor<true, T> { - constexpr static void (*destructor)(void*) = nullptr; -}; - -template <typename T> -void arena_delete_object(void* object) { - delete reinterpret_cast<T*>(object); -} -} // namespace internal - -// ArenaOptions provides optional additional parameters to arena construction -// that control its block-allocation behavior. -struct ArenaOptions { - // This defines the size of the first block requested from the system malloc. - // Subsequent block sizes will increase in a geometric series up to a maximum. - size_t start_block_size; - - // This defines the maximum block size requested from system malloc (unless an - // individual arena allocation request occurs with a size larger than this - // maximum). Requested block sizes increase up to this value, then remain - // here. - size_t max_block_size; - - // An initial block of memory for the arena to use, or NULL for none. If - // provided, the block must live at least as long as the arena itself. The - // creator of the Arena retains ownership of the block after the Arena is - // destroyed. - char* initial_block; - - // The size of the initial block, if provided. - size_t initial_block_size; - - // A function pointer to an alloc method that returns memory blocks of size - // requested. By default, it contains a ptr to the malloc function. - // - // NOTE: block_alloc and dealloc functions are expected to behave like - // malloc and free, including Asan poisoning. - void* (*block_alloc)(size_t); - // A function pointer to a dealloc method that takes ownership of the blocks - // from the arena. By default, it contains a ptr to a wrapper function that - // calls free. - void (*block_dealloc)(void*, size_t); - - ArenaOptions() - : start_block_size(internal::AllocationPolicy::kDefaultStartBlockSize), - max_block_size(internal::AllocationPolicy::kDefaultMaxBlockSize), - initial_block(NULL), - initial_block_size(0), - block_alloc(nullptr), - block_dealloc(nullptr), - make_metrics_collector(nullptr) {} - - private: - // If make_metrics_collector is not nullptr, it will be called at Arena init - // time. It may return a pointer to a collector instance that will be notified - // of interesting events related to the arena. - internal::ArenaMetricsCollector* (*make_metrics_collector)(); - - internal::ArenaMetricsCollector* MetricsCollector() const { - return make_metrics_collector ? (*make_metrics_collector)() : nullptr; - } - - internal::AllocationPolicy AllocationPolicy() const { - internal::AllocationPolicy res; - res.start_block_size = start_block_size; - res.max_block_size = max_block_size; - res.block_alloc = block_alloc; - res.block_dealloc = block_dealloc; - res.metrics_collector = MetricsCollector(); - return res; - } - - friend void arena_metrics::EnableArenaMetrics(ArenaOptions*); - - friend class Arena; - friend class ArenaOptionsTestFriend; -}; - -// Support for non-RTTI environments. (The metrics hooks API uses type -// information.) -#if PROTOBUF_RTTI -#define RTTI_TYPE_ID(type) (&typeid(type)) -#else -#define RTTI_TYPE_ID(type) (NULL) -#endif - -// Arena allocator. Arena allocation replaces ordinary (heap-based) allocation -// with new/delete, and improves performance by aggregating allocations into -// larger blocks and freeing allocations all at once. Protocol messages are -// allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and -// are automatically freed when the arena is destroyed. -// -// This is a thread-safe implementation: multiple threads may allocate from the -// arena concurrently. Destruction is not thread-safe and the destructing -// thread must synchronize with users of the arena first. -// -// An arena provides two allocation interfaces: CreateMessage<T>, which works -// for arena-enabled proto2 message types as well as other types that satisfy -// the appropriate protocol (described below), and Create<T>, which works for -// any arbitrary type T. CreateMessage<T> is better when the type T supports it, -// because this interface (i) passes the arena pointer to the created object so -// that its sub-objects and internal allocations can use the arena too, and (ii) -// elides the object's destructor call when possible. Create<T> does not place -// any special requirements on the type T, and will invoke the object's -// destructor when the arena is destroyed. -// -// The arena message allocation protocol, required by -// CreateMessage<T>(Arena* arena, Args&&... args), is as follows: -// -// - The type T must have (at least) two constructors: a constructor callable -// with `args` (without `arena`), called when a T is allocated on the heap; -// and a constructor callable with `Arena* arena, Args&&... args`, called when -// a T is allocated on an arena. If the second constructor is called with a -// NULL arena pointer, it must be equivalent to invoking the first -// (`args`-only) constructor. -// -// - The type T must have a particular type trait: a nested type -// |InternalArenaConstructable_|. This is usually a typedef to |void|. If no -// such type trait exists, then the instantiation CreateMessage<T> will fail -// to compile. -// -// - The type T *may* have the type trait |DestructorSkippable_|. If this type -// trait is present in the type, then its destructor will not be called if and -// only if it was passed a non-NULL arena pointer. If this type trait is not -// present on the type, then its destructor is always called when the -// containing arena is destroyed. -// -// This protocol is implemented by all arena-enabled proto2 message classes as -// well as protobuf container types like RepeatedPtrField and Map. The protocol -// is internal to protobuf and is not guaranteed to be stable. Non-proto types -// should not rely on this protocol. -class PROTOBUF_EXPORT PROTOBUF_ALIGNAS(8) Arena final { - public: - // Default constructor with sensible default options, tuned for average - // use-cases. - inline Arena() : impl_() {} - - // Construct an arena with default options, except for the supplied - // initial block. It is more efficient to use this constructor - // instead of passing ArenaOptions if the only configuration needed - // by the caller is supplying an initial block. - inline Arena(char* initial_block, size_t initial_block_size) - : impl_(initial_block, initial_block_size) {} - - // Arena constructor taking custom options. See ArenaOptions above for - // descriptions of the options available. - explicit Arena(const ArenaOptions& options) - : impl_(options.initial_block, options.initial_block_size, - options.AllocationPolicy()) {} - - // Block overhead. Use this as a guide for how much to over-allocate the - // initial block if you want an allocation of size N to fit inside it. - // - // WARNING: if you allocate multiple objects, it is difficult to guarantee - // that a series of allocations will fit in the initial block, especially if - // Arena changes its alignment guarantees in the future! - static const size_t kBlockOverhead = - internal::ThreadSafeArena::kBlockHeaderSize + - internal::ThreadSafeArena::kSerialArenaSize; - - inline ~Arena() {} - - // TODO(protobuf-team): Fix callers to use constructor and delete this method. - void Init(const ArenaOptions&) {} - - // API to create proto2 message objects on the arena. If the arena passed in - // is NULL, then a heap allocated object is returned. Type T must be a message - // defined in a .proto file with cc_enable_arenas set to true, otherwise a - // compilation error will occur. - // - // RepeatedField and RepeatedPtrField may also be instantiated directly on an - // arena with this method. - // - // This function also accepts any type T that satisfies the arena message - // allocation protocol, documented above. - template <typename T, typename... Args> - PROTOBUF_ALWAYS_INLINE static T* CreateMessage(Arena* arena, Args&&... args) { - static_assert( - InternalHelper<T>::is_arena_constructable::value, - "CreateMessage can only construct types that are ArenaConstructable"); - // We must delegate to CreateMaybeMessage() and NOT CreateMessageInternal() - // because protobuf generated classes specialize CreateMaybeMessage() and we - // need to use that specialization for code size reasons. - return Arena::CreateMaybeMessage<T>(arena, static_cast<Args&&>(args)...); - } - - // API to create any objects on the arena. Note that only the object will - // be created on the arena; the underlying ptrs (in case of a proto2 message) - // will be still heap allocated. Proto messages should usually be allocated - // with CreateMessage<T>() instead. - // - // Note that even if T satisfies the arena message construction protocol - // (InternalArenaConstructable_ trait and optional DestructorSkippable_ - // trait), as described above, this function does not follow the protocol; - // instead, it treats T as a black-box type, just as if it did not have these - // traits. Specifically, T's constructor arguments will always be only those - // passed to Create<T>() -- no additional arena pointer is implicitly added. - // Furthermore, the destructor will always be called at arena destruction time - // (unless the destructor is trivial). Hence, from T's point of view, it is as - // if the object were allocated on the heap (except that the underlying memory - // is obtained from the arena). - template <typename T, typename... Args> - PROTOBUF_NDEBUG_INLINE static T* Create(Arena* arena, Args&&... args) { - return CreateInternal<T>(arena, std::is_convertible<T*, MessageLite*>(), - static_cast<Args&&>(args)...); - } - - // Allocates memory with the specific size and alignment. - void* AllocateAligned(size_t size, size_t align = 8) { - if (align <= 8) { - return AllocateAlignedNoHook(internal::AlignUpTo8(size)); - } else { - // We are wasting space by over allocating align - 8 bytes. Compared - // to a dedicated function that takes current alignment in consideration. - // Such a scheme would only waste (align - 8)/2 bytes on average, but - // requires a dedicated function in the outline arena allocation - // functions. Possibly re-evaluate tradeoffs later. - return internal::AlignTo(AllocateAlignedNoHook(size + align - 8), align); - } - } - - // Create an array of object type T on the arena *without* invoking the - // constructor of T. If `arena` is null, then the return value should be freed - // with `delete[] x;` (or `::operator delete[](x);`). - // To ensure safe uses, this function checks at compile time - // (when compiled as C++11) that T is trivially default-constructible and - // trivially destructible. - template <typename T> - PROTOBUF_NDEBUG_INLINE static T* CreateArray(Arena* arena, - size_t num_elements) { - static_assert(std::is_trivial<T>::value, - "CreateArray requires a trivially constructible type"); - static_assert(std::is_trivially_destructible<T>::value, - "CreateArray requires a trivially destructible type"); - GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T)) - << "Requested size is too large to fit into size_t."; - if (arena == NULL) { - return static_cast<T*>(::operator new[](num_elements * sizeof(T))); - } else { - return arena->CreateInternalRawArray<T>(num_elements); - } - } - - // The following are routines are for monitoring. They will approximate the - // total sum allocated and used memory, but the exact value is an - // implementation deal. For instance allocated space depends on growth - // policies. Do not use these in unit tests. - // Returns the total space allocated by the arena, which is the sum of the - // sizes of the underlying blocks. - uint64_t SpaceAllocated() const { return impl_.SpaceAllocated(); } - // Returns the total space used by the arena. Similar to SpaceAllocated but - // does not include free space and block overhead. The total space returned - // may not include space used by other threads executing concurrently with - // the call to this method. - uint64_t SpaceUsed() const { return impl_.SpaceUsed(); } - - // Frees all storage allocated by this arena after calling destructors - // registered with OwnDestructor() and freeing objects registered with Own(). - // Any objects allocated on this arena are unusable after this call. It also - // returns the total space used by the arena which is the sums of the sizes - // of the allocated blocks. This method is not thread-safe. - uint64_t Reset() { return impl_.Reset(); } - - // Adds |object| to a list of heap-allocated objects to be freed with |delete| - // when the arena is destroyed or reset. - template <typename T> - PROTOBUF_ALWAYS_INLINE void Own(T* object) { - OwnInternal(object, std::is_convertible<T*, MessageLite*>()); - } - - // Adds |object| to a list of objects whose destructors will be manually - // called when the arena is destroyed or reset. This differs from Own() in - // that it does not free the underlying memory with |delete|; hence, it is - // normally only used for objects that are placement-newed into - // arena-allocated memory. - template <typename T> - PROTOBUF_ALWAYS_INLINE void OwnDestructor(T* object) { - if (object != NULL) { - impl_.AddCleanup(object, &internal::arena_destruct_object<T>); - } - } - - // Adds a custom member function on an object to the list of destructors that - // will be manually called when the arena is destroyed or reset. This differs - // from OwnDestructor() in that any member function may be specified, not only - // the class destructor. - PROTOBUF_ALWAYS_INLINE void OwnCustomDestructor(void* object, - void (*destruct)(void*)) { - impl_.AddCleanup(object, destruct); - } - - // Retrieves the arena associated with |value| if |value| is an arena-capable - // message, or NULL otherwise. If possible, the call resolves at compile time. - // Note that we can often devirtualize calls to `value->GetArena()` so usually - // calling this method is unnecessary. - template <typename T> - PROTOBUF_ALWAYS_INLINE static Arena* GetArena(const T* value) { - return GetArenaInternal(value); - } - - template <typename T> - class InternalHelper { - private: - // Provides access to protected GetOwningArena to generated messages. - static Arena* GetOwningArena(const T* p) { return p->GetOwningArena(); } - - static void InternalSwap(T* a, T* b) { a->InternalSwap(b); } - - static Arena* GetArenaForAllocationInternal( - const T* p, std::true_type /*is_derived_from<MessageLite>*/) { - return p->GetArenaForAllocation(); - } - - static Arena* GetArenaForAllocationInternal( - const T* p, std::false_type /*is_derived_from<MessageLite>*/) { - return GetArenaForAllocationForNonMessage( - p, typename is_arena_constructable::type()); - } - - static Arena* GetArenaForAllocationForNonMessage( - const T* p, std::true_type /*is_arena_constructible*/) { - return p->GetArena(); - } - - static Arena* GetArenaForAllocationForNonMessage( - const T* p, std::false_type /*is_arena_constructible*/) { - return GetArenaForAllocationForNonMessageNonArenaConstructible( - p, typename has_get_arena::type()); - } - - static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible( - const T* p, std::true_type /*has_get_arena*/) { - return p->GetArena(); - } - - static Arena* GetArenaForAllocationForNonMessageNonArenaConstructible( - const T* /* p */, std::false_type /*has_get_arena*/) { - return nullptr; - } - - template <typename U> - static char DestructorSkippable(const typename U::DestructorSkippable_*); - template <typename U> - static double DestructorSkippable(...); - - typedef std::integral_constant< - bool, sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) == - sizeof(char) || - std::is_trivially_destructible<T>::value> - is_destructor_skippable; - - template <typename U> - static char ArenaConstructable( - const typename U::InternalArenaConstructable_*); - template <typename U> - static double ArenaConstructable(...); - - typedef std::integral_constant<bool, sizeof(ArenaConstructable<T>( - static_cast<const T*>(0))) == - sizeof(char)> - is_arena_constructable; - - template <typename U, - typename std::enable_if< - std::is_same<Arena*, decltype(std::declval<const U>() - .GetArena())>::value, - int>::type = 0> - static char HasGetArena(decltype(&U::GetArena)); - template <typename U> - static double HasGetArena(...); - - typedef std::integral_constant<bool, sizeof(HasGetArena<T>(nullptr)) == - sizeof(char)> - has_get_arena; - - template <typename... Args> - static T* Construct(void* ptr, Args&&... args) { - return new (ptr) T(static_cast<Args&&>(args)...); - } - - static inline PROTOBUF_ALWAYS_INLINE T* New() { - return new T(nullptr); - } - - static Arena* GetArena(const T* p) { return p->GetArena(); } - - friend class Arena; - friend class TestUtil::ReflectionTester; - }; - - // Provides access to protected GetOwningArena to generated messages. For - // internal use only. - template <typename T> - static Arena* InternalGetOwningArena(const T* p) { - return InternalHelper<T>::GetOwningArena(p); - } - - // Provides access to protected GetArenaForAllocation to generated messages. - // For internal use only. - template <typename T> - static Arena* InternalGetArenaForAllocation(const T* p) { - return InternalHelper<T>::GetArenaForAllocationInternal( - p, std::is_convertible<T*, MessageLite*>()); - } - - // Creates message-owned arena. For internal use only. - static Arena* InternalCreateMessageOwnedArena() { - return new Arena(internal::MessageOwned{}); - } - - // Checks whether this arena is message-owned. For internal use only. - bool InternalIsMessageOwnedArena() { return IsMessageOwned(); } - - // Helper typetraits that indicates support for arenas in a type T at compile - // time. This is public only to allow construction of higher-level templated - // utilities. - // - // is_arena_constructable<T>::value is true if the message type T has arena - // support enabled, and false otherwise. - // - // is_destructor_skippable<T>::value is true if the message type T has told - // the arena that it is safe to skip the destructor, and false otherwise. - // - // This is inside Arena because only Arena has the friend relationships - // necessary to see the underlying generated code traits. - template <typename T> - struct is_arena_constructable : InternalHelper<T>::is_arena_constructable {}; - template <typename T> - struct is_destructor_skippable : InternalHelper<T>::is_destructor_skippable { - }; - - private: - internal::ThreadSafeArena impl_; - - template <typename T> - struct has_get_arena : InternalHelper<T>::has_get_arena {}; - - // Constructor solely used by message-owned arena. - inline Arena(internal::MessageOwned) : impl_(internal::MessageOwned{}) {} - - // Checks whether this arena is message-owned. - PROTOBUF_ALWAYS_INLINE bool IsMessageOwned() const { - return impl_.IsMessageOwned(); - } - - void ReturnArrayMemory(void* p, size_t size) { - impl_.ReturnArrayMemory(p, size); - } - - template <typename T, typename... Args> - PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena, - Args&&... args) { - static_assert( - InternalHelper<T>::is_arena_constructable::value, - "CreateMessage can only construct types that are ArenaConstructable"); - if (arena == NULL) { - return new T(nullptr, static_cast<Args&&>(args)...); - } else { - return arena->DoCreateMessage<T>(static_cast<Args&&>(args)...); - } - } - - // This specialization for no arguments is necessary, because its behavior is - // slightly different. When the arena pointer is nullptr, it calls T() - // instead of T(nullptr). - template <typename T> - PROTOBUF_NDEBUG_INLINE static T* CreateMessageInternal(Arena* arena) { - static_assert( - InternalHelper<T>::is_arena_constructable::value, - "CreateMessage can only construct types that are ArenaConstructable"); - if (arena == NULL) { - // Generated arena constructor T(Arena*) is protected. Call via - // InternalHelper. - return InternalHelper<T>::New(); - } else { - return arena->DoCreateMessage<T>(); - } - } - - // Allocate and also optionally call collector with the allocated type info - // when allocation recording is enabled. - PROTOBUF_NDEBUG_INLINE void* AllocateInternal(size_t size, size_t align, - void (*destructor)(void*), - const std::type_info* type) { - // Monitor allocation if needed. - if (destructor == nullptr) { - return AllocateAlignedWithHook(size, align, type); - } else { - if (align <= 8) { - auto res = AllocateAlignedWithCleanup(internal::AlignUpTo8(size), type); - res.second->elem = res.first; - res.second->cleanup = destructor; - return res.first; - } else { - auto res = AllocateAlignedWithCleanup(size + align - 8, type); - auto ptr = internal::AlignTo(res.first, align); - res.second->elem = ptr; - res.second->cleanup = destructor; - return ptr; - } - } - } - - // CreateMessage<T> requires that T supports arenas, but this private method - // works whether or not T supports arenas. These are not exposed to user code - // as it can cause confusing API usages, and end up having double free in - // user code. These are used only internally from LazyField and Repeated - // fields, since they are designed to work in all mode combinations. - template <typename Msg, typename... Args> - PROTOBUF_ALWAYS_INLINE static Msg* DoCreateMaybeMessage(Arena* arena, - std::true_type, - Args&&... args) { - return CreateMessageInternal<Msg>(arena, std::forward<Args>(args)...); - } - - template <typename T, typename... Args> - PROTOBUF_ALWAYS_INLINE static T* DoCreateMaybeMessage(Arena* arena, - std::false_type, - Args&&... args) { - return Create<T>(arena, std::forward<Args>(args)...); - } - - template <typename T, typename... Args> - PROTOBUF_ALWAYS_INLINE static T* CreateMaybeMessage(Arena* arena, - Args&&... args) { - return DoCreateMaybeMessage<T>(arena, is_arena_constructable<T>(), - std::forward<Args>(args)...); - } - - // Just allocate the required size for the given type assuming the - // type has a trivial constructor. - template <typename T> - PROTOBUF_NDEBUG_INLINE T* CreateInternalRawArray(size_t num_elements) { - GOOGLE_CHECK_LE(num_elements, std::numeric_limits<size_t>::max() / sizeof(T)) - << "Requested size is too large to fit into size_t."; - // We count on compiler to realize that if sizeof(T) is a multiple of - // 8 AlignUpTo can be elided. - const size_t n = sizeof(T) * num_elements; - return static_cast<T*>( - AllocateAlignedWithHookForArray(n, alignof(T), RTTI_TYPE_ID(T))); - } - - template <typename T, typename... Args> - PROTOBUF_NDEBUG_INLINE T* DoCreateMessage(Args&&... args) { - return InternalHelper<T>::Construct( - AllocateInternal(sizeof(T), alignof(T), - internal::ObjectDestructor< - InternalHelper<T>::is_destructor_skippable::value, - T>::destructor, - RTTI_TYPE_ID(T)), - this, std::forward<Args>(args)...); - } - - // CreateInArenaStorage is used to implement map field. Without it, - // Map need to call generated message's protected arena constructor, - // which needs to declare Map as friend of generated message. - template <typename T, typename... Args> - static void CreateInArenaStorage(T* ptr, Arena* arena, Args&&... args) { - CreateInArenaStorageInternal(ptr, arena, - typename is_arena_constructable<T>::type(), - std::forward<Args>(args)...); - if (arena != nullptr) { - RegisterDestructorInternal( - ptr, arena, - typename InternalHelper<T>::is_destructor_skippable::type()); - } - } - - template <typename T, typename... Args> - static void CreateInArenaStorageInternal(T* ptr, Arena* arena, - std::true_type, Args&&... args) { - InternalHelper<T>::Construct(ptr, arena, std::forward<Args>(args)...); - } - template <typename T, typename... Args> - static void CreateInArenaStorageInternal(T* ptr, Arena* /* arena */, - std::false_type, Args&&... args) { - new (ptr) T(std::forward<Args>(args)...); - } - - template <typename T> - static void RegisterDestructorInternal(T* /* ptr */, Arena* /* arena */, - std::true_type) {} - template <typename T> - static void RegisterDestructorInternal(T* ptr, Arena* arena, - std::false_type) { - arena->OwnDestructor(ptr); - } - - // These implement Create(). The second parameter has type 'true_type' if T is - // a subtype of Message and 'false_type' otherwise. - template <typename T, typename... Args> - PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::true_type, - Args&&... args) { - if (arena == nullptr) { - return new T(std::forward<Args>(args)...); - } else { - auto destructor = - internal::ObjectDestructor<std::is_trivially_destructible<T>::value, - T>::destructor; - T* result = - new (arena->AllocateInternal(sizeof(T), alignof(T), destructor, - RTTI_TYPE_ID(T))) - T(std::forward<Args>(args)...); - return result; - } - } - template <typename T, typename... Args> - PROTOBUF_ALWAYS_INLINE static T* CreateInternal(Arena* arena, std::false_type, - Args&&... args) { - if (arena == nullptr) { - return new T(std::forward<Args>(args)...); - } else { - auto destructor = - internal::ObjectDestructor<std::is_trivially_destructible<T>::value, - T>::destructor; - return new (arena->AllocateInternal(sizeof(T), alignof(T), destructor, - RTTI_TYPE_ID(T))) - T(std::forward<Args>(args)...); - } - } - - // These implement Own(), which registers an object for deletion (destructor - // call and operator delete()). The second parameter has type 'true_type' if T - // is a subtype of Message and 'false_type' otherwise. Collapsing - // all template instantiations to one for generic Message reduces code size, - // using the virtual destructor instead. - template <typename T> - PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::true_type) { - if (object != NULL) { - impl_.AddCleanup(object, &internal::arena_delete_object<MessageLite>); - } - } - template <typename T> - PROTOBUF_ALWAYS_INLINE void OwnInternal(T* object, std::false_type) { - if (object != NULL) { - impl_.AddCleanup(object, &internal::arena_delete_object<T>); - } - } - - // Implementation for GetArena(). Only message objects with - // InternalArenaConstructable_ tags can be associated with an arena, and such - // objects must implement a GetArena() method. - template <typename T, typename std::enable_if< - is_arena_constructable<T>::value, int>::type = 0> - PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) { - return InternalHelper<T>::GetArena(value); - } - template <typename T, - typename std::enable_if<!is_arena_constructable<T>::value && - has_get_arena<T>::value, - int>::type = 0> - PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) { - return value->GetArena(); - } - template <typename T, - typename std::enable_if<!is_arena_constructable<T>::value && - !has_get_arena<T>::value, - int>::type = 0> - PROTOBUF_ALWAYS_INLINE static Arena* GetArenaInternal(const T* value) { - (void)value; - return nullptr; - } - - template <typename T> - PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArena(const T* value) { - return GetOwningArenaInternal( - value, std::is_convertible<T*, MessageLite*>()); - } - - // Implementation for GetOwningArena(). All and only message objects have - // GetOwningArena() method. - template <typename T> - PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal( - const T* value, std::true_type) { - return InternalHelper<T>::GetOwningArena(value); - } - template <typename T> - PROTOBUF_ALWAYS_INLINE static Arena* GetOwningArenaInternal( - const T* /* value */, std::false_type) { - return nullptr; - } - - void* AllocateAlignedWithHookForArray(size_t n, size_t align, - const std::type_info* type) { - if (align <= 8) { - return AllocateAlignedWithHookForArray(internal::AlignUpTo8(n), type); - } else { - // We are wasting space by over allocating align - 8 bytes. Compared - // to a dedicated function that takes current alignment in consideration. - // Such a scheme would only waste (align - 8)/2 bytes on average, but - // requires a dedicated function in the outline arena allocation - // functions. Possibly re-evaluate tradeoffs later. - return internal::AlignTo( - AllocateAlignedWithHookForArray(n + align - 8, type), align); - } - } - - void* AllocateAlignedWithHook(size_t n, size_t align, - const std::type_info* type) { - if (align <= 8) { - return AllocateAlignedWithHook(internal::AlignUpTo8(n), type); - } else { - // We are wasting space by over allocating align - 8 bytes. Compared - // to a dedicated function that takes current alignment in consideration. - // Such a scheme would only waste (align - 8)/2 bytes on average, but - // requires a dedicated function in the outline arena allocation - // functions. Possibly re-evaluate tradeoffs later. - return internal::AlignTo(AllocateAlignedWithHook(n + align - 8, type), - align); - } - } - - void* AllocateAlignedNoHook(size_t n); - void* AllocateAlignedWithHook(size_t n, const std::type_info* type); - void* AllocateAlignedWithHookForArray(size_t n, const std::type_info* type); - std::pair<void*, internal::SerialArena::CleanupNode*> - AllocateAlignedWithCleanup(size_t n, const std::type_info* type); - - template <typename Type> - friend class internal::GenericTypeHandler; - friend class internal::InternalMetadata; // For user_arena(). - friend class internal::LazyField; // For CreateMaybeMessage. - friend class internal::EpsCopyInputStream; // For parser performance - friend class MessageLite; - template <typename Key, typename T> - friend class Map; - template <typename> - friend class RepeatedField; // For ReturnArrayMemory - friend class internal::RepeatedPtrFieldBase; // For ReturnArrayMemory - friend struct internal::ArenaTestPeer; -}; - -// Defined above for supporting environments without RTTI. -#undef RTTI_TYPE_ID - -} // namespace protobuf -} // namespace google - -#include <google/protobuf/port_undef.inc> - -#endif // GOOGLE_PROTOBUF_ARENA_H__ |