• 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 <array>
21 #include <cstddef>
22 #include <cstdint>
23 #include <string>
24 #include <unordered_map>
25 #include <unordered_set>
26 #include <utility>
27 #include <vector>
28 
29 #include "perfetto/base/status.h"
30 #include "perfetto/ext/base/flat_hash_map.h"
31 #include "perfetto/ext/base/hash.h"
32 #include "perfetto/ext/base/string_view.h"
33 #include "perfetto/protozero/field.h"
34 #include "src/trace_processor/importers/common/event_tracker.h"
35 #include "src/trace_processor/importers/common/parser_types.h"
36 #include "src/trace_processor/importers/common/trace_parser.h"
37 #include "src/trace_processor/importers/ftrace/drm_tracker.h"
38 #include "src/trace_processor/importers/ftrace/ftrace_descriptors.h"
39 #include "src/trace_processor/importers/ftrace/gpu_work_period_tracker.h"
40 #include "src/trace_processor/importers/ftrace/iostat_tracker.h"
41 #include "src/trace_processor/importers/ftrace/mali_gpu_event_tracker.h"
42 #include "src/trace_processor/importers/ftrace/pixel_mm_kswapd_event_tracker.h"
43 #include "src/trace_processor/importers/ftrace/pkvm_hyp_cpu_tracker.h"
44 #include "src/trace_processor/importers/ftrace/rss_stat_tracker.h"
45 #include "src/trace_processor/importers/ftrace/thermal_tracker.h"
46 #include "src/trace_processor/importers/ftrace/virtio_gpu_tracker.h"
47 #include "src/trace_processor/storage/trace_storage.h"
48 #include "src/trace_processor/types/trace_processor_context.h"
49 
50 namespace perfetto::trace_processor {
51 
52 class FtraceParser {
53  public:
54   explicit FtraceParser(TraceProcessorContext* context);
55 
56   base::Status ParseFtraceStats(protozero::ConstBytes,
57                                 uint32_t packet_sequence_id);
58 
59   base::Status ParseFtraceEvent(uint32_t cpu,
60                                 int64_t ts,
61                                 const TracePacketData& data);
62   base::Status ParseInlineSchedSwitch(uint32_t cpu,
63                                       int64_t ts,
64                                       const InlineSchedSwitch& data);
65   base::Status ParseInlineSchedWaking(uint32_t cpu,
66                                       int64_t ts,
67                                       const InlineSchedWaking& data);
68 
69  private:
70   void ParseGenericFtrace(int64_t timestamp,
71                           uint32_t cpu,
72                           uint32_t pid,
73                           protozero::ConstBytes);
74   void ParseTypedFtraceToRaw(uint32_t ftrace_id,
75                              int64_t timestamp,
76                              uint32_t cpu,
77                              uint32_t pid,
78                              protozero::ConstBytes,
79                              PacketSequenceStateGeneration*);
80   void ParseSchedSwitch(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
81   void ParseKprobe(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
82   void ParseSchedWaking(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
83   void ParseSchedProcessFree(int64_t timestamp, protozero::ConstBytes);
84   void ParseCpuFreq(int64_t timestamp, protozero::ConstBytes);
85   void ParseCpuFreqThrottle(int64_t timestamp, protozero::ConstBytes);
86   void ParseGpuFreq(int64_t timestamp, protozero::ConstBytes);
87   void ParseKgslGpuFreq(int64_t timestamp, protozero::ConstBytes);
88   void ParseCpuIdle(int64_t timestamp, protozero::ConstBytes);
89   void ParsePrint(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
90   void ParseZero(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
91   void ParseMdssTracingMarkWrite(int64_t timestamp,
92                                  uint32_t pid,
93                                  protozero::ConstBytes);
94   void ParseSdeTracingMarkWrite(int64_t timestamp,
95                                 uint32_t pid,
96                                 protozero::ConstBytes);
97   void ParseDpuTracingMarkWrite(int64_t timestamp,
98                                 uint32_t pid,
99                                 protozero::ConstBytes);
100   void ParseDpuDispDpuUnderrun(int64_t timestamp, protozero::ConstBytes);
101   void ParseDpuDispVblankIrqEnable(int64_t timestamp, protozero::ConstBytes);
102   void ParseG2dTracingMarkWrite(int64_t timestamp,
103                                 uint32_t pid,
104                                 protozero::ConstBytes);
105   void ParseSamsungTracingMarkWrite(int64_t timestamp,
106                                     uint32_t pid,
107                                     protozero::ConstBytes);
108   void ParseMaliTracingMarkWrite(int64_t timestamp,
109                                  uint32_t pid,
110                                  protozero::ConstBytes);
111   void ParseLwisTracingMarkWrite(int64_t timestamp,
112                                  uint32_t pid,
113                                  protozero::ConstBytes);
114   void ParseIonHeapGrowOrShrink(int64_t timestamp,
115                                 uint32_t pid,
116                                 protozero::ConstBytes,
117                                 bool grow);
118   void ParseIonStat(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
119   void ParseBclIrq(int64_t timestamp, protozero::ConstBytes);
120   void ParseDmaHeapStat(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
121   void ParseSignalGenerate(int64_t timestamp, protozero::ConstBytes);
122   void ParseSignalDeliver(int64_t timestamp,
123                           uint32_t pid,
124                           protozero::ConstBytes);
125   void ParseOOMScoreAdjUpdate(int64_t timestamp, protozero::ConstBytes);
126   void ParseOOMKill(int64_t timestamp, protozero::ConstBytes);
127   void ParseMmEventRecord(int64_t timestamp,
128                           uint32_t pid,
129                           protozero::ConstBytes);
130   void ParseSysEnterEvent(int64_t timestamp,
131                           uint32_t pid,
132                           protozero::ConstBytes);
133   void ParseSysExitEvent(int64_t timestamp,
134                          uint32_t pid,
135                          protozero::ConstBytes);
136   void ParseI2cReadEvent(int64_t timestamp,
137                          uint32_t pid,
138                          protozero::ConstBytes);
139   void ParseI2cWriteEvent(int64_t timestamp,
140                           uint32_t pid,
141                           protozero::ConstBytes);
142   void ParseI2cResultEvent(int64_t timestamp,
143                            uint32_t pid,
144                            protozero::ConstBytes);
145   void ParseTaskNewTask(int64_t timestamp,
146                         uint32_t source_tid,
147                         protozero::ConstBytes);
148   void ParseTaskRename(protozero::ConstBytes);
149   void ParseBinderTransaction(int64_t timestamp,
150                               uint32_t pid,
151                               protozero::ConstBytes);
152   void ParseBinderTransactionReceived(int64_t timestamp,
153                                       uint32_t pid,
154                                       protozero::ConstBytes);
155   void ParseBinderCommand(int64_t timestamp,
156                           uint32_t pid,
157                           protozero::ConstBytes);
158   void ParseBinderReturn(int64_t timestamp,
159                          uint32_t pid,
160                          protozero::ConstBytes);
161   void ParseBinderTransactionAllocBuf(int64_t timestamp,
162                                       uint32_t pid,
163                                       protozero::ConstBytes);
164   void ParseBinderLocked(int64_t timestamp,
165                          uint32_t pid,
166                          protozero::ConstBytes);
167   void ParseBinderLock(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
168   void ParseBinderUnlock(int64_t timestamp,
169                          uint32_t pid,
170                          protozero::ConstBytes);
171   void ParseClockSetRate(int64_t timestamp, protozero::ConstBytes);
172   void ParseClockEnable(int64_t timestamp, protozero::ConstBytes);
173   void ParseClockDisable(int64_t timestamp, protozero::ConstBytes);
174   void ParseScmCallStart(int64_t timestamp,
175                          uint32_t pid,
176                          protozero::ConstBytes);
177   void ParseScmCallEnd(int64_t timestamp, uint32_t pid, protozero::ConstBytes);
178   void ParseCmaAllocStart(int64_t timestamp, uint32_t pid);
179   void ParseCmaAllocInfo(int64_t timestamp,
180                          uint32_t pid,
181                          protozero::ConstBytes);
182   void ParseDirectReclaimBegin(int64_t timestamp,
183                                uint32_t pid,
184                                protozero::ConstBytes);
185   void ParseDirectReclaimEnd(int64_t timestamp,
186                              uint32_t pid,
187                              protozero::ConstBytes);
188   void ParseShrinkSlabStart(int64_t timestamp,
189                             uint32_t pid,
190                             protozero::ConstBytes,
191                             PacketSequenceStateGeneration* seq_state);
192   void ParseShrinkSlabEnd(int64_t timestamp,
193                           uint32_t pid,
194                           protozero::ConstBytes);
195   void ParseWorkqueueExecuteStart(uint32_t cpu,
196                                   int64_t timestamp,
197                                   uint32_t pid,
198                                   protozero::ConstBytes,
199                                   PacketSequenceStateGeneration* seq_state);
200   void ParseWorkqueueExecuteEnd(int64_t timestamp,
201                                 uint32_t pid,
202                                 protozero::ConstBytes);
203   void ParseIrqHandlerEntry(uint32_t cpu,
204                             int64_t timestamp,
205                             protozero::ConstBytes);
206   void ParseIrqHandlerExit(uint32_t cpu,
207                            int64_t timestamp,
208                            protozero::ConstBytes);
209   void ParseSoftIrqEntry(uint32_t cpu,
210                          int64_t timestamp,
211                          protozero::ConstBytes);
212   void ParseSoftIrqExit(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
213   void ParseGpuMemTotal(int64_t timestamp, protozero::ConstBytes);
214   void ParseSchedBlockedReason(protozero::ConstBytes,
215                                PacketSequenceStateGeneration*);
216   void ParseFastRpcDmaStat(int64_t timestamp,
217                            uint32_t pid,
218                            protozero::ConstBytes);
219   void ParseCpuhpPause(int64_t, uint32_t, protozero::ConstBytes);
220   void ParseNetifReceiveSkb(uint32_t cpu,
221                             int64_t timestamp,
222                             protozero::ConstBytes);
223   void ParseNetDevXmit(uint32_t cpu, int64_t timestamp, protozero::ConstBytes);
224   void ParseInetSockSetState(int64_t timestamp,
225                              uint32_t pid,
226                              protozero::ConstBytes);
227   void ParseTcpRetransmitSkb(int64_t timestamp, protozero::ConstBytes);
228   void ParseNapiGroReceiveEntry(uint32_t cpu,
229                                 int64_t timestamp,
230                                 protozero::ConstBytes);
231   void ParseNapiGroReceiveExit(uint32_t cpu,
232                                int64_t timestamp,
233                                protozero::ConstBytes);
234   void ParseCpuFrequencyLimits(int64_t timestamp, protozero::ConstBytes);
235   void ParseKfreeSkb(int64_t timestamp, protozero::ConstBytes);
236   void ParseUfshcdCommand(int64_t timestamp, protozero::ConstBytes);
237   void ParseUfshcdClkGating(int64_t timestamp, protozero::ConstBytes);
238 
239   void ParseCrosEcSensorhubData(int64_t timestamp, protozero::ConstBytes);
240 
241   void ParseWakeSourceActivate(int64_t timestamp, protozero::ConstBytes);
242   void ParseWakeSourceDeactivate(int64_t timestamp, protozero::ConstBytes);
243   void ParseSuspendResume(int64_t timestamp,
244                           uint32_t cpu,
245                           uint32_t pid,
246                           protozero::ConstBytes);
247   void ParseSuspendResumeMinimal(int64_t timestamp, protozero::ConstBytes);
248   void ParseSchedCpuUtilCfs(int64_t timestamp, protozero::ConstBytes);
249 
250   void ParseFuncgraphEntry(int64_t timestamp,
251                            uint32_t cpu,
252                            uint32_t pid,
253                            protozero::ConstBytes blob,
254                            PacketSequenceStateGeneration* seq_state);
255   void ParseFuncgraphExit(int64_t timestamp,
256                           uint32_t cpu,
257                           uint32_t pid,
258                           protozero::ConstBytes blob,
259                           PacketSequenceStateGeneration* seq_state);
260 
261   void MaybeOnFirstFtraceEvent();
262   StringId InternedKernelSymbolOrFallback(
263       uint64_t key,
264       PacketSequenceStateGeneration* seq_state);
265   void ParseTrustySmc(uint32_t pid, int64_t timestamp, protozero::ConstBytes);
266   void ParseTrustySmcDone(uint32_t pid,
267                           int64_t timestamp,
268                           protozero::ConstBytes);
269   void ParseTrustyStdCall32(uint32_t pid,
270                             int64_t ts,
271                             protozero::ConstBytes data);
272   void ParseTrustyStdCall32Done(uint32_t pid,
273                                 int64_t ts,
274                                 protozero::ConstBytes data);
275   void ParseTrustyShareMemory(uint32_t pid, int64_t ts, protozero::ConstBytes);
276   void ParseTrustyShareMemoryDone(uint32_t pid,
277                                   int64_t ts,
278                                   protozero::ConstBytes);
279   void ParseTrustyReclaimMemory(uint32_t pid,
280                                 int64_t ts,
281                                 protozero::ConstBytes);
282   void ParseTrustyReclaimMemoryDone(uint32_t pid,
283                                     int64_t ts,
284                                     protozero::ConstBytes);
285   void ParseTrustyIrq(uint32_t pid, int64_t ts, protozero::ConstBytes);
286   void ParseTrustyIpcHandleEvent(uint32_t pid,
287                                  int64_t ts,
288                                  protozero::ConstBytes);
289   void ParseTrustyIpcConnect(uint32_t pid, int64_t ts, protozero::ConstBytes);
290   void ParseTrustyIpcConnectEnd(uint32_t pid,
291                                 int64_t ts,
292                                 protozero::ConstBytes);
293   void ParseTrustyIpcWrite(uint32_t pid, int64_t ts, protozero::ConstBytes);
294   void ParseTrustyIpcWriteEnd(uint32_t pid, int64_t ts, protozero::ConstBytes);
295   void ParseTrustyIpcRead(uint32_t pid, int64_t ts, protozero::ConstBytes);
296   void ParseTrustyIpcReadEnd(uint32_t pid, int64_t ts, protozero::ConstBytes);
297   void ParseTrustyIpcPoll(uint32_t pid, int64_t ts, protozero::ConstBytes);
298   void ParseTrustyIpcRx(uint32_t pid, int64_t ts, protozero::ConstBytes);
299   void ParseTrustyEnqueueNop(uint32_t pid, int64_t ts, protozero::ConstBytes);
300   void ParseAndroidFsDatareadEnd(int64_t timestamp, protozero::ConstBytes);
301   void ParseAndroidFsDatareadStart(int64_t ts,
302                                    uint32_t pid,
303                                    protozero::ConstBytes);
304   StringId GetRpmStatusStringId(int32_t rpm_status_val);
305   void ParseRpmStatus(int64_t ts, protozero::ConstBytes);
306   void ParseDevicePmCallbackStart(int64_t ts,
307                                   uint32_t cpu,
308                                   uint32_t pid,
309                                   protozero::ConstBytes);
310   void ParseDevicePmCallbackEnd(int64_t ts, protozero::ConstBytes);
311   void ParsePanelWriteGeneric(int64_t timestamp,
312                               uint32_t pid,
313                               protozero::ConstBytes);
314   void ParseGoogleIccEvent(int64_t timestamp, protozero::ConstBytes);
315   void ParseGoogleIrmEvent(int64_t timestamp, protozero::ConstBytes);
316   void ParseDeviceFrequency(int64_t ts, protozero::ConstBytes blob);
317   void ParseParamSetValueCpm(protozero::ConstBytes blob);
318   void ParseBlockIoStart(int64_t ts, protozero::ConstBytes blob);
319   void ParseBlockIoDone(int64_t ts, protozero::ConstBytes blob);
320   void ParseCpuhpEnter(uint32_t fld_id,
321                        int64_t ts,
322                        uint32_t cpu,
323                        protozero::ConstBytes blob);
324   void ParseCpuhpExit(int64_t ts, protozero::ConstBytes blob);
325 
326   TraceProcessorContext* context_;
327   RssStatTracker rss_stat_tracker_;
328   DrmTracker drm_tracker_;
329   IostatTracker iostat_tracker_;
330   VirtioGpuTracker virtio_gpu_tracker_;
331   MaliGpuEventTracker mali_gpu_event_tracker_;
332   PkvmHypervisorCpuTracker pkvm_hyp_cpu_tracker_;
333   GpuWorkPeriodTracker gpu_work_period_tracker_;
334   ThermalTracker thermal_tracker_;
335   PixelMmKswapdEventTracker pixel_mm_kswapd_event_tracker_;
336 
337   const StringId sched_wakeup_name_id_;
338   const StringId sched_waking_name_id_;
339   const StringId cpu_id_;
340   const StringId suspend_resume_minimal_slice_name_id_;
341   const StringId inode_arg_id_;
342   const StringId signal_generate_id_;
343   const StringId signal_deliver_id_;
344   const StringId lmk_id_;
345   const StringId comm_name_id_;
346   const StringId signal_name_id_;
347   const StringId oom_kill_id_;
348   const StringId workqueue_id_;
349   const StringId irq_id_;
350   const StringId tcp_state_id_;
351   const StringId tcp_event_id_;
352   const StringId protocol_arg_id_;
353   const StringId napi_gro_id_;
354   const StringId ret_arg_id_;
355   const StringId len_arg_id_;
356   const StringId direct_reclaim_nr_reclaimed_id_;
357   const StringId direct_reclaim_order_id_;
358   const StringId direct_reclaim_may_writepage_id_;
359   const StringId direct_reclaim_gfp_flags_id_;
360   const StringId vec_arg_id_;
361   const StringId io_wait_id_;
362   const StringId function_id_;
363   const StringId waker_utid_id_;
364   const StringId cros_ec_arg_num_id_;
365   const StringId cros_ec_arg_ec_id_;
366   const StringId cros_ec_arg_sample_ts_id_;
367   const StringId shrink_slab_id_;
368   const StringId shrink_name_id_;
369   const StringId shrink_total_scan_id_;
370   const StringId shrink_freed_id_;
371   const StringId shrink_priority_id_;
372   const StringId trusty_category_id_;
373   const StringId trusty_name_trusty_std_id_;
374   const StringId trusty_name_tipc_rx_id_;
375   const StringId cma_alloc_id_;
376   const StringId cma_name_id_;
377   const StringId cma_pfn_id_;
378   const StringId cma_req_pages_id_;
379   const StringId cma_nr_migrated_id_;
380   const StringId cma_nr_reclaimed_id_;
381   const StringId cma_nr_mapped_id_;
382   const StringId cma_nr_isolate_fail_id_;
383   const StringId cma_nr_migrate_fail_id_;
384   const StringId cma_nr_test_fail_id_;
385   const StringId syscall_ret_id_;
386   const StringId syscall_args_id_;
387   const StringId replica_slice_id_;
388   const StringId file_path_id_;
389   const StringId offset_id_start_;
390   const StringId offset_id_end_;
391   const StringId bytes_read_id_start_;
392   const StringId bytes_read_id_end_;
393   const StringId android_fs_data_read_id_;
394   const StringId google_icc_event_id_;
395   const StringId google_irm_event_id_;
396   const StringId runtime_status_invalid_id_;
397   const StringId runtime_status_active_id_;
398   const StringId runtime_status_suspending_id_;
399   const StringId runtime_status_resuming_id_;
400   const StringId suspend_resume_main_event_id_;
401   const StringId suspend_resume_device_pm_event_id_;
402   const StringId suspend_resume_utid_arg_name_;
403   const StringId suspend_resume_device_arg_name_;
404   const StringId suspend_resume_driver_arg_name_;
405   const StringId suspend_resume_callback_phase_arg_name_;
406   const StringId suspend_resume_event_type_arg_name_;
407   const StringId device_name_id_;
408   const StringId block_io_id_;
409   const StringId block_io_arg_sector_id_;
410   const StringId cpuhp_action_cpu_id_;
411   const StringId cpuhp_idx_id_;
412   const StringId disp_vblank_irq_enable_id_;
413   const StringId disp_vblank_irq_enable_output_id_arg_name_;
414 
415   std::vector<StringId> syscall_arg_name_ids_;
416 
417   struct FtraceMessageStrings {
418     // The string id of name of the event field (e.g. sched_switch's id).
419     StringId message_name_id = kNullStringId;
420     std::array<StringId, kMaxFtraceEventFields> field_name_ids;
421   };
422   std::vector<FtraceMessageStrings> ftrace_message_strings_;
423 
424   struct MmEventCounterNames {
425     MmEventCounterNames() = default;
MmEventCounterNamesMmEventCounterNames426     MmEventCounterNames(StringId _count, StringId _max_lat, StringId _avg_lat)
427         : count(_count), max_lat(_max_lat), avg_lat(_avg_lat) {}
428 
429     StringId count = kNullStringId;
430     StringId max_lat = kNullStringId;
431     StringId avg_lat = kNullStringId;
432   };
433 
434   // Keep kMmEventCounterSize equal to mm_event_type::MM_TYPE_NUM in the kernel.
435   static constexpr size_t kMmEventCounterSize = 7;
436   std::array<MmEventCounterNames, kMmEventCounterSize> mm_event_counter_names_;
437 
438   // Record number of received bytes from the network interface card.
439   std::unordered_map<std::string, uint64_t> nic_received_bytes_;
440 
441   // Record number of transmitted bytes to the network interface card.
442   std::unordered_map<std::string, uint64_t> nic_transmitted_bytes_;
443 
444   // Record number of kfree_skb with ip protocol.
445   uint64_t num_of_kfree_skb_ip_prot = 0;
446 
447   // Keep sock to stream number mapping.
448   std::unordered_map<uint64_t, uint32_t> skaddr_to_stream_;
449 
450   // Record number of tcp steams.
451   uint32_t num_of_tcp_stream_ = 0;
452 
453   // A name collision is possible, always show if active wakelock exists
454   // with a give name
455   std::unordered_map<std::string, uint32_t> active_wakelock_to_count_;
456 
457   // Tiny state machine for tracking the suspend_enter bug.
458   enum SuspendEnterBugState {
459     // Nothing special.
460     SUSPEND_STATE_INITIAL,
461     // We are inside a suspend_enter slice.
462     SUSPEND_STATE_ENTER,
463     // We are inside a suspend_enter slice and a freeze_processes slice.
464     SUSPEND_STATE_FREEZE
465   };
466 
467   SuspendEnterBugState suspend_state_ = SUSPEND_STATE_INITIAL;
468 
469   // cookie for the current suspend_enter slice if any; needed to close it.
470   int64_t suspend_enter_slice_cookie_ = 0;
471 
472   bool has_seen_first_ftrace_packet_ = false;
473 
474   // Ftrace events before this timestamp get dropped.
475   int64_t drop_ftrace_data_before_ts_ = 0;
476 
477   // Ftrace events before this timestamp get parsed into the |ftrace_events|
478   // table, but don't get propagated into other tables/trackers.
479   // Must be no less than drop_ftrace_data_before_ts_.
480   int64_t soft_drop_ftrace_data_before_ts_ = 0;
481 
482   // Does not skip any ftrace events.
483   bool preserve_ftrace_buffer_ = false;
484 
485   // Sequence ids for which ftrace_errors have been seen. Used to avoid
486   // putting them in the metadata multiple times (the ftrace data sources
487   // re-emits begin stats on every flush).
488   std::unordered_set<uint32_t> seen_errors_for_sequence_id_;
489 
490   // Tracks Linux devices with active runtime power management (RPM) status
491   // slices.
492   std::unordered_set<TrackId> active_rpm_tracks_;
493 
494   struct PairHash {
operatorPairHash495     std::size_t operator()(const std::pair<uint64_t, int64_t>& p) const {
496       base::Hasher hasher;
497       hasher.Update(p.first);
498       hasher.Update(p.second);
499       return static_cast<std::size_t>(hasher.digest());
500     }
501   };
502 
503   base::FlatHashMap<std::pair<uint64_t, int64_t>, uint32_t, PairHash>
504       inode_offset_thread_map_;
505 };
506 
507 }  // namespace perfetto::trace_processor
508 
509 #endif  // SRC_TRACE_PROCESSOR_IMPORTERS_FTRACE_FTRACE_PARSER_H_
510