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

• Show log

  Commit

• Hash : 295d2ccd
  Author :
  Date : 2020-08-24T14:46:31
  

  Vulkan: Generate perf warnings on suboptimal paths
  
  Using KHR_debug features, this change creates a
  performance-warning-generation macro and employs it in a handful of
  locations to provide useful feedback to application developers.
  
  The warnings added in this change are not exhaustive.
  
  Bug: angleproject:3461
  Bug: angleproject:4900
  Change-Id: Id62435d170d90c5be9c1c5cab2d6779ccb58345e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2372628
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

Download

• src/libANGLE/Debug.h

• //
  // Copyright 2015 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.
  //
  
  // Debug.h: Defines debug state used for GL_KHR_debug
  
  #ifndef LIBANGLE_DEBUG_H_
  #define LIBANGLE_DEBUG_H_
  
  #include "angle_gl.h"
  #include "common/PackedEnums.h"
  #include "common/angleutils.h"
  #include "libANGLE/AttributeMap.h"
  
  #include <deque>
  #include <string>
  #include <vector>
  
  namespace gl
  {
  class Context;
  
  class LabeledObject
  {
    public:
      virtual ~LabeledObject() {}
      virtual void setLabel(const Context *context, const std::string &label) = 0;
      virtual const std::string &getLabel() const                             = 0;
  };
  
  class Debug : angle::NonCopyable
  {
    public:
      Debug(bool initialDebugState);
      ~Debug();
  
      void setMaxLoggedMessages(GLuint maxLoggedMessages);
  
      void setOutputEnabled(bool enabled);
      bool isOutputEnabled() const;
  
      void setOutputSynchronous(bool synchronous);
      bool isOutputSynchronous() const;
  
      void setCallback(GLDEBUGPROCKHR callback, const void *userParam);
      GLDEBUGPROCKHR getCallback() const;
      const void *getUserParam() const;
  
      void insertMessage(GLenum source,
                         GLenum type,
                         GLuint id,
                         GLenum severity,
                         const std::string &message,
                         gl::LogSeverity logSeverity) const;
      void insertMessage(GLenum source,
                         GLenum type,
                         GLuint id,
                         GLenum severity,
                         std::string &&message,
                         gl::LogSeverity logSeverity) const;
  
      void setMessageControl(GLenum source,
                             GLenum type,
                             GLenum severity,
                             std::vector<GLuint> &&ids,
                             bool enabled);
      size_t getMessages(GLuint count,
                         GLsizei bufSize,
                         GLenum *sources,
                         GLenum *types,
                         GLuint *ids,
                         GLenum *severities,
                         GLsizei *lengths,
                         GLchar *messageLog);
      size_t getNextMessageLength() const;
      size_t getMessageCount() const;
  
      void pushGroup(GLenum source, GLuint id, std::string &&message);
      void popGroup();
      size_t getGroupStackDepth() const;
  
      // Helper for ANGLE_PERF_WARNING
      void insertPerfWarning(GLenum severity, const char *message, uint32_t *repeatCount) const;
  
    private:
      bool isMessageEnabled(GLenum source, GLenum type, GLuint id, GLenum severity) const;
  
      void pushDefaultGroup();
  
      struct Message
      {
          GLenum source;
          GLenum type;
          GLuint id;
          GLenum severity;
          std::string message;
      };
  
      struct Control
      {
          Control();
          ~Control();
          Control(const Control &other);
  
          GLenum source;
          GLenum type;
          GLenum severity;
          std::vector<GLuint> ids;
          bool enabled;
      };
  
      struct Group
      {
          Group();
          ~Group();
          Group(const Group &other);
  
          GLenum source;
          GLuint id;
          std::string message;
  
          std::vector<Control> controls;
      };
  
      bool mOutputEnabled;
      GLDEBUGPROCKHR mCallbackFunction;
      const void *mCallbackUserParam;
      mutable std::deque<Message> mMessages;
      GLuint mMaxLoggedMessages;
      bool mOutputSynchronous;
      std::vector<Group> mGroups;
  };
  }  // namespace gl
  
  namespace egl
  {
  class LabeledObject
  {
    public:
      virtual ~LabeledObject() {}
      virtual void setLabel(EGLLabelKHR label) = 0;
      virtual EGLLabelKHR getLabel() const     = 0;
  };
  
  class Debug : angle::NonCopyable
  {
    public:
      Debug();
  
      void setCallback(EGLDEBUGPROCKHR callback, const AttributeMap &attribs);
      EGLDEBUGPROCKHR getCallback() const;
      bool isMessageTypeEnabled(MessageType type) const;
  
      void insertMessage(EGLenum error,
                         const char *command,
                         MessageType messageType,
                         EGLLabelKHR threadLabel,
                         EGLLabelKHR objectLabel,
                         const std::string &message) const;
  
    private:
      EGLDEBUGPROCKHR mCallback;
      angle::PackedEnumBitSet<MessageType> mEnabledMessageTypes;
  };
  }  // namespace egl
  
  // Generate a perf warning.  Only outputs the same message a few times to avoid spamming the logs.
  #define ANGLE_PERF_WARNING(debug, severity, message)                 \
      do                                                               \
      {                                                                \
          static uint32_t sRepeatCount = 0;                            \
          (debug).insertPerfWarning(severity, message, &sRepeatCount); \
      } while (0)
  
  #endif  // LIBANGLE_DEBUG_H_
  

Download