allocation.h

Go to the documentation of this file.

// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef INCLUDE_CPPGC_ALLOCATION_H_
#define INCLUDE_CPPGC_ALLOCATION_H_
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <new>
#include <type_traits>
#include <utility>
 
#include "cppgc/custom-space.h"
#include "cppgc/internal/api-constants.h"
#include "cppgc/internal/gc-info.h"
#include "cppgc/type-traits.h"
#include "v8config.h"  // NOLINT(build/include_directory)
 
#if defined(__has_attribute)
#if __has_attribute(assume_aligned)
#define CPPGC_DEFAULT_ALIGNED \
  __attribute__((assume_aligned(api_constants::kDefaultAlignment)))
#define CPPGC_DOUBLE_WORD_ALIGNED \
  __attribute__((assume_aligned(2 * api_constants::kDefaultAlignment)))
#endif  // __has_attribute(assume_aligned)
#endif  // defined(__has_attribute)
 
#if !defined(CPPGC_DEFAULT_ALIGNED)
#define CPPGC_DEFAULT_ALIGNED
#endif
 
#if !defined(CPPGC_DOUBLE_WORD_ALIGNED)
#define CPPGC_DOUBLE_WORD_ALIGNED
#endif
 
namespace cppgc {
 
class AllocationHandle;
 
class GarbageCollectedMixin;
 
namespace internal {
 
using AlignVal = std::align_val_t;
 
class MakeGarbageCollectedTraitInternal {
 protected:
  enum class CanContainMixins { kNo, kYes };
 
  static inline void MarkObjectAsFullyConstructed(const void* payload) {
    // See api_constants for an explanation of the constants.
    std::atomic_ref<uint16_t> atomic_mutable_bitfield(
        *const_cast<uint16_t*>(reinterpret_cast<const uint16_t*>(
            reinterpret_cast<const uint8_t*>(payload) -
            api_constants::kFullyConstructedBitFieldOffsetFromPayload)));
    // It's safe to split use load+store here (instead of a read-modify-write
    // operation), since it's guaranteed that this 16-bit bitfield is only
    // modified by a single thread. This is cheaper in terms of code bloat (on
    // ARM) and performance.
    uint16_t value = atomic_mutable_bitfield.load(std::memory_order_relaxed);
    value |= api_constants::kFullyConstructedBitMask;
    atomic_mutable_bitfield.store(value, std::memory_order_release);
  }
 
  // Dispatch based on compile-time information.
  //
  // Default implementation is for a custom space with >`kDefaultAlignment` byte
  // alignment.
  template <typename GCInfoType, typename CustomSpace, size_t alignment,
            CanContainMixins contain_mixins>
  struct AllocationDispatcher final {
    static void* Invoke(AllocationHandle& handle, size_t size) {
      static_assert(std::is_base_of_v<CustomSpaceBase, CustomSpace>,
                    "Custom space must inherit from CustomSpaceBase.");
      static_assert(
          !CustomSpace::kSupportsCompaction,
          "Custom spaces that support compaction do not support allocating "
          "objects with non-default (i.e. word-sized) alignment.");
      if constexpr (contain_mixins == CanContainMixins::kYes) {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, static_cast<AlignVal>(alignment),
            internal::GCInfoTrait<GCInfoType>::Index(),
            CustomSpace::kSpaceIndex, kMixinTag);
      } else {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, static_cast<AlignVal>(alignment),
            internal::GCInfoTrait<GCInfoType>::Index(),
            CustomSpace::kSpaceIndex);
      }
    }
  };
 
  // Fast path for regular allocations for the default space with
  // `kDefaultAlignment` byte alignment.
  template <typename GCInfoType, CanContainMixins contain_mixins>
  struct AllocationDispatcher<GCInfoType, void,
                              api_constants::kDefaultAlignment, contain_mixins>
      final {
    static void* Invoke(AllocationHandle& handle, size_t size) {
      if constexpr (contain_mixins == CanContainMixins::kYes) {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, internal::GCInfoTrait<GCInfoType>::Index(),
            kMixinTag);
      } else {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, internal::GCInfoTrait<GCInfoType>::Index());
      }
    }
  };
 
  // Default space with >`kDefaultAlignment` byte alignment.
  template <typename GCInfoType, size_t alignment,
            CanContainMixins contain_mixins>
  struct AllocationDispatcher<GCInfoType, void, alignment, contain_mixins>
      final {
    static void* Invoke(AllocationHandle& handle, size_t size) {
      if constexpr (contain_mixins == CanContainMixins::kYes) {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, static_cast<AlignVal>(alignment),
            internal::GCInfoTrait<GCInfoType>::Index(), kMixinTag);
      } else {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, static_cast<AlignVal>(alignment),
            internal::GCInfoTrait<GCInfoType>::Index());
      }
    }
  };
 
  // Custom space with `kDefaultAlignment` byte alignment.
  template <typename GCInfoType, typename CustomSpace,
            CanContainMixins contain_mixins>
  struct AllocationDispatcher<GCInfoType, CustomSpace,
                              api_constants::kDefaultAlignment, contain_mixins>
      final {
    static void* Invoke(AllocationHandle& handle, size_t size) {
      static_assert(std::is_base_of_v<CustomSpaceBase, CustomSpace>,
                    "Custom space must inherit from CustomSpaceBase.");
      if constexpr (contain_mixins == CanContainMixins::kYes) {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, internal::GCInfoTrait<GCInfoType>::Index(),
            CustomSpace::kSpaceIndex, kMixinTag);
      } else {
        return MakeGarbageCollectedTraitInternal::Allocate(
            handle, size, internal::GCInfoTrait<GCInfoType>::Index(),
            CustomSpace::kSpaceIndex);
      }
    }
  };
 
 private:
  inline const static struct MixinTag {
  } kMixinTag;
 
  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex);
  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex);
  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex, CustomSpaceIndex);
  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex,
           CustomSpaceIndex);
  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex, MixinTag);
  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex, MixinTag);
  V8_EXPORT static void* CPPGC_DEFAULT_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, GCInfoIndex, CustomSpaceIndex,
           MixinTag);
  V8_EXPORT static void* CPPGC_DOUBLE_WORD_ALIGNED
  Allocate(cppgc::AllocationHandle&, size_t, AlignVal, GCInfoIndex,
           CustomSpaceIndex, MixinTag);
 
  friend class HeapObjectHeader;
};
 
}  // namespace internal
 
