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

• Show log

  Commit

• Hash : 1252d9aa
  Author :
  Date : 2025-05-30T14:16:23
  

  CL: Create frontend event and pass to enqueue APIs
  
  Since frontend cl_event object does not depend on enqueue
  API routines, we can construct it early and then pass to
  mImpl enqueue API calls (for any backend that needs it).
  
  Also update backend routines to init their backend
  event implementations using frontend event object.
  
  Bug: angleproject:444482493
  Change-Id: I459dbf34f10cb6b30245479c9966f876d6e905d7
  Signed-off-by: Austin Annestrand <a.annestrand@samsung.com>
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6941604
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/CLEvent.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.
  //
  // CLEvent.h: Defines the cl::Event class, which can be used to track the execution status of an
  // OpenCL command.
  
  #ifndef LIBANGLE_CLEVENT_H_
  #define LIBANGLE_CLEVENT_H_
  
  #include "libANGLE/CLObject.h"
  #include "libANGLE/renderer/CLEventImpl.h"
  
  #include "common/SynchronizedValue.h"
  
  #include <array>
  
  namespace cl
  {
  
  class Event final : public _cl_event, public Object
  {
    public:
      // Front end entry functions, only called from OpenCL entry points
  
      angle::Result setUserEventStatus(cl_int executionStatus);
  
      angle::Result getInfo(EventInfo name,
                            size_t valueSize,
                            void *value,
                            size_t *valueSizeRet) const;
  
      angle::Result setCallback(cl_int commandExecCallbackType, EventCB pfnNotify, void *userData);
  
      angle::Result getProfilingInfo(ProfilingInfo name,
                                     size_t valueSize,
                                     void *value,
                                     size_t *valueSizeRet);
  
    public:
      ~Event() override;
  
      Context &getContext();
      const Context &getContext() const;
      const CommandQueuePtr &getCommandQueue() const;
      cl_command_type getCommandType() const;
      bool wasStatusChanged() const;
  
      template <typename T = rx::CLEventImpl>
      T &getImpl() const;
  
      void callback(cl_int commandStatus);
  
      angle::Result initBackend(const rx::CLEventImpl::CreateFunc &createFunc);
      bool isBackendInitialized() const { return mImpl != nullptr; }
      bool isUserEvent() const { return mCommandType == CL_COMMAND_USER; }
  
      static EventPtrs Cast(cl_uint numEvents, const cl_event *eventList);
  
    private:
      using CallbackData = std::pair<EventCB, void *>;
      using Callbacks    = std::vector<CallbackData>;
  
      Event(Context &context);
  
      Event(CommandQueue &queue, cl_command_type commandType);
  
      const ContextPtr mContext;
      const CommandQueuePtr mCommandQueue;
      const cl_command_type mCommandType;
      rx::CLEventImpl::Ptr mImpl;
  
      bool mStatusWasChanged = false;
  
      // Create separate storage for each possible callback type.
      static_assert(CL_COMPLETE == 0 && CL_RUNNING == 1 && CL_SUBMITTED == 2,
                    "OpenCL command execution status values are not as assumed");
      angle::SynchronizedValue<std::array<Callbacks, 3u>> mCallbacks;
  
      friend class Object;
  };
  
  inline Context &Event::getContext()
  {
      return *mContext;
  }
  
  inline const Context &Event::getContext() const
  {
      return *mContext;
  }
  
  inline const CommandQueuePtr &Event::getCommandQueue() const
  {
      return mCommandQueue;
  }
  
  inline cl_command_type Event::getCommandType() const
  {
      return mCommandType;
  }
  
  inline bool Event::wasStatusChanged() const
  {
      return mStatusWasChanged;
  }
  
  template <typename T>
  inline T &Event::getImpl() const
  {
      return static_cast<T &>(*mImpl);
  }
  
  }  // namespace cl
  
  #endif  // LIBANGLE_CLEVENT_H_
  

Download