kc3-lang/angle/src/libANGLE/renderer/serial_utils.h

• Show log

  Commit

• Hash : ce4918f1
  Author :
  Date : 2020-02-19T09:39:44
  

  Vulkan: Sanitize Images & Buffers with non-zero values.
  
  Only enabled for specific tests at the moment. This CL allows our tests
  to sanitizes memory for the robust resource access extension. It is
  quite slow so should not be enabled by default.
  
  Only works for 1 level 2D color textures and buffers. Makes several
  flaky robust resource initialization tests consistently fail.
  
  Controlled via an angle::Feature in FeaturesVk.
  
  It works by initializing memory to an abitrary non-zero value:
  
   - if newly allocated memory is mappable, we map it in init and set it
   - if a buffer or texture can be a transfer destination, we use a
     staging resource
   - otherwise we don't attempt to initialize the resource.
  
  Bug: angleproject:4384
  Change-Id: I9b4f347bfcddf3096f491ed0243bef86837feaa0
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2043271
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libANGLE/renderer/serial_utils.h

• //
  // Copyright 2019 The ANGLE 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.
  //
  // serial_utils:
  //   Utilities for generating unique IDs for resources in ANGLE.
  //
  
  #ifndef LIBANGLE_RENDERER_SERIAL_UTILS_H_
  #define LIBANGLE_RENDERER_SERIAL_UTILS_H_
  
  #include <atomic>
  #include <limits>
  
  #include "common/angleutils.h"
  #include "common/debug.h"
  
  namespace rx
  {
  class ResourceSerial
  {
    public:
      constexpr ResourceSerial() : mValue(kDirty) {}
      explicit constexpr ResourceSerial(uintptr_t value) : mValue(value) {}
      constexpr bool operator==(ResourceSerial other) const { return mValue == other.mValue; }
      constexpr bool operator!=(ResourceSerial other) const { return mValue != other.mValue; }
  
      void dirty() { mValue = kDirty; }
      void clear() { mValue = kEmpty; }
  
      constexpr bool valid() const { return mValue != kEmpty && mValue != kDirty; }
      constexpr bool empty() const { return mValue == kEmpty; }
  
    private:
      constexpr static uintptr_t kDirty = std::numeric_limits<uintptr_t>::max();
      constexpr static uintptr_t kEmpty = 0;
  
      uintptr_t mValue;
  };
  
  class Serial final
  {
    public:
      constexpr Serial() : mValue(kInvalid) {}
      constexpr Serial(const Serial &other) = default;
      Serial &operator=(const Serial &other) = default;
  
      static constexpr Serial Infinite() { return Serial(std::numeric_limits<uint64_t>::max()); }
  
      constexpr bool operator==(const Serial &other) const
      {
          return mValue != kInvalid && mValue == other.mValue;
      }
      constexpr bool operator==(uint32_t value) const
      {
          return mValue != kInvalid && mValue == static_cast<uint64_t>(value);
      }
      constexpr bool operator!=(const Serial &other) const
      {
          return mValue == kInvalid || mValue != other.mValue;
      }
      constexpr bool operator>(const Serial &other) const { return mValue > other.mValue; }
      constexpr bool operator>=(const Serial &other) const { return mValue >= other.mValue; }
      constexpr bool operator<(const Serial &other) const { return mValue < other.mValue; }
      constexpr bool operator<=(const Serial &other) const { return mValue <= other.mValue; }
  
      constexpr bool operator<(uint32_t value) const { return mValue < static_cast<uint64_t>(value); }
  
      // Useful for serialization.
      constexpr uint64_t getValue() const { return mValue; }
  
    private:
      template <typename T>
      friend class SerialFactoryBase;
      constexpr explicit Serial(uint64_t value) : mValue(value) {}
      uint64_t mValue;
      static constexpr uint64_t kInvalid = 0;
  };
  
  // Used as default/initial serial
  static constexpr Serial kZeroSerial = Serial();
  
  template <typename SerialBaseType>
  class SerialFactoryBase final : angle::NonCopyable
  {
    public:
      SerialFactoryBase() : mSerial(1) {}
  
      Serial generate()
      {
          ASSERT(mSerial + 1 > mSerial);
          return Serial(mSerial++);
      }
  
    private:
      SerialBaseType mSerial;
  };
  
  using SerialFactory       = SerialFactoryBase<uint64_t>;
  using AtomicSerialFactory = SerialFactoryBase<std::atomic<uint64_t>>;
  }  // namespace rx
  
  #endif  // LIBANGLE_RENDERER_SERIAL_UTILS_H_
  

Download