kc3-lang/angle/src/common/MemoryBuffer.h

• Show log

  Commit

• Hash : 9c9b40ac
  Author :
  Date : 2017-04-26T16:31:57
  

  Use parameter cache to skip passing IndexRange.
  
  For DrawElements et al., we can use a simple design to store
  entry point parameters and compute index ranges lazily. This allows
  us to compute the index range outside of the validation layer.
  
  Fixing this will let us implement a few things, such as the no error
  extension. It will also allow auto-generation of the entry points,
  since we won't have to have special cases for certain entry
  points. It will also help fix the syncState layering problem. Now the
  cached parameter helper (which is owned by the Context) can make the
  impl layer calls, instead of the validation layer calling the impl
  directly.
  
  We use a small array in Context to gather parameters in a generic
  way without reallocation on call. We also check type safety by storing
  a type info struct which can handle inheritance between type classes.
  Optional variables for the cache determine when to re-compute values.
  
  The intent with gatherParams is to call this in every entry point, and
  have in most cases be a no-op. In some cases like for IndexRange, we
  store some parameters for later use. The inheritance scheme enables
  auto-generation of the entry points by keeping signatures similar.
  
  BUG=angleproject:747
  
  Change-Id: I871e99e1334cf6e61ef8da62fde3ced094903f8a
  Reviewed-on: https://chromium-review.googlesource.com/474119
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/common/MemoryBuffer.h

• //
  // Copyright (c) 2014 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.
  //
  
  #ifndef COMMON_MEMORYBUFFER_H_
  #define COMMON_MEMORYBUFFER_H_
  
  #include "common/angleutils.h"
  
  #include <cstddef>
  #include <stdint.h>
  
  namespace angle
  {
  
  class MemoryBuffer final : NonCopyable
  {
    public:
      MemoryBuffer();
      ~MemoryBuffer();
  
      bool resize(size_t size);
      size_t size() const;
      bool empty() const { return mSize == 0; }
  
      const uint8_t *data() const;
      uint8_t *data();
  
      void fill(uint8_t datum);
  
    private:
      size_t mSize;
      uint8_t *mData;
  };
  
  class ScratchBuffer final : NonCopyable
  {
    public:
      // If we request a scratch buffer requesting a smaller size this many times, release and
      // recreate the scratch buffer. This ensures we don't have a degenerate case where we are stuck
      // hogging memory.
      ScratchBuffer(uint32_t lifetime);
      ~ScratchBuffer();
  
      // Returns true with a memory buffer of the requested size, or false on failure.
      bool get(size_t requestedSize, MemoryBuffer **memoryBufferOut);
  
      // Ticks the release counter for the scratch buffer. Also done implicitly in get().
      void tick();
  
      void clear();
  
    private:
      const uint32_t mLifetime;
      uint32_t mResetCounter;
      MemoryBuffer mScratchMemory;
  };
  
  }  // namespace angle
  
  #endif // COMMON_MEMORYBUFFER_H_
  

Download