1 // Generated by the protocol buffer compiler.  DO NOT EDIT!
2 // source: protos/perfetto/config/stress_test_config.proto
3 
4 #include "protos/perfetto/config/stress_test_config.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 {
StressTestConfig_WriterTiming(::_pbi::ConstantInitialized)23 PROTOBUF_CONSTEXPR StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(
24     ::_pbi::ConstantInitialized): _impl_{
25     /*decltype(_impl_._has_bits_)*/{}
26   , /*decltype(_impl_._cached_size_)*/{}
27   , /*decltype(_impl_.payload_mean_)*/0
28   , /*decltype(_impl_.payload_stddev_)*/0
29   , /*decltype(_impl_.rate_mean_)*/0
30   , /*decltype(_impl_.rate_stddev_)*/0
31   , /*decltype(_impl_.payload_write_time_ms_)*/0u} {}
32 struct StressTestConfig_WriterTimingDefaultTypeInternal {
StressTestConfig_WriterTimingDefaultTypeInternalperfetto::protos::StressTestConfig_WriterTimingDefaultTypeInternal33   PROTOBUF_CONSTEXPR StressTestConfig_WriterTimingDefaultTypeInternal()
34       : _instance(::_pbi::ConstantInitialized{}) {}
~StressTestConfig_WriterTimingDefaultTypeInternalperfetto::protos::StressTestConfig_WriterTimingDefaultTypeInternal35   ~StressTestConfig_WriterTimingDefaultTypeInternal() {}
36   union {  // NOLINT(misc-non-private-member-variables-in-classes)
37     StressTestConfig_WriterTiming _instance;
38   };
39 };
40 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StressTestConfig_WriterTimingDefaultTypeInternal _StressTestConfig_WriterTiming_default_instance_;
StressTestConfig(::_pbi::ConstantInitialized)41 PROTOBUF_CONSTEXPR StressTestConfig::StressTestConfig(
42     ::_pbi::ConstantInitialized): _impl_{
43     /*decltype(_impl_._has_bits_)*/{}
44   , /*decltype(_impl_._cached_size_)*/{}
45   , /*decltype(_impl_.trace_config_)*/nullptr
46   , /*decltype(_impl_.steady_state_timings_)*/nullptr
47   , /*decltype(_impl_.burst_timings_)*/nullptr
48   , /*decltype(_impl_.shmem_size_kb_)*/0u
49   , /*decltype(_impl_.shmem_page_size_kb_)*/0u
50   , /*decltype(_impl_.num_processes_)*/0u
51   , /*decltype(_impl_.num_threads_)*/0u
52   , /*decltype(_impl_.max_events_)*/0u
53   , /*decltype(_impl_.nesting_)*/0u
54   , /*decltype(_impl_.burst_period_ms_)*/0u
55   , /*decltype(_impl_.burst_duration_ms_)*/0u} {}
56 struct StressTestConfigDefaultTypeInternal {
StressTestConfigDefaultTypeInternalperfetto::protos::StressTestConfigDefaultTypeInternal57   PROTOBUF_CONSTEXPR StressTestConfigDefaultTypeInternal()
58       : _instance(::_pbi::ConstantInitialized{}) {}
~StressTestConfigDefaultTypeInternalperfetto::protos::StressTestConfigDefaultTypeInternal59   ~StressTestConfigDefaultTypeInternal() {}
60   union {  // NOLINT(misc-non-private-member-variables-in-classes)
61     StressTestConfig _instance;
62   };
63 };
64 PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 StressTestConfigDefaultTypeInternal _StressTestConfig_default_instance_;
65 }  // namespace protos
66 }  // namespace perfetto
67 namespace perfetto {
68 namespace protos {
69 
70 // ===================================================================
71 
72 class StressTestConfig_WriterTiming::_Internal {
73  public:
74   using HasBits = decltype(std::declval<StressTestConfig_WriterTiming>()._impl_._has_bits_);
set_has_payload_mean(HasBits * has_bits)75   static void set_has_payload_mean(HasBits* has_bits) {
76     (*has_bits)[0] |= 1u;
77   }
set_has_payload_stddev(HasBits * has_bits)78   static void set_has_payload_stddev(HasBits* has_bits) {
79     (*has_bits)[0] |= 2u;
80   }
set_has_rate_mean(HasBits * has_bits)81   static void set_has_rate_mean(HasBits* has_bits) {
82     (*has_bits)[0] |= 4u;
83   }
set_has_rate_stddev(HasBits * has_bits)84   static void set_has_rate_stddev(HasBits* has_bits) {
85     (*has_bits)[0] |= 8u;
86   }
set_has_payload_write_time_ms(HasBits * has_bits)87   static void set_has_payload_write_time_ms(HasBits* has_bits) {
88     (*has_bits)[0] |= 16u;
89   }
90 };
91 
StressTestConfig_WriterTiming(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)92 StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(::PROTOBUF_NAMESPACE_ID::Arena* arena,
93                          bool is_message_owned)
94   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
95   SharedCtor(arena, is_message_owned);
96   // @@protoc_insertion_point(arena_constructor:perfetto.protos.StressTestConfig.WriterTiming)
97 }
StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming & from)98 StressTestConfig_WriterTiming::StressTestConfig_WriterTiming(const StressTestConfig_WriterTiming& from)
99   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
100   StressTestConfig_WriterTiming* const _this = this; (void)_this;
101   new (&_impl_) Impl_{
102       decltype(_impl_._has_bits_){from._impl_._has_bits_}
103     , /*decltype(_impl_._cached_size_)*/{}
104     , decltype(_impl_.payload_mean_){}
105     , decltype(_impl_.payload_stddev_){}
106     , decltype(_impl_.rate_mean_){}
107     , decltype(_impl_.rate_stddev_){}
108     , decltype(_impl_.payload_write_time_ms_){}};
109 
110   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
111   ::memcpy(&_impl_.payload_mean_, &from._impl_.payload_mean_,
112     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.payload_write_time_ms_) -
113     reinterpret_cast<char*>(&_impl_.payload_mean_)) + sizeof(_impl_.payload_write_time_ms_));
114   // @@protoc_insertion_point(copy_constructor:perfetto.protos.StressTestConfig.WriterTiming)
115 }
116 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)117 inline void StressTestConfig_WriterTiming::SharedCtor(
118     ::_pb::Arena* arena, bool is_message_owned) {
119   (void)arena;
120   (void)is_message_owned;
121   new (&_impl_) Impl_{
122       decltype(_impl_._has_bits_){}
123     , /*decltype(_impl_._cached_size_)*/{}
124     , decltype(_impl_.payload_mean_){0}
125     , decltype(_impl_.payload_stddev_){0}
126     , decltype(_impl_.rate_mean_){0}
127     , decltype(_impl_.rate_stddev_){0}
128     , decltype(_impl_.payload_write_time_ms_){0u}
129   };
130 }
131 
~StressTestConfig_WriterTiming()132 StressTestConfig_WriterTiming::~StressTestConfig_WriterTiming() {
133   // @@protoc_insertion_point(destructor:perfetto.protos.StressTestConfig.WriterTiming)
134   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
135   (void)arena;
136     return;
137   }
138   SharedDtor();
139 }
140 
SharedDtor()141 inline void StressTestConfig_WriterTiming::SharedDtor() {
142   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
143 }
144 
SetCachedSize(int size) const145 void StressTestConfig_WriterTiming::SetCachedSize(int size) const {
146   _impl_._cached_size_.Set(size);
147 }
148 
Clear()149 void StressTestConfig_WriterTiming::Clear() {
150 // @@protoc_insertion_point(message_clear_start:perfetto.protos.StressTestConfig.WriterTiming)
151   ::uint32_t cached_has_bits = 0;
152   // Prevent compiler warnings about cached_has_bits being unused
153   (void) cached_has_bits;
154 
155   cached_has_bits = _impl_._has_bits_[0];
156   if (cached_has_bits & 0x0000001fu) {
157     ::memset(&_impl_.payload_mean_, 0, static_cast<size_t>(
158         reinterpret_cast<char*>(&_impl_.payload_write_time_ms_) -
159         reinterpret_cast<char*>(&_impl_.payload_mean_)) + sizeof(_impl_.payload_write_time_ms_));
160   }
161   _impl_._has_bits_.Clear();
162   _internal_metadata_.Clear<std::string>();
163 }
164 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)165 const char* StressTestConfig_WriterTiming::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
166 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
167   _Internal::HasBits has_bits{};
168   while (!ctx->Done(&ptr)) {
169     ::uint32_t tag;
170     ptr = ::_pbi::ReadTag(ptr, &tag);
171     switch (tag >> 3) {
172       // optional double payload_mean = 1;
173       case 1:
174         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 9)) {
175           _Internal::set_has_payload_mean(&has_bits);
176           _impl_.payload_mean_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
177           ptr += sizeof(double);
178         } else {
179           goto handle_unusual;
180         }
181         continue;
182       // optional double payload_stddev = 2;
183       case 2:
184         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 17)) {
185           _Internal::set_has_payload_stddev(&has_bits);
186           _impl_.payload_stddev_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
187           ptr += sizeof(double);
188         } else {
189           goto handle_unusual;
190         }
191         continue;
192       // optional double rate_mean = 3;
193       case 3:
194         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 25)) {
195           _Internal::set_has_rate_mean(&has_bits);
196           _impl_.rate_mean_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
197           ptr += sizeof(double);
198         } else {
199           goto handle_unusual;
200         }
201         continue;
202       // optional double rate_stddev = 4;
203       case 4:
204         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 33)) {
205           _Internal::set_has_rate_stddev(&has_bits);
206           _impl_.rate_stddev_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<double>(ptr);
207           ptr += sizeof(double);
208         } else {
209           goto handle_unusual;
210         }
211         continue;
212       // optional uint32 payload_write_time_ms = 5;
213       case 5:
214         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
215           _Internal::set_has_payload_write_time_ms(&has_bits);
216           _impl_.payload_write_time_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
217           CHK_(ptr);
218         } else {
219           goto handle_unusual;
220         }
221         continue;
222       default:
223         goto handle_unusual;
224     }  // switch
225   handle_unusual:
226     if ((tag == 0) || ((tag & 7) == 4)) {
227       CHK_(ptr);
228       ctx->SetLastTag(tag);
229       goto message_done;
230     }
231     ptr = UnknownFieldParse(
232         tag,
233         _internal_metadata_.mutable_unknown_fields<std::string>(),
234         ptr, ctx);
235     CHK_(ptr != nullptr);
236   }  // while
237 message_done:
238   _impl_._has_bits_.Or(has_bits);
239   return ptr;
240 failure:
241   ptr = nullptr;
242   goto message_done;
243 #undef CHK_
244 }
245 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const246 ::uint8_t* StressTestConfig_WriterTiming::_InternalSerialize(
247     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
248   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.StressTestConfig.WriterTiming)
249   ::uint32_t cached_has_bits = 0;
250   (void) cached_has_bits;
251 
252   cached_has_bits = _impl_._has_bits_[0];
253   // optional double payload_mean = 1;
254   if (cached_has_bits & 0x00000001u) {
255     target = stream->EnsureSpace(target);
256     target = ::_pbi::WireFormatLite::WriteDoubleToArray(1, this->_internal_payload_mean(), target);
257   }
258 
259   // optional double payload_stddev = 2;
260   if (cached_has_bits & 0x00000002u) {
261     target = stream->EnsureSpace(target);
262     target = ::_pbi::WireFormatLite::WriteDoubleToArray(2, this->_internal_payload_stddev(), target);
263   }
264 
265   // optional double rate_mean = 3;
266   if (cached_has_bits & 0x00000004u) {
267     target = stream->EnsureSpace(target);
268     target = ::_pbi::WireFormatLite::WriteDoubleToArray(3, this->_internal_rate_mean(), target);
269   }
270 
271   // optional double rate_stddev = 4;
272   if (cached_has_bits & 0x00000008u) {
273     target = stream->EnsureSpace(target);
274     target = ::_pbi::WireFormatLite::WriteDoubleToArray(4, this->_internal_rate_stddev(), target);
275   }
276 
277   // optional uint32 payload_write_time_ms = 5;
278   if (cached_has_bits & 0x00000010u) {
279     target = stream->EnsureSpace(target);
280     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_payload_write_time_ms(), target);
281   }
282 
283   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
284     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
285         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
286   }
287   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.StressTestConfig.WriterTiming)
288   return target;
289 }
290 
ByteSizeLong() const291 size_t StressTestConfig_WriterTiming::ByteSizeLong() const {
292 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.StressTestConfig.WriterTiming)
293   size_t total_size = 0;
294 
295   ::uint32_t cached_has_bits = 0;
296   // Prevent compiler warnings about cached_has_bits being unused
297   (void) cached_has_bits;
298 
299   cached_has_bits = _impl_._has_bits_[0];
300   if (cached_has_bits & 0x0000001fu) {
301     // optional double payload_mean = 1;
302     if (cached_has_bits & 0x00000001u) {
303       total_size += 1 + 8;
304     }
305 
306     // optional double payload_stddev = 2;
307     if (cached_has_bits & 0x00000002u) {
308       total_size += 1 + 8;
309     }
310 
311     // optional double rate_mean = 3;
312     if (cached_has_bits & 0x00000004u) {
313       total_size += 1 + 8;
314     }
315 
316     // optional double rate_stddev = 4;
317     if (cached_has_bits & 0x00000008u) {
318       total_size += 1 + 8;
319     }
320 
321     // optional uint32 payload_write_time_ms = 5;
322     if (cached_has_bits & 0x00000010u) {
323       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_payload_write_time_ms());
324     }
325 
326   }
327   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
328     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
329   }
330   int cached_size = ::_pbi::ToCachedSize(total_size);
331   SetCachedSize(cached_size);
332   return total_size;
333 }
334 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)335 void StressTestConfig_WriterTiming::CheckTypeAndMergeFrom(
336     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
337   MergeFrom(*::_pbi::DownCast<const StressTestConfig_WriterTiming*>(
338       &from));
339 }
340 
MergeFrom(const StressTestConfig_WriterTiming & from)341 void StressTestConfig_WriterTiming::MergeFrom(const StressTestConfig_WriterTiming& from) {
342   StressTestConfig_WriterTiming* const _this = this;
343   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.StressTestConfig.WriterTiming)
344   GOOGLE_DCHECK_NE(&from, _this);
345   ::uint32_t cached_has_bits = 0;
346   (void) cached_has_bits;
347 
348   cached_has_bits = from._impl_._has_bits_[0];
349   if (cached_has_bits & 0x0000001fu) {
350     if (cached_has_bits & 0x00000001u) {
351       _this->_impl_.payload_mean_ = from._impl_.payload_mean_;
352     }
353     if (cached_has_bits & 0x00000002u) {
354       _this->_impl_.payload_stddev_ = from._impl_.payload_stddev_;
355     }
356     if (cached_has_bits & 0x00000004u) {
357       _this->_impl_.rate_mean_ = from._impl_.rate_mean_;
358     }
359     if (cached_has_bits & 0x00000008u) {
360       _this->_impl_.rate_stddev_ = from._impl_.rate_stddev_;
361     }
362     if (cached_has_bits & 0x00000010u) {
363       _this->_impl_.payload_write_time_ms_ = from._impl_.payload_write_time_ms_;
364     }
365     _this->_impl_._has_bits_[0] |= cached_has_bits;
366   }
367   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
368 }
369 
CopyFrom(const StressTestConfig_WriterTiming & from)370 void StressTestConfig_WriterTiming::CopyFrom(const StressTestConfig_WriterTiming& from) {
371 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.StressTestConfig.WriterTiming)
372   if (&from == this) return;
373   Clear();
374   MergeFrom(from);
375 }
376 
IsInitialized() const377 bool StressTestConfig_WriterTiming::IsInitialized() const {
378   return true;
379 }
380 
InternalSwap(StressTestConfig_WriterTiming * other)381 void StressTestConfig_WriterTiming::InternalSwap(StressTestConfig_WriterTiming* other) {
382   using std::swap;
383   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
384   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
385   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
386       PROTOBUF_FIELD_OFFSET(StressTestConfig_WriterTiming, _impl_.payload_write_time_ms_)
387       + sizeof(StressTestConfig_WriterTiming::_impl_.payload_write_time_ms_)  // NOLINT
388       - PROTOBUF_FIELD_OFFSET(StressTestConfig_WriterTiming, _impl_.payload_mean_)>(
389           reinterpret_cast<char*>(&_impl_.payload_mean_),
390           reinterpret_cast<char*>(&other->_impl_.payload_mean_));
391 }
392 
GetTypeName() const393 std::string StressTestConfig_WriterTiming::GetTypeName() const {
394   return "perfetto.protos.StressTestConfig.WriterTiming";
395 }
396 
397 
398 // ===================================================================
399 
400 class StressTestConfig::_Internal {
401  public:
402   using HasBits = decltype(std::declval<StressTestConfig>()._impl_._has_bits_);
403   static const ::perfetto::protos::TraceConfig& trace_config(const StressTestConfig* msg);
set_has_trace_config(HasBits * has_bits)404   static void set_has_trace_config(HasBits* has_bits) {
405     (*has_bits)[0] |= 1u;
406   }
set_has_shmem_size_kb(HasBits * has_bits)407   static void set_has_shmem_size_kb(HasBits* has_bits) {
408     (*has_bits)[0] |= 8u;
409   }
set_has_shmem_page_size_kb(HasBits * has_bits)410   static void set_has_shmem_page_size_kb(HasBits* has_bits) {
411     (*has_bits)[0] |= 16u;
412   }
set_has_num_processes(HasBits * has_bits)413   static void set_has_num_processes(HasBits* has_bits) {
414     (*has_bits)[0] |= 32u;
415   }
set_has_num_threads(HasBits * has_bits)416   static void set_has_num_threads(HasBits* has_bits) {
417     (*has_bits)[0] |= 64u;
418   }
set_has_max_events(HasBits * has_bits)419   static void set_has_max_events(HasBits* has_bits) {
420     (*has_bits)[0] |= 128u;
421   }
set_has_nesting(HasBits * has_bits)422   static void set_has_nesting(HasBits* has_bits) {
423     (*has_bits)[0] |= 256u;
424   }
425   static const ::perfetto::protos::StressTestConfig_WriterTiming& steady_state_timings(const StressTestConfig* msg);
set_has_steady_state_timings(HasBits * has_bits)426   static void set_has_steady_state_timings(HasBits* has_bits) {
427     (*has_bits)[0] |= 2u;
428   }
set_has_burst_period_ms(HasBits * has_bits)429   static void set_has_burst_period_ms(HasBits* has_bits) {
430     (*has_bits)[0] |= 512u;
431   }
set_has_burst_duration_ms(HasBits * has_bits)432   static void set_has_burst_duration_ms(HasBits* has_bits) {
433     (*has_bits)[0] |= 1024u;
434   }
435   static const ::perfetto::protos::StressTestConfig_WriterTiming& burst_timings(const StressTestConfig* msg);
set_has_burst_timings(HasBits * has_bits)436   static void set_has_burst_timings(HasBits* has_bits) {
437     (*has_bits)[0] |= 4u;
438   }
439 };
440 
441 const ::perfetto::protos::TraceConfig&
trace_config(const StressTestConfig * msg)442 StressTestConfig::_Internal::trace_config(const StressTestConfig* msg) {
443   return *msg->_impl_.trace_config_;
444 }
445 const ::perfetto::protos::StressTestConfig_WriterTiming&
steady_state_timings(const StressTestConfig * msg)446 StressTestConfig::_Internal::steady_state_timings(const StressTestConfig* msg) {
447   return *msg->_impl_.steady_state_timings_;
448 }
449 const ::perfetto::protos::StressTestConfig_WriterTiming&
burst_timings(const StressTestConfig * msg)450 StressTestConfig::_Internal::burst_timings(const StressTestConfig* msg) {
451   return *msg->_impl_.burst_timings_;
452 }
clear_trace_config()453 void StressTestConfig::clear_trace_config() {
454   if (_impl_.trace_config_ != nullptr) _impl_.trace_config_->Clear();
455   _impl_._has_bits_[0] &= ~0x00000001u;
456 }
StressTestConfig(::PROTOBUF_NAMESPACE_ID::Arena * arena,bool is_message_owned)457 StressTestConfig::StressTestConfig(::PROTOBUF_NAMESPACE_ID::Arena* arena,
458                          bool is_message_owned)
459   : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena, is_message_owned) {
460   SharedCtor(arena, is_message_owned);
461   // @@protoc_insertion_point(arena_constructor:perfetto.protos.StressTestConfig)
462 }
StressTestConfig(const StressTestConfig & from)463 StressTestConfig::StressTestConfig(const StressTestConfig& from)
464   : ::PROTOBUF_NAMESPACE_ID::MessageLite() {
465   StressTestConfig* const _this = this; (void)_this;
466   new (&_impl_) Impl_{
467       decltype(_impl_._has_bits_){from._impl_._has_bits_}
468     , /*decltype(_impl_._cached_size_)*/{}
469     , decltype(_impl_.trace_config_){nullptr}
470     , decltype(_impl_.steady_state_timings_){nullptr}
471     , decltype(_impl_.burst_timings_){nullptr}
472     , decltype(_impl_.shmem_size_kb_){}
473     , decltype(_impl_.shmem_page_size_kb_){}
474     , decltype(_impl_.num_processes_){}
475     , decltype(_impl_.num_threads_){}
476     , decltype(_impl_.max_events_){}
477     , decltype(_impl_.nesting_){}
478     , decltype(_impl_.burst_period_ms_){}
479     , decltype(_impl_.burst_duration_ms_){}};
480 
481   _internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
482   if (from._internal_has_trace_config()) {
483     _this->_impl_.trace_config_ = new ::perfetto::protos::TraceConfig(*from._impl_.trace_config_);
484   }
485   if (from._internal_has_steady_state_timings()) {
486     _this->_impl_.steady_state_timings_ = new ::perfetto::protos::StressTestConfig_WriterTiming(*from._impl_.steady_state_timings_);
487   }
488   if (from._internal_has_burst_timings()) {
489     _this->_impl_.burst_timings_ = new ::perfetto::protos::StressTestConfig_WriterTiming(*from._impl_.burst_timings_);
490   }
491   ::memcpy(&_impl_.shmem_size_kb_, &from._impl_.shmem_size_kb_,
492     static_cast<size_t>(reinterpret_cast<char*>(&_impl_.burst_duration_ms_) -
493     reinterpret_cast<char*>(&_impl_.shmem_size_kb_)) + sizeof(_impl_.burst_duration_ms_));
494   // @@protoc_insertion_point(copy_constructor:perfetto.protos.StressTestConfig)
495 }
496 
SharedCtor(::_pb::Arena * arena,bool is_message_owned)497 inline void StressTestConfig::SharedCtor(
498     ::_pb::Arena* arena, bool is_message_owned) {
499   (void)arena;
500   (void)is_message_owned;
501   new (&_impl_) Impl_{
502       decltype(_impl_._has_bits_){}
503     , /*decltype(_impl_._cached_size_)*/{}
504     , decltype(_impl_.trace_config_){nullptr}
505     , decltype(_impl_.steady_state_timings_){nullptr}
506     , decltype(_impl_.burst_timings_){nullptr}
507     , decltype(_impl_.shmem_size_kb_){0u}
508     , decltype(_impl_.shmem_page_size_kb_){0u}
509     , decltype(_impl_.num_processes_){0u}
510     , decltype(_impl_.num_threads_){0u}
511     , decltype(_impl_.max_events_){0u}
512     , decltype(_impl_.nesting_){0u}
513     , decltype(_impl_.burst_period_ms_){0u}
514     , decltype(_impl_.burst_duration_ms_){0u}
515   };
516 }
517 
~StressTestConfig()518 StressTestConfig::~StressTestConfig() {
519   // @@protoc_insertion_point(destructor:perfetto.protos.StressTestConfig)
520   if (auto *arena = _internal_metadata_.DeleteReturnArena<std::string>()) {
521   (void)arena;
522     return;
523   }
524   SharedDtor();
525 }
526 
SharedDtor()527 inline void StressTestConfig::SharedDtor() {
528   GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
529   if (this != internal_default_instance()) delete _impl_.trace_config_;
530   if (this != internal_default_instance()) delete _impl_.steady_state_timings_;
531   if (this != internal_default_instance()) delete _impl_.burst_timings_;
532 }
533 
SetCachedSize(int size) const534 void StressTestConfig::SetCachedSize(int size) const {
535   _impl_._cached_size_.Set(size);
536 }
537 
Clear()538 void StressTestConfig::Clear() {
539 // @@protoc_insertion_point(message_clear_start:perfetto.protos.StressTestConfig)
540   ::uint32_t cached_has_bits = 0;
541   // Prevent compiler warnings about cached_has_bits being unused
542   (void) cached_has_bits;
543 
544   cached_has_bits = _impl_._has_bits_[0];
545   if (cached_has_bits & 0x00000007u) {
546     if (cached_has_bits & 0x00000001u) {
547       GOOGLE_DCHECK(_impl_.trace_config_ != nullptr);
548       _impl_.trace_config_->Clear();
549     }
550     if (cached_has_bits & 0x00000002u) {
551       GOOGLE_DCHECK(_impl_.steady_state_timings_ != nullptr);
552       _impl_.steady_state_timings_->Clear();
553     }
554     if (cached_has_bits & 0x00000004u) {
555       GOOGLE_DCHECK(_impl_.burst_timings_ != nullptr);
556       _impl_.burst_timings_->Clear();
557     }
558   }
559   if (cached_has_bits & 0x000000f8u) {
560     ::memset(&_impl_.shmem_size_kb_, 0, static_cast<size_t>(
561         reinterpret_cast<char*>(&_impl_.max_events_) -
562         reinterpret_cast<char*>(&_impl_.shmem_size_kb_)) + sizeof(_impl_.max_events_));
563   }
564   if (cached_has_bits & 0x00000700u) {
565     ::memset(&_impl_.nesting_, 0, static_cast<size_t>(
566         reinterpret_cast<char*>(&_impl_.burst_duration_ms_) -
567         reinterpret_cast<char*>(&_impl_.nesting_)) + sizeof(_impl_.burst_duration_ms_));
568   }
569   _impl_._has_bits_.Clear();
570   _internal_metadata_.Clear<std::string>();
571 }
572 
_InternalParse(const char * ptr,::_pbi::ParseContext * ctx)573 const char* StressTestConfig::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) {
574 #define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
575   _Internal::HasBits has_bits{};
576   while (!ctx->Done(&ptr)) {
577     ::uint32_t tag;
578     ptr = ::_pbi::ReadTag(ptr, &tag);
579     switch (tag >> 3) {
580       // optional .perfetto.protos.TraceConfig trace_config = 1;
581       case 1:
582         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 10)) {
583           ptr = ctx->ParseMessage(_internal_mutable_trace_config(), ptr);
584           CHK_(ptr);
585         } else {
586           goto handle_unusual;
587         }
588         continue;
589       // optional uint32 shmem_size_kb = 2;
590       case 2:
591         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 16)) {
592           _Internal::set_has_shmem_size_kb(&has_bits);
593           _impl_.shmem_size_kb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
594           CHK_(ptr);
595         } else {
596           goto handle_unusual;
597         }
598         continue;
599       // optional uint32 shmem_page_size_kb = 3;
600       case 3:
601         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 24)) {
602           _Internal::set_has_shmem_page_size_kb(&has_bits);
603           _impl_.shmem_page_size_kb_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
604           CHK_(ptr);
605         } else {
606           goto handle_unusual;
607         }
608         continue;
609       // optional uint32 num_processes = 4;
610       case 4:
611         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 32)) {
612           _Internal::set_has_num_processes(&has_bits);
613           _impl_.num_processes_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
614           CHK_(ptr);
615         } else {
616           goto handle_unusual;
617         }
618         continue;
619       // optional uint32 num_threads = 5;
620       case 5:
621         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 40)) {
622           _Internal::set_has_num_threads(&has_bits);
623           _impl_.num_threads_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
624           CHK_(ptr);
625         } else {
626           goto handle_unusual;
627         }
628         continue;
629       // optional uint32 max_events = 6;
630       case 6:
631         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 48)) {
632           _Internal::set_has_max_events(&has_bits);
633           _impl_.max_events_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
634           CHK_(ptr);
635         } else {
636           goto handle_unusual;
637         }
638         continue;
639       // optional uint32 nesting = 7;
640       case 7:
641         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 56)) {
642           _Internal::set_has_nesting(&has_bits);
643           _impl_.nesting_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
644           CHK_(ptr);
645         } else {
646           goto handle_unusual;
647         }
648         continue;
649       // optional .perfetto.protos.StressTestConfig.WriterTiming steady_state_timings = 8;
650       case 8:
651         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 66)) {
652           ptr = ctx->ParseMessage(_internal_mutable_steady_state_timings(), ptr);
653           CHK_(ptr);
654         } else {
655           goto handle_unusual;
656         }
657         continue;
658       // optional uint32 burst_period_ms = 9;
659       case 9:
660         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 72)) {
661           _Internal::set_has_burst_period_ms(&has_bits);
662           _impl_.burst_period_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
663           CHK_(ptr);
664         } else {
665           goto handle_unusual;
666         }
667         continue;
668       // optional uint32 burst_duration_ms = 10;
669       case 10:
670         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 80)) {
671           _Internal::set_has_burst_duration_ms(&has_bits);
672           _impl_.burst_duration_ms_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
673           CHK_(ptr);
674         } else {
675           goto handle_unusual;
676         }
677         continue;
678       // optional .perfetto.protos.StressTestConfig.WriterTiming burst_timings = 11;
679       case 11:
680         if (PROTOBUF_PREDICT_TRUE(static_cast<::uint8_t>(tag) == 90)) {
681           ptr = ctx->ParseMessage(_internal_mutable_burst_timings(), ptr);
682           CHK_(ptr);
683         } else {
684           goto handle_unusual;
685         }
686         continue;
687       default:
688         goto handle_unusual;
689     }  // switch
690   handle_unusual:
691     if ((tag == 0) || ((tag & 7) == 4)) {
692       CHK_(ptr);
693       ctx->SetLastTag(tag);
694       goto message_done;
695     }
696     ptr = UnknownFieldParse(
697         tag,
698         _internal_metadata_.mutable_unknown_fields<std::string>(),
699         ptr, ctx);
700     CHK_(ptr != nullptr);
701   }  // while
702 message_done:
703   _impl_._has_bits_.Or(has_bits);
704   return ptr;
705 failure:
706   ptr = nullptr;
707   goto message_done;
708 #undef CHK_
709 }
710 
_InternalSerialize(::uint8_t * target,::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream * stream) const711 ::uint8_t* StressTestConfig::_InternalSerialize(
712     ::uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
713   // @@protoc_insertion_point(serialize_to_array_start:perfetto.protos.StressTestConfig)
714   ::uint32_t cached_has_bits = 0;
715   (void) cached_has_bits;
716 
717   cached_has_bits = _impl_._has_bits_[0];
718   // optional .perfetto.protos.TraceConfig trace_config = 1;
719   if (cached_has_bits & 0x00000001u) {
720     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
721       InternalWriteMessage(1, _Internal::trace_config(this),
722         _Internal::trace_config(this).GetCachedSize(), target, stream);
723   }
724 
725   // optional uint32 shmem_size_kb = 2;
726   if (cached_has_bits & 0x00000008u) {
727     target = stream->EnsureSpace(target);
728     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(2, this->_internal_shmem_size_kb(), target);
729   }
730 
731   // optional uint32 shmem_page_size_kb = 3;
732   if (cached_has_bits & 0x00000010u) {
733     target = stream->EnsureSpace(target);
734     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(3, this->_internal_shmem_page_size_kb(), target);
735   }
736 
737   // optional uint32 num_processes = 4;
738   if (cached_has_bits & 0x00000020u) {
739     target = stream->EnsureSpace(target);
740     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(4, this->_internal_num_processes(), target);
741   }
742 
743   // optional uint32 num_threads = 5;
744   if (cached_has_bits & 0x00000040u) {
745     target = stream->EnsureSpace(target);
746     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(5, this->_internal_num_threads(), target);
747   }
748 
749   // optional uint32 max_events = 6;
750   if (cached_has_bits & 0x00000080u) {
751     target = stream->EnsureSpace(target);
752     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(6, this->_internal_max_events(), target);
753   }
754 
755   // optional uint32 nesting = 7;
756   if (cached_has_bits & 0x00000100u) {
757     target = stream->EnsureSpace(target);
758     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(7, this->_internal_nesting(), target);
759   }
760 
761   // optional .perfetto.protos.StressTestConfig.WriterTiming steady_state_timings = 8;
762   if (cached_has_bits & 0x00000002u) {
763     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
764       InternalWriteMessage(8, _Internal::steady_state_timings(this),
765         _Internal::steady_state_timings(this).GetCachedSize(), target, stream);
766   }
767 
768   // optional uint32 burst_period_ms = 9;
769   if (cached_has_bits & 0x00000200u) {
770     target = stream->EnsureSpace(target);
771     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(9, this->_internal_burst_period_ms(), target);
772   }
773 
774   // optional uint32 burst_duration_ms = 10;
775   if (cached_has_bits & 0x00000400u) {
776     target = stream->EnsureSpace(target);
777     target = ::_pbi::WireFormatLite::WriteUInt32ToArray(10, this->_internal_burst_duration_ms(), target);
778   }
779 
780   // optional .perfetto.protos.StressTestConfig.WriterTiming burst_timings = 11;
781   if (cached_has_bits & 0x00000004u) {
782     target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
783       InternalWriteMessage(11, _Internal::burst_timings(this),
784         _Internal::burst_timings(this).GetCachedSize(), target, stream);
785   }
786 
787   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
788     target = stream->WriteRaw(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).data(),
789         static_cast<int>(_internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size()), target);
790   }
791   // @@protoc_insertion_point(serialize_to_array_end:perfetto.protos.StressTestConfig)
792   return target;
793 }
794 
ByteSizeLong() const795 size_t StressTestConfig::ByteSizeLong() const {
796 // @@protoc_insertion_point(message_byte_size_start:perfetto.protos.StressTestConfig)
797   size_t total_size = 0;
798 
799   ::uint32_t cached_has_bits = 0;
800   // Prevent compiler warnings about cached_has_bits being unused
801   (void) cached_has_bits;
802 
803   cached_has_bits = _impl_._has_bits_[0];
804   if (cached_has_bits & 0x000000ffu) {
805     // optional .perfetto.protos.TraceConfig trace_config = 1;
806     if (cached_has_bits & 0x00000001u) {
807       total_size += 1 +
808         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
809           *_impl_.trace_config_);
810     }
811 
812     // optional .perfetto.protos.StressTestConfig.WriterTiming steady_state_timings = 8;
813     if (cached_has_bits & 0x00000002u) {
814       total_size += 1 +
815         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
816           *_impl_.steady_state_timings_);
817     }
818 
819     // optional .perfetto.protos.StressTestConfig.WriterTiming burst_timings = 11;
820     if (cached_has_bits & 0x00000004u) {
821       total_size += 1 +
822         ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
823           *_impl_.burst_timings_);
824     }
825 
826     // optional uint32 shmem_size_kb = 2;
827     if (cached_has_bits & 0x00000008u) {
828       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_shmem_size_kb());
829     }
830 
831     // optional uint32 shmem_page_size_kb = 3;
832     if (cached_has_bits & 0x00000010u) {
833       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_shmem_page_size_kb());
834     }
835 
836     // optional uint32 num_processes = 4;
837     if (cached_has_bits & 0x00000020u) {
838       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num_processes());
839     }
840 
841     // optional uint32 num_threads = 5;
842     if (cached_has_bits & 0x00000040u) {
843       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_num_threads());
844     }
845 
846     // optional uint32 max_events = 6;
847     if (cached_has_bits & 0x00000080u) {
848       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_max_events());
849     }
850 
851   }
852   if (cached_has_bits & 0x00000700u) {
853     // optional uint32 nesting = 7;
854     if (cached_has_bits & 0x00000100u) {
855       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_nesting());
856     }
857 
858     // optional uint32 burst_period_ms = 9;
859     if (cached_has_bits & 0x00000200u) {
860       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_burst_period_ms());
861     }
862 
863     // optional uint32 burst_duration_ms = 10;
864     if (cached_has_bits & 0x00000400u) {
865       total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne(this->_internal_burst_duration_ms());
866     }
867 
868   }
869   if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
870     total_size += _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString).size();
871   }
872   int cached_size = ::_pbi::ToCachedSize(total_size);
873   SetCachedSize(cached_size);
874   return total_size;
875 }
876 
CheckTypeAndMergeFrom(const::PROTOBUF_NAMESPACE_ID::MessageLite & from)877 void StressTestConfig::CheckTypeAndMergeFrom(
878     const ::PROTOBUF_NAMESPACE_ID::MessageLite& from) {
879   MergeFrom(*::_pbi::DownCast<const StressTestConfig*>(
880       &from));
881 }
882 
MergeFrom(const StressTestConfig & from)883 void StressTestConfig::MergeFrom(const StressTestConfig& from) {
884   StressTestConfig* const _this = this;
885   // @@protoc_insertion_point(class_specific_merge_from_start:perfetto.protos.StressTestConfig)
886   GOOGLE_DCHECK_NE(&from, _this);
887   ::uint32_t cached_has_bits = 0;
888   (void) cached_has_bits;
889 
890   cached_has_bits = from._impl_._has_bits_[0];
891   if (cached_has_bits & 0x000000ffu) {
892     if (cached_has_bits & 0x00000001u) {
893       _this->_internal_mutable_trace_config()->::perfetto::protos::TraceConfig::MergeFrom(
894           from._internal_trace_config());
895     }
896     if (cached_has_bits & 0x00000002u) {
897       _this->_internal_mutable_steady_state_timings()->::perfetto::protos::StressTestConfig_WriterTiming::MergeFrom(
898           from._internal_steady_state_timings());
899     }
900     if (cached_has_bits & 0x00000004u) {
901       _this->_internal_mutable_burst_timings()->::perfetto::protos::StressTestConfig_WriterTiming::MergeFrom(
902           from._internal_burst_timings());
903     }
904     if (cached_has_bits & 0x00000008u) {
905       _this->_impl_.shmem_size_kb_ = from._impl_.shmem_size_kb_;
906     }
907     if (cached_has_bits & 0x00000010u) {
908       _this->_impl_.shmem_page_size_kb_ = from._impl_.shmem_page_size_kb_;
909     }
910     if (cached_has_bits & 0x00000020u) {
911       _this->_impl_.num_processes_ = from._impl_.num_processes_;
912     }
913     if (cached_has_bits & 0x00000040u) {
914       _this->_impl_.num_threads_ = from._impl_.num_threads_;
915     }
916     if (cached_has_bits & 0x00000080u) {
917       _this->_impl_.max_events_ = from._impl_.max_events_;
918     }
919     _this->_impl_._has_bits_[0] |= cached_has_bits;
920   }
921   if (cached_has_bits & 0x00000700u) {
922     if (cached_has_bits & 0x00000100u) {
923       _this->_impl_.nesting_ = from._impl_.nesting_;
924     }
925     if (cached_has_bits & 0x00000200u) {
926       _this->_impl_.burst_period_ms_ = from._impl_.burst_period_ms_;
927     }
928     if (cached_has_bits & 0x00000400u) {
929       _this->_impl_.burst_duration_ms_ = from._impl_.burst_duration_ms_;
930     }
931     _this->_impl_._has_bits_[0] |= cached_has_bits;
932   }
933   _this->_internal_metadata_.MergeFrom<std::string>(from._internal_metadata_);
934 }
935 
CopyFrom(const StressTestConfig & from)936 void StressTestConfig::CopyFrom(const StressTestConfig& from) {
937 // @@protoc_insertion_point(class_specific_copy_from_start:perfetto.protos.StressTestConfig)
938   if (&from == this) return;
939   Clear();
940   MergeFrom(from);
941 }
942 
IsInitialized() const943 bool StressTestConfig::IsInitialized() const {
944   return true;
945 }
946 
InternalSwap(StressTestConfig * other)947 void StressTestConfig::InternalSwap(StressTestConfig* other) {
948   using std::swap;
949   _internal_metadata_.InternalSwap(&other->_internal_metadata_);
950   swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]);
951   ::PROTOBUF_NAMESPACE_ID::internal::memswap<
952       PROTOBUF_FIELD_OFFSET(StressTestConfig, _impl_.burst_duration_ms_)
953       + sizeof(StressTestConfig::_impl_.burst_duration_ms_)  // NOLINT
954       - PROTOBUF_FIELD_OFFSET(StressTestConfig, _impl_.trace_config_)>(
955           reinterpret_cast<char*>(&_impl_.trace_config_),
956           reinterpret_cast<char*>(&other->_impl_.trace_config_));
957 }
958 
GetTypeName() const959 std::string StressTestConfig::GetTypeName() const {
960   return "perfetto.protos.StressTestConfig";
961 }
962 
963 
964 // @@protoc_insertion_point(namespace_scope)
965 }  // namespace protos
966 }  // namespace perfetto
967 PROTOBUF_NAMESPACE_OPEN
968 template<> PROTOBUF_NOINLINE ::perfetto::protos::StressTestConfig_WriterTiming*
CreateMaybeMessage(Arena * arena)969 Arena::CreateMaybeMessage< ::perfetto::protos::StressTestConfig_WriterTiming >(Arena* arena) {
970   return Arena::CreateMessageInternal< ::perfetto::protos::StressTestConfig_WriterTiming >(arena);
971 }
972 template<> PROTOBUF_NOINLINE ::perfetto::protos::StressTestConfig*
CreateMaybeMessage(Arena * arena)973 Arena::CreateMaybeMessage< ::perfetto::protos::StressTestConfig >(Arena* arena) {
974   return Arena::CreateMessageInternal< ::perfetto::protos::StressTestConfig >(arena);
975 }
976 PROTOBUF_NAMESPACE_CLOSE
977 
978 // @@protoc_insertion_point(global_scope)
979 #include <google/protobuf/port_undef.inc>
980