kc3-lang/angle/src/common/frame_capture_utils.cpp

• Show log

  Commit

• Hash : c0d806b4
  Author :
  Date : 2025-02-10T23:01:33
  

  CL: OpenCL support for ANGLE Capture/Replay
  
  Implementation of OpenCL Capture/Replay tool in ANGLE.
  Brief notes about the change:
  - Most meaningful changes for the capture process are
    made in src/libANGLE/capture/
  - Most meaningful changes for replay are made in
    util/capture/ and src/tests/perf_tests/
  - Many autogenerated files are changed/added to allow
    the capture of OpenCL objects & calls
  - The following applications were captured/replayed:
    benchmark_model, GeekBench Compute, GeekBench ML,
    AI-Benchmark, various OCL CTS tests
  - End2end test added to capture_tests.
    CapturedTestCL.MultiFrameCL/ES3_Vulkan
  
  Bug: angleproject:383841335
  Change-Id: I55fdaa6cd6c7ba740aaa2351e4d29050059d6d1d
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6102105
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  Reviewed-by: Roman Lavrov <romanl@google.com>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/common/frame_capture_utils.cpp

• //
  // Copyright 2022 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.
  //
  // frame_capture_utils.cpp:
  //   ANGLE Frame capture common classes.
  //
  
  #include "common/frame_capture_utils.h"
  
  namespace angle
  {
  namespace
  {
  // Keep the simplest nullptr string for easy C parsing.
  constexpr char kNullPointerString[] = "0";
  }  // anonymous namespace
  
  uint32_t ParamCapture::nextID = 0;
  
  ParamCapture::ParamCapture()
      : type(ParamType::TGLenum), enumGroup(gl::GLESEnum::AllEnums), uniqueID(nextID++)
  {}
  
  ParamCapture::ParamCapture(const char *nameIn, ParamType typeIn)
      : name(nameIn),
        type(typeIn),
        enumGroup(gl::GLESEnum::AllEnums),
        bigGLEnum(gl::BigGLEnum::AllEnums),
        uniqueID(nextID++)
  {}
  
  ParamCapture::~ParamCapture() = default;
  
  ParamCapture::ParamCapture(ParamCapture &&other)
      : type(ParamType::TGLenum),
        enumGroup(gl::GLESEnum::AllEnums),
        bigGLEnum(gl::BigGLEnum::AllEnums)
  {
      *this = std::move(other);
  }
  
  ParamCapture &ParamCapture::operator=(ParamCapture &&other)
  {
      std::swap(name, other.name);
      std::swap(type, other.type);
      std::swap(value, other.value);
      std::swap(enumGroup, other.enumGroup);
      std::swap(bigGLEnum, other.bigGLEnum);
      std::swap(data, other.data);
      std::swap(arrayClientPointerIndex, other.arrayClientPointerIndex);
      std::swap(readBufferSizeBytes, other.readBufferSizeBytes);
      std::swap(dataNElements, other.dataNElements);
      std::swap(uniqueID, other.uniqueID);
      return *this;
  }
  
  ParamBuffer::ParamBuffer() {}
  
  ParamBuffer::~ParamBuffer() = default;
  
  ParamBuffer::ParamBuffer(ParamBuffer &&other)
  {
      *this = std::move(other);
  }
  
  ParamBuffer &ParamBuffer::operator=(ParamBuffer &&other)
  {
      std::swap(mParamCaptures, other.mParamCaptures);
      std::swap(mClientArrayDataParam, other.mClientArrayDataParam);
      std::swap(mReadBufferSize, other.mReadBufferSize);
      std::swap(mReturnValueCapture, other.mReturnValueCapture);
      return *this;
  }
  
  ParamCapture &ParamBuffer::getParam(const char *paramName, ParamType paramType, int index)
  {
      ParamCapture &capture = mParamCaptures[index];
      ASSERT(capture.name == paramName);
      ASSERT(capture.type == paramType);
      return capture;
  }
  
  const ParamCapture &ParamBuffer::getParam(const char *paramName,
                                            ParamType paramType,
                                            int index) const
  {
      return const_cast<ParamBuffer *>(this)->getParam(paramName, paramType, index);
  }
  
  ParamCapture &ParamBuffer::getParamFlexName(const char *paramName1,
                                              const char *paramName2,
                                              ParamType paramType,
                                              int index)
  {
      ParamCapture &capture = mParamCaptures[index];
      ASSERT(capture.name == paramName1 || capture.name == paramName2);
      ASSERT(capture.type == paramType);
      return capture;
  }
  
  const ParamCapture &ParamBuffer::getParamFlexName(const char *paramName1,
                                                    const char *paramName2,
                                                    ParamType paramType,
                                                    int index) const
  {
      return const_cast<ParamBuffer *>(this)->getParamFlexName(paramName1, paramName2, paramType,
                                                               index);
  }
  
  void ParamBuffer::addParam(ParamCapture &&param)
  {
      if (param.arrayClientPointerIndex != -1)
      {
          ASSERT(mClientArrayDataParam == -1);
          mClientArrayDataParam = static_cast<int>(mParamCaptures.size());
      }
  
      mReadBufferSize = std::max(param.readBufferSizeBytes, mReadBufferSize);
      mParamCaptures.emplace_back(std::move(param));
  }
  
  void ParamBuffer::addReturnValue(ParamCapture &&returnValue)
  {
      mReturnValueCapture = std::move(returnValue);
  }
  
  const char *ParamBuffer::getNextParamName()
  {
      static const char *kParamNames[] = {"p0",  "p1",  "p2",  "p3",  "p4",  "p5",  "p6",  "p7",
                                          "p8",  "p9",  "p10", "p11", "p12", "p13", "p14", "p15",
                                          "p16", "p17", "p18", "p19", "p20", "p21", "p22"};
      ASSERT(mParamCaptures.size() < ArraySize(kParamNames));
      return kParamNames[mParamCaptures.size()];
  }
  
  ParamCapture &ParamBuffer::getClientArrayPointerParameter()
  {
      ASSERT(hasClientArrayData());
      return mParamCaptures[mClientArrayDataParam];
  }
  
  CallCapture::CallCapture(EntryPoint entryPointIn, ParamBuffer &&paramsIn)
      : entryPoint(entryPointIn), params(std::move(paramsIn))
  {}
  
  CallCapture::CallCapture(const std::string &customFunctionNameIn, ParamBuffer &&paramsIn)
      : entryPoint(EntryPoint::Invalid),
        customFunctionName(customFunctionNameIn),
        params(std::move(paramsIn))
  {}
  
  CallCapture::~CallCapture() = default;
  
  CallCapture::CallCapture(CallCapture &&other)
  {
      *this = std::move(other);
  }
  
  CallCapture &CallCapture::operator=(CallCapture &&other)
  {
      std::swap(entryPoint, other.entryPoint);
      std::swap(customFunctionName, other.customFunctionName);
      std::swap(params, other.params);
      std::swap(isActive, other.isActive);
      std::swap(contextID, other.contextID);
      std::swap(isSyncPoint, other.isSyncPoint);
      return *this;
  }
  
  const char *CallCapture::name() const
  {
      if (customFunctionName.empty())
      {
          ASSERT(entryPoint != EntryPoint::Invalid);
          return angle::GetEntryPointName(entryPoint);
      }
      else
      {
          return customFunctionName.c_str();
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLboolean>(std::ostream &os,
                                                    const CallCapture &call,
                                                    GLboolean value)
  {
      switch (value)
      {
          case GL_TRUE:
              os << "GL_TRUE";
              break;
          case GL_FALSE:
              os << "GL_FALSE";
              break;
          default:
              os << "0x" << std::hex << std::uppercase << GLint(value);
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLbooleanPointer>(std::ostream &os,
                                                           const CallCapture &call,
                                                           GLboolean *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(GLboolean *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TvoidConstPointer>(std::ostream &os,
                                                           const CallCapture &call,
                                                           const void *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const void *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TvoidPointer>(std::ostream &os,
                                                      const CallCapture &call,
                                                      void *value)
  {
      if (value == 0 || value == nullptr)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(void *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLfloatConstPointer>(std::ostream &os,
                                                              const CallCapture &call,
                                                              const GLfloat *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const GLfloat *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLintConstPointer>(std::ostream &os,
                                                            const CallCapture &call,
                                                            const GLint *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const GLint *)" << static_cast<int>(reinterpret_cast<intptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLsizeiPointer>(std::ostream &os,
                                                         const CallCapture &call,
                                                         GLsizei *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(GLsizei *)" << static_cast<int>(reinterpret_cast<intptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLuintPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        GLuint *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(GLuint *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLuintConstPointer>(std::ostream &os,
                                                             const CallCapture &call,
                                                             const GLuint *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const GLuint *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLDEBUGPROCKHR>(std::ostream &os,
                                                         const CallCapture &call,
                                                         GLDEBUGPROCKHR value)
  {}
  
  template <>
  void WriteParamValueReplay<ParamType::TGLDEBUGPROC>(std::ostream &os,
                                                      const CallCapture &call,
                                                      GLDEBUGPROC value)
  {}
  
  template <>
  void WriteParamValueReplay<ParamType::TBufferID>(std::ostream &os,
                                                   const CallCapture &call,
                                                   gl::BufferID value)
  {
      os << "gBufferMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TFenceNVID>(std::ostream &os,
                                                    const CallCapture &call,
                                                    gl::FenceNVID value)
  {
      os << "gFenceNVMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TFramebufferID>(std::ostream &os,
                                                        const CallCapture &call,
                                                        gl::FramebufferID value)
  {
      os << "gFramebufferMapPerContext[" << call.contextID.value << "][" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TMemoryObjectID>(std::ostream &os,
                                                         const CallCapture &call,
                                                         gl::MemoryObjectID value)
  {
      os << "gMemoryObjectMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TProgramPipelineID>(std::ostream &os,
                                                            const CallCapture &call,
                                                            gl::ProgramPipelineID value)
  {
      os << "gProgramPipelineMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TQueryID>(std::ostream &os,
                                                  const CallCapture &call,
                                                  gl::QueryID value)
  {
      os << "gQueryMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TRenderbufferID>(std::ostream &os,
                                                         const CallCapture &call,
                                                         gl::RenderbufferID value)
  {
      os << "gRenderbufferMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TSamplerID>(std::ostream &os,
                                                    const CallCapture &call,
                                                    gl::SamplerID value)
  {
      os << "gSamplerMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TSemaphoreID>(std::ostream &os,
                                                      const CallCapture &call,
                                                      gl::SemaphoreID value)
  {
      os << "gSemaphoreMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TShaderProgramID>(std::ostream &os,
                                                          const CallCapture &call,
                                                          gl::ShaderProgramID value)
  {
      os << "gShaderProgramMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TSyncID>(std::ostream &os,
                                                 const CallCapture &call,
                                                 gl::SyncID value)
  {
      os << "gSyncMap2[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TTextureID>(std::ostream &os,
                                                    const CallCapture &call,
                                                    gl::TextureID value)
  {
      os << "gTextureMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TTransformFeedbackID>(std::ostream &os,
                                                              const CallCapture &call,
                                                              gl::TransformFeedbackID value)
  {
      os << "gTransformFeedbackMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TVertexArrayID>(std::ostream &os,
                                                        const CallCapture &call,
                                                        gl::VertexArrayID value)
  {
      os << "gVertexArrayMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TUniformLocation>(std::ostream &os,
                                                          const CallCapture &call,
                                                          gl::UniformLocation value)
  {
      if (value.value == -1)
      {
          os << "-1";
          return;
      }
  
      os << "gUniformLocations[";
  
      // Find the program from the call parameters.
      std::vector<gl::ShaderProgramID> shaderProgramIDs;
      if (FindResourceIDsInCall<gl::ShaderProgramID>(call, shaderProgramIDs))
      {
          ASSERT(shaderProgramIDs.size() == 1);
          os << shaderProgramIDs[0].value;
      }
      else
      {
          os << "gCurrentProgram";
      }
  
      os << "][" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TUniformBlockIndex>(std::ostream &os,
                                                            const CallCapture &call,
                                                            gl::UniformBlockIndex value)
  {
      // We do not support directly using uniform block indexes due to their multiple indirections.
      // Use CaptureCustomUniformBlockBinding if you end up hitting this assertion.
      UNREACHABLE();
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLubyte>(std::ostream &os,
                                                  const CallCapture &call,
                                                  GLubyte value)
  {
      const int v = value;
      os << v;
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLDEBUGPROCKHR>(std::ostream &os,
                                                          const CallCapture &call,
                                                          EGLDEBUGPROCKHR value)
  {
      // It's not necessary to implement correct capture for these types.
      os << "0";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLGetBlobFuncANDROID>(std::ostream &os,
                                                                const CallCapture &call,
                                                                EGLGetBlobFuncANDROID value)
  {
      // It's not necessary to implement correct capture for these types.
      os << "0";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLSetBlobFuncANDROID>(std::ostream &os,
                                                                const CallCapture &call,
                                                                EGLSetBlobFuncANDROID value)
  {
      // It's not necessary to implement correct capture for these types.
      os << "0";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tegl_ConfigPointer>(std::ostream &os,
                                                            const CallCapture &call,
                                                            egl::Config *value)
  {
      os << "EGL_NO_CONFIG_KHR";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TSurfaceID>(std::ostream &os,
                                                    const CallCapture &call,
                                                    egl::SurfaceID value)
  {
      os << "gSurfaceMap2[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TContextID>(std::ostream &os,
                                                    const CallCapture &call,
                                                    gl::ContextID value)
  {
      os << "gContextMap2[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tegl_DisplayPointer>(std::ostream &os,
                                                             const CallCapture &call,
                                                             egl::Display *value)
  {
      os << "gEGLDisplay";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TImageID>(std::ostream &os,
                                                  const CallCapture &call,
                                                  egl::ImageID value)
  {
      os << "gEGLImageMap2[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLClientBuffer>(std::ostream &os,
                                                          const CallCapture &call,
                                                          EGLClientBuffer value)
  {
      os << value;
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tegl_SyncID>(std::ostream &os,
                                                     const CallCapture &call,
                                                     egl::SyncID value)
  {
      os << "gEGLSyncMap[" << value.value << "]";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLAttribPointer>(std::ostream &os,
                                                           const CallCapture &call,
                                                           EGLAttrib *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(EGLAttrib *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLAttribConstPointer>(std::ostream &os,
                                                                const CallCapture &call,
                                                                const EGLAttrib *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const EGLAttrib *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLintConstPointer>(std::ostream &os,
                                                             const CallCapture &call,
                                                             const EGLint *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const EGLint *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLintPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        EGLint *value)
  {
      if (value == 0)
      {
          os << kNullPointerString;
      }
      else
      {
          os << "(const EGLint *)" << static_cast<int>(reinterpret_cast<uintptr_t>(value));
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLTime>(std::ostream &os,
                                                  const CallCapture &call,
                                                  EGLTime value)
  {
      os << value << "ul";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TEGLTimeKHR>(std::ostream &os,
                                                     const CallCapture &call,
                                                     EGLTimeKHR value)
  {
      os << value << "ul";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLGETBLOBPROCANGLE>(std::ostream &os,
                                                             const CallCapture &call,
                                                             GLGETBLOBPROCANGLE value)
  {
      // It's not necessary to implement correct capture for these types.
      os << "0";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TGLSETBLOBPROCANGLE>(std::ostream &os,
                                                             const CallCapture &call,
                                                             GLSETBLOBPROCANGLE value)
  {
      // It's not necessary to implement correct capture for these types.
      os << "0";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TcharConstPointer>(std::ostream &os,
                                                           const CallCapture &call,
                                                           const char *value)
  {
      if (value)
      {
          os << "\"" << value << "\"";
      }
      else
      {
          os << NULL;
      }
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tsize_tPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        size_t *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tsize_tConstPointer>(std::ostream &os,
                                                             const CallCapture &call,
                                                             size_t const *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TcharConstPointerPointer>(std::ostream &os,
                                                                  const CallCapture &call,
                                                                  const char **value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::TcharUnsignedConstPointerPointer>(std::ostream &os,
                                                                          const CallCapture &call,
                                                                          const unsigned char **value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  #ifdef ANGLE_ENABLE_CL
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_platform_idPointer>(std::ostream &os,
                                                                const CallCapture &call,
                                                                cl_platform_id *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_uintPointer>(std::ostream &os,
                                                         const CallCapture &call,
                                                         cl_uint *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_device_idPointer>(std::ostream &os,
                                                              const CallCapture &call,
                                                              cl_device_id *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_context_propertiesConstPointer>(
      std::ostream &os,
      const CallCapture &call,
      cl_context_properties const *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_eventPointer>(std::ostream &os,
                                                          const CallCapture &call,
                                                          cl_event *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_eventConstPointer>(std::ostream &os,
                                                               const CallCapture &call,
                                                               cl_event const *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_device_idConstPointer>(std::ostream &os,
                                                                   const CallCapture &call,
                                                                   cl_device_id const *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_image_formatPointer>(std::ostream &os,
                                                                 const CallCapture &call,
                                                                 cl_image_format *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_intPointer>(std::ostream &os,
                                                        const CallCapture &call,
                                                        cl_int *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_queue_propertiesConstPointer>(
      std::ostream &os,
      const CallCapture &call,
      const cl_queue_properties *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_command_queue_propertiesPointer>(
      std::ostream &os,
      const CallCapture &call,
      const cl_command_queue_properties *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_device_partition_propertyConstPointer>(
      std::ostream &os,
      const CallCapture &call,
      const cl_device_partition_property *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_programConstPointer>(std::ostream &os,
                                                                 const CallCapture &call,
                                                                 const cl_program *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_pipe_propertiesConstPointer>(
      std::ostream &os,
      const CallCapture &call,
      const cl_pipe_properties *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_ulongPointer>(std::ostream &os,
                                                          const CallCapture &call,
                                                          cl_ulong *value)
  {
      ASSERT(!value);
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_callback_func_type>(std::ostream &os,
                                                                const CallCapture &call,
                                                                cl_callback_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_context_destructor_func_type>(
      std::ostream &os,
      const CallCapture &call,
      cl_context_destructor_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_context_func_type>(std::ostream &os,
                                                               const CallCapture &call,
                                                               cl_context_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_mem_destructor_func_type>(
      std::ostream &os,
      const CallCapture &call,
      cl_mem_destructor_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_program_func_type>(std::ostream &os,
                                                               const CallCapture &call,
                                                               cl_program_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_svm_free_callback_func_type>(
      std::ostream &os,
      const CallCapture &call,
      cl_svm_free_callback_func_type value)
  {
      os << "NULL";
  }
  
  template <>
  void WriteParamValueReplay<ParamType::Tcl_void_func_type>(std::ostream &os,
                                                            const CallCapture &call,
                                                            cl_void_func_type value)
  {
      os << "NULL";
  }
  
  #endif
  
  template <typename ParamValueType>
  bool FindResourceIDsInCall(const CallCapture &call, std::vector<ParamValueType> &idsOut)
  {
      const ParamType paramType = ParamValueTrait<ParamValueType>::typeID;
      for (const ParamCapture &param : call.params.getParamCaptures())
      {
          if (param.type == paramType)
          {
              const ParamValueType id = AccessParamValue<ParamValueType>(paramType, param.value);
              idsOut.push_back(id);
          }
      }
  
      return !idsOut.empty();
  }
  
  // Explicit instantiation
  template bool FindResourceIDsInCall<gl::TextureID>(const CallCapture &call,
                                                     std::vector<gl::TextureID> &idsOut);
  template bool FindResourceIDsInCall<gl::ShaderProgramID>(const CallCapture &call,
                                                           std::vector<gl::ShaderProgramID> &idsOut);
  }  // namespace angle
  

Download