为什么chrome://tracing的两个函数重叠在一起

Sky天曰

为什么chrome://tracing的两个函数重叠在一起，有没有大佬帮我看看

代码如下：

1. // #include "HeaderFolder\Timer.h"
   
2. 
   
3. #include <iostream>        
   
4. #include <string>
   
5. #include <chrono>
   
6. #include <algorithm>
   
7. #include <fstream>
   
8. 
   
9. #include <cmath>
   
10. #include <thread>
    
11. 
    
12. struct ProfileResult
    
13. {
    
14.         std::string Name;
    
15.         long long Start, End;
    
16.         uint32_t ThreadID;
    
17. };
    
18. 
    
19. struct InstrumentationSession
    
20. {
    
21.         std::string Name;
    
22. };
    
23. 
    
24. struct Instrumentor
    
25. {
    
26. private:
    
27.         InstrumentationSession* m_CurrentSession;
    
28.         std::ofstream m_OutpuyStream;
    
29.         int m_ProfileCount;
    
30. public:
    
31.         Instrumentor()
    
32.                 : m_CurrentSession(nullptr), m_ProfileCount(0)
    
33.         {
    
34.         }
    
35. 
    
36.         void BeginSession(const std::string& name, const std::string& filepath = "results.json")
    
37.         {
    
38.                 m_OutpuyStream.open(filepath);
    
39.                 WriteHeader();
    
40.                 m_CurrentSession = new InstrumentationSession{ name };
    
41.         }
    
42. 
    
43.         void EndSession()
    
44.         {
    
45.                 WriteFooter();
    
46.                 m_OutpuyStream.close();
    
47.                 delete m_CurrentSession;
    
48.                 m_CurrentSession = nullptr;
    
49.                 m_ProfileCount = 0;
    
50.         }
    
51. 
    
52.         void WriteProfile(const ProfileResult& result)
    
53.         {
    
54.                 if (m_ProfileCount++ > 0)
    
55.                         m_OutpuyStream << ",";
    
56. 
    
57.                 std::string name = result.Name;
    
58.                 std::replace(name.begin(), name.end(), '"', '\'');
    
59. 
    
60.                 m_OutpuyStream << "{";
    
61.                 m_OutpuyStream << ""cat":"function",";
    
62.                 m_OutpuyStream << ""dur":" << (result.End - result.Start) << ",";
    
63.                 m_OutpuyStream << ""name":"" << name << "",";
    
64.                 m_OutpuyStream << ""ph":"X",";
    
65.                 m_OutpuyStream << ""pid":0,";
    
66.                 m_OutpuyStream << ""tid":" << result.ThreadID << ",";
    
67.                 m_OutpuyStream << ""ts":" << result.Start;
    
68.                 m_OutpuyStream << "}";
    
69. 
    
70.                 m_OutpuyStream.flush();
    
71.         }
    
72. 
    
73.         void WriteHeader()
    
74.         {
    
75.                 m_OutpuyStream << "{"otherData": {},"traceEvents":[";
    
76.                 m_OutpuyStream.flush();
    
77.         }
    
78. 
    
79.         void WriteFooter()
    
80.         {
    
81.                 m_OutpuyStream << "]}";
    
82.                 m_OutpuyStream.flush();
    
83.         }
    
84. 
    
85.         static Instrumentor& Get()
    
86.         {
    
87.                 static Instrumentor* instance = new Instrumentor();
    
88.                 return *instance;
    
89.         }
    
90. };
    
91. 
    
92. class InstrumentationTimer
    
93. {
    
94. public:
    
95.         InstrumentationTimer(const char* name)
    
96.                 : m_Name(name), m_Stopped(false)
    
97.         {
    
98.                 m_StartTimepoint = std::chrono::high_resolution_clock::now();
    
99.         }
    
100. 
     
101.         ~InstrumentationTimer()
     
102.         {
     
103.                 if (!m_Stopped)
     
104.                         Stop();
     
105.         }
     
106. 
     
107.         void Stop()
     
108.         {
     
109.                 auto endTimepoint = std::chrono::high_resolution_clock::now();
     
110. 
     
111.                 long long start = std::chrono::time_point_cast<std::chrono::milliseconds>(m_StartTimepoint).time_since_epoch().count();
     
112.                 long long end = std::chrono::time_point_cast<std::chrono::milliseconds>(endTimepoint).time_since_epoch().count();
     
113. 
     
114.                 uint32_t threadID = std::hash<std::thread::id>{}(std::this_thread::get_id());
     
115.                 Instrumentor::Get().WriteProfile({ m_Name, start, end, threadID });
     
116. 
     
117.                 m_Stopped = true;
     
118.         }
     
119. 
     
120. private:
     
121.         const char* m_Name;
     
122.         std::chrono::high_resolution_clock::time_point m_StartTimepoint; // std::chrono::high_resolution_clock::time_point | std::chrono::time_point<std::chrono::steady_clock>
     
123.         bool m_Stopped;
     
124. };
     
125. 
     
