1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: protos/perfetto/trace/ftrace/vmscan.proto
3
4 #include "protos/perfetto/trace/ftrace/vmscan.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 {
MmVmscanDirectReclaimBeginFtraceEvent(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR MmVmscanDirectReclaimBeginFtraceEvent::MmVmscanDirectReclaimBeginFtraceEvent(
24 ::_pbi::ConstantInitialized): _impl_{
25 /*decltype(_impl_._has_bits_)*/{}
26 , /*decltype(_impl_._cached_size_)*/{}
27 , /*decltype(_impl_.order_)*/0
28 , /*decltype(_impl_.may_writepage_)*/0
29 , /*decltype(_impl_.gfp_flags_)*/0u} {}
30 struct MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal {
MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal31 PROTOBUF_CONSTEXPR MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal()
32 : _instance(::_pbi::ConstantInitialized{}) {}
~MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal33 ~MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal() {}
34 union { // NOLINT(misc-non-private-member-variables-in-classes)
35 MmVmscanDirectReclaimBeginFtraceEvent _instance;
36 };
37 };
38 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmVmscanDirectReclaimBeginFtraceEventDefaultTypeInternal _MmVmscanDirectReclaimBeginFtraceEvent_default_instance_;
MmVmscanDirectReclaimEndFtraceEvent(::_pbi::ConstantInitialized)39 PROTOBUF_CONSTEXPR MmVmscanDirectReclaimEndFtraceEvent::MmVmscanDirectReclaimEndFtraceEvent(
40 ::_pbi::ConstantInitialized): _impl_{
41 /*decltype(_impl_._has_bits_)*/{}
42 , /*decltype(_impl_._cached_size_)*/{}
43 , /*decltype(_impl_.nr_reclaimed_)*/::uint64_t{0u}} {}
44 struct MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal {
MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal45 PROTOBUF_CONSTEXPR MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal()
46 : _instance(::_pbi::ConstantInitialized{}) {}
~MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal47 ~MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal() {}
48 union { // NOLINT(misc-non-private-member-variables-in-classes)
49 MmVmscanDirectReclaimEndFtraceEvent _instance;
50 };
51 };
52 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmVmscanDirectReclaimEndFtraceEventDefaultTypeInternal _MmVmscanDirectReclaimEndFtraceEvent_default_instance_;
MmVmscanKswapdWakeFtraceEvent(::_pbi::ConstantInitialized)53 PROTOBUF_CONSTEXPR MmVmscanKswapdWakeFtraceEvent::MmVmscanKswapdWakeFtraceEvent(
54 ::_pbi::ConstantInitialized): _impl_{
55 /*decltype(_impl_._has_bits_)*/{}
56 , /*decltype(_impl_._cached_size_)*/{}
57 , /*decltype(_impl_.nid_)*/0
58 , /*decltype(_impl_.order_)*/0
59 , /*decltype(_impl_.zid_)*/0} {}
60 struct MmVmscanKswapdWakeFtraceEventDefaultTypeInternal {
MmVmscanKswapdWakeFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanKswapdWakeFtraceEventDefaultTypeInternal61 PROTOBUF_CONSTEXPR MmVmscanKswapdWakeFtraceEventDefaultTypeInternal()
62 : _instance(::_pbi::ConstantInitialized{}) {}
~MmVmscanKswapdWakeFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanKswapdWakeFtraceEventDefaultTypeInternal63 ~MmVmscanKswapdWakeFtraceEventDefaultTypeInternal() {}
64 union { // NOLINT(misc-non-private-member-variables-in-classes)
65 MmVmscanKswapdWakeFtraceEvent _instance;
66 };
67 };
68 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmVmscanKswapdWakeFtraceEventDefaultTypeInternal _MmVmscanKswapdWakeFtraceEvent_default_instance_;
MmVmscanKswapdSleepFtraceEvent(::_pbi::ConstantInitialized)69 PROTOBUF_CONSTEXPR MmVmscanKswapdSleepFtraceEvent::MmVmscanKswapdSleepFtraceEvent(
70 ::_pbi::ConstantInitialized): _impl_{
71 /*decltype(_impl_._has_bits_)*/{}
72 , /*decltype(_impl_._cached_size_)*/{}
73 , /*decltype(_impl_.nid_)*/0} {}
74 struct MmVmscanKswapdSleepFtraceEventDefaultTypeInternal {
MmVmscanKswapdSleepFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanKswapdSleepFtraceEventDefaultTypeInternal75 PROTOBUF_CONSTEXPR MmVmscanKswapdSleepFtraceEventDefaultTypeInternal()
76 : _instance(::_pbi::ConstantInitialized{}) {}
~MmVmscanKswapdSleepFtraceEventDefaultTypeInternalperfetto::protos::MmVmscanKswapdSleepFtraceEventDefaultTypeInternal77 ~MmVmscanKswapdSleepFtraceEventDefaultTypeInternal() {}
78 union { // NOLINT(misc-non-private-member-variables-in-classes)
79 MmVmscanKswapdSleepFtraceEvent _instance;
80 };
81 };
82 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmVmscanKswapdSleepFtraceEventDefaultTypeInternal _MmVmscanKswapdSleepFtraceEvent_default_instance_;
MmShrinkSlabStartFtraceEvent(::_pbi::ConstantInitialized)83 PROTOBUF_CONSTEXPR MmShrinkSlabStartFtraceEvent::MmShrinkSlabStartFtraceEvent(
84 ::_pbi::ConstantInitialized): _impl_{
85 /*decltype(_impl_._has_bits_)*/{}
86 , /*decltype(_impl_._cached_size_)*/{}
87 , /*decltype(_impl_.cache_items_)*/::uint64_t{0u}
88 , /*decltype(_impl_.delta_)*/::uint64_t{0u}
89 , /*decltype(_impl_.lru_pgs_)*/::uint64_t{0u}
90 , /*decltype(_impl_.nr_objects_to_shrink_)*/::int64_t{0}
91 , /*decltype(_impl_.pgs_scanned_)*/::uint64_t{0u}
92 , /*decltype(_impl_.gfp_flags_)*/0u
93 , /*decltype(_impl_.nid_)*/0
94 , /*decltype(_impl_.shr_)*/::uint64_t{0u}
95 , /*decltype(_impl_.shrink_)*/::uint64_t{0u}
96 , /*decltype(_impl_.total_scan_)*/::uint64_t{0u}
97 , /*decltype(_impl_.priority_)*/0} {}
98 struct MmShrinkSlabStartFtraceEventDefaultTypeInternal {
MmShrinkSlabStartFtraceEventDefaultTypeInternalperfetto::protos::MmShrinkSlabStartFtraceEventDefaultTypeInternal99 PROTOBUF_CONSTEXPR MmShrinkSlabStartFtraceEventDefaultTypeInternal()
100 : _instance(::_pbi::ConstantInitialized{}) {}
~MmShrinkSlabStartFtraceEventDefaultTypeInternalperfetto::protos::MmShrinkSlabStartFtraceEventDefaultTypeInternal101 ~MmShrinkSlabStartFtraceEventDefaultTypeInternal() {}
102 union { // NOLINT(misc-non-private-member-variables-in-classes)
103 MmShrinkSlabStartFtraceEvent _instance;
104 };
105 };
106 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmShrinkSlabStartFtraceEventDefaultTypeInternal _MmShrinkSlabStartFtraceEvent_default_instance_;
MmShrinkSlabEndFtraceEvent(::_pbi::ConstantInitialized)107 PROTOBUF_CONSTEXPR MmShrinkSlabEndFtraceEvent::MmShrinkSlabEndFtraceEvent(
108 ::_pbi::ConstantInitialized): _impl_{
109 /*decltype(_impl_._has_bits_)*/{}
110 , /*decltype(_impl_._cached_size_)*/{}
111 , /*decltype(_impl_.new_scan_)*/::int64_t{0}
112 , /*decltype(_impl_.shr_)*/::uint64_t{0u}
113 , /*decltype(_impl_.shrink_)*/::uint64_t{0u}
114 , /*decltype(_impl_.retval_)*/0
115 , /*decltype(_impl_.nid_)*/0
116 , /*decltype(_impl_.total_scan_)*/::int64_t{0}
117 , /*decltype(_impl_.unused_scan_)*/::int64_t{0}} {}
118 struct MmShrinkSlabEndFtraceEventDefaultTypeInternal {
MmShrinkSlabEndFtraceEventDefaultTypeInternalperfetto::protos::MmShrinkSlabEndFtraceEventDefaultTypeInternal119 PROTOBUF_CONSTEXPR MmShrinkSlabEndFtraceEventDefaultTypeInternal()
120 : _instance(::_pbi::ConstantInitialized{}) {}
~MmShrinkSlabEndFtraceEventDefaultTypeInternalperfetto::protos::MmShrinkSlabEndFtraceEventDefaultTypeInternal121 ~MmShrinkSlabEndFtraceEventDefaultTypeInternal() {}
122 union { // NOLINT(misc-non-private-member-variables-in-classes)
123 MmShrinkSlabEndFtraceEvent _instance;
124 };
125 };
126 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MmShrinkSlabEndFtraceEventDefaultTypeInternal _MmShrinkSlabEndFtraceEvent_default_instance_;
127 } // namespace protos
128 } // namespace perfetto
129 namespace perfetto {
130 namespace protos {
131
132 // ===================================================================
133
134 class MmVmscanDirectReclaimBeginFtraceEvent::_Internal {
135 public:
136 using HasBits = decltype(std::declval<MmVmscanDirectReclaimBeginFtraceEvent>()._impl_._has_bits_);
set_has_order(HasBits * has_bits)137 static void set_has_order(HasBits* has_bits) {
138 (*has_bits)[0] |= 1u;
139 }
set_has_may_writepage(HasBits * has_bits)140 static void set_has_may_writepage(HasBits* has_bits) {
141 (*has_bits)[0] |= 2u;
142 }
set_has_gfp_flags(HasBits * has_bits)143 static void set_has_gfp_flags(HasBits* has_bits) {
144 (*has_bits)[0] |= 4u;
145 }
146 };
147
MmVmscanDirectReclaimBeginFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)148 MmVmscanDirectReclaimBeginFtraceEvent::MmVmscanDirectReclaimBeginFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
149 bool is_message_owned)
150 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
151 SharedCtor(arena, is_message_owned);
152 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
153 }
MmVmscanDirectReclaimBeginFtraceEvent(const MmVmscanDirectReclaimBeginFtraceEvent & from)154 MmVmscanDirectReclaimBeginFtraceEvent::MmVmscanDirectReclaimBeginFtraceEvent(const MmVmscanDirectReclaimBeginFtraceEvent& from)
155 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
156 MmVmscanDirectReclaimBeginFtraceEvent* const _this = this; (void)_this;
157 new (&_impl_) Impl_{
158 decltype(_impl_._has_bits_){from._impl_._has_bits_}
159 , /*decltype(_impl_._cached_size_)*/{}
160 , decltype(_impl_.order_){}
161 , decltype(_impl_.may_writepage_){}
162 , decltype(_impl_.gfp_flags_){}};
163
164 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
165 ::memcpy(&_impl_.order_, &from._impl_.order_,
166 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.gfp_flags_) -
167 reinterpret_cast<char*>(&_impl_.order_)) + sizeof(_impl_.gfp_flags_));
168 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
169 }
170
SharedCtor(::_pb::Arena * arena,bool is_message_owned)171 inline void MmVmscanDirectReclaimBeginFtraceEvent::SharedCtor(
172 ::_pb::Arena* arena, bool is_message_owned) {
173 (void)arena;
174 (void)is_message_owned;
175 new (&_impl_) Impl_{
176 decltype(_impl_._has_bits_){}
177 , /*decltype(_impl_._cached_size_)*/{}
178 , decltype(_impl_.order_){0}
179 , decltype(_impl_.may_writepage_){0}
180 , decltype(_impl_.gfp_flags_){0u}
181 };
182 }
183
~MmVmscanDirectReclaimBeginFtraceEvent()184 MmVmscanDirectReclaimBeginFtraceEvent::~MmVmscanDirectReclaimBeginFtraceEvent() {
185 // @@protoc_insertion_point(destructor:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
186 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
187 (void)arena;
188 return;
189 }
190 SharedDtor();
191 }
192
SharedDtor()193 inline void MmVmscanDirectReclaimBeginFtraceEvent::SharedDtor() {
194 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
195 }
196
SetCachedSize(int size) const197 void MmVmscanDirectReclaimBeginFtraceEvent::SetCachedSize(int size) const {
198 _impl_._cached_size_.Set(size);
199 }
200
Clear()201 void MmVmscanDirectReclaimBeginFtraceEvent::Clear() {
202 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
203 ::uint32_t cached_has_bits = 0;
204 // Prevent compiler warnings about cached_has_bits being unused
205 (void) cached_has_bits;
206
207 cached_has_bits = _impl_._has_bits_[0];
208 if (cached_has_bits & 0x00000007u) {
209 ::memset(&_impl_.order_, 0, static_cast<size_t>(
210 reinterpret_cast<char*>(&_impl_.gfp_flags_) -
211 reinterpret_cast<char*>(&_impl_.order_)) + sizeof(_impl_.gfp_flags_));
212 }
213 _impl_._has_bits_.Clear();
214 _internal_metadata_.Clear<std::string>();
215 }
216
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)217 const char* MmVmscanDirectReclaimBeginFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
218 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
219 _Internal::HasBits has_bits{};
220 while (!ctx->Done(&ptr)) {
221 ::uint32_t tag;
222 ptr = ::_pbi::ReadTag(ptr, &tag);
223 switch (tag >> 3) {
224 // optional int32 order = 1;
225 case 1:
226 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
227 _Internal::set_has_order(&has_bits);
228 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
229 CHK_(ptr);
230 } else {
231 goto handle_unusual;
232 }
233 continue;
234 // optional int32 may_writepage = 2;
235 case 2:
236 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
237 _Internal::set_has_may_writepage(&has_bits);
238 _impl_.may_writepage_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
239 CHK_(ptr);
240 } else {
241 goto handle_unusual;
242 }
243 continue;
244 // optional uint32 gfp_flags = 3;
245 case 3:
246 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
247 _Internal::set_has_gfp_flags(&has_bits);
248 _impl_.gfp_flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
249 CHK_(ptr);
250 } else {
251 goto handle_unusual;
252 }
253 continue;
254 default:
255 goto handle_unusual;
256 } // switch
257 handle_unusual:
258 if ((tag == 0) || ((tag & 7) == 4)) {
259 CHK_(ptr);
260 ctx->SetLastTag(tag);
261 goto message_done;
262 }
263 ptr = UnknownFieldParse(
264 tag,
265 _internal_metadata_.mutable_unknown_fields<std::string>(),
266 ptr, ctx);
267 CHK_(ptr != nullptr);
268 } // while
269 message_done:
270 _impl_._has_bits_.Or(has_bits);
271 return ptr;
272 failure:
273 ptr = nullptr;
274 goto message_done;
275 #undef CHK_
276 }
277
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const278 ::uint8_t* MmVmscanDirectReclaimBeginFtraceEvent::_InternalSerialize(
279 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
280 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
281 ::uint32_t cached_has_bits = 0;
282 (void) cached_has_bits;
283
284 cached_has_bits = _impl_._has_bits_[0];
285 // optional int32 order = 1;
286 if (cached_has_bits & 0x00000001u) {
287 target = stream->EnsureSpace(target);
288 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_order(), target);
289 }
290
291 // optional int32 may_writepage = 2;
292 if (cached_has_bits & 0x00000002u) {
293 target = stream->EnsureSpace(target);
294 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_may_writepage(), target);
295 }
296
297 // optional uint32 gfp_flags = 3;
298 if (cached_has_bits & 0x00000004u) {
299 target = stream->EnsureSpace(target);
300 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_gfp_flags(), target);
301 }
302
303 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
304 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
305 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
306 }
307 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
308 return target;
309 }
310
ByteSizeLong() const311 size_t MmVmscanDirectReclaimBeginFtraceEvent::ByteSizeLong() const {
312 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
313 size_t total_size = 0;
314
315 ::uint32_t cached_has_bits = 0;
316 // Prevent compiler warnings about cached_has_bits being unused
317 (void) cached_has_bits;
318
319 cached_has_bits = _impl_._has_bits_[0];
320 if (cached_has_bits & 0x00000007u) {
321 // optional int32 order = 1;
322 if (cached_has_bits & 0x00000001u) {
323 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
324 }
325
326 // optional int32 may_writepage = 2;
327 if (cached_has_bits & 0x00000002u) {
328 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_may_writepage());
329 }
330
331 // optional uint32 gfp_flags = 3;
332 if (cached_has_bits & 0x00000004u) {
333 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gfp_flags());
334 }
335
336 }
337 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
338 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
339 }
340 int cached_size = ::_pbi::ToCachedSize(total_size);
341 SetCachedSize(cached_size);
342 return total_size;
343 }
344
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)345 void MmVmscanDirectReclaimBeginFtraceEvent::CheckTypeAndMergeFrom(
346 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
347 MergeFrom(*::_pbi::DownCast<const MmVmscanDirectReclaimBeginFtraceEvent*>(
348 &from));
349 }
350
MergeFrom(const MmVmscanDirectReclaimBeginFtraceEvent & from)351 void MmVmscanDirectReclaimBeginFtraceEvent::MergeFrom(const MmVmscanDirectReclaimBeginFtraceEvent& from) {
352 MmVmscanDirectReclaimBeginFtraceEvent* const _this = this;
353 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
354 GOOGLE_DCHECK_NE(&from, _this);
355 ::uint32_t cached_has_bits = 0;
356 (void) cached_has_bits;
357
358 cached_has_bits = from._impl_._has_bits_[0];
359 if (cached_has_bits & 0x00000007u) {
360 if (cached_has_bits & 0x00000001u) {
361 _this->_impl_.order_ = from._impl_.order_;
362 }
363 if (cached_has_bits & 0x00000002u) {
364 _this->_impl_.may_writepage_ = from._impl_.may_writepage_;
365 }
366 if (cached_has_bits & 0x00000004u) {
367 _this->_impl_.gfp_flags_ = from._impl_.gfp_flags_;
368 }
369 _this->_impl_._has_bits_[0] |= cached_has_bits;
370 }
371 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
372 }
373
CopyFrom(const MmVmscanDirectReclaimBeginFtraceEvent & from)374 void MmVmscanDirectReclaimBeginFtraceEvent::CopyFrom(const MmVmscanDirectReclaimBeginFtraceEvent& from) {
375 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent)
376 if (&from == this) return;
377 Clear();
378 MergeFrom(from);
379 }
380
IsInitialized() const381 bool MmVmscanDirectReclaimBeginFtraceEvent::IsInitialized() const {
382 return true;
383 }
384
InternalSwap(MmVmscanDirectReclaimBeginFtraceEvent * other)385 void MmVmscanDirectReclaimBeginFtraceEvent::InternalSwap(MmVmscanDirectReclaimBeginFtraceEvent* other) {
386 using std::swap;
387 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
388 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
389 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
390 PROTOBUF_FIELD_OFFSET(MmVmscanDirectReclaimBeginFtraceEvent, _impl_.gfp_flags_)
391 + sizeof(MmVmscanDirectReclaimBeginFtraceEvent::_impl_.gfp_flags_) // NOLINT
392 - PROTOBUF_FIELD_OFFSET(MmVmscanDirectReclaimBeginFtraceEvent, _impl_.order_)>(
393 reinterpret_cast<char*>(&_impl_.order_),
394 reinterpret_cast<char*>(&other->_impl_.order_));
395 }
396
GetTypeName() const397 std::string MmVmscanDirectReclaimBeginFtraceEvent::GetTypeName() const {
398 return "perfetto.protos.MmVmscanDirectReclaimBeginFtraceEvent";
399 }
400
401
402 // ===================================================================
403
404 class MmVmscanDirectReclaimEndFtraceEvent::_Internal {
405 public:
406 using HasBits = decltype(std::declval<MmVmscanDirectReclaimEndFtraceEvent>()._impl_._has_bits_);
set_has_nr_reclaimed(HasBits * has_bits)407 static void set_has_nr_reclaimed(HasBits* has_bits) {
408 (*has_bits)[0] |= 1u;
409 }
410 };
411
MmVmscanDirectReclaimEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)412 MmVmscanDirectReclaimEndFtraceEvent::MmVmscanDirectReclaimEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
413 bool is_message_owned)
414 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
415 SharedCtor(arena, is_message_owned);
416 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
417 }
MmVmscanDirectReclaimEndFtraceEvent(const MmVmscanDirectReclaimEndFtraceEvent & from)418 MmVmscanDirectReclaimEndFtraceEvent::MmVmscanDirectReclaimEndFtraceEvent(const MmVmscanDirectReclaimEndFtraceEvent& from)
419 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
420 MmVmscanDirectReclaimEndFtraceEvent* const _this = this; (void)_this;
421 new (&_impl_) Impl_{
422 decltype(_impl_._has_bits_){from._impl_._has_bits_}
423 , /*decltype(_impl_._cached_size_)*/{}
424 , decltype(_impl_.nr_reclaimed_){}};
425
426 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
427 _this->_impl_.nr_reclaimed_ = from._impl_.nr_reclaimed_;
428 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
429 }
430
SharedCtor(::_pb::Arena * arena,bool is_message_owned)431 inline void MmVmscanDirectReclaimEndFtraceEvent::SharedCtor(
432 ::_pb::Arena* arena, bool is_message_owned) {
433 (void)arena;
434 (void)is_message_owned;
435 new (&_impl_) Impl_{
436 decltype(_impl_._has_bits_){}
437 , /*decltype(_impl_._cached_size_)*/{}
438 , decltype(_impl_.nr_reclaimed_){::uint64_t{0u}}
439 };
440 }
441
~MmVmscanDirectReclaimEndFtraceEvent()442 MmVmscanDirectReclaimEndFtraceEvent::~MmVmscanDirectReclaimEndFtraceEvent() {
443 // @@protoc_insertion_point(destructor:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
444 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
445 (void)arena;
446 return;
447 }
448 SharedDtor();
449 }
450
SharedDtor()451 inline void MmVmscanDirectReclaimEndFtraceEvent::SharedDtor() {
452 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
453 }
454
SetCachedSize(int size) const455 void MmVmscanDirectReclaimEndFtraceEvent::SetCachedSize(int size) const {
456 _impl_._cached_size_.Set(size);
457 }
458
Clear()459 void MmVmscanDirectReclaimEndFtraceEvent::Clear() {
460 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
461 ::uint32_t cached_has_bits = 0;
462 // Prevent compiler warnings about cached_has_bits being unused
463 (void) cached_has_bits;
464
465 _impl_.nr_reclaimed_ = ::uint64_t{0u};
466 _impl_._has_bits_.Clear();
467 _internal_metadata_.Clear<std::string>();
468 }
469
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)470 const char* MmVmscanDirectReclaimEndFtraceEvent::_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 uint64 nr_reclaimed = 1;
478 case 1:
479 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
480 _Internal::set_has_nr_reclaimed(&has_bits);
481 _impl_.nr_reclaimed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
482 CHK_(ptr);
483 } else {
484 goto handle_unusual;
485 }
486 continue;
487 default:
488 goto handle_unusual;
489 } // switch
490 handle_unusual:
491 if ((tag == 0) || ((tag & 7) == 4)) {
492 CHK_(ptr);
493 ctx->SetLastTag(tag);
494 goto message_done;
495 }
496 ptr = UnknownFieldParse(
497 tag,
498 _internal_metadata_.mutable_unknown_fields<std::string>(),
499 ptr, ctx);
500 CHK_(ptr != nullptr);
501 } // while
502 message_done:
503 _impl_._has_bits_.Or(has_bits);
504 return ptr;
505 failure:
506 ptr = nullptr;
507 goto message_done;
508 #undef CHK_
509 }
510
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const511 ::uint8_t* MmVmscanDirectReclaimEndFtraceEvent::_InternalSerialize(
512 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
513 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
514 ::uint32_t cached_has_bits = 0;
515 (void) cached_has_bits;
516
517 cached_has_bits = _impl_._has_bits_[0];
518 // optional uint64 nr_reclaimed = 1;
519 if (cached_has_bits & 0x00000001u) {
520 target = stream->EnsureSpace(target);
521 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_nr_reclaimed(), target);
522 }
523
524 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
525 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
526 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
527 }
528 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
529 return target;
530 }
531
ByteSizeLong() const532 size_t MmVmscanDirectReclaimEndFtraceEvent::ByteSizeLong() const {
533 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
534 size_t total_size = 0;
535
536 ::uint32_t cached_has_bits = 0;
537 // Prevent compiler warnings about cached_has_bits being unused
538 (void) cached_has_bits;
539
540 // optional uint64 nr_reclaimed = 1;
541 cached_has_bits = _impl_._has_bits_[0];
542 if (cached_has_bits & 0x00000001u) {
543 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_nr_reclaimed());
544 }
545
546 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
547 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
548 }
549 int cached_size = ::_pbi::ToCachedSize(total_size);
550 SetCachedSize(cached_size);
551 return total_size;
552 }
553
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)554 void MmVmscanDirectReclaimEndFtraceEvent::CheckTypeAndMergeFrom(
555 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
556 MergeFrom(*::_pbi::DownCast<const MmVmscanDirectReclaimEndFtraceEvent*>(
557 &from));
558 }
559
MergeFrom(const MmVmscanDirectReclaimEndFtraceEvent & from)560 void MmVmscanDirectReclaimEndFtraceEvent::MergeFrom(const MmVmscanDirectReclaimEndFtraceEvent& from) {
561 MmVmscanDirectReclaimEndFtraceEvent* const _this = this;
562 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
563 GOOGLE_DCHECK_NE(&from, _this);
564 ::uint32_t cached_has_bits = 0;
565 (void) cached_has_bits;
566
567 if (from._internal_has_nr_reclaimed()) {
568 _this->_internal_set_nr_reclaimed(from._internal_nr_reclaimed());
569 }
570 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
571 }
572
CopyFrom(const MmVmscanDirectReclaimEndFtraceEvent & from)573 void MmVmscanDirectReclaimEndFtraceEvent::CopyFrom(const MmVmscanDirectReclaimEndFtraceEvent& from) {
574 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent)
575 if (&from == this) return;
576 Clear();
577 MergeFrom(from);
578 }
579
IsInitialized() const580 bool MmVmscanDirectReclaimEndFtraceEvent::IsInitialized() const {
581 return true;
582 }
583
InternalSwap(MmVmscanDirectReclaimEndFtraceEvent * other)584 void MmVmscanDirectReclaimEndFtraceEvent::InternalSwap(MmVmscanDirectReclaimEndFtraceEvent* other) {
585 using std::swap;
586 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
587 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
588 swap(_impl_.nr_reclaimed_, other->_impl_.nr_reclaimed_);
589 }
590
GetTypeName() const591 std::string MmVmscanDirectReclaimEndFtraceEvent::GetTypeName() const {
592 return "perfetto.protos.MmVmscanDirectReclaimEndFtraceEvent";
593 }
594
595
596 // ===================================================================
597
598 class MmVmscanKswapdWakeFtraceEvent::_Internal {
599 public:
600 using HasBits = decltype(std::declval<MmVmscanKswapdWakeFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)601 static void set_has_nid(HasBits* has_bits) {
602 (*has_bits)[0] |= 1u;
603 }
set_has_order(HasBits * has_bits)604 static void set_has_order(HasBits* has_bits) {
605 (*has_bits)[0] |= 2u;
606 }
set_has_zid(HasBits * has_bits)607 static void set_has_zid(HasBits* has_bits) {
608 (*has_bits)[0] |= 4u;
609 }
610 };
611
MmVmscanKswapdWakeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)612 MmVmscanKswapdWakeFtraceEvent::MmVmscanKswapdWakeFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
613 bool is_message_owned)
614 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
615 SharedCtor(arena, is_message_owned);
616 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
617 }
MmVmscanKswapdWakeFtraceEvent(const MmVmscanKswapdWakeFtraceEvent & from)618 MmVmscanKswapdWakeFtraceEvent::MmVmscanKswapdWakeFtraceEvent(const MmVmscanKswapdWakeFtraceEvent& from)
619 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
620 MmVmscanKswapdWakeFtraceEvent* const _this = this; (void)_this;
621 new (&_impl_) Impl_{
622 decltype(_impl_._has_bits_){from._impl_._has_bits_}
623 , /*decltype(_impl_._cached_size_)*/{}
624 , decltype(_impl_.nid_){}
625 , decltype(_impl_.order_){}
626 , decltype(_impl_.zid_){}};
627
628 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
629 ::memcpy(&_impl_.nid_, &from._impl_.nid_,
630 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.zid_) -
631 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.zid_));
632 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
633 }
634
SharedCtor(::_pb::Arena * arena,bool is_message_owned)635 inline void MmVmscanKswapdWakeFtraceEvent::SharedCtor(
636 ::_pb::Arena* arena, bool is_message_owned) {
637 (void)arena;
638 (void)is_message_owned;
639 new (&_impl_) Impl_{
640 decltype(_impl_._has_bits_){}
641 , /*decltype(_impl_._cached_size_)*/{}
642 , decltype(_impl_.nid_){0}
643 , decltype(_impl_.order_){0}
644 , decltype(_impl_.zid_){0}
645 };
646 }
647
~MmVmscanKswapdWakeFtraceEvent()648 MmVmscanKswapdWakeFtraceEvent::~MmVmscanKswapdWakeFtraceEvent() {
649 // @@protoc_insertion_point(destructor:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
650 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
651 (void)arena;
652 return;
653 }
654 SharedDtor();
655 }
656
SharedDtor()657 inline void MmVmscanKswapdWakeFtraceEvent::SharedDtor() {
658 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
659 }
660
SetCachedSize(int size) const661 void MmVmscanKswapdWakeFtraceEvent::SetCachedSize(int size) const {
662 _impl_._cached_size_.Set(size);
663 }
664
Clear()665 void MmVmscanKswapdWakeFtraceEvent::Clear() {
666 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
667 ::uint32_t cached_has_bits = 0;
668 // Prevent compiler warnings about cached_has_bits being unused
669 (void) cached_has_bits;
670
671 cached_has_bits = _impl_._has_bits_[0];
672 if (cached_has_bits & 0x00000007u) {
673 ::memset(&_impl_.nid_, 0, static_cast<size_t>(
674 reinterpret_cast<char*>(&_impl_.zid_) -
675 reinterpret_cast<char*>(&_impl_.nid_)) + sizeof(_impl_.zid_));
676 }
677 _impl_._has_bits_.Clear();
678 _internal_metadata_.Clear<std::string>();
679 }
680
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)681 const char* MmVmscanKswapdWakeFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
682 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
683 _Internal::HasBits has_bits{};
684 while (!ctx->Done(&ptr)) {
685 ::uint32_t tag;
686 ptr = ::_pbi::ReadTag(ptr, &tag);
687 switch (tag >> 3) {
688 // optional int32 nid = 1;
689 case 1:
690 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
691 _Internal::set_has_nid(&has_bits);
692 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
693 CHK_(ptr);
694 } else {
695 goto handle_unusual;
696 }
697 continue;
698 // optional int32 order = 2;
699 case 2:
700 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
701 _Internal::set_has_order(&has_bits);
702 _impl_.order_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
703 CHK_(ptr);
704 } else {
705 goto handle_unusual;
706 }
707 continue;
708 // optional int32 zid = 3;
709 case 3:
710 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
711 _Internal::set_has_zid(&has_bits);
712 _impl_.zid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
713 CHK_(ptr);
714 } else {
715 goto handle_unusual;
716 }
717 continue;
718 default:
719 goto handle_unusual;
720 } // switch
721 handle_unusual:
722 if ((tag == 0) || ((tag & 7) == 4)) {
723 CHK_(ptr);
724 ctx->SetLastTag(tag);
725 goto message_done;
726 }
727 ptr = UnknownFieldParse(
728 tag,
729 _internal_metadata_.mutable_unknown_fields<std::string>(),
730 ptr, ctx);
731 CHK_(ptr != nullptr);
732 } // while
733 message_done:
734 _impl_._has_bits_.Or(has_bits);
735 return ptr;
736 failure:
737 ptr = nullptr;
738 goto message_done;
739 #undef CHK_
740 }
741
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const742 ::uint8_t* MmVmscanKswapdWakeFtraceEvent::_InternalSerialize(
743 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
744 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
745 ::uint32_t cached_has_bits = 0;
746 (void) cached_has_bits;
747
748 cached_has_bits = _impl_._has_bits_[0];
749 // optional int32 nid = 1;
750 if (cached_has_bits & 0x00000001u) {
751 target = stream->EnsureSpace(target);
752 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
753 }
754
755 // optional int32 order = 2;
756 if (cached_has_bits & 0x00000002u) {
757 target = stream->EnsureSpace(target);
758 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_order(), target);
759 }
760
761 // optional int32 zid = 3;
762 if (cached_has_bits & 0x00000004u) {
763 target = stream->EnsureSpace(target);
764 target = ::_pbi::WireFormatLite::WriteInt32ToArray(3, this->_internal_zid(), target);
765 }
766
767 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
768 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
769 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
770 }
771 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
772 return target;
773 }
774
ByteSizeLong() const775 size_t MmVmscanKswapdWakeFtraceEvent::ByteSizeLong() const {
776 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
777 size_t total_size = 0;
778
779 ::uint32_t cached_has_bits = 0;
780 // Prevent compiler warnings about cached_has_bits being unused
781 (void) cached_has_bits;
782
783 cached_has_bits = _impl_._has_bits_[0];
784 if (cached_has_bits & 0x00000007u) {
785 // optional int32 nid = 1;
786 if (cached_has_bits & 0x00000001u) {
787 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
788 }
789
790 // optional int32 order = 2;
791 if (cached_has_bits & 0x00000002u) {
792 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_order());
793 }
794
795 // optional int32 zid = 3;
796 if (cached_has_bits & 0x00000004u) {
797 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_zid());
798 }
799
800 }
801 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
802 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
803 }
804 int cached_size = ::_pbi::ToCachedSize(total_size);
805 SetCachedSize(cached_size);
806 return total_size;
807 }
808
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)809 void MmVmscanKswapdWakeFtraceEvent::CheckTypeAndMergeFrom(
810 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
811 MergeFrom(*::_pbi::DownCast<const MmVmscanKswapdWakeFtraceEvent*>(
812 &from));
813 }
814
MergeFrom(const MmVmscanKswapdWakeFtraceEvent & from)815 void MmVmscanKswapdWakeFtraceEvent::MergeFrom(const MmVmscanKswapdWakeFtraceEvent& from) {
816 MmVmscanKswapdWakeFtraceEvent* const _this = this;
817 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
818 GOOGLE_DCHECK_NE(&from, _this);
819 ::uint32_t cached_has_bits = 0;
820 (void) cached_has_bits;
821
822 cached_has_bits = from._impl_._has_bits_[0];
823 if (cached_has_bits & 0x00000007u) {
824 if (cached_has_bits & 0x00000001u) {
825 _this->_impl_.nid_ = from._impl_.nid_;
826 }
827 if (cached_has_bits & 0x00000002u) {
828 _this->_impl_.order_ = from._impl_.order_;
829 }
830 if (cached_has_bits & 0x00000004u) {
831 _this->_impl_.zid_ = from._impl_.zid_;
832 }
833 _this->_impl_._has_bits_[0] |= cached_has_bits;
834 }
835 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
836 }
837
CopyFrom(const MmVmscanKswapdWakeFtraceEvent & from)838 void MmVmscanKswapdWakeFtraceEvent::CopyFrom(const MmVmscanKswapdWakeFtraceEvent& from) {
839 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmVmscanKswapdWakeFtraceEvent)
840 if (&from == this) return;
841 Clear();
842 MergeFrom(from);
843 }
844
IsInitialized() const845 bool MmVmscanKswapdWakeFtraceEvent::IsInitialized() const {
846 return true;
847 }
848
InternalSwap(MmVmscanKswapdWakeFtraceEvent * other)849 void MmVmscanKswapdWakeFtraceEvent::InternalSwap(MmVmscanKswapdWakeFtraceEvent* other) {
850 using std::swap;
851 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
852 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
853 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
854 PROTOBUF_FIELD_OFFSET(MmVmscanKswapdWakeFtraceEvent, _impl_.zid_)
855 + sizeof(MmVmscanKswapdWakeFtraceEvent::_impl_.zid_) // NOLINT
856 - PROTOBUF_FIELD_OFFSET(MmVmscanKswapdWakeFtraceEvent, _impl_.nid_)>(
857 reinterpret_cast<char*>(&_impl_.nid_),
858 reinterpret_cast<char*>(&other->_impl_.nid_));
859 }
860
GetTypeName() const861 std::string MmVmscanKswapdWakeFtraceEvent::GetTypeName() const {
862 return "perfetto.protos.MmVmscanKswapdWakeFtraceEvent";
863 }
864
865
866 // ===================================================================
867
868 class MmVmscanKswapdSleepFtraceEvent::_Internal {
869 public:
870 using HasBits = decltype(std::declval<MmVmscanKswapdSleepFtraceEvent>()._impl_._has_bits_);
set_has_nid(HasBits * has_bits)871 static void set_has_nid(HasBits* has_bits) {
872 (*has_bits)[0] |= 1u;
873 }
874 };
875
MmVmscanKswapdSleepFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)876 MmVmscanKswapdSleepFtraceEvent::MmVmscanKswapdSleepFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
877 bool is_message_owned)
878 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
879 SharedCtor(arena, is_message_owned);
880 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
881 }
MmVmscanKswapdSleepFtraceEvent(const MmVmscanKswapdSleepFtraceEvent & from)882 MmVmscanKswapdSleepFtraceEvent::MmVmscanKswapdSleepFtraceEvent(const MmVmscanKswapdSleepFtraceEvent& from)
883 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
884 MmVmscanKswapdSleepFtraceEvent* const _this = this; (void)_this;
885 new (&_impl_) Impl_{
886 decltype(_impl_._has_bits_){from._impl_._has_bits_}
887 , /*decltype(_impl_._cached_size_)*/{}
888 , decltype(_impl_.nid_){}};
889
890 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
891 _this->_impl_.nid_ = from._impl_.nid_;
892 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
893 }
894
SharedCtor(::_pb::Arena * arena,bool is_message_owned)895 inline void MmVmscanKswapdSleepFtraceEvent::SharedCtor(
896 ::_pb::Arena* arena, bool is_message_owned) {
897 (void)arena;
898 (void)is_message_owned;
899 new (&_impl_) Impl_{
900 decltype(_impl_._has_bits_){}
901 , /*decltype(_impl_._cached_size_)*/{}
902 , decltype(_impl_.nid_){0}
903 };
904 }
905
~MmVmscanKswapdSleepFtraceEvent()906 MmVmscanKswapdSleepFtraceEvent::~MmVmscanKswapdSleepFtraceEvent() {
907 // @@protoc_insertion_point(destructor:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
908 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
909 (void)arena;
910 return;
911 }
912 SharedDtor();
913 }
914
SharedDtor()915 inline void MmVmscanKswapdSleepFtraceEvent::SharedDtor() {
916 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
917 }
918
SetCachedSize(int size) const919 void MmVmscanKswapdSleepFtraceEvent::SetCachedSize(int size) const {
920 _impl_._cached_size_.Set(size);
921 }
922
Clear()923 void MmVmscanKswapdSleepFtraceEvent::Clear() {
924 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
925 ::uint32_t cached_has_bits = 0;
926 // Prevent compiler warnings about cached_has_bits being unused
927 (void) cached_has_bits;
928
929 _impl_.nid_ = 0;
930 _impl_._has_bits_.Clear();
931 _internal_metadata_.Clear<std::string>();
932 }
933
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)934 const char* MmVmscanKswapdSleepFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
935 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
936 _Internal::HasBits has_bits{};
937 while (!ctx->Done(&ptr)) {
938 ::uint32_t tag;
939 ptr = ::_pbi::ReadTag(ptr, &tag);
940 switch (tag >> 3) {
941 // optional int32 nid = 1;
942 case 1:
943 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
944 _Internal::set_has_nid(&has_bits);
945 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
946 CHK_(ptr);
947 } else {
948 goto handle_unusual;
949 }
950 continue;
951 default:
952 goto handle_unusual;
953 } // switch
954 handle_unusual:
955 if ((tag == 0) || ((tag & 7) == 4)) {
956 CHK_(ptr);
957 ctx->SetLastTag(tag);
958 goto message_done;
959 }
960 ptr = UnknownFieldParse(
961 tag,
962 _internal_metadata_.mutable_unknown_fields<std::string>(),
963 ptr, ctx);
964 CHK_(ptr != nullptr);
965 } // while
966 message_done:
967 _impl_._has_bits_.Or(has_bits);
968 return ptr;
969 failure:
970 ptr = nullptr;
971 goto message_done;
972 #undef CHK_
973 }
974
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const975 ::uint8_t* MmVmscanKswapdSleepFtraceEvent::_InternalSerialize(
976 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
977 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
978 ::uint32_t cached_has_bits = 0;
979 (void) cached_has_bits;
980
981 cached_has_bits = _impl_._has_bits_[0];
982 // optional int32 nid = 1;
983 if (cached_has_bits & 0x00000001u) {
984 target = stream->EnsureSpace(target);
985 target = ::_pbi::WireFormatLite::WriteInt32ToArray(1, this->_internal_nid(), target);
986 }
987
988 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
989 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
990 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
991 }
992 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
993 return target;
994 }
995
ByteSizeLong() const996 size_t MmVmscanKswapdSleepFtraceEvent::ByteSizeLong() const {
997 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
998 size_t total_size = 0;
999
1000 ::uint32_t cached_has_bits = 0;
1001 // Prevent compiler warnings about cached_has_bits being unused
1002 (void) cached_has_bits;
1003
1004 // optional int32 nid = 1;
1005 cached_has_bits = _impl_._has_bits_[0];
1006 if (cached_has_bits & 0x00000001u) {
1007 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
1008 }
1009
1010 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1011 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1012 }
1013 int cached_size = ::_pbi::ToCachedSize(total_size);
1014 SetCachedSize(cached_size);
1015 return total_size;
1016 }
1017
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1018 void MmVmscanKswapdSleepFtraceEvent::CheckTypeAndMergeFrom(
1019 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1020 MergeFrom(*::_pbi::DownCast<const MmVmscanKswapdSleepFtraceEvent*>(
1021 &from));
1022 }
1023
MergeFrom(const MmVmscanKswapdSleepFtraceEvent & from)1024 void MmVmscanKswapdSleepFtraceEvent::MergeFrom(const MmVmscanKswapdSleepFtraceEvent& from) {
1025 MmVmscanKswapdSleepFtraceEvent* const _this = this;
1026 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
1027 GOOGLE_DCHECK_NE(&from, _this);
1028 ::uint32_t cached_has_bits = 0;
1029 (void) cached_has_bits;
1030
1031 if (from._internal_has_nid()) {
1032 _this->_internal_set_nid(from._internal_nid());
1033 }
1034 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1035 }
1036
CopyFrom(const MmVmscanKswapdSleepFtraceEvent & from)1037 void MmVmscanKswapdSleepFtraceEvent::CopyFrom(const MmVmscanKswapdSleepFtraceEvent& from) {
1038 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmVmscanKswapdSleepFtraceEvent)
1039 if (&from == this) return;
1040 Clear();
1041 MergeFrom(from);
1042 }
1043
IsInitialized() const1044 bool MmVmscanKswapdSleepFtraceEvent::IsInitialized() const {
1045 return true;
1046 }
1047
InternalSwap(MmVmscanKswapdSleepFtraceEvent * other)1048 void MmVmscanKswapdSleepFtraceEvent::InternalSwap(MmVmscanKswapdSleepFtraceEvent* other) {
1049 using std::swap;
1050 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1051 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1052 swap(_impl_.nid_, other->_impl_.nid_);
1053 }
1054
GetTypeName() const1055 std::string MmVmscanKswapdSleepFtraceEvent::GetTypeName() const {
1056 return "perfetto.protos.MmVmscanKswapdSleepFtraceEvent";
1057 }
1058
1059
1060 // ===================================================================
1061
1062 class MmShrinkSlabStartFtraceEvent::_Internal {
1063 public:
1064 using HasBits = decltype(std::declval<MmShrinkSlabStartFtraceEvent>()._impl_._has_bits_);
set_has_cache_items(HasBits * has_bits)1065 static void set_has_cache_items(HasBits* has_bits) {
1066 (*has_bits)[0] |= 1u;
1067 }
set_has_delta(HasBits * has_bits)1068 static void set_has_delta(HasBits* has_bits) {
1069 (*has_bits)[0] |= 2u;
1070 }
set_has_gfp_flags(HasBits * has_bits)1071 static void set_has_gfp_flags(HasBits* has_bits) {
1072 (*has_bits)[0] |= 32u;
1073 }
set_has_lru_pgs(HasBits * has_bits)1074 static void set_has_lru_pgs(HasBits* has_bits) {
1075 (*has_bits)[0] |= 4u;
1076 }
set_has_nr_objects_to_shrink(HasBits * has_bits)1077 static void set_has_nr_objects_to_shrink(HasBits* has_bits) {
1078 (*has_bits)[0] |= 8u;
1079 }
set_has_pgs_scanned(HasBits * has_bits)1080 static void set_has_pgs_scanned(HasBits* has_bits) {
1081 (*has_bits)[0] |= 16u;
1082 }
set_has_shr(HasBits * has_bits)1083 static void set_has_shr(HasBits* has_bits) {
1084 (*has_bits)[0] |= 128u;
1085 }
set_has_shrink(HasBits * has_bits)1086 static void set_has_shrink(HasBits* has_bits) {
1087 (*has_bits)[0] |= 256u;
1088 }
set_has_total_scan(HasBits * has_bits)1089 static void set_has_total_scan(HasBits* has_bits) {
1090 (*has_bits)[0] |= 512u;
1091 }
set_has_nid(HasBits * has_bits)1092 static void set_has_nid(HasBits* has_bits) {
1093 (*has_bits)[0] |= 64u;
1094 }
set_has_priority(HasBits * has_bits)1095 static void set_has_priority(HasBits* has_bits) {
1096 (*has_bits)[0] |= 1024u;
1097 }
1098 };
1099
MmShrinkSlabStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1100 MmShrinkSlabStartFtraceEvent::MmShrinkSlabStartFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1101 bool is_message_owned)
1102 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1103 SharedCtor(arena, is_message_owned);
1104 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1105 }
MmShrinkSlabStartFtraceEvent(const MmShrinkSlabStartFtraceEvent & from)1106 MmShrinkSlabStartFtraceEvent::MmShrinkSlabStartFtraceEvent(const MmShrinkSlabStartFtraceEvent& from)
1107 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1108 MmShrinkSlabStartFtraceEvent* const _this = this; (void)_this;
1109 new (&_impl_) Impl_{
1110 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1111 , /*decltype(_impl_._cached_size_)*/{}
1112 , decltype(_impl_.cache_items_){}
1113 , decltype(_impl_.delta_){}
1114 , decltype(_impl_.lru_pgs_){}
1115 , decltype(_impl_.nr_objects_to_shrink_){}
1116 , decltype(_impl_.pgs_scanned_){}
1117 , decltype(_impl_.gfp_flags_){}
1118 , decltype(_impl_.nid_){}
1119 , decltype(_impl_.shr_){}
1120 , decltype(_impl_.shrink_){}
1121 , decltype(_impl_.total_scan_){}
1122 , decltype(_impl_.priority_){}};
1123
1124 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1125 ::memcpy(&_impl_.cache_items_, &from._impl_.cache_items_,
1126 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.priority_) -
1127 reinterpret_cast<char*>(&_impl_.cache_items_)) + sizeof(_impl_.priority_));
1128 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1129 }
1130
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1131 inline void MmShrinkSlabStartFtraceEvent::SharedCtor(
1132 ::_pb::Arena* arena, bool is_message_owned) {
1133 (void)arena;
1134 (void)is_message_owned;
1135 new (&_impl_) Impl_{
1136 decltype(_impl_._has_bits_){}
1137 , /*decltype(_impl_._cached_size_)*/{}
1138 , decltype(_impl_.cache_items_){::uint64_t{0u}}
1139 , decltype(_impl_.delta_){::uint64_t{0u}}
1140 , decltype(_impl_.lru_pgs_){::uint64_t{0u}}
1141 , decltype(_impl_.nr_objects_to_shrink_){::int64_t{0}}
1142 , decltype(_impl_.pgs_scanned_){::uint64_t{0u}}
1143 , decltype(_impl_.gfp_flags_){0u}
1144 , decltype(_impl_.nid_){0}
1145 , decltype(_impl_.shr_){::uint64_t{0u}}
1146 , decltype(_impl_.shrink_){::uint64_t{0u}}
1147 , decltype(_impl_.total_scan_){::uint64_t{0u}}
1148 , decltype(_impl_.priority_){0}
1149 };
1150 }
1151
~MmShrinkSlabStartFtraceEvent()1152 MmShrinkSlabStartFtraceEvent::~MmShrinkSlabStartFtraceEvent() {
1153 // @@protoc_insertion_point(destructor:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1154 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1155 (void)arena;
1156 return;
1157 }
1158 SharedDtor();
1159 }
1160
SharedDtor()1161 inline void MmShrinkSlabStartFtraceEvent::SharedDtor() {
1162 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1163 }
1164
SetCachedSize(int size) const1165 void MmShrinkSlabStartFtraceEvent::SetCachedSize(int size) const {
1166 _impl_._cached_size_.Set(size);
1167 }
1168
Clear()1169 void MmShrinkSlabStartFtraceEvent::Clear() {
1170 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1171 ::uint32_t cached_has_bits = 0;
1172 // Prevent compiler warnings about cached_has_bits being unused
1173 (void) cached_has_bits;
1174
1175 cached_has_bits = _impl_._has_bits_[0];
1176 if (cached_has_bits & 0x000000ffu) {
1177 ::memset(&_impl_.cache_items_, 0, static_cast<size_t>(
1178 reinterpret_cast<char*>(&_impl_.shr_) -
1179 reinterpret_cast<char*>(&_impl_.cache_items_)) + sizeof(_impl_.shr_));
1180 }
1181 if (cached_has_bits & 0x00000700u) {
1182 ::memset(&_impl_.shrink_, 0, static_cast<size_t>(
1183 reinterpret_cast<char*>(&_impl_.priority_) -
1184 reinterpret_cast<char*>(&_impl_.shrink_)) + sizeof(_impl_.priority_));
1185 }
1186 _impl_._has_bits_.Clear();
1187 _internal_metadata_.Clear<std::string>();
1188 }
1189
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1190 const char* MmShrinkSlabStartFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1191 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1192 _Internal::HasBits has_bits{};
1193 while (!ctx->Done(&ptr)) {
1194 ::uint32_t tag;
1195 ptr = ::_pbi::ReadTag(ptr, &tag);
1196 switch (tag >> 3) {
1197 // optional uint64 cache_items = 1;
1198 case 1:
1199 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1200 _Internal::set_has_cache_items(&has_bits);
1201 _impl_.cache_items_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1202 CHK_(ptr);
1203 } else {
1204 goto handle_unusual;
1205 }
1206 continue;
1207 // optional uint64 delta = 2;
1208 case 2:
1209 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1210 _Internal::set_has_delta(&has_bits);
1211 _impl_.delta_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1212 CHK_(ptr);
1213 } else {
1214 goto handle_unusual;
1215 }
1216 continue;
1217 // optional uint32 gfp_flags = 3;
1218 case 3:
1219 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1220 _Internal::set_has_gfp_flags(&has_bits);
1221 _impl_.gfp_flags_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1222 CHK_(ptr);
1223 } else {
1224 goto handle_unusual;
1225 }
1226 continue;
1227 // optional uint64 lru_pgs = 4;
1228 case 4:
1229 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1230 _Internal::set_has_lru_pgs(&has_bits);
1231 _impl_.lru_pgs_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1232 CHK_(ptr);
1233 } else {
1234 goto handle_unusual;
1235 }
1236 continue;
1237 // optional int64 nr_objects_to_shrink = 5;
1238 case 5:
1239 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1240 _Internal::set_has_nr_objects_to_shrink(&has_bits);
1241 _impl_.nr_objects_to_shrink_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1242 CHK_(ptr);
1243 } else {
1244 goto handle_unusual;
1245 }
1246 continue;
1247 // optional uint64 pgs_scanned = 6;
1248 case 6:
1249 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1250 _Internal::set_has_pgs_scanned(&has_bits);
1251 _impl_.pgs_scanned_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1252 CHK_(ptr);
1253 } else {
1254 goto handle_unusual;
1255 }
1256 continue;
1257 // optional uint64 shr = 7;
1258 case 7:
1259 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1260 _Internal::set_has_shr(&has_bits);
1261 _impl_.shr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1262 CHK_(ptr);
1263 } else {
1264 goto handle_unusual;
1265 }
1266 continue;
1267 // optional uint64 shrink = 8;
1268 case 8:
1269 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 64)) {
1270 _Internal::set_has_shrink(&has_bits);
1271 _impl_.shrink_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1272 CHK_(ptr);
1273 } else {
1274 goto handle_unusual;
1275 }
1276 continue;
1277 // optional uint64 total_scan = 9;
1278 case 9:
1279 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
1280 _Internal::set_has_total_scan(&has_bits);
1281 _impl_.total_scan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1282 CHK_(ptr);
1283 } else {
1284 goto handle_unusual;
1285 }
1286 continue;
1287 // optional int32 nid = 10;
1288 case 10:
1289 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
1290 _Internal::set_has_nid(&has_bits);
1291 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1292 CHK_(ptr);
1293 } else {
1294 goto handle_unusual;
1295 }
1296 continue;
1297 // optional int32 priority = 11;
1298 case 11:
1299 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 88)) {
1300 _Internal::set_has_priority(&has_bits);
1301 _impl_.priority_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1302 CHK_(ptr);
1303 } else {
1304 goto handle_unusual;
1305 }
1306 continue;
1307 default:
1308 goto handle_unusual;
1309 } // switch
1310 handle_unusual:
1311 if ((tag == 0) || ((tag & 7) == 4)) {
1312 CHK_(ptr);
1313 ctx->SetLastTag(tag);
1314 goto message_done;
1315 }
1316 ptr = UnknownFieldParse(
1317 tag,
1318 _internal_metadata_.mutable_unknown_fields<std::string>(),
1319 ptr, ctx);
1320 CHK_(ptr != nullptr);
1321 } // while
1322 message_done:
1323 _impl_._has_bits_.Or(has_bits);
1324 return ptr;
1325 failure:
1326 ptr = nullptr;
1327 goto message_done;
1328 #undef CHK_
1329 }
1330
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1331 ::uint8_t* MmShrinkSlabStartFtraceEvent::_InternalSerialize(
1332 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1333 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1334 ::uint32_t cached_has_bits = 0;
1335 (void) cached_has_bits;
1336
1337 cached_has_bits = _impl_._has_bits_[0];
1338 // optional uint64 cache_items = 1;
1339 if (cached_has_bits & 0x00000001u) {
1340 target = stream->EnsureSpace(target);
1341 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(1, this->_internal_cache_items(), target);
1342 }
1343
1344 // optional uint64 delta = 2;
1345 if (cached_has_bits & 0x00000002u) {
1346 target = stream->EnsureSpace(target);
1347 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(2, this->_internal_delta(), target);
1348 }
1349
1350 // optional uint32 gfp_flags = 3;
1351 if (cached_has_bits & 0x00000020u) {
1352 target = stream->EnsureSpace(target);
1353 target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_gfp_flags(), target);
1354 }
1355
1356 // optional uint64 lru_pgs = 4;
1357 if (cached_has_bits & 0x00000004u) {
1358 target = stream->EnsureSpace(target);
1359 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_lru_pgs(), target);
1360 }
1361
1362 // optional int64 nr_objects_to_shrink = 5;
1363 if (cached_has_bits & 0x00000008u) {
1364 target = stream->EnsureSpace(target);
1365 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_nr_objects_to_shrink(), target);
1366 }
1367
1368 // optional uint64 pgs_scanned = 6;
1369 if (cached_has_bits & 0x00000010u) {
1370 target = stream->EnsureSpace(target);
1371 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(6, this->_internal_pgs_scanned(), target);
1372 }
1373
1374 // optional uint64 shr = 7;
1375 if (cached_has_bits & 0x00000080u) {
1376 target = stream->EnsureSpace(target);
1377 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(7, this->_internal_shr(), target);
1378 }
1379
1380 // optional uint64 shrink = 8;
1381 if (cached_has_bits & 0x00000100u) {
1382 target = stream->EnsureSpace(target);
1383 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(8, this->_internal_shrink(), target);
1384 }
1385
1386 // optional uint64 total_scan = 9;
1387 if (cached_has_bits & 0x00000200u) {
1388 target = stream->EnsureSpace(target);
1389 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(9, this->_internal_total_scan(), target);
1390 }
1391
1392 // optional int32 nid = 10;
1393 if (cached_has_bits & 0x00000040u) {
1394 target = stream->EnsureSpace(target);
1395 target = ::_pbi::WireFormatLite::WriteInt32ToArray(10, this->_internal_nid(), target);
1396 }
1397
1398 // optional int32 priority = 11;
1399 if (cached_has_bits & 0x00000400u) {
1400 target = stream->EnsureSpace(target);
1401 target = ::_pbi::WireFormatLite::WriteInt32ToArray(11, this->_internal_priority(), target);
1402 }
1403
1404 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1405 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1406 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1407 }
1408 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1409 return target;
1410 }
1411
ByteSizeLong() const1412 size_t MmShrinkSlabStartFtraceEvent::ByteSizeLong() const {
1413 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1414 size_t total_size = 0;
1415
1416 ::uint32_t cached_has_bits = 0;
1417 // Prevent compiler warnings about cached_has_bits being unused
1418 (void) cached_has_bits;
1419
1420 cached_has_bits = _impl_._has_bits_[0];
1421 if (cached_has_bits & 0x000000ffu) {
1422 // optional uint64 cache_items = 1;
1423 if (cached_has_bits & 0x00000001u) {
1424 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_cache_items());
1425 }
1426
1427 // optional uint64 delta = 2;
1428 if (cached_has_bits & 0x00000002u) {
1429 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_delta());
1430 }
1431
1432 // optional uint64 lru_pgs = 4;
1433 if (cached_has_bits & 0x00000004u) {
1434 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_lru_pgs());
1435 }
1436
1437 // optional int64 nr_objects_to_shrink = 5;
1438 if (cached_has_bits & 0x00000008u) {
1439 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_nr_objects_to_shrink());
1440 }
1441
1442 // optional uint64 pgs_scanned = 6;
1443 if (cached_has_bits & 0x00000010u) {
1444 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_pgs_scanned());
1445 }
1446
1447 // optional uint32 gfp_flags = 3;
1448 if (cached_has_bits & 0x00000020u) {
1449 total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_gfp_flags());
1450 }
1451
1452 // optional int32 nid = 10;
1453 if (cached_has_bits & 0x00000040u) {
1454 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
1455 }
1456
1457 // optional uint64 shr = 7;
1458 if (cached_has_bits & 0x00000080u) {
1459 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shr());
1460 }
1461
1462 }
1463 if (cached_has_bits & 0x00000700u) {
1464 // optional uint64 shrink = 8;
1465 if (cached_has_bits & 0x00000100u) {
1466 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shrink());
1467 }
1468
1469 // optional uint64 total_scan = 9;
1470 if (cached_has_bits & 0x00000200u) {
1471 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_total_scan());
1472 }
1473
1474 // optional int32 priority = 11;
1475 if (cached_has_bits & 0x00000400u) {
1476 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_priority());
1477 }
1478
1479 }
1480 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1481 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1482 }
1483 int cached_size = ::_pbi::ToCachedSize(total_size);
1484 SetCachedSize(cached_size);
1485 return total_size;
1486 }
1487
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1488 void MmShrinkSlabStartFtraceEvent::CheckTypeAndMergeFrom(
1489 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1490 MergeFrom(*::_pbi::DownCast<const MmShrinkSlabStartFtraceEvent*>(
1491 &from));
1492 }
1493
MergeFrom(const MmShrinkSlabStartFtraceEvent & from)1494 void MmShrinkSlabStartFtraceEvent::MergeFrom(const MmShrinkSlabStartFtraceEvent& from) {
1495 MmShrinkSlabStartFtraceEvent* const _this = this;
1496 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1497 GOOGLE_DCHECK_NE(&from, _this);
1498 ::uint32_t cached_has_bits = 0;
1499 (void) cached_has_bits;
1500
1501 cached_has_bits = from._impl_._has_bits_[0];
1502 if (cached_has_bits & 0x000000ffu) {
1503 if (cached_has_bits & 0x00000001u) {
1504 _this->_impl_.cache_items_ = from._impl_.cache_items_;
1505 }
1506 if (cached_has_bits & 0x00000002u) {
1507 _this->_impl_.delta_ = from._impl_.delta_;
1508 }
1509 if (cached_has_bits & 0x00000004u) {
1510 _this->_impl_.lru_pgs_ = from._impl_.lru_pgs_;
1511 }
1512 if (cached_has_bits & 0x00000008u) {
1513 _this->_impl_.nr_objects_to_shrink_ = from._impl_.nr_objects_to_shrink_;
1514 }
1515 if (cached_has_bits & 0x00000010u) {
1516 _this->_impl_.pgs_scanned_ = from._impl_.pgs_scanned_;
1517 }
1518 if (cached_has_bits & 0x00000020u) {
1519 _this->_impl_.gfp_flags_ = from._impl_.gfp_flags_;
1520 }
1521 if (cached_has_bits & 0x00000040u) {
1522 _this->_impl_.nid_ = from._impl_.nid_;
1523 }
1524 if (cached_has_bits & 0x00000080u) {
1525 _this->_impl_.shr_ = from._impl_.shr_;
1526 }
1527 _this->_impl_._has_bits_[0] |= cached_has_bits;
1528 }
1529 if (cached_has_bits & 0x00000700u) {
1530 if (cached_has_bits & 0x00000100u) {
1531 _this->_impl_.shrink_ = from._impl_.shrink_;
1532 }
1533 if (cached_has_bits & 0x00000200u) {
1534 _this->_impl_.total_scan_ = from._impl_.total_scan_;
1535 }
1536 if (cached_has_bits & 0x00000400u) {
1537 _this->_impl_.priority_ = from._impl_.priority_;
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 MmShrinkSlabStartFtraceEvent & from)1544 void MmShrinkSlabStartFtraceEvent::CopyFrom(const MmShrinkSlabStartFtraceEvent& from) {
1545 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmShrinkSlabStartFtraceEvent)
1546 if (&from == this) return;
1547 Clear();
1548 MergeFrom(from);
1549 }
1550
IsInitialized() const1551 bool MmShrinkSlabStartFtraceEvent::IsInitialized() const {
1552 return true;
1553 }
1554
InternalSwap(MmShrinkSlabStartFtraceEvent * other)1555 void MmShrinkSlabStartFtraceEvent::InternalSwap(MmShrinkSlabStartFtraceEvent* 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(MmShrinkSlabStartFtraceEvent, _impl_.priority_)
1561 + sizeof(MmShrinkSlabStartFtraceEvent::_impl_.priority_) // NOLINT
1562 - PROTOBUF_FIELD_OFFSET(MmShrinkSlabStartFtraceEvent, _impl_.cache_items_)>(
1563 reinterpret_cast<char*>(&_impl_.cache_items_),
1564 reinterpret_cast<char*>(&other->_impl_.cache_items_));
1565 }
1566
GetTypeName() const1567 std::string MmShrinkSlabStartFtraceEvent::GetTypeName() const {
1568 return "perfetto.protos.MmShrinkSlabStartFtraceEvent";
1569 }
1570
1571
1572 // ===================================================================
1573
1574 class MmShrinkSlabEndFtraceEvent::_Internal {
1575 public:
1576 using HasBits = decltype(std::declval<MmShrinkSlabEndFtraceEvent>()._impl_._has_bits_);
set_has_new_scan(HasBits * has_bits)1577 static void set_has_new_scan(HasBits* has_bits) {
1578 (*has_bits)[0] |= 1u;
1579 }
set_has_retval(HasBits * has_bits)1580 static void set_has_retval(HasBits* has_bits) {
1581 (*has_bits)[0] |= 8u;
1582 }
set_has_shr(HasBits * has_bits)1583 static void set_has_shr(HasBits* has_bits) {
1584 (*has_bits)[0] |= 2u;
1585 }
set_has_shrink(HasBits * has_bits)1586 static void set_has_shrink(HasBits* has_bits) {
1587 (*has_bits)[0] |= 4u;
1588 }
set_has_total_scan(HasBits * has_bits)1589 static void set_has_total_scan(HasBits* has_bits) {
1590 (*has_bits)[0] |= 32u;
1591 }
set_has_unused_scan(HasBits * has_bits)1592 static void set_has_unused_scan(HasBits* has_bits) {
1593 (*has_bits)[0] |= 64u;
1594 }
set_has_nid(HasBits * has_bits)1595 static void set_has_nid(HasBits* has_bits) {
1596 (*has_bits)[0] |= 16u;
1597 }
1598 };
1599
MmShrinkSlabEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)1600 MmShrinkSlabEndFtraceEvent::MmShrinkSlabEndFtraceEvent(::PROTOBUF_NAMESPACE_ID::Arena* arena,
1601 bool is_message_owned)
1602 : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
1603 SharedCtor(arena, is_message_owned);
1604 // @@protoc_insertion_point(arena_constructor:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1605 }
MmShrinkSlabEndFtraceEvent(const MmShrinkSlabEndFtraceEvent & from)1606 MmShrinkSlabEndFtraceEvent::MmShrinkSlabEndFtraceEvent(const MmShrinkSlabEndFtraceEvent& from)
1607 : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
1608 MmShrinkSlabEndFtraceEvent* const _this = this; (void)_this;
1609 new (&_impl_) Impl_{
1610 decltype(_impl_._has_bits_){from._impl_._has_bits_}
1611 , /*decltype(_impl_._cached_size_)*/{}
1612 , decltype(_impl_.new_scan_){}
1613 , decltype(_impl_.shr_){}
1614 , decltype(_impl_.shrink_){}
1615 , decltype(_impl_.retval_){}
1616 , decltype(_impl_.nid_){}
1617 , decltype(_impl_.total_scan_){}
1618 , decltype(_impl_.unused_scan_){}};
1619
1620 _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1621 ::memcpy(&_impl_.new_scan_, &from._impl_.new_scan_,
1622 static_cast<size_t>(reinterpret_cast<char*>(&_impl_.unused_scan_) -
1623 reinterpret_cast<char*>(&_impl_.new_scan_)) + sizeof(_impl_.unused_scan_));
1624 // @@protoc_insertion_point(copy_constructor:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1625 }
1626
SharedCtor(::_pb::Arena * arena,bool is_message_owned)1627 inline void MmShrinkSlabEndFtraceEvent::SharedCtor(
1628 ::_pb::Arena* arena, bool is_message_owned) {
1629 (void)arena;
1630 (void)is_message_owned;
1631 new (&_impl_) Impl_{
1632 decltype(_impl_._has_bits_){}
1633 , /*decltype(_impl_._cached_size_)*/{}
1634 , decltype(_impl_.new_scan_){::int64_t{0}}
1635 , decltype(_impl_.shr_){::uint64_t{0u}}
1636 , decltype(_impl_.shrink_){::uint64_t{0u}}
1637 , decltype(_impl_.retval_){0}
1638 , decltype(_impl_.nid_){0}
1639 , decltype(_impl_.total_scan_){::int64_t{0}}
1640 , decltype(_impl_.unused_scan_){::int64_t{0}}
1641 };
1642 }
1643
~MmShrinkSlabEndFtraceEvent()1644 MmShrinkSlabEndFtraceEvent::~MmShrinkSlabEndFtraceEvent() {
1645 // @@protoc_insertion_point(destructor:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1646 if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
1647 (void)arena;
1648 return;
1649 }
1650 SharedDtor();
1651 }
1652
SharedDtor()1653 inline void MmShrinkSlabEndFtraceEvent::SharedDtor() {
1654 GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
1655 }
1656
SetCachedSize(int size) const1657 void MmShrinkSlabEndFtraceEvent::SetCachedSize(int size) const {
1658 _impl_._cached_size_.Set(size);
1659 }
1660
Clear()1661 void MmShrinkSlabEndFtraceEvent::Clear() {
1662 // @@protoc_insertion_point(message_clear_start:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1663 ::uint32_t cached_has_bits = 0;
1664 // Prevent compiler warnings about cached_has_bits being unused
1665 (void) cached_has_bits;
1666
1667 cached_has_bits = _impl_._has_bits_[0];
1668 if (cached_has_bits & 0x0000007fu) {
1669 ::memset(&_impl_.new_scan_, 0, static_cast<size_t>(
1670 reinterpret_cast<char*>(&_impl_.unused_scan_) -
1671 reinterpret_cast<char*>(&_impl_.new_scan_)) + sizeof(_impl_.unused_scan_));
1672 }
1673 _impl_._has_bits_.Clear();
1674 _internal_metadata_.Clear<std::string>();
1675 }
1676
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)1677 const char* MmShrinkSlabEndFtraceEvent::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
1678 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
1679 _Internal::HasBits has_bits{};
1680 while (!ctx->Done(&ptr)) {
1681 ::uint32_t tag;
1682 ptr = ::_pbi::ReadTag(ptr, &tag);
1683 switch (tag >> 3) {
1684 // optional int64 new_scan = 1;
1685 case 1:
1686 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 8)) {
1687 _Internal::set_has_new_scan(&has_bits);
1688 _impl_.new_scan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1689 CHK_(ptr);
1690 } else {
1691 goto handle_unusual;
1692 }
1693 continue;
1694 // optional int32 retval = 2;
1695 case 2:
1696 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
1697 _Internal::set_has_retval(&has_bits);
1698 _impl_.retval_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1699 CHK_(ptr);
1700 } else {
1701 goto handle_unusual;
1702 }
1703 continue;
1704 // optional uint64 shr = 3;
1705 case 3:
1706 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
1707 _Internal::set_has_shr(&has_bits);
1708 _impl_.shr_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1709 CHK_(ptr);
1710 } else {
1711 goto handle_unusual;
1712 }
1713 continue;
1714 // optional uint64 shrink = 4;
1715 case 4:
1716 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
1717 _Internal::set_has_shrink(&has_bits);
1718 _impl_.shrink_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1719 CHK_(ptr);
1720 } else {
1721 goto handle_unusual;
1722 }
1723 continue;
1724 // optional int64 total_scan = 5;
1725 case 5:
1726 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
1727 _Internal::set_has_total_scan(&has_bits);
1728 _impl_.total_scan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1729 CHK_(ptr);
1730 } else {
1731 goto handle_unusual;
1732 }
1733 continue;
1734 // optional int64 unused_scan = 6;
1735 case 6:
1736 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
1737 _Internal::set_has_unused_scan(&has_bits);
1738 _impl_.unused_scan_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
1739 CHK_(ptr);
1740 } else {
1741 goto handle_unusual;
1742 }
1743 continue;
1744 // optional int32 nid = 7;
1745 case 7:
1746 if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
1747 _Internal::set_has_nid(&has_bits);
1748 _impl_.nid_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
1749 CHK_(ptr);
1750 } else {
1751 goto handle_unusual;
1752 }
1753 continue;
1754 default:
1755 goto handle_unusual;
1756 } // switch
1757 handle_unusual:
1758 if ((tag == 0) || ((tag & 7) == 4)) {
1759 CHK_(ptr);
1760 ctx->SetLastTag(tag);
1761 goto message_done;
1762 }
1763 ptr = UnknownFieldParse(
1764 tag,
1765 _internal_metadata_.mutable_unknown_fields<std::string>(),
1766 ptr, ctx);
1767 CHK_(ptr != nullptr);
1768 } // while
1769 message_done:
1770 _impl_._has_bits_.Or(has_bits);
1771 return ptr;
1772 failure:
1773 ptr = nullptr;
1774 goto message_done;
1775 #undef CHK_
1776 }
1777
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const1778 ::uint8_t* MmShrinkSlabEndFtraceEvent::_InternalSerialize(
1779 ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
1780 // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1781 ::uint32_t cached_has_bits = 0;
1782 (void) cached_has_bits;
1783
1784 cached_has_bits = _impl_._has_bits_[0];
1785 // optional int64 new_scan = 1;
1786 if (cached_has_bits & 0x00000001u) {
1787 target = stream->EnsureSpace(target);
1788 target = ::_pbi::WireFormatLite::WriteInt64ToArray(1, this->_internal_new_scan(), target);
1789 }
1790
1791 // optional int32 retval = 2;
1792 if (cached_has_bits & 0x00000008u) {
1793 target = stream->EnsureSpace(target);
1794 target = ::_pbi::WireFormatLite::WriteInt32ToArray(2, this->_internal_retval(), target);
1795 }
1796
1797 // optional uint64 shr = 3;
1798 if (cached_has_bits & 0x00000002u) {
1799 target = stream->EnsureSpace(target);
1800 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(3, this->_internal_shr(), target);
1801 }
1802
1803 // optional uint64 shrink = 4;
1804 if (cached_has_bits & 0x00000004u) {
1805 target = stream->EnsureSpace(target);
1806 target = ::_pbi::WireFormatLite::WriteUInt64ToArray(4, this->_internal_shrink(), target);
1807 }
1808
1809 // optional int64 total_scan = 5;
1810 if (cached_has_bits & 0x00000020u) {
1811 target = stream->EnsureSpace(target);
1812 target = ::_pbi::WireFormatLite::WriteInt64ToArray(5, this->_internal_total_scan(), target);
1813 }
1814
1815 // optional int64 unused_scan = 6;
1816 if (cached_has_bits & 0x00000040u) {
1817 target = stream->EnsureSpace(target);
1818 target = ::_pbi::WireFormatLite::WriteInt64ToArray(6, this->_internal_unused_scan(), target);
1819 }
1820
1821 // optional int32 nid = 7;
1822 if (cached_has_bits & 0x00000010u) {
1823 target = stream->EnsureSpace(target);
1824 target = ::_pbi::WireFormatLite::WriteInt32ToArray(7, this->_internal_nid(), target);
1825 }
1826
1827 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1828 target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
1829 static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
1830 }
1831 // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1832 return target;
1833 }
1834
ByteSizeLong() const1835 size_t MmShrinkSlabEndFtraceEvent::ByteSizeLong() const {
1836 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1837 size_t total_size = 0;
1838
1839 ::uint32_t cached_has_bits = 0;
1840 // Prevent compiler warnings about cached_has_bits being unused
1841 (void) cached_has_bits;
1842
1843 cached_has_bits = _impl_._has_bits_[0];
1844 if (cached_has_bits & 0x0000007fu) {
1845 // optional int64 new_scan = 1;
1846 if (cached_has_bits & 0x00000001u) {
1847 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_new_scan());
1848 }
1849
1850 // optional uint64 shr = 3;
1851 if (cached_has_bits & 0x00000002u) {
1852 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shr());
1853 }
1854
1855 // optional uint64 shrink = 4;
1856 if (cached_has_bits & 0x00000004u) {
1857 total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne(this->_internal_shrink());
1858 }
1859
1860 // optional int32 retval = 2;
1861 if (cached_has_bits & 0x00000008u) {
1862 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_retval());
1863 }
1864
1865 // optional int32 nid = 7;
1866 if (cached_has_bits & 0x00000010u) {
1867 total_size += ::_pbi::WireFormatLite::Int32SizePlusOne(this->_internal_nid());
1868 }
1869
1870 // optional int64 total_scan = 5;
1871 if (cached_has_bits & 0x00000020u) {
1872 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_total_scan());
1873 }
1874
1875 // optional int64 unused_scan = 6;
1876 if (cached_has_bits & 0x00000040u) {
1877 total_size += ::_pbi::WireFormatLite::Int64SizePlusOne(this->_internal_unused_scan());
1878 }
1879
1880 }
1881 if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
1882 total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
1883 }
1884 int cached_size = ::_pbi::ToCachedSize(total_size);
1885 SetCachedSize(cached_size);
1886 return total_size;
1887 }
1888
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)1889 void MmShrinkSlabEndFtraceEvent::CheckTypeAndMergeFrom(
1890 const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
1891 MergeFrom(*::_pbi::DownCast<const MmShrinkSlabEndFtraceEvent*>(
1892 &from));
1893 }
1894
MergeFrom(const MmShrinkSlabEndFtraceEvent & from)1895 void MmShrinkSlabEndFtraceEvent::MergeFrom(const MmShrinkSlabEndFtraceEvent& from) {
1896 MmShrinkSlabEndFtraceEvent* const _this = this;
1897 // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1898 GOOGLE_DCHECK_NE(&from, _this);
1899 ::uint32_t cached_has_bits = 0;
1900 (void) cached_has_bits;
1901
1902 cached_has_bits = from._impl_._has_bits_[0];
1903 if (cached_has_bits & 0x0000007fu) {
1904 if (cached_has_bits & 0x00000001u) {
1905 _this->_impl_.new_scan_ = from._impl_.new_scan_;
1906 }
1907 if (cached_has_bits & 0x00000002u) {
1908 _this->_impl_.shr_ = from._impl_.shr_;
1909 }
1910 if (cached_has_bits & 0x00000004u) {
1911 _this->_impl_.shrink_ = from._impl_.shrink_;
1912 }
1913 if (cached_has_bits & 0x00000008u) {
1914 _this->_impl_.retval_ = from._impl_.retval_;
1915 }
1916 if (cached_has_bits & 0x00000010u) {
1917 _this->_impl_.nid_ = from._impl_.nid_;
1918 }
1919 if (cached_has_bits & 0x00000020u) {
1920 _this->_impl_.total_scan_ = from._impl_.total_scan_;
1921 }
1922 if (cached_has_bits & 0x00000040u) {
1923 _this->_impl_.unused_scan_ = from._impl_.unused_scan_;
1924 }
1925 _this->_impl_._has_bits_[0] |= cached_has_bits;
1926 }
1927 _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
1928 }
1929
CopyFrom(const MmShrinkSlabEndFtraceEvent & from)1930 void MmShrinkSlabEndFtraceEvent::CopyFrom(const MmShrinkSlabEndFtraceEvent& from) {
1931 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.MmShrinkSlabEndFtraceEvent)
1932 if (&from == this) return;
1933 Clear();
1934 MergeFrom(from);
1935 }
1936
IsInitialized() const1937 bool MmShrinkSlabEndFtraceEvent::IsInitialized() const {
1938 return true;
1939 }
1940
InternalSwap(MmShrinkSlabEndFtraceEvent * other)1941 void MmShrinkSlabEndFtraceEvent::InternalSwap(MmShrinkSlabEndFtraceEvent* other) {
1942 using std::swap;
1943 _internal_metadata_.InternalSwap(&other->_internal_metadata_);
1944 swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
1945 ::PROTOBUF_NAMESPACE_ID::internal::memswap<
1946 PROTOBUF_FIELD_OFFSET(MmShrinkSlabEndFtraceEvent, _impl_.unused_scan_)
1947 + sizeof(MmShrinkSlabEndFtraceEvent::_impl_.unused_scan_) // NOLINT
1948 - PROTOBUF_FIELD_OFFSET(MmShrinkSlabEndFtraceEvent, _impl_.new_scan_)>(
1949 reinterpret_cast<char*>(&_impl_.new_scan_),
1950 reinterpret_cast<char*>(&other->_impl_.new_scan_));
1951 }
1952
GetTypeName() const1953 std::string MmShrinkSlabEndFtraceEvent::GetTypeName() const {
1954 return "perfetto.protos.MmShrinkSlabEndFtraceEvent";
1955 }
1956
1957
1958 // @@protoc_insertion_point(namespace_scope)
1959 } // namespace protos
1960 } // namespace perfetto
1961 PROTOBUF_NAMESPACE_OPEN
1962 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmVmscanDirectReclaimBeginFtraceEvent*
CreateMaybeMessage(Arena * arena)1963 Arena::CreateMaybeMessage< ::perfetto::protos::MmVmscanDirectReclaimBeginFtraceEvent >(Arena* arena) {
1964 return Arena::CreateMessageInternal< ::perfetto::protos::MmVmscanDirectReclaimBeginFtraceEvent >(arena);
1965 }
1966 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmVmscanDirectReclaimEndFtraceEvent*
CreateMaybeMessage(Arena * arena)1967 Arena::CreateMaybeMessage< ::perfetto::protos::MmVmscanDirectReclaimEndFtraceEvent >(Arena* arena) {
1968 return Arena::CreateMessageInternal< ::perfetto::protos::MmVmscanDirectReclaimEndFtraceEvent >(arena);
1969 }
1970 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmVmscanKswapdWakeFtraceEvent*
CreateMaybeMessage(Arena * arena)1971 Arena::CreateMaybeMessage< ::perfetto::protos::MmVmscanKswapdWakeFtraceEvent >(Arena* arena) {
1972 return Arena::CreateMessageInternal< ::perfetto::protos::MmVmscanKswapdWakeFtraceEvent >(arena);
1973 }
1974 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmVmscanKswapdSleepFtraceEvent*
CreateMaybeMessage(Arena * arena)1975 Arena::CreateMaybeMessage< ::perfetto::protos::MmVmscanKswapdSleepFtraceEvent >(Arena* arena) {
1976 return Arena::CreateMessageInternal< ::perfetto::protos::MmVmscanKswapdSleepFtraceEvent >(arena);
1977 }
1978 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmShrinkSlabStartFtraceEvent*
CreateMaybeMessage(Arena * arena)1979 Arena::CreateMaybeMessage< ::perfetto::protos::MmShrinkSlabStartFtraceEvent >(Arena* arena) {
1980 return Arena::CreateMessageInternal< ::perfetto::protos::MmShrinkSlabStartFtraceEvent >(arena);
1981 }
1982 template<> PROTOBUF_NOINLINE ::perfetto::protos::MmShrinkSlabEndFtraceEvent*
CreateMaybeMessage(Arena * arena)1983 Arena::CreateMaybeMessage< ::perfetto::protos::MmShrinkSlabEndFtraceEvent >(Arena* arena) {
1984 return Arena::CreateMessageInternal< ::perfetto::protos::MmShrinkSlabEndFtraceEvent >(arena);
1985 }
1986 PROTOBUF_NAMESPACE_CLOSE
1987
1988 // @@protoc_insertion_point(global_scope)
1989 #include <google/protobuf/port_undef.inc>
1990