1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/perf_trace_counters.proto
3 
4 #include "protos/perfetto/trace/ftrace/perf_trace_counters.pb.h"
5 
6 #include <algorithm>
7 #include <cstdint>
8 
9 #include <google/protobuf/io/coded_stream.h>
10 #include <google/protobuf/extension_set.h>
11 #include <google/protobuf/wire_format_lite.h>
12 #include <google/protobuf/io/zero_copy_stream_impl_lite.h>
13 // @@protoc_insertion_point(includes)
14 #include <google/protobuf/port_def.inc>
15 
16 PROTOBUF_PRAGMA_INIT_SEG
17 
18 namespace _pb = ::PROTOBUF_NAMESPACE_ID;
19 namespace _pbi = _pb::internal;
20 
21 namespace perfetto {
22 namespace protos {
SchedSwitchWithCtrsFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR SchedSwitchWithCtrsFtraceEvent::SchedSwitchWithCtrsFtraceEvent(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.prev_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
28   , /*decltype(_impl_.next_comm_)*/{&::_pbi::fixed_address_empty_string, ::_pbi::ConstantInitialized{}}
29   , /*decltype(_impl_.old_pid_)*/0
30   , /*decltype(_impl_.new_pid_)*/0
31   , /*decltype(_impl_.cctr_)*/::uint64_t{0u}
32   , /*decltype(_impl_.ctr0_)*/::uint64_t{0u}
33   , /*decltype(_impl_.ctr1_)*/::uint64_t{0u}
34   , /*decltype(_impl_.ctr2_)*/::uint64_t{0u}
35   , /*decltype(_impl_.ctr3_)*/::uint64_t{0u}
36   , /*decltype(_impl_.lctr0_)*/0u
37   , /*decltype(_impl_.lctr1_)*/0u
38   , /*decltype(_impl_.ctr4_)*/::uint64_t{0u}
39   , /*decltype(_impl_.ctr5_)*/::uint64_t{0u}
40   , /*decltype(_impl_.prev_pid_)*/0
41   , /*decltype(_impl_.cyc_)*/0u
42   , /*decltype(_impl_.inst_)*/0u
43   , /*decltype(_impl_.stallbm_)*/0u
44   , /*decltype(_impl_.l3dm_)*/0u
45   , /*decltype(_impl_.next_pid_)*/0
46   , /*decltype(_impl_.prev_state_)*/::int64_t{0}
47   , /*decltype(_impl_.amu0_)*/::uint64_t{0u}
48   , /*decltype(_impl_.amu1_)*/::uint64_t{0u}
49   , /*decltype(_impl_.amu2_)*/::uint64_t{0u}} {}
50 struct SchedSwitchWithCtrsFtraceEventDefaultTypeInternal {
SchedSwitchWithCtrsFtraceEventDefaultTypeInternalperfetto::protos::SchedSwitchWithCtrsFtraceEventDefaultTypeInternal51   PROTOBUF_CONSTEXPR SchedSwitchWithCtrsFtraceEventDefaultTypeInternal()
52       : _instance(::_pbi::ConstantInitialized{}) {}
~SchedSwitchWithCtrsFtraceEventDefaultTypeInternalperfetto::protos::SchedSwitchWithCtrsFtraceEventDefaultTypeInternal53   ~SchedSwitchWithCtrsFtraceEventDefaultTypeInternal() {}
54   union {  // NOLINT(misc-non-private-member-variables-in-classes)
55     SchedSwitchWithCtrsFtraceEvent _instance;
56   };
57 };
58 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SchedSwitchWithCtrsFtraceEventDefaultTypeInternal _SchedSwitchWithCtrsFtraceEvent_default_instance_;
59 }  // namespace protos
60 }  // namespace perfetto
61 namespace perfetto {
62 namespace protos {
63 
64 // ===================================================================
65 
66 class SchedSwitchWithCtrsFtraceEvent::_Internal {
67  public:
68   using HasBits = decltype(std::declval<SchedSwitchWithCtrsFtraceEvent>()._impl_._has_bits_);
set_has_old_pid(HasBits * has_bits)69   static void set_has_old_pid(HasBits* has_bits) {
70     (*has_bits)[0] |= 4u;
71   }
set_has_new_pid(HasBits * has_bits)72   static void set_has_new_pid(HasBits* has_bits) {
73     (*has_bits)[0] |= 8u;
74   }
set_has_cctr(HasBits * has_bits)75   static void set_has_cctr(HasBits* has_bits) {
76     (*has_bits)[0] |= 16u;
77   }
set_has_ctr0(HasBits * has_bits)78   static void set_has_ctr0(HasBits* has_bits) {
79     (*has_bits)[0] |= 32u;
80   }
set_has_ctr1(HasBits * has_bits)81   static void set_has_ctr1(HasBits* has_bits) {
82     (*has_bits)[0] |= 64u;
83   }
set_has_ctr2(HasBits * has_bits)84   static void set_has_ctr2(HasBits* has_bits) {
85     (*has_bits)[0] |= 128u;
86   }
set_has_ctr3(HasBits * has_bits)87   static void set_has_ctr3(HasBits* has_bits) {
88     (*has_bits)[0] |= 256u;
89   }
set_has_lctr0(HasBits * has_bits)90   static void set_has_lctr0(HasBits* has_bits) {
91     (*has_bits)[0] |= 512u;
92   }
set_has_lctr1(HasBits * has_bits)93   static void set_has_lctr1(HasBits* has_bits) {
94     (*has_bits)[0] |= 1024u;
95   }
set_has_ctr4(HasBits * has_bits)96   static void set_has_ctr4(HasBits* has_bits) {
97     (*has_bits)[0] |= 2048u;
98   }
set_has_ctr5(HasBits * has_bits)99   static void set_has_ctr5(HasBits* has_bits) {
100     (*has_bits)[0] |= 4096u;
101   }
set_has_prev_comm(HasBits * has_bits)102   static void set_has_prev_comm(HasBits* has_bits) {
103     (*has_bits)[0] |= 1u;
104   }
set_has_prev_pid(HasBits * has_bits)105   static void set_has_prev_pid(HasBits* has_bits) {
106     (*has_bits)[0] |= 8192u;
107   }
set_has_cyc(HasBits * has_bits)108   static void set_has_cyc(HasBits* has_bits) {
109     (*has_bits)[0] |= 16384u;
110   }
set_has_inst(HasBits * has_bits)111   static void set_has_inst(HasBits* has_bits) {
112     (*has_bits)[0] |= 32768u;
113   }
set_has_stallbm(HasBits * has_bits)114   static void set_has_stallbm(HasBits* has_bits) {
115     (*has_bits)[0] |= 65536u;
116   }
set_has_l3dm(HasBits * has_bits)117   static void set_has_l3dm(HasBits* has_bits) {
118     (*has_bits)[0] |= 131072u;
119   }
set_has_next_pid(HasBits * has_bits)120   static void set_has_next_pid(HasBits* has_bits) {
121     (*has_bits)[0] |= 262144u;
122   }
set_has_next_comm(HasBits * has_bits)123   static void set_has_next_comm(HasBits* has_bits) {
124     (*has_bits)[0] |= 2u;
125   }
set_has_prev_state(HasBits * has_bits)126   static void set_has_prev_state(HasBits* has_bits) {
127     (*has_bits)[0] |= 524288u;
128   }
set_has_amu0(HasBits * has_bits)129   static void set_has_amu0(HasBits* has_bits) {
130     (*has_bits)[0] |= 1048576u;
131   }
set_has_amu1(HasBits * has_bits)132   static void set_has_amu1(HasBits* has_bits) {
133     (*has_bits)[0] |= 2097152u;
134   }
set_has_amu2(HasBits * has_bits)135   static void set_has_amu2(HasBits* has_bits) {
136     (*has_bits)[0] |= 4194304u;
137   }
138 };
139 
SchedSwitchWithCtrsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)140 SchedSwitchWithCtrsFtraceEvent::SchedSwitchWithCtrsFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
141                          bool is_message_owned)
142   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
143   SharedCtor(arena, is_message_owned);
144   // @@protoc_insertion_point(arena_constructor:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
145 }
SchedSwitchWithCtrsFtraceEvent(const SchedSwitchWithCtrsFtraceEvent & from)146 SchedSwitchWithCtrsFtraceEvent::SchedSwitchWithCtrsFtraceEvent(const SchedSwitchWithCtrsFtraceEvent& from)
147   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
148   SchedSwitchWithCtrsFtraceEvent* const _this = this; (void)_this;
149   new (&_impl_) Impl_{
150       decltype(_impl_._has_bits_){from._impl_._has_bits_}
151     , /*decltype(_impl_._cached_size_)*/{}
152     , decltype(_impl_.prev_comm_){}
153     , decltype(_impl_.next_comm_){}
154     , decltype(_impl_.old_pid_){}
155     , decltype(_impl_.new_pid_){}
156     , decltype(_impl_.cctr_){}
157     , decltype(_impl_.ctr0_){}
158     , decltype(_impl_.ctr1_){}
159     , decltype(_impl_.ctr2_){}
160     , decltype(_impl_.ctr3_){}
161     , decltype(_impl_.lctr0_){}
162     , decltype(_impl_.lctr1_){}
163     , decltype(_impl_.ctr4_){}
164     , decltype(_impl_.ctr5_){}
165     , decltype(_impl_.prev_pid_){}
166     , decltype(_impl_.cyc_){}
167     , decltype(_impl_.inst_){}
168     , decltype(_impl_.stallbm_){}
169     , decltype(_impl_.l3dm_){}
170     , decltype(_impl_.next_pid_){}
171     , decltype(_impl_.prev_state_){}
172     , decltype(_impl_.amu0_){}
173     , decltype(_impl_.amu1_){}
174     , decltype(_impl_.amu2_){}};
175 
176   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
177   _impl_.prev_comm_.InitDefault();
178   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
179     _impl_.prev_comm_.Set("", GetArenaForAllocation());
180   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
181   if (from._internal_has_prev_comm()) {
182     _this->_impl_.prev_comm_.Set(from._internal_prev_comm(),
183       _this->GetArenaForAllocation());
184   }
185   _impl_.next_comm_.InitDefault();
186   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
187     _impl_.next_comm_.Set("", GetArenaForAllocation());
188   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
189   if (from._internal_has_next_comm()) {
190     _this->_impl_.next_comm_.Set(from._internal_next_comm(),
191       _this->GetArenaForAllocation());
192   }
193   ::memcpy(&_impl_.old_pid_, &from._impl_.old_pid_,
194     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.amu2_) -
195     reinterpret_cast<char*>(&_impl_.old_pid_)) + sizeof(_impl_.amu2_));
196   // @@protoc_insertion_point(copy_constructor:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
197 }
198 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)199 inline void SchedSwitchWithCtrsFtraceEvent::SharedCtor(
200     ::_pb::Arena* arena, bool is_message_owned) {
201   (void)arena;
202   (void)is_message_owned;
203   new (&_impl_) Impl_{
204       decltype(_impl_._has_bits_){}
205     , /*decltype(_impl_._cached_size_)*/{}
206     , decltype(_impl_.prev_comm_){}
207     , decltype(_impl_.next_comm_){}
208     , decltype(_impl_.old_pid_){0}
209     , decltype(_impl_.new_pid_){0}
210     , decltype(_impl_.cctr_){::uint64_t{0u}}
211     , decltype(_impl_.ctr0_){::uint64_t{0u}}
212     , decltype(_impl_.ctr1_){::uint64_t{0u}}
213     , decltype(_impl_.ctr2_){::uint64_t{0u}}
214     , decltype(_impl_.ctr3_){::uint64_t{0u}}
215     , decltype(_impl_.lctr0_){0u}
216     , decltype(_impl_.lctr1_){0u}
217     , decltype(_impl_.ctr4_){::uint64_t{0u}}
218     , decltype(_impl_.ctr5_){::uint64_t{0u}}
219     , decltype(_impl_.prev_pid_){0}
220     , decltype(_impl_.cyc_){0u}
221     , decltype(_impl_.inst_){0u}
222     , decltype(_impl_.stallbm_){0u}
223     , decltype(_impl_.l3dm_){0u}
224     , decltype(_impl_.next_pid_){0}
225     , decltype(_impl_.prev_state_){::int64_t{0}}
226     , decltype(_impl_.amu0_){::uint64_t{0u}}
227     , decltype(_impl_.amu1_){::uint64_t{0u}}
228     , decltype(_impl_.amu2_){::uint64_t{0u}}
229   };
230   _impl_.prev_comm_.InitDefault();
231   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
232     _impl_.prev_comm_.Set("", GetArenaForAllocation());
233   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
234   _impl_.next_comm_.InitDefault();
235   #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
236     _impl_.next_comm_.Set("", GetArenaForAllocation());
237   #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
238 }
239 
~SchedSwitchWithCtrsFtraceEvent()240 SchedSwitchWithCtrsFtraceEvent::~SchedSwitchWithCtrsFtraceEvent() {
241   // @@protoc_insertion_point(destructor:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
242   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
243   (void)arena;
244     return;
245   }
246   SharedDtor();
247 }
248 
SharedDtor()249 inline void SchedSwitchWithCtrsFtraceEvent::SharedDtor() {
250   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
251   _impl_.prev_comm_.Destroy();
252   _impl_.next_comm_.Destroy();
253 }
254 
SetCachedSize(int size) const255 void SchedSwitchWithCtrsFtraceEvent::SetCachedSize(int size) const {
256   _impl_._cached_size_.Set(size);
257 }
258 
Clear()259 void SchedSwitchWithCtrsFtraceEvent::Clear() {
260 // @@protoc_insertion_point(message_clear_start:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
261   ::uint32_t cached_has_bits = 0;
262   // Prevent compiler warnings about cached_has_bits being unused
263   (void) cached_has_bits;
264 
265   cached_has_bits = _impl_._has_bits_[0];
266   if (cached_has_bits & 0x00000003u) {
267     if (cached_has_bits & 0x00000001u) {
268       _impl_.prev_comm_.ClearNonDefaultToEmpty();
269     }
270     if (cached_has_bits & 0x00000002u) {
271       _impl_.next_comm_.ClearNonDefaultToEmpty();
272     }
273   }
274   if (cached_has_bits & 0x000000fcu) {
275     ::memset(&_impl_.old_pid_, 0, static_cast<size_t>(
276         reinterpret_cast<char*>(&_impl_.ctr2_) -
277         reinterpret_cast<char*>(&_impl_.old_pid_)) + sizeof(_impl_.ctr2_));
278   }
279   if (cached_has_bits & 0x0000ff00u) {
280     ::memset(&_impl_.ctr3_, 0, static_cast<size_t>(
281         reinterpret_cast<char*>(&_impl_.inst_) -
282         reinterpret_cast<char*>(&_impl_.ctr3_)) + sizeof(_impl_.inst_));
283   }
284   if (cached_has_bits & 0x007f0000u) {
285     ::memset(&_impl_.stallbm_, 0, static_cast<size_t>(
286         reinterpret_cast<char*>(&_impl_.amu2_) -
287         reinterpret_cast<char*>(&_impl_.stallbm_)) + sizeof(_impl_.amu2_));
288   }
289   _impl_._has_bits_.Clear();
290   _internal_metadata_.Clear<std::string>();
291 }
292 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)293 const char* SchedSwitchWithCtrsFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
294 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
295   _Internal::HasBits has_bits{};
296   while (!ctx->Done(&ptr)) {
297     ::uint32_t tag;
298     ptr = ::_pbi::ReadTag(ptr, &tag);
299     switch (tag >> 3) {
300       // optional int32 old_pid = 1;
301       case 1:
302         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
303           _Internal::set_has_old_pid(&has_bits);
304           _impl_.old_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
305           CHK_(ptr);
306         } else {
307           goto handle_unusual;
308         }
309         continue;
310       // optional int32 new_pid = 2;
311       case 2:
312         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
313           _Internal::set_has_new_pid(&has_bits);
314           _impl_.new_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
315           CHK_(ptr);
316         } else {
317           goto handle_unusual;
318         }
319         continue;
320       // optional uint64 cctr = 3;
321       case 3:
322         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
323           _Internal::set_has_cctr(&has_bits);
324           _impl_.cctr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
325           CHK_(ptr);
326         } else {
327           goto handle_unusual;
328         }
329         continue;
330       // optional uint64 ctr0 = 4;
331       case 4:
332         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
333           _Internal::set_has_ctr0(&has_bits);
334           _impl_.ctr0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
335           CHK_(ptr);
336         } else {
337           goto handle_unusual;
338         }
339         continue;
340       // optional uint64 ctr1 = 5;
341       case 5:
342         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
343           _Internal::set_has_ctr1(&has_bits);
344           _impl_.ctr1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
345           CHK_(ptr);
346         } else {
347           goto handle_unusual;
348         }
349         continue;
350       // optional uint64 ctr2 = 6;
351       case 6:
352         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
353           _Internal::set_has_ctr2(&has_bits);
354           _impl_.ctr2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
355           CHK_(ptr);
356         } else {
357           goto handle_unusual;
358         }
359         continue;
360       // optional uint64 ctr3 = 7;
361       case 7:
362         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
363           _Internal::set_has_ctr3(&has_bits);
364           _impl_.ctr3_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
365           CHK_(ptr);
366         } else {
367           goto handle_unusual;
368         }
369         continue;
370       // optional uint32 lctr0 = 8;
371       case 8:
372         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
373           _Internal::set_has_lctr0(&has_bits);
374           _impl_.lctr0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
375           CHK_(ptr);
376         } else {
377           goto handle_unusual;
378         }
379         continue;
380       // optional uint32 lctr1 = 9;
381       case 9:
382         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
383           _Internal::set_has_lctr1(&has_bits);
384           _impl_.lctr1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
385           CHK_(ptr);
386         } else {
387           goto handle_unusual;
388         }
389         continue;
390       // optional uint64 ctr4 = 10;
391       case 10:
392         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
393           _Internal::set_has_ctr4(&has_bits);
394           _impl_.ctr4_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
395           CHK_(ptr);
396         } else {
397           goto handle_unusual;
398         }
399         continue;
400       // optional uint64 ctr5 = 11;
401       case 11:
402         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
403           _Internal::set_has_ctr5(&has_bits);
404           _impl_.ctr5_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
405           CHK_(ptr);
406         } else {
407           goto handle_unusual;
408         }
409         continue;
410       // optional string prev_comm = 12;
411       case 12:
412         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 98)) {
413           auto str = _internal_mutable_prev_comm();
414           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
415           CHK_(ptr);
416         } else {
417           goto handle_unusual;
418         }
419         continue;
420       // optional int32 prev_pid = 13;
421       case 13:
422         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
423           _Internal::set_has_prev_pid(&has_bits);
424           _impl_.prev_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
425           CHK_(ptr);
426         } else {
427           goto handle_unusual;
428         }
429         continue;
430       // optional uint32 cyc = 14;
431       case 14:
432         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
433           _Internal::set_has_cyc(&has_bits);
434           _impl_.cyc_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
435           CHK_(ptr);
436         } else {
437           goto handle_unusual;
438         }
439         continue;
440       // optional uint32 inst = 15;
441       case 15:
442         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
443           _Internal::set_has_inst(&has_bits);
444           _impl_.inst_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
445           CHK_(ptr);
446         } else {
447           goto handle_unusual;
448         }
449         continue;
450       // optional uint32 stallbm = 16;
451       case 16:
452         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
453           _Internal::set_has_stallbm(&has_bits);
454           _impl_.stallbm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
455           CHK_(ptr);
456         } else {
457           goto handle_unusual;
458         }
459         continue;
460       // optional uint32 l3dm = 17;
461       case 17:
462         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 136)) {
463           _Internal::set_has_l3dm(&has_bits);
464           _impl_.l3dm_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
465           CHK_(ptr);
466         } else {
467           goto handle_unusual;
468         }
469         continue;
470       // optional int32 next_pid = 18;
471       case 18:
472         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 144)) {
473           _Internal::set_has_next_pid(&has_bits);
474           _impl_.next_pid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
475           CHK_(ptr);
476         } else {
477           goto handle_unusual;
478         }
479         continue;
480       // optional string next_comm = 19;
481       case 19:
482         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 154)) {
483           auto str = _internal_mutable_next_comm();
484           ptr = ::_pbi::InlineGreedyStringParser(str, ptr, ctx);
485           CHK_(ptr);
486         } else {
487           goto handle_unusual;
488         }
489         continue;
490       // optional int64 prev_state = 20;
491       case 20:
492         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 160)) {
493           _Internal::set_has_prev_state(&has_bits);
494           _impl_.prev_state_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
495           CHK_(ptr);
496         } else {
497           goto handle_unusual;
498         }
499         continue;
500       // optional uint64 amu0 = 21;
501       case 21:
502         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 168)) {
503           _Internal::set_has_amu0(&has_bits);
504           _impl_.amu0_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
505           CHK_(ptr);
506         } else {
507           goto handle_unusual;
508         }
509         continue;
510       // optional uint64 amu1 = 22;
511       case 22:
512         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 176)) {
513           _Internal::set_has_amu1(&has_bits);
514           _impl_.amu1_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
515           CHK_(ptr);
516         } else {
517           goto handle_unusual;
518         }
519         continue;
520       // optional uint64 amu2 = 23;
521       case 23:
522         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 184)) {
523           _Internal::set_has_amu2(&has_bits);
524           _impl_.amu2_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
525           CHK_(ptr);
526         } else {
527           goto handle_unusual;
528         }
529         continue;
530       default:
531         goto handle_unusual;
532     }  // switch
533   handle_unusual:
534     if ((tag == 0) || ((tag & 7) == 4)) {
535       CHK_(ptr);
536       ctx->SetLastTag(tag);
537       goto message_done;
538     }
539     ptr = UnknownFieldParse(
540         tag,
541         _internal_metadata_.mutable_unknown_fields<std::string>(),
542         ptr, ctx);
543     CHK_(ptr != nullptr);
544   }  // while
545 message_done:
546   _impl_._has_bits_.Or(has_bits);
547   return ptr;
548 failure:
549   ptr = nullptr;
550   goto message_done;
551 #undef CHK_
552 }
553 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const554 ::uint8_t* SchedSwitchWithCtrsFtraceEvent::_InternalSerialize(
555     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
556   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
557   ::uint32_t cached_has_bits = 0;
558   (void) cached_has_bits;
559 
560   cached_has_bits = _impl_._has_bits_[0];
561   // optional int32 old_pid = 1;
562   if (cached_has_bits & 0x00000004u) {
563     target = stream->EnsureSpace(target);
564     target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_old_pid(), target);
565   }
566 
567   // optional int32 new_pid = 2;
568   if (cached_has_bits & 0x00000008u) {
569     target = stream->EnsureSpace(target);
570     target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_new_pid(), target);
571   }
572 
573   // optional uint64 cctr = 3;
574   if (cached_has_bits & 0x00000010u) {
575     target = stream->EnsureSpace(target);
576     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_cctr(), target);
577   }
578 
579   // optional uint64 ctr0 = 4;
580   if (cached_has_bits & 0x00000020u) {
581     target = stream->EnsureSpace(target);
582     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_ctr0(), target);
583   }
584 
585   // optional uint64 ctr1 = 5;
586   if (cached_has_bits & 0x00000040u) {
587     target = stream->EnsureSpace(target);
588     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_ctr1(), target);
589   }
590 
591   // optional uint64 ctr2 = 6;
592   if (cached_has_bits & 0x00000080u) {
593     target = stream->EnsureSpace(target);
594     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_ctr2(), target);
595   }
596 
597   // optional uint64 ctr3 = 7;
598   if (cached_has_bits & 0x00000100u) {
599     target = stream->EnsureSpace(target);
600     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_ctr3(), target);
601   }
602 
603   // optional uint32 lctr0 = 8;
604   if (cached_has_bits & 0x00000200u) {
605     target = stream->EnsureSpace(target);
606     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(8, this->_internal_lctr0(), target);
607   }
608 
609   // optional uint32 lctr1 = 9;
610   if (cached_has_bits & 0x00000400u) {
611     target = stream->EnsureSpace(target);
612     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_lctr1(), target);
613   }
614 
615   // optional uint64 ctr4 = 10;
616   if (cached_has_bits & 0x00000800u) {
617     target = stream->EnsureSpace(target);
618     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(10, this->_internal_ctr4(), target);
619   }
620 
621   // optional uint64 ctr5 = 11;
622   if (cached_has_bits & 0x00001000u) {
623     target = stream->EnsureSpace(target);
624     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(11, this->_internal_ctr5(), target);
625   }
626 
627   // optional string prev_comm = 12;
628   if (cached_has_bits & 0x00000001u) {
629     target = stream->WriteStringMaybeAliased(
630         12, this->_internal_prev_comm(), target);
631   }
632 
633   // optional int32 prev_pid = 13;
634   if (cached_has_bits & 0x00002000u) {
635     target = stream->EnsureSpace(target);
636     target = ::_pbi::WireFormatLite::WriteInt32ToArray(13, this->_internal_prev_pid(), target);
637   }
638 
639   // optional uint32 cyc = 14;
640   if (cached_has_bits & 0x00004000u) {
641     target = stream->EnsureSpace(target);
642     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(14, this->_internal_cyc(), target);
643   }
644 
645   // optional uint32 inst = 15;
646   if (cached_has_bits & 0x00008000u) {
647     target = stream->EnsureSpace(target);
648     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(15, this->_internal_inst(), target);
649   }
650 
651   // optional uint32 stallbm = 16;
652   if (cached_has_bits & 0x00010000u) {
653     target = stream->EnsureSpace(target);
654     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(16, this->_internal_stallbm(), target);
655   }
656 
657   // optional uint32 l3dm = 17;
658   if (cached_has_bits & 0x00020000u) {
659     target = stream->EnsureSpace(target);
660     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(17, this->_internal_l3dm(), target);
661   }
662 
663   // optional int32 next_pid = 18;
664   if (cached_has_bits & 0x00040000u) {
665     target = stream->EnsureSpace(target);
666     target = ::_pbi::WireFormatLite::WriteInt32ToArray(18, this->_internal_next_pid(), target);
667   }
668 
669   // optional string next_comm = 19;
670   if (cached_has_bits & 0x00000002u) {
671     target = stream->WriteStringMaybeAliased(
672         19, this->_internal_next_comm(), target);
673   }
674 
675   // optional int64 prev_state = 20;
676   if (cached_has_bits & 0x00080000u) {
677     target = stream->EnsureSpace(target);
678     target = ::_pbi::WireFormatLite::WriteInt64ToArray(20, this->_internal_prev_state(), target);
679   }
680 
681   // optional uint64 amu0 = 21;
682   if (cached_has_bits & 0x00100000u) {
683     target = stream->EnsureSpace(target);
684     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(21, this->_internal_amu0(), target);
685   }
686 
687   // optional uint64 amu1 = 22;
688   if (cached_has_bits & 0x00200000u) {
689     target = stream->EnsureSpace(target);
690     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(22, this->_internal_amu1(), target);
691   }
692 
693   // optional uint64 amu2 = 23;
694   if (cached_has_bits & 0x00400000u) {
695     target = stream->EnsureSpace(target);
696     target = ::_pbi::WireFormatLite::WriteUInt64ToArray(23, this->_internal_amu2(), target);
697   }
698 
699   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
700     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
701         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
702   }
703   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
704   return target;
705 }
706 
ByteSizeLong() const707 size_t SchedSwitchWithCtrsFtraceEvent::ByteSizeLong() const {
708 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
709   size_t total_size = 0;
710 
711   ::uint32_t cached_has_bits = 0;
712   // Prevent compiler warnings about cached_has_bits being unused
713   (void) cached_has_bits;
714 
715   cached_has_bits = _impl_._has_bits_[0];
716   if (cached_has_bits & 0x000000ffu) {
717     // optional string prev_comm = 12;
718     if (cached_has_bits & 0x00000001u) {
719       total_size += 1 +
720         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
721           this->_internal_prev_comm());
722     }
723 
724     // optional string next_comm = 19;
725     if (cached_has_bits & 0x00000002u) {
726       total_size += 2 +
727         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
728           this->_internal_next_comm());
729     }
730 
731     // optional int32 old_pid = 1;
732     if (cached_has_bits & 0x00000004u) {
733       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_old_pid());
734     }
735 
736     // optional int32 new_pid = 2;
737     if (cached_has_bits & 0x00000008u) {
738       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_new_pid());
739     }
740 
741     // optional uint64 cctr = 3;
742     if (cached_has_bits & 0x00000010u) {
743       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cctr());
744     }
745 
746     // optional uint64 ctr0 = 4;
747     if (cached_has_bits & 0x00000020u) {
748       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr0());
749     }
750 
751     // optional uint64 ctr1 = 5;
752     if (cached_has_bits & 0x00000040u) {
753       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr1());
754     }
755 
756     // optional uint64 ctr2 = 6;
757     if (cached_has_bits & 0x00000080u) {
758       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr2());
759     }
760 
761   }
762   if (cached_has_bits & 0x0000ff00u) {
763     // optional uint64 ctr3 = 7;
764     if (cached_has_bits & 0x00000100u) {
765       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr3());
766     }
767 
768     // optional uint32 lctr0 = 8;
769     if (cached_has_bits & 0x00000200u) {
770       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lctr0());
771     }
772 
773     // optional uint32 lctr1 = 9;
774     if (cached_has_bits & 0x00000400u) {
775       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_lctr1());
776     }
777 
778     // optional uint64 ctr4 = 10;
779     if (cached_has_bits & 0x00000800u) {
780       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr4());
781     }
782 
783     // optional uint64 ctr5 = 11;
784     if (cached_has_bits & 0x00001000u) {
785       total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ctr5());
786     }
787 
788     // optional int32 prev_pid = 13;
789     if (cached_has_bits & 0x00002000u) {
790       total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prev_pid());
791     }
792 
793     // optional uint32 cyc = 14;
794     if (cached_has_bits & 0x00004000u) {
795       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_cyc());
796     }
797 
798     // optional uint32 inst = 15;
799     if (cached_has_bits & 0x00008000u) {
800       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_inst());
801     }
802 
803   }
804   if (cached_has_bits & 0x007f0000u) {
805     // optional uint32 stallbm = 16;
806     if (cached_has_bits & 0x00010000u) {
807       total_size += 2 +
808         ::_pbi::WireFormatLite::UInt32Size(
809           this->_internal_stallbm());
810     }
811 
812     // optional uint32 l3dm = 17;
813     if (cached_has_bits & 0x00020000u) {
814       total_size += 2 +
815         ::_pbi::WireFormatLite::UInt32Size(
816           this->_internal_l3dm());
817     }
818 
819     // optional int32 next_pid = 18;
820     if (cached_has_bits & 0x00040000u) {
821       total_size += 2 +
822         ::_pbi::WireFormatLite::Int32Size(
823           this->_internal_next_pid());
824     }
825 
826     // optional int64 prev_state = 20;
827     if (cached_has_bits & 0x00080000u) {
828       total_size += 2 +
829         ::_pbi::WireFormatLite::Int64Size(
830           this->_internal_prev_state());
831     }
832 
833     // optional uint64 amu0 = 21;
834     if (cached_has_bits & 0x00100000u) {
835       total_size += 2 +
836         ::_pbi::WireFormatLite::UInt64Size(
837           this->_internal_amu0());
838     }
839 
840     // optional uint64 amu1 = 22;
841     if (cached_has_bits & 0x00200000u) {
842       total_size += 2 +
843         ::_pbi::WireFormatLite::UInt64Size(
844           this->_internal_amu1());
845     }
846 
847     // optional uint64 amu2 = 23;
848     if (cached_has_bits & 0x00400000u) {
849       total_size += 2 +
850         ::_pbi::WireFormatLite::UInt64Size(
851           this->_internal_amu2());
852     }
853 
854   }
855   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
856     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
857   }
858   int cached_size = ::_pbi::ToCachedSize(total_size);
859   SetCachedSize(cached_size);
860   return total_size;
861 }
862 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)863 void SchedSwitchWithCtrsFtraceEvent::CheckTypeAndMergeFrom(
864     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
865   MergeFrom(*::_pbi::DownCast<const SchedSwitchWithCtrsFtraceEvent*>(
866       &from));
867 }
868 
MergeFrom(const SchedSwitchWithCtrsFtraceEvent & from)869 void SchedSwitchWithCtrsFtraceEvent::MergeFrom(const SchedSwitchWithCtrsFtraceEvent& from) {
870   SchedSwitchWithCtrsFtraceEvent* const _this = this;
871   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
872   GOOGLE_DCHECK_NE(&from, _this);
873   ::uint32_t cached_has_bits = 0;
874   (void) cached_has_bits;
875 
876   cached_has_bits = from._impl_._has_bits_[0];
877   if (cached_has_bits & 0x000000ffu) {
878     if (cached_has_bits & 0x00000001u) {
879       _this->_internal_set_prev_comm(from._internal_prev_comm());
880     }
881     if (cached_has_bits & 0x00000002u) {
882       _this->_internal_set_next_comm(from._internal_next_comm());
883     }
884     if (cached_has_bits & 0x00000004u) {
885       _this->_impl_.old_pid_ = from._impl_.old_pid_;
886     }
887     if (cached_has_bits & 0x00000008u) {
888       _this->_impl_.new_pid_ = from._impl_.new_pid_;
889     }
890     if (cached_has_bits & 0x00000010u) {
891       _this->_impl_.cctr_ = from._impl_.cctr_;
892     }
893     if (cached_has_bits & 0x00000020u) {
894       _this->_impl_.ctr0_ = from._impl_.ctr0_;
895     }
896     if (cached_has_bits & 0x00000040u) {
897       _this->_impl_.ctr1_ = from._impl_.ctr1_;
898     }
899     if (cached_has_bits & 0x00000080u) {
900       _this->_impl_.ctr2_ = from._impl_.ctr2_;
901     }
902     _this->_impl_._has_bits_[0] |= cached_has_bits;
903   }
904   if (cached_has_bits & 0x0000ff00u) {
905     if (cached_has_bits & 0x00000100u) {
906       _this->_impl_.ctr3_ = from._impl_.ctr3_;
907     }
908     if (cached_has_bits & 0x00000200u) {
909       _this->_impl_.lctr0_ = from._impl_.lctr0_;
910     }
911     if (cached_has_bits & 0x00000400u) {
912       _this->_impl_.lctr1_ = from._impl_.lctr1_;
913     }
914     if (cached_has_bits & 0x00000800u) {
915       _this->_impl_.ctr4_ = from._impl_.ctr4_;
916     }
917     if (cached_has_bits & 0x00001000u) {
918       _this->_impl_.ctr5_ = from._impl_.ctr5_;
919     }
920     if (cached_has_bits & 0x00002000u) {
921       _this->_impl_.prev_pid_ = from._impl_.prev_pid_;
922     }
923     if (cached_has_bits & 0x00004000u) {
924       _this->_impl_.cyc_ = from._impl_.cyc_;
925     }
926     if (cached_has_bits & 0x00008000u) {
927       _this->_impl_.inst_ = from._impl_.inst_;
928     }
929     _this->_impl_._has_bits_[0] |= cached_has_bits;
930   }
931   if (cached_has_bits & 0x007f0000u) {
932     if (cached_has_bits & 0x00010000u) {
933       _this->_impl_.stallbm_ = from._impl_.stallbm_;
934     }
935     if (cached_has_bits & 0x00020000u) {
936       _this->_impl_.l3dm_ = from._impl_.l3dm_;
937     }
938     if (cached_has_bits & 0x00040000u) {
939       _this->_impl_.next_pid_ = from._impl_.next_pid_;
940     }
941     if (cached_has_bits & 0x00080000u) {
942       _this->_impl_.prev_state_ = from._impl_.prev_state_;
943     }
944     if (cached_has_bits & 0x00100000u) {
945       _this->_impl_.amu0_ = from._impl_.amu0_;
946     }
947     if (cached_has_bits & 0x00200000u) {
948       _this->_impl_.amu1_ = from._impl_.amu1_;
949     }
950     if (cached_has_bits & 0x00400000u) {
951       _this->_impl_.amu2_ = from._impl_.amu2_;
952     }
953     _this->_impl_._has_bits_[0] |= cached_has_bits;
954   }
955   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
956 }
957 
CopyFrom(const SchedSwitchWithCtrsFtraceEvent & from)958 void SchedSwitchWithCtrsFtraceEvent::CopyFrom(const SchedSwitchWithCtrsFtraceEvent& from) {
959 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.SchedSwitchWithCtrsFtraceEvent)
960   if (&from == this) return;
961   Clear();
962   MergeFrom(from);
963 }
964 
IsInitialized() const965 bool SchedSwitchWithCtrsFtraceEvent::IsInitialized() const {
966   return true;
967 }
968 
InternalSwap(SchedSwitchWithCtrsFtraceEvent * other)969 void SchedSwitchWithCtrsFtraceEvent::InternalSwap(SchedSwitchWithCtrsFtraceEvent* other) {
970   using std::swap;
971   auto* lhs_arena = GetArenaForAllocation();
972   auto* rhs_arena = other->GetArenaForAllocation();
973   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
974   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
975   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
976       &_impl_.prev_comm_, lhs_arena,
977       &other->_impl_.prev_comm_, rhs_arena
978   );
979   ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
980       &_impl_.next_comm_, lhs_arena,
981       &other->_impl_.next_comm_, rhs_arena
982   );
983   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
984       PROTOBUF_FIELD_OFFSET(SchedSwitchWithCtrsFtraceEvent, _impl_.amu2_)
985       + sizeof(SchedSwitchWithCtrsFtraceEvent::_impl_.amu2_)  // NOLINT
986       - PROTOBUF_FIELD_OFFSET(SchedSwitchWithCtrsFtraceEvent, _impl_.old_pid_)>(
987           reinterpret_cast<char*>(&_impl_.old_pid_),
988           reinterpret_cast<char*>(&other->_impl_.old_pid_));
989 }
990 
GetTypeName() const991 std::string SchedSwitchWithCtrsFtraceEvent::GetTypeName() const {
992   return "perfetto.protos.SchedSwitchWithCtrsFtraceEvent";
993 }
994 
995 
996 // @@protoc_insertion_point(namespace_scope)
997 }  // namespace protos
998 }  // namespace perfetto
999 PROTOBUF_NAMESPACE_OPEN
1000 template<> PROTOBUF_NOINLINE ::perfetto::protos::SchedSwitchWithCtrsFtraceEvent*
CreateMaybeMessage(Arena * arena)1001 Arena::CreateMaybeMessage< ::perfetto::protos::SchedSwitchWithCtrsFtraceEvent >(Arena* arena) {
1002   return Arena::CreateMessageInternal< ::perfetto::protos::SchedSwitchWithCtrsFtraceEvent >(arena);
1003 }
1004 PROTOBUF_NAMESPACE_CLOSE
1005 
1006 // @@protoc_insertion_point(global_scope)
1007 #include <google/protobuf/port_undef.inc>
1008