126. #define PROFING true
     
127. 
     
128. #if PROFING
     
129. #define PROFILE_SCOPE(name) InstrumentationTimer timer##__LINE__(name)
     
130. #define        PROFILE_FUNCTION() PROFILE_SCOPE(__FUNCSIG__)
     
131. #else
     
132. #define PROFILE_SCOPE(name)
     
133. #endif
     
134. 
     
135. namespace Benchmark {
     
136.         void PrintFunction(int value)
     
137.         {
     
138.                 PROFILE_FUNCTION();
     
139. 
     
140.                 for (int i = 0; i < 1000; i++)
     
141.                         std::cout << "Hello World! #" << (i + value) << std::endl;
     
142.         }
     
143. 
     
144.         void PrintFunction()
     
145.         {
     
146.                 PROFILE_FUNCTION();
     
147. 
     
148.                 for (int i = 0; i < 1000; i++)
     
149.                         std::cout << "Hello World! #" << sqrt(i) << std::endl;
     
150.         }
     
151. 
     
152.         void RunBenchmarks()
     
153.         {
     
154.                 PROFILE_FUNCTION();
     
155. 
     
156.                 std::cout << "Running Banchmarks...\n";
     
157. 
     
158.                 PrintFunction(2);
     
159.                 PrintFunction();
     
160.         }
     
161. }
     
162. 
     
163. int main()
     
164. {
     
165.         Instrumentor::Get().BeginSession("Profile");
     
166.         Benchmark::RunBenchmarks();
     
167.         Instrumentor::Get().EndSession();
     
168. 
     
169.         std::cin.get();
     
170. }        
     

复制代码

还有这个生成的json文件：

1. {
   
2.   "otherData": {},
   
3.   "traceEvents": [
   
4.     {
   
5.       "cat": "function",
   
6.       "dur": 86,
   
7.       "name": "void __cdecl Benchmark::PrintFunction(int)",
   
8.       "ph": "X",
   
9.       "pid": 0,
   
10.       "tid": 3404007327,
    
11.       "ts": 14619163
    
12.     },
    
13.     {
    
14.       "cat": "function",
    
15.       "dur": 123,
    
16.       "name": "void __cdecl Benchmark::PrintFunction(void)",
    
17.       "ph": "X",
    
18.       "pid": 0,
    
19.       "tid": 3404007327,
    
20.       "ts": 14619249
    
21.     },
    
22.     {
    
23.       "cat": "function",
    
24.       "dur": 209,
    
25.       "name": "void __cdecl Benchmark::RunBenchmarks(void)",
    
26.       "ph": "X",
    
27.       "pid": 0,
    
28.       "tid": 3404007327,
    
29.       "ts": 14619163
    
30.     }
    
31.   ]
    
32. }
    

复制代码

这个json文件中有两个的“ts”时一样的！！！
怎么解决这个问题？急！
file:///D:/lixxl/Pictures/Screenshots/Screenshot%202024-07-24%20145010.png

Sky天曰

FishC

首先，欢迎来到鱼油的编程小课堂！我们今天要聊聊在 `chrome://tracing` 中看到的函数重叠现象。这就像糖果铺里你一不小心把两个糖捏在一起了，结果吃起来怪怪的。

根据你提供的代码，描述了一个简单的性能分析工具。对`ProfileResult`结构体来说，每次测量的开始和结束时间是关键。问题可能出现在以下几个方面：

1. **时间戳不准确**：如果计算开始 (`Start`) 和结束 (`End`) 时间的代码逻辑有问题，比如调用顺序错误或者没有正确记录时间，就会导致多个函数的时间戳重叠。

2. **没有足够的分隔**：如果在记录每个函数执行的过程时，没有为每个函数创建单独的 `ProfileResult` 实例，可能会将多个函数的执行结果写到同一个记录中，从而在最终输出时导致重叠。

3. **并发执行**：如果你的函数是多线程执行的，而你没有为每个线程的执行结果设置适当的锁或管理机制，这样多个线程的执行记录可能会交错在一起，表现为重叠。

4. **WriteProfile方法缺失**：你提供的代码片段在 `WriteProfile` 方法的实现上似乎没完整展示，确保这个方法能够正确地将每个函数的执行信息写入输出流中。如果这里没搞清楚，重叠问题就会出现。

修复这个问题的建议：
- 确保你在记录 `Start` 和 `End` 时使用的是准确的时间获取方法（比如用高精度计时器）。
- 确保每个测量都生成新的 `ProfileResult`，并且在写入时做好数据管理。
- 如果涉及多线程，看看是否需要加锁来防止数据竞争。

总之，要想在 `chrome://tracing` 中看到无重叠的函数表现，就像想要在糖果铺里找到完好无损的糖果，一定要注意细节哦！希望这些小建议能帮助到你，如果还有问题，随时问我！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

Sky天曰

FishC 发表于 2024-7-24 15:02
首先，欢迎来到鱼油的编程小课堂！我们今天要聊聊在 `chrome://tracing` 中看到的函数重叠现象。这就像糖果 ...