template <typename T>
class MakeGarbageCollectedTraitBase
    : private internal::MakeGarbageCollectedTraitInternal {
 private:
  static_assert(internal::IsGarbageCollectedType<T>::value,
                "T needs to be a garbage collected object");
  static_assert(!IsGarbageCollectedWithMixinTypeV<T> ||
                    sizeof(T) <=
                        internal::api_constants::kLargeObjectSizeThreshold,
                "GarbageCollectedMixin may not be a large object");
 
 protected:
  V8_INLINE static void* Allocate(AllocationHandle& handle, size_t size) {
    static_assert(
        std::is_base_of_v<typename T::ParentMostGarbageCollectedType, T>,
        "U of GarbageCollected<U> must be a base of T. Check "
        "GarbageCollected<T> base class inheritance.");
    static constexpr size_t kWantedAlignment =
        alignof(T) < internal::api_constants::kDefaultAlignment
            ? internal::api_constants::kDefaultAlignment
            : alignof(T);
    constexpr CanContainMixins kMayContainMixins =
        std::is_base_of_v<GarbageCollectedMixin, T> ? CanContainMixins::kYes
                                                    : CanContainMixins::kNo;
    static_assert(
        kWantedAlignment <= internal::api_constants::kMaxSupportedAlignment,
        "Requested alignment larger than alignof(std::max_align_t) bytes. "
        "Please file a bug to possibly get this restriction lifted.");
    return AllocationDispatcher<
        typename internal::GCInfoFolding<
            T, typename T::ParentMostGarbageCollectedType>::ResultType,
        typename SpaceTrait<T>::Space, kWantedAlignment,
        kMayContainMixins>::Invoke(handle, size);
  }
 
  V8_INLINE static void MarkObjectAsFullyConstructed(const void* payload) {
    internal::MakeGarbageCollectedTraitInternal::MarkObjectAsFullyConstructed(
        payload);
  }
};
 
struct AdditionalBytes {
  constexpr explicit AdditionalBytes(uint32_t bytes) : value(bytes) {}
  const uint32_t value;
};
 
template <typename T>
class MakeGarbageCollectedTrait : public MakeGarbageCollectedTraitBase<T> {
 public:
  template <typename... Args>
  static T* Call(AllocationHandle& handle, Args&&... args) {
    static_assert(sizeof(T) <= std::numeric_limits<uint32_t>::max());
    void* memory =
        MakeGarbageCollectedTraitBase<T>::Allocate(handle, sizeof(T));
    T* object = ::new (memory) T(std::forward<Args>(args)...);
    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
    return object;
  }
 
  template <typename... Args>
  static T* Call(AllocationHandle& handle, AdditionalBytes additional_bytes,
                 Args&&... args) {
    static_assert(sizeof(T) <= std::numeric_limits<uint32_t>::max());
    const size_t size_to_allocate = sizeof(T) + additional_bytes.value;
    // On 64-bit systems, since sizeof(T) and additional_bytes.value are both at
    // most 32 bits, we know that their sum can't overflow. On 32-bit systems,
    // we need to check it.
#if !defined(V8_HOST_ARCH_64_BIT)
    CPPGC_CHECK(size_to_allocate > additional_bytes.value);
#endif
    void* memory =
        MakeGarbageCollectedTraitBase<T>::Allocate(handle, size_to_allocate);
    T* object = ::new (memory) T(std::forward<Args>(args)...);
    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
    return object;
  }
};
 
template <typename T, typename = void>
struct PostConstructionCallbackTrait {
  static void Call(T*) {}
};
 
template <typename T, typename... Args>
V8_INLINE T* MakeGarbageCollected(AllocationHandle& handle, Args&&... args) {
  T* object =
      MakeGarbageCollectedTrait<T>::Call(handle, std::forward<Args>(args)...);
  PostConstructionCallbackTrait<T>::Call(object);
  return object;
}
 
template <typename T, typename... Args>
V8_INLINE T* MakeGarbageCollected(AllocationHandle& handle,
                                  AdditionalBytes additional_bytes,
                                  Args&&... args) {
  T* object = MakeGarbageCollectedTrait<T>::Call(handle, additional_bytes,
                                                 std::forward<Args>(args)...);
  PostConstructionCallbackTrait<T>::Call(object);
  return object;
}
 
}  // namespace cppgc
 
#undef CPPGC_DEFAULT_ALIGNED
#undef CPPGC_DOUBLE_WORD_ALIGNED
 
#endif  // INCLUDE_CPPGC_ALLOCATION_H_