kc3-lang/angle/src/libANGLE/CLMemory.h

• Show log

  Commit

• Hash : 41b817f3
  Author :
  Date : 2021-05-31T17:38:43
  

  CL: Add buffer enqueue commands
  
  Add buffer enqueue commands to front end and pass-through back end.
  
  Bug: angleproject:6015
  Change-Id: I936530d31903e395550e4540339ebec2e6702e65
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2928425
  Commit-Queue: John Plate <jplate@google.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libANGLE/CLMemory.h

• //
  // Copyright 2021 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.
  //
  // CLMemory.h: Defines the abstract cl::Memory class, which is a memory object
  // and the base class for OpenCL objects such as Buffer, Image and Pipe.
  
  #ifndef LIBANGLE_CLMEMORY_H_
  #define LIBANGLE_CLMEMORY_H_
  
  #include "libANGLE/CLObject.h"
  #include "libANGLE/renderer/CLMemoryImpl.h"
  
  namespace cl
  {
  
  class Memory : public _cl_mem, public Object
  {
    public:
      // Front end entry functions, only called from OpenCL entry points
  
      cl_int getInfo(MemInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
  
    public:
      using PropArray = std::vector<cl_mem_properties>;
  
      ~Memory() override;
  
      virtual cl_mem_object_type getType() const = 0;
  
      const Context &getContext() const;
      const PropArray &getProperties() const;
      MemFlags getFlags() const;
      void *getHostPtr() const;
      const MemoryPtr &getParent() const;
      size_t getOffset() const;
  
      template <typename T = rx::CLMemoryImpl>
      T &getImpl() const;
  
      MemFlags getEffectiveFlags() const;
  
    protected:
      Memory(const Buffer &buffer,
             Context &context,
             PropArray &&properties,
             MemFlags flags,
             size_t size,
             void *hostPtr,
             cl_int &errorCode);
  
      Memory(const Buffer &buffer,
             Buffer &parent,
             MemFlags flags,
             size_t offset,
             size_t size,
             cl_int &errorCode);
  
      Memory(const Image &image,
             Context &context,
             PropArray &&properties,
             MemFlags flags,
             const cl_image_format &format,
             const ImageDescriptor &desc,
             Memory *parent,
             void *hostPtr,
             cl_int &errorCode);
  
      const ContextPtr mContext;
      const PropArray mProperties;
      const MemFlags mFlags;
      void *const mHostPtr = nullptr;
      const MemoryPtr mParent;
      const size_t mOffset = 0u;
      const rx::CLMemoryImpl::Ptr mImpl;
      const size_t mSize;
  
      cl_uint mMapCount = 0u;
  
      friend class Buffer;
      friend class Context;
  };
  
  inline const Context &Memory::getContext() const
  {
      return *mContext;
  }
  
  inline const Memory::PropArray &Memory::getProperties() const
  {
      return mProperties;
  }
  
  inline MemFlags Memory::getFlags() const
  {
      return mFlags;
  }
  
  inline void *Memory::getHostPtr() const
  {
      return mHostPtr;
  }
  
  inline const MemoryPtr &Memory::getParent() const
  {
      return mParent;
  }
  
  inline size_t Memory::getOffset() const
  {
      return mOffset;
  }
  
  template <typename T>
  inline T &Memory::getImpl() const
  {
      return static_cast<T &>(*mImpl);
  }
  
  }  // namespace cl
  
  #endif  // LIBANGLE_CLMEMORY_H_
  

Download