1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/kgsl.proto
3
4 #include "protos/perfetto/trace/ftrace/kgsl.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 {
KgslGpuFrequencyFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR KgslGpuFrequencyFtraceEvent::KgslGpuFrequencyFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.gpu_freq_)*/0u
28 , /*decltype(_impl_.gpu_id_)*/0u} {}
29 struct KgslGpuFrequencyFtraceEventDefaultTypeInternal {
KgslGpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::KgslGpuFrequencyFtraceEventDefaultTypeInternal30 PROTOBUF_CONSTEXPR KgslGpuFrequencyFtraceEventDefaultTypeInternal()
31 : _instance(::_pbi::ConstantInitialized{}) {}
~KgslGpuFrequencyFtraceEventDefaultTypeInternalperfetto::protos::KgslGpuFrequencyFtraceEventDefaultTypeInternal32 ~KgslGpuFrequencyFtraceEventDefaultTypeInternal() {}
33 union { // NOLINT(misc-non-private-member-variables-in-classes)
34 KgslGpuFrequencyFtraceEvent _instance;
35 };
36 };
37 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KgslGpuFrequencyFtraceEventDefaultTypeInternal _KgslGpuFrequencyFtraceEvent_default_instance_;
KgslAdrenoCmdbatchQueuedFtraceEvent(::_pbi::ConstantInitialized)38 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchQueuedFtraceEvent::KgslAdrenoCmdbatchQueuedFtraceEvent(
39 ::_pbi::ConstantInitialized): _impl_{
40 /*decltype(_impl_._has_bits_)*/{}
41 , /*decltype(_impl_._cached_size_)*/{}
42 , /*decltype(_impl_.id_)*/0u
43 , /*decltype(_impl_.timestamp_)*/0u
44 , /*decltype(_impl_.queued_)*/0u
45 , /*decltype(_impl_.flags_)*/0u
46 , /*decltype(_impl_.prio_)*/0u} {}
47 struct KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal {
KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal48 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal()
49 : _instance(::_pbi::ConstantInitialized{}) {}
~KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal50 ~KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal() {}
51 union { // NOLINT(misc-non-private-member-variables-in-classes)
52 KgslAdrenoCmdbatchQueuedFtraceEvent _instance;
53 };
54 };
55 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KgslAdrenoCmdbatchQueuedFtraceEventDefaultTypeInternal _KgslAdrenoCmdbatchQueuedFtraceEvent_default_instance_;
KgslAdrenoCmdbatchSubmittedFtraceEvent(::_pbi::ConstantInitialized)56 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchSubmittedFtraceEvent::KgslAdrenoCmdbatchSubmittedFtraceEvent(
57 ::_pbi::ConstantInitialized): _impl_{
58 /*decltype(_impl_._has_bits_)*/{}
59 , /*decltype(_impl_._cached_size_)*/{}
60 , /*decltype(_impl_.id_)*/0u
61 , /*decltype(_impl_.timestamp_)*/0u
62 , /*decltype(_impl_.inflight_)*/::int64_t{0}
63 , /*decltype(_impl_.ticks_)*/::uint64_t{0u}
64 , /*decltype(_impl_.secs_)*/::uint64_t{0u}
65 , /*decltype(_impl_.flags_)*/0u
66 , /*decltype(_impl_.prio_)*/0
67 , /*decltype(_impl_.usecs_)*/::uint64_t{0u}
68 , /*decltype(_impl_.rb_id_)*/0
69 , /*decltype(_impl_.rptr_)*/0u
70 , /*decltype(_impl_.wptr_)*/0u
71 , /*decltype(_impl_.q_inflight_)*/0
72 , /*decltype(_impl_.dispatch_queue_)*/0} {}
73 struct KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal {
KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal74 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal()
75 : _instance(::_pbi::ConstantInitialized{}) {}
~KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal76 ~KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal() {}
77 union { // NOLINT(misc-non-private-member-variables-in-classes)
78 KgslAdrenoCmdbatchSubmittedFtraceEvent _instance;
79 };
80 };
81 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KgslAdrenoCmdbatchSubmittedFtraceEventDefaultTypeInternal _KgslAdrenoCmdbatchSubmittedFtraceEvent_default_instance_;
KgslAdrenoCmdbatchSyncFtraceEvent(::_pbi::ConstantInitialized)82 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchSyncFtraceEvent::KgslAdrenoCmdbatchSyncFtraceEvent(
83 ::_pbi::ConstantInitialized): _impl_{
84 /*decltype(_impl_._has_bits_)*/{}
85 , /*decltype(_impl_._cached_size_)*/{}
86 , /*decltype(_impl_.id_)*/0u
87 , /*decltype(_impl_.timestamp_)*/0u
88 , /*decltype(_impl_.ticks_)*/::uint64_t{0u}
89 , /*decltype(_impl_.prio_)*/0} {}
90 struct KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal {
KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal91 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal()
92 : _instance(::_pbi::ConstantInitialized{}) {}
~KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal93 ~KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal() {}
94 union { // NOLINT(misc-non-private-member-variables-in-classes)
95 KgslAdrenoCmdbatchSyncFtraceEvent _instance;
96 };
97 };
98 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KgslAdrenoCmdbatchSyncFtraceEventDefaultTypeInternal _KgslAdrenoCmdbatchSyncFtraceEvent_default_instance_;
KgslAdrenoCmdbatchRetiredFtraceEvent(::_pbi::ConstantInitialized)99 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchRetiredFtraceEvent::KgslAdrenoCmdbatchRetiredFtraceEvent(
100 ::_pbi::ConstantInitialized): _impl_{
101 /*decltype(_impl_._has_bits_)*/{}
102 , /*decltype(_impl_._cached_size_)*/{}
103 , /*decltype(_impl_.id_)*/0u
104 , /*decltype(_impl_.timestamp_)*/0u
105 , /*decltype(_impl_.inflight_)*/::int64_t{0}
106 , /*decltype(_impl_.recovery_)*/0u
107 , /*decltype(_impl_.flags_)*/0u
108 , /*decltype(_impl_.start_)*/::uint64_t{0u}
109 , /*decltype(_impl_.retire_)*/::uint64_t{0u}
110 , /*decltype(_impl_.prio_)*/0
111 , /*decltype(_impl_.rb_id_)*/0
112 , /*decltype(_impl_.rptr_)*/0u
113 , /*decltype(_impl_.wptr_)*/0u
114 , /*decltype(_impl_.fault_recovery_)*/::uint64_t{0u}
115 , /*decltype(_impl_.q_inflight_)*/0
116 , /*decltype(_impl_.dispatch_queue_)*/0u
117 , /*decltype(_impl_.submitted_to_rb_)*/::uint64_t{0u}
118 , /*decltype(_impl_.retired_on_gmu_)*/::uint64_t{0u}
119 , /*decltype(_impl_.active_)*/::uint64_t{0u}} {}
120 struct KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal {
KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal121 PROTOBUF_CONSTEXPR KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal()
122 : _instance(::_pbi::ConstantInitialized{}) {}
~KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternalperfetto::protos::KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal123 ~KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal() {}
124 union { // NOLINT(misc-non-private-member-variables-in-classes)
125 KgslAdrenoCmdbatchRetiredFtraceEvent _instance;
126 };
127 };
128 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 KgslAdrenoCmdbatchRetiredFtraceEventDefaultTypeInternal _KgslAdrenoCmdbatchRetiredFtraceEvent_default_instance_;
129 } // namespace protos
130 } // namespace perfetto
131 namespace perfetto {
132 namespace protos {
133
134 // ===================================================================
135
136 class KgslGpuFrequencyFtraceEvent::_Internal {
137 public:
138 using HasBits = decltype(std::declval<KgslGpuFrequencyFtraceEvent>()._impl_._has_bits_);
set_has_gpu_freq(HasBits * has_bits)139 static void set_has_gpu_freq(HasBits* has_bits) {
140 (*has_bits)[0] |= 1u;
141 }
set_has_gpu_id(HasBits * has_bits)142 static void set_has_gpu_id(HasBits* has_bits) {
143 (*has_bits)[0] |= 2u;
144 }
145 };
146
KgslGpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)147 KgslGpuFrequencyFtraceEvent::KgslGpuFrequencyFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
148 bool is_message_owned)
149 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
150 SharedCtor(arena, is_message_owned);
151 // @@protoc_insertion_point(arena_constructor:perfetto.protos.KgslGpuFrequencyFtraceEvent)
152 }
KgslGpuFrequencyFtraceEvent(const KgslGpuFrequencyFtraceEvent & from)153 KgslGpuFrequencyFtraceEvent::KgslGpuFrequencyFtraceEvent(const KgslGpuFrequencyFtraceEvent& from)
154 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
155 KgslGpuFrequencyFtraceEvent* const _this = this; (void)_this;
156 new (&_impl_) Impl_{
157 decltype(_impl_._has_bits_){from._impl_._has_bits_}
158 , /*decltype(_impl_._cached_size_)*/{}
159 , decltype(_impl_.gpu_freq_){}
160 , decltype(_impl_.gpu_id_){}};
161
162 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
163 ::memcpy(&_impl_.gpu_freq_, &from._impl_.gpu_freq_,
164 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.gpu_id_) -
165 reinterpret_cast<char*>(&_impl_.gpu_freq_)) + sizeof(_impl_.gpu_id_));
166 // @@protoc_insertion_point(copy_constructor:perfetto.protos.KgslGpuFrequencyFtraceEvent)
167 }
168
SharedCtor(::_pb::Arena * arena,bool is_message_owned)169 inline void KgslGpuFrequencyFtraceEvent::SharedCtor(
170 ::_pb::Arena* arena, bool is_message_owned) {
171 (void)arena;
172 (void)is_message_owned;
173 new (&_impl_) Impl_{
174 decltype(_impl_._has_bits_){}
175 , /*decltype(_impl_._cached_size_)*/{}
176 , decltype(_impl_.gpu_freq_){0u}
177 , decltype(_impl_.gpu_id_){0u}
178 };
179 }
180
~KgslGpuFrequencyFtraceEvent()181 KgslGpuFrequencyFtraceEvent::~KgslGpuFrequencyFtraceEvent() {
182 // @@protoc_insertion_point(destructor:perfetto.protos.KgslGpuFrequencyFtraceEvent)
183 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
184 (void)arena;
185 return;
186 }
187 SharedDtor();
188 }
189
SharedDtor()190 inline void KgslGpuFrequencyFtraceEvent::SharedDtor() {
191 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
192 }
193
SetCachedSize(int size) const194 void KgslGpuFrequencyFtraceEvent::SetCachedSize(int size) const {
195 _impl_._cached_size_.Set(size);
196 }
197
Clear()198 void KgslGpuFrequencyFtraceEvent::Clear() {
199 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KgslGpuFrequencyFtraceEvent)
200 ::uint32_t cached_has_bits = 0;
201 // Prevent compiler warnings about cached_has_bits being unused
202 (void) cached_has_bits;
203
204 cached_has_bits = _impl_._has_bits_[0];
205 if (cached_has_bits & 0x00000003u) {
206 ::memset(&_impl_.gpu_freq_, 0, static_cast<size_t>(
207 reinterpret_cast<char*>(&_impl_.gpu_id_) -
208 reinterpret_cast<char*>(&_impl_.gpu_freq_)) + sizeof(_impl_.gpu_id_));
209 }
210 _impl_._has_bits_.Clear();
211 _internal_metadata_.Clear<std::string>();
212 }
213
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)214 const char* KgslGpuFrequencyFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
215 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
216 _Internal::HasBits has_bits{};
217 while (!ctx->Done(&ptr)) {
218 ::uint32_t tag;
219 ptr = ::_pbi::ReadTag(ptr, &tag);
220 switch (tag >> 3) {
221 // optional uint32 gpu_freq = 1;
222 case 1:
223 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
224 _Internal::set_has_gpu_freq(&has_bits);
225 _impl_.gpu_freq_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
226 CHK_(ptr);
227 } else {
228 goto handle_unusual;
229 }
230 continue;
231 // optional uint32 gpu_id = 2;
232 case 2:
233 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
234 _Internal::set_has_gpu_id(&has_bits);
235 _impl_.gpu_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
236 CHK_(ptr);
237 } else {
238 goto handle_unusual;
239 }
240 continue;
241 default:
242 goto handle_unusual;
243 } // switch
244 handle_unusual:
245 if ((tag == 0) || ((tag & 7) == 4)) {
246 CHK_(ptr);
247 ctx->SetLastTag(tag);
248 goto message_done;
249 }
250 ptr = UnknownFieldParse(
251 tag,
252 _internal_metadata_.mutable_unknown_fields<std::string>(),
253 ptr, ctx);
254 CHK_(ptr != nullptr);
255 } // while
256 message_done:
257 _impl_._has_bits_.Or(has_bits);
258 return ptr;
259 failure:
260 ptr = nullptr;
261 goto message_done;
262 #undef CHK_
263 }
264
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const265 ::uint8_t* KgslGpuFrequencyFtraceEvent::_InternalSerialize(
266 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
267 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KgslGpuFrequencyFtraceEvent)
268 ::uint32_t cached_has_bits = 0;
269 (void) cached_has_bits;
270
271 cached_has_bits = _impl_._has_bits_[0];
272 // optional uint32 gpu_freq = 1;
273 if (cached_has_bits & 0x00000001u) {
274 target = stream->EnsureSpace(target);
275 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_gpu_freq(), target);
276 }
277
278 // optional uint32 gpu_id = 2;
279 if (cached_has_bits & 0x00000002u) {
280 target = stream->EnsureSpace(target);
281 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_gpu_id(), target);
282 }
283
284 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
285 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
286 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
287 }
288 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KgslGpuFrequencyFtraceEvent)
289 return target;
290 }
291
ByteSizeLong() const292 size_t KgslGpuFrequencyFtraceEvent::ByteSizeLong() const {
293 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KgslGpuFrequencyFtraceEvent)
294 size_t total_size = 0;
295
296 ::uint32_t cached_has_bits = 0;
297 // Prevent compiler warnings about cached_has_bits being unused
298 (void) cached_has_bits;
299
300 cached_has_bits = _impl_._has_bits_[0];
301 if (cached_has_bits & 0x00000003u) {
302 // optional uint32 gpu_freq = 1;
303 if (cached_has_bits & 0x00000001u) {
304 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gpu_freq());
305 }
306
307 // optional uint32 gpu_id = 2;
308 if (cached_has_bits & 0x00000002u) {
309 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gpu_id());
310 }
311
312 }
313 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
314 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
315 }
316 int cached_size = ::_pbi::ToCachedSize(total_size);
317 SetCachedSize(cached_size);
318 return total_size;
319 }
320
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)321 void KgslGpuFrequencyFtraceEvent::CheckTypeAndMergeFrom(
322 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
323 MergeFrom(*::_pbi::DownCast<const KgslGpuFrequencyFtraceEvent*>(
324 &from));
325 }
326
MergeFrom(const KgslGpuFrequencyFtraceEvent & from)327 void KgslGpuFrequencyFtraceEvent::MergeFrom(const KgslGpuFrequencyFtraceEvent& from) {
328 KgslGpuFrequencyFtraceEvent* const _this = this;
329 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KgslGpuFrequencyFtraceEvent)
330 GOOGLE_DCHECK_NE(&from, _this);
331 ::uint32_t cached_has_bits = 0;
332 (void) cached_has_bits;
333
334 cached_has_bits = from._impl_._has_bits_[0];
335 if (cached_has_bits & 0x00000003u) {
336 if (cached_has_bits & 0x00000001u) {
337 _this->_impl_.gpu_freq_ = from._impl_.gpu_freq_;
338 }
339 if (cached_has_bits & 0x00000002u) {
340 _this->_impl_.gpu_id_ = from._impl_.gpu_id_;
341 }
342 _this->_impl_._has_bits_[0] |= cached_has_bits;
343 }
344 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
345 }
346
CopyFrom(const KgslGpuFrequencyFtraceEvent & from)347 void KgslGpuFrequencyFtraceEvent::CopyFrom(const KgslGpuFrequencyFtraceEvent& from) {
348 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KgslGpuFrequencyFtraceEvent)
349 if (&from == this) return;
350 Clear();
351 MergeFrom(from);
352 }
353
IsInitialized() const354 bool KgslGpuFrequencyFtraceEvent::IsInitialized() const {
355 return true;
356 }
357
InternalSwap(KgslGpuFrequencyFtraceEvent * other)358 void KgslGpuFrequencyFtraceEvent::InternalSwap(KgslGpuFrequencyFtraceEvent* other) {
359 using std::swap;
360 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
361 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
362 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
363 PROTOBUF_FIELD_OFFSET(KgslGpuFrequencyFtraceEvent, _impl_.gpu_id_)
364 + sizeof(KgslGpuFrequencyFtraceEvent::_impl_.gpu_id_) // NOLINT
365 - PROTOBUF_FIELD_OFFSET(KgslGpuFrequencyFtraceEvent, _impl_.gpu_freq_)>(
366 reinterpret_cast<char*>(&_impl_.gpu_freq_),
367 reinterpret_cast<char*>(&other->_impl_.gpu_freq_));
368 }
369
GetTypeName() const370 std::string KgslGpuFrequencyFtraceEvent::GetTypeName() const {
371 return "perfetto.protos.KgslGpuFrequencyFtraceEvent";
372 }
373
374
375 // ===================================================================
376
377 class KgslAdrenoCmdbatchQueuedFtraceEvent::_Internal {
378 public:
379 using HasBits = decltype(std::declval<KgslAdrenoCmdbatchQueuedFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)380 static void set_has_id(HasBits* has_bits) {
381 (*has_bits)[0] |= 1u;
382 }
set_has_timestamp(HasBits * has_bits)383 static void set_has_timestamp(HasBits* has_bits) {
384 (*has_bits)[0] |= 2u;
385 }
set_has_queued(HasBits * has_bits)386 static void set_has_queued(HasBits* has_bits) {
387 (*has_bits)[0] |= 4u;
388 }
set_has_flags(HasBits * has_bits)389 static void set_has_flags(HasBits* has_bits) {
390 (*has_bits)[0] |= 8u;
391 }
set_has_prio(HasBits * has_bits)392 static void set_has_prio(HasBits* has_bits) {
393 (*has_bits)[0] |= 16u;
394 }
395 };
396
KgslAdrenoCmdbatchQueuedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)397 KgslAdrenoCmdbatchQueuedFtraceEvent::KgslAdrenoCmdbatchQueuedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
398 bool is_message_owned)
399 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
400 SharedCtor(arena, is_message_owned);
401 // @@protoc_insertion_point(arena_constructor:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
402 }
KgslAdrenoCmdbatchQueuedFtraceEvent(const KgslAdrenoCmdbatchQueuedFtraceEvent & from)403 KgslAdrenoCmdbatchQueuedFtraceEvent::KgslAdrenoCmdbatchQueuedFtraceEvent(const KgslAdrenoCmdbatchQueuedFtraceEvent& from)
404 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
405 KgslAdrenoCmdbatchQueuedFtraceEvent* const _this = this; (void)_this;
406 new (&_impl_) Impl_{
407 decltype(_impl_._has_bits_){from._impl_._has_bits_}
408 , /*decltype(_impl_._cached_size_)*/{}
409 , decltype(_impl_.id_){}
410 , decltype(_impl_.timestamp_){}
411 , decltype(_impl_.queued_){}
412 , decltype(_impl_.flags_){}
413 , decltype(_impl_.prio_){}};
414
415 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
416 ::memcpy(&_impl_.id_, &from._impl_.id_,
417 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
418 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.prio_));
419 // @@protoc_insertion_point(copy_constructor:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
420 }
421
SharedCtor(::_pb::Arena * arena,bool is_message_owned)422 inline void KgslAdrenoCmdbatchQueuedFtraceEvent::SharedCtor(
423 ::_pb::Arena* arena, bool is_message_owned) {
424 (void)arena;
425 (void)is_message_owned;
426 new (&_impl_) Impl_{
427 decltype(_impl_._has_bits_){}
428 , /*decltype(_impl_._cached_size_)*/{}
429 , decltype(_impl_.id_){0u}
430 , decltype(_impl_.timestamp_){0u}
431 , decltype(_impl_.queued_){0u}
432 , decltype(_impl_.flags_){0u}
433 , decltype(_impl_.prio_){0u}
434 };
435 }
436
~KgslAdrenoCmdbatchQueuedFtraceEvent()437 KgslAdrenoCmdbatchQueuedFtraceEvent::~KgslAdrenoCmdbatchQueuedFtraceEvent() {
438 // @@protoc_insertion_point(destructor:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
439 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
440 (void)arena;
441 return;
442 }
443 SharedDtor();
444 }
445
SharedDtor()446 inline void KgslAdrenoCmdbatchQueuedFtraceEvent::SharedDtor() {
447 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
448 }
449
SetCachedSize(int size) const450 void KgslAdrenoCmdbatchQueuedFtraceEvent::SetCachedSize(int size) const {
451 _impl_._cached_size_.Set(size);
452 }
453
Clear()454 void KgslAdrenoCmdbatchQueuedFtraceEvent::Clear() {
455 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
456 ::uint32_t cached_has_bits = 0;
457 // Prevent compiler warnings about cached_has_bits being unused
458 (void) cached_has_bits;
459
460 cached_has_bits = _impl_._has_bits_[0];
461 if (cached_has_bits & 0x0000001fu) {
462 ::memset(&_impl_.id_, 0, static_cast<size_t>(
463 reinterpret_cast<char*>(&_impl_.prio_) -
464 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.prio_));
465 }
466 _impl_._has_bits_.Clear();
467 _internal_metadata_.Clear<std::string>();
468 }
469
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)470 const char* KgslAdrenoCmdbatchQueuedFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
471 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
472 _Internal::HasBits has_bits{};
473 while (!ctx->Done(&ptr)) {
474 ::uint32_t tag;
475 ptr = ::_pbi::ReadTag(ptr, &tag);
476 switch (tag >> 3) {
477 // optional uint32 id = 1;
478 case 1:
479 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
480 _Internal::set_has_id(&has_bits);
481 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
482 CHK_(ptr);
483 } else {
484 goto handle_unusual;
485 }
486 continue;
487 // optional uint32 timestamp = 2;
488 case 2:
489 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
490 _Internal::set_has_timestamp(&has_bits);
491 _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
492 CHK_(ptr);
493 } else {
494 goto handle_unusual;
495 }
496 continue;
497 // optional uint32 queued = 3;
498 case 3:
499 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
500 _Internal::set_has_queued(&has_bits);
501 _impl_.queued_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
502 CHK_(ptr);
503 } else {
504 goto handle_unusual;
505 }
506 continue;
507 // optional uint32 flags = 4;
508 case 4:
509 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
510 _Internal::set_has_flags(&has_bits);
511 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
512 CHK_(ptr);
513 } else {
514 goto handle_unusual;
515 }
516 continue;
517 // optional uint32 prio = 5;
518 case 5:
519 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
520 _Internal::set_has_prio(&has_bits);
521 _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
522 CHK_(ptr);
523 } else {
524 goto handle_unusual;
525 }
526 continue;
527 default:
528 goto handle_unusual;
529 } // switch
530 handle_unusual:
531 if ((tag == 0) || ((tag & 7) == 4)) {
532 CHK_(ptr);
533 ctx->SetLastTag(tag);
534 goto message_done;
535 }
536 ptr = UnknownFieldParse(
537 tag,
538 _internal_metadata_.mutable_unknown_fields<std::string>(),
539 ptr, ctx);
540 CHK_(ptr != nullptr);
541 } // while
542 message_done:
543 _impl_._has_bits_.Or(has_bits);
544 return ptr;
545 failure:
546 ptr = nullptr;
547 goto message_done;
548 #undef CHK_
549 }
550
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const551 ::uint8_t* KgslAdrenoCmdbatchQueuedFtraceEvent::_InternalSerialize(
552 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
553 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
554 ::uint32_t cached_has_bits = 0;
555 (void) cached_has_bits;
556
557 cached_has_bits = _impl_._has_bits_[0];
558 // optional uint32 id = 1;
559 if (cached_has_bits & 0x00000001u) {
560 target = stream->EnsureSpace(target);
561 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
562 }
563
564 // optional uint32 timestamp = 2;
565 if (cached_has_bits & 0x00000002u) {
566 target = stream->EnsureSpace(target);
567 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_timestamp(), target);
568 }
569
570 // optional uint32 queued = 3;
571 if (cached_has_bits & 0x00000004u) {
572 target = stream->EnsureSpace(target);
573 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_queued(), target);
574 }
575
576 // optional uint32 flags = 4;
577 if (cached_has_bits & 0x00000008u) {
578 target = stream->EnsureSpace(target);
579 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_flags(), target);
580 }
581
582 // optional uint32 prio = 5;
583 if (cached_has_bits & 0x00000010u) {
584 target = stream->EnsureSpace(target);
585 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_prio(), target);
586 }
587
588 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
589 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
590 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
591 }
592 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
593 return target;
594 }
595
ByteSizeLong() const596 size_t KgslAdrenoCmdbatchQueuedFtraceEvent::ByteSizeLong() const {
597 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
598 size_t total_size = 0;
599
600 ::uint32_t cached_has_bits = 0;
601 // Prevent compiler warnings about cached_has_bits being unused
602 (void) cached_has_bits;
603
604 cached_has_bits = _impl_._has_bits_[0];
605 if (cached_has_bits & 0x0000001fu) {
606 // optional uint32 id = 1;
607 if (cached_has_bits & 0x00000001u) {
608 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
609 }
610
611 // optional uint32 timestamp = 2;
612 if (cached_has_bits & 0x00000002u) {
613 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timestamp());
614 }
615
616 // optional uint32 queued = 3;
617 if (cached_has_bits & 0x00000004u) {
618 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_queued());
619 }
620
621 // optional uint32 flags = 4;
622 if (cached_has_bits & 0x00000008u) {
623 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
624 }
625
626 // optional uint32 prio = 5;
627 if (cached_has_bits & 0x00000010u) {
628 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_prio());
629 }
630
631 }
632 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
633 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
634 }
635 int cached_size = ::_pbi::ToCachedSize(total_size);
636 SetCachedSize(cached_size);
637 return total_size;
638 }
639
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)640 void KgslAdrenoCmdbatchQueuedFtraceEvent::CheckTypeAndMergeFrom(
641 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
642 MergeFrom(*::_pbi::DownCast<const KgslAdrenoCmdbatchQueuedFtraceEvent*>(
643 &from));
644 }
645
MergeFrom(const KgslAdrenoCmdbatchQueuedFtraceEvent & from)646 void KgslAdrenoCmdbatchQueuedFtraceEvent::MergeFrom(const KgslAdrenoCmdbatchQueuedFtraceEvent& from) {
647 KgslAdrenoCmdbatchQueuedFtraceEvent* const _this = this;
648 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
649 GOOGLE_DCHECK_NE(&from, _this);
650 ::uint32_t cached_has_bits = 0;
651 (void) cached_has_bits;
652
653 cached_has_bits = from._impl_._has_bits_[0];
654 if (cached_has_bits & 0x0000001fu) {
655 if (cached_has_bits & 0x00000001u) {
656 _this->_impl_.id_ = from._impl_.id_;
657 }
658 if (cached_has_bits & 0x00000002u) {
659 _this->_impl_.timestamp_ = from._impl_.timestamp_;
660 }
661 if (cached_has_bits & 0x00000004u) {
662 _this->_impl_.queued_ = from._impl_.queued_;
663 }
664 if (cached_has_bits & 0x00000008u) {
665 _this->_impl_.flags_ = from._impl_.flags_;
666 }
667 if (cached_has_bits & 0x00000010u) {
668 _this->_impl_.prio_ = from._impl_.prio_;
669 }
670 _this->_impl_._has_bits_[0] |= cached_has_bits;
671 }
672 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
673 }
674
CopyFrom(const KgslAdrenoCmdbatchQueuedFtraceEvent & from)675 void KgslAdrenoCmdbatchQueuedFtraceEvent::CopyFrom(const KgslAdrenoCmdbatchQueuedFtraceEvent& from) {
676 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent)
677 if (&from == this) return;
678 Clear();
679 MergeFrom(from);
680 }
681
IsInitialized() const682 bool KgslAdrenoCmdbatchQueuedFtraceEvent::IsInitialized() const {
683 return true;
684 }
685
InternalSwap(KgslAdrenoCmdbatchQueuedFtraceEvent * other)686 void KgslAdrenoCmdbatchQueuedFtraceEvent::InternalSwap(KgslAdrenoCmdbatchQueuedFtraceEvent* other) {
687 using std::swap;
688 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
689 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
690 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
691 PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchQueuedFtraceEvent, _impl_.prio_)
692 + sizeof(KgslAdrenoCmdbatchQueuedFtraceEvent::_impl_.prio_) // NOLINT
693 - PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchQueuedFtraceEvent, _impl_.id_)>(
694 reinterpret_cast<char*>(&_impl_.id_),
695 reinterpret_cast<char*>(&other->_impl_.id_));
696 }
697
GetTypeName() const698 std::string KgslAdrenoCmdbatchQueuedFtraceEvent::GetTypeName() const {
699 return "perfetto.protos.KgslAdrenoCmdbatchQueuedFtraceEvent";
700 }
701
702
703 // ===================================================================
704
705 class KgslAdrenoCmdbatchSubmittedFtraceEvent::_Internal {
706 public:
707 using HasBits = decltype(std::declval<KgslAdrenoCmdbatchSubmittedFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)708 static void set_has_id(HasBits* has_bits) {
709 (*has_bits)[0] |= 1u;
710 }
set_has_timestamp(HasBits * has_bits)711 static void set_has_timestamp(HasBits* has_bits) {
712 (*has_bits)[0] |= 2u;
713 }
set_has_inflight(HasBits * has_bits)714 static void set_has_inflight(HasBits* has_bits) {
715 (*has_bits)[0] |= 4u;
716 }
set_has_flags(HasBits * has_bits)717 static void set_has_flags(HasBits* has_bits) {
718 (*has_bits)[0] |= 32u;
719 }
set_has_ticks(HasBits * has_bits)720 static void set_has_ticks(HasBits* has_bits) {
721 (*has_bits)[0] |= 8u;
722 }
set_has_secs(HasBits * has_bits)723 static void set_has_secs(HasBits* has_bits) {
724 (*has_bits)[0] |= 16u;
725 }
set_has_usecs(HasBits * has_bits)726 static void set_has_usecs(HasBits* has_bits) {
727 (*has_bits)[0] |= 128u;
728 }
set_has_prio(HasBits * has_bits)729 static void set_has_prio(HasBits* has_bits) {
730 (*has_bits)[0] |= 64u;
731 }
set_has_rb_id(HasBits * has_bits)732 static void set_has_rb_id(HasBits* has_bits) {
733 (*has_bits)[0] |= 256u;
734 }
set_has_rptr(HasBits * has_bits)735 static void set_has_rptr(HasBits* has_bits) {
736 (*has_bits)[0] |= 512u;
737 }
set_has_wptr(HasBits * has_bits)738 static void set_has_wptr(HasBits* has_bits) {
739 (*has_bits)[0] |= 1024u;
740 }
set_has_q_inflight(HasBits * has_bits)741 static void set_has_q_inflight(HasBits* has_bits) {
742 (*has_bits)[0] |= 2048u;
743 }
set_has_dispatch_queue(HasBits * has_bits)744 static void set_has_dispatch_queue(HasBits* has_bits) {
745 (*has_bits)[0] |= 4096u;
746 }
747 };
748
KgslAdrenoCmdbatchSubmittedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)749 KgslAdrenoCmdbatchSubmittedFtraceEvent::KgslAdrenoCmdbatchSubmittedFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
750 bool is_message_owned)
751 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
752 SharedCtor(arena, is_message_owned);
753 // @@protoc_insertion_point(arena_constructor:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
754 }
KgslAdrenoCmdbatchSubmittedFtraceEvent(const KgslAdrenoCmdbatchSubmittedFtraceEvent & from)755 KgslAdrenoCmdbatchSubmittedFtraceEvent::KgslAdrenoCmdbatchSubmittedFtraceEvent(const KgslAdrenoCmdbatchSubmittedFtraceEvent& from)
756 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
757 KgslAdrenoCmdbatchSubmittedFtraceEvent* const _this = this; (void)_this;
758 new (&_impl_) Impl_{
759 decltype(_impl_._has_bits_){from._impl_._has_bits_}
760 , /*decltype(_impl_._cached_size_)*/{}
761 , decltype(_impl_.id_){}
762 , decltype(_impl_.timestamp_){}
763 , decltype(_impl_.inflight_){}
764 , decltype(_impl_.ticks_){}
765 , decltype(_impl_.secs_){}
766 , decltype(_impl_.flags_){}
767 , decltype(_impl_.prio_){}
768 , decltype(_impl_.usecs_){}
769 , decltype(_impl_.rb_id_){}
770 , decltype(_impl_.rptr_){}
771 , decltype(_impl_.wptr_){}
772 , decltype(_impl_.q_inflight_){}
773 , decltype(_impl_.dispatch_queue_){}};
774
775 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
776 ::memcpy(&_impl_.id_, &from._impl_.id_,
777 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.dispatch_queue_) -
778 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.dispatch_queue_));
779 // @@protoc_insertion_point(copy_constructor:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
780 }
781
SharedCtor(::_pb::Arena * arena,bool is_message_owned)782 inline void KgslAdrenoCmdbatchSubmittedFtraceEvent::SharedCtor(
783 ::_pb::Arena* arena, bool is_message_owned) {
784 (void)arena;
785 (void)is_message_owned;
786 new (&_impl_) Impl_{
787 decltype(_impl_._has_bits_){}
788 , /*decltype(_impl_._cached_size_)*/{}
789 , decltype(_impl_.id_){0u}
790 , decltype(_impl_.timestamp_){0u}
791 , decltype(_impl_.inflight_){::int64_t{0}}
792 , decltype(_impl_.ticks_){::uint64_t{0u}}
793 , decltype(_impl_.secs_){::uint64_t{0u}}
794 , decltype(_impl_.flags_){0u}
795 , decltype(_impl_.prio_){0}
796 , decltype(_impl_.usecs_){::uint64_t{0u}}
797 , decltype(_impl_.rb_id_){0}
798 , decltype(_impl_.rptr_){0u}
799 , decltype(_impl_.wptr_){0u}
800 , decltype(_impl_.q_inflight_){0}
801 , decltype(_impl_.dispatch_queue_){0}
802 };
803 }
804
~KgslAdrenoCmdbatchSubmittedFtraceEvent()805 KgslAdrenoCmdbatchSubmittedFtraceEvent::~KgslAdrenoCmdbatchSubmittedFtraceEvent() {
806 // @@protoc_insertion_point(destructor:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
807 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
808 (void)arena;
809 return;
810 }
811 SharedDtor();
812 }
813
SharedDtor()814 inline void KgslAdrenoCmdbatchSubmittedFtraceEvent::SharedDtor() {
815 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
816 }
817
SetCachedSize(int size) const818 void KgslAdrenoCmdbatchSubmittedFtraceEvent::SetCachedSize(int size) const {
819 _impl_._cached_size_.Set(size);
820 }
821
Clear()822 void KgslAdrenoCmdbatchSubmittedFtraceEvent::Clear() {
823 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
824 ::uint32_t cached_has_bits = 0;
825 // Prevent compiler warnings about cached_has_bits being unused
826 (void) cached_has_bits;
827
828 cached_has_bits = _impl_._has_bits_[0];
829 if (cached_has_bits & 0x000000ffu) {
830 ::memset(&_impl_.id_, 0, static_cast<size_t>(
831 reinterpret_cast<char*>(&_impl_.usecs_) -
832 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.usecs_));
833 }
834 if (cached_has_bits & 0x00001f00u) {
835 ::memset(&_impl_.rb_id_, 0, static_cast<size_t>(
836 reinterpret_cast<char*>(&_impl_.dispatch_queue_) -
837 reinterpret_cast<char*>(&_impl_.rb_id_)) + sizeof(_impl_.dispatch_queue_));
838 }
839 _impl_._has_bits_.Clear();
840 _internal_metadata_.Clear<std::string>();
841 }
842
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)843 const char* KgslAdrenoCmdbatchSubmittedFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
844 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
845 _Internal::HasBits has_bits{};
846 while (!ctx->Done(&ptr)) {
847 ::uint32_t tag;
848 ptr = ::_pbi::ReadTag(ptr, &tag);
849 switch (tag >> 3) {
850 // optional uint32 id = 1;
851 case 1:
852 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
853 _Internal::set_has_id(&has_bits);
854 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
855 CHK_(ptr);
856 } else {
857 goto handle_unusual;
858 }
859 continue;
860 // optional uint32 timestamp = 2;
861 case 2:
862 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
863 _Internal::set_has_timestamp(&has_bits);
864 _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
865 CHK_(ptr);
866 } else {
867 goto handle_unusual;
868 }
869 continue;
870 // optional int64 inflight = 3;
871 case 3:
872 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
873 _Internal::set_has_inflight(&has_bits);
874 _impl_.inflight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
875 CHK_(ptr);
876 } else {
877 goto handle_unusual;
878 }
879 continue;
880 // optional uint32 flags = 4;
881 case 4:
882 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
883 _Internal::set_has_flags(&has_bits);
884 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
885 CHK_(ptr);
886 } else {
887 goto handle_unusual;
888 }
889 continue;
890 // optional uint64 ticks = 5;
891 case 5:
892 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
893 _Internal::set_has_ticks(&has_bits);
894 _impl_.ticks_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
895 CHK_(ptr);
896 } else {
897 goto handle_unusual;
898 }
899 continue;
900 // optional uint64 secs = 6;
901 case 6:
902 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
903 _Internal::set_has_secs(&has_bits);
904 _impl_.secs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
905 CHK_(ptr);
906 } else {
907 goto handle_unusual;
908 }
909 continue;
910 // optional uint64 usecs = 7;
911 case 7:
912 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
913 _Internal::set_has_usecs(&has_bits);
914 _impl_.usecs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
915 CHK_(ptr);
916 } else {
917 goto handle_unusual;
918 }
919 continue;
920 // optional int32 prio = 8;
921 case 8:
922 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
923 _Internal::set_has_prio(&has_bits);
924 _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
925 CHK_(ptr);
926 } else {
927 goto handle_unusual;
928 }
929 continue;
930 // optional int32 rb_id = 9;
931 case 9:
932 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
933 _Internal::set_has_rb_id(&has_bits);
934 _impl_.rb_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
935 CHK_(ptr);
936 } else {
937 goto handle_unusual;
938 }
939 continue;
940 // optional uint32 rptr = 10;
941 case 10:
942 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
943 _Internal::set_has_rptr(&has_bits);
944 _impl_.rptr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
945 CHK_(ptr);
946 } else {
947 goto handle_unusual;
948 }
949 continue;
950 // optional uint32 wptr = 11;
951 case 11:
952 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
953 _Internal::set_has_wptr(&has_bits);
954 _impl_.wptr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
955 CHK_(ptr);
956 } else {
957 goto handle_unusual;
958 }
959 continue;
960 // optional int32 q_inflight = 12;
961 case 12:
962 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
963 _Internal::set_has_q_inflight(&has_bits);
964 _impl_.q_inflight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
965 CHK_(ptr);
966 } else {
967 goto handle_unusual;
968 }
969 continue;
970 // optional int32 dispatch_queue = 13;
971 case 13:
972 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
973 _Internal::set_has_dispatch_queue(&has_bits);
974 _impl_.dispatch_queue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
975 CHK_(ptr);
976 } else {
977 goto handle_unusual;
978 }
979 continue;
980 default:
981 goto handle_unusual;
982 } // switch
983 handle_unusual:
984 if ((tag == 0) || ((tag & 7) == 4)) {
985 CHK_(ptr);
986 ctx->SetLastTag(tag);
987 goto message_done;
988 }
989 ptr = UnknownFieldParse(
990 tag,
991 _internal_metadata_.mutable_unknown_fields<std::string>(),
992 ptr, ctx);
993 CHK_(ptr != nullptr);
994 } // while
995 message_done:
996 _impl_._has_bits_.Or(has_bits);
997 return ptr;
998 failure:
999 ptr = nullptr;
1000 goto message_done;
1001 #undef CHK_
1002 }
1003
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1004 ::uint8_t* KgslAdrenoCmdbatchSubmittedFtraceEvent::_InternalSerialize(
1005 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1006 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
1007 ::uint32_t cached_has_bits = 0;
1008 (void) cached_has_bits;
1009
1010 cached_has_bits = _impl_._has_bits_[0];
1011 // optional uint32 id = 1;
1012 if (cached_has_bits & 0x00000001u) {
1013 target = stream->EnsureSpace(target);
1014 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
1015 }
1016
1017 // optional uint32 timestamp = 2;
1018 if (cached_has_bits & 0x00000002u) {
1019 target = stream->EnsureSpace(target);
1020 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_timestamp(), target);
1021 }
1022
1023 // optional int64 inflight = 3;
1024 if (cached_has_bits & 0x00000004u) {
1025 target = stream->EnsureSpace(target);
1026 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_inflight(), target);
1027 }
1028
1029 // optional uint32 flags = 4;
1030 if (cached_has_bits & 0x00000020u) {
1031 target = stream->EnsureSpace(target);
1032 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_flags(), target);
1033 }
1034
1035 // optional uint64 ticks = 5;
1036 if (cached_has_bits & 0x00000008u) {
1037 target = stream->EnsureSpace(target);
1038 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(5, this->_internal_ticks(), target);
1039 }
1040
1041 // optional uint64 secs = 6;
1042 if (cached_has_bits & 0x00000010u) {
1043 target = stream->EnsureSpace(target);
1044 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_secs(), target);
1045 }
1046
1047 // optional uint64 usecs = 7;
1048 if (cached_has_bits & 0x00000080u) {
1049 target = stream->EnsureSpace(target);
1050 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_usecs(), target);
1051 }
1052
1053 // optional int32 prio = 8;
1054 if (cached_has_bits & 0x00000040u) {
1055 target = stream->EnsureSpace(target);
1056 target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_prio(), target);
1057 }
1058
1059 // optional int32 rb_id = 9;
1060 if (cached_has_bits & 0x00000100u) {
1061 target = stream->EnsureSpace(target);
1062 target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_rb_id(), target);
1063 }
1064
1065 // optional uint32 rptr = 10;
1066 if (cached_has_bits & 0x00000200u) {
1067 target = stream->EnsureSpace(target);
1068 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_rptr(), target);
1069 }
1070
1071 // optional uint32 wptr = 11;
1072 if (cached_has_bits & 0x00000400u) {
1073 target = stream->EnsureSpace(target);
1074 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_wptr(), target);
1075 }
1076
1077 // optional int32 q_inflight = 12;
1078 if (cached_has_bits & 0x00000800u) {
1079 target = stream->EnsureSpace(target);
1080 target = ::_pbi::WireFormatLite::WriteInt32ToArray(12, this->_internal_q_inflight(), target);
1081 }
1082
1083 // optional int32 dispatch_queue = 13;
1084 if (cached_has_bits & 0x00001000u) {
1085 target = stream->EnsureSpace(target);
1086 target = ::_pbi::WireFormatLite::WriteInt32ToArray(13, this->_internal_dispatch_queue(), target);
1087 }
1088
1089 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1090 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1091 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1092 }
1093 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
1094 return target;
1095 }
1096
ByteSizeLong() const1097 size_t KgslAdrenoCmdbatchSubmittedFtraceEvent::ByteSizeLong() const {
1098 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
1099 size_t total_size = 0;
1100
1101 ::uint32_t cached_has_bits = 0;
1102 // Prevent compiler warnings about cached_has_bits being unused
1103 (void) cached_has_bits;
1104
1105 cached_has_bits = _impl_._has_bits_[0];
1106 if (cached_has_bits & 0x000000ffu) {
1107 // optional uint32 id = 1;
1108 if (cached_has_bits & 0x00000001u) {
1109 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
1110 }
1111
1112 // optional uint32 timestamp = 2;
1113 if (cached_has_bits & 0x00000002u) {
1114 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timestamp());
1115 }
1116
1117 // optional int64 inflight = 3;
1118 if (cached_has_bits & 0x00000004u) {
1119 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_inflight());
1120 }
1121
1122 // optional uint64 ticks = 5;
1123 if (cached_has_bits & 0x00000008u) {
1124 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ticks());
1125 }
1126
1127 // optional uint64 secs = 6;
1128 if (cached_has_bits & 0x00000010u) {
1129 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_secs());
1130 }
1131
1132 // optional uint32 flags = 4;
1133 if (cached_has_bits & 0x00000020u) {
1134 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
1135 }
1136
1137 // optional int32 prio = 8;
1138 if (cached_has_bits & 0x00000040u) {
1139 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
1140 }
1141
1142 // optional uint64 usecs = 7;
1143 if (cached_has_bits & 0x00000080u) {
1144 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_usecs());
1145 }
1146
1147 }
1148 if (cached_has_bits & 0x00001f00u) {
1149 // optional int32 rb_id = 9;
1150 if (cached_has_bits & 0x00000100u) {
1151 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_rb_id());
1152 }
1153
1154 // optional uint32 rptr = 10;
1155 if (cached_has_bits & 0x00000200u) {
1156 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rptr());
1157 }
1158
1159 // optional uint32 wptr = 11;
1160 if (cached_has_bits & 0x00000400u) {
1161 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_wptr());
1162 }
1163
1164 // optional int32 q_inflight = 12;
1165 if (cached_has_bits & 0x00000800u) {
1166 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_q_inflight());
1167 }
1168
1169 // optional int32 dispatch_queue = 13;
1170 if (cached_has_bits & 0x00001000u) {
1171 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_dispatch_queue());
1172 }
1173
1174 }
1175 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1176 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1177 }
1178 int cached_size = ::_pbi::ToCachedSize(total_size);
1179 SetCachedSize(cached_size);
1180 return total_size;
1181 }
1182
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1183 void KgslAdrenoCmdbatchSubmittedFtraceEvent::CheckTypeAndMergeFrom(
1184 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1185 MergeFrom(*::_pbi::DownCast<const KgslAdrenoCmdbatchSubmittedFtraceEvent*>(
1186 &from));
1187 }
1188
MergeFrom(const KgslAdrenoCmdbatchSubmittedFtraceEvent & from)1189 void KgslAdrenoCmdbatchSubmittedFtraceEvent::MergeFrom(const KgslAdrenoCmdbatchSubmittedFtraceEvent& from) {
1190 KgslAdrenoCmdbatchSubmittedFtraceEvent* const _this = this;
1191 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
1192 GOOGLE_DCHECK_NE(&from, _this);
1193 ::uint32_t cached_has_bits = 0;
1194 (void) cached_has_bits;
1195
1196 cached_has_bits = from._impl_._has_bits_[0];
1197 if (cached_has_bits & 0x000000ffu) {
1198 if (cached_has_bits & 0x00000001u) {
1199 _this->_impl_.id_ = from._impl_.id_;
1200 }
1201 if (cached_has_bits & 0x00000002u) {
1202 _this->_impl_.timestamp_ = from._impl_.timestamp_;
1203 }
1204 if (cached_has_bits & 0x00000004u) {
1205 _this->_impl_.inflight_ = from._impl_.inflight_;
1206 }
1207 if (cached_has_bits & 0x00000008u) {
1208 _this->_impl_.ticks_ = from._impl_.ticks_;
1209 }
1210 if (cached_has_bits & 0x00000010u) {
1211 _this->_impl_.secs_ = from._impl_.secs_;
1212 }
1213 if (cached_has_bits & 0x00000020u) {
1214 _this->_impl_.flags_ = from._impl_.flags_;
1215 }
1216 if (cached_has_bits & 0x00000040u) {
1217 _this->_impl_.prio_ = from._impl_.prio_;
1218 }
1219 if (cached_has_bits & 0x00000080u) {
1220 _this->_impl_.usecs_ = from._impl_.usecs_;
1221 }
1222 _this->_impl_._has_bits_[0] |= cached_has_bits;
1223 }
1224 if (cached_has_bits & 0x00001f00u) {
1225 if (cached_has_bits & 0x00000100u) {
1226 _this->_impl_.rb_id_ = from._impl_.rb_id_;
1227 }
1228 if (cached_has_bits & 0x00000200u) {
1229 _this->_impl_.rptr_ = from._impl_.rptr_;
1230 }
1231 if (cached_has_bits & 0x00000400u) {
1232 _this->_impl_.wptr_ = from._impl_.wptr_;
1233 }
1234 if (cached_has_bits & 0x00000800u) {
1235 _this->_impl_.q_inflight_ = from._impl_.q_inflight_;
1236 }
1237 if (cached_has_bits & 0x00001000u) {
1238 _this->_impl_.dispatch_queue_ = from._impl_.dispatch_queue_;
1239 }
1240 _this->_impl_._has_bits_[0] |= cached_has_bits;
1241 }
1242 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1243 }
1244
CopyFrom(const KgslAdrenoCmdbatchSubmittedFtraceEvent & from)1245 void KgslAdrenoCmdbatchSubmittedFtraceEvent::CopyFrom(const KgslAdrenoCmdbatchSubmittedFtraceEvent& from) {
1246 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent)
1247 if (&from == this) return;
1248 Clear();
1249 MergeFrom(from);
1250 }
1251
IsInitialized() const1252 bool KgslAdrenoCmdbatchSubmittedFtraceEvent::IsInitialized() const {
1253 return true;
1254 }
1255
InternalSwap(KgslAdrenoCmdbatchSubmittedFtraceEvent * other)1256 void KgslAdrenoCmdbatchSubmittedFtraceEvent::InternalSwap(KgslAdrenoCmdbatchSubmittedFtraceEvent* other) {
1257 using std::swap;
1258 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1259 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1260 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1261 PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchSubmittedFtraceEvent, _impl_.dispatch_queue_)
1262 + sizeof(KgslAdrenoCmdbatchSubmittedFtraceEvent::_impl_.dispatch_queue_) // NOLINT
1263 - PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchSubmittedFtraceEvent, _impl_.id_)>(
1264 reinterpret_cast<char*>(&_impl_.id_),
1265 reinterpret_cast<char*>(&other->_impl_.id_));
1266 }
1267
GetTypeName() const1268 std::string KgslAdrenoCmdbatchSubmittedFtraceEvent::GetTypeName() const {
1269 return "perfetto.protos.KgslAdrenoCmdbatchSubmittedFtraceEvent";
1270 }
1271
1272
1273 // ===================================================================
1274
1275 class KgslAdrenoCmdbatchSyncFtraceEvent::_Internal {
1276 public:
1277 using HasBits = decltype(std::declval<KgslAdrenoCmdbatchSyncFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)1278 static void set_has_id(HasBits* has_bits) {
1279 (*has_bits)[0] |= 1u;
1280 }
set_has_timestamp(HasBits * has_bits)1281 static void set_has_timestamp(HasBits* has_bits) {
1282 (*has_bits)[0] |= 2u;
1283 }
set_has_ticks(HasBits * has_bits)1284 static void set_has_ticks(HasBits* has_bits) {
1285 (*has_bits)[0] |= 4u;
1286 }
set_has_prio(HasBits * has_bits)1287 static void set_has_prio(HasBits* has_bits) {
1288 (*has_bits)[0] |= 8u;
1289 }
1290 };
1291
KgslAdrenoCmdbatchSyncFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1292 KgslAdrenoCmdbatchSyncFtraceEvent::KgslAdrenoCmdbatchSyncFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1293 bool is_message_owned)
1294 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1295 SharedCtor(arena, is_message_owned);
1296 // @@protoc_insertion_point(arena_constructor:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1297 }
KgslAdrenoCmdbatchSyncFtraceEvent(const KgslAdrenoCmdbatchSyncFtraceEvent & from)1298 KgslAdrenoCmdbatchSyncFtraceEvent::KgslAdrenoCmdbatchSyncFtraceEvent(const KgslAdrenoCmdbatchSyncFtraceEvent& from)
1299 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1300 KgslAdrenoCmdbatchSyncFtraceEvent* const _this = this; (void)_this;
1301 new (&_impl_) Impl_{
1302 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1303 , /*decltype(_impl_._cached_size_)*/{}
1304 , decltype(_impl_.id_){}
1305 , decltype(_impl_.timestamp_){}
1306 , decltype(_impl_.ticks_){}
1307 , decltype(_impl_.prio_){}};
1308
1309 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1310 ::memcpy(&_impl_.id_, &from._impl_.id_,
1311 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.prio_) -
1312 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.prio_));
1313 // @@protoc_insertion_point(copy_constructor:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1314 }
1315
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1316 inline void KgslAdrenoCmdbatchSyncFtraceEvent::SharedCtor(
1317 ::_pb::Arena* arena, bool is_message_owned) {
1318 (void)arena;
1319 (void)is_message_owned;
1320 new (&_impl_) Impl_{
1321 decltype(_impl_._has_bits_){}
1322 , /*decltype(_impl_._cached_size_)*/{}
1323 , decltype(_impl_.id_){0u}
1324 , decltype(_impl_.timestamp_){0u}
1325 , decltype(_impl_.ticks_){::uint64_t{0u}}
1326 , decltype(_impl_.prio_){0}
1327 };
1328 }
1329
~KgslAdrenoCmdbatchSyncFtraceEvent()1330 KgslAdrenoCmdbatchSyncFtraceEvent::~KgslAdrenoCmdbatchSyncFtraceEvent() {
1331 // @@protoc_insertion_point(destructor:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1332 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1333 (void)arena;
1334 return;
1335 }
1336 SharedDtor();
1337 }
1338
SharedDtor()1339 inline void KgslAdrenoCmdbatchSyncFtraceEvent::SharedDtor() {
1340 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1341 }
1342
SetCachedSize(int size) const1343 void KgslAdrenoCmdbatchSyncFtraceEvent::SetCachedSize(int size) const {
1344 _impl_._cached_size_.Set(size);
1345 }
1346
Clear()1347 void KgslAdrenoCmdbatchSyncFtraceEvent::Clear() {
1348 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1349 ::uint32_t cached_has_bits = 0;
1350 // Prevent compiler warnings about cached_has_bits being unused
1351 (void) cached_has_bits;
1352
1353 cached_has_bits = _impl_._has_bits_[0];
1354 if (cached_has_bits & 0x0000000fu) {
1355 ::memset(&_impl_.id_, 0, static_cast<size_t>(
1356 reinterpret_cast<char*>(&_impl_.prio_) -
1357 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.prio_));
1358 }
1359 _impl_._has_bits_.Clear();
1360 _internal_metadata_.Clear<std::string>();
1361 }
1362
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1363 const char* KgslAdrenoCmdbatchSyncFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1364 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1365 _Internal::HasBits has_bits{};
1366 while (!ctx->Done(&ptr)) {
1367 ::uint32_t tag;
1368 ptr = ::_pbi::ReadTag(ptr, &tag);
1369 switch (tag >> 3) {
1370 // optional uint32 id = 1;
1371 case 1:
1372 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1373 _Internal::set_has_id(&has_bits);
1374 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1375 CHK_(ptr);
1376 } else {
1377 goto handle_unusual;
1378 }
1379 continue;
1380 // optional uint32 timestamp = 2;
1381 case 2:
1382 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1383 _Internal::set_has_timestamp(&has_bits);
1384 _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1385 CHK_(ptr);
1386 } else {
1387 goto handle_unusual;
1388 }
1389 continue;
1390 // optional uint64 ticks = 3;
1391 case 3:
1392 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1393 _Internal::set_has_ticks(&has_bits);
1394 _impl_.ticks_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1395 CHK_(ptr);
1396 } else {
1397 goto handle_unusual;
1398 }
1399 continue;
1400 // optional int32 prio = 4;
1401 case 4:
1402 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1403 _Internal::set_has_prio(&has_bits);
1404 _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1405 CHK_(ptr);
1406 } else {
1407 goto handle_unusual;
1408 }
1409 continue;
1410 default:
1411 goto handle_unusual;
1412 } // switch
1413 handle_unusual:
1414 if ((tag == 0) || ((tag & 7) == 4)) {
1415 CHK_(ptr);
1416 ctx->SetLastTag(tag);
1417 goto message_done;
1418 }
1419 ptr = UnknownFieldParse(
1420 tag,
1421 _internal_metadata_.mutable_unknown_fields<std::string>(),
1422 ptr, ctx);
1423 CHK_(ptr != nullptr);
1424 } // while
1425 message_done:
1426 _impl_._has_bits_.Or(has_bits);
1427 return ptr;
1428 failure:
1429 ptr = nullptr;
1430 goto message_done;
1431 #undef CHK_
1432 }
1433
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1434 ::uint8_t* KgslAdrenoCmdbatchSyncFtraceEvent::_InternalSerialize(
1435 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1436 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1437 ::uint32_t cached_has_bits = 0;
1438 (void) cached_has_bits;
1439
1440 cached_has_bits = _impl_._has_bits_[0];
1441 // optional uint32 id = 1;
1442 if (cached_has_bits & 0x00000001u) {
1443 target = stream->EnsureSpace(target);
1444 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
1445 }
1446
1447 // optional uint32 timestamp = 2;
1448 if (cached_has_bits & 0x00000002u) {
1449 target = stream->EnsureSpace(target);
1450 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_timestamp(), target);
1451 }
1452
1453 // optional uint64 ticks = 3;
1454 if (cached_has_bits & 0x00000004u) {
1455 target = stream->EnsureSpace(target);
1456 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_ticks(), target);
1457 }
1458
1459 // optional int32 prio = 4;
1460 if (cached_has_bits & 0x00000008u) {
1461 target = stream->EnsureSpace(target);
1462 target = ::_pbi::WireFormatLite::WriteInt32ToArray(4, this->_internal_prio(), target);
1463 }
1464
1465 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1466 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1467 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1468 }
1469 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1470 return target;
1471 }
1472
ByteSizeLong() const1473 size_t KgslAdrenoCmdbatchSyncFtraceEvent::ByteSizeLong() const {
1474 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1475 size_t total_size = 0;
1476
1477 ::uint32_t cached_has_bits = 0;
1478 // Prevent compiler warnings about cached_has_bits being unused
1479 (void) cached_has_bits;
1480
1481 cached_has_bits = _impl_._has_bits_[0];
1482 if (cached_has_bits & 0x0000000fu) {
1483 // optional uint32 id = 1;
1484 if (cached_has_bits & 0x00000001u) {
1485 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
1486 }
1487
1488 // optional uint32 timestamp = 2;
1489 if (cached_has_bits & 0x00000002u) {
1490 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timestamp());
1491 }
1492
1493 // optional uint64 ticks = 3;
1494 if (cached_has_bits & 0x00000004u) {
1495 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_ticks());
1496 }
1497
1498 // optional int32 prio = 4;
1499 if (cached_has_bits & 0x00000008u) {
1500 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
1501 }
1502
1503 }
1504 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1505 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1506 }
1507 int cached_size = ::_pbi::ToCachedSize(total_size);
1508 SetCachedSize(cached_size);
1509 return total_size;
1510 }
1511
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1512 void KgslAdrenoCmdbatchSyncFtraceEvent::CheckTypeAndMergeFrom(
1513 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1514 MergeFrom(*::_pbi::DownCast<const KgslAdrenoCmdbatchSyncFtraceEvent*>(
1515 &from));
1516 }
1517
MergeFrom(const KgslAdrenoCmdbatchSyncFtraceEvent & from)1518 void KgslAdrenoCmdbatchSyncFtraceEvent::MergeFrom(const KgslAdrenoCmdbatchSyncFtraceEvent& from) {
1519 KgslAdrenoCmdbatchSyncFtraceEvent* const _this = this;
1520 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1521 GOOGLE_DCHECK_NE(&from, _this);
1522 ::uint32_t cached_has_bits = 0;
1523 (void) cached_has_bits;
1524
1525 cached_has_bits = from._impl_._has_bits_[0];
1526 if (cached_has_bits & 0x0000000fu) {
1527 if (cached_has_bits & 0x00000001u) {
1528 _this->_impl_.id_ = from._impl_.id_;
1529 }
1530 if (cached_has_bits & 0x00000002u) {
1531 _this->_impl_.timestamp_ = from._impl_.timestamp_;
1532 }
1533 if (cached_has_bits & 0x00000004u) {
1534 _this->_impl_.ticks_ = from._impl_.ticks_;
1535 }
1536 if (cached_has_bits & 0x00000008u) {
1537 _this->_impl_.prio_ = from._impl_.prio_;
1538 }
1539 _this->_impl_._has_bits_[0] |= cached_has_bits;
1540 }
1541 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1542 }
1543
CopyFrom(const KgslAdrenoCmdbatchSyncFtraceEvent & from)1544 void KgslAdrenoCmdbatchSyncFtraceEvent::CopyFrom(const KgslAdrenoCmdbatchSyncFtraceEvent& from) {
1545 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent)
1546 if (&from == this) return;
1547 Clear();
1548 MergeFrom(from);
1549 }
1550
IsInitialized() const1551 bool KgslAdrenoCmdbatchSyncFtraceEvent::IsInitialized() const {
1552 return true;
1553 }
1554
InternalSwap(KgslAdrenoCmdbatchSyncFtraceEvent * other)1555 void KgslAdrenoCmdbatchSyncFtraceEvent::InternalSwap(KgslAdrenoCmdbatchSyncFtraceEvent* other) {
1556 using std::swap;
1557 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1558 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1559 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1560 PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchSyncFtraceEvent, _impl_.prio_)
1561 + sizeof(KgslAdrenoCmdbatchSyncFtraceEvent::_impl_.prio_) // NOLINT
1562 - PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchSyncFtraceEvent, _impl_.id_)>(
1563 reinterpret_cast<char*>(&_impl_.id_),
1564 reinterpret_cast<char*>(&other->_impl_.id_));
1565 }
1566
GetTypeName() const1567 std::string KgslAdrenoCmdbatchSyncFtraceEvent::GetTypeName() const {
1568 return "perfetto.protos.KgslAdrenoCmdbatchSyncFtraceEvent";
1569 }
1570
1571
1572 // ===================================================================
1573
1574 class KgslAdrenoCmdbatchRetiredFtraceEvent::_Internal {
1575 public:
1576 using HasBits = decltype(std::declval<KgslAdrenoCmdbatchRetiredFtraceEvent>()._impl_._has_bits_);
set_has_id(HasBits * has_bits)1577 static void set_has_id(HasBits* has_bits) {
1578 (*has_bits)[0] |= 1u;
1579 }
set_has_timestamp(HasBits * has_bits)1580 static void set_has_timestamp(HasBits* has_bits) {
1581 (*has_bits)[0] |= 2u;
1582 }
set_has_inflight(HasBits * has_bits)1583 static void set_has_inflight(HasBits* has_bits) {
1584 (*has_bits)[0] |= 4u;
1585 }
set_has_recovery(HasBits * has_bits)1586 static void set_has_recovery(HasBits* has_bits) {
1587 (*has_bits)[0] |= 8u;
1588 }
set_has_flags(HasBits * has_bits)1589 static void set_has_flags(HasBits* has_bits) {
1590 (*has_bits)[0] |= 16u;
1591 }
set_has_start(HasBits * has_bits)1592 static void set_has_start(HasBits* has_bits) {
1593 (*has_bits)[0] |= 32u;
1594 }
set_has_retire(HasBits * has_bits)1595 static void set_has_retire(HasBits* has_bits) {
1596 (*has_bits)[0] |= 64u;
1597 }
set_has_prio(HasBits * has_bits)1598 static void set_has_prio(HasBits* has_bits) {
1599 (*has_bits)[0] |= 128u;
1600 }
set_has_rb_id(HasBits * has_bits)1601 static void set_has_rb_id(HasBits* has_bits) {
1602 (*has_bits)[0] |= 256u;
1603 }
set_has_rptr(HasBits * has_bits)1604 static void set_has_rptr(HasBits* has_bits) {
1605 (*has_bits)[0] |= 512u;
1606 }
set_has_wptr(HasBits * has_bits)1607 static void set_has_wptr(HasBits* has_bits) {
1608 (*has_bits)[0] |= 1024u;
1609 }
set_has_q_inflight(HasBits * has_bits)1610 static void set_has_q_inflight(HasBits* has_bits) {
1611 (*has_bits)[0] |= 4096u;
1612 }
set_has_fault_recovery(HasBits * has_bits)1613 static void set_has_fault_recovery(HasBits* has_bits) {
1614 (*has_bits)[0] |= 2048u;
1615 }
set_has_dispatch_queue(HasBits * has_bits)1616 static void set_has_dispatch_queue(HasBits* has_bits) {
1617 (*has_bits)[0] |= 8192u;
1618 }
set_has_submitted_to_rb(HasBits * has_bits)1619 static void set_has_submitted_to_rb(HasBits* has_bits) {
1620 (*has_bits)[0] |= 16384u;
1621 }
set_has_retired_on_gmu(HasBits * has_bits)1622 static void set_has_retired_on_gmu(HasBits* has_bits) {
1623 (*has_bits)[0] |= 32768u;
1624 }
set_has_active(HasBits * has_bits)1625 static void set_has_active(HasBits* has_bits) {
1626 (*has_bits)[0] |= 65536u;
1627 }
1628 };
1629
KgslAdrenoCmdbatchRetiredFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1630 KgslAdrenoCmdbatchRetiredFtraceEvent::KgslAdrenoCmdbatchRetiredFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1631 bool is_message_owned)
1632 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1633 SharedCtor(arena, is_message_owned);
1634 // @@protoc_insertion_point(arena_constructor:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
1635 }
KgslAdrenoCmdbatchRetiredFtraceEvent(const KgslAdrenoCmdbatchRetiredFtraceEvent & from)1636 KgslAdrenoCmdbatchRetiredFtraceEvent::KgslAdrenoCmdbatchRetiredFtraceEvent(const KgslAdrenoCmdbatchRetiredFtraceEvent& from)
1637 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1638 KgslAdrenoCmdbatchRetiredFtraceEvent* const _this = this; (void)_this;
1639 new (&_impl_) Impl_{
1640 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1641 , /*decltype(_impl_._cached_size_)*/{}
1642 , decltype(_impl_.id_){}
1643 , decltype(_impl_.timestamp_){}
1644 , decltype(_impl_.inflight_){}
1645 , decltype(_impl_.recovery_){}
1646 , decltype(_impl_.flags_){}
1647 , decltype(_impl_.start_){}
1648 , decltype(_impl_.retire_){}
1649 , decltype(_impl_.prio_){}
1650 , decltype(_impl_.rb_id_){}
1651 , decltype(_impl_.rptr_){}
1652 , decltype(_impl_.wptr_){}
1653 , decltype(_impl_.fault_recovery_){}
1654 , decltype(_impl_.q_inflight_){}
1655 , decltype(_impl_.dispatch_queue_){}
1656 , decltype(_impl_.submitted_to_rb_){}
1657 , decltype(_impl_.retired_on_gmu_){}
1658 , decltype(_impl_.active_){}};
1659
1660 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1661 ::memcpy(&_impl_.id_, &from._impl_.id_,
1662 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.active_) -
1663 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.active_));
1664 // @@protoc_insertion_point(copy_constructor:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
1665 }
1666
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1667 inline void KgslAdrenoCmdbatchRetiredFtraceEvent::SharedCtor(
1668 ::_pb::Arena* arena, bool is_message_owned) {
1669 (void)arena;
1670 (void)is_message_owned;
1671 new (&_impl_) Impl_{
1672 decltype(_impl_._has_bits_){}
1673 , /*decltype(_impl_._cached_size_)*/{}
1674 , decltype(_impl_.id_){0u}
1675 , decltype(_impl_.timestamp_){0u}
1676 , decltype(_impl_.inflight_){::int64_t{0}}
1677 , decltype(_impl_.recovery_){0u}
1678 , decltype(_impl_.flags_){0u}
1679 , decltype(_impl_.start_){::uint64_t{0u}}
1680 , decltype(_impl_.retire_){::uint64_t{0u}}
1681 , decltype(_impl_.prio_){0}
1682 , decltype(_impl_.rb_id_){0}
1683 , decltype(_impl_.rptr_){0u}
1684 , decltype(_impl_.wptr_){0u}
1685 , decltype(_impl_.fault_recovery_){::uint64_t{0u}}
1686 , decltype(_impl_.q_inflight_){0}
1687 , decltype(_impl_.dispatch_queue_){0u}
1688 , decltype(_impl_.submitted_to_rb_){::uint64_t{0u}}
1689 , decltype(_impl_.retired_on_gmu_){::uint64_t{0u}}
1690 , decltype(_impl_.active_){::uint64_t{0u}}
1691 };
1692 }
1693
~KgslAdrenoCmdbatchRetiredFtraceEvent()1694 KgslAdrenoCmdbatchRetiredFtraceEvent::~KgslAdrenoCmdbatchRetiredFtraceEvent() {
1695 // @@protoc_insertion_point(destructor:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
1696 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1697 (void)arena;
1698 return;
1699 }
1700 SharedDtor();
1701 }
1702
SharedDtor()1703 inline void KgslAdrenoCmdbatchRetiredFtraceEvent::SharedDtor() {
1704 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1705 }
1706
SetCachedSize(int size) const1707 void KgslAdrenoCmdbatchRetiredFtraceEvent::SetCachedSize(int size) const {
1708 _impl_._cached_size_.Set(size);
1709 }
1710
Clear()1711 void KgslAdrenoCmdbatchRetiredFtraceEvent::Clear() {
1712 // @@protoc_insertion_point(message_clear_start:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
1713 ::uint32_t cached_has_bits = 0;
1714 // Prevent compiler warnings about cached_has_bits being unused
1715 (void) cached_has_bits;
1716
1717 cached_has_bits = _impl_._has_bits_[0];
1718 if (cached_has_bits & 0x000000ffu) {
1719 ::memset(&_impl_.id_, 0, static_cast<size_t>(
1720 reinterpret_cast<char*>(&_impl_.prio_) -
1721 reinterpret_cast<char*>(&_impl_.id_)) + sizeof(_impl_.prio_));
1722 }
1723 if (cached_has_bits & 0x0000ff00u) {
1724 ::memset(&_impl_.rb_id_, 0, static_cast<size_t>(
1725 reinterpret_cast<char*>(&_impl_.retired_on_gmu_) -
1726 reinterpret_cast<char*>(&_impl_.rb_id_)) + sizeof(_impl_.retired_on_gmu_));
1727 }
1728 _impl_.active_ = ::uint64_t{0u};
1729 _impl_._has_bits_.Clear();
1730 _internal_metadata_.Clear<std::string>();
1731 }
1732
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1733 const char* KgslAdrenoCmdbatchRetiredFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1734 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1735 _Internal::HasBits has_bits{};
1736 while (!ctx->Done(&ptr)) {
1737 ::uint32_t tag;
1738 ptr = ::_pbi::ReadTag(ptr, &tag);
1739 switch (tag >> 3) {
1740 // optional uint32 id = 1;
1741 case 1:
1742 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1743 _Internal::set_has_id(&has_bits);
1744 _impl_.id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1745 CHK_(ptr);
1746 } else {
1747 goto handle_unusual;
1748 }
1749 continue;
1750 // optional uint32 timestamp = 2;
1751 case 2:
1752 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1753 _Internal::set_has_timestamp(&has_bits);
1754 _impl_.timestamp_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1755 CHK_(ptr);
1756 } else {
1757 goto handle_unusual;
1758 }
1759 continue;
1760 // optional int64 inflight = 3;
1761 case 3:
1762 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1763 _Internal::set_has_inflight(&has_bits);
1764 _impl_.inflight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1765 CHK_(ptr);
1766 } else {
1767 goto handle_unusual;
1768 }
1769 continue;
1770 // optional uint32 recovery = 4;
1771 case 4:
1772 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1773 _Internal::set_has_recovery(&has_bits);
1774 _impl_.recovery_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1775 CHK_(ptr);
1776 } else {
1777 goto handle_unusual;
1778 }
1779 continue;
1780 // optional uint32 flags = 5;
1781 case 5:
1782 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1783 _Internal::set_has_flags(&has_bits);
1784 _impl_.flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1785 CHK_(ptr);
1786 } else {
1787 goto handle_unusual;
1788 }
1789 continue;
1790 // optional uint64 start = 6;
1791 case 6:
1792 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1793 _Internal::set_has_start(&has_bits);
1794 _impl_.start_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1795 CHK_(ptr);
1796 } else {
1797 goto handle_unusual;
1798 }
1799 continue;
1800 // optional uint64 retire = 7;
1801 case 7:
1802 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1803 _Internal::set_has_retire(&has_bits);
1804 _impl_.retire_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1805 CHK_(ptr);
1806 } else {
1807 goto handle_unusual;
1808 }
1809 continue;
1810 // optional int32 prio = 8;
1811 case 8:
1812 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1813 _Internal::set_has_prio(&has_bits);
1814 _impl_.prio_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1815 CHK_(ptr);
1816 } else {
1817 goto handle_unusual;
1818 }
1819 continue;
1820 // optional int32 rb_id = 9;
1821 case 9:
1822 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1823 _Internal::set_has_rb_id(&has_bits);
1824 _impl_.rb_id_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1825 CHK_(ptr);
1826 } else {
1827 goto handle_unusual;
1828 }
1829 continue;
1830 // optional uint32 rptr = 10;
1831 case 10:
1832 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1833 _Internal::set_has_rptr(&has_bits);
1834 _impl_.rptr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1835 CHK_(ptr);
1836 } else {
1837 goto handle_unusual;
1838 }
1839 continue;
1840 // optional uint32 wptr = 11;
1841 case 11:
1842 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1843 _Internal::set_has_wptr(&has_bits);
1844 _impl_.wptr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1845 CHK_(ptr);
1846 } else {
1847 goto handle_unusual;
1848 }
1849 continue;
1850 // optional int32 q_inflight = 12;
1851 case 12:
1852 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 96)) {
1853 _Internal::set_has_q_inflight(&has_bits);
1854 _impl_.q_inflight_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1855 CHK_(ptr);
1856 } else {
1857 goto handle_unusual;
1858 }
1859 continue;
1860 // optional uint64 fault_recovery = 13;
1861 case 13:
1862 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 104)) {
1863 _Internal::set_has_fault_recovery(&has_bits);
1864 _impl_.fault_recovery_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1865 CHK_(ptr);
1866 } else {
1867 goto handle_unusual;
1868 }
1869 continue;
1870 // optional uint32 dispatch_queue = 14;
1871 case 14:
1872 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 112)) {
1873 _Internal::set_has_dispatch_queue(&has_bits);
1874 _impl_.dispatch_queue_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1875 CHK_(ptr);
1876 } else {
1877 goto handle_unusual;
1878 }
1879 continue;
1880 // optional uint64 submitted_to_rb = 15;
1881 case 15:
1882 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 120)) {
1883 _Internal::set_has_submitted_to_rb(&has_bits);
1884 _impl_.submitted_to_rb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1885 CHK_(ptr);
1886 } else {
1887 goto handle_unusual;
1888 }
1889 continue;
1890 // optional uint64 retired_on_gmu = 16;
1891 case 16:
1892 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 128)) {
1893 _Internal::set_has_retired_on_gmu(&has_bits);
1894 _impl_.retired_on_gmu_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1895 CHK_(ptr);
1896 } else {
1897 goto handle_unusual;
1898 }
1899 continue;
1900 // optional uint64 active = 17;
1901 case 17:
1902 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 136)) {
1903 _Internal::set_has_active(&has_bits);
1904 _impl_.active_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1905 CHK_(ptr);
1906 } else {
1907 goto handle_unusual;
1908 }
1909 continue;
1910 default:
1911 goto handle_unusual;
1912 } // switch
1913 handle_unusual:
1914 if ((tag == 0) || ((tag & 7) == 4)) {
1915 CHK_(ptr);
1916 ctx->SetLastTag(tag);
1917 goto message_done;
1918 }
1919 ptr = UnknownFieldParse(
1920 tag,
1921 _internal_metadata_.mutable_unknown_fields<std::string>(),
1922 ptr, ctx);
1923 CHK_(ptr != nullptr);
1924 } // while
1925 message_done:
1926 _impl_._has_bits_.Or(has_bits);
1927 return ptr;
1928 failure:
1929 ptr = nullptr;
1930 goto message_done;
1931 #undef CHK_
1932 }
1933
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1934 ::uint8_t* KgslAdrenoCmdbatchRetiredFtraceEvent::_InternalSerialize(
1935 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1936 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
1937 ::uint32_t cached_has_bits = 0;
1938 (void) cached_has_bits;
1939
1940 cached_has_bits = _impl_._has_bits_[0];
1941 // optional uint32 id = 1;
1942 if (cached_has_bits & 0x00000001u) {
1943 target = stream->EnsureSpace(target);
1944 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(1, this->_internal_id(), target);
1945 }
1946
1947 // optional uint32 timestamp = 2;
1948 if (cached_has_bits & 0x00000002u) {
1949 target = stream->EnsureSpace(target);
1950 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_timestamp(), target);
1951 }
1952
1953 // optional int64 inflight = 3;
1954 if (cached_has_bits & 0x00000004u) {
1955 target = stream->EnsureSpace(target);
1956 target = ::_pbi::WireFormatLite::WriteInt64ToArray(3, this->_internal_inflight(), target);
1957 }
1958
1959 // optional uint32 recovery = 4;
1960 if (cached_has_bits & 0x00000008u) {
1961 target = stream->EnsureSpace(target);
1962 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_recovery(), target);
1963 }
1964
1965 // optional uint32 flags = 5;
1966 if (cached_has_bits & 0x00000010u) {
1967 target = stream->EnsureSpace(target);
1968 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_flags(), target);
1969 }
1970
1971 // optional uint64 start = 6;
1972 if (cached_has_bits & 0x00000020u) {
1973 target = stream->EnsureSpace(target);
1974 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_start(), target);
1975 }
1976
1977 // optional uint64 retire = 7;
1978 if (cached_has_bits & 0x00000040u) {
1979 target = stream->EnsureSpace(target);
1980 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_retire(), target);
1981 }
1982
1983 // optional int32 prio = 8;
1984 if (cached_has_bits & 0x00000080u) {
1985 target = stream->EnsureSpace(target);
1986 target = ::_pbi::WireFormatLite::WriteInt32ToArray(8, this->_internal_prio(), target);
1987 }
1988
1989 // optional int32 rb_id = 9;
1990 if (cached_has_bits & 0x00000100u) {
1991 target = stream->EnsureSpace(target);
1992 target = ::_pbi::WireFormatLite::WriteInt32ToArray(9, this->_internal_rb_id(), target);
1993 }
1994
1995 // optional uint32 rptr = 10;
1996 if (cached_has_bits & 0x00000200u) {
1997 target = stream->EnsureSpace(target);
1998 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_rptr(), target);
1999 }
2000
2001 // optional uint32 wptr = 11;
2002 if (cached_has_bits & 0x00000400u) {
2003 target = stream->EnsureSpace(target);
2004 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(11, this->_internal_wptr(), target);
2005 }
2006
2007 // optional int32 q_inflight = 12;
2008 if (cached_has_bits & 0x00001000u) {
2009 target = stream->EnsureSpace(target);
2010 target = ::_pbi::WireFormatLite::WriteInt32ToArray(12, this->_internal_q_inflight(), target);
2011 }
2012
2013 // optional uint64 fault_recovery = 13;
2014 if (cached_has_bits & 0x00000800u) {
2015 target = stream->EnsureSpace(target);
2016 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(13, this->_internal_fault_recovery(), target);
2017 }
2018
2019 // optional uint32 dispatch_queue = 14;
2020 if (cached_has_bits & 0x00002000u) {
2021 target = stream->EnsureSpace(target);
2022 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(14, this->_internal_dispatch_queue(), target);
2023 }
2024
2025 // optional uint64 submitted_to_rb = 15;
2026 if (cached_has_bits & 0x00004000u) {
2027 target = stream->EnsureSpace(target);
2028 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(15, this->_internal_submitted_to_rb(), target);
2029 }
2030
2031 // optional uint64 retired_on_gmu = 16;
2032 if (cached_has_bits & 0x00008000u) {
2033 target = stream->EnsureSpace(target);
2034 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(16, this->_internal_retired_on_gmu(), target);
2035 }
2036
2037 // optional uint64 active = 17;
2038 if (cached_has_bits & 0x00010000u) {
2039 target = stream->EnsureSpace(target);
2040 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(17, this->_internal_active(), target);
2041 }
2042
2043 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2044 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
2045 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
2046 }
2047 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
2048 return target;
2049 }
2050
ByteSizeLong() const2051 size_t KgslAdrenoCmdbatchRetiredFtraceEvent::ByteSizeLong() const {
2052 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
2053 size_t total_size = 0;
2054
2055 ::uint32_t cached_has_bits = 0;
2056 // Prevent compiler warnings about cached_has_bits being unused
2057 (void) cached_has_bits;
2058
2059 cached_has_bits = _impl_._has_bits_[0];
2060 if (cached_has_bits & 0x000000ffu) {
2061 // optional uint32 id = 1;
2062 if (cached_has_bits & 0x00000001u) {
2063 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_id());
2064 }
2065
2066 // optional uint32 timestamp = 2;
2067 if (cached_has_bits & 0x00000002u) {
2068 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_timestamp());
2069 }
2070
2071 // optional int64 inflight = 3;
2072 if (cached_has_bits & 0x00000004u) {
2073 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_inflight());
2074 }
2075
2076 // optional uint32 recovery = 4;
2077 if (cached_has_bits & 0x00000008u) {
2078 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_recovery());
2079 }
2080
2081 // optional uint32 flags = 5;
2082 if (cached_has_bits & 0x00000010u) {
2083 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_flags());
2084 }
2085
2086 // optional uint64 start = 6;
2087 if (cached_has_bits & 0x00000020u) {
2088 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_start());
2089 }
2090
2091 // optional uint64 retire = 7;
2092 if (cached_has_bits & 0x00000040u) {
2093 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_retire());
2094 }
2095
2096 // optional int32 prio = 8;
2097 if (cached_has_bits & 0x00000080u) {
2098 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_prio());
2099 }
2100
2101 }
2102 if (cached_has_bits & 0x0000ff00u) {
2103 // optional int32 rb_id = 9;
2104 if (cached_has_bits & 0x00000100u) {
2105 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_rb_id());
2106 }
2107
2108 // optional uint32 rptr = 10;
2109 if (cached_has_bits & 0x00000200u) {
2110 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_rptr());
2111 }
2112
2113 // optional uint32 wptr = 11;
2114 if (cached_has_bits & 0x00000400u) {
2115 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_wptr());
2116 }
2117
2118 // optional uint64 fault_recovery = 13;
2119 if (cached_has_bits & 0x00000800u) {
2120 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_fault_recovery());
2121 }
2122
2123 // optional int32 q_inflight = 12;
2124 if (cached_has_bits & 0x00001000u) {
2125 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_q_inflight());
2126 }
2127
2128 // optional uint32 dispatch_queue = 14;
2129 if (cached_has_bits & 0x00002000u) {
2130 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_dispatch_queue());
2131 }
2132
2133 // optional uint64 submitted_to_rb = 15;
2134 if (cached_has_bits & 0x00004000u) {
2135 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_submitted_to_rb());
2136 }
2137
2138 // optional uint64 retired_on_gmu = 16;
2139 if (cached_has_bits & 0x00008000u) {
2140 total_size += 2 +
2141 ::_pbi::WireFormatLite::UInt64Size(
2142 this->_internal_retired_on_gmu());
2143 }
2144
2145 }
2146 // optional uint64 active = 17;
2147 if (cached_has_bits & 0x00010000u) {
2148 total_size += 2 +
2149 ::_pbi::WireFormatLite::UInt64Size(
2150 this->_internal_active());
2151 }
2152
2153 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
2154 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
2155 }
2156 int cached_size = ::_pbi::ToCachedSize(total_size);
2157 SetCachedSize(cached_size);
2158 return total_size;
2159 }
2160
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)2161 void KgslAdrenoCmdbatchRetiredFtraceEvent::CheckTypeAndMergeFrom(
2162 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
2163 MergeFrom(*::_pbi::DownCast<const KgslAdrenoCmdbatchRetiredFtraceEvent*>(
2164 &from));
2165 }
2166
MergeFrom(const KgslAdrenoCmdbatchRetiredFtraceEvent & from)2167 void KgslAdrenoCmdbatchRetiredFtraceEvent::MergeFrom(const KgslAdrenoCmdbatchRetiredFtraceEvent& from) {
2168 KgslAdrenoCmdbatchRetiredFtraceEvent* const _this = this;
2169 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
2170 GOOGLE_DCHECK_NE(&from, _this);
2171 ::uint32_t cached_has_bits = 0;
2172 (void) cached_has_bits;
2173
2174 cached_has_bits = from._impl_._has_bits_[0];
2175 if (cached_has_bits & 0x000000ffu) {
2176 if (cached_has_bits & 0x00000001u) {
2177 _this->_impl_.id_ = from._impl_.id_;
2178 }
2179 if (cached_has_bits & 0x00000002u) {
2180 _this->_impl_.timestamp_ = from._impl_.timestamp_;
2181 }
2182 if (cached_has_bits & 0x00000004u) {
2183 _this->_impl_.inflight_ = from._impl_.inflight_;
2184 }
2185 if (cached_has_bits & 0x00000008u) {
2186 _this->_impl_.recovery_ = from._impl_.recovery_;
2187 }
2188 if (cached_has_bits & 0x00000010u) {
2189 _this->_impl_.flags_ = from._impl_.flags_;
2190 }
2191 if (cached_has_bits & 0x00000020u) {
2192 _this->_impl_.start_ = from._impl_.start_;
2193 }
2194 if (cached_has_bits & 0x00000040u) {
2195 _this->_impl_.retire_ = from._impl_.retire_;
2196 }
2197 if (cached_has_bits & 0x00000080u) {
2198 _this->_impl_.prio_ = from._impl_.prio_;
2199 }
2200 _this->_impl_._has_bits_[0] |= cached_has_bits;
2201 }
2202 if (cached_has_bits & 0x0000ff00u) {
2203 if (cached_has_bits & 0x00000100u) {
2204 _this->_impl_.rb_id_ = from._impl_.rb_id_;
2205 }
2206 if (cached_has_bits & 0x00000200u) {
2207 _this->_impl_.rptr_ = from._impl_.rptr_;
2208 }
2209 if (cached_has_bits & 0x00000400u) {
2210 _this->_impl_.wptr_ = from._impl_.wptr_;
2211 }
2212 if (cached_has_bits & 0x00000800u) {
2213 _this->_impl_.fault_recovery_ = from._impl_.fault_recovery_;
2214 }
2215 if (cached_has_bits & 0x00001000u) {
2216 _this->_impl_.q_inflight_ = from._impl_.q_inflight_;
2217 }
2218 if (cached_has_bits & 0x00002000u) {
2219 _this->_impl_.dispatch_queue_ = from._impl_.dispatch_queue_;
2220 }
2221 if (cached_has_bits & 0x00004000u) {
2222 _this->_impl_.submitted_to_rb_ = from._impl_.submitted_to_rb_;
2223 }
2224 if (cached_has_bits & 0x00008000u) {
2225 _this->_impl_.retired_on_gmu_ = from._impl_.retired_on_gmu_;
2226 }
2227 _this->_impl_._has_bits_[0] |= cached_has_bits;
2228 }
2229 if (cached_has_bits & 0x00010000u) {
2230 _this->_internal_set_active(from._internal_active());
2231 }
2232 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
2233 }
2234
CopyFrom(const KgslAdrenoCmdbatchRetiredFtraceEvent & from)2235 void KgslAdrenoCmdbatchRetiredFtraceEvent::CopyFrom(const KgslAdrenoCmdbatchRetiredFtraceEvent& from) {
2236 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent)
2237 if (&from == this) return;
2238 Clear();
2239 MergeFrom(from);
2240 }
2241
IsInitialized() const2242 bool KgslAdrenoCmdbatchRetiredFtraceEvent::IsInitialized() const {
2243 return true;
2244 }
2245
InternalSwap(KgslAdrenoCmdbatchRetiredFtraceEvent * other)2246 void KgslAdrenoCmdbatchRetiredFtraceEvent::InternalSwap(KgslAdrenoCmdbatchRetiredFtraceEvent* other) {
2247 using std::swap;
2248 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
2249 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
2250 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
2251 PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchRetiredFtraceEvent, _impl_.active_)
2252 + sizeof(KgslAdrenoCmdbatchRetiredFtraceEvent::_impl_.active_) // NOLINT
2253 - PROTOBUF_FIELD_OFFSET(KgslAdrenoCmdbatchRetiredFtraceEvent, _impl_.id_)>(
2254 reinterpret_cast<char*>(&_impl_.id_),
2255 reinterpret_cast<char*>(&other->_impl_.id_));
2256 }
2257
GetTypeName() const2258 std::string KgslAdrenoCmdbatchRetiredFtraceEvent::GetTypeName() const {
2259 return "perfetto.protos.KgslAdrenoCmdbatchRetiredFtraceEvent";
2260 }
2261
2262
2263 // @@protoc_insertion_point(namespace_scope)
2264 } // namespace protos
2265 } // namespace perfetto
2266 PROTOBUF_NAMESPACE_OPEN
2267 template<> PROTOBUF_NOINLINE ::perfetto::protos::KgslGpuFrequencyFtraceEvent*
CreateMaybeMessage(Arena * arena)2268 Arena::CreateMaybeMessage< ::perfetto::protos::KgslGpuFrequencyFtraceEvent >(Arena* arena) {
2269 return Arena::CreateMessageInternal< ::perfetto::protos::KgslGpuFrequencyFtraceEvent >(arena);
2270 }
2271 template<> PROTOBUF_NOINLINE ::perfetto::protos::KgslAdrenoCmdbatchQueuedFtraceEvent*
CreateMaybeMessage(Arena * arena)2272 Arena::CreateMaybeMessage< ::perfetto::protos::KgslAdrenoCmdbatchQueuedFtraceEvent >(Arena* arena) {
2273 return Arena::CreateMessageInternal< ::perfetto::protos::KgslAdrenoCmdbatchQueuedFtraceEvent >(arena);
2274 }
2275 template<> PROTOBUF_NOINLINE ::perfetto::protos::KgslAdrenoCmdbatchSubmittedFtraceEvent*
CreateMaybeMessage(Arena * arena)2276 Arena::CreateMaybeMessage< ::perfetto::protos::KgslAdrenoCmdbatchSubmittedFtraceEvent >(Arena* arena) {
2277 return Arena::CreateMessageInternal< ::perfetto::protos::KgslAdrenoCmdbatchSubmittedFtraceEvent >(arena);
2278 }
2279 template<> PROTOBUF_NOINLINE ::perfetto::protos::KgslAdrenoCmdbatchSyncFtraceEvent*
CreateMaybeMessage(Arena * arena)2280 Arena::CreateMaybeMessage< ::perfetto::protos::KgslAdrenoCmdbatchSyncFtraceEvent >(Arena* arena) {
2281 return Arena::CreateMessageInternal< ::perfetto::protos::KgslAdrenoCmdbatchSyncFtraceEvent >(arena);
2282 }
2283 template<> PROTOBUF_NOINLINE ::perfetto::protos::KgslAdrenoCmdbatchRetiredFtraceEvent*
CreateMaybeMessage(Arena * arena)2284 Arena::CreateMaybeMessage< ::perfetto::protos::KgslAdrenoCmdbatchRetiredFtraceEvent >(Arena* arena) {
2285 return Arena::CreateMessageInternal< ::perfetto::protos::KgslAdrenoCmdbatchRetiredFtraceEvent >(arena);
2286 }
2287 PROTOBUF_NAMESPACE_CLOSE
2288
2289 // @@protoc_insertion_point(global_scope)
2290 #include <google/protobuf/port_undef.inc>
2291