有代码吗

FishC

Sky天曰 发表于 2024-07-24 16:15
有代码吗

当然可以！下面是一个简化版的 `InstrumentationSession` 和 `Instrumentor` 的代码示例，加入了一些细节以帮助你避免函数重叠的问题。我们还补充了 `WriteProfile` 的完整实现和线程安全性考虑。

1. #include <iostream>
   
2. #include <fstream>
   
3. #include <string>
   
4. #include <chrono>
   
5. #include <mutex>
   
6. 
   
7. struct ProfileResult {
   
8.     std::string Name;
   
9.     long long Start, End;
   
10.     uint32_t ThreadID;
    
11. };
    
12. 
    
13. struct InstrumentationSession {
    
14.     std::string Name;
    
15. };
    
16. 
    
17. class Instrumentor {
    
18. private:
    
19.     InstrumentationSession* m_CurrentSession;
    
20.     std::ofstream m_OutputStream;
    
21.     int m_ProfileCount;
    
22.     std::mutex m_Mutex; // 用于多线程保护
    
23. 
    
24. public:
    
25.     Instrumentor()
    
26.         : m_CurrentSession(nullptr), m_ProfileCount(0) {}
    
27. 
    
28.     void BeginSession(const std::string& name, const std::string& filepath = "results.json") {
    
29.         std::lock_guard<std::mutex> lock(m_Mutex); // 保护代码块
    
30.         m_OutputStream.open(filepath);
    
31.         WriteHeader();
    
32.         m_CurrentSession = new InstrumentationSession{ name };
    
33.     }
    
34. 
    
35.     void EndSession() {
    
36.         std::lock_guard<std::mutex> lock(m_Mutex); // 保护代码块
    
37.         WriteFooter();
    
38.         m_OutputStream.close();
    
39.         delete m_CurrentSession;
    
40.         m_CurrentSession = nullptr;
    
41.         m_ProfileCount = 0;
    
42.     }
    
43. 
    
44.     void WriteProfile(const ProfileResult& result) {
    
45.         std::lock_guard<std::mutex> lock(m_Mutex); // 保护代码块
    
46.         if (m_ProfileCount++ > 0) {
    
47.             m_OutputStream << ",";
    
48.         }
    
49.         m_OutputStream << "{";
    
50.         m_OutputStream << ""name":"" << result.Name << "",";
    
51.         m_OutputStream << ""cat":"function",";
    
52.         m_OutputStream << ""ph":"X",";
    
53.         m_OutputStream << ""ts":" << result.Start << ",";
    
54.         m_OutputStream << ""dur":" << (result.End - result.Start) << ",";
    
55.         m_OutputStream << ""pid":0,";
    
56.         m_OutputStream << ""tid":" << result.ThreadID;
    
57.         m_OutputStream << "}";
    
58.     }
    
59. 
    
60. private:
    
61.     void WriteHeader() {
    
62.         m_OutputStream << "[";
    
63.     }
    
64. 
    
65.     void WriteFooter() {
    
66.         m_OutputStream << "]";
    
67.     }
    
68. };
    
69. 
    
70. // 使用示例
    
71. void FunctionToProfile(Instrumentor& instrumentor) {
    
72.     auto start = std::chrono::high_resolution_clock::now();
    
73.    
    
74.     // 假设这里是要测量的代码
    
75.     std::this_thread::sleep_for(std::chrono::milliseconds(100));
    
76. 
    
77.     auto end = std::chrono::high_resolution_clock::now();
    
78.     long long startTime = std::chrono::duration_cast<std::chrono::microseconds>(start.time_since_epoch()).count();
    
79.     long long endTime = std::chrono::duration_cast<std::chrono::microseconds>(end.time_since_epoch()).count();
    
80. 
    
81.     instrumentor.WriteProfile({ "FunctionToProfile", startTime, endTime, std::this_thread::get_id() });
    
82. }
    
83. 
    
84. int main() {
    
85.     Instrumentor instrumentor;
    
86.     instrumentor.BeginSession("Profile Session");
    
87. 
    
88.     // 这里可以启动多个线程来测试
    
89.     FunctionToProfile(instrumentor);
    
90. 
    
91.     instrumentor.EndSession();
    
92.     return 0;
    
93. }

复制代码

### 代码解释：
1. **多线程保护**：用 `std::mutex` 来确保在多线程环境下写入文件时不会发生数据竞争。
2. **时间戳的获取**：使用高分辨率时钟捕获开始和结束时间，并计算出持续时间，以防止函数重叠。
3. **`WriteProfile` 方法**：正确地格式化每个函数的执行结果并写入输出流，这将有助于降低输出重叠的风险。

在实际应用中，确保你调用 `BeginSession` 和 `EndSession` 的时候要匹配，并在它们之间的代码段使用 `WriteProfile` 来记录各个函数的执行情况。

希望这个代码示例能帮助你清晰地理解如何避免函数重叠问题！如果还有疑问，随时问我！

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。