CL: sampler object creation for front end and pass-through

scripts/code_generation_hashes/packed_enum.json

 {
   "src/common/PackedCLEnums_autogen.cpp":
-    "91ef59eed1815db6947faae73a8d3e2d",
+    "19052c8c0888c36b2cf43a3cd4ae5f89",
   "src/common/PackedCLEnums_autogen.h":
-    "4ca5b1eb69c7b690c402a91644d564db",
+    "9c166aa124e697446b35c7eea8b9ff6c",
   "src/common/PackedEGLEnums_autogen.cpp":
     "1e5cf84847c9880d32d1f638b366ed08",
   "src/common/PackedEGLEnums_autogen.h":
@@ -14,7 +14,7 @@
   "src/common/gen_packed_gl_enums.py":
     "7453287e3f184427043604d172a6765b",
   "src/common/packed_cl_enums.json":
-    "b38037f250994e7d275ac2185afea820",
+    "65150f52de0ece8f4280bbe4db52bf6f",
   "src/common/packed_egl_enums.json":
     "76e1b814421e121164d60a0d89cb16c1",
   "src/common/packed_gl_enums.json":

src/common/PackedCLEnums_autogen.cpp

@@ -2159,12 +2159,6 @@ SamplerInfo FromCLenum<SamplerInfo>(CLenum from)
             return SamplerInfo::AddressingMode;
         case CL_SAMPLER_FILTER_MODE:
             return SamplerInfo::FilterMode;
-        case CL_SAMPLER_MIP_FILTER_MODE:
-            return SamplerInfo::MipFilterMode;
-        case CL_SAMPLER_LOD_MIN:
-            return SamplerInfo::LOD_Min;
-        case CL_SAMPLER_LOD_MAX:
-            return SamplerInfo::LOD_Max;
         case CL_SAMPLER_PROPERTIES:
             return SamplerInfo::Properties;
         default:
@@ -2186,12 +2180,6 @@ CLenum ToCLenum(SamplerInfo from)
             return CL_SAMPLER_ADDRESSING_MODE;
         case SamplerInfo::FilterMode:
             return CL_SAMPLER_FILTER_MODE;
-        case SamplerInfo::MipFilterMode:
-            return CL_SAMPLER_MIP_FILTER_MODE;
-        case SamplerInfo::LOD_Min:
-            return CL_SAMPLER_LOD_MIN;
-        case SamplerInfo::LOD_Max:
-            return CL_SAMPLER_LOD_MAX;
         case SamplerInfo::Properties:
             return CL_SAMPLER_PROPERTIES;
         default:
@@ -2219,15 +2207,6 @@ std::ostream &operator<<(std::ostream &os, SamplerInfo value)
         case SamplerInfo::FilterMode:
             os << "CL_SAMPLER_FILTER_MODE";
             break;
-        case SamplerInfo::MipFilterMode:
-            os << "CL_SAMPLER_MIP_FILTER_MODE";
-            break;
-        case SamplerInfo::LOD_Min:
-            os << "CL_SAMPLER_LOD_MIN";
-            break;
-        case SamplerInfo::LOD_Max:
-            os << "CL_SAMPLER_LOD_MAX";
-            break;
         case SamplerInfo::Properties:
             os << "CL_SAMPLER_PROPERTIES";
             break;

src/common/PackedCLEnums_autogen.h

@@ -479,13 +479,10 @@ enum class SamplerInfo : uint8_t
     NormalizedCoords = 2,
     AddressingMode   = 3,
     FilterMode       = 4,
-    MipFilterMode    = 5,
-    LOD_Min          = 6,
-    LOD_Max          = 7,
-    Properties       = 8,
+    Properties       = 5,
 
-    InvalidEnum = 9,
-    EnumCount   = 9,
+    InvalidEnum = 6,
+    EnumCount   = 6,
 };
 
 template <>

src/common/packed_cl_enums.json

@@ -194,9 +194,6 @@
         "NormalizedCoords": "CL_SAMPLER_NORMALIZED_COORDS",
         "AddressingMode": "CL_SAMPLER_ADDRESSING_MODE",
         "FilterMode": "CL_SAMPLER_FILTER_MODE",
-        "MipFilterMode": "CL_SAMPLER_MIP_FILTER_MODE",
-        "LOD_Min": "CL_SAMPLER_LOD_MIN",
-        "LOD_Max": "CL_SAMPLER_LOD_MAX",
         "Properties": "CL_SAMPLER_PROPERTIES"
     },
     "ProgramInfo": {

src/libANGLE/CLContext.cpp

@@ -173,6 +173,53 @@ cl_mem Context::createImage3D(cl_mem_flags flags,
         new Image(*this, {}, flags, *format, imageDesc, nullptr, hostPtr, errcodeRet), errcodeRet);
 }
 
+cl_sampler Context::createSampler(cl_bool normalizedCoords,
+                                  AddressingMode addressingMode,
+                                  FilterMode filterMode,
+                                  cl_int *errcodeRet)
+{
+    return createSampler(
+        new Sampler(*this, {}, normalizedCoords, addressingMode, filterMode, errcodeRet),
+        errcodeRet);
+}
+
+cl_sampler Context::createSamplerWithProperties(const cl_sampler_properties *properties,
+                                                cl_int *errcodeRet)
+{
+    Sampler::PropArray propArray;
+    cl_bool normalizedCoords      = CL_TRUE;
+    AddressingMode addressingMode = AddressingMode::Clamp;
+    FilterMode filterMode         = FilterMode::Nearest;
+
+    if (properties != nullptr)
+    {
+        const cl_sampler_properties *propIt = properties;
+        while (*propIt != 0)
+        {
+            switch (*propIt++)
+            {
+                case CL_SAMPLER_NORMALIZED_COORDS:
+                    normalizedCoords = static_cast<decltype(normalizedCoords)>(*propIt++);
+                    break;
+                case CL_SAMPLER_ADDRESSING_MODE:
+                    addressingMode = FromCLenum<AddressingMode>(static_cast<CLenum>(*propIt++));
+                    break;
+                case CL_SAMPLER_FILTER_MODE:
+                    filterMode = FromCLenum<FilterMode>(static_cast<CLenum>(*propIt++));
+                    break;
+            }
+        }
+        // Include the trailing zero
+        ++propIt;
+        propArray.reserve(propIt - properties);
+        propArray.insert(propArray.cend(), properties, propIt);
+    }
+
+    return createSampler(new Sampler(*this, std::move(propArray), normalizedCoords, addressingMode,
+                                     filterMode, errcodeRet),
+                         errcodeRet);
+}
+
 bool Context::IsValid(const _cl_context *context)
 {
     const Platform::PtrList &platforms = Platform::GetPlatforms();
@@ -249,6 +296,21 @@ cl_mem Context::createMemory(Memory *memory, cl_int *errcodeRet)
     return mMemories.back().get();
 }
 
+cl_sampler Context::createSampler(Sampler *sampler, cl_int *errcodeRet)
+{
+    mSamplers.emplace_back(sampler);
+    if (!mSamplers.back()->mImpl)
+    {
+        mSamplers.back()->release();
+        return nullptr;
+    }
+    if (errcodeRet != nullptr)
+    {
+        *errcodeRet = CL_SUCCESS;
+    }
+    return mSamplers.back().get();
+}
+
 void Context::destroyCommandQueue(CommandQueue *commandQueue)
 {
     auto commandQueueIt = mCommandQueues.cbegin();
@@ -283,6 +345,23 @@ void Context::destroyMemory(Memory *memory)
     }
 }
 
+void Context::destroySampler(Sampler *sampler)
+{
+    auto samplerIt = mSamplers.cbegin();
+    while (samplerIt != mSamplers.cend() && samplerIt->get() != sampler)
+    {
+        ++samplerIt;
+    }
+    if (samplerIt != mSamplers.cend())
+    {
+        mSamplers.erase(samplerIt);
+    }
+    else
+    {
+        ERR() << "Sampler not found";
+    }
+}
+
 void Context::ErrorCallback(const char *errinfo, const void *privateInfo, size_t cb, void *userData)
 {
     Context *const context = static_cast<Context *>(userData);

src/libANGLE/CLContext.h

@@ -12,6 +12,7 @@
 #include "libANGLE/CLCommandQueue.h"
 #include "libANGLE/CLDevice.h"
 #include "libANGLE/CLMemory.h"
+#include "libANGLE/CLSampler.h"
 #include "libANGLE/renderer/CLContextImpl.h"
 
 namespace cl
@@ -28,9 +29,11 @@ class Context final : public _cl_context, public Object
     const Platform &getPlatform() const noexcept;
     bool hasDevice(const _cl_device_id *device) const;
     const DeviceRefList &getDevices() const;
+    bool supportsImages() const;
 
     bool hasCommandQueue(const _cl_command_queue *commandQueue) const;
     bool hasMemory(const _cl_mem *memory) const;
+    bool hasSampler(const _cl_sampler *sampler) const;
 
     void retain() noexcept;
     bool release();
@@ -76,6 +79,14 @@ class Context final : public _cl_context, public Object
                          void *hostPtr,
                          cl_int *errcodeRet);
 
+    cl_sampler createSampler(cl_bool normalizedCoords,
+                             AddressingMode addressingMode,
+                             FilterMode filterMode,
+                             cl_int *errcodeRet);
+
+    cl_sampler createSamplerWithProperties(const cl_sampler_properties *properties,
+                                           cl_int *errcodeRet);
+
     static bool IsValid(const _cl_context *context);
 
   private:
@@ -97,9 +108,11 @@ class Context final : public _cl_context, public Object
 
     cl_command_queue createCommandQueue(CommandQueue *commandQueue, cl_int *errcodeRet);
     cl_mem createMemory(Memory *memory, cl_int *errcodeRet);
+    cl_sampler createSampler(Sampler *sampler, cl_int *errcodeRet);
 
     void destroyCommandQueue(CommandQueue *commandQueue);
     void destroyMemory(Memory *memory);
+    void destroySampler(Sampler *sampler);
 
     static void CL_CALLBACK ErrorCallback(const char *errinfo,
                                           const void *privateInfo,
@@ -115,11 +128,13 @@ class Context final : public _cl_context, public Object
 
     CommandQueue::PtrList mCommandQueues;
     Memory::PtrList mMemories;
+    Sampler::PtrList mSamplers;
 
     friend class Buffer;
     friend class CommandQueue;
     friend class Memory;
     friend class Platform;
+    friend class Sampler;
 };
 
 inline const Platform &Context::getPlatform() const noexcept
@@ -139,6 +154,13 @@ inline const DeviceRefList &Context::getDevices() const
     return mDevices;
 }
 
+inline bool Context::supportsImages() const
+{
+    return (std::find_if(mDevices.cbegin(), mDevices.cend(), [](const DeviceRefPtr &ptr) {
+                return ptr->getInfo().mImageSupport == CL_TRUE;
+            }) != mDevices.cend());
+}
+
 inline bool Context::hasCommandQueue(const _cl_command_queue *commandQueue) const
 {
     return std::find_if(mCommandQueues.cbegin(), mCommandQueues.cend(),
@@ -153,6 +175,13 @@ inline bool Context::hasMemory(const _cl_mem *memory) const
            }) != mMemories.cend();
 }
 
+inline bool Context::hasSampler(const _cl_sampler *sampler) const
+{
+    return std::find_if(mSamplers.cbegin(), mSamplers.cend(), [=](const SamplerPtr &ptr) {
+               return ptr.get() == sampler;
+           }) != mSamplers.cend();
+}
+
 inline void Context::retain() noexcept
 {
     addRef();

src/libANGLE/CLPlatform.h

@@ -36,6 +36,7 @@ class Platform final : public _cl_platform_id, public Object
     bool hasContext(const _cl_context *context) const;
     bool hasCommandQueue(const _cl_command_queue *commandQueue) const;
     bool hasMemory(const _cl_mem *memory) const;
+    bool hasSampler(const _cl_sampler *sampler) const;
 
     cl_int getInfo(PlatformInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
 
@@ -135,6 +136,13 @@ inline bool Platform::hasMemory(const _cl_mem *memory) const
            }) != mContexts.cend();
 }
 
+inline bool Platform::hasSampler(const _cl_sampler *sampler) const
+{
+    return std::find_if(mContexts.cbegin(), mContexts.cend(), [=](const ContextPtr &ptr) {
+               return ptr->hasSampler(sampler);
+           }) != mContexts.cend();
+}
+
 inline Platform::PtrList &Platform::GetList()
 {
     static angle::base::NoDestructor<PtrList> sList;

src/libANGLE/CLSampler.cpp

@@ -7,9 +7,109 @@
 
 #include "libANGLE/CLSampler.h"
 
+#include "libANGLE/CLContext.h"
+#include "libANGLE/CLPlatform.h"
+
+#include <cstring>
+
 namespace cl
 {
 
-Sampler::Sampler(const cl_icd_dispatch &dispatch) : _cl_sampler(dispatch) {}
+Sampler::~Sampler() = default;
+
+bool Sampler::release()
+{
+    const bool released = removeRef();
+    if (released)
+    {
+        mContext->destroySampler(this);
+    }
+    return released;
+}
+
+cl_int Sampler::getInfo(SamplerInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const
+{
+    static_assert(std::is_same<cl_uint, cl_addressing_mode>::value &&
+                      std::is_same<cl_uint, cl_filter_mode>::value,
+                  "OpenCL type mismatch");
+
+    cl_uint valUInt       = 0u;
+    void *valPointer      = nullptr;
+    const void *copyValue = nullptr;
+    size_t copySize       = 0u;
+
+    switch (name)
+    {
+        case SamplerInfo::ReferenceCount:
+            copyValue = getRefCountPtr();
+            copySize  = sizeof(*getRefCountPtr());
+            break;
+        case SamplerInfo::Context:
+            valPointer = static_cast<cl_context>(mContext.get());
+            copyValue  = &valPointer;
+            copySize   = sizeof(valPointer);
+            break;
+        case SamplerInfo::NormalizedCoords:
+            copyValue = &mNormalizedCoords;
+            copySize  = sizeof(mNormalizedCoords);
+            break;
+        case SamplerInfo::AddressingMode:
+            valUInt   = ToCLenum(mAddressingMode);
+            copyValue = &valUInt;
+            copySize  = sizeof(valUInt);
+            break;
+        case SamplerInfo::FilterMode:
+            valUInt   = ToCLenum(mFilterMode);
+            copyValue = &valUInt;
+            copySize  = sizeof(valUInt);
+            break;
+        case SamplerInfo::Properties:
+            copyValue = mProperties.data();
+            copySize  = mProperties.size() * sizeof(decltype(mProperties)::value_type);
+            break;
+        default:
+            return CL_INVALID_VALUE;
+    }
+
+    if (value != nullptr)
+    {
+        if (valueSize < copySize)
+        {
+            return CL_INVALID_VALUE;
+        }
+        if (copyValue != nullptr)
+        {
+            std::memcpy(value, copyValue, copySize);
+        }
+    }
+    if (valueSizeRet != nullptr)
+    {
+        *valueSizeRet = copySize;
+    }
+    return CL_SUCCESS;
+}
+
+bool Sampler::IsValid(const _cl_sampler *sampler)
+{
+    const Platform::PtrList &platforms = Platform::GetPlatforms();
+    return std::find_if(platforms.cbegin(), platforms.cend(), [=](const PlatformPtr &platform) {
+               return platform->hasSampler(sampler);
+           }) != platforms.cend();
+}
+
+Sampler::Sampler(Context &context,
+                 PropArray &&properties,
+                 cl_bool normalizedCoords,
+                 AddressingMode addressingMode,
+                 FilterMode filterMode,
+                 cl_int *errcodeRet)
+    : _cl_sampler(context.getDispatch()),
+      mContext(&context),
+      mProperties(std::move(properties)),
+      mNormalizedCoords(normalizedCoords),
+      mAddressingMode(addressingMode),
+      mFilterMode(filterMode),
+      mImpl(context.mImpl->createSampler(*this, errcodeRet))
+{}
 
 }  // namespace cl

src/libANGLE/CLSampler.h

@@ -9,6 +9,7 @@
 #define LIBANGLE_CLSAMPLER_H_
 
 #include "libANGLE/CLObject.h"
+#include "libANGLE/renderer/CLSamplerImpl.h"
 
 namespace cl
 {
@@ -16,10 +17,72 @@ namespace cl
 class Sampler final : public _cl_sampler, public Object
 {
   public:
-    Sampler(const cl_icd_dispatch &dispatch);
-    ~Sampler() override = default;
+    using PtrList   = std::list<SamplerPtr>;
+    using PropArray = std::vector<cl_sampler_properties>;
+
+    ~Sampler() override;
+
+    const Context &getContext() const;
+    const PropArray &getProperties() const;
+    cl_bool getNormalizedCoords() const;
+    AddressingMode getAddressingMode() const;
+    FilterMode getFilterMode() const;
+
+    void retain() noexcept;
+    bool release();
+
+    cl_int getInfo(SamplerInfo name, size_t valueSize, void *value, size_t *valueSizeRet) const;
+
+    static bool IsValid(const _cl_sampler *sampler);
+
+  private:
+    Sampler(Context &context,
+            PropArray &&properties,
+            cl_bool normalizedCoords,
+            AddressingMode addressingMode,
+            FilterMode filterMode,
+            cl_int *errcodeRet);
+
+    const ContextRefPtr mContext;
+    const PropArray mProperties;
+    const cl_bool mNormalizedCoords;
+    const AddressingMode mAddressingMode;
+    const FilterMode mFilterMode;
+    const rx::CLSamplerImpl::Ptr mImpl;
+
+    friend class Context;
 };
 
+inline const Context &Sampler::getContext() const
+{
+    return *mContext;
+}
+
+inline const Sampler::PropArray &Sampler::getProperties() const
+{
+    return mProperties;
+}
+
+inline cl_bool Sampler::getNormalizedCoords() const
+{
+    return mNormalizedCoords;
+}
+
+inline AddressingMode Sampler::getAddressingMode() const
+{
+    return mAddressingMode;
+}
+
+inline FilterMode Sampler::getFilterMode() const
+{
+    return mFilterMode;
+}
+
+inline void Sampler::retain() noexcept
+{
+    addRef();
+}
+
 }  // namespace cl
 
 #endif  // LIBANGLE_CLSAMPLER_H_

src/libANGLE/renderer/CLContextImpl.h

@@ -11,6 +11,7 @@
 #include "libANGLE/renderer/CLCommandQueueImpl.h"
 #include "libANGLE/renderer/CLDeviceImpl.h"
 #include "libANGLE/renderer/CLMemoryImpl.h"
+#include "libANGLE/renderer/CLSamplerImpl.h"
 
 namespace rx
 {
@@ -39,6 +40,8 @@ class CLContextImpl : angle::NonCopyable
                                           void *hostPtr,
                                           cl_int *errcodeRet) = 0;
 
+    virtual CLSamplerImpl::Ptr createSampler(const cl::Sampler &sampler, cl_int *errcodeRet) = 0;
+
   protected:
     const cl::Context &mContext;
 };

src/libANGLE/renderer/CLSamplerImpl.cpp

+//
+// 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.
+//
+// CLSamplerImpl.cpp: Implements the class methods for CLSamplerImpl.
+
+#include "libANGLE/renderer/CLSamplerImpl.h"
+
+namespace rx
+{
+
+CLSamplerImpl::CLSamplerImpl(const cl::Sampler &sampler) : mSampler(sampler) {}
+
+CLSamplerImpl::~CLSamplerImpl() = default;
+
+}  // namespace rx

src/libANGLE/renderer/CLSamplerImpl.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.
+//
+// CLSamplerImpl.h: Defines the abstract rx::CLSamplerImpl class.
+
+#ifndef LIBANGLE_RENDERER_CLSAMPLERIMPL_H_
+#define LIBANGLE_RENDERER_CLSAMPLERIMPL_H_
+
+#include "libANGLE/renderer/CLtypes.h"
+
+namespace rx
+{
+
+class CLSamplerImpl : angle::NonCopyable
+{
+  public:
+    using Ptr = std::unique_ptr<CLSamplerImpl>;
+
+    CLSamplerImpl(const cl::Sampler &sampler);
+    virtual ~CLSamplerImpl();
+
+  protected:
+    const cl::Sampler &mSampler;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_CLSAMPLERIMPL_H_

src/libANGLE/renderer/cl/BUILD.gn

@@ -19,6 +19,8 @@ _cl_backend_sources = [
   "CLMemoryCL.h",
   "CLPlatformCL.cpp",
   "CLPlatformCL.h",
+  "CLSamplerCL.cpp",
+  "CLSamplerCL.h",
   "cl_types.h",
   "cl_util.cpp",
   "cl_util.h",

src/libANGLE/renderer/cl/CLContextCL.cpp

@@ -10,6 +10,7 @@
 #include "libANGLE/renderer/cl/CLCommandQueueCL.h"
 #include "libANGLE/renderer/cl/CLDeviceCL.h"
 #include "libANGLE/renderer/cl/CLMemoryCL.h"
+#include "libANGLE/renderer/cl/CLSamplerCL.h"
 
 #include "libANGLE/CLBuffer.h"
 #include "libANGLE/CLCommandQueue.h"
@@ -18,6 +19,7 @@
 #include "libANGLE/CLImage.h"
 #include "libANGLE/CLMemory.h"
 #include "libANGLE/CLPlatform.h"
+#include "libANGLE/CLSampler.h"
 #include "libANGLE/Debug.h"
 
 namespace rx
@@ -170,4 +172,34 @@ CLMemoryImpl::Ptr CLContextCL::createImage(const cl::Image &image,
     return CLMemoryImpl::Ptr(nativeImage != nullptr ? new CLMemoryCL(image, nativeImage) : nullptr);
 }
 
+CLSamplerImpl::Ptr CLContextCL::createSampler(const cl::Sampler &sampler, cl_int *errcodeRet)
+{
+    cl_sampler nativeSampler = nullptr;
+    if (!mContext.getPlatform().isVersionOrNewer(2u, 0u))
+    {
+        nativeSampler = mNative->getDispatch().clCreateSampler(
+            mNative, sampler.getNormalizedCoords(), cl::ToCLenum(sampler.getAddressingMode()),
+            cl::ToCLenum(sampler.getFilterMode()), errcodeRet);
+    }
+    else if (!sampler.getProperties().empty())
+    {
+        nativeSampler = mNative->getDispatch().clCreateSamplerWithProperties(
+            mNative, sampler.getProperties().data(), errcodeRet);
+    }
+    else
+    {
+        const cl_sampler_properties propArray[] = {CL_SAMPLER_NORMALIZED_COORDS,
+                                                   sampler.getNormalizedCoords(),
+                                                   CL_SAMPLER_ADDRESSING_MODE,
+                                                   cl::ToCLenum(sampler.getAddressingMode()),
+                                                   CL_SAMPLER_FILTER_MODE,
+                                                   cl::ToCLenum(sampler.getFilterMode()),
+                                                   0u};
+        nativeSampler =
+            mNative->getDispatch().clCreateSamplerWithProperties(mNative, propArray, errcodeRet);
+    }
+    return CLSamplerImpl::Ptr(nativeSampler != nullptr ? new CLSamplerCL(sampler, nativeSampler)
+                                                       : nullptr);
+}
+
 }  // namespace rx

src/libANGLE/renderer/cl/CLContextCL.h

@@ -37,6 +37,8 @@ class CLContextCL : public CLContextImpl
                                   void *hostPtr,
                                   cl_int *errcodeRet) override;
 
+    CLSamplerImpl::Ptr createSampler(const cl::Sampler &sampler, cl_int *errcodeRet) override;
+
   private:
     const cl_context mNative;
 };

src/libANGLE/renderer/cl/CLSamplerCL.cpp

+//
+// 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.
+//
+// CLSamplerCL.cpp: Implements the class methods for CLSamplerCL.
+
+#include "libANGLE/renderer/cl/CLSamplerCL.h"
+
+#include "libANGLE/Debug.h"
+
+namespace rx
+{
+
+CLSamplerCL::CLSamplerCL(const cl::Sampler &sampler, cl_sampler native)
+    : CLSamplerImpl(sampler), mNative(native)
+{}
+
+CLSamplerCL::~CLSamplerCL()
+{
+    if (mNative->getDispatch().clReleaseSampler(mNative) != CL_SUCCESS)
+    {
+        ERR() << "Error while releasing CL sampler";
+    }
+}
+
+}  // namespace rx

src/libANGLE/renderer/cl/CLSamplerCL.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.
+//
+// CLSamplerCL.h: Defines the class interface for CLSamplerCL, implementing CLSamplerImpl.
+
+#ifndef LIBANGLE_RENDERER_CL_CLSAMPLERCL_H_
+#define LIBANGLE_RENDERER_CL_CLSAMPLERCL_H_
+
+#include "libANGLE/renderer/cl/cl_types.h"
+
+#include "libANGLE/renderer/CLSamplerImpl.h"
+
+namespace rx
+{
+
+class CLSamplerCL : public CLSamplerImpl
+{
+  public:
+    CLSamplerCL(const cl::Sampler &sampler, cl_sampler native);
+    ~CLSamplerCL() override;
+
+  private:
+    const cl_sampler mNative;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_CL_CLSAMPLERCL_H_

src/libANGLE/renderer/vulkan/BUILD.gn

@@ -115,6 +115,8 @@ if (angle_enable_cl) {
     "CLMemoryVk.h",
     "CLPlatformVk.cpp",
     "CLPlatformVk.h",
+    "CLSamplerVk.cpp",
+    "CLSamplerVk.h",
     "cl_types.h",
   ]
 }

src/libANGLE/renderer/vulkan/CLSamplerVk.cpp

+//
+// 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.
+//
+// CLSamplerVk.cpp: Implements the class methods for CLSamplerVk.
+
+#include "libANGLE/renderer/vulkan/CLSamplerVk.h"
+
+namespace rx
+{
+
+CLSamplerVk::CLSamplerVk(const cl::Sampler &sampler) : CLSamplerImpl(sampler) {}
+
+CLSamplerVk::~CLSamplerVk() = default;
+
+}  // namespace rx

src/libANGLE/renderer/vulkan/CLSamplerVk.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.
+//
+// CLSamplerVk.h: Defines the class interface for CLSamplerVk, implementing CLSamplerImpl.
+
+#ifndef LIBANGLE_RENDERER_VULKAN_CLSAMPLERVK_H_
+#define LIBANGLE_RENDERER_VULKAN_CLSAMPLERVK_H_
+
+#include "libANGLE/renderer/vulkan/cl_types.h"
+
+#include "libANGLE/renderer/CLSamplerImpl.h"
+
+namespace rx
+{
+
+class CLSamplerVk : public CLSamplerImpl
+{
+  public:
+    CLSamplerVk(const cl::Sampler &sampler);
+    ~CLSamplerVk() override;
+};
+
+}  // namespace rx
+
+#endif  // LIBANGLE_RENDERER_VULKAN_CLSAMPLERVK_H_

src/libANGLE/validationCL.cpp

@@ -601,12 +601,12 @@ cl_int ValidateGetImageInfo(cl_mem image,
 
 cl_int ValidateRetainSampler(cl_sampler sampler)
 {
-    return CL_SUCCESS;
+    return Sampler::IsValid(sampler) ? CL_SUCCESS : CL_INVALID_SAMPLER;
 }
 
 cl_int ValidateReleaseSampler(cl_sampler sampler)
 {
-    return CL_SUCCESS;
+    return Sampler::IsValid(sampler) ? CL_SUCCESS : CL_INVALID_SAMPLER;
 }
 
 cl_int ValidateGetSamplerInfo(cl_sampler sampler,
@@ -615,6 +615,17 @@ cl_int ValidateGetSamplerInfo(cl_sampler sampler,
                               const void *param_value,
                               const size_t *param_value_size_ret)
 {
+    if (!Sampler::IsValid(sampler))
+    {
+        return CL_INVALID_SAMPLER;
+    }
+    const Platform &platform = static_cast<const Sampler *>(sampler)->getContext().getPlatform();
+    if (param_name == SamplerInfo::InvalidEnum ||
+        (param_name == SamplerInfo::Properties && !platform.isVersionOrNewer(3u, 0u)) ||
+        (param_value_size == 0u && param_value != nullptr))
+    {
+        return CL_INVALID_VALUE;
+    }
     return CL_SUCCESS;
 }
 
@@ -1047,6 +1058,19 @@ bool ValidateCreateSampler(cl_context context,
                            FilterMode filter_mode,
                            cl_int *errcode_ret)
 {
+    if (!Context::IsValid(context))
+    {
+        ANGLE_ERROR_RETURN(CL_INVALID_CONTEXT, false);
+    }
+    if ((normalized_coords != CL_FALSE && normalized_coords != CL_TRUE) ||
+        addressing_mode == AddressingMode::InvalidEnum || filter_mode == FilterMode::InvalidEnum)
+    {
+        ANGLE_ERROR_RETURN(CL_INVALID_VALUE, false);
+    }
+    if (!static_cast<Context *>(context)->supportsImages())
+    {
+        ANGLE_ERROR_RETURN(CL_INVALID_OPERATION, false);
+    }
     return true;
 }
 
@@ -1281,16 +1305,13 @@ bool ValidateCreateImage(cl_context context,
         ANGLE_ERROR_RETURN(CL_INVALID_IMAGE_DESCRIPTOR, false);
     }
 
-    const DeviceRefList &devices = ctx.getDevices();
-    // Fail if no device supports images
-    if (std::find_if(devices.cbegin(), devices.cend(), [](const DeviceRefPtr &ptr) {
-            return ptr->getInfo().mImageSupport == CL_TRUE;
-        }) == devices.cend())
+    if (!ctx.supportsImages())
     {
         ANGLE_ERROR_RETURN(CL_INVALID_OPERATION, false);
     }
 
     // Fail if image dimensions exceed supported maximum of all devices
+    const DeviceRefList &devices = ctx.getDevices();
     if (std::find_if(devices.cbegin(), devices.cend(), [&](const DeviceRefPtr &ptr) {
             switch (image_desc->image_type)
             {
@@ -1524,6 +1545,53 @@ bool ValidateCreateSamplerWithProperties(cl_context context,
                                          const cl_sampler_properties *sampler_properties,
                                          cl_int *errcode_ret)
 {
+    if (!Context::IsValid(context))
+    {
+        ANGLE_ERROR_RETURN(CL_INVALID_CONTEXT, false);
+    }
+    if (sampler_properties != nullptr)
+    {
+        bool hasNormalizedCoords            = false;
+        bool hasAddressingMode              = false;
+        bool hasFilterMode                  = false;
+        const cl_sampler_properties *propIt = sampler_properties;
+        while (*propIt != 0)
+        {
+            switch (*propIt++)
+            {
+                case CL_SAMPLER_NORMALIZED_COORDS:
+                    if (hasNormalizedCoords || (*propIt != CL_FALSE && *propIt != CL_TRUE))
+                    {
+                        ANGLE_ERROR_RETURN(CL_INVALID_VALUE, false);
+                    }
+                    hasNormalizedCoords = true;
+                    ++propIt;
+                    break;
+                case CL_SAMPLER_ADDRESSING_MODE:
+                    if (hasAddressingMode || FromCLenum<AddressingMode>(static_cast<CLenum>(
+                                                 *propIt++)) == AddressingMode::InvalidEnum)
+                    {
+                        ANGLE_ERROR_RETURN(CL_INVALID_VALUE, false);
+                    }
+                    hasAddressingMode = true;
+                    break;
+                case CL_SAMPLER_FILTER_MODE:
+                    if (hasFilterMode || FromCLenum<FilterMode>(static_cast<CLenum>(*propIt++)) ==
+                                             FilterMode::InvalidEnum)
+                    {
+                        ANGLE_ERROR_RETURN(CL_INVALID_VALUE, false);
+                    }
+                    hasFilterMode = true;
+                    break;
+                default:
+                    ANGLE_ERROR_RETURN(CL_INVALID_VALUE, false);
+            }
+        }
+    }
+    if (!static_cast<Context *>(context)->supportsImages())
+    {
+        ANGLE_ERROR_RETURN(CL_INVALID_OPERATION, false);
+    }
     return true;
 }
 

src/libGLESv2.gni

@@ -473,6 +473,7 @@ libangle_cl_headers = [
   "src/libANGLE/renderer/CLDeviceImpl.h",
   "src/libANGLE/renderer/CLMemoryImpl.h",
   "src/libANGLE/renderer/CLPlatformImpl.h",
+  "src/libANGLE/renderer/CLSamplerImpl.h",
   "src/libANGLE/renderer/CLtypes.h",
   "src/libANGLE/validationCL.h",
   "src/libANGLE/validationCL_autogen.h",
@@ -497,6 +498,7 @@ libangle_cl_sources = [
   "src/libANGLE/renderer/CLDeviceImpl.cpp",
   "src/libANGLE/renderer/CLMemoryImpl.cpp",
   "src/libANGLE/renderer/CLPlatformImpl.cpp",
+  "src/libANGLE/renderer/CLSamplerImpl.cpp",
   "src/libANGLE/validationCL.cpp",
 ]
 

src/libGLESv2/cl_stubs.cpp

@@ -345,20 +345,20 @@ cl_sampler CreateSamplerWithProperties(cl_context context,
                                        const cl_sampler_properties *sampler_properties,
                                        cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateSamplerWithProperties);
-    return 0;
+    return static_cast<Context *>(context)->createSamplerWithProperties(sampler_properties,
+                                                                        errcode_ret);
 }
 
 cl_int RetainSampler(cl_sampler sampler)
 {
-    WARN_NOT_SUPPORTED(RetainSampler);
-    return 0;
+    static_cast<Sampler *>(sampler)->retain();
+    return CL_SUCCESS;
 }
 
 cl_int ReleaseSampler(cl_sampler sampler)
 {
-    WARN_NOT_SUPPORTED(ReleaseSampler);
-    return 0;
+    static_cast<Sampler *>(sampler)->release();
+    return CL_SUCCESS;
 }
 
 cl_int GetSamplerInfo(cl_sampler sampler,
@@ -367,8 +367,8 @@ cl_int GetSamplerInfo(cl_sampler sampler,
                       void *param_value,
                       size_t *param_value_size_ret)
 {
-    WARN_NOT_SUPPORTED(GetSamplerInfo);
-    return 0;
+    return static_cast<Sampler *>(sampler)->getInfo(param_name, param_value_size, param_value,
+                                                    param_value_size_ret);
 }
 
 cl_program CreateProgramWithSource(cl_context context,
@@ -1152,8 +1152,8 @@ cl_sampler CreateSampler(cl_context context,
                          FilterMode filter_mode,
                          cl_int *errcode_ret)
 {
-    WARN_NOT_SUPPORTED(CreateSampler);
-    return 0;
+    return static_cast<Context *>(context)->createSampler(normalized_coords, addressing_mode,
+                                                          filter_mode, errcode_ret);
 }
 
 cl_int EnqueueTask(cl_command_queue command_queue,