kc3-lang/angle/util/capture/frame_capture_test_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

• util/capture/frame_capture_test_utils.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.
  //
  // frame_capture_test_utils:
  //   Helper functions for capture and replay of traces.
  //
  
  #include "frame_capture_test_utils.h"
  
  #include "common/frame_capture_utils.h"
  #include "common/string_utils.h"
  
  #include <rapidjson/document.h>
  #include <rapidjson/istreamwrapper.h>
  #include <fstream>
  
  namespace angle
  {
  
  namespace
  {
  bool LoadJSONFromFile(const std::string &fileName, rapidjson::Document *doc)
  {
      std::ifstream ifs(fileName);
      if (!ifs.is_open())
      {
          return false;
      }
  
      rapidjson::IStreamWrapper inWrapper(ifs);
      doc->ParseStream(inWrapper);
      return !doc->HasParseError();
  }
  
  // Branched from:
  // https://crsrc.org/c/third_party/zlib/google/compression_utils_portable.cc;drc=9fc44ce454cc889b603900ccd14b7024ea2c284c;l=167
  // Unmodified other than inlining ZlibStreamWrapperType and z_stream arg to access .msg
  int GzipUncompressHelperPatched(Bytef *dest,
                                  uLongf *dest_length,
                                  const Bytef *source,
                                  uLong source_length,
                                  z_stream &stream)
  {
      stream.next_in  = static_cast<z_const Bytef *>(const_cast<Bytef *>(source));
      stream.avail_in = static_cast<uInt>(source_length);
      if (static_cast<uLong>(stream.avail_in) != source_length)
          return Z_BUF_ERROR;
  
      stream.next_out  = dest;
      stream.avail_out = static_cast<uInt>(*dest_length);
      if (static_cast<uLong>(stream.avail_out) != *dest_length)
          return Z_BUF_ERROR;
  
      stream.zalloc = static_cast<alloc_func>(0);
      stream.zfree  = static_cast<free_func>(0);
  
      int err = inflateInit2(&stream, MAX_WBITS + 16);
      if (err != Z_OK)
          return err;
  
      err = inflate(&stream, Z_FINISH);
      if (err != Z_STREAM_END)
      {
          inflateEnd(&stream);
          if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0))
              return Z_DATA_ERROR;
          return err;
      }
      *dest_length = stream.total_out;
  
      err = inflateEnd(&stream);
      return err;
  }
  
  bool UncompressData(const std::vector<uint8_t> &compressedData,
                      std::vector<uint8_t> *uncompressedData)
  {
      uint32_t uncompressedSize =
          zlib_internal::GetGzipUncompressedSize(compressedData.data(), compressedData.size());
  
      uncompressedData->resize(uncompressedSize + 1);  // +1 to make sure .data() is valid
      uLong destLen = uncompressedSize;
      z_stream stream;
      int zResult =
          GzipUncompressHelperPatched(uncompressedData->data(), &destLen, compressedData.data(),
                                      static_cast<uLong>(compressedData.size()), stream);
  
      if (zResult != Z_OK)
      {
          std::cerr << "Failure to decompressed binary data: " << zResult
                    << " msg=" << (stream.msg ? stream.msg : "nil") << "\n";
          fprintf(stderr,
                  "next_in %p (input %p) avail_in %d total_in %lu next_out %p (output %p) avail_out "
                  "%d total_out %ld adler %lX crc %lX crc_simd %lX\n",
                  stream.next_in, compressedData.data(), stream.avail_in, stream.total_in,
                  stream.next_out, uncompressedData->data(), stream.avail_out, stream.total_out,
                  stream.adler, crc32(0, uncompressedData->data(), uncompressedSize),
                  crc32(0, uncompressedData->data(), 16 * (uncompressedSize / 16)));
          return false;
      }
  
      return true;
  }
  
  void SaveDebugFile(const std::string &outputDir,
                     const char *baseFileName,
                     const char *suffix,
                     const std::vector<uint8_t> data)
  {
      if (outputDir.empty())
      {
          return;
      }
  
      std::ostringstream path;
      path << outputDir << "/" << baseFileName << suffix;
      FILE *fp = fopen(path.str().c_str(), "wb");
      fwrite(data.data(), 1, data.size(), fp);
      fclose(fp);
  }
  }  // namespace
  
  bool LoadTraceNamesFromJSON(const std::string jsonFilePath, std::vector<std::string> *namesOut)
  {
      rapidjson::Document doc;
      if (!LoadJSONFromFile(jsonFilePath, &doc))
      {
          return false;
      }
  
      if (!doc.IsArray())
      {
          return false;
      }
  
      // Read trace json into a list of trace names.
      std::vector<std::string> traces;
  
      rapidjson::Document::Array traceArray = doc.GetArray();
      for (rapidjson::SizeType arrayIndex = 0; arrayIndex < traceArray.Size(); ++arrayIndex)
      {
          const rapidjson::Document::ValueType &arrayElement = traceArray[arrayIndex];
  
          if (!arrayElement.IsString())
          {
              return false;
          }
  
          traces.push_back(arrayElement.GetString());
      }
  
      *namesOut = std::move(traces);
      return true;
  }
  
  bool LoadTraceInfoFromJSON(const std::string &traceName,
                             const std::string &traceJsonPath,
                             TraceInfo *traceInfoOut)
  {
      rapidjson::Document doc;
      if (!LoadJSONFromFile(traceJsonPath, &doc))
      {
          return false;
      }
  
      if (!doc.IsObject() || !doc.HasMember("TraceMetadata"))
      {
          return false;
      }
  
      const rapidjson::Document::Object &meta = doc["TraceMetadata"].GetObj();
  
      strncpy(traceInfoOut->name, traceName.c_str(), kTraceInfoMaxNameLen);
      traceInfoOut->frameEnd               = meta["FrameEnd"].GetInt();
      traceInfoOut->frameStart             = meta["FrameStart"].GetInt();
      traceInfoOut->isBinaryDataCompressed = meta["IsBinaryDataCompressed"].GetBool();
      traceInfoOut->isCL                   = meta.HasMember("IsOpenCL");
  
      if (meta.HasMember("ContextClientMajorVersion"))
      {
          traceInfoOut->contextClientMajorVersion = meta["ContextClientMajorVersion"].GetInt();
          traceInfoOut->contextClientMinorVersion = meta["ContextClientMinorVersion"].GetInt();
          traceInfoOut->drawSurfaceHeight         = meta["DrawSurfaceHeight"].GetInt();
          traceInfoOut->drawSurfaceWidth          = meta["DrawSurfaceWidth"].GetInt();
  
          angle::HexStringToUInt(meta["DrawSurfaceColorSpace"].GetString(),
                                 &traceInfoOut->drawSurfaceColorSpace);
          angle::HexStringToUInt(meta["DisplayPlatformType"].GetString(),
                                 &traceInfoOut->displayPlatformType);
          angle::HexStringToUInt(meta["DisplayDeviceType"].GetString(),
                                 &traceInfoOut->displayDeviceType);
  
          traceInfoOut->configRedBits          = meta["ConfigRedBits"].GetInt();
          traceInfoOut->configGreenBits        = meta["ConfigGreenBits"].GetInt();
          traceInfoOut->configBlueBits         = meta["ConfigBlueBits"].GetInt();
          traceInfoOut->configAlphaBits        = meta["ConfigAlphaBits"].GetInt();
          traceInfoOut->configDepthBits        = meta["ConfigDepthBits"].GetInt();
          traceInfoOut->configStencilBits      = meta["ConfigStencilBits"].GetInt();
          traceInfoOut->areClientArraysEnabled = meta["AreClientArraysEnabled"].GetBool();
          traceInfoOut->isBindGeneratesResourcesEnabled =
              meta["IsBindGeneratesResourcesEnabled"].GetBool();
          traceInfoOut->isWebGLCompatibilityEnabled = meta["IsWebGLCompatibilityEnabled"].GetBool();
          traceInfoOut->isRobustResourceInitEnabled = meta["IsRobustResourceInitEnabled"].GetBool();
      }
      else
      {
          traceInfoOut->contextClientMajorVersion = 1;
          traceInfoOut->contextClientMinorVersion = 1;
          traceInfoOut->drawSurfaceHeight         = 1;
          traceInfoOut->drawSurfaceWidth          = 1;
      }
  
      if (doc.HasMember("WindowSurfaceContextID"))
      {
          traceInfoOut->windowSurfaceContextId = doc["WindowSurfaceContextID"].GetInt();
      }
  
      if (doc.HasMember("RequiredExtensions"))
      {
          const rapidjson::Value &requiredExtensions = doc["RequiredExtensions"];
          if (!requiredExtensions.IsArray())
          {
              return false;
          }
          for (rapidjson::SizeType i = 0; i < requiredExtensions.Size(); i++)
          {
              std::string ext = std::string(requiredExtensions[i].GetString());
              traceInfoOut->requiredExtensions.push_back(ext);
          }
      }
  
      if (meta.HasMember("KeyFrames"))
      {
          const rapidjson::Value &keyFrames = meta["KeyFrames"];
          if (!keyFrames.IsArray())
          {
              return false;
          }
          for (rapidjson::SizeType i = 0; i < keyFrames.Size(); i++)
          {
              int frame = keyFrames[i].GetInt();
              traceInfoOut->keyFrames.push_back(frame);
          }
      }
  
      const rapidjson::Document::Array &traceFiles = doc["TraceFiles"].GetArray();
      for (const rapidjson::Value &value : traceFiles)
      {
          traceInfoOut->traceFiles.push_back(value.GetString());
      }
  
      traceInfoOut->initialized = true;
      return true;
  }
  
  TraceLibrary::TraceLibrary(const std::string &traceName,
                             const TraceInfo &traceInfo,
                             const std::string &baseDir)
  {
      std::stringstream libNameStr;
      SearchType searchType = SearchType::ModuleDir;
  
  #if defined(ANGLE_TRACE_EXTERNAL_BINARIES)
      // This means we are using the binary build of traces on Android, which are
      // not bundled in the APK, but located in the app's home directory.
      searchType = SearchType::SystemDir;
      libNameStr << baseDir;
  #endif  // defined(ANGLE_TRACE_EXTERNAL_BINARIES)
  #if !defined(ANGLE_PLATFORM_WINDOWS)
      libNameStr << "lib";
  #endif  // !defined(ANGLE_PLATFORM_WINDOWS)
      libNameStr << traceName;
      std::string libName = libNameStr.str();
      std::string loadError;
  
      mTraceLibrary.reset(OpenSharedLibraryAndGetError(libName.c_str(), searchType, &loadError));
      if (mTraceLibrary->getNative() == nullptr)
      {
          FATAL() << "Failed to load trace library (" << libName << "): " << loadError;
      }
  
      callFunc<SetupEntryPoints>("SetupEntryPoints", static_cast<angle::TraceCallbacks *>(this),
                                 &mTraceFunctions);
      mTraceFunctions->SetTraceInfo(traceInfo);
      mTraceInfo = traceInfo;
  }
  
  uint8_t *TraceLibrary::LoadBinaryData(const char *fileName)
  {
      std::ostringstream pathBuffer;
      pathBuffer << mBinaryDataDir << "/" << fileName;
      FILE *fp = fopen(pathBuffer.str().c_str(), "rb");
      if (fp == 0)
      {
          fprintf(stderr, "Error loading binary data file: %s\n", fileName);
          exit(1);
      }
      fseek(fp, 0, SEEK_END);
      long size = ftell(fp);
      fseek(fp, 0, SEEK_SET);
      if (mTraceInfo.isBinaryDataCompressed)
      {
          if (!strstr(fileName, ".gz"))
          {
              fprintf(stderr, "Filename does not end in .gz");
              exit(1);
          }
  
          std::vector<uint8_t> compressedData(size);
          size_t bytesRead = fread(compressedData.data(), 1, size, fp);
          if (bytesRead != static_cast<size_t>(size))
          {
              std::cerr << "Failed to read binary data: " << bytesRead << " != " << size << "\n";
              exit(1);
          }
  
          if (!UncompressData(compressedData, &mBinaryData))
          {
              // Workaround for sporadic failures https://issuetracker.google.com/296921272
              SaveDebugFile(mDebugOutputDir, fileName, ".gzdbg_input.gz", compressedData);
              SaveDebugFile(mDebugOutputDir, fileName, ".gzdbg_attempt1", mBinaryData);
              std::vector<uint8_t> uncompressedData;
              bool secondResult = UncompressData(compressedData, &uncompressedData);
              SaveDebugFile(mDebugOutputDir, fileName, ".gzdbg_attempt2", uncompressedData);
              if (!secondResult)
              {
                  std::cerr << "Uncompress retry failed\n";
                  exit(1);
              }
              std::cerr << "Uncompress retry succeeded, moving to mBinaryData\n";
              mBinaryData = std::move(uncompressedData);
          }
      }
      else
      {
          if (!strstr(fileName, ".angledata"))
          {
              fprintf(stderr, "Filename does not end in .angledata");
              exit(1);
          }
          mBinaryData.resize(size + 1);
          (void)fread(mBinaryData.data(), 1, size, fp);
      }
      fclose(fp);
  
      return mBinaryData.data();
  }
  
  }  // namespace angle
  

Download