• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2019 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef SRC_TRACE_PROCESSOR_IMPORTERS_FTRACE_FTRACE_PARSER_H_
18 #define SRC_TRACE_PROCESSOR_IMPORTERS_FTRACE_FTRACE_PARSER_H_
19 
20 #include <cstdint>
21 
22 #include <string>
23 #include <unordered_set>
24 #include <vector>
25 
26 #include "perfetto/ext/base/flat_hash_map.h"
27 #include "perfetto/ext/base/hash.h"
28 #include "src/trace_processor/importers/common/event_tracker.h"
29 #include "src/trace_processor/importers/common/parser_types.h"
30 #include "src/trace_processor/importers/common/trace_parser.h"
31 #include "src/trace_processor/importers/ftrace/drm_tracker.h"
32 #include "src/trace_processor/importers/ftrace/ftrace_descriptors.h"
33 #include "src/trace_processor/importers/ftrace/gpu_work_period_tracker.h"
34 #include "src/trace_processor/importers/ftrace/iostat_tracker.h"
35 #include "src/trace_processor/importers/ftrace/mali_gpu_event_tracker.h"
36 #include "src/trace_processor/importers/ftrace/pkvm_hyp_cpu_tracker.h"
37 #include "src/trace_processor/importers/ftrace/rss_stat_tracker.h"
38 #include "src/trace_processor/importers/ftrace/thermal_tracker.h"
39 #include "src/trace_processor/importers/ftrace/virtio_gpu_tracker.h"
40 #include "src/trace_processor/types/trace_processor_context.h"
41 
42 namespace perfetto {
43 namespace trace_processor {
44 
45 class FtraceParser {
46  public:
47   explicit FtraceParser(TraceProcessorContext* context);
48 
49   base::Status ParseFtraceStats(protozero::ConstBytes,
50                                 uint32_t packet_sequence_id);
51 
52   base::Status ParseFtraceEvent(uint32_t cpu,
53                                 int64_t ts,
54                                 const TracePacketData& data);
55   base::Status ParseInlineSchedSwitch(uint32_t cpu,
56                                       int64_t ts,
57                                       const InlineSchedSwitch& data);
58   base::Status ParseInlineSchedWaking(uint32_t cpu,
59                                       int64_t ts,
60                                       const InlineSchedWaking& data);
61 
62  private:
63   void ParseGenericFtrace(int64_t timestamp,
64                           uint32_t cpu,
65                           uint32_t pid,
66                           protozero::ConstBytes);
67   void ParseTypedFtraceToRaw(uint32_t ftrace_id,
68                              int64_t timestamp,
69                              uint32_t cpu,
70                              uint32_t pid,
71                              protozero::ConstBytes,
72                              PacketSequenceStateGeneration*);
73   void ParseSchedSwitch(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
74   void ParseSchedWaking(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
75   void ParseSchedProcessFree(int64_t timestamp, protozero::ConstBytes);
76   void ParseCpuFreq(int64_t timestamp, protozero::ConstBytes);
77   void ParseCpuFreqThrottle(int64_t timestamp, protozero::ConstBytes);
78   void ParseGpuFreq(int64_t timestamp, protozero::ConstBytes);
79   void ParseKgslGpuFreq(int64_t timestamp, protozero::ConstBytes);
80   void ParseCpuIdle(int64_t timestamp, protozero::ConstBytes);
81   void ParsePrint(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
82   void ParseZero(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
83   void ParseMdssTracingMarkWrite(int64_t timestamp,
84                                  uint32_t pid,
85                                  protozero::ConstBytes);
86   void ParseSdeTracingMarkWrite(int64_t timestamp,
87                                 uint32_t pid,
88                                 protozero::ConstBytes);
89   void ParseDpuTracingMarkWrite(int64_t timestamp,
90                                 uint32_t pid,
91                                 protozero::ConstBytes);
92   void ParseG2dTracingMarkWrite(int64_t timestamp,
93                                 uint32_t pid,
94                                 protozero::ConstBytes);
95   void ParseSamsungTracingMarkWrite(int64_t timestamp,
96                                     uint32_t pid,
97                                     protozero::ConstBytes);
98   void ParseMaliTracingMarkWrite(int64_t timestamp,
99                                  uint32_t pid,
100                                  protozero::ConstBytes);
101   void ParseLwisTracingMarkWrite(int64_t timestamp,
102                                  uint32_t pid,
103                                  protozero::ConstBytes);
104   void ParseIonHeapGrowOrShrink(int64_t timestamp,
105                                 uint32_t pid,
106                                 protozero::ConstBytes,
107                                 bool grow);
108   void ParseIonStat(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
109   void ParseBclIrq(int64_t timestamp, protozero::ConstBytes);
110   void ParseDmaHeapStat(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
111   void ParseSignalGenerate(int64_t timestamp, protozero::ConstBytes);
112   void ParseSignalDeliver(int64_t timestamp,
113                           uint32_t pid,
114                           protozero::ConstBytes);
115   void ParseOOMScoreAdjUpdate(int64_t timestamp, protozero::ConstBytes);
116   void ParseOOMKill(int64_t timestamp, protozero::ConstBytes);
117   void ParseMmEventRecord(int64_t timestamp,
118                           uint32_t pid,
119                           protozero::ConstBytes);
120   void ParseSysEnterEvent(int64_t timestamp,
121                           uint32_t pid,
122                           protozero::ConstBytes);
123   void ParseSysExitEvent(int64_t timestamp,
124                          uint32_t pid,
125                          protozero::ConstBytes);
126   void ParseI2cReadEvent(int64_t timestamp,
127                          uint32_t pid,
128                          protozero::ConstBytes);
129   void ParseI2cWriteEvent(int64_t timestamp,
130                           uint32_t pid,
131                           protozero::ConstBytes);
132   void ParseI2cResultEvent(int64_t timestamp,
133                            uint32_t pid,
134                            protozero::ConstBytes);
135   void ParseTaskNewTask(int64_t timestamp,
136                         uint32_t source_tid,
137                         protozero::ConstBytes);
138   void ParseTaskRename(protozero::ConstBytes);
139   void ParseBinderTransaction(int64_t timestamp,
140                               uint32_t pid,
141                               protozero::ConstBytes);
142   void ParseBinderTransactionReceived(int64_t timestamp,
143                                       uint32_t pid,
144                                       protozero::ConstBytes);
145   void ParseBinderCommand(int64_t timestamp,
146                           uint32_t pid,
147                           protozero::ConstBytes);
148   void ParseBinderReturn(int64_t timestamp,
149                          uint32_t pid,
150                          protozero::ConstBytes);
151   void ParseBinderTransactionAllocBuf(int64_t timestamp,
152                                       uint32_t pid,
153                                       protozero::ConstBytes);
154   void ParseBinderLocked(int64_t timestamp,
155                          uint32_t pid,
156                          protozero::ConstBytes);
157   void ParseBinderLock(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
158   void ParseBinderUnlock(int64_t timestamp,
159                          uint32_t pid,
160                          protozero::ConstBytes);
161   void ParseClockSetRate(int64_t timestamp, protozero::ConstBytes);
162   void ParseClockEnable(int64_t timestamp, protozero::ConstBytes);
163   void ParseClockDisable(int64_t timestamp, protozero::ConstBytes);
164   void ClockRate(int64_t timestamp,
165                  base::StringView clock_name,
166                  base::StringView subtitle,
167                  uint64_t rate);
168   void ParseScmCallStart(int64_t timestamp,
169                          uint32_t pid,
170                          protozero::ConstBytes);
171   void ParseScmCallEnd(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
172   void ParseCmaAllocStart(int64_t timestamp, uint32_t pid);
173   void ParseCmaAllocInfo(int64_t timestamp,
174                          uint32_t pid,
175                          protozero::ConstBytes);
176   void ParseDirectReclaimBegin(int64_t timestamp,
177                                uint32_t pid,
178                                protozero::ConstBytes);
179   void ParseDirectReclaimEnd(int64_t timestamp,
180                              uint32_t pid,
181                              protozero::ConstBytes);
182   void ParseShrinkSlabStart(int64_t timestamp,
183                             uint32_t pid,
184                             protozero::ConstBytes,
185                             PacketSequenceStateGeneration* seq_state);
186   void ParseShrinkSlabEnd(int64_t timestamp,
187                           uint32_t pid,
188                           protozero::ConstBytes);
189   void ParseWorkqueueExecuteStart(uint32_t cpu,
190                                   int64_t timestamp,
191                                   uint32_t pid,
192                                   protozero::ConstBytes,
193                                   PacketSequenceStateGeneration* seq_state);
194   void ParseWorkqueueExecuteEnd(int64_t timestamp,
195                                 uint32_t pid,
196                                 protozero::ConstBytes);
197   void ParseIrqHandlerEntry(uint32_t cpu,
198                             int64_t timestamp,
199                             protozero::ConstBytes);
200   void ParseIrqHandlerExit(uint32_t cpu,
201                            int64_t timestamp,
202                            protozero::ConstBytes);
203   void ParseSoftIrqEntry(uint32_t cpu,
204                          int64_t timestamp,
205                          protozero::ConstBytes);
206   void ParseSoftIrqExit(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
207   void ParseGpuMemTotal(int64_t timestamp, protozero::ConstBytes);
208   void ParseSchedBlockedReason(protozero::ConstBytes,
209                                PacketSequenceStateGeneration*);
210   void ParseFastRpcDmaStat(int64_t timestamp,
211                            uint32_t pid,
212                            protozero::ConstBytes);
213   void ParseCpuhpPause(int64_t, uint32_t, protozero::ConstBytes);
214   void ParseNetifReceiveSkb(uint32_t cpu,
215                             int64_t timestamp,
216                             protozero::ConstBytes);
217   void ParseNetDevXmit(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
218   void ParseInetSockSetState(int64_t timestamp,
219                              uint32_t pid,
220                              protozero::ConstBytes);
221   void ParseTcpRetransmitSkb(int64_t timestamp, protozero::ConstBytes);
222   void ParseNapiGroReceiveEntry(uint32_t cpu,
223                                 int64_t timestamp,
224                                 protozero::ConstBytes);
225   void ParseNapiGroReceiveExit(uint32_t cpu,
226                                int64_t timestamp,
227                                protozero::ConstBytes);
228   void ParseCpuFrequencyLimits(int64_t timestamp, protozero::ConstBytes);
229   void ParseKfreeSkb(int64_t timestamp, protozero::ConstBytes);
230   void ParseUfshcdCommand(int64_t timestamp, protozero::ConstBytes);
231   void ParseUfshcdClkGating(int64_t timestamp, protozero::ConstBytes);
232 
233   void ParseCrosEcSensorhubData(int64_t timestamp, protozero::ConstBytes);
234 
235   void ParseWakeSourceActivate(int64_t timestamp, protozero::ConstBytes);
236   void ParseWakeSourceDeactivate(int64_t timestamp, protozero::ConstBytes);
237   void ParseSuspendResume(int64_t timestamp, protozero::ConstBytes);
238   void ParseSuspendResumeMinimal(int64_t timestamp, protozero::ConstBytes);
239   void ParseSchedCpuUtilCfs(int64_t timestamp, protozero::ConstBytes);
240 
241   void ParseFuncgraphEntry(int64_t timestamp,
242                            uint32_t cpu,
243                            uint32_t pid,
244                            protozero::ConstBytes blob,
245                            PacketSequenceStateGeneration* seq_state);
246   void ParseFuncgraphExit(int64_t timestamp,
247                           uint32_t cpu,
248                           uint32_t pid,
249                           protozero::ConstBytes blob,
250                           PacketSequenceStateGeneration* seq_state);
251 
252   void MaybeOnFirstFtraceEvent();
253   StringId InternedKernelSymbolOrFallback(
254       uint64_t key,
255       PacketSequenceStateGeneration* seq_state);
256   void ParseTrustySmc(uint32_t pid, int64_t timestamp, protozero::ConstBytes);
257   void ParseTrustySmcDone(uint32_t pid,
258                           int64_t timestamp,
259                           protozero::ConstBytes);
260   void ParseTrustyStdCall32(uint32_t pid,
261                             int64_t ts,
262                             protozero::ConstBytes data);
263   void ParseTrustyStdCall32Done(uint32_t pid,
264                                 int64_t ts,
265                                 protozero::ConstBytes data);
266   void ParseTrustyShareMemory(uint32_t pid, int64_t ts, protozero::ConstBytes);
267   void ParseTrustyShareMemoryDone(uint32_t pid,
268                                   int64_t ts,
269                                   protozero::ConstBytes);
270   void ParseTrustyReclaimMemory(uint32_t pid,
271                                 int64_t ts,
272                                 protozero::ConstBytes);
273   void ParseTrustyReclaimMemoryDone(uint32_t pid,
274                                     int64_t ts,
275                                     protozero::ConstBytes);
276   void ParseTrustyIrq(uint32_t pid, int64_t ts, protozero::ConstBytes);
277   void ParseTrustyIpcHandleEvent(uint32_t pid,
278                                  int64_t ts,
279                                  protozero::ConstBytes);
280   void ParseTrustyIpcConnect(uint32_t pid, int64_t ts, protozero::ConstBytes);
281   void ParseTrustyIpcConnectEnd(uint32_t pid,
282                                 int64_t ts,
283                                 protozero::ConstBytes);
284   void ParseTrustyIpcWrite(uint32_t pid, int64_t ts, protozero::ConstBytes);
285   void ParseTrustyIpcWriteEnd(uint32_t pid, int64_t ts, protozero::ConstBytes);
286   void ParseTrustyIpcRead(uint32_t pid, int64_t ts, protozero::ConstBytes);
287   void ParseTrustyIpcReadEnd(uint32_t pid, int64_t ts, protozero::ConstBytes);
288   void ParseTrustyIpcPoll(uint32_t pid, int64_t ts, protozero::ConstBytes);
289   void ParseTrustyIpcRx(uint32_t pid, int64_t ts, protozero::ConstBytes);
290   void ParseTrustyEnqueueNop(uint32_t pid, int64_t ts, protozero::ConstBytes);
291   void ParseMaliKcpuCqsSet(uint32_t pid, int64_t ts);
292   void ParseMaliKcpuCqsWaitStart(uint32_t pid, int64_t ts);
293   void ParseMaliKcpuCqsWaitEnd(uint32_t pid, int64_t ts);
294   void ParseMaliKcpuFenceSignal(uint32_t pid, int64_t ts);
295   void ParseMaliKcpuFenceWaitStart(uint32_t pid, int64_t ts);
296   void ParseMaliKcpuFenceWaitEnd(uint32_t pid, int64_t ts);
297   void ParseAndroidFsDatareadEnd(int64_t timestamp, protozero::ConstBytes);
298   void ParseAndroidFsDatareadStart(int64_t ts,
299                                    uint32_t pid,
300                                    protozero::ConstBytes);
301   StringId GetRpmStatusStringId(int32_t rpm_status_val);
302   void ParseRpmStatus(int64_t ts, protozero::ConstBytes);
303   void ParseDevicePmCallbackStart(int64_t ts, protozero::ConstBytes);
304   void ParseDevicePmCallbackEnd(int64_t ts, protozero::ConstBytes);
305   void ParsePanelWriteGeneric(int64_t timestamp,
306                               uint32_t pid,
307                               protozero::ConstBytes);
308   void ParseGoogleIccEvent(int64_t timestamp, protozero::ConstBytes);
309   void ParseGoogleIrmEvent(int64_t timestamp, protozero::ConstBytes);
310 
311   TraceProcessorContext* context_;
312   RssStatTracker rss_stat_tracker_;
313   DrmTracker drm_tracker_;
314   IostatTracker iostat_tracker_;
315   VirtioGpuTracker virtio_gpu_tracker_;
316   MaliGpuEventTracker mali_gpu_event_tracker_;
317   PkvmHypervisorCpuTracker pkvm_hyp_cpu_tracker_;
318   GpuWorkPeriodTracker gpu_work_period_tracker_;
319   ThermalTracker thermal_tracker_;
320 
321   const StringId sched_wakeup_name_id_;
322   const StringId sched_waking_name_id_;
323   const StringId cpu_id_;
324   const StringId cpu_freq_name_id_;
325   const StringId cpu_freq_throttle_name_id_;
326   const StringId gpu_freq_name_id_;
327   const StringId cpu_idle_name_id_;
328   const StringId suspend_resume_name_id_;
329   const StringId suspend_resume_minimal_name_id_;
330   const StringId suspend_resume_minimal_slice_name_id_;
331   const StringId kfree_skb_name_id_;
332   const StringId ion_total_id_;
333   const StringId ion_change_id_;
334   const StringId ion_buffer_id_;
335   const StringId dma_heap_total_id_;
336   const StringId dma_heap_change_id_;
337   const StringId dma_buffer_id_;
338   const StringId ion_total_unknown_id_;
339   const StringId ion_change_unknown_id_;
340   const StringId bcl_irq_id_;
341   const StringId bcl_irq_throttle_;
342   const StringId bcl_irq_cpu0_;
343   const StringId bcl_irq_cpu1_;
344   const StringId bcl_irq_cpu2_;
345   const StringId bcl_irq_tpu_;
346   const StringId bcl_irq_gpu_;
347   const StringId bcl_irq_voltage_;
348   const StringId bcl_irq_capacity_;
349   const StringId signal_generate_id_;
350   const StringId signal_deliver_id_;
351   const StringId oom_score_adj_id_;
352   const StringId lmk_id_;
353   const StringId comm_name_id_;
354   const StringId signal_name_id_;
355   const StringId oom_kill_id_;
356   const StringId workqueue_id_;
357   const StringId irq_id_;
358   const StringId tcp_state_id_;
359   const StringId tcp_event_id_;
360   const StringId protocol_arg_id_;
361   const StringId napi_gro_id_;
362   const StringId tcp_retransmited_name_id_;
363   const StringId ret_arg_id_;
364   const StringId len_arg_id_;
365   const StringId direct_reclaim_nr_reclaimed_id_;
366   const StringId direct_reclaim_order_id_;
367   const StringId direct_reclaim_may_writepage_id_;
368   const StringId direct_reclaim_gfp_flags_id_;
369   const StringId vec_arg_id_;
370   const StringId gpu_mem_total_name_id_;
371   const StringId gpu_mem_total_unit_id_;
372   const StringId gpu_mem_total_global_desc_id_;
373   const StringId gpu_mem_total_proc_desc_id_;
374   const StringId io_wait_id_;
375   const StringId function_id_;
376   const StringId waker_utid_id_;
377   const StringId cros_ec_arg_num_id_;
378   const StringId cros_ec_arg_ec_id_;
379   const StringId cros_ec_arg_sample_ts_id_;
380   const StringId ufs_clkgating_id_;
381   const StringId ufs_command_count_id_;
382   const StringId shrink_slab_id_;
383   const StringId shrink_name_id_;
384   const StringId shrink_total_scan_id_;
385   const StringId shrink_freed_id_;
386   const StringId shrink_priority_id_;
387   const StringId trusty_category_id_;
388   const StringId trusty_name_trusty_std_id_;
389   const StringId trusty_name_tipc_rx_id_;
390   const StringId cma_alloc_id_;
391   const StringId cma_name_id_;
392   const StringId cma_pfn_id_;
393   const StringId cma_req_pages_id_;
394   const StringId cma_nr_migrated_id_;
395   const StringId cma_nr_reclaimed_id_;
396   const StringId cma_nr_mapped_id_;
397   const StringId cma_nr_isolate_fail_id_;
398   const StringId cma_nr_migrate_fail_id_;
399   const StringId cma_nr_test_fail_id_;
400   const StringId syscall_ret_id_;
401   const StringId syscall_args_id_;
402   const StringId replica_slice_id_;
403   const StringId file_path_id_;
404   const StringId offset_id_start_;
405   const StringId offset_id_end_;
406   const StringId bytes_read_id_start_;
407   const StringId bytes_read_id_end_;
408   const StringId android_fs_category_id_;
409   const StringId android_fs_data_read_id_;
410   const StringId google_icc_event_id_;
411   const StringId google_irm_event_id_;
412   const StringId runtime_status_invalid_id_;
413   const StringId runtime_status_active_id_;
414   const StringId runtime_status_suspending_id_;
415   const StringId runtime_status_resuming_id_;
416   std::vector<StringId> syscall_arg_name_ids_;
417 
418   struct FtraceMessageStrings {
419     // The string id of name of the event field (e.g. sched_switch's id).
420     StringId message_name_id = kNullStringId;
421     std::array<StringId, kMaxFtraceEventFields> field_name_ids;
422   };
423   std::vector<FtraceMessageStrings> ftrace_message_strings_;
424 
425   struct MmEventCounterNames {
426     MmEventCounterNames() = default;
MmEventCounterNamesMmEventCounterNames427     MmEventCounterNames(StringId _count, StringId _max_lat, StringId _avg_lat)
428         : count(_count), max_lat(_max_lat), avg_lat(_avg_lat) {}
429 
430     StringId count = kNullStringId;
431     StringId max_lat = kNullStringId;
432     StringId avg_lat = kNullStringId;
433   };
434 
435   static constexpr size_t kFastRpcCounterSize = 4;
436   std::array<StringId, kFastRpcCounterSize> fast_rpc_delta_names_;
437   std::array<StringId, kFastRpcCounterSize> fast_rpc_total_names_;
438 
439   // Keep kMmEventCounterSize equal to mm_event_type::MM_TYPE_NUM in the kernel.
440   static constexpr size_t kMmEventCounterSize = 7;
441   std::array<MmEventCounterNames, kMmEventCounterSize> mm_event_counter_names_;
442 
443   // Record number of received bytes from the network interface card.
444   std::unordered_map<StringId, uint64_t> nic_received_bytes_;
445 
446   // Record number of transmitted bytes to the network interface card.
447   std::unordered_map<StringId, uint64_t> nic_transmitted_bytes_;
448 
449   // Record number of kfree_skb with ip protocol.
450   uint64_t num_of_kfree_skb_ip_prot = 0;
451 
452   // Keep sock to stream number mapping.
453   std::unordered_map<uint64_t, uint32_t> skaddr_to_stream_;
454 
455   // Record number of tcp steams.
456   uint32_t num_of_tcp_stream_ = 0;
457 
458   // A name collision is possible, always show if active wakelock exists
459   // with a give name
460   std::unordered_map<std::string, uint32_t> active_wakelock_to_count_;
461 
462   // Record whether a suspend resume action is ongoing.
463   std::unordered_map<std::string, bool> ongoing_suspend_resume_actions;
464 
465   bool has_seen_first_ftrace_packet_ = false;
466 
467   // Ftrace events before this timestamp get dropped.
468   int64_t drop_ftrace_data_before_ts_ = 0;
469 
470   // Ftrace events before this timestamp get parsed into the |ftrace_events|
471   // table, but don't get propagated into other tables/trackers.
472   // Must be no less than drop_ftrace_data_before_ts_.
473   int64_t soft_drop_ftrace_data_before_ts_ = 0;
474 
475   // Does not skip any ftrace events.
476   bool preserve_ftrace_buffer_ = false;
477 
478   // Sequence ids for which ftrace_errors have been seen. Used to avoid
479   // putting them in the metadata multiple times (the ftrace data sources
480   // re-emits begin stats on every flush).
481   std::unordered_set<uint32_t> seen_errors_for_sequence_id_;
482 
483   // Tracks Linux devices with active runtime power management (RPM) status
484   // slices.
485   std::unordered_set<std::string> devices_with_active_rpm_slice_;
486 
487   // Tracks unique identifiers ("cookies") to create separate async tracks for
488   // the Suspend/Resume UI track. The separation prevents unnestable slices from
489   // overlapping on a single trace processor track.
490   //
491   // For `suspend_resume` ftrace events, the key for this map is derived from
492   // the `val` field in the trace object.
493   //
494   // For `device_pm_callback_[start|end]` ftrace events, the key for this map is
495   // derived from the device name.
496   base::FlatHashMap<std::string, int64_t> suspend_resume_cookie_map_;
497 
498   struct PairHash {
operatorPairHash499     std::size_t operator()(const std::pair<uint64_t, int64_t>& p) const {
500       base::Hasher hasher;
501       hasher.Update(p.first);
502       hasher.Update(p.second);
503       return static_cast<std::size_t>(hasher.digest());
504     }
505   };
506 
507   base::FlatHashMap<std::pair<uint64_t, int64_t>, uint32_t, PairHash>
508       inode_offset_thread_map_;
509 };
510 
511 }  // namespace trace_processor
512 }  // namespace perfetto
513 
514 #endif  // SRC_TRACE_PROCESSOR_IMPORTERS_FTRACE_FTRACE_PARSER_H_
515