kc3-lang/angle/util/capture/frame_capture_test_utils.cpp

• Show log

  Commit

• Hash : b581a6ce
  Author :
  Date : 2023-11-07T10:45:39
  

  Traces: workaround sporadic uncompress failures
  
  Usually succeeding uncompress retry:
  https://issuetracker.google.com/296921272#comment26
  
  Move uncompressed data to mBinaryData and keep going. Unknown if the
  test would succeed or crash later on, would be interesting to see.
  
  Bug: b/296921272
  Change-Id: If4f158305cef49208f39164ee3865e5fdccd39ee
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/5008081
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Roman Lavrov <romanl@google.com>
  Auto-Submit: Roman Lavrov <romanl@google.com>
  Commit-Queue: Shahbaz Youssefi <syoussefi@chromium.org>
  

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";
          return false;
      }
  
      return true;
  }
  }  // namespace
  
  bool LoadTraceNamesFromJSON(const std::string jsonFilePath, std::vector<std::string> *namesOut)
  {
      rapidjson::Document doc;
      if (!LoadJSONFromFile(jsonFilePath, &doc))
      {
          return false;
      }
  
      if (!doc.IsObject() || !doc.HasMember("traces") || !doc["traces"].IsArray())
      {
          return false;
      }
  
      // Read trace json into a list of trace names.
      std::vector<std::string> traces;
  
      rapidjson::Document::Array traceArray = doc["traces"].GetArray();
      for (rapidjson::SizeType arrayIndex = 0; arrayIndex < traceArray.Size(); ++arrayIndex)
      {
          const rapidjson::Document::ValueType &arrayElement = traceArray[arrayIndex];
  
          if (!arrayElement.IsString())
          {
              return false;
          }
  
          std::vector<std::string> traceAndVersion;
          angle::SplitStringAlongWhitespace(arrayElement.GetString(), &traceAndVersion);
          traces.push_back(traceAndVersion[0]);
      }
  
      *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->contextClientMajorVersion = meta["ContextClientMajorVersion"].GetInt();
      traceInfoOut->contextClientMinorVersion = meta["ContextClientMinorVersion"].GetInt();
      traceInfoOut->frameEnd                  = meta["FrameEnd"].GetInt();
      traceInfoOut->frameStart                = meta["FrameStart"].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->isBinaryDataCompressed = meta["IsBinaryDataCompressed"].GetBool();
      traceInfoOut->areClientArraysEnabled = meta["AreClientArraysEnabled"].GetBool();
      traceInfoOut->isBindGeneratesResourcesEnabled =
          meta["IsBindGeneratesResourcesEnabled"].GetBool();
      traceInfoOut->isWebGLCompatibilityEnabled = meta["IsWebGLCompatibilityEnabled"].GetBool();
      traceInfoOut->isRobustResourceInitEnabled = meta["IsRobustResourceInitEnabled"].GetBool();
      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)
  {
      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 << "/data/user/0/com.android.angle.test/angle_traces/";
  #endif  // defined(ANGLE_TRACE_EXTERNAL_BINARIES)
  #if !defined(ANGLE_PLATFORM_WINDOWS)
      libNameStr << "lib";
  #endif  // !defined(ANGLE_PLATFORM_WINDOWS)
      libNameStr << traceName;
  #if defined(ANGLE_PLATFORM_ANDROID) && defined(COMPONENT_BUILD)
      // Added to shared library names in Android component builds in
      // https://chromium.googlesource.com/chromium/src/+/9bacc8c4868cc802f69e1e858eea6757217a508f/build/toolchain/toolchain.gni#56
      libNameStr << ".cr";
  #endif  // defined(ANGLE_PLATFORM_ANDROID) && defined(COMPONENT_BUILD)
      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
              std::vector<uint8_t> uncompressedData;
              bool secondResult = UncompressData(compressedData, &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