1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #ifndef RS_PROFILER_FILE_H 17 #define RS_PROFILER_FILE_H 18 19 #include <mutex> 20 21 #include "rs_profiler_capturedata.h" 22 #include "rs_profiler_utils.h" 23 24 #ifdef RENDER_PROFILER_APPLICATION 25 #include <memory> 26 27 #include "rs_adapt.h" 28 #endif 29 30 namespace OHOS::Rosen { 31 32 #define RSFILE_VERSION_RENDER_METRICS_ADDED 0x240701 33 #define RSFILE_VERSION_RENDER_ANIMESTARTTIMES_ADDED 0x240723 34 #define RSFILE_VERSION_RENDER_TYPEFACE_FIX 0x240801 35 #define RSFILE_VERSION_LATEST RSFILE_VERSION_RENDER_TYPEFACE_FIX 36 37 struct RSFileLayer final { 38 std::pair<uint32_t, uint32_t> layerHeader; // to put in GLOBAL HEADER 39 40 RSCaptureData property; 41 42 using TrackMarkup = std::vector<std::pair<uint32_t, uint32_t>>; 43 static constexpr size_t MARKUP_SIZE = sizeof(TrackMarkup::value_type); 44 45 TrackMarkup rsData; 46 TrackMarkup oglData; 47 TrackMarkup rsMetrics; 48 TrackMarkup oglMetrics; 49 TrackMarkup gfxMetrics; 50 TrackMarkup renderMetrics; 51 52 uint32_t readindexRsData = 0; 53 uint32_t readindexOglData = 0; 54 uint32_t readindexRsMetrics = 0; 55 uint32_t readindexOglMetrics = 0; 56 uint32_t readindexGfxMetrics = 0; 57 uint32_t readindexRenderMetrics = 0; 58 }; 59 60 class RSFile final { 61 public: 62 RSFile(); 63 64 void Create(const std::string& fname); 65 bool Open(const std::string& fname); 66 67 bool IsOpen() const; 68 69 void SetWriteTime(double time); 70 double GetWriteTime() const; 71 72 const std::string& GetHeaderFirstFrame() const; 73 void AddHeaderFirstFrame(const std::string& dataFirstFrame); 74 75 const std::vector<std::pair<uint64_t, int64_t>>& GetAnimeStartTimes() const; 76 void AddAnimeStartTimes(const std::vector<std::pair<uint64_t, int64_t>>& startTimes); 77 78 void AddHeaderPid(pid_t pid); 79 const std::vector<pid_t>& GetHeaderPids() const; 80 81 uint32_t AddLayer(); 82 void LayerAddHeaderProperty(uint32_t layer, const std::string& name, const std::string& value); 83 84 void WriteRSData(double time, const void* data, size_t size); 85 void WriteOGLData(uint32_t layer, double time, const void* data, size_t size); 86 void WriteRSMetrics(uint32_t layer, double time, const void* data, size_t size); 87 void WriteRenderMetrics(uint32_t layer, double time, const void* data, size_t size); 88 void WriteOGLMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size); 89 void WriteGFXMetrics(uint32_t layer, double time, uint32_t frame, const void* data, size_t size); 90 91 void ReadRSDataRestart(); 92 void ReadOGLDataRestart(uint32_t layer); 93 void ReadRSMetricsRestart(uint32_t layer); 94 void ReadRenderMetricsRestart(uint32_t layer); 95 void ReadOGLMetricsRestart(uint32_t layer); 96 void ReadGFXMetricsRestart(uint32_t layer); 97 98 bool RSDataEOF() const; 99 bool OGLDataEOF(uint32_t layer) const; 100 bool RSMetricsEOF(uint32_t layer) const; 101 bool RenderMetricsEOF(uint32_t layer) const; 102 bool OGLMetricsEOF(uint32_t layer) const; 103 bool GFXMetricsEOF(uint32_t layer) const; 104 105 bool ReadRSData(double untilTime, std::vector<uint8_t>& data, double& readTime); 106 bool ReadOGLData(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 107 bool ReadRSMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 108 bool ReadRenderMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 109 bool ReadOGLMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 110 bool ReadGFXMetrics(double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 111 bool GetDataCopy(std::vector<uint8_t>& data); // copy the content of RSFile so far 112 113 bool HasLayer(uint32_t layer) const; 114 115 void SetPreparedHeader(const std::vector<uint8_t>& headerData); 116 void GetPreparedHeader(std::vector<uint8_t>& headerData); 117 void SetPreparedHeaderMode(bool mode); 118 void Close(); 119 120 uint32_t GetVersion() const; 121 void SetVersion(uint32_t version); 122 123 static const std::string& GetDefaultPath(); 124 125 void CacheVsyncId2Time(uint32_t layer); 126 double ConvertVsyncId2Time(int64_t vsyncId); 127 int64_t ConvertTime2VsyncId(double time) const; 128 129 private: 130 void WriteHeaders(); 131 void WriteHeader(); 132 void LayerWriteHeader(uint32_t layer); 133 134 template<typename Track> LayerWriteHeaderOfTrack(const Track & track)135 void LayerWriteHeaderOfTrack(const Track& track) 136 { 137 uint32_t recordSize = track.size(); 138 Utils::FileWrite(&recordSize, sizeof(recordSize), 1, file_); 139 for (auto item : track) { 140 Utils::FileWrite(&item.first, sizeof(item.first), 1, file_); 141 Utils::FileWrite(&item.second, sizeof(item.second), 1, file_); 142 } 143 } 144 145 std::string ReadHeaders(); 146 std::string ReadHeader(); 147 bool ReadHeaderPidList(); 148 bool ReadHeaderFirstScreen(); 149 std::string LayerReadHeader(uint32_t layer); 150 151 template<typename Track> LayerReadHeaderOfTrack(Track & track)152 void LayerReadHeaderOfTrack(Track& track) 153 { 154 uint32_t recordSize; 155 Utils::FileRead(&recordSize, sizeof(recordSize), 1, file_); 156 track.resize(recordSize); 157 for (size_t i = 0; i < recordSize; i++) { 158 Utils::FileRead(&track[i].first, sizeof(track[i].first), 1, file_); 159 Utils::FileRead(&track[i].second, sizeof(track[i].second), 1, file_); 160 } 161 } 162 163 using LayerTrackIndexPtr = uint32_t RSFileLayer::*; 164 using LayerTrackMarkupPtr = RSFileLayer::TrackMarkup RSFileLayer::*; 165 struct LayerTrackPtr { 166 LayerTrackIndexPtr index; 167 LayerTrackMarkupPtr markup; 168 }; 169 170 void WriteTrackData(LayerTrackMarkupPtr trackMarkup, uint32_t layer, double time, const void* data, size_t size); 171 bool ReadTrackData( 172 LayerTrackPtr track, double untilTime, uint32_t layer, std::vector<uint8_t>& data, double& readTime); 173 void ReadTrackDataRestart(LayerTrackIndexPtr trackIndex, uint32_t layer); 174 bool TrackEOF(LayerTrackPtr track, uint32_t layer) const; 175 176 private: 177 FILE* file_ = nullptr; 178 uint32_t versionId_ = 0; 179 double writeStartTime_ = 0.0; 180 uint32_t headerOff_ = 0u; 181 std::vector<pid_t> headerPidList_; 182 std::vector<RSFileLayer> layerData_; 183 uint32_t writeDataOff_ = 0u; // last byte of file where we can continue writing 184 std::string headerFirstFrame_; 185 std::vector<std::pair<uint64_t, int64_t>> headerAnimeStartTimes_; 186 std::mutex writeMutex_; 187 bool wasChanged_ = false; 188 std::vector<uint8_t> preparedHeader_; 189 bool preparedHeaderMode_ = false; 190 std::map<int64_t, double> mapVsyncId2Time_; 191 192 static constexpr size_t chunkSizeMax = 100'000'000; 193 static constexpr size_t headerSizeMax = 512u * 1024u * 1024u; 194 }; 195 196 } // namespace OHOS::Rosen 197 198 #endif // RS_PROFILER_FILE_H