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

• Show log

  Commit

• Hash : 2d1bb3e1
  Author :
  Date : 2024-04-15T00:58:07
  

  CL: Replace Spinlock with angle::SimpleMutex
  
  Bug: angleproject:8667
  Change-Id: I9b53da920ea743d77c76793522cef826ecc62813
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5446559
  Reviewed-by: Austin Annestrand <a.annestrand@samsung.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/CLProgram.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.
  //
  // CLProgram.h: Defines the cl::Program class, which consists of a set of OpenCL kernels.
  
  #ifndef LIBANGLE_CLPROGRAM_H_
  #define LIBANGLE_CLPROGRAM_H_
  
  #include "libANGLE/CLDevice.h"
  #include "libANGLE/CLKernel.h"
  #include "libANGLE/cl_utils.h"
  #include "libANGLE/renderer/CLProgramImpl.h"
  
  #include "common/SynchronizedValue.h"
  
  #include <atomic>
  
  namespace cl
  {
  
  class Program final : public _cl_program, public Object
  {
    public:
      // Front end entry functions, only called from OpenCL entry points
  
      angle::Result build(cl_uint numDevices,
                          const cl_device_id *deviceList,
                          const char *options,
                          ProgramCB pfnNotify,
                          void *userData);
  
      angle::Result compile(cl_uint numDevices,
                            const cl_device_id *deviceList,
                            const char *options,
                            cl_uint numInputHeaders,
                            const cl_program *inputHeaders,
                            const char **headerIncludeNames,
                            ProgramCB pfnNotify,
                            void *userData);
  
      angle::Result getInfo(ProgramInfo name,
                            size_t valueSize,
                            void *value,
                            size_t *valueSizeRet) const;
  
      angle::Result getBuildInfo(cl_device_id device,
                                 ProgramBuildInfo name,
                                 size_t valueSize,
                                 void *value,
                                 size_t *valueSizeRet) const;
  
      cl_kernel createKernel(const char *kernel_name);
  
      angle::Result createKernels(cl_uint numKernels, cl_kernel *kernels, cl_uint *numKernelsRet);
  
    public:
      ~Program() override;
  
      Context &getContext();
      const Context &getContext() const;
      const DevicePtrs &getDevices() const;
      const std::string &getSource() const;
      bool hasDevice(const _cl_device_id *device) const;
  
      bool isBuilding() const;
      bool hasAttachedKernels() const;
  
      template <typename T = rx::CLProgramImpl>
      T &getImpl() const;
  
      void callback();
  
    private:
      Program(Context &context, std::string &&source);
      Program(Context &context, const void *il, size_t length);
  
      Program(Context &context,
              DevicePtrs &&devices,
              const size_t *lengths,
              const unsigned char **binaries,
              cl_int *binaryStatus);
  
      Program(Context &context, DevicePtrs &&devices, const char *kernelNames);
  
      Program(Context &context,
              const DevicePtrs &devices,
              const char *options,
              const cl::ProgramPtrs &inputPrograms,
              ProgramCB pfnNotify,
              void *userData);
  
      using CallbackData = std::pair<ProgramCB, void *>;
  
      const ContextPtr mContext;
      const DevicePtrs mDevices;
      const std::string mIL;
  
      // mCallback might be accessed from implementation initialization
      // and needs to be initialized first.
      angle::SynchronizedValue<CallbackData> mCallback;
      std::atomic<cl_uint> mNumAttachedKernels;
  
      rx::CLProgramImpl::Ptr mImpl;
      const std::string mSource;
  
      friend class Kernel;
      friend class Object;
  };
  
  inline Context &Program::getContext()
  {
      return *mContext;
  }
  
  inline const Context &Program::getContext() const
  {
      return *mContext;
  }
  
  inline const DevicePtrs &Program::getDevices() const
  {
      return mDevices;
  }
  
  inline const std::string &Program::getSource() const
  {
      return mSource;
  }
  
  inline bool Program::hasDevice(const _cl_device_id *device) const
  {
      return std::find(mDevices.cbegin(), mDevices.cend(), device) != mDevices.cend();
  }
  
  inline bool Program::isBuilding() const
  {
      for (const DevicePtr &device : getDevices())
      {
          cl_build_status buildStatus;
          ANGLE_CL_IMPL_TRY(getBuildInfo(device->getNative(), ProgramBuildInfo::Status,
                                         sizeof(cl_build_status), &buildStatus, nullptr));
          if ((mCallback->first != nullptr) || (buildStatus == CL_BUILD_IN_PROGRESS))
          {
              return true;
          }
      }
      return false;
  }
  
  inline bool Program::hasAttachedKernels() const
  {
      return mNumAttachedKernels != 0u;
  }
  
  template <typename T>
  inline T &Program::getImpl() const
  {
      return static_cast<T &>(*mImpl);
  }
  
  }  // namespace cl
  
  #endif  // LIBANGLE_CLPROGRAM_H_
  

Download