1/* AUTOMATICALLY GENERATED FILE - DO NOT EDIT */
2
3#ifndef JFRFILES_JFREVENTCLASSES_HPP
4#define JFRFILES_JFREVENTCLASSES_HPP
5
6#include "oops/klass.hpp"
7#include "jfrfiles/jfrTypes.hpp"
8#include "jfr/utilities/jfrTypes.hpp"
9#include "utilities/macros.hpp"
10#include "utilities/ticks.hpp"
11#if INCLUDE_JFR
12#include "jfr/recorder/service/jfrEvent.hpp"
13/*
14 * Each event class has an assert member function verify() which is invoked
15 * just before the engine writes the event and its fields to the data stream.
16 * The purpose of verify() is to ensure that all fields in the event are initialized
17 * and set before attempting to commit.
18 *
19 * We enforce this requirement because events are generally stack allocated and therefore
20 * *not* initialized to default values. This prevents us from inadvertently committing
21 * uninitialized values to the data stream.
22 *
23 * The assert message contains both the index (zero based) as well as the name of the field.
24 */
25
26struct JfrStructVirtualSpace
27{
28 private:
29 u8 _start;
30 u8 _committedEnd;
31 u8 _committedSize;
32 u8 _reservedEnd;
33 u8 _reservedSize;
34
35 public:
36 void set_start(u8 new_value) { this->_start = new_value; }
37 void set_committedEnd(u8 new_value) { this->_committedEnd = new_value; }
38 void set_committedSize(u8 new_value) { this->_committedSize = new_value; }
39 void set_reservedEnd(u8 new_value) { this->_reservedEnd = new_value; }
40 void set_reservedSize(u8 new_value) { this->_reservedSize = new_value; }
41
42 template <typename Writer>
43 void writeData(Writer& w) {
44 w.write(_start);
45 w.write(_committedEnd);
46 w.write(_committedSize);
47 w.write(_reservedEnd);
48 w.write(_reservedSize);
49 }
50};
51
52
53struct JfrStructObjectSpace
54{
55 private:
56 u8 _start;
57 u8 _end;
58 u8 _used;
59 u8 _size;
60
61 public:
62 void set_start(u8 new_value) { this->_start = new_value; }
63 void set_end(u8 new_value) { this->_end = new_value; }
64 void set_used(u8 new_value) { this->_used = new_value; }
65 void set_size(u8 new_value) { this->_size = new_value; }
66
67 template <typename Writer>
68 void writeData(Writer& w) {
69 w.write(_start);
70 w.write(_end);
71 w.write(_used);
72 w.write(_size);
73 }
74};
75
76
77struct JfrStructMetaspaceSizes
78{
79 private:
80 u8 _committed;
81 u8 _used;
82 u8 _reserved;
83
84 public:
85 void set_committed(u8 new_value) { this->_committed = new_value; }
86 void set_used(u8 new_value) { this->_used = new_value; }
87 void set_reserved(u8 new_value) { this->_reserved = new_value; }
88
89 template <typename Writer>
90 void writeData(Writer& w) {
91 w.write(_committed);
92 w.write(_used);
93 w.write(_reserved);
94 }
95};
96
97
98struct JfrStructCopyFailed
99{
100 private:
101 u8 _objectCount;
102 u8 _firstSize;
103 u8 _smallestSize;
104 u8 _totalSize;
105
106 public:
107 void set_objectCount(u8 new_value) { this->_objectCount = new_value; }
108 void set_firstSize(u8 new_value) { this->_firstSize = new_value; }
109 void set_smallestSize(u8 new_value) { this->_smallestSize = new_value; }
110 void set_totalSize(u8 new_value) { this->_totalSize = new_value; }
111
112 template <typename Writer>
113 void writeData(Writer& w) {
114 w.write(_objectCount);
115 w.write(_firstSize);
116 w.write(_smallestSize);
117 w.write(_totalSize);
118 }
119};
120
121
122struct JfrStructG1EvacuationStatistics
123{
124 private:
125 unsigned _gcId;
126 u8 _allocated;
127 u8 _wasted;
128 u8 _used;
129 u8 _undoWaste;
130 u8 _regionEndWaste;
131 unsigned _regionsRefilled;
132 u8 _directAllocated;
133 u8 _failureUsed;
134 u8 _failureWaste;
135
136 public:
137 void set_gcId(unsigned new_value) { this->_gcId = new_value; }
138 void set_allocated(u8 new_value) { this->_allocated = new_value; }
139 void set_wasted(u8 new_value) { this->_wasted = new_value; }
140 void set_used(u8 new_value) { this->_used = new_value; }
141 void set_undoWaste(u8 new_value) { this->_undoWaste = new_value; }
142 void set_regionEndWaste(u8 new_value) { this->_regionEndWaste = new_value; }
143 void set_regionsRefilled(unsigned new_value) { this->_regionsRefilled = new_value; }
144 void set_directAllocated(u8 new_value) { this->_directAllocated = new_value; }
145 void set_failureUsed(u8 new_value) { this->_failureUsed = new_value; }
146 void set_failureWaste(u8 new_value) { this->_failureWaste = new_value; }
147
148 template <typename Writer>
149 void writeData(Writer& w) {
150 w.write(_gcId);
151 w.write(_allocated);
152 w.write(_wasted);
153 w.write(_used);
154 w.write(_undoWaste);
155 w.write(_regionEndWaste);
156 w.write(_regionsRefilled);
157 w.write(_directAllocated);
158 w.write(_failureUsed);
159 w.write(_failureWaste);
160 }
161};
162
163
164struct JfrStructCalleeMethod
165{
166 private:
167 const char* _type;
168 const char* _name;
169 const char* _descriptor;
170
171 public:
172 void set_type(const char* new_value) { this->_type = new_value; }
173 void set_name(const char* new_value) { this->_name = new_value; }
174 void set_descriptor(const char* new_value) { this->_descriptor = new_value; }
175
176 template <typename Writer>
177 void writeData(Writer& w) {
178 w.write(_type);
179 w.write(_name);
180 w.write(_descriptor);
181 }
182};
183
184
185struct JfrStructStackFrame
186{
187 private:
188 const Method* _method;
189 s4 _lineNumber;
190 s4 _bytecodeIndex;
191 u8 _type;
192
193 public:
194 void set_method(const Method* new_value) { this->_method = new_value; }
195 void set_lineNumber(s4 new_value) { this->_lineNumber = new_value; }
196 void set_bytecodeIndex(s4 new_value) { this->_bytecodeIndex = new_value; }
197 void set_type(u8 new_value) { this->_type = new_value; }
198
199 template <typename Writer>
200 void writeData(Writer& w) {
201 w.write(_method);
202 w.write(_lineNumber);
203 w.write(_bytecodeIndex);
204 w.write(_type);
205 }
206};
207
208
209class EventThreadStart : public JfrEvent<EventThreadStart>
210{
211 private:
212 u8 _thread;
213
214 public:
215 static const bool hasThread = true;
216 static const bool hasStackTrace = false;
217 static const bool isInstant = true;
218 static const bool hasCutoff = false;
219 static const bool isRequestable = false;
220 static const JfrEventId eventId = JfrThreadStartEvent;
221
222 EventThreadStart(EventStartTime timing=TIMED) : JfrEvent<EventThreadStart>(timing) {}
223
224 void set_thread(u8 new_value) {
225 this->_thread = new_value;
226 DEBUG_ONLY(set_field_bit(0));
227 }
228
229 template <typename Writer>
230 void writeData(Writer& w) {
231 w.write(_thread);
232 }
233
234 using JfrEvent<EventThreadStart>::commit; // else commit() is hidden by overloaded versions in this class
235
236
237
238 static void commit(u8 thread) {
239 EventThreadStart me(UNTIMED);
240
241 if (me.should_commit()) {
242 me.set_thread(thread);
243 me.commit();
244 }
245 }
246
247#ifdef ASSERT
248 void verify() const {
249 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_thread");
250 }
251#endif
252};
253
254class EventThreadEnd : public JfrEvent<EventThreadEnd>
255{
256 private:
257 u8 _thread;
258
259 public:
260 static const bool hasThread = true;
261 static const bool hasStackTrace = false;
262 static const bool isInstant = true;
263 static const bool hasCutoff = false;
264 static const bool isRequestable = false;
265 static const JfrEventId eventId = JfrThreadEndEvent;
266
267 EventThreadEnd(EventStartTime timing=TIMED) : JfrEvent<EventThreadEnd>(timing) {}
268
269 void set_thread(u8 new_value) {
270 this->_thread = new_value;
271 DEBUG_ONLY(set_field_bit(0));
272 }
273
274 template <typename Writer>
275 void writeData(Writer& w) {
276 w.write(_thread);
277 }
278
279 using JfrEvent<EventThreadEnd>::commit; // else commit() is hidden by overloaded versions in this class
280
281
282
283 static void commit(u8 thread) {
284 EventThreadEnd me(UNTIMED);
285
286 if (me.should_commit()) {
287 me.set_thread(thread);
288 me.commit();
289 }
290 }
291
292#ifdef ASSERT
293 void verify() const {
294 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_thread");
295 }
296#endif
297};
298
299class EventThreadSleep : public JfrEvent<EventThreadSleep>
300{
301 private:
302 s8 _time;
303
304 public:
305 static const bool hasThread = true;
306 static const bool hasStackTrace = true;
307 static const bool isInstant = false;
308 static const bool hasCutoff = false;
309 static const bool isRequestable = false;
310 static const JfrEventId eventId = JfrThreadSleepEvent;
311
312 EventThreadSleep(EventStartTime timing=TIMED) : JfrEvent<EventThreadSleep>(timing) {}
313
314 void set_time(s8 new_value) {
315 this->_time = new_value;
316 DEBUG_ONLY(set_field_bit(0));
317 }
318
319 template <typename Writer>
320 void writeData(Writer& w) {
321 w.write(_time);
322 }
323
324 using JfrEvent<EventThreadSleep>::commit; // else commit() is hidden by overloaded versions in this class
325
326 EventThreadSleep(
327 s8 time) : JfrEvent<EventThreadSleep>(TIMED) {
328 if (should_commit()) {
329 set_time(time);
330 }
331 }
332
333 void commit(s8 time) {
334 if (should_commit()) {
335 set_time(time);
336 commit();
337 }
338 }
339
340 static void commit(const Ticks& startTicks,
341 const Ticks& endTicks,
342 s8 time) {
343 EventThreadSleep me(UNTIMED);
344
345 if (me.should_commit()) {
346 me.set_starttime(startTicks);
347 me.set_endtime(endTicks);
348 me.set_time(time);
349 me.commit();
350 }
351 }
352
353#ifdef ASSERT
354 void verify() const {
355 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_time");
356 }
357#endif
358};
359
360class EventThreadPark : public JfrEvent<EventThreadPark>
361{
362 private:
363 const Klass* _parkedClass;
364 s8 _timeout;
365 s8 _until;
366 u8 _address;
367
368 public:
369 static const bool hasThread = true;
370 static const bool hasStackTrace = true;
371 static const bool isInstant = false;
372 static const bool hasCutoff = false;
373 static const bool isRequestable = false;
374 static const JfrEventId eventId = JfrThreadParkEvent;
375
376 EventThreadPark(EventStartTime timing=TIMED) : JfrEvent<EventThreadPark>(timing) {}
377
378 void set_parkedClass(const Klass* new_value) {
379 this->_parkedClass = new_value;
380 DEBUG_ONLY(set_field_bit(0));
381 }
382 void set_timeout(s8 new_value) {
383 this->_timeout = new_value;
384 DEBUG_ONLY(set_field_bit(1));
385 }
386 void set_until(s8 new_value) {
387 this->_until = new_value;
388 DEBUG_ONLY(set_field_bit(2));
389 }
390 void set_address(u8 new_value) {
391 this->_address = new_value;
392 DEBUG_ONLY(set_field_bit(3));
393 }
394
395 template <typename Writer>
396 void writeData(Writer& w) {
397 w.write(_parkedClass);
398 w.write(_timeout);
399 w.write(_until);
400 w.write(_address);
401 }
402
403 using JfrEvent<EventThreadPark>::commit; // else commit() is hidden by overloaded versions in this class
404
405 EventThreadPark(
406 const Klass* parkedClass,
407 s8 timeout,
408 s8 until,
409 u8 address) : JfrEvent<EventThreadPark>(TIMED) {
410 if (should_commit()) {
411 set_parkedClass(parkedClass);
412 set_timeout(timeout);
413 set_until(until);
414 set_address(address);
415 }
416 }
417
418 void commit(const Klass* parkedClass,
419 s8 timeout,
420 s8 until,
421 u8 address) {
422 if (should_commit()) {
423 set_parkedClass(parkedClass);
424 set_timeout(timeout);
425 set_until(until);
426 set_address(address);
427 commit();
428 }
429 }
430
431 static void commit(const Ticks& startTicks,
432 const Ticks& endTicks,
433 const Klass* parkedClass,
434 s8 timeout,
435 s8 until,
436 u8 address) {
437 EventThreadPark me(UNTIMED);
438
439 if (me.should_commit()) {
440 me.set_starttime(startTicks);
441 me.set_endtime(endTicks);
442 me.set_parkedClass(parkedClass);
443 me.set_timeout(timeout);
444 me.set_until(until);
445 me.set_address(address);
446 me.commit();
447 }
448 }
449
450#ifdef ASSERT
451 void verify() const {
452 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_parkedClass");
453 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_timeout");
454 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_until");
455 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_address");
456 }
457#endif
458};
459
460class EventJavaMonitorEnter : public JfrEvent<EventJavaMonitorEnter>
461{
462 private:
463 const Klass* _monitorClass;
464 u8 _previousOwner;
465 u8 _address;
466
467 public:
468 static const bool hasThread = true;
469 static const bool hasStackTrace = true;
470 static const bool isInstant = false;
471 static const bool hasCutoff = false;
472 static const bool isRequestable = false;
473 static const JfrEventId eventId = JfrJavaMonitorEnterEvent;
474
475 EventJavaMonitorEnter(EventStartTime timing=TIMED) : JfrEvent<EventJavaMonitorEnter>(timing) {}
476
477 void set_monitorClass(const Klass* new_value) {
478 this->_monitorClass = new_value;
479 DEBUG_ONLY(set_field_bit(0));
480 }
481 void set_previousOwner(u8 new_value) {
482 this->_previousOwner = new_value;
483 DEBUG_ONLY(set_field_bit(1));
484 }
485 void set_address(u8 new_value) {
486 this->_address = new_value;
487 DEBUG_ONLY(set_field_bit(2));
488 }
489
490 template <typename Writer>
491 void writeData(Writer& w) {
492 w.write(_monitorClass);
493 w.write(_previousOwner);
494 w.write(_address);
495 }
496
497 using JfrEvent<EventJavaMonitorEnter>::commit; // else commit() is hidden by overloaded versions in this class
498
499 EventJavaMonitorEnter(
500 const Klass* monitorClass,
501 u8 previousOwner,
502 u8 address) : JfrEvent<EventJavaMonitorEnter>(TIMED) {
503 if (should_commit()) {
504 set_monitorClass(monitorClass);
505 set_previousOwner(previousOwner);
506 set_address(address);
507 }
508 }
509
510 void commit(const Klass* monitorClass,
511 u8 previousOwner,
512 u8 address) {
513 if (should_commit()) {
514 set_monitorClass(monitorClass);
515 set_previousOwner(previousOwner);
516 set_address(address);
517 commit();
518 }
519 }
520
521 static void commit(const Ticks& startTicks,
522 const Ticks& endTicks,
523 const Klass* monitorClass,
524 u8 previousOwner,
525 u8 address) {
526 EventJavaMonitorEnter me(UNTIMED);
527
528 if (me.should_commit()) {
529 me.set_starttime(startTicks);
530 me.set_endtime(endTicks);
531 me.set_monitorClass(monitorClass);
532 me.set_previousOwner(previousOwner);
533 me.set_address(address);
534 me.commit();
535 }
536 }
537
538#ifdef ASSERT
539 void verify() const {
540 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_monitorClass");
541 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_previousOwner");
542 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_address");
543 }
544#endif
545};
546
547class EventJavaMonitorWait : public JfrEvent<EventJavaMonitorWait>
548{
549 private:
550 const Klass* _monitorClass;
551 u8 _notifier;
552 s8 _timeout;
553 bool _timedOut;
554 u8 _address;
555
556 public:
557 static const bool hasThread = true;
558 static const bool hasStackTrace = true;
559 static const bool isInstant = false;
560 static const bool hasCutoff = false;
561 static const bool isRequestable = false;
562 static const JfrEventId eventId = JfrJavaMonitorWaitEvent;
563
564 EventJavaMonitorWait(EventStartTime timing=TIMED) : JfrEvent<EventJavaMonitorWait>(timing) {}
565
566 void set_monitorClass(const Klass* new_value) {
567 this->_monitorClass = new_value;
568 DEBUG_ONLY(set_field_bit(0));
569 }
570 void set_notifier(u8 new_value) {
571 this->_notifier = new_value;
572 DEBUG_ONLY(set_field_bit(1));
573 }
574 void set_timeout(s8 new_value) {
575 this->_timeout = new_value;
576 DEBUG_ONLY(set_field_bit(2));
577 }
578 void set_timedOut(bool new_value) {
579 this->_timedOut = new_value;
580 DEBUG_ONLY(set_field_bit(3));
581 }
582 void set_address(u8 new_value) {
583 this->_address = new_value;
584 DEBUG_ONLY(set_field_bit(4));
585 }
586
587 template <typename Writer>
588 void writeData(Writer& w) {
589 w.write(_monitorClass);
590 w.write(_notifier);
591 w.write(_timeout);
592 w.write(_timedOut);
593 w.write(_address);
594 }
595
596 using JfrEvent<EventJavaMonitorWait>::commit; // else commit() is hidden by overloaded versions in this class
597
598 EventJavaMonitorWait(
599 const Klass* monitorClass,
600 u8 notifier,
601 s8 timeout,
602 bool timedOut,
603 u8 address) : JfrEvent<EventJavaMonitorWait>(TIMED) {
604 if (should_commit()) {
605 set_monitorClass(monitorClass);
606 set_notifier(notifier);
607 set_timeout(timeout);
608 set_timedOut(timedOut);
609 set_address(address);
610 }
611 }
612
613 void commit(const Klass* monitorClass,
614 u8 notifier,
615 s8 timeout,
616 bool timedOut,
617 u8 address) {
618 if (should_commit()) {
619 set_monitorClass(monitorClass);
620 set_notifier(notifier);
621 set_timeout(timeout);
622 set_timedOut(timedOut);
623 set_address(address);
624 commit();
625 }
626 }
627
628 static void commit(const Ticks& startTicks,
629 const Ticks& endTicks,
630 const Klass* monitorClass,
631 u8 notifier,
632 s8 timeout,
633 bool timedOut,
634 u8 address) {
635 EventJavaMonitorWait me(UNTIMED);
636
637 if (me.should_commit()) {
638 me.set_starttime(startTicks);
639 me.set_endtime(endTicks);
640 me.set_monitorClass(monitorClass);
641 me.set_notifier(notifier);
642 me.set_timeout(timeout);
643 me.set_timedOut(timedOut);
644 me.set_address(address);
645 me.commit();
646 }
647 }
648
649#ifdef ASSERT
650 void verify() const {
651 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_monitorClass");
652 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_notifier");
653 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_timeout");
654 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_timedOut");
655 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_address");
656 }
657#endif
658};
659
660class EventJavaMonitorInflate : public JfrEvent<EventJavaMonitorInflate>
661{
662 private:
663 const Klass* _monitorClass;
664 u8 _address;
665 u8 _cause;
666
667 public:
668 static const bool hasThread = true;
669 static const bool hasStackTrace = true;
670 static const bool isInstant = false;
671 static const bool hasCutoff = false;
672 static const bool isRequestable = false;
673 static const JfrEventId eventId = JfrJavaMonitorInflateEvent;
674
675 EventJavaMonitorInflate(EventStartTime timing=TIMED) : JfrEvent<EventJavaMonitorInflate>(timing) {}
676
677 void set_monitorClass(const Klass* new_value) {
678 this->_monitorClass = new_value;
679 DEBUG_ONLY(set_field_bit(0));
680 }
681 void set_address(u8 new_value) {
682 this->_address = new_value;
683 DEBUG_ONLY(set_field_bit(1));
684 }
685 void set_cause(u8 new_value) {
686 this->_cause = new_value;
687 DEBUG_ONLY(set_field_bit(2));
688 }
689
690 template <typename Writer>
691 void writeData(Writer& w) {
692 w.write(_monitorClass);
693 w.write(_address);
694 w.write(_cause);
695 }
696
697 using JfrEvent<EventJavaMonitorInflate>::commit; // else commit() is hidden by overloaded versions in this class
698
699 EventJavaMonitorInflate(
700 const Klass* monitorClass,
701 u8 address,
702 u8 cause) : JfrEvent<EventJavaMonitorInflate>(TIMED) {
703 if (should_commit()) {
704 set_monitorClass(monitorClass);
705 set_address(address);
706 set_cause(cause);
707 }
708 }
709
710 void commit(const Klass* monitorClass,
711 u8 address,
712 u8 cause) {
713 if (should_commit()) {
714 set_monitorClass(monitorClass);
715 set_address(address);
716 set_cause(cause);
717 commit();
718 }
719 }
720
721 static void commit(const Ticks& startTicks,
722 const Ticks& endTicks,
723 const Klass* monitorClass,
724 u8 address,
725 u8 cause) {
726 EventJavaMonitorInflate me(UNTIMED);
727
728 if (me.should_commit()) {
729 me.set_starttime(startTicks);
730 me.set_endtime(endTicks);
731 me.set_monitorClass(monitorClass);
732 me.set_address(address);
733 me.set_cause(cause);
734 me.commit();
735 }
736 }
737
738#ifdef ASSERT
739 void verify() const {
740 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_monitorClass");
741 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_address");
742 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_cause");
743 }
744#endif
745};
746
747class EventBiasedLockRevocation : public JfrEvent<EventBiasedLockRevocation>
748{
749 private:
750 const Klass* _lockClass;
751 u8 _safepointId;
752 u8 _previousOwner;
753
754 public:
755 static const bool hasThread = true;
756 static const bool hasStackTrace = true;
757 static const bool isInstant = false;
758 static const bool hasCutoff = false;
759 static const bool isRequestable = false;
760 static const JfrEventId eventId = JfrBiasedLockRevocationEvent;
761
762 EventBiasedLockRevocation(EventStartTime timing=TIMED) : JfrEvent<EventBiasedLockRevocation>(timing) {}
763
764 void set_lockClass(const Klass* new_value) {
765 this->_lockClass = new_value;
766 DEBUG_ONLY(set_field_bit(0));
767 }
768 void set_safepointId(u8 new_value) {
769 this->_safepointId = new_value;
770 DEBUG_ONLY(set_field_bit(1));
771 }
772 void set_previousOwner(u8 new_value) {
773 this->_previousOwner = new_value;
774 DEBUG_ONLY(set_field_bit(2));
775 }
776
777 template <typename Writer>
778 void writeData(Writer& w) {
779 w.write(_lockClass);
780 w.write(_safepointId);
781 w.write(_previousOwner);
782 }
783
784 using JfrEvent<EventBiasedLockRevocation>::commit; // else commit() is hidden by overloaded versions in this class
785
786 EventBiasedLockRevocation(
787 const Klass* lockClass,
788 u8 safepointId,
789 u8 previousOwner) : JfrEvent<EventBiasedLockRevocation>(TIMED) {
790 if (should_commit()) {
791 set_lockClass(lockClass);
792 set_safepointId(safepointId);
793 set_previousOwner(previousOwner);
794 }
795 }
796
797 void commit(const Klass* lockClass,
798 u8 safepointId,
799 u8 previousOwner) {
800 if (should_commit()) {
801 set_lockClass(lockClass);
802 set_safepointId(safepointId);
803 set_previousOwner(previousOwner);
804 commit();
805 }
806 }
807
808 static void commit(const Ticks& startTicks,
809 const Ticks& endTicks,
810 const Klass* lockClass,
811 u8 safepointId,
812 u8 previousOwner) {
813 EventBiasedLockRevocation me(UNTIMED);
814
815 if (me.should_commit()) {
816 me.set_starttime(startTicks);
817 me.set_endtime(endTicks);
818 me.set_lockClass(lockClass);
819 me.set_safepointId(safepointId);
820 me.set_previousOwner(previousOwner);
821 me.commit();
822 }
823 }
824
825#ifdef ASSERT
826 void verify() const {
827 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_lockClass");
828 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_safepointId");
829 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_previousOwner");
830 }
831#endif
832};
833
834class EventBiasedLockSelfRevocation : public JfrEvent<EventBiasedLockSelfRevocation>
835{
836 private:
837 const Klass* _lockClass;
838
839 public:
840 static const bool hasThread = true;
841 static const bool hasStackTrace = true;
842 static const bool isInstant = false;
843 static const bool hasCutoff = false;
844 static const bool isRequestable = false;
845 static const JfrEventId eventId = JfrBiasedLockSelfRevocationEvent;
846
847 EventBiasedLockSelfRevocation(EventStartTime timing=TIMED) : JfrEvent<EventBiasedLockSelfRevocation>(timing) {}
848
849 void set_lockClass(const Klass* new_value) {
850 this->_lockClass = new_value;
851 DEBUG_ONLY(set_field_bit(0));
852 }
853
854 template <typename Writer>
855 void writeData(Writer& w) {
856 w.write(_lockClass);
857 }
858
859 using JfrEvent<EventBiasedLockSelfRevocation>::commit; // else commit() is hidden by overloaded versions in this class
860
861 EventBiasedLockSelfRevocation(
862 const Klass* lockClass) : JfrEvent<EventBiasedLockSelfRevocation>(TIMED) {
863 if (should_commit()) {
864 set_lockClass(lockClass);
865 }
866 }
867
868 void commit(const Klass* lockClass) {
869 if (should_commit()) {
870 set_lockClass(lockClass);
871 commit();
872 }
873 }
874
875 static void commit(const Ticks& startTicks,
876 const Ticks& endTicks,
877 const Klass* lockClass) {
878 EventBiasedLockSelfRevocation me(UNTIMED);
879
880 if (me.should_commit()) {
881 me.set_starttime(startTicks);
882 me.set_endtime(endTicks);
883 me.set_lockClass(lockClass);
884 me.commit();
885 }
886 }
887
888#ifdef ASSERT
889 void verify() const {
890 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_lockClass");
891 }
892#endif
893};
894
895class EventBiasedLockClassRevocation : public JfrEvent<EventBiasedLockClassRevocation>
896{
897 private:
898 const Klass* _revokedClass;
899 bool _disableBiasing;
900 u8 _safepointId;
901
902 public:
903 static const bool hasThread = true;
904 static const bool hasStackTrace = true;
905 static const bool isInstant = false;
906 static const bool hasCutoff = false;
907 static const bool isRequestable = false;
908 static const JfrEventId eventId = JfrBiasedLockClassRevocationEvent;
909
910 EventBiasedLockClassRevocation(EventStartTime timing=TIMED) : JfrEvent<EventBiasedLockClassRevocation>(timing) {}
911
912 void set_revokedClass(const Klass* new_value) {
913 this->_revokedClass = new_value;
914 DEBUG_ONLY(set_field_bit(0));
915 }
916 void set_disableBiasing(bool new_value) {
917 this->_disableBiasing = new_value;
918 DEBUG_ONLY(set_field_bit(1));
919 }
920 void set_safepointId(u8 new_value) {
921 this->_safepointId = new_value;
922 DEBUG_ONLY(set_field_bit(2));
923 }
924
925 template <typename Writer>
926 void writeData(Writer& w) {
927 w.write(_revokedClass);
928 w.write(_disableBiasing);
929 w.write(_safepointId);
930 }
931
932 using JfrEvent<EventBiasedLockClassRevocation>::commit; // else commit() is hidden by overloaded versions in this class
933
934 EventBiasedLockClassRevocation(
935 const Klass* revokedClass,
936 bool disableBiasing,
937 u8 safepointId) : JfrEvent<EventBiasedLockClassRevocation>(TIMED) {
938 if (should_commit()) {
939 set_revokedClass(revokedClass);
940 set_disableBiasing(disableBiasing);
941 set_safepointId(safepointId);
942 }
943 }
944
945 void commit(const Klass* revokedClass,
946 bool disableBiasing,
947 u8 safepointId) {
948 if (should_commit()) {
949 set_revokedClass(revokedClass);
950 set_disableBiasing(disableBiasing);
951 set_safepointId(safepointId);
952 commit();
953 }
954 }
955
956 static void commit(const Ticks& startTicks,
957 const Ticks& endTicks,
958 const Klass* revokedClass,
959 bool disableBiasing,
960 u8 safepointId) {
961 EventBiasedLockClassRevocation me(UNTIMED);
962
963 if (me.should_commit()) {
964 me.set_starttime(startTicks);
965 me.set_endtime(endTicks);
966 me.set_revokedClass(revokedClass);
967 me.set_disableBiasing(disableBiasing);
968 me.set_safepointId(safepointId);
969 me.commit();
970 }
971 }
972
973#ifdef ASSERT
974 void verify() const {
975 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_revokedClass");
976 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_disableBiasing");
977 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_safepointId");
978 }
979#endif
980};
981
982class EventReservedStackActivation : public JfrEvent<EventReservedStackActivation>
983{
984 private:
985 const Method* _method;
986
987 public:
988 static const bool hasThread = true;
989 static const bool hasStackTrace = true;
990 static const bool isInstant = true;
991 static const bool hasCutoff = false;
992 static const bool isRequestable = false;
993 static const JfrEventId eventId = JfrReservedStackActivationEvent;
994
995 EventReservedStackActivation(EventStartTime timing=TIMED) : JfrEvent<EventReservedStackActivation>(timing) {}
996
997 void set_method(const Method* new_value) {
998 this->_method = new_value;
999 DEBUG_ONLY(set_field_bit(0));
1000 }
1001
1002 template <typename Writer>
1003 void writeData(Writer& w) {
1004 w.write(_method);
1005 }
1006
1007 using JfrEvent<EventReservedStackActivation>::commit; // else commit() is hidden by overloaded versions in this class
1008
1009
1010
1011 static void commit(const Method* method) {
1012 EventReservedStackActivation me(UNTIMED);
1013
1014 if (me.should_commit()) {
1015 me.set_method(method);
1016 me.commit();
1017 }
1018 }
1019
1020#ifdef ASSERT
1021 void verify() const {
1022 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_method");
1023 }
1024#endif
1025};
1026
1027class EventClassLoad : public JfrEvent<EventClassLoad>
1028{
1029 private:
1030 const Klass* _loadedClass;
1031 const ClassLoaderData* _definingClassLoader;
1032 const ClassLoaderData* _initiatingClassLoader;
1033
1034 public:
1035 static const bool hasThread = true;
1036 static const bool hasStackTrace = true;
1037 static const bool isInstant = false;
1038 static const bool hasCutoff = false;
1039 static const bool isRequestable = false;
1040 static const JfrEventId eventId = JfrClassLoadEvent;
1041
1042 EventClassLoad(EventStartTime timing=TIMED) : JfrEvent<EventClassLoad>(timing) {}
1043
1044 void set_loadedClass(const Klass* new_value) {
1045 this->_loadedClass = new_value;
1046 DEBUG_ONLY(set_field_bit(0));
1047 }
1048 void set_definingClassLoader(const ClassLoaderData* new_value) {
1049 this->_definingClassLoader = new_value;
1050 DEBUG_ONLY(set_field_bit(1));
1051 }
1052 void set_initiatingClassLoader(const ClassLoaderData* new_value) {
1053 this->_initiatingClassLoader = new_value;
1054 DEBUG_ONLY(set_field_bit(2));
1055 }
1056
1057 template <typename Writer>
1058 void writeData(Writer& w) {
1059 w.write(_loadedClass);
1060 w.write(_definingClassLoader);
1061 w.write(_initiatingClassLoader);
1062 }
1063
1064 using JfrEvent<EventClassLoad>::commit; // else commit() is hidden by overloaded versions in this class
1065
1066 EventClassLoad(
1067 const Klass* loadedClass,
1068 const ClassLoaderData* definingClassLoader,
1069 const ClassLoaderData* initiatingClassLoader) : JfrEvent<EventClassLoad>(TIMED) {
1070 if (should_commit()) {
1071 set_loadedClass(loadedClass);
1072 set_definingClassLoader(definingClassLoader);
1073 set_initiatingClassLoader(initiatingClassLoader);
1074 }
1075 }
1076
1077 void commit(const Klass* loadedClass,
1078 const ClassLoaderData* definingClassLoader,
1079 const ClassLoaderData* initiatingClassLoader) {
1080 if (should_commit()) {
1081 set_loadedClass(loadedClass);
1082 set_definingClassLoader(definingClassLoader);
1083 set_initiatingClassLoader(initiatingClassLoader);
1084 commit();
1085 }
1086 }
1087
1088 static void commit(const Ticks& startTicks,
1089 const Ticks& endTicks,
1090 const Klass* loadedClass,
1091 const ClassLoaderData* definingClassLoader,
1092 const ClassLoaderData* initiatingClassLoader) {
1093 EventClassLoad me(UNTIMED);
1094
1095 if (me.should_commit()) {
1096 me.set_starttime(startTicks);
1097 me.set_endtime(endTicks);
1098 me.set_loadedClass(loadedClass);
1099 me.set_definingClassLoader(definingClassLoader);
1100 me.set_initiatingClassLoader(initiatingClassLoader);
1101 me.commit();
1102 }
1103 }
1104
1105#ifdef ASSERT
1106 void verify() const {
1107 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_loadedClass");
1108 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_definingClassLoader");
1109 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_initiatingClassLoader");
1110 }
1111#endif
1112};
1113
1114class EventClassDefine : public JfrEvent<EventClassDefine>
1115{
1116 private:
1117 const Klass* _definedClass;
1118 const ClassLoaderData* _definingClassLoader;
1119
1120 public:
1121 static const bool hasThread = true;
1122 static const bool hasStackTrace = true;
1123 static const bool isInstant = true;
1124 static const bool hasCutoff = false;
1125 static const bool isRequestable = false;
1126 static const JfrEventId eventId = JfrClassDefineEvent;
1127
1128 EventClassDefine(EventStartTime timing=TIMED) : JfrEvent<EventClassDefine>(timing) {}
1129
1130 void set_definedClass(const Klass* new_value) {
1131 this->_definedClass = new_value;
1132 DEBUG_ONLY(set_field_bit(0));
1133 }
1134 void set_definingClassLoader(const ClassLoaderData* new_value) {
1135 this->_definingClassLoader = new_value;
1136 DEBUG_ONLY(set_field_bit(1));
1137 }
1138
1139 template <typename Writer>
1140 void writeData(Writer& w) {
1141 w.write(_definedClass);
1142 w.write(_definingClassLoader);
1143 }
1144
1145 using JfrEvent<EventClassDefine>::commit; // else commit() is hidden by overloaded versions in this class
1146
1147
1148
1149 static void commit(const Klass* definedClass,
1150 const ClassLoaderData* definingClassLoader) {
1151 EventClassDefine me(UNTIMED);
1152
1153 if (me.should_commit()) {
1154 me.set_definedClass(definedClass);
1155 me.set_definingClassLoader(definingClassLoader);
1156 me.commit();
1157 }
1158 }
1159
1160#ifdef ASSERT
1161 void verify() const {
1162 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_definedClass");
1163 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_definingClassLoader");
1164 }
1165#endif
1166};
1167
1168class EventClassUnload : public JfrEvent<EventClassUnload>
1169{
1170 private:
1171 const Klass* _unloadedClass;
1172 const ClassLoaderData* _definingClassLoader;
1173
1174 public:
1175 static const bool hasThread = true;
1176 static const bool hasStackTrace = false;
1177 static const bool isInstant = true;
1178 static const bool hasCutoff = false;
1179 static const bool isRequestable = false;
1180 static const JfrEventId eventId = JfrClassUnloadEvent;
1181
1182 EventClassUnload(EventStartTime timing=TIMED) : JfrEvent<EventClassUnload>(timing) {}
1183
1184 void set_unloadedClass(const Klass* new_value) {
1185 this->_unloadedClass = new_value;
1186 DEBUG_ONLY(set_field_bit(0));
1187 }
1188 void set_definingClassLoader(const ClassLoaderData* new_value) {
1189 this->_definingClassLoader = new_value;
1190 DEBUG_ONLY(set_field_bit(1));
1191 }
1192
1193 template <typename Writer>
1194 void writeData(Writer& w) {
1195 w.write(_unloadedClass);
1196 w.write(_definingClassLoader);
1197 }
1198
1199 using JfrEvent<EventClassUnload>::commit; // else commit() is hidden by overloaded versions in this class
1200
1201
1202
1203 static void commit(const Klass* unloadedClass,
1204 const ClassLoaderData* definingClassLoader) {
1205 EventClassUnload me(UNTIMED);
1206
1207 if (me.should_commit()) {
1208 me.set_unloadedClass(unloadedClass);
1209 me.set_definingClassLoader(definingClassLoader);
1210 me.commit();
1211 }
1212 }
1213
1214#ifdef ASSERT
1215 void verify() const {
1216 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_unloadedClass");
1217 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_definingClassLoader");
1218 }
1219#endif
1220};
1221
1222class EventIntFlagChanged : public JfrEvent<EventIntFlagChanged>
1223{
1224 private:
1225 const char* _name;
1226 s4 _oldValue;
1227 s4 _newValue;
1228 u8 _origin;
1229
1230 public:
1231 static const bool hasThread = false;
1232 static const bool hasStackTrace = false;
1233 static const bool isInstant = true;
1234 static const bool hasCutoff = false;
1235 static const bool isRequestable = false;
1236 static const JfrEventId eventId = JfrIntFlagChangedEvent;
1237
1238 EventIntFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventIntFlagChanged>(timing) {}
1239
1240 void set_name(const char* new_value) {
1241 this->_name = new_value;
1242 DEBUG_ONLY(set_field_bit(0));
1243 }
1244 void set_oldValue(s4 new_value) {
1245 this->_oldValue = new_value;
1246 DEBUG_ONLY(set_field_bit(1));
1247 }
1248 void set_newValue(s4 new_value) {
1249 this->_newValue = new_value;
1250 DEBUG_ONLY(set_field_bit(2));
1251 }
1252 void set_origin(u8 new_value) {
1253 this->_origin = new_value;
1254 DEBUG_ONLY(set_field_bit(3));
1255 }
1256
1257 template <typename Writer>
1258 void writeData(Writer& w) {
1259 w.write(_name);
1260 w.write(_oldValue);
1261 w.write(_newValue);
1262 w.write(_origin);
1263 }
1264
1265 using JfrEvent<EventIntFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1266
1267
1268
1269 static void commit(const char* name,
1270 s4 oldValue,
1271 s4 newValue,
1272 u8 origin) {
1273 EventIntFlagChanged me(UNTIMED);
1274
1275 if (me.should_commit()) {
1276 me.set_name(name);
1277 me.set_oldValue(oldValue);
1278 me.set_newValue(newValue);
1279 me.set_origin(origin);
1280 me.commit();
1281 }
1282 }
1283
1284#ifdef ASSERT
1285 void verify() const {
1286 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1287 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1288 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1289 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1290 }
1291#endif
1292};
1293
1294class EventUnsignedIntFlagChanged : public JfrEvent<EventUnsignedIntFlagChanged>
1295{
1296 private:
1297 const char* _name;
1298 unsigned _oldValue;
1299 unsigned _newValue;
1300 u8 _origin;
1301
1302 public:
1303 static const bool hasThread = false;
1304 static const bool hasStackTrace = false;
1305 static const bool isInstant = true;
1306 static const bool hasCutoff = false;
1307 static const bool isRequestable = false;
1308 static const JfrEventId eventId = JfrUnsignedIntFlagChangedEvent;
1309
1310 EventUnsignedIntFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventUnsignedIntFlagChanged>(timing) {}
1311
1312 void set_name(const char* new_value) {
1313 this->_name = new_value;
1314 DEBUG_ONLY(set_field_bit(0));
1315 }
1316 void set_oldValue(unsigned new_value) {
1317 this->_oldValue = new_value;
1318 DEBUG_ONLY(set_field_bit(1));
1319 }
1320 void set_newValue(unsigned new_value) {
1321 this->_newValue = new_value;
1322 DEBUG_ONLY(set_field_bit(2));
1323 }
1324 void set_origin(u8 new_value) {
1325 this->_origin = new_value;
1326 DEBUG_ONLY(set_field_bit(3));
1327 }
1328
1329 template <typename Writer>
1330 void writeData(Writer& w) {
1331 w.write(_name);
1332 w.write(_oldValue);
1333 w.write(_newValue);
1334 w.write(_origin);
1335 }
1336
1337 using JfrEvent<EventUnsignedIntFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1338
1339
1340
1341 static void commit(const char* name,
1342 unsigned oldValue,
1343 unsigned newValue,
1344 u8 origin) {
1345 EventUnsignedIntFlagChanged me(UNTIMED);
1346
1347 if (me.should_commit()) {
1348 me.set_name(name);
1349 me.set_oldValue(oldValue);
1350 me.set_newValue(newValue);
1351 me.set_origin(origin);
1352 me.commit();
1353 }
1354 }
1355
1356#ifdef ASSERT
1357 void verify() const {
1358 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1359 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1360 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1361 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1362 }
1363#endif
1364};
1365
1366class EventLongFlagChanged : public JfrEvent<EventLongFlagChanged>
1367{
1368 private:
1369 const char* _name;
1370 s8 _oldValue;
1371 s8 _newValue;
1372 u8 _origin;
1373
1374 public:
1375 static const bool hasThread = false;
1376 static const bool hasStackTrace = false;
1377 static const bool isInstant = true;
1378 static const bool hasCutoff = false;
1379 static const bool isRequestable = false;
1380 static const JfrEventId eventId = JfrLongFlagChangedEvent;
1381
1382 EventLongFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventLongFlagChanged>(timing) {}
1383
1384 void set_name(const char* new_value) {
1385 this->_name = new_value;
1386 DEBUG_ONLY(set_field_bit(0));
1387 }
1388 void set_oldValue(s8 new_value) {
1389 this->_oldValue = new_value;
1390 DEBUG_ONLY(set_field_bit(1));
1391 }
1392 void set_newValue(s8 new_value) {
1393 this->_newValue = new_value;
1394 DEBUG_ONLY(set_field_bit(2));
1395 }
1396 void set_origin(u8 new_value) {
1397 this->_origin = new_value;
1398 DEBUG_ONLY(set_field_bit(3));
1399 }
1400
1401 template <typename Writer>
1402 void writeData(Writer& w) {
1403 w.write(_name);
1404 w.write(_oldValue);
1405 w.write(_newValue);
1406 w.write(_origin);
1407 }
1408
1409 using JfrEvent<EventLongFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1410
1411
1412
1413 static void commit(const char* name,
1414 s8 oldValue,
1415 s8 newValue,
1416 u8 origin) {
1417 EventLongFlagChanged me(UNTIMED);
1418
1419 if (me.should_commit()) {
1420 me.set_name(name);
1421 me.set_oldValue(oldValue);
1422 me.set_newValue(newValue);
1423 me.set_origin(origin);
1424 me.commit();
1425 }
1426 }
1427
1428#ifdef ASSERT
1429 void verify() const {
1430 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1431 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1432 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1433 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1434 }
1435#endif
1436};
1437
1438class EventUnsignedLongFlagChanged : public JfrEvent<EventUnsignedLongFlagChanged>
1439{
1440 private:
1441 const char* _name;
1442 u8 _oldValue;
1443 u8 _newValue;
1444 u8 _origin;
1445
1446 public:
1447 static const bool hasThread = false;
1448 static const bool hasStackTrace = false;
1449 static const bool isInstant = true;
1450 static const bool hasCutoff = false;
1451 static const bool isRequestable = false;
1452 static const JfrEventId eventId = JfrUnsignedLongFlagChangedEvent;
1453
1454 EventUnsignedLongFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventUnsignedLongFlagChanged>(timing) {}
1455
1456 void set_name(const char* new_value) {
1457 this->_name = new_value;
1458 DEBUG_ONLY(set_field_bit(0));
1459 }
1460 void set_oldValue(u8 new_value) {
1461 this->_oldValue = new_value;
1462 DEBUG_ONLY(set_field_bit(1));
1463 }
1464 void set_newValue(u8 new_value) {
1465 this->_newValue = new_value;
1466 DEBUG_ONLY(set_field_bit(2));
1467 }
1468 void set_origin(u8 new_value) {
1469 this->_origin = new_value;
1470 DEBUG_ONLY(set_field_bit(3));
1471 }
1472
1473 template <typename Writer>
1474 void writeData(Writer& w) {
1475 w.write(_name);
1476 w.write(_oldValue);
1477 w.write(_newValue);
1478 w.write(_origin);
1479 }
1480
1481 using JfrEvent<EventUnsignedLongFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1482
1483
1484
1485 static void commit(const char* name,
1486 u8 oldValue,
1487 u8 newValue,
1488 u8 origin) {
1489 EventUnsignedLongFlagChanged me(UNTIMED);
1490
1491 if (me.should_commit()) {
1492 me.set_name(name);
1493 me.set_oldValue(oldValue);
1494 me.set_newValue(newValue);
1495 me.set_origin(origin);
1496 me.commit();
1497 }
1498 }
1499
1500#ifdef ASSERT
1501 void verify() const {
1502 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1503 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1504 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1505 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1506 }
1507#endif
1508};
1509
1510class EventDoubleFlagChanged : public JfrEvent<EventDoubleFlagChanged>
1511{
1512 private:
1513 const char* _name;
1514 double _oldValue;
1515 double _newValue;
1516 u8 _origin;
1517
1518 public:
1519 static const bool hasThread = false;
1520 static const bool hasStackTrace = false;
1521 static const bool isInstant = true;
1522 static const bool hasCutoff = false;
1523 static const bool isRequestable = false;
1524 static const JfrEventId eventId = JfrDoubleFlagChangedEvent;
1525
1526 EventDoubleFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventDoubleFlagChanged>(timing) {}
1527
1528 void set_name(const char* new_value) {
1529 this->_name = new_value;
1530 DEBUG_ONLY(set_field_bit(0));
1531 }
1532 void set_oldValue(double new_value) {
1533 this->_oldValue = new_value;
1534 DEBUG_ONLY(set_field_bit(1));
1535 }
1536 void set_newValue(double new_value) {
1537 this->_newValue = new_value;
1538 DEBUG_ONLY(set_field_bit(2));
1539 }
1540 void set_origin(u8 new_value) {
1541 this->_origin = new_value;
1542 DEBUG_ONLY(set_field_bit(3));
1543 }
1544
1545 template <typename Writer>
1546 void writeData(Writer& w) {
1547 w.write(_name);
1548 w.write(_oldValue);
1549 w.write(_newValue);
1550 w.write(_origin);
1551 }
1552
1553 using JfrEvent<EventDoubleFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1554
1555
1556
1557 static void commit(const char* name,
1558 double oldValue,
1559 double newValue,
1560 u8 origin) {
1561 EventDoubleFlagChanged me(UNTIMED);
1562
1563 if (me.should_commit()) {
1564 me.set_name(name);
1565 me.set_oldValue(oldValue);
1566 me.set_newValue(newValue);
1567 me.set_origin(origin);
1568 me.commit();
1569 }
1570 }
1571
1572#ifdef ASSERT
1573 void verify() const {
1574 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1575 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1576 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1577 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1578 }
1579#endif
1580};
1581
1582class EventBooleanFlagChanged : public JfrEvent<EventBooleanFlagChanged>
1583{
1584 private:
1585 const char* _name;
1586 bool _oldValue;
1587 bool _newValue;
1588 u8 _origin;
1589
1590 public:
1591 static const bool hasThread = false;
1592 static const bool hasStackTrace = false;
1593 static const bool isInstant = true;
1594 static const bool hasCutoff = false;
1595 static const bool isRequestable = false;
1596 static const JfrEventId eventId = JfrBooleanFlagChangedEvent;
1597
1598 EventBooleanFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventBooleanFlagChanged>(timing) {}
1599
1600 void set_name(const char* new_value) {
1601 this->_name = new_value;
1602 DEBUG_ONLY(set_field_bit(0));
1603 }
1604 void set_oldValue(bool new_value) {
1605 this->_oldValue = new_value;
1606 DEBUG_ONLY(set_field_bit(1));
1607 }
1608 void set_newValue(bool new_value) {
1609 this->_newValue = new_value;
1610 DEBUG_ONLY(set_field_bit(2));
1611 }
1612 void set_origin(u8 new_value) {
1613 this->_origin = new_value;
1614 DEBUG_ONLY(set_field_bit(3));
1615 }
1616
1617 template <typename Writer>
1618 void writeData(Writer& w) {
1619 w.write(_name);
1620 w.write(_oldValue);
1621 w.write(_newValue);
1622 w.write(_origin);
1623 }
1624
1625 using JfrEvent<EventBooleanFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1626
1627
1628
1629 static void commit(const char* name,
1630 bool oldValue,
1631 bool newValue,
1632 u8 origin) {
1633 EventBooleanFlagChanged me(UNTIMED);
1634
1635 if (me.should_commit()) {
1636 me.set_name(name);
1637 me.set_oldValue(oldValue);
1638 me.set_newValue(newValue);
1639 me.set_origin(origin);
1640 me.commit();
1641 }
1642 }
1643
1644#ifdef ASSERT
1645 void verify() const {
1646 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1647 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1648 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1649 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1650 }
1651#endif
1652};
1653
1654class EventStringFlagChanged : public JfrEvent<EventStringFlagChanged>
1655{
1656 private:
1657 const char* _name;
1658 const char* _oldValue;
1659 const char* _newValue;
1660 u8 _origin;
1661
1662 public:
1663 static const bool hasThread = false;
1664 static const bool hasStackTrace = false;
1665 static const bool isInstant = true;
1666 static const bool hasCutoff = false;
1667 static const bool isRequestable = false;
1668 static const JfrEventId eventId = JfrStringFlagChangedEvent;
1669
1670 EventStringFlagChanged(EventStartTime timing=TIMED) : JfrEvent<EventStringFlagChanged>(timing) {}
1671
1672 void set_name(const char* new_value) {
1673 this->_name = new_value;
1674 DEBUG_ONLY(set_field_bit(0));
1675 }
1676 void set_oldValue(const char* new_value) {
1677 this->_oldValue = new_value;
1678 DEBUG_ONLY(set_field_bit(1));
1679 }
1680 void set_newValue(const char* new_value) {
1681 this->_newValue = new_value;
1682 DEBUG_ONLY(set_field_bit(2));
1683 }
1684 void set_origin(u8 new_value) {
1685 this->_origin = new_value;
1686 DEBUG_ONLY(set_field_bit(3));
1687 }
1688
1689 template <typename Writer>
1690 void writeData(Writer& w) {
1691 w.write(_name);
1692 w.write(_oldValue);
1693 w.write(_newValue);
1694 w.write(_origin);
1695 }
1696
1697 using JfrEvent<EventStringFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
1698
1699
1700
1701 static void commit(const char* name,
1702 const char* oldValue,
1703 const char* newValue,
1704 u8 origin) {
1705 EventStringFlagChanged me(UNTIMED);
1706
1707 if (me.should_commit()) {
1708 me.set_name(name);
1709 me.set_oldValue(oldValue);
1710 me.set_newValue(newValue);
1711 me.set_origin(origin);
1712 me.commit();
1713 }
1714 }
1715
1716#ifdef ASSERT
1717 void verify() const {
1718 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
1719 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldValue");
1720 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newValue");
1721 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_origin");
1722 }
1723#endif
1724};
1725
1726class EventGCHeapSummary : public JfrEvent<EventGCHeapSummary>
1727{
1728 private:
1729 unsigned _gcId;
1730 u8 _when;
1731 JfrStructVirtualSpace _heapSpace;
1732 u8 _heapUsed;
1733
1734 public:
1735 static const bool hasThread = false;
1736 static const bool hasStackTrace = false;
1737 static const bool isInstant = true;
1738 static const bool hasCutoff = false;
1739 static const bool isRequestable = false;
1740 static const JfrEventId eventId = JfrGCHeapSummaryEvent;
1741
1742 EventGCHeapSummary(EventStartTime timing=TIMED) : JfrEvent<EventGCHeapSummary>(timing) {}
1743
1744 void set_gcId(unsigned new_value) {
1745 this->_gcId = new_value;
1746 DEBUG_ONLY(set_field_bit(0));
1747 }
1748 void set_when(u8 new_value) {
1749 this->_when = new_value;
1750 DEBUG_ONLY(set_field_bit(1));
1751 }
1752 void set_heapSpace(const JfrStructVirtualSpace& value) {
1753 this->_heapSpace = value;
1754 DEBUG_ONLY(set_field_bit(2));
1755 }
1756 void set_heapUsed(u8 new_value) {
1757 this->_heapUsed = new_value;
1758 DEBUG_ONLY(set_field_bit(3));
1759 }
1760
1761 template <typename Writer>
1762 void writeData(Writer& w) {
1763 w.write(_gcId);
1764 w.write(_when);
1765 _heapSpace.writeData(w);
1766 w.write(_heapUsed);
1767 }
1768
1769 using JfrEvent<EventGCHeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
1770
1771
1772
1773 static void commit(unsigned gcId,
1774 u8 when,
1775 const JfrStructVirtualSpace& heapSpace,
1776 u8 heapUsed) {
1777 EventGCHeapSummary me(UNTIMED);
1778
1779 if (me.should_commit()) {
1780 me.set_gcId(gcId);
1781 me.set_when(when);
1782 me.set_heapSpace(heapSpace);
1783 me.set_heapUsed(heapUsed);
1784 me.commit();
1785 }
1786 }
1787
1788#ifdef ASSERT
1789 void verify() const {
1790 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
1791 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_when");
1792 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_heapSpace");
1793 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_heapUsed");
1794 }
1795#endif
1796};
1797
1798class EventMetaspaceSummary : public JfrEvent<EventMetaspaceSummary>
1799{
1800 private:
1801 unsigned _gcId;
1802 u8 _when;
1803 u8 _gcThreshold;
1804 JfrStructMetaspaceSizes _metaspace;
1805 JfrStructMetaspaceSizes _dataSpace;
1806 JfrStructMetaspaceSizes _classSpace;
1807
1808 public:
1809 static const bool hasThread = false;
1810 static const bool hasStackTrace = false;
1811 static const bool isInstant = true;
1812 static const bool hasCutoff = false;
1813 static const bool isRequestable = false;
1814 static const JfrEventId eventId = JfrMetaspaceSummaryEvent;
1815
1816 EventMetaspaceSummary(EventStartTime timing=TIMED) : JfrEvent<EventMetaspaceSummary>(timing) {}
1817
1818 void set_gcId(unsigned new_value) {
1819 this->_gcId = new_value;
1820 DEBUG_ONLY(set_field_bit(0));
1821 }
1822 void set_when(u8 new_value) {
1823 this->_when = new_value;
1824 DEBUG_ONLY(set_field_bit(1));
1825 }
1826 void set_gcThreshold(u8 new_value) {
1827 this->_gcThreshold = new_value;
1828 DEBUG_ONLY(set_field_bit(2));
1829 }
1830 void set_metaspace(const JfrStructMetaspaceSizes& value) {
1831 this->_metaspace = value;
1832 DEBUG_ONLY(set_field_bit(3));
1833 }
1834 void set_dataSpace(const JfrStructMetaspaceSizes& value) {
1835 this->_dataSpace = value;
1836 DEBUG_ONLY(set_field_bit(4));
1837 }
1838 void set_classSpace(const JfrStructMetaspaceSizes& value) {
1839 this->_classSpace = value;
1840 DEBUG_ONLY(set_field_bit(5));
1841 }
1842
1843 template <typename Writer>
1844 void writeData(Writer& w) {
1845 w.write(_gcId);
1846 w.write(_when);
1847 w.write(_gcThreshold);
1848 _metaspace.writeData(w);
1849 _dataSpace.writeData(w);
1850 _classSpace.writeData(w);
1851 }
1852
1853 using JfrEvent<EventMetaspaceSummary>::commit; // else commit() is hidden by overloaded versions in this class
1854
1855
1856
1857 static void commit(unsigned gcId,
1858 u8 when,
1859 u8 gcThreshold,
1860 const JfrStructMetaspaceSizes& metaspace,
1861 const JfrStructMetaspaceSizes& dataSpace,
1862 const JfrStructMetaspaceSizes& classSpace) {
1863 EventMetaspaceSummary me(UNTIMED);
1864
1865 if (me.should_commit()) {
1866 me.set_gcId(gcId);
1867 me.set_when(when);
1868 me.set_gcThreshold(gcThreshold);
1869 me.set_metaspace(metaspace);
1870 me.set_dataSpace(dataSpace);
1871 me.set_classSpace(classSpace);
1872 me.commit();
1873 }
1874 }
1875
1876#ifdef ASSERT
1877 void verify() const {
1878 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
1879 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_when");
1880 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_gcThreshold");
1881 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_metaspace");
1882 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_dataSpace");
1883 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_classSpace");
1884 }
1885#endif
1886};
1887
1888class EventMetaspaceGCThreshold : public JfrEvent<EventMetaspaceGCThreshold>
1889{
1890 private:
1891 u8 _oldValue;
1892 u8 _newValue;
1893 u8 _updater;
1894
1895 public:
1896 static const bool hasThread = false;
1897 static const bool hasStackTrace = false;
1898 static const bool isInstant = true;
1899 static const bool hasCutoff = false;
1900 static const bool isRequestable = false;
1901 static const JfrEventId eventId = JfrMetaspaceGCThresholdEvent;
1902
1903 EventMetaspaceGCThreshold(EventStartTime timing=TIMED) : JfrEvent<EventMetaspaceGCThreshold>(timing) {}
1904
1905 void set_oldValue(u8 new_value) {
1906 this->_oldValue = new_value;
1907 DEBUG_ONLY(set_field_bit(0));
1908 }
1909 void set_newValue(u8 new_value) {
1910 this->_newValue = new_value;
1911 DEBUG_ONLY(set_field_bit(1));
1912 }
1913 void set_updater(u8 new_value) {
1914 this->_updater = new_value;
1915 DEBUG_ONLY(set_field_bit(2));
1916 }
1917
1918 template <typename Writer>
1919 void writeData(Writer& w) {
1920 w.write(_oldValue);
1921 w.write(_newValue);
1922 w.write(_updater);
1923 }
1924
1925 using JfrEvent<EventMetaspaceGCThreshold>::commit; // else commit() is hidden by overloaded versions in this class
1926
1927
1928
1929 static void commit(u8 oldValue,
1930 u8 newValue,
1931 u8 updater) {
1932 EventMetaspaceGCThreshold me(UNTIMED);
1933
1934 if (me.should_commit()) {
1935 me.set_oldValue(oldValue);
1936 me.set_newValue(newValue);
1937 me.set_updater(updater);
1938 me.commit();
1939 }
1940 }
1941
1942#ifdef ASSERT
1943 void verify() const {
1944 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_oldValue");
1945 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_newValue");
1946 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_updater");
1947 }
1948#endif
1949};
1950
1951class EventMetaspaceAllocationFailure : public JfrEvent<EventMetaspaceAllocationFailure>
1952{
1953 private:
1954 const ClassLoaderData* _classLoader;
1955 bool _unsafeAnonymousClassLoader;
1956 u8 _size;
1957 u8 _metadataType;
1958 u8 _metaspaceObjectType;
1959
1960 public:
1961 static const bool hasThread = false;
1962 static const bool hasStackTrace = true;
1963 static const bool isInstant = true;
1964 static const bool hasCutoff = false;
1965 static const bool isRequestable = false;
1966 static const JfrEventId eventId = JfrMetaspaceAllocationFailureEvent;
1967
1968 EventMetaspaceAllocationFailure(EventStartTime timing=TIMED) : JfrEvent<EventMetaspaceAllocationFailure>(timing) {}
1969
1970 void set_classLoader(const ClassLoaderData* new_value) {
1971 this->_classLoader = new_value;
1972 DEBUG_ONLY(set_field_bit(0));
1973 }
1974 void set_unsafeAnonymousClassLoader(bool new_value) {
1975 this->_unsafeAnonymousClassLoader = new_value;
1976 DEBUG_ONLY(set_field_bit(1));
1977 }
1978 void set_size(u8 new_value) {
1979 this->_size = new_value;
1980 DEBUG_ONLY(set_field_bit(2));
1981 }
1982 void set_metadataType(u8 new_value) {
1983 this->_metadataType = new_value;
1984 DEBUG_ONLY(set_field_bit(3));
1985 }
1986 void set_metaspaceObjectType(u8 new_value) {
1987 this->_metaspaceObjectType = new_value;
1988 DEBUG_ONLY(set_field_bit(4));
1989 }
1990
1991 template <typename Writer>
1992 void writeData(Writer& w) {
1993 w.write(_classLoader);
1994 w.write(_unsafeAnonymousClassLoader);
1995 w.write(_size);
1996 w.write(_metadataType);
1997 w.write(_metaspaceObjectType);
1998 }
1999
2000 using JfrEvent<EventMetaspaceAllocationFailure>::commit; // else commit() is hidden by overloaded versions in this class
2001
2002
2003
2004 static void commit(const ClassLoaderData* classLoader,
2005 bool unsafeAnonymousClassLoader,
2006 u8 size,
2007 u8 metadataType,
2008 u8 metaspaceObjectType) {
2009 EventMetaspaceAllocationFailure me(UNTIMED);
2010
2011 if (me.should_commit()) {
2012 me.set_classLoader(classLoader);
2013 me.set_unsafeAnonymousClassLoader(unsafeAnonymousClassLoader);
2014 me.set_size(size);
2015 me.set_metadataType(metadataType);
2016 me.set_metaspaceObjectType(metaspaceObjectType);
2017 me.commit();
2018 }
2019 }
2020
2021#ifdef ASSERT
2022 void verify() const {
2023 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_classLoader");
2024 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_unsafeAnonymousClassLoader");
2025 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_size");
2026 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_metadataType");
2027 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_metaspaceObjectType");
2028 }
2029#endif
2030};
2031
2032class EventMetaspaceOOM : public JfrEvent<EventMetaspaceOOM>
2033{
2034 private:
2035 const ClassLoaderData* _classLoader;
2036 bool _unsafeAnonymousClassLoader;
2037 u8 _size;
2038 u8 _metadataType;
2039 u8 _metaspaceObjectType;
2040
2041 public:
2042 static const bool hasThread = false;
2043 static const bool hasStackTrace = true;
2044 static const bool isInstant = true;
2045 static const bool hasCutoff = false;
2046 static const bool isRequestable = false;
2047 static const JfrEventId eventId = JfrMetaspaceOOMEvent;
2048
2049 EventMetaspaceOOM(EventStartTime timing=TIMED) : JfrEvent<EventMetaspaceOOM>(timing) {}
2050
2051 void set_classLoader(const ClassLoaderData* new_value) {
2052 this->_classLoader = new_value;
2053 DEBUG_ONLY(set_field_bit(0));
2054 }
2055 void set_unsafeAnonymousClassLoader(bool new_value) {
2056 this->_unsafeAnonymousClassLoader = new_value;
2057 DEBUG_ONLY(set_field_bit(1));
2058 }
2059 void set_size(u8 new_value) {
2060 this->_size = new_value;
2061 DEBUG_ONLY(set_field_bit(2));
2062 }
2063 void set_metadataType(u8 new_value) {
2064 this->_metadataType = new_value;
2065 DEBUG_ONLY(set_field_bit(3));
2066 }
2067 void set_metaspaceObjectType(u8 new_value) {
2068 this->_metaspaceObjectType = new_value;
2069 DEBUG_ONLY(set_field_bit(4));
2070 }
2071
2072 template <typename Writer>
2073 void writeData(Writer& w) {
2074 w.write(_classLoader);
2075 w.write(_unsafeAnonymousClassLoader);
2076 w.write(_size);
2077 w.write(_metadataType);
2078 w.write(_metaspaceObjectType);
2079 }
2080
2081 using JfrEvent<EventMetaspaceOOM>::commit; // else commit() is hidden by overloaded versions in this class
2082
2083
2084
2085 static void commit(const ClassLoaderData* classLoader,
2086 bool unsafeAnonymousClassLoader,
2087 u8 size,
2088 u8 metadataType,
2089 u8 metaspaceObjectType) {
2090 EventMetaspaceOOM me(UNTIMED);
2091
2092 if (me.should_commit()) {
2093 me.set_classLoader(classLoader);
2094 me.set_unsafeAnonymousClassLoader(unsafeAnonymousClassLoader);
2095 me.set_size(size);
2096 me.set_metadataType(metadataType);
2097 me.set_metaspaceObjectType(metaspaceObjectType);
2098 me.commit();
2099 }
2100 }
2101
2102#ifdef ASSERT
2103 void verify() const {
2104 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_classLoader");
2105 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_unsafeAnonymousClassLoader");
2106 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_size");
2107 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_metadataType");
2108 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_metaspaceObjectType");
2109 }
2110#endif
2111};
2112
2113class EventMetaspaceChunkFreeListSummary : public JfrEvent<EventMetaspaceChunkFreeListSummary>
2114{
2115 private:
2116 unsigned _gcId;
2117 u8 _when;
2118 u8 _metadataType;
2119 u8 _specializedChunks;
2120 u8 _specializedChunksTotalSize;
2121 u8 _smallChunks;
2122 u8 _smallChunksTotalSize;
2123 u8 _mediumChunks;
2124 u8 _mediumChunksTotalSize;
2125 u8 _humongousChunks;
2126 u8 _humongousChunksTotalSize;
2127
2128 public:
2129 static const bool hasThread = false;
2130 static const bool hasStackTrace = false;
2131 static const bool isInstant = true;
2132 static const bool hasCutoff = false;
2133 static const bool isRequestable = false;
2134 static const JfrEventId eventId = JfrMetaspaceChunkFreeListSummaryEvent;
2135
2136 EventMetaspaceChunkFreeListSummary(EventStartTime timing=TIMED) : JfrEvent<EventMetaspaceChunkFreeListSummary>(timing) {}
2137
2138 void set_gcId(unsigned new_value) {
2139 this->_gcId = new_value;
2140 DEBUG_ONLY(set_field_bit(0));
2141 }
2142 void set_when(u8 new_value) {
2143 this->_when = new_value;
2144 DEBUG_ONLY(set_field_bit(1));
2145 }
2146 void set_metadataType(u8 new_value) {
2147 this->_metadataType = new_value;
2148 DEBUG_ONLY(set_field_bit(2));
2149 }
2150 void set_specializedChunks(u8 new_value) {
2151 this->_specializedChunks = new_value;
2152 DEBUG_ONLY(set_field_bit(3));
2153 }
2154 void set_specializedChunksTotalSize(u8 new_value) {
2155 this->_specializedChunksTotalSize = new_value;
2156 DEBUG_ONLY(set_field_bit(4));
2157 }
2158 void set_smallChunks(u8 new_value) {
2159 this->_smallChunks = new_value;
2160 DEBUG_ONLY(set_field_bit(5));
2161 }
2162 void set_smallChunksTotalSize(u8 new_value) {
2163 this->_smallChunksTotalSize = new_value;
2164 DEBUG_ONLY(set_field_bit(6));
2165 }
2166 void set_mediumChunks(u8 new_value) {
2167 this->_mediumChunks = new_value;
2168 DEBUG_ONLY(set_field_bit(7));
2169 }
2170 void set_mediumChunksTotalSize(u8 new_value) {
2171 this->_mediumChunksTotalSize = new_value;
2172 DEBUG_ONLY(set_field_bit(8));
2173 }
2174 void set_humongousChunks(u8 new_value) {
2175 this->_humongousChunks = new_value;
2176 DEBUG_ONLY(set_field_bit(9));
2177 }
2178 void set_humongousChunksTotalSize(u8 new_value) {
2179 this->_humongousChunksTotalSize = new_value;
2180 DEBUG_ONLY(set_field_bit(10));
2181 }
2182
2183 template <typename Writer>
2184 void writeData(Writer& w) {
2185 w.write(_gcId);
2186 w.write(_when);
2187 w.write(_metadataType);
2188 w.write(_specializedChunks);
2189 w.write(_specializedChunksTotalSize);
2190 w.write(_smallChunks);
2191 w.write(_smallChunksTotalSize);
2192 w.write(_mediumChunks);
2193 w.write(_mediumChunksTotalSize);
2194 w.write(_humongousChunks);
2195 w.write(_humongousChunksTotalSize);
2196 }
2197
2198 using JfrEvent<EventMetaspaceChunkFreeListSummary>::commit; // else commit() is hidden by overloaded versions in this class
2199
2200
2201
2202 static void commit(unsigned gcId,
2203 u8 when,
2204 u8 metadataType,
2205 u8 specializedChunks,
2206 u8 specializedChunksTotalSize,
2207 u8 smallChunks,
2208 u8 smallChunksTotalSize,
2209 u8 mediumChunks,
2210 u8 mediumChunksTotalSize,
2211 u8 humongousChunks,
2212 u8 humongousChunksTotalSize) {
2213 EventMetaspaceChunkFreeListSummary me(UNTIMED);
2214
2215 if (me.should_commit()) {
2216 me.set_gcId(gcId);
2217 me.set_when(when);
2218 me.set_metadataType(metadataType);
2219 me.set_specializedChunks(specializedChunks);
2220 me.set_specializedChunksTotalSize(specializedChunksTotalSize);
2221 me.set_smallChunks(smallChunks);
2222 me.set_smallChunksTotalSize(smallChunksTotalSize);
2223 me.set_mediumChunks(mediumChunks);
2224 me.set_mediumChunksTotalSize(mediumChunksTotalSize);
2225 me.set_humongousChunks(humongousChunks);
2226 me.set_humongousChunksTotalSize(humongousChunksTotalSize);
2227 me.commit();
2228 }
2229 }
2230
2231#ifdef ASSERT
2232 void verify() const {
2233 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2234 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_when");
2235 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_metadataType");
2236 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_specializedChunks");
2237 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_specializedChunksTotalSize");
2238 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_smallChunks");
2239 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_smallChunksTotalSize");
2240 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_mediumChunks");
2241 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_mediumChunksTotalSize");
2242 assert(verify_field_bit(9), "Attempting to write an uninitialized event field: %s", "_humongousChunks");
2243 assert(verify_field_bit(10), "Attempting to write an uninitialized event field: %s", "_humongousChunksTotalSize");
2244 }
2245#endif
2246};
2247
2248class EventPSHeapSummary : public JfrEvent<EventPSHeapSummary>
2249{
2250 private:
2251 unsigned _gcId;
2252 u8 _when;
2253 JfrStructVirtualSpace _oldSpace;
2254 JfrStructObjectSpace _oldObjectSpace;
2255 JfrStructVirtualSpace _youngSpace;
2256 JfrStructObjectSpace _edenSpace;
2257 JfrStructObjectSpace _fromSpace;
2258 JfrStructObjectSpace _toSpace;
2259
2260 public:
2261 static const bool hasThread = false;
2262 static const bool hasStackTrace = false;
2263 static const bool isInstant = true;
2264 static const bool hasCutoff = false;
2265 static const bool isRequestable = false;
2266 static const JfrEventId eventId = JfrPSHeapSummaryEvent;
2267
2268 EventPSHeapSummary(EventStartTime timing=TIMED) : JfrEvent<EventPSHeapSummary>(timing) {}
2269
2270 void set_gcId(unsigned new_value) {
2271 this->_gcId = new_value;
2272 DEBUG_ONLY(set_field_bit(0));
2273 }
2274 void set_when(u8 new_value) {
2275 this->_when = new_value;
2276 DEBUG_ONLY(set_field_bit(1));
2277 }
2278 void set_oldSpace(const JfrStructVirtualSpace& value) {
2279 this->_oldSpace = value;
2280 DEBUG_ONLY(set_field_bit(2));
2281 }
2282 void set_oldObjectSpace(const JfrStructObjectSpace& value) {
2283 this->_oldObjectSpace = value;
2284 DEBUG_ONLY(set_field_bit(3));
2285 }
2286 void set_youngSpace(const JfrStructVirtualSpace& value) {
2287 this->_youngSpace = value;
2288 DEBUG_ONLY(set_field_bit(4));
2289 }
2290 void set_edenSpace(const JfrStructObjectSpace& value) {
2291 this->_edenSpace = value;
2292 DEBUG_ONLY(set_field_bit(5));
2293 }
2294 void set_fromSpace(const JfrStructObjectSpace& value) {
2295 this->_fromSpace = value;
2296 DEBUG_ONLY(set_field_bit(6));
2297 }
2298 void set_toSpace(const JfrStructObjectSpace& value) {
2299 this->_toSpace = value;
2300 DEBUG_ONLY(set_field_bit(7));
2301 }
2302
2303 template <typename Writer>
2304 void writeData(Writer& w) {
2305 w.write(_gcId);
2306 w.write(_when);
2307 _oldSpace.writeData(w);
2308 _oldObjectSpace.writeData(w);
2309 _youngSpace.writeData(w);
2310 _edenSpace.writeData(w);
2311 _fromSpace.writeData(w);
2312 _toSpace.writeData(w);
2313 }
2314
2315 using JfrEvent<EventPSHeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
2316
2317
2318
2319 static void commit(unsigned gcId,
2320 u8 when,
2321 const JfrStructVirtualSpace& oldSpace,
2322 const JfrStructObjectSpace& oldObjectSpace,
2323 const JfrStructVirtualSpace& youngSpace,
2324 const JfrStructObjectSpace& edenSpace,
2325 const JfrStructObjectSpace& fromSpace,
2326 const JfrStructObjectSpace& toSpace) {
2327 EventPSHeapSummary me(UNTIMED);
2328
2329 if (me.should_commit()) {
2330 me.set_gcId(gcId);
2331 me.set_when(when);
2332 me.set_oldSpace(oldSpace);
2333 me.set_oldObjectSpace(oldObjectSpace);
2334 me.set_youngSpace(youngSpace);
2335 me.set_edenSpace(edenSpace);
2336 me.set_fromSpace(fromSpace);
2337 me.set_toSpace(toSpace);
2338 me.commit();
2339 }
2340 }
2341
2342#ifdef ASSERT
2343 void verify() const {
2344 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2345 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_when");
2346 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_oldSpace");
2347 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_oldObjectSpace");
2348 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_youngSpace");
2349 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_edenSpace");
2350 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_fromSpace");
2351 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_toSpace");
2352 }
2353#endif
2354};
2355
2356class EventG1HeapSummary : public JfrEvent<EventG1HeapSummary>
2357{
2358 private:
2359 unsigned _gcId;
2360 u8 _when;
2361 u8 _edenUsedSize;
2362 u8 _edenTotalSize;
2363 u8 _survivorUsedSize;
2364 unsigned _numberOfRegions;
2365
2366 public:
2367 static const bool hasThread = false;
2368 static const bool hasStackTrace = false;
2369 static const bool isInstant = true;
2370 static const bool hasCutoff = false;
2371 static const bool isRequestable = false;
2372 static const JfrEventId eventId = JfrG1HeapSummaryEvent;
2373
2374 EventG1HeapSummary(EventStartTime timing=TIMED) : JfrEvent<EventG1HeapSummary>(timing) {}
2375
2376 void set_gcId(unsigned new_value) {
2377 this->_gcId = new_value;
2378 DEBUG_ONLY(set_field_bit(0));
2379 }
2380 void set_when(u8 new_value) {
2381 this->_when = new_value;
2382 DEBUG_ONLY(set_field_bit(1));
2383 }
2384 void set_edenUsedSize(u8 new_value) {
2385 this->_edenUsedSize = new_value;
2386 DEBUG_ONLY(set_field_bit(2));
2387 }
2388 void set_edenTotalSize(u8 new_value) {
2389 this->_edenTotalSize = new_value;
2390 DEBUG_ONLY(set_field_bit(3));
2391 }
2392 void set_survivorUsedSize(u8 new_value) {
2393 this->_survivorUsedSize = new_value;
2394 DEBUG_ONLY(set_field_bit(4));
2395 }
2396 void set_numberOfRegions(unsigned new_value) {
2397 this->_numberOfRegions = new_value;
2398 DEBUG_ONLY(set_field_bit(5));
2399 }
2400
2401 template <typename Writer>
2402 void writeData(Writer& w) {
2403 w.write(_gcId);
2404 w.write(_when);
2405 w.write(_edenUsedSize);
2406 w.write(_edenTotalSize);
2407 w.write(_survivorUsedSize);
2408 w.write(_numberOfRegions);
2409 }
2410
2411 using JfrEvent<EventG1HeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
2412
2413
2414
2415 static void commit(unsigned gcId,
2416 u8 when,
2417 u8 edenUsedSize,
2418 u8 edenTotalSize,
2419 u8 survivorUsedSize,
2420 unsigned numberOfRegions) {
2421 EventG1HeapSummary me(UNTIMED);
2422
2423 if (me.should_commit()) {
2424 me.set_gcId(gcId);
2425 me.set_when(when);
2426 me.set_edenUsedSize(edenUsedSize);
2427 me.set_edenTotalSize(edenTotalSize);
2428 me.set_survivorUsedSize(survivorUsedSize);
2429 me.set_numberOfRegions(numberOfRegions);
2430 me.commit();
2431 }
2432 }
2433
2434#ifdef ASSERT
2435 void verify() const {
2436 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2437 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_when");
2438 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_edenUsedSize");
2439 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_edenTotalSize");
2440 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_survivorUsedSize");
2441 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_numberOfRegions");
2442 }
2443#endif
2444};
2445
2446class EventGarbageCollection : public JfrEvent<EventGarbageCollection>
2447{
2448 private:
2449 unsigned _gcId;
2450 u8 _name;
2451 u8 _cause;
2452 Tickspan _sumOfPauses;
2453 Tickspan _longestPause;
2454
2455 public:
2456 static const bool hasThread = false;
2457 static const bool hasStackTrace = false;
2458 static const bool isInstant = false;
2459 static const bool hasCutoff = false;
2460 static const bool isRequestable = false;
2461 static const JfrEventId eventId = JfrGarbageCollectionEvent;
2462
2463 EventGarbageCollection(EventStartTime timing=TIMED) : JfrEvent<EventGarbageCollection>(timing) {}
2464
2465 void set_gcId(unsigned new_value) {
2466 this->_gcId = new_value;
2467 DEBUG_ONLY(set_field_bit(0));
2468 }
2469 void set_name(u8 new_value) {
2470 this->_name = new_value;
2471 DEBUG_ONLY(set_field_bit(1));
2472 }
2473 void set_cause(u8 new_value) {
2474 this->_cause = new_value;
2475 DEBUG_ONLY(set_field_bit(2));
2476 }
2477 void set_sumOfPauses(const Tickspan& new_value) {
2478 this->_sumOfPauses = new_value;
2479 DEBUG_ONLY(set_field_bit(3));
2480 }
2481 void set_longestPause(const Tickspan& new_value) {
2482 this->_longestPause = new_value;
2483 DEBUG_ONLY(set_field_bit(4));
2484 }
2485
2486 template <typename Writer>
2487 void writeData(Writer& w) {
2488 w.write(_gcId);
2489 w.write(_name);
2490 w.write(_cause);
2491 w.write(_sumOfPauses);
2492 w.write(_longestPause);
2493 }
2494
2495 using JfrEvent<EventGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
2496
2497 EventGarbageCollection(
2498 unsigned gcId,
2499 u8 name,
2500 u8 cause,
2501 const Tickspan& sumOfPauses,
2502 const Tickspan& longestPause) : JfrEvent<EventGarbageCollection>(TIMED) {
2503 if (should_commit()) {
2504 set_gcId(gcId);
2505 set_name(name);
2506 set_cause(cause);
2507 set_sumOfPauses(sumOfPauses);
2508 set_longestPause(longestPause);
2509 }
2510 }
2511
2512 void commit(unsigned gcId,
2513 u8 name,
2514 u8 cause,
2515 const Tickspan& sumOfPauses,
2516 const Tickspan& longestPause) {
2517 if (should_commit()) {
2518 set_gcId(gcId);
2519 set_name(name);
2520 set_cause(cause);
2521 set_sumOfPauses(sumOfPauses);
2522 set_longestPause(longestPause);
2523 commit();
2524 }
2525 }
2526
2527 static void commit(const Ticks& startTicks,
2528 const Ticks& endTicks,
2529 unsigned gcId,
2530 u8 name,
2531 u8 cause,
2532 const Tickspan& sumOfPauses,
2533 const Tickspan& longestPause) {
2534 EventGarbageCollection me(UNTIMED);
2535
2536 if (me.should_commit()) {
2537 me.set_starttime(startTicks);
2538 me.set_endtime(endTicks);
2539 me.set_gcId(gcId);
2540 me.set_name(name);
2541 me.set_cause(cause);
2542 me.set_sumOfPauses(sumOfPauses);
2543 me.set_longestPause(longestPause);
2544 me.commit();
2545 }
2546 }
2547
2548#ifdef ASSERT
2549 void verify() const {
2550 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2551 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
2552 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_cause");
2553 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_sumOfPauses");
2554 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_longestPause");
2555 }
2556#endif
2557};
2558
2559class EventParallelOldGarbageCollection : public JfrEvent<EventParallelOldGarbageCollection>
2560{
2561 private:
2562 unsigned _gcId;
2563 u8 _densePrefix;
2564
2565 public:
2566 static const bool hasThread = false;
2567 static const bool hasStackTrace = false;
2568 static const bool isInstant = false;
2569 static const bool hasCutoff = false;
2570 static const bool isRequestable = false;
2571 static const JfrEventId eventId = JfrParallelOldGarbageCollectionEvent;
2572
2573 EventParallelOldGarbageCollection(EventStartTime timing=TIMED) : JfrEvent<EventParallelOldGarbageCollection>(timing) {}
2574
2575 void set_gcId(unsigned new_value) {
2576 this->_gcId = new_value;
2577 DEBUG_ONLY(set_field_bit(0));
2578 }
2579 void set_densePrefix(u8 new_value) {
2580 this->_densePrefix = new_value;
2581 DEBUG_ONLY(set_field_bit(1));
2582 }
2583
2584 template <typename Writer>
2585 void writeData(Writer& w) {
2586 w.write(_gcId);
2587 w.write(_densePrefix);
2588 }
2589
2590 using JfrEvent<EventParallelOldGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
2591
2592 EventParallelOldGarbageCollection(
2593 unsigned gcId,
2594 u8 densePrefix) : JfrEvent<EventParallelOldGarbageCollection>(TIMED) {
2595 if (should_commit()) {
2596 set_gcId(gcId);
2597 set_densePrefix(densePrefix);
2598 }
2599 }
2600
2601 void commit(unsigned gcId,
2602 u8 densePrefix) {
2603 if (should_commit()) {
2604 set_gcId(gcId);
2605 set_densePrefix(densePrefix);
2606 commit();
2607 }
2608 }
2609
2610 static void commit(const Ticks& startTicks,
2611 const Ticks& endTicks,
2612 unsigned gcId,
2613 u8 densePrefix) {
2614 EventParallelOldGarbageCollection me(UNTIMED);
2615
2616 if (me.should_commit()) {
2617 me.set_starttime(startTicks);
2618 me.set_endtime(endTicks);
2619 me.set_gcId(gcId);
2620 me.set_densePrefix(densePrefix);
2621 me.commit();
2622 }
2623 }
2624
2625#ifdef ASSERT
2626 void verify() const {
2627 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2628 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_densePrefix");
2629 }
2630#endif
2631};
2632
2633class EventYoungGarbageCollection : public JfrEvent<EventYoungGarbageCollection>
2634{
2635 private:
2636 unsigned _gcId;
2637 unsigned _tenuringThreshold;
2638
2639 public:
2640 static const bool hasThread = false;
2641 static const bool hasStackTrace = false;
2642 static const bool isInstant = false;
2643 static const bool hasCutoff = false;
2644 static const bool isRequestable = false;
2645 static const JfrEventId eventId = JfrYoungGarbageCollectionEvent;
2646
2647 EventYoungGarbageCollection(EventStartTime timing=TIMED) : JfrEvent<EventYoungGarbageCollection>(timing) {}
2648
2649 void set_gcId(unsigned new_value) {
2650 this->_gcId = new_value;
2651 DEBUG_ONLY(set_field_bit(0));
2652 }
2653 void set_tenuringThreshold(unsigned new_value) {
2654 this->_tenuringThreshold = new_value;
2655 DEBUG_ONLY(set_field_bit(1));
2656 }
2657
2658 template <typename Writer>
2659 void writeData(Writer& w) {
2660 w.write(_gcId);
2661 w.write(_tenuringThreshold);
2662 }
2663
2664 using JfrEvent<EventYoungGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
2665
2666 EventYoungGarbageCollection(
2667 unsigned gcId,
2668 unsigned tenuringThreshold) : JfrEvent<EventYoungGarbageCollection>(TIMED) {
2669 if (should_commit()) {
2670 set_gcId(gcId);
2671 set_tenuringThreshold(tenuringThreshold);
2672 }
2673 }
2674
2675 void commit(unsigned gcId,
2676 unsigned tenuringThreshold) {
2677 if (should_commit()) {
2678 set_gcId(gcId);
2679 set_tenuringThreshold(tenuringThreshold);
2680 commit();
2681 }
2682 }
2683
2684 static void commit(const Ticks& startTicks,
2685 const Ticks& endTicks,
2686 unsigned gcId,
2687 unsigned tenuringThreshold) {
2688 EventYoungGarbageCollection me(UNTIMED);
2689
2690 if (me.should_commit()) {
2691 me.set_starttime(startTicks);
2692 me.set_endtime(endTicks);
2693 me.set_gcId(gcId);
2694 me.set_tenuringThreshold(tenuringThreshold);
2695 me.commit();
2696 }
2697 }
2698
2699#ifdef ASSERT
2700 void verify() const {
2701 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2702 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_tenuringThreshold");
2703 }
2704#endif
2705};
2706
2707class EventOldGarbageCollection : public JfrEvent<EventOldGarbageCollection>
2708{
2709 private:
2710 unsigned _gcId;
2711
2712 public:
2713 static const bool hasThread = false;
2714 static const bool hasStackTrace = false;
2715 static const bool isInstant = false;
2716 static const bool hasCutoff = false;
2717 static const bool isRequestable = false;
2718 static const JfrEventId eventId = JfrOldGarbageCollectionEvent;
2719
2720 EventOldGarbageCollection(EventStartTime timing=TIMED) : JfrEvent<EventOldGarbageCollection>(timing) {}
2721
2722 void set_gcId(unsigned new_value) {
2723 this->_gcId = new_value;
2724 DEBUG_ONLY(set_field_bit(0));
2725 }
2726
2727 template <typename Writer>
2728 void writeData(Writer& w) {
2729 w.write(_gcId);
2730 }
2731
2732 using JfrEvent<EventOldGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
2733
2734 EventOldGarbageCollection(
2735 unsigned gcId) : JfrEvent<EventOldGarbageCollection>(TIMED) {
2736 if (should_commit()) {
2737 set_gcId(gcId);
2738 }
2739 }
2740
2741 void commit(unsigned gcId) {
2742 if (should_commit()) {
2743 set_gcId(gcId);
2744 commit();
2745 }
2746 }
2747
2748 static void commit(const Ticks& startTicks,
2749 const Ticks& endTicks,
2750 unsigned gcId) {
2751 EventOldGarbageCollection me(UNTIMED);
2752
2753 if (me.should_commit()) {
2754 me.set_starttime(startTicks);
2755 me.set_endtime(endTicks);
2756 me.set_gcId(gcId);
2757 me.commit();
2758 }
2759 }
2760
2761#ifdef ASSERT
2762 void verify() const {
2763 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2764 }
2765#endif
2766};
2767
2768class EventG1GarbageCollection : public JfrEvent<EventG1GarbageCollection>
2769{
2770 private:
2771 unsigned _gcId;
2772 u8 _type;
2773
2774 public:
2775 static const bool hasThread = false;
2776 static const bool hasStackTrace = false;
2777 static const bool isInstant = false;
2778 static const bool hasCutoff = false;
2779 static const bool isRequestable = false;
2780 static const JfrEventId eventId = JfrG1GarbageCollectionEvent;
2781
2782 EventG1GarbageCollection(EventStartTime timing=TIMED) : JfrEvent<EventG1GarbageCollection>(timing) {}
2783
2784 void set_gcId(unsigned new_value) {
2785 this->_gcId = new_value;
2786 DEBUG_ONLY(set_field_bit(0));
2787 }
2788 void set_type(u8 new_value) {
2789 this->_type = new_value;
2790 DEBUG_ONLY(set_field_bit(1));
2791 }
2792
2793 template <typename Writer>
2794 void writeData(Writer& w) {
2795 w.write(_gcId);
2796 w.write(_type);
2797 }
2798
2799 using JfrEvent<EventG1GarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
2800
2801 EventG1GarbageCollection(
2802 unsigned gcId,
2803 u8 type) : JfrEvent<EventG1GarbageCollection>(TIMED) {
2804 if (should_commit()) {
2805 set_gcId(gcId);
2806 set_type(type);
2807 }
2808 }
2809
2810 void commit(unsigned gcId,
2811 u8 type) {
2812 if (should_commit()) {
2813 set_gcId(gcId);
2814 set_type(type);
2815 commit();
2816 }
2817 }
2818
2819 static void commit(const Ticks& startTicks,
2820 const Ticks& endTicks,
2821 unsigned gcId,
2822 u8 type) {
2823 EventG1GarbageCollection me(UNTIMED);
2824
2825 if (me.should_commit()) {
2826 me.set_starttime(startTicks);
2827 me.set_endtime(endTicks);
2828 me.set_gcId(gcId);
2829 me.set_type(type);
2830 me.commit();
2831 }
2832 }
2833
2834#ifdef ASSERT
2835 void verify() const {
2836 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2837 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_type");
2838 }
2839#endif
2840};
2841
2842class EventG1MMU : public JfrEvent<EventG1MMU>
2843{
2844 private:
2845 unsigned _gcId;
2846 s8 _timeSlice;
2847 s8 _gcTime;
2848 s8 _pauseTarget;
2849
2850 public:
2851 static const bool hasThread = false;
2852 static const bool hasStackTrace = false;
2853 static const bool isInstant = true;
2854 static const bool hasCutoff = false;
2855 static const bool isRequestable = false;
2856 static const JfrEventId eventId = JfrG1MMUEvent;
2857
2858 EventG1MMU(EventStartTime timing=TIMED) : JfrEvent<EventG1MMU>(timing) {}
2859
2860 void set_gcId(unsigned new_value) {
2861 this->_gcId = new_value;
2862 DEBUG_ONLY(set_field_bit(0));
2863 }
2864 void set_timeSlice(s8 new_value) {
2865 this->_timeSlice = new_value;
2866 DEBUG_ONLY(set_field_bit(1));
2867 }
2868 void set_gcTime(s8 new_value) {
2869 this->_gcTime = new_value;
2870 DEBUG_ONLY(set_field_bit(2));
2871 }
2872 void set_pauseTarget(s8 new_value) {
2873 this->_pauseTarget = new_value;
2874 DEBUG_ONLY(set_field_bit(3));
2875 }
2876
2877 template <typename Writer>
2878 void writeData(Writer& w) {
2879 w.write(_gcId);
2880 w.write(_timeSlice);
2881 w.write(_gcTime);
2882 w.write(_pauseTarget);
2883 }
2884
2885 using JfrEvent<EventG1MMU>::commit; // else commit() is hidden by overloaded versions in this class
2886
2887
2888
2889 static void commit(unsigned gcId,
2890 s8 timeSlice,
2891 s8 gcTime,
2892 s8 pauseTarget) {
2893 EventG1MMU me(UNTIMED);
2894
2895 if (me.should_commit()) {
2896 me.set_gcId(gcId);
2897 me.set_timeSlice(timeSlice);
2898 me.set_gcTime(gcTime);
2899 me.set_pauseTarget(pauseTarget);
2900 me.commit();
2901 }
2902 }
2903
2904#ifdef ASSERT
2905 void verify() const {
2906 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
2907 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_timeSlice");
2908 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_gcTime");
2909 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_pauseTarget");
2910 }
2911#endif
2912};
2913
2914class EventEvacuationInformation : public JfrEvent<EventEvacuationInformation>
2915{
2916 private:
2917 unsigned _gcId;
2918 unsigned _cSetRegions;
2919 u8 _cSetUsedBefore;
2920 u8 _cSetUsedAfter;
2921 unsigned _allocationRegions;
2922 u8 _allocationRegionsUsedBefore;
2923 u8 _allocationRegionsUsedAfter;
2924 u8 _bytesCopied;
2925 unsigned _regionsFreed;
2926
2927 public:
2928 static const bool hasThread = false;
2929 static const bool hasStackTrace = false;
2930 static const bool isInstant = true;
2931 static const bool hasCutoff = false;
2932 static const bool isRequestable = false;
2933 static const JfrEventId eventId = JfrEvacuationInformationEvent;
2934
2935 EventEvacuationInformation(EventStartTime timing=TIMED) : JfrEvent<EventEvacuationInformation>(timing) {}
2936
2937 void set_gcId(unsigned new_value) {
2938 this->_gcId = new_value;
2939 DEBUG_ONLY(set_field_bit(0));
2940 }
2941 void set_cSetRegions(unsigned new_value) {
2942 this->_cSetRegions = new_value;
2943 DEBUG_ONLY(set_field_bit(1));
2944 }
2945 void set_cSetUsedBefore(u8 new_value) {
2946 this->_cSetUsedBefore = new_value;
2947 DEBUG_ONLY(set_field_bit(2));
2948 }
2949 void set_cSetUsedAfter(u8 new_value) {
2950 this->_cSetUsedAfter = new_value;
2951 DEBUG_ONLY(set_field_bit(3));
2952 }
2953 void set_allocationRegions(unsigned new_value) {
2954 this->_allocationRegions = new_value;
2955 DEBUG_ONLY(set_field_bit(4));
2956 }
2957 void set_allocationRegionsUsedBefore(u8 new_value) {
2958 this->_allocationRegionsUsedBefore = new_value;
2959 DEBUG_ONLY(set_field_bit(5));
2960 }
2961 void set_allocationRegionsUsedAfter(u8 new_value) {
2962 this->_allocationRegionsUsedAfter = new_value;
2963 DEBUG_ONLY(set_field_bit(6));
2964 }
2965 void set_bytesCopied(u8 new_value) {
2966 this->_bytesCopied = new_value;
2967 DEBUG_ONLY(set_field_bit(7));
2968 }
2969 void set_regionsFreed(unsigned new_value) {
2970 this->_regionsFreed = new_value;
2971 DEBUG_ONLY(set_field_bit(8));
2972 }
2973
2974 template <typename Writer>
2975 void writeData(Writer& w) {
2976 w.write(_gcId);
2977 w.write(_cSetRegions);
2978 w.write(_cSetUsedBefore);
2979 w.write(_cSetUsedAfter);
2980 w.write(_allocationRegions);
2981 w.write(_allocationRegionsUsedBefore);
2982 w.write(_allocationRegionsUsedAfter);
2983 w.write(_bytesCopied);
2984 w.write(_regionsFreed);
2985 }
2986
2987 using JfrEvent<EventEvacuationInformation>::commit; // else commit() is hidden by overloaded versions in this class
2988
2989
2990
2991 static void commit(unsigned gcId,
2992 unsigned cSetRegions,
2993 u8 cSetUsedBefore,
2994 u8 cSetUsedAfter,
2995 unsigned allocationRegions,
2996 u8 allocationRegionsUsedBefore,
2997 u8 allocationRegionsUsedAfter,
2998 u8 bytesCopied,
2999 unsigned regionsFreed) {
3000 EventEvacuationInformation me(UNTIMED);
3001
3002 if (me.should_commit()) {
3003 me.set_gcId(gcId);
3004 me.set_cSetRegions(cSetRegions);
3005 me.set_cSetUsedBefore(cSetUsedBefore);
3006 me.set_cSetUsedAfter(cSetUsedAfter);
3007 me.set_allocationRegions(allocationRegions);
3008 me.set_allocationRegionsUsedBefore(allocationRegionsUsedBefore);
3009 me.set_allocationRegionsUsedAfter(allocationRegionsUsedAfter);
3010 me.set_bytesCopied(bytesCopied);
3011 me.set_regionsFreed(regionsFreed);
3012 me.commit();
3013 }
3014 }
3015
3016#ifdef ASSERT
3017 void verify() const {
3018 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3019 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_cSetRegions");
3020 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_cSetUsedBefore");
3021 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_cSetUsedAfter");
3022 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_allocationRegions");
3023 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_allocationRegionsUsedBefore");
3024 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_allocationRegionsUsedAfter");
3025 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_bytesCopied");
3026 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_regionsFreed");
3027 }
3028#endif
3029};
3030
3031class EventGCReferenceStatistics : public JfrEvent<EventGCReferenceStatistics>
3032{
3033 private:
3034 unsigned _gcId;
3035 u8 _type;
3036 u8 _count;
3037
3038 public:
3039 static const bool hasThread = false;
3040 static const bool hasStackTrace = false;
3041 static const bool isInstant = true;
3042 static const bool hasCutoff = false;
3043 static const bool isRequestable = false;
3044 static const JfrEventId eventId = JfrGCReferenceStatisticsEvent;
3045
3046 EventGCReferenceStatistics(EventStartTime timing=TIMED) : JfrEvent<EventGCReferenceStatistics>(timing) {}
3047
3048 void set_gcId(unsigned new_value) {
3049 this->_gcId = new_value;
3050 DEBUG_ONLY(set_field_bit(0));
3051 }
3052 void set_type(u8 new_value) {
3053 this->_type = new_value;
3054 DEBUG_ONLY(set_field_bit(1));
3055 }
3056 void set_count(u8 new_value) {
3057 this->_count = new_value;
3058 DEBUG_ONLY(set_field_bit(2));
3059 }
3060
3061 template <typename Writer>
3062 void writeData(Writer& w) {
3063 w.write(_gcId);
3064 w.write(_type);
3065 w.write(_count);
3066 }
3067
3068 using JfrEvent<EventGCReferenceStatistics>::commit; // else commit() is hidden by overloaded versions in this class
3069
3070
3071
3072 static void commit(unsigned gcId,
3073 u8 type,
3074 u8 count) {
3075 EventGCReferenceStatistics me(UNTIMED);
3076
3077 if (me.should_commit()) {
3078 me.set_gcId(gcId);
3079 me.set_type(type);
3080 me.set_count(count);
3081 me.commit();
3082 }
3083 }
3084
3085#ifdef ASSERT
3086 void verify() const {
3087 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3088 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_type");
3089 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_count");
3090 }
3091#endif
3092};
3093
3094class EventObjectCountAfterGC : public JfrEvent<EventObjectCountAfterGC>
3095{
3096 private:
3097 unsigned _gcId;
3098 const Klass* _objectClass;
3099 s8 _count;
3100 u8 _totalSize;
3101
3102 public:
3103 static const bool hasThread = false;
3104 static const bool hasStackTrace = false;
3105 static const bool isInstant = true;
3106 static const bool hasCutoff = false;
3107 static const bool isRequestable = false;
3108 static const JfrEventId eventId = JfrObjectCountAfterGCEvent;
3109
3110 EventObjectCountAfterGC(EventStartTime timing=TIMED) : JfrEvent<EventObjectCountAfterGC>(timing) {}
3111
3112 void set_gcId(unsigned new_value) {
3113 this->_gcId = new_value;
3114 DEBUG_ONLY(set_field_bit(0));
3115 }
3116 void set_objectClass(const Klass* new_value) {
3117 this->_objectClass = new_value;
3118 DEBUG_ONLY(set_field_bit(1));
3119 }
3120 void set_count(s8 new_value) {
3121 this->_count = new_value;
3122 DEBUG_ONLY(set_field_bit(2));
3123 }
3124 void set_totalSize(u8 new_value) {
3125 this->_totalSize = new_value;
3126 DEBUG_ONLY(set_field_bit(3));
3127 }
3128
3129 template <typename Writer>
3130 void writeData(Writer& w) {
3131 w.write(_gcId);
3132 w.write(_objectClass);
3133 w.write(_count);
3134 w.write(_totalSize);
3135 }
3136
3137 using JfrEvent<EventObjectCountAfterGC>::commit; // else commit() is hidden by overloaded versions in this class
3138
3139
3140
3141 static void commit(unsigned gcId,
3142 const Klass* objectClass,
3143 s8 count,
3144 u8 totalSize) {
3145 EventObjectCountAfterGC me(UNTIMED);
3146
3147 if (me.should_commit()) {
3148 me.set_gcId(gcId);
3149 me.set_objectClass(objectClass);
3150 me.set_count(count);
3151 me.set_totalSize(totalSize);
3152 me.commit();
3153 }
3154 }
3155
3156#ifdef ASSERT
3157 void verify() const {
3158 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3159 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_objectClass");
3160 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_count");
3161 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_totalSize");
3162 }
3163#endif
3164};
3165
3166class EventG1EvacuationYoungStatistics : public JfrEvent<EventG1EvacuationYoungStatistics>
3167{
3168 private:
3169 JfrStructG1EvacuationStatistics _statistics;
3170
3171 public:
3172 static const bool hasThread = false;
3173 static const bool hasStackTrace = false;
3174 static const bool isInstant = true;
3175 static const bool hasCutoff = false;
3176 static const bool isRequestable = false;
3177 static const JfrEventId eventId = JfrG1EvacuationYoungStatisticsEvent;
3178
3179 EventG1EvacuationYoungStatistics(EventStartTime timing=TIMED) : JfrEvent<EventG1EvacuationYoungStatistics>(timing) {}
3180
3181 void set_statistics(const JfrStructG1EvacuationStatistics& value) {
3182 this->_statistics = value;
3183 DEBUG_ONLY(set_field_bit(0));
3184 }
3185
3186 template <typename Writer>
3187 void writeData(Writer& w) {
3188 _statistics.writeData(w);
3189 }
3190
3191 using JfrEvent<EventG1EvacuationYoungStatistics>::commit; // else commit() is hidden by overloaded versions in this class
3192
3193
3194
3195 static void commit(const JfrStructG1EvacuationStatistics& statistics) {
3196 EventG1EvacuationYoungStatistics me(UNTIMED);
3197
3198 if (me.should_commit()) {
3199 me.set_statistics(statistics);
3200 me.commit();
3201 }
3202 }
3203
3204#ifdef ASSERT
3205 void verify() const {
3206 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_statistics");
3207 }
3208#endif
3209};
3210
3211class EventG1EvacuationOldStatistics : public JfrEvent<EventG1EvacuationOldStatistics>
3212{
3213 private:
3214 JfrStructG1EvacuationStatistics _statistics;
3215
3216 public:
3217 static const bool hasThread = false;
3218 static const bool hasStackTrace = false;
3219 static const bool isInstant = true;
3220 static const bool hasCutoff = false;
3221 static const bool isRequestable = false;
3222 static const JfrEventId eventId = JfrG1EvacuationOldStatisticsEvent;
3223
3224 EventG1EvacuationOldStatistics(EventStartTime timing=TIMED) : JfrEvent<EventG1EvacuationOldStatistics>(timing) {}
3225
3226 void set_statistics(const JfrStructG1EvacuationStatistics& value) {
3227 this->_statistics = value;
3228 DEBUG_ONLY(set_field_bit(0));
3229 }
3230
3231 template <typename Writer>
3232 void writeData(Writer& w) {
3233 _statistics.writeData(w);
3234 }
3235
3236 using JfrEvent<EventG1EvacuationOldStatistics>::commit; // else commit() is hidden by overloaded versions in this class
3237
3238
3239
3240 static void commit(const JfrStructG1EvacuationStatistics& statistics) {
3241 EventG1EvacuationOldStatistics me(UNTIMED);
3242
3243 if (me.should_commit()) {
3244 me.set_statistics(statistics);
3245 me.commit();
3246 }
3247 }
3248
3249#ifdef ASSERT
3250 void verify() const {
3251 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_statistics");
3252 }
3253#endif
3254};
3255
3256class EventG1BasicIHOP : public JfrEvent<EventG1BasicIHOP>
3257{
3258 private:
3259 unsigned _gcId;
3260 u8 _threshold;
3261 float _thresholdPercentage;
3262 u8 _targetOccupancy;
3263 u8 _currentOccupancy;
3264 u8 _recentMutatorAllocationSize;
3265 s8 _recentMutatorDuration;
3266 double _recentAllocationRate;
3267 s8 _lastMarkingDuration;
3268
3269 public:
3270 static const bool hasThread = false;
3271 static const bool hasStackTrace = false;
3272 static const bool isInstant = true;
3273 static const bool hasCutoff = false;
3274 static const bool isRequestable = false;
3275 static const JfrEventId eventId = JfrG1BasicIHOPEvent;
3276
3277 EventG1BasicIHOP(EventStartTime timing=TIMED) : JfrEvent<EventG1BasicIHOP>(timing) {}
3278
3279 void set_gcId(unsigned new_value) {
3280 this->_gcId = new_value;
3281 DEBUG_ONLY(set_field_bit(0));
3282 }
3283 void set_threshold(u8 new_value) {
3284 this->_threshold = new_value;
3285 DEBUG_ONLY(set_field_bit(1));
3286 }
3287 void set_thresholdPercentage(float new_value) {
3288 this->_thresholdPercentage = new_value;
3289 DEBUG_ONLY(set_field_bit(2));
3290 }
3291 void set_targetOccupancy(u8 new_value) {
3292 this->_targetOccupancy = new_value;
3293 DEBUG_ONLY(set_field_bit(3));
3294 }
3295 void set_currentOccupancy(u8 new_value) {
3296 this->_currentOccupancy = new_value;
3297 DEBUG_ONLY(set_field_bit(4));
3298 }
3299 void set_recentMutatorAllocationSize(u8 new_value) {
3300 this->_recentMutatorAllocationSize = new_value;
3301 DEBUG_ONLY(set_field_bit(5));
3302 }
3303 void set_recentMutatorDuration(s8 new_value) {
3304 this->_recentMutatorDuration = new_value;
3305 DEBUG_ONLY(set_field_bit(6));
3306 }
3307 void set_recentAllocationRate(double new_value) {
3308 this->_recentAllocationRate = new_value;
3309 DEBUG_ONLY(set_field_bit(7));
3310 }
3311 void set_lastMarkingDuration(s8 new_value) {
3312 this->_lastMarkingDuration = new_value;
3313 DEBUG_ONLY(set_field_bit(8));
3314 }
3315
3316 template <typename Writer>
3317 void writeData(Writer& w) {
3318 w.write(_gcId);
3319 w.write(_threshold);
3320 w.write(_thresholdPercentage);
3321 w.write(_targetOccupancy);
3322 w.write(_currentOccupancy);
3323 w.write(_recentMutatorAllocationSize);
3324 w.write(_recentMutatorDuration);
3325 w.write(_recentAllocationRate);
3326 w.write(_lastMarkingDuration);
3327 }
3328
3329 using JfrEvent<EventG1BasicIHOP>::commit; // else commit() is hidden by overloaded versions in this class
3330
3331
3332
3333 static void commit(unsigned gcId,
3334 u8 threshold,
3335 float thresholdPercentage,
3336 u8 targetOccupancy,
3337 u8 currentOccupancy,
3338 u8 recentMutatorAllocationSize,
3339 s8 recentMutatorDuration,
3340 double recentAllocationRate,
3341 s8 lastMarkingDuration) {
3342 EventG1BasicIHOP me(UNTIMED);
3343
3344 if (me.should_commit()) {
3345 me.set_gcId(gcId);
3346 me.set_threshold(threshold);
3347 me.set_thresholdPercentage(thresholdPercentage);
3348 me.set_targetOccupancy(targetOccupancy);
3349 me.set_currentOccupancy(currentOccupancy);
3350 me.set_recentMutatorAllocationSize(recentMutatorAllocationSize);
3351 me.set_recentMutatorDuration(recentMutatorDuration);
3352 me.set_recentAllocationRate(recentAllocationRate);
3353 me.set_lastMarkingDuration(lastMarkingDuration);
3354 me.commit();
3355 }
3356 }
3357
3358#ifdef ASSERT
3359 void verify() const {
3360 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3361 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_threshold");
3362 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_thresholdPercentage");
3363 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_targetOccupancy");
3364 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_currentOccupancy");
3365 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_recentMutatorAllocationSize");
3366 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_recentMutatorDuration");
3367 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_recentAllocationRate");
3368 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_lastMarkingDuration");
3369 }
3370#endif
3371};
3372
3373class EventG1AdaptiveIHOP : public JfrEvent<EventG1AdaptiveIHOP>
3374{
3375 private:
3376 unsigned _gcId;
3377 u8 _threshold;
3378 float _thresholdPercentage;
3379 u8 _ihopTargetOccupancy;
3380 u8 _currentOccupancy;
3381 u8 _additionalBufferSize;
3382 double _predictedAllocationRate;
3383 s8 _predictedMarkingDuration;
3384 bool _predictionActive;
3385
3386 public:
3387 static const bool hasThread = false;
3388 static const bool hasStackTrace = false;
3389 static const bool isInstant = true;
3390 static const bool hasCutoff = false;
3391 static const bool isRequestable = false;
3392 static const JfrEventId eventId = JfrG1AdaptiveIHOPEvent;
3393
3394 EventG1AdaptiveIHOP(EventStartTime timing=TIMED) : JfrEvent<EventG1AdaptiveIHOP>(timing) {}
3395
3396 void set_gcId(unsigned new_value) {
3397 this->_gcId = new_value;
3398 DEBUG_ONLY(set_field_bit(0));
3399 }
3400 void set_threshold(u8 new_value) {
3401 this->_threshold = new_value;
3402 DEBUG_ONLY(set_field_bit(1));
3403 }
3404 void set_thresholdPercentage(float new_value) {
3405 this->_thresholdPercentage = new_value;
3406 DEBUG_ONLY(set_field_bit(2));
3407 }
3408 void set_ihopTargetOccupancy(u8 new_value) {
3409 this->_ihopTargetOccupancy = new_value;
3410 DEBUG_ONLY(set_field_bit(3));
3411 }
3412 void set_currentOccupancy(u8 new_value) {
3413 this->_currentOccupancy = new_value;
3414 DEBUG_ONLY(set_field_bit(4));
3415 }
3416 void set_additionalBufferSize(u8 new_value) {
3417 this->_additionalBufferSize = new_value;
3418 DEBUG_ONLY(set_field_bit(5));
3419 }
3420 void set_predictedAllocationRate(double new_value) {
3421 this->_predictedAllocationRate = new_value;
3422 DEBUG_ONLY(set_field_bit(6));
3423 }
3424 void set_predictedMarkingDuration(s8 new_value) {
3425 this->_predictedMarkingDuration = new_value;
3426 DEBUG_ONLY(set_field_bit(7));
3427 }
3428 void set_predictionActive(bool new_value) {
3429 this->_predictionActive = new_value;
3430 DEBUG_ONLY(set_field_bit(8));
3431 }
3432
3433 template <typename Writer>
3434 void writeData(Writer& w) {
3435 w.write(_gcId);
3436 w.write(_threshold);
3437 w.write(_thresholdPercentage);
3438 w.write(_ihopTargetOccupancy);
3439 w.write(_currentOccupancy);
3440 w.write(_additionalBufferSize);
3441 w.write(_predictedAllocationRate);
3442 w.write(_predictedMarkingDuration);
3443 w.write(_predictionActive);
3444 }
3445
3446 using JfrEvent<EventG1AdaptiveIHOP>::commit; // else commit() is hidden by overloaded versions in this class
3447
3448
3449
3450 static void commit(unsigned gcId,
3451 u8 threshold,
3452 float thresholdPercentage,
3453 u8 ihopTargetOccupancy,
3454 u8 currentOccupancy,
3455 u8 additionalBufferSize,
3456 double predictedAllocationRate,
3457 s8 predictedMarkingDuration,
3458 bool predictionActive) {
3459 EventG1AdaptiveIHOP me(UNTIMED);
3460
3461 if (me.should_commit()) {
3462 me.set_gcId(gcId);
3463 me.set_threshold(threshold);
3464 me.set_thresholdPercentage(thresholdPercentage);
3465 me.set_ihopTargetOccupancy(ihopTargetOccupancy);
3466 me.set_currentOccupancy(currentOccupancy);
3467 me.set_additionalBufferSize(additionalBufferSize);
3468 me.set_predictedAllocationRate(predictedAllocationRate);
3469 me.set_predictedMarkingDuration(predictedMarkingDuration);
3470 me.set_predictionActive(predictionActive);
3471 me.commit();
3472 }
3473 }
3474
3475#ifdef ASSERT
3476 void verify() const {
3477 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3478 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_threshold");
3479 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_thresholdPercentage");
3480 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_ihopTargetOccupancy");
3481 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_currentOccupancy");
3482 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_additionalBufferSize");
3483 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_predictedAllocationRate");
3484 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_predictedMarkingDuration");
3485 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_predictionActive");
3486 }
3487#endif
3488};
3489
3490class EventPromoteObjectInNewPLAB : public JfrEvent<EventPromoteObjectInNewPLAB>
3491{
3492 private:
3493 unsigned _gcId;
3494 const Klass* _objectClass;
3495 u8 _objectSize;
3496 unsigned _tenuringAge;
3497 bool _tenured;
3498 u8 _plabSize;
3499
3500 public:
3501 static const bool hasThread = true;
3502 static const bool hasStackTrace = false;
3503 static const bool isInstant = true;
3504 static const bool hasCutoff = false;
3505 static const bool isRequestable = false;
3506 static const JfrEventId eventId = JfrPromoteObjectInNewPLABEvent;
3507
3508 EventPromoteObjectInNewPLAB(EventStartTime timing=TIMED) : JfrEvent<EventPromoteObjectInNewPLAB>(timing) {}
3509
3510 void set_gcId(unsigned new_value) {
3511 this->_gcId = new_value;
3512 DEBUG_ONLY(set_field_bit(0));
3513 }
3514 void set_objectClass(const Klass* new_value) {
3515 this->_objectClass = new_value;
3516 DEBUG_ONLY(set_field_bit(1));
3517 }
3518 void set_objectSize(u8 new_value) {
3519 this->_objectSize = new_value;
3520 DEBUG_ONLY(set_field_bit(2));
3521 }
3522 void set_tenuringAge(unsigned new_value) {
3523 this->_tenuringAge = new_value;
3524 DEBUG_ONLY(set_field_bit(3));
3525 }
3526 void set_tenured(bool new_value) {
3527 this->_tenured = new_value;
3528 DEBUG_ONLY(set_field_bit(4));
3529 }
3530 void set_plabSize(u8 new_value) {
3531 this->_plabSize = new_value;
3532 DEBUG_ONLY(set_field_bit(5));
3533 }
3534
3535 template <typename Writer>
3536 void writeData(Writer& w) {
3537 w.write(_gcId);
3538 w.write(_objectClass);
3539 w.write(_objectSize);
3540 w.write(_tenuringAge);
3541 w.write(_tenured);
3542 w.write(_plabSize);
3543 }
3544
3545 using JfrEvent<EventPromoteObjectInNewPLAB>::commit; // else commit() is hidden by overloaded versions in this class
3546
3547
3548
3549 static void commit(unsigned gcId,
3550 const Klass* objectClass,
3551 u8 objectSize,
3552 unsigned tenuringAge,
3553 bool tenured,
3554 u8 plabSize) {
3555 EventPromoteObjectInNewPLAB me(UNTIMED);
3556
3557 if (me.should_commit()) {
3558 me.set_gcId(gcId);
3559 me.set_objectClass(objectClass);
3560 me.set_objectSize(objectSize);
3561 me.set_tenuringAge(tenuringAge);
3562 me.set_tenured(tenured);
3563 me.set_plabSize(plabSize);
3564 me.commit();
3565 }
3566 }
3567
3568#ifdef ASSERT
3569 void verify() const {
3570 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3571 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_objectClass");
3572 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_objectSize");
3573 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_tenuringAge");
3574 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_tenured");
3575 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_plabSize");
3576 }
3577#endif
3578};
3579
3580class EventPromoteObjectOutsidePLAB : public JfrEvent<EventPromoteObjectOutsidePLAB>
3581{
3582 private:
3583 unsigned _gcId;
3584 const Klass* _objectClass;
3585 u8 _objectSize;
3586 unsigned _tenuringAge;
3587 bool _tenured;
3588
3589 public:
3590 static const bool hasThread = true;
3591 static const bool hasStackTrace = false;
3592 static const bool isInstant = true;
3593 static const bool hasCutoff = false;
3594 static const bool isRequestable = false;
3595 static const JfrEventId eventId = JfrPromoteObjectOutsidePLABEvent;
3596
3597 EventPromoteObjectOutsidePLAB(EventStartTime timing=TIMED) : JfrEvent<EventPromoteObjectOutsidePLAB>(timing) {}
3598
3599 void set_gcId(unsigned new_value) {
3600 this->_gcId = new_value;
3601 DEBUG_ONLY(set_field_bit(0));
3602 }
3603 void set_objectClass(const Klass* new_value) {
3604 this->_objectClass = new_value;
3605 DEBUG_ONLY(set_field_bit(1));
3606 }
3607 void set_objectSize(u8 new_value) {
3608 this->_objectSize = new_value;
3609 DEBUG_ONLY(set_field_bit(2));
3610 }
3611 void set_tenuringAge(unsigned new_value) {
3612 this->_tenuringAge = new_value;
3613 DEBUG_ONLY(set_field_bit(3));
3614 }
3615 void set_tenured(bool new_value) {
3616 this->_tenured = new_value;
3617 DEBUG_ONLY(set_field_bit(4));
3618 }
3619
3620 template <typename Writer>
3621 void writeData(Writer& w) {
3622 w.write(_gcId);
3623 w.write(_objectClass);
3624 w.write(_objectSize);
3625 w.write(_tenuringAge);
3626 w.write(_tenured);
3627 }
3628
3629 using JfrEvent<EventPromoteObjectOutsidePLAB>::commit; // else commit() is hidden by overloaded versions in this class
3630
3631
3632
3633 static void commit(unsigned gcId,
3634 const Klass* objectClass,
3635 u8 objectSize,
3636 unsigned tenuringAge,
3637 bool tenured) {
3638 EventPromoteObjectOutsidePLAB me(UNTIMED);
3639
3640 if (me.should_commit()) {
3641 me.set_gcId(gcId);
3642 me.set_objectClass(objectClass);
3643 me.set_objectSize(objectSize);
3644 me.set_tenuringAge(tenuringAge);
3645 me.set_tenured(tenured);
3646 me.commit();
3647 }
3648 }
3649
3650#ifdef ASSERT
3651 void verify() const {
3652 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3653 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_objectClass");
3654 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_objectSize");
3655 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_tenuringAge");
3656 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_tenured");
3657 }
3658#endif
3659};
3660
3661class EventPromotionFailed : public JfrEvent<EventPromotionFailed>
3662{
3663 private:
3664 unsigned _gcId;
3665 JfrStructCopyFailed _promotionFailed;
3666 u8 _thread;
3667
3668 public:
3669 static const bool hasThread = false;
3670 static const bool hasStackTrace = false;
3671 static const bool isInstant = true;
3672 static const bool hasCutoff = false;
3673 static const bool isRequestable = false;
3674 static const JfrEventId eventId = JfrPromotionFailedEvent;
3675
3676 EventPromotionFailed(EventStartTime timing=TIMED) : JfrEvent<EventPromotionFailed>(timing) {}
3677
3678 void set_gcId(unsigned new_value) {
3679 this->_gcId = new_value;
3680 DEBUG_ONLY(set_field_bit(0));
3681 }
3682 void set_promotionFailed(const JfrStructCopyFailed& value) {
3683 this->_promotionFailed = value;
3684 DEBUG_ONLY(set_field_bit(1));
3685 }
3686 void set_thread(u8 new_value) {
3687 this->_thread = new_value;
3688 DEBUG_ONLY(set_field_bit(2));
3689 }
3690
3691 template <typename Writer>
3692 void writeData(Writer& w) {
3693 w.write(_gcId);
3694 _promotionFailed.writeData(w);
3695 w.write(_thread);
3696 }
3697
3698 using JfrEvent<EventPromotionFailed>::commit; // else commit() is hidden by overloaded versions in this class
3699
3700
3701
3702 static void commit(unsigned gcId,
3703 const JfrStructCopyFailed& promotionFailed,
3704 u8 thread) {
3705 EventPromotionFailed me(UNTIMED);
3706
3707 if (me.should_commit()) {
3708 me.set_gcId(gcId);
3709 me.set_promotionFailed(promotionFailed);
3710 me.set_thread(thread);
3711 me.commit();
3712 }
3713 }
3714
3715#ifdef ASSERT
3716 void verify() const {
3717 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3718 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_promotionFailed");
3719 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_thread");
3720 }
3721#endif
3722};
3723
3724class EventEvacuationFailed : public JfrEvent<EventEvacuationFailed>
3725{
3726 private:
3727 unsigned _gcId;
3728 JfrStructCopyFailed _evacuationFailed;
3729
3730 public:
3731 static const bool hasThread = false;
3732 static const bool hasStackTrace = false;
3733 static const bool isInstant = true;
3734 static const bool hasCutoff = false;
3735 static const bool isRequestable = false;
3736 static const JfrEventId eventId = JfrEvacuationFailedEvent;
3737
3738 EventEvacuationFailed(EventStartTime timing=TIMED) : JfrEvent<EventEvacuationFailed>(timing) {}
3739
3740 void set_gcId(unsigned new_value) {
3741 this->_gcId = new_value;
3742 DEBUG_ONLY(set_field_bit(0));
3743 }
3744 void set_evacuationFailed(const JfrStructCopyFailed& value) {
3745 this->_evacuationFailed = value;
3746 DEBUG_ONLY(set_field_bit(1));
3747 }
3748
3749 template <typename Writer>
3750 void writeData(Writer& w) {
3751 w.write(_gcId);
3752 _evacuationFailed.writeData(w);
3753 }
3754
3755 using JfrEvent<EventEvacuationFailed>::commit; // else commit() is hidden by overloaded versions in this class
3756
3757
3758
3759 static void commit(unsigned gcId,
3760 const JfrStructCopyFailed& evacuationFailed) {
3761 EventEvacuationFailed me(UNTIMED);
3762
3763 if (me.should_commit()) {
3764 me.set_gcId(gcId);
3765 me.set_evacuationFailed(evacuationFailed);
3766 me.commit();
3767 }
3768 }
3769
3770#ifdef ASSERT
3771 void verify() const {
3772 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3773 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_evacuationFailed");
3774 }
3775#endif
3776};
3777
3778class EventConcurrentModeFailure : public JfrEvent<EventConcurrentModeFailure>
3779{
3780 private:
3781 unsigned _gcId;
3782
3783 public:
3784 static const bool hasThread = false;
3785 static const bool hasStackTrace = false;
3786 static const bool isInstant = true;
3787 static const bool hasCutoff = false;
3788 static const bool isRequestable = false;
3789 static const JfrEventId eventId = JfrConcurrentModeFailureEvent;
3790
3791 EventConcurrentModeFailure(EventStartTime timing=TIMED) : JfrEvent<EventConcurrentModeFailure>(timing) {}
3792
3793 void set_gcId(unsigned new_value) {
3794 this->_gcId = new_value;
3795 DEBUG_ONLY(set_field_bit(0));
3796 }
3797
3798 template <typename Writer>
3799 void writeData(Writer& w) {
3800 w.write(_gcId);
3801 }
3802
3803 using JfrEvent<EventConcurrentModeFailure>::commit; // else commit() is hidden by overloaded versions in this class
3804
3805
3806
3807 static void commit(unsigned gcId) {
3808 EventConcurrentModeFailure me(UNTIMED);
3809
3810 if (me.should_commit()) {
3811 me.set_gcId(gcId);
3812 me.commit();
3813 }
3814 }
3815
3816#ifdef ASSERT
3817 void verify() const {
3818 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3819 }
3820#endif
3821};
3822
3823class EventGCPhasePause : public JfrEvent<EventGCPhasePause>
3824{
3825 private:
3826 unsigned _gcId;
3827 const char* _name;
3828
3829 public:
3830 static const bool hasThread = true;
3831 static const bool hasStackTrace = false;
3832 static const bool isInstant = false;
3833 static const bool hasCutoff = false;
3834 static const bool isRequestable = false;
3835 static const JfrEventId eventId = JfrGCPhasePauseEvent;
3836
3837 EventGCPhasePause(EventStartTime timing=TIMED) : JfrEvent<EventGCPhasePause>(timing) {}
3838
3839 void set_gcId(unsigned new_value) {
3840 this->_gcId = new_value;
3841 DEBUG_ONLY(set_field_bit(0));
3842 }
3843 void set_name(const char* new_value) {
3844 this->_name = new_value;
3845 DEBUG_ONLY(set_field_bit(1));
3846 }
3847
3848 template <typename Writer>
3849 void writeData(Writer& w) {
3850 w.write(_gcId);
3851 w.write(_name);
3852 }
3853
3854 using JfrEvent<EventGCPhasePause>::commit; // else commit() is hidden by overloaded versions in this class
3855
3856 EventGCPhasePause(
3857 unsigned gcId,
3858 const char* name) : JfrEvent<EventGCPhasePause>(TIMED) {
3859 if (should_commit()) {
3860 set_gcId(gcId);
3861 set_name(name);
3862 }
3863 }
3864
3865 void commit(unsigned gcId,
3866 const char* name) {
3867 if (should_commit()) {
3868 set_gcId(gcId);
3869 set_name(name);
3870 commit();
3871 }
3872 }
3873
3874 static void commit(const Ticks& startTicks,
3875 const Ticks& endTicks,
3876 unsigned gcId,
3877 const char* name) {
3878 EventGCPhasePause me(UNTIMED);
3879
3880 if (me.should_commit()) {
3881 me.set_starttime(startTicks);
3882 me.set_endtime(endTicks);
3883 me.set_gcId(gcId);
3884 me.set_name(name);
3885 me.commit();
3886 }
3887 }
3888
3889#ifdef ASSERT
3890 void verify() const {
3891 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3892 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
3893 }
3894#endif
3895};
3896
3897class EventGCPhasePauseLevel1 : public JfrEvent<EventGCPhasePauseLevel1>
3898{
3899 private:
3900 unsigned _gcId;
3901 const char* _name;
3902
3903 public:
3904 static const bool hasThread = true;
3905 static const bool hasStackTrace = false;
3906 static const bool isInstant = false;
3907 static const bool hasCutoff = false;
3908 static const bool isRequestable = false;
3909 static const JfrEventId eventId = JfrGCPhasePauseLevel1Event;
3910
3911 EventGCPhasePauseLevel1(EventStartTime timing=TIMED) : JfrEvent<EventGCPhasePauseLevel1>(timing) {}
3912
3913 void set_gcId(unsigned new_value) {
3914 this->_gcId = new_value;
3915 DEBUG_ONLY(set_field_bit(0));
3916 }
3917 void set_name(const char* new_value) {
3918 this->_name = new_value;
3919 DEBUG_ONLY(set_field_bit(1));
3920 }
3921
3922 template <typename Writer>
3923 void writeData(Writer& w) {
3924 w.write(_gcId);
3925 w.write(_name);
3926 }
3927
3928 using JfrEvent<EventGCPhasePauseLevel1>::commit; // else commit() is hidden by overloaded versions in this class
3929
3930 EventGCPhasePauseLevel1(
3931 unsigned gcId,
3932 const char* name) : JfrEvent<EventGCPhasePauseLevel1>(TIMED) {
3933 if (should_commit()) {
3934 set_gcId(gcId);
3935 set_name(name);
3936 }
3937 }
3938
3939 void commit(unsigned gcId,
3940 const char* name) {
3941 if (should_commit()) {
3942 set_gcId(gcId);
3943 set_name(name);
3944 commit();
3945 }
3946 }
3947
3948 static void commit(const Ticks& startTicks,
3949 const Ticks& endTicks,
3950 unsigned gcId,
3951 const char* name) {
3952 EventGCPhasePauseLevel1 me(UNTIMED);
3953
3954 if (me.should_commit()) {
3955 me.set_starttime(startTicks);
3956 me.set_endtime(endTicks);
3957 me.set_gcId(gcId);
3958 me.set_name(name);
3959 me.commit();
3960 }
3961 }
3962
3963#ifdef ASSERT
3964 void verify() const {
3965 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
3966 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
3967 }
3968#endif
3969};
3970
3971class EventGCPhasePauseLevel2 : public JfrEvent<EventGCPhasePauseLevel2>
3972{
3973 private:
3974 unsigned _gcId;
3975 const char* _name;
3976
3977 public:
3978 static const bool hasThread = true;
3979 static const bool hasStackTrace = false;
3980 static const bool isInstant = false;
3981 static const bool hasCutoff = false;
3982 static const bool isRequestable = false;
3983 static const JfrEventId eventId = JfrGCPhasePauseLevel2Event;
3984
3985 EventGCPhasePauseLevel2(EventStartTime timing=TIMED) : JfrEvent<EventGCPhasePauseLevel2>(timing) {}
3986
3987 void set_gcId(unsigned new_value) {
3988 this->_gcId = new_value;
3989 DEBUG_ONLY(set_field_bit(0));
3990 }
3991 void set_name(const char* new_value) {
3992 this->_name = new_value;
3993 DEBUG_ONLY(set_field_bit(1));
3994 }
3995
3996 template <typename Writer>
3997 void writeData(Writer& w) {
3998 w.write(_gcId);
3999 w.write(_name);
4000 }
4001
4002 using JfrEvent<EventGCPhasePauseLevel2>::commit; // else commit() is hidden by overloaded versions in this class
4003
4004 EventGCPhasePauseLevel2(
4005 unsigned gcId,
4006 const char* name) : JfrEvent<EventGCPhasePauseLevel2>(TIMED) {
4007 if (should_commit()) {
4008 set_gcId(gcId);
4009 set_name(name);
4010 }
4011 }
4012
4013 void commit(unsigned gcId,
4014 const char* name) {
4015 if (should_commit()) {
4016 set_gcId(gcId);
4017 set_name(name);
4018 commit();
4019 }
4020 }
4021
4022 static void commit(const Ticks& startTicks,
4023 const Ticks& endTicks,
4024 unsigned gcId,
4025 const char* name) {
4026 EventGCPhasePauseLevel2 me(UNTIMED);
4027
4028 if (me.should_commit()) {
4029 me.set_starttime(startTicks);
4030 me.set_endtime(endTicks);
4031 me.set_gcId(gcId);
4032 me.set_name(name);
4033 me.commit();
4034 }
4035 }
4036
4037#ifdef ASSERT
4038 void verify() const {
4039 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4040 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
4041 }
4042#endif
4043};
4044
4045class EventGCPhasePauseLevel3 : public JfrEvent<EventGCPhasePauseLevel3>
4046{
4047 private:
4048 unsigned _gcId;
4049 const char* _name;
4050
4051 public:
4052 static const bool hasThread = true;
4053 static const bool hasStackTrace = false;
4054 static const bool isInstant = false;
4055 static const bool hasCutoff = false;
4056 static const bool isRequestable = false;
4057 static const JfrEventId eventId = JfrGCPhasePauseLevel3Event;
4058
4059 EventGCPhasePauseLevel3(EventStartTime timing=TIMED) : JfrEvent<EventGCPhasePauseLevel3>(timing) {}
4060
4061 void set_gcId(unsigned new_value) {
4062 this->_gcId = new_value;
4063 DEBUG_ONLY(set_field_bit(0));
4064 }
4065 void set_name(const char* new_value) {
4066 this->_name = new_value;
4067 DEBUG_ONLY(set_field_bit(1));
4068 }
4069
4070 template <typename Writer>
4071 void writeData(Writer& w) {
4072 w.write(_gcId);
4073 w.write(_name);
4074 }
4075
4076 using JfrEvent<EventGCPhasePauseLevel3>::commit; // else commit() is hidden by overloaded versions in this class
4077
4078 EventGCPhasePauseLevel3(
4079 unsigned gcId,
4080 const char* name) : JfrEvent<EventGCPhasePauseLevel3>(TIMED) {
4081 if (should_commit()) {
4082 set_gcId(gcId);
4083 set_name(name);
4084 }
4085 }
4086
4087 void commit(unsigned gcId,
4088 const char* name) {
4089 if (should_commit()) {
4090 set_gcId(gcId);
4091 set_name(name);
4092 commit();
4093 }
4094 }
4095
4096 static void commit(const Ticks& startTicks,
4097 const Ticks& endTicks,
4098 unsigned gcId,
4099 const char* name) {
4100 EventGCPhasePauseLevel3 me(UNTIMED);
4101
4102 if (me.should_commit()) {
4103 me.set_starttime(startTicks);
4104 me.set_endtime(endTicks);
4105 me.set_gcId(gcId);
4106 me.set_name(name);
4107 me.commit();
4108 }
4109 }
4110
4111#ifdef ASSERT
4112 void verify() const {
4113 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4114 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
4115 }
4116#endif
4117};
4118
4119class EventGCPhasePauseLevel4 : public JfrEvent<EventGCPhasePauseLevel4>
4120{
4121 private:
4122 unsigned _gcId;
4123 const char* _name;
4124
4125 public:
4126 static const bool hasThread = true;
4127 static const bool hasStackTrace = false;
4128 static const bool isInstant = false;
4129 static const bool hasCutoff = false;
4130 static const bool isRequestable = false;
4131 static const JfrEventId eventId = JfrGCPhasePauseLevel4Event;
4132
4133 EventGCPhasePauseLevel4(EventStartTime timing=TIMED) : JfrEvent<EventGCPhasePauseLevel4>(timing) {}
4134
4135 void set_gcId(unsigned new_value) {
4136 this->_gcId = new_value;
4137 DEBUG_ONLY(set_field_bit(0));
4138 }
4139 void set_name(const char* new_value) {
4140 this->_name = new_value;
4141 DEBUG_ONLY(set_field_bit(1));
4142 }
4143
4144 template <typename Writer>
4145 void writeData(Writer& w) {
4146 w.write(_gcId);
4147 w.write(_name);
4148 }
4149
4150 using JfrEvent<EventGCPhasePauseLevel4>::commit; // else commit() is hidden by overloaded versions in this class
4151
4152 EventGCPhasePauseLevel4(
4153 unsigned gcId,
4154 const char* name) : JfrEvent<EventGCPhasePauseLevel4>(TIMED) {
4155 if (should_commit()) {
4156 set_gcId(gcId);
4157 set_name(name);
4158 }
4159 }
4160
4161 void commit(unsigned gcId,
4162 const char* name) {
4163 if (should_commit()) {
4164 set_gcId(gcId);
4165 set_name(name);
4166 commit();
4167 }
4168 }
4169
4170 static void commit(const Ticks& startTicks,
4171 const Ticks& endTicks,
4172 unsigned gcId,
4173 const char* name) {
4174 EventGCPhasePauseLevel4 me(UNTIMED);
4175
4176 if (me.should_commit()) {
4177 me.set_starttime(startTicks);
4178 me.set_endtime(endTicks);
4179 me.set_gcId(gcId);
4180 me.set_name(name);
4181 me.commit();
4182 }
4183 }
4184
4185#ifdef ASSERT
4186 void verify() const {
4187 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4188 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
4189 }
4190#endif
4191};
4192
4193class EventGCPhaseConcurrent : public JfrEvent<EventGCPhaseConcurrent>
4194{
4195 private:
4196 unsigned _gcId;
4197 const char* _name;
4198
4199 public:
4200 static const bool hasThread = true;
4201 static const bool hasStackTrace = false;
4202 static const bool isInstant = false;
4203 static const bool hasCutoff = false;
4204 static const bool isRequestable = false;
4205 static const JfrEventId eventId = JfrGCPhaseConcurrentEvent;
4206
4207 EventGCPhaseConcurrent(EventStartTime timing=TIMED) : JfrEvent<EventGCPhaseConcurrent>(timing) {}
4208
4209 void set_gcId(unsigned new_value) {
4210 this->_gcId = new_value;
4211 DEBUG_ONLY(set_field_bit(0));
4212 }
4213 void set_name(const char* new_value) {
4214 this->_name = new_value;
4215 DEBUG_ONLY(set_field_bit(1));
4216 }
4217
4218 template <typename Writer>
4219 void writeData(Writer& w) {
4220 w.write(_gcId);
4221 w.write(_name);
4222 }
4223
4224 using JfrEvent<EventGCPhaseConcurrent>::commit; // else commit() is hidden by overloaded versions in this class
4225
4226 EventGCPhaseConcurrent(
4227 unsigned gcId,
4228 const char* name) : JfrEvent<EventGCPhaseConcurrent>(TIMED) {
4229 if (should_commit()) {
4230 set_gcId(gcId);
4231 set_name(name);
4232 }
4233 }
4234
4235 void commit(unsigned gcId,
4236 const char* name) {
4237 if (should_commit()) {
4238 set_gcId(gcId);
4239 set_name(name);
4240 commit();
4241 }
4242 }
4243
4244 static void commit(const Ticks& startTicks,
4245 const Ticks& endTicks,
4246 unsigned gcId,
4247 const char* name) {
4248 EventGCPhaseConcurrent me(UNTIMED);
4249
4250 if (me.should_commit()) {
4251 me.set_starttime(startTicks);
4252 me.set_endtime(endTicks);
4253 me.set_gcId(gcId);
4254 me.set_name(name);
4255 me.commit();
4256 }
4257 }
4258
4259#ifdef ASSERT
4260 void verify() const {
4261 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4262 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
4263 }
4264#endif
4265};
4266
4267class EventGCPhaseParallel : public JfrEvent<EventGCPhaseParallel>
4268{
4269 private:
4270 unsigned _gcId;
4271 unsigned _gcWorkerId;
4272 const char* _name;
4273
4274 public:
4275 static const bool hasThread = true;
4276 static const bool hasStackTrace = false;
4277 static const bool isInstant = false;
4278 static const bool hasCutoff = false;
4279 static const bool isRequestable = false;
4280 static const JfrEventId eventId = JfrGCPhaseParallelEvent;
4281
4282 EventGCPhaseParallel(EventStartTime timing=TIMED) : JfrEvent<EventGCPhaseParallel>(timing) {}
4283
4284 void set_gcId(unsigned new_value) {
4285 this->_gcId = new_value;
4286 DEBUG_ONLY(set_field_bit(0));
4287 }
4288 void set_gcWorkerId(unsigned new_value) {
4289 this->_gcWorkerId = new_value;
4290 DEBUG_ONLY(set_field_bit(1));
4291 }
4292 void set_name(const char* new_value) {
4293 this->_name = new_value;
4294 DEBUG_ONLY(set_field_bit(2));
4295 }
4296
4297 template <typename Writer>
4298 void writeData(Writer& w) {
4299 w.write(_gcId);
4300 w.write(_gcWorkerId);
4301 w.write(_name);
4302 }
4303
4304 using JfrEvent<EventGCPhaseParallel>::commit; // else commit() is hidden by overloaded versions in this class
4305
4306 EventGCPhaseParallel(
4307 unsigned gcId,
4308 unsigned gcWorkerId,
4309 const char* name) : JfrEvent<EventGCPhaseParallel>(TIMED) {
4310 if (should_commit()) {
4311 set_gcId(gcId);
4312 set_gcWorkerId(gcWorkerId);
4313 set_name(name);
4314 }
4315 }
4316
4317 void commit(unsigned gcId,
4318 unsigned gcWorkerId,
4319 const char* name) {
4320 if (should_commit()) {
4321 set_gcId(gcId);
4322 set_gcWorkerId(gcWorkerId);
4323 set_name(name);
4324 commit();
4325 }
4326 }
4327
4328 static void commit(const Ticks& startTicks,
4329 const Ticks& endTicks,
4330 unsigned gcId,
4331 unsigned gcWorkerId,
4332 const char* name) {
4333 EventGCPhaseParallel me(UNTIMED);
4334
4335 if (me.should_commit()) {
4336 me.set_starttime(startTicks);
4337 me.set_endtime(endTicks);
4338 me.set_gcId(gcId);
4339 me.set_gcWorkerId(gcWorkerId);
4340 me.set_name(name);
4341 me.commit();
4342 }
4343 }
4344
4345#ifdef ASSERT
4346 void verify() const {
4347 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4348 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_gcWorkerId");
4349 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_name");
4350 }
4351#endif
4352};
4353
4354class EventAllocationRequiringGC : public JfrEvent<EventAllocationRequiringGC>
4355{
4356 private:
4357 unsigned _gcId;
4358 u8 _size;
4359
4360 public:
4361 static const bool hasThread = true;
4362 static const bool hasStackTrace = true;
4363 static const bool isInstant = true;
4364 static const bool hasCutoff = false;
4365 static const bool isRequestable = false;
4366 static const JfrEventId eventId = JfrAllocationRequiringGCEvent;
4367
4368 EventAllocationRequiringGC(EventStartTime timing=TIMED) : JfrEvent<EventAllocationRequiringGC>(timing) {}
4369
4370 void set_gcId(unsigned new_value) {
4371 this->_gcId = new_value;
4372 DEBUG_ONLY(set_field_bit(0));
4373 }
4374 void set_size(u8 new_value) {
4375 this->_size = new_value;
4376 DEBUG_ONLY(set_field_bit(1));
4377 }
4378
4379 template <typename Writer>
4380 void writeData(Writer& w) {
4381 w.write(_gcId);
4382 w.write(_size);
4383 }
4384
4385 using JfrEvent<EventAllocationRequiringGC>::commit; // else commit() is hidden by overloaded versions in this class
4386
4387
4388
4389 static void commit(unsigned gcId,
4390 u8 size) {
4391 EventAllocationRequiringGC me(UNTIMED);
4392
4393 if (me.should_commit()) {
4394 me.set_gcId(gcId);
4395 me.set_size(size);
4396 me.commit();
4397 }
4398 }
4399
4400#ifdef ASSERT
4401 void verify() const {
4402 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4403 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_size");
4404 }
4405#endif
4406};
4407
4408class EventTenuringDistribution : public JfrEvent<EventTenuringDistribution>
4409{
4410 private:
4411 unsigned _gcId;
4412 unsigned _age;
4413 u8 _size;
4414
4415 public:
4416 static const bool hasThread = false;
4417 static const bool hasStackTrace = false;
4418 static const bool isInstant = true;
4419 static const bool hasCutoff = false;
4420 static const bool isRequestable = false;
4421 static const JfrEventId eventId = JfrTenuringDistributionEvent;
4422
4423 EventTenuringDistribution(EventStartTime timing=TIMED) : JfrEvent<EventTenuringDistribution>(timing) {}
4424
4425 void set_gcId(unsigned new_value) {
4426 this->_gcId = new_value;
4427 DEBUG_ONLY(set_field_bit(0));
4428 }
4429 void set_age(unsigned new_value) {
4430 this->_age = new_value;
4431 DEBUG_ONLY(set_field_bit(1));
4432 }
4433 void set_size(u8 new_value) {
4434 this->_size = new_value;
4435 DEBUG_ONLY(set_field_bit(2));
4436 }
4437
4438 template <typename Writer>
4439 void writeData(Writer& w) {
4440 w.write(_gcId);
4441 w.write(_age);
4442 w.write(_size);
4443 }
4444
4445 using JfrEvent<EventTenuringDistribution>::commit; // else commit() is hidden by overloaded versions in this class
4446
4447
4448
4449 static void commit(unsigned gcId,
4450 unsigned age,
4451 u8 size) {
4452 EventTenuringDistribution me(UNTIMED);
4453
4454 if (me.should_commit()) {
4455 me.set_gcId(gcId);
4456 me.set_age(age);
4457 me.set_size(size);
4458 me.commit();
4459 }
4460 }
4461
4462#ifdef ASSERT
4463 void verify() const {
4464 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
4465 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_age");
4466 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_size");
4467 }
4468#endif
4469};
4470
4471class EventG1HeapRegionTypeChange : public JfrEvent<EventG1HeapRegionTypeChange>
4472{
4473 private:
4474 unsigned _index;
4475 u8 _from;
4476 u8 _to;
4477 u8 _start;
4478 u8 _used;
4479
4480 public:
4481 static const bool hasThread = false;
4482 static const bool hasStackTrace = false;
4483 static const bool isInstant = true;
4484 static const bool hasCutoff = false;
4485 static const bool isRequestable = false;
4486 static const JfrEventId eventId = JfrG1HeapRegionTypeChangeEvent;
4487
4488 EventG1HeapRegionTypeChange(EventStartTime timing=TIMED) : JfrEvent<EventG1HeapRegionTypeChange>(timing) {}
4489
4490 void set_index(unsigned new_value) {
4491 this->_index = new_value;
4492 DEBUG_ONLY(set_field_bit(0));
4493 }
4494 void set_from(u8 new_value) {
4495 this->_from = new_value;
4496 DEBUG_ONLY(set_field_bit(1));
4497 }
4498 void set_to(u8 new_value) {
4499 this->_to = new_value;
4500 DEBUG_ONLY(set_field_bit(2));
4501 }
4502 void set_start(u8 new_value) {
4503 this->_start = new_value;
4504 DEBUG_ONLY(set_field_bit(3));
4505 }
4506 void set_used(u8 new_value) {
4507 this->_used = new_value;
4508 DEBUG_ONLY(set_field_bit(4));
4509 }
4510
4511 template <typename Writer>
4512 void writeData(Writer& w) {
4513 w.write(_index);
4514 w.write(_from);
4515 w.write(_to);
4516 w.write(_start);
4517 w.write(_used);
4518 }
4519
4520 using JfrEvent<EventG1HeapRegionTypeChange>::commit; // else commit() is hidden by overloaded versions in this class
4521
4522
4523
4524 static void commit(unsigned index,
4525 u8 from,
4526 u8 to,
4527 u8 start,
4528 u8 used) {
4529 EventG1HeapRegionTypeChange me(UNTIMED);
4530
4531 if (me.should_commit()) {
4532 me.set_index(index);
4533 me.set_from(from);
4534 me.set_to(to);
4535 me.set_start(start);
4536 me.set_used(used);
4537 me.commit();
4538 }
4539 }
4540
4541#ifdef ASSERT
4542 void verify() const {
4543 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_index");
4544 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_from");
4545 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_to");
4546 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_start");
4547 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_used");
4548 }
4549#endif
4550};
4551
4552class EventCompilation : public JfrEvent<EventCompilation>
4553{
4554 private:
4555 const Method* _method;
4556 unsigned _compileId;
4557 u2 _compileLevel;
4558 bool _succeded;
4559 bool _isOsr;
4560 u8 _codeSize;
4561 u8 _inlinedBytes;
4562
4563 public:
4564 static const bool hasThread = true;
4565 static const bool hasStackTrace = false;
4566 static const bool isInstant = false;
4567 static const bool hasCutoff = false;
4568 static const bool isRequestable = false;
4569 static const JfrEventId eventId = JfrCompilationEvent;
4570
4571 EventCompilation(EventStartTime timing=TIMED) : JfrEvent<EventCompilation>(timing) {}
4572
4573 void set_method(const Method* new_value) {
4574 this->_method = new_value;
4575 DEBUG_ONLY(set_field_bit(0));
4576 }
4577 void set_compileId(unsigned new_value) {
4578 this->_compileId = new_value;
4579 DEBUG_ONLY(set_field_bit(1));
4580 }
4581 void set_compileLevel(u2 new_value) {
4582 this->_compileLevel = new_value;
4583 DEBUG_ONLY(set_field_bit(2));
4584 }
4585 void set_succeded(bool new_value) {
4586 this->_succeded = new_value;
4587 DEBUG_ONLY(set_field_bit(3));
4588 }
4589 void set_isOsr(bool new_value) {
4590 this->_isOsr = new_value;
4591 DEBUG_ONLY(set_field_bit(4));
4592 }
4593 void set_codeSize(u8 new_value) {
4594 this->_codeSize = new_value;
4595 DEBUG_ONLY(set_field_bit(5));
4596 }
4597 void set_inlinedBytes(u8 new_value) {
4598 this->_inlinedBytes = new_value;
4599 DEBUG_ONLY(set_field_bit(6));
4600 }
4601
4602 template <typename Writer>
4603 void writeData(Writer& w) {
4604 w.write(_method);
4605 w.write(_compileId);
4606 w.write(_compileLevel);
4607 w.write(_succeded);
4608 w.write(_isOsr);
4609 w.write(_codeSize);
4610 w.write(_inlinedBytes);
4611 }
4612
4613 using JfrEvent<EventCompilation>::commit; // else commit() is hidden by overloaded versions in this class
4614
4615 EventCompilation(
4616 const Method* method,
4617 unsigned compileId,
4618 u2 compileLevel,
4619 bool succeded,
4620 bool isOsr,
4621 u8 codeSize,
4622 u8 inlinedBytes) : JfrEvent<EventCompilation>(TIMED) {
4623 if (should_commit()) {
4624 set_method(method);
4625 set_compileId(compileId);
4626 set_compileLevel(compileLevel);
4627 set_succeded(succeded);
4628 set_isOsr(isOsr);
4629 set_codeSize(codeSize);
4630 set_inlinedBytes(inlinedBytes);
4631 }
4632 }
4633
4634 void commit(const Method* method,
4635 unsigned compileId,
4636 u2 compileLevel,
4637 bool succeded,
4638 bool isOsr,
4639 u8 codeSize,
4640 u8 inlinedBytes) {
4641 if (should_commit()) {
4642 set_method(method);
4643 set_compileId(compileId);
4644 set_compileLevel(compileLevel);
4645 set_succeded(succeded);
4646 set_isOsr(isOsr);
4647 set_codeSize(codeSize);
4648 set_inlinedBytes(inlinedBytes);
4649 commit();
4650 }
4651 }
4652
4653 static void commit(const Ticks& startTicks,
4654 const Ticks& endTicks,
4655 const Method* method,
4656 unsigned compileId,
4657 u2 compileLevel,
4658 bool succeded,
4659 bool isOsr,
4660 u8 codeSize,
4661 u8 inlinedBytes) {
4662 EventCompilation me(UNTIMED);
4663
4664 if (me.should_commit()) {
4665 me.set_starttime(startTicks);
4666 me.set_endtime(endTicks);
4667 me.set_method(method);
4668 me.set_compileId(compileId);
4669 me.set_compileLevel(compileLevel);
4670 me.set_succeded(succeded);
4671 me.set_isOsr(isOsr);
4672 me.set_codeSize(codeSize);
4673 me.set_inlinedBytes(inlinedBytes);
4674 me.commit();
4675 }
4676 }
4677
4678#ifdef ASSERT
4679 void verify() const {
4680 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_method");
4681 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_compileId");
4682 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_compileLevel");
4683 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_succeded");
4684 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_isOsr");
4685 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_codeSize");
4686 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_inlinedBytes");
4687 }
4688#endif
4689};
4690
4691class EventCompilerPhase : public JfrEvent<EventCompilerPhase>
4692{
4693 private:
4694 u8 _phase;
4695 unsigned _compileId;
4696 u2 _phaseLevel;
4697
4698 public:
4699 static const bool hasThread = true;
4700 static const bool hasStackTrace = false;
4701 static const bool isInstant = false;
4702 static const bool hasCutoff = false;
4703 static const bool isRequestable = false;
4704 static const JfrEventId eventId = JfrCompilerPhaseEvent;
4705
4706 EventCompilerPhase(EventStartTime timing=TIMED) : JfrEvent<EventCompilerPhase>(timing) {}
4707
4708 void set_phase(u8 new_value) {
4709 this->_phase = new_value;
4710 DEBUG_ONLY(set_field_bit(0));
4711 }
4712 void set_compileId(unsigned new_value) {
4713 this->_compileId = new_value;
4714 DEBUG_ONLY(set_field_bit(1));
4715 }
4716 void set_phaseLevel(u2 new_value) {
4717 this->_phaseLevel = new_value;
4718 DEBUG_ONLY(set_field_bit(2));
4719 }
4720
4721 template <typename Writer>
4722 void writeData(Writer& w) {
4723 w.write(_phase);
4724 w.write(_compileId);
4725 w.write(_phaseLevel);
4726 }
4727
4728 using JfrEvent<EventCompilerPhase>::commit; // else commit() is hidden by overloaded versions in this class
4729
4730 EventCompilerPhase(
4731 u8 phase,
4732 unsigned compileId,
4733 u2 phaseLevel) : JfrEvent<EventCompilerPhase>(TIMED) {
4734 if (should_commit()) {
4735 set_phase(phase);
4736 set_compileId(compileId);
4737 set_phaseLevel(phaseLevel);
4738 }
4739 }
4740
4741 void commit(u8 phase,
4742 unsigned compileId,
4743 u2 phaseLevel) {
4744 if (should_commit()) {
4745 set_phase(phase);
4746 set_compileId(compileId);
4747 set_phaseLevel(phaseLevel);
4748 commit();
4749 }
4750 }
4751
4752 static void commit(const Ticks& startTicks,
4753 const Ticks& endTicks,
4754 u8 phase,
4755 unsigned compileId,
4756 u2 phaseLevel) {
4757 EventCompilerPhase me(UNTIMED);
4758
4759 if (me.should_commit()) {
4760 me.set_starttime(startTicks);
4761 me.set_endtime(endTicks);
4762 me.set_phase(phase);
4763 me.set_compileId(compileId);
4764 me.set_phaseLevel(phaseLevel);
4765 me.commit();
4766 }
4767 }
4768
4769#ifdef ASSERT
4770 void verify() const {
4771 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_phase");
4772 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_compileId");
4773 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_phaseLevel");
4774 }
4775#endif
4776};
4777
4778class EventCompilationFailure : public JfrEvent<EventCompilationFailure>
4779{
4780 private:
4781 const char* _failureMessage;
4782 unsigned _compileId;
4783
4784 public:
4785 static const bool hasThread = true;
4786 static const bool hasStackTrace = false;
4787 static const bool isInstant = true;
4788 static const bool hasCutoff = false;
4789 static const bool isRequestable = false;
4790 static const JfrEventId eventId = JfrCompilationFailureEvent;
4791
4792 EventCompilationFailure(EventStartTime timing=TIMED) : JfrEvent<EventCompilationFailure>(timing) {}
4793
4794 void set_failureMessage(const char* new_value) {
4795 this->_failureMessage = new_value;
4796 DEBUG_ONLY(set_field_bit(0));
4797 }
4798 void set_compileId(unsigned new_value) {
4799 this->_compileId = new_value;
4800 DEBUG_ONLY(set_field_bit(1));
4801 }
4802
4803 template <typename Writer>
4804 void writeData(Writer& w) {
4805 w.write(_failureMessage);
4806 w.write(_compileId);
4807 }
4808
4809 using JfrEvent<EventCompilationFailure>::commit; // else commit() is hidden by overloaded versions in this class
4810
4811
4812
4813 static void commit(const char* failureMessage,
4814 unsigned compileId) {
4815 EventCompilationFailure me(UNTIMED);
4816
4817 if (me.should_commit()) {
4818 me.set_failureMessage(failureMessage);
4819 me.set_compileId(compileId);
4820 me.commit();
4821 }
4822 }
4823
4824#ifdef ASSERT
4825 void verify() const {
4826 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_failureMessage");
4827 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_compileId");
4828 }
4829#endif
4830};
4831
4832class EventCompilerInlining : public JfrEvent<EventCompilerInlining>
4833{
4834 private:
4835 unsigned _compileId;
4836 const Method* _caller;
4837 JfrStructCalleeMethod _callee;
4838 bool _succeeded;
4839 const char* _message;
4840 s4 _bci;
4841
4842 public:
4843 static const bool hasThread = true;
4844 static const bool hasStackTrace = false;
4845 static const bool isInstant = true;
4846 static const bool hasCutoff = false;
4847 static const bool isRequestable = false;
4848 static const JfrEventId eventId = JfrCompilerInliningEvent;
4849
4850 EventCompilerInlining(EventStartTime timing=TIMED) : JfrEvent<EventCompilerInlining>(timing) {}
4851
4852 void set_compileId(unsigned new_value) {
4853 this->_compileId = new_value;
4854 DEBUG_ONLY(set_field_bit(0));
4855 }
4856 void set_caller(const Method* new_value) {
4857 this->_caller = new_value;
4858 DEBUG_ONLY(set_field_bit(1));
4859 }
4860 void set_callee(const JfrStructCalleeMethod& value) {
4861 this->_callee = value;
4862 DEBUG_ONLY(set_field_bit(2));
4863 }
4864 void set_succeeded(bool new_value) {
4865 this->_succeeded = new_value;
4866 DEBUG_ONLY(set_field_bit(3));
4867 }
4868 void set_message(const char* new_value) {
4869 this->_message = new_value;
4870 DEBUG_ONLY(set_field_bit(4));
4871 }
4872 void set_bci(s4 new_value) {
4873 this->_bci = new_value;
4874 DEBUG_ONLY(set_field_bit(5));
4875 }
4876
4877 template <typename Writer>
4878 void writeData(Writer& w) {
4879 w.write(_compileId);
4880 w.write(_caller);
4881 _callee.writeData(w);
4882 w.write(_succeeded);
4883 w.write(_message);
4884 w.write(_bci);
4885 }
4886
4887 using JfrEvent<EventCompilerInlining>::commit; // else commit() is hidden by overloaded versions in this class
4888
4889
4890
4891 static void commit(unsigned compileId,
4892 const Method* caller,
4893 const JfrStructCalleeMethod& callee,
4894 bool succeeded,
4895 const char* message,
4896 s4 bci) {
4897 EventCompilerInlining me(UNTIMED);
4898
4899 if (me.should_commit()) {
4900 me.set_compileId(compileId);
4901 me.set_caller(caller);
4902 me.set_callee(callee);
4903 me.set_succeeded(succeeded);
4904 me.set_message(message);
4905 me.set_bci(bci);
4906 me.commit();
4907 }
4908 }
4909
4910#ifdef ASSERT
4911 void verify() const {
4912 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_compileId");
4913 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_caller");
4914 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_callee");
4915 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_succeeded");
4916 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_message");
4917 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bci");
4918 }
4919#endif
4920};
4921
4922class EventSweepCodeCache : public JfrEvent<EventSweepCodeCache>
4923{
4924 private:
4925 s4 _sweepId;
4926 unsigned _sweptCount;
4927 unsigned _flushedCount;
4928 unsigned _zombifiedCount;
4929
4930 public:
4931 static const bool hasThread = true;
4932 static const bool hasStackTrace = false;
4933 static const bool isInstant = false;
4934 static const bool hasCutoff = false;
4935 static const bool isRequestable = false;
4936 static const JfrEventId eventId = JfrSweepCodeCacheEvent;
4937
4938 EventSweepCodeCache(EventStartTime timing=TIMED) : JfrEvent<EventSweepCodeCache>(timing) {}
4939
4940 void set_sweepId(s4 new_value) {
4941 this->_sweepId = new_value;
4942 DEBUG_ONLY(set_field_bit(0));
4943 }
4944 void set_sweptCount(unsigned new_value) {
4945 this->_sweptCount = new_value;
4946 DEBUG_ONLY(set_field_bit(1));
4947 }
4948 void set_flushedCount(unsigned new_value) {
4949 this->_flushedCount = new_value;
4950 DEBUG_ONLY(set_field_bit(2));
4951 }
4952 void set_zombifiedCount(unsigned new_value) {
4953 this->_zombifiedCount = new_value;
4954 DEBUG_ONLY(set_field_bit(3));
4955 }
4956
4957 template <typename Writer>
4958 void writeData(Writer& w) {
4959 w.write(_sweepId);
4960 w.write(_sweptCount);
4961 w.write(_flushedCount);
4962 w.write(_zombifiedCount);
4963 }
4964
4965 using JfrEvent<EventSweepCodeCache>::commit; // else commit() is hidden by overloaded versions in this class
4966
4967 EventSweepCodeCache(
4968 s4 sweepId,
4969 unsigned sweptCount,
4970 unsigned flushedCount,
4971 unsigned zombifiedCount) : JfrEvent<EventSweepCodeCache>(TIMED) {
4972 if (should_commit()) {
4973 set_sweepId(sweepId);
4974 set_sweptCount(sweptCount);
4975 set_flushedCount(flushedCount);
4976 set_zombifiedCount(zombifiedCount);
4977 }
4978 }
4979
4980 void commit(s4 sweepId,
4981 unsigned sweptCount,
4982 unsigned flushedCount,
4983 unsigned zombifiedCount) {
4984 if (should_commit()) {
4985 set_sweepId(sweepId);
4986 set_sweptCount(sweptCount);
4987 set_flushedCount(flushedCount);
4988 set_zombifiedCount(zombifiedCount);
4989 commit();
4990 }
4991 }
4992
4993 static void commit(const Ticks& startTicks,
4994 const Ticks& endTicks,
4995 s4 sweepId,
4996 unsigned sweptCount,
4997 unsigned flushedCount,
4998 unsigned zombifiedCount) {
4999 EventSweepCodeCache me(UNTIMED);
5000
5001 if (me.should_commit()) {
5002 me.set_starttime(startTicks);
5003 me.set_endtime(endTicks);
5004 me.set_sweepId(sweepId);
5005 me.set_sweptCount(sweptCount);
5006 me.set_flushedCount(flushedCount);
5007 me.set_zombifiedCount(zombifiedCount);
5008 me.commit();
5009 }
5010 }
5011
5012#ifdef ASSERT
5013 void verify() const {
5014 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_sweepId");
5015 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_sweptCount");
5016 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_flushedCount");
5017 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_zombifiedCount");
5018 }
5019#endif
5020};
5021
5022class EventCodeCacheFull : public JfrEvent<EventCodeCacheFull>
5023{
5024 private:
5025 u8 _codeBlobType;
5026 u8 _startAddress;
5027 u8 _commitedTopAddress;
5028 u8 _reservedTopAddress;
5029 s4 _entryCount;
5030 s4 _methodCount;
5031 s4 _adaptorCount;
5032 u8 _unallocatedCapacity;
5033 s4 _fullCount;
5034
5035 public:
5036 static const bool hasThread = true;
5037 static const bool hasStackTrace = false;
5038 static const bool isInstant = true;
5039 static const bool hasCutoff = false;
5040 static const bool isRequestable = false;
5041 static const JfrEventId eventId = JfrCodeCacheFullEvent;
5042
5043 EventCodeCacheFull(EventStartTime timing=TIMED) : JfrEvent<EventCodeCacheFull>(timing) {}
5044
5045 void set_codeBlobType(u8 new_value) {
5046 this->_codeBlobType = new_value;
5047 DEBUG_ONLY(set_field_bit(0));
5048 }
5049 void set_startAddress(u8 new_value) {
5050 this->_startAddress = new_value;
5051 DEBUG_ONLY(set_field_bit(1));
5052 }
5053 void set_commitedTopAddress(u8 new_value) {
5054 this->_commitedTopAddress = new_value;
5055 DEBUG_ONLY(set_field_bit(2));
5056 }
5057 void set_reservedTopAddress(u8 new_value) {
5058 this->_reservedTopAddress = new_value;
5059 DEBUG_ONLY(set_field_bit(3));
5060 }
5061 void set_entryCount(s4 new_value) {
5062 this->_entryCount = new_value;
5063 DEBUG_ONLY(set_field_bit(4));
5064 }
5065 void set_methodCount(s4 new_value) {
5066 this->_methodCount = new_value;
5067 DEBUG_ONLY(set_field_bit(5));
5068 }
5069 void set_adaptorCount(s4 new_value) {
5070 this->_adaptorCount = new_value;
5071 DEBUG_ONLY(set_field_bit(6));
5072 }
5073 void set_unallocatedCapacity(u8 new_value) {
5074 this->_unallocatedCapacity = new_value;
5075 DEBUG_ONLY(set_field_bit(7));
5076 }
5077 void set_fullCount(s4 new_value) {
5078 this->_fullCount = new_value;
5079 DEBUG_ONLY(set_field_bit(8));
5080 }
5081
5082 template <typename Writer>
5083 void writeData(Writer& w) {
5084 w.write(_codeBlobType);
5085 w.write(_startAddress);
5086 w.write(_commitedTopAddress);
5087 w.write(_reservedTopAddress);
5088 w.write(_entryCount);
5089 w.write(_methodCount);
5090 w.write(_adaptorCount);
5091 w.write(_unallocatedCapacity);
5092 w.write(_fullCount);
5093 }
5094
5095 using JfrEvent<EventCodeCacheFull>::commit; // else commit() is hidden by overloaded versions in this class
5096
5097
5098
5099 static void commit(u8 codeBlobType,
5100 u8 startAddress,
5101 u8 commitedTopAddress,
5102 u8 reservedTopAddress,
5103 s4 entryCount,
5104 s4 methodCount,
5105 s4 adaptorCount,
5106 u8 unallocatedCapacity,
5107 s4 fullCount) {
5108 EventCodeCacheFull me(UNTIMED);
5109
5110 if (me.should_commit()) {
5111 me.set_codeBlobType(codeBlobType);
5112 me.set_startAddress(startAddress);
5113 me.set_commitedTopAddress(commitedTopAddress);
5114 me.set_reservedTopAddress(reservedTopAddress);
5115 me.set_entryCount(entryCount);
5116 me.set_methodCount(methodCount);
5117 me.set_adaptorCount(adaptorCount);
5118 me.set_unallocatedCapacity(unallocatedCapacity);
5119 me.set_fullCount(fullCount);
5120 me.commit();
5121 }
5122 }
5123
5124#ifdef ASSERT
5125 void verify() const {
5126 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_codeBlobType");
5127 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_startAddress");
5128 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_commitedTopAddress");
5129 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_reservedTopAddress");
5130 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_entryCount");
5131 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_methodCount");
5132 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_adaptorCount");
5133 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_unallocatedCapacity");
5134 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_fullCount");
5135 }
5136#endif
5137};
5138
5139class EventSafepointBegin : public JfrEvent<EventSafepointBegin>
5140{
5141 private:
5142 u8 _safepointId;
5143 s4 _totalThreadCount;
5144 s4 _jniCriticalThreadCount;
5145
5146 public:
5147 static const bool hasThread = true;
5148 static const bool hasStackTrace = false;
5149 static const bool isInstant = false;
5150 static const bool hasCutoff = false;
5151 static const bool isRequestable = false;
5152 static const JfrEventId eventId = JfrSafepointBeginEvent;
5153
5154 EventSafepointBegin(EventStartTime timing=TIMED) : JfrEvent<EventSafepointBegin>(timing) {}
5155
5156 void set_safepointId(u8 new_value) {
5157 this->_safepointId = new_value;
5158 DEBUG_ONLY(set_field_bit(0));
5159 }
5160 void set_totalThreadCount(s4 new_value) {
5161 this->_totalThreadCount = new_value;
5162 DEBUG_ONLY(set_field_bit(1));
5163 }
5164 void set_jniCriticalThreadCount(s4 new_value) {
5165 this->_jniCriticalThreadCount = new_value;
5166 DEBUG_ONLY(set_field_bit(2));
5167 }
5168
5169 template <typename Writer>
5170 void writeData(Writer& w) {
5171 w.write(_safepointId);
5172 w.write(_totalThreadCount);
5173 w.write(_jniCriticalThreadCount);
5174 }
5175
5176 using JfrEvent<EventSafepointBegin>::commit; // else commit() is hidden by overloaded versions in this class
5177
5178 EventSafepointBegin(
5179 u8 safepointId,
5180 s4 totalThreadCount,
5181 s4 jniCriticalThreadCount) : JfrEvent<EventSafepointBegin>(TIMED) {
5182 if (should_commit()) {
5183 set_safepointId(safepointId);
5184 set_totalThreadCount(totalThreadCount);
5185 set_jniCriticalThreadCount(jniCriticalThreadCount);
5186 }
5187 }
5188
5189 void commit(u8 safepointId,
5190 s4 totalThreadCount,
5191 s4 jniCriticalThreadCount) {
5192 if (should_commit()) {
5193 set_safepointId(safepointId);
5194 set_totalThreadCount(totalThreadCount);
5195 set_jniCriticalThreadCount(jniCriticalThreadCount);
5196 commit();
5197 }
5198 }
5199
5200 static void commit(const Ticks& startTicks,
5201 const Ticks& endTicks,
5202 u8 safepointId,
5203 s4 totalThreadCount,
5204 s4 jniCriticalThreadCount) {
5205 EventSafepointBegin me(UNTIMED);
5206
5207 if (me.should_commit()) {
5208 me.set_starttime(startTicks);
5209 me.set_endtime(endTicks);
5210 me.set_safepointId(safepointId);
5211 me.set_totalThreadCount(totalThreadCount);
5212 me.set_jniCriticalThreadCount(jniCriticalThreadCount);
5213 me.commit();
5214 }
5215 }
5216
5217#ifdef ASSERT
5218 void verify() const {
5219 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_safepointId");
5220 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_totalThreadCount");
5221 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_jniCriticalThreadCount");
5222 }
5223#endif
5224};
5225
5226class EventSafepointStateSynchronization : public JfrEvent<EventSafepointStateSynchronization>
5227{
5228 private:
5229 u8 _safepointId;
5230 s4 _initialThreadCount;
5231 s4 _runningThreadCount;
5232 s4 _iterations;
5233
5234 public:
5235 static const bool hasThread = true;
5236 static const bool hasStackTrace = false;
5237 static const bool isInstant = false;
5238 static const bool hasCutoff = false;
5239 static const bool isRequestable = false;
5240 static const JfrEventId eventId = JfrSafepointStateSynchronizationEvent;
5241
5242 EventSafepointStateSynchronization(EventStartTime timing=TIMED) : JfrEvent<EventSafepointStateSynchronization>(timing) {}
5243
5244 void set_safepointId(u8 new_value) {
5245 this->_safepointId = new_value;
5246 DEBUG_ONLY(set_field_bit(0));
5247 }
5248 void set_initialThreadCount(s4 new_value) {
5249 this->_initialThreadCount = new_value;
5250 DEBUG_ONLY(set_field_bit(1));
5251 }
5252 void set_runningThreadCount(s4 new_value) {
5253 this->_runningThreadCount = new_value;
5254 DEBUG_ONLY(set_field_bit(2));
5255 }
5256 void set_iterations(s4 new_value) {
5257 this->_iterations = new_value;
5258 DEBUG_ONLY(set_field_bit(3));
5259 }
5260
5261 template <typename Writer>
5262 void writeData(Writer& w) {
5263 w.write(_safepointId);
5264 w.write(_initialThreadCount);
5265 w.write(_runningThreadCount);
5266 w.write(_iterations);
5267 }
5268
5269 using JfrEvent<EventSafepointStateSynchronization>::commit; // else commit() is hidden by overloaded versions in this class
5270
5271 EventSafepointStateSynchronization(
5272 u8 safepointId,
5273 s4 initialThreadCount,
5274 s4 runningThreadCount,
5275 s4 iterations) : JfrEvent<EventSafepointStateSynchronization>(TIMED) {
5276 if (should_commit()) {
5277 set_safepointId(safepointId);
5278 set_initialThreadCount(initialThreadCount);
5279 set_runningThreadCount(runningThreadCount);
5280 set_iterations(iterations);
5281 }
5282 }
5283
5284 void commit(u8 safepointId,
5285 s4 initialThreadCount,
5286 s4 runningThreadCount,
5287 s4 iterations) {
5288 if (should_commit()) {
5289 set_safepointId(safepointId);
5290 set_initialThreadCount(initialThreadCount);
5291 set_runningThreadCount(runningThreadCount);
5292 set_iterations(iterations);
5293 commit();
5294 }
5295 }
5296
5297 static void commit(const Ticks& startTicks,
5298 const Ticks& endTicks,
5299 u8 safepointId,
5300 s4 initialThreadCount,
5301 s4 runningThreadCount,
5302 s4 iterations) {
5303 EventSafepointStateSynchronization me(UNTIMED);
5304
5305 if (me.should_commit()) {
5306 me.set_starttime(startTicks);
5307 me.set_endtime(endTicks);
5308 me.set_safepointId(safepointId);
5309 me.set_initialThreadCount(initialThreadCount);
5310 me.set_runningThreadCount(runningThreadCount);
5311 me.set_iterations(iterations);
5312 me.commit();
5313 }
5314 }
5315
5316#ifdef ASSERT
5317 void verify() const {
5318 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_safepointId");
5319 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_initialThreadCount");
5320 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_runningThreadCount");
5321 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_iterations");
5322 }
5323#endif
5324};
5325
5326class EventSafepointCleanup : public JfrEvent<EventSafepointCleanup>
5327{
5328 private:
5329 u8 _safepointId;
5330
5331 public:
5332 static const bool hasThread = true;
5333 static const bool hasStackTrace = false;
5334 static const bool isInstant = false;
5335 static const bool hasCutoff = false;
5336 static const bool isRequestable = false;
5337 static const JfrEventId eventId = JfrSafepointCleanupEvent;
5338
5339 EventSafepointCleanup(EventStartTime timing=TIMED) : JfrEvent<EventSafepointCleanup>(timing) {}
5340
5341 void set_safepointId(u8 new_value) {
5342 this->_safepointId = new_value;
5343 DEBUG_ONLY(set_field_bit(0));
5344 }
5345
5346 template <typename Writer>
5347 void writeData(Writer& w) {
5348 w.write(_safepointId);
5349 }
5350
5351 using JfrEvent<EventSafepointCleanup>::commit; // else commit() is hidden by overloaded versions in this class
5352
5353 EventSafepointCleanup(
5354 u8 safepointId) : JfrEvent<EventSafepointCleanup>(TIMED) {
5355 if (should_commit()) {
5356 set_safepointId(safepointId);
5357 }
5358 }
5359
5360 void commit(u8 safepointId) {
5361 if (should_commit()) {
5362 set_safepointId(safepointId);
5363 commit();
5364 }
5365 }
5366
5367 static void commit(const Ticks& startTicks,
5368 const Ticks& endTicks,
5369 u8 safepointId) {
5370 EventSafepointCleanup me(UNTIMED);
5371
5372 if (me.should_commit()) {
5373 me.set_starttime(startTicks);
5374 me.set_endtime(endTicks);
5375 me.set_safepointId(safepointId);
5376 me.commit();
5377 }
5378 }
5379
5380#ifdef ASSERT
5381 void verify() const {
5382 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_safepointId");
5383 }
5384#endif
5385};
5386
5387class EventSafepointCleanupTask : public JfrEvent<EventSafepointCleanupTask>
5388{
5389 private:
5390 u8 _safepointId;
5391 const char* _name;
5392
5393 public:
5394 static const bool hasThread = true;
5395 static const bool hasStackTrace = false;
5396 static const bool isInstant = false;
5397 static const bool hasCutoff = false;
5398 static const bool isRequestable = false;
5399 static const JfrEventId eventId = JfrSafepointCleanupTaskEvent;
5400
5401 EventSafepointCleanupTask(EventStartTime timing=TIMED) : JfrEvent<EventSafepointCleanupTask>(timing) {}
5402
5403 void set_safepointId(u8 new_value) {
5404 this->_safepointId = new_value;
5405 DEBUG_ONLY(set_field_bit(0));
5406 }
5407 void set_name(const char* new_value) {
5408 this->_name = new_value;
5409 DEBUG_ONLY(set_field_bit(1));
5410 }
5411
5412 template <typename Writer>
5413 void writeData(Writer& w) {
5414 w.write(_safepointId);
5415 w.write(_name);
5416 }
5417
5418 using JfrEvent<EventSafepointCleanupTask>::commit; // else commit() is hidden by overloaded versions in this class
5419
5420 EventSafepointCleanupTask(
5421 u8 safepointId,
5422 const char* name) : JfrEvent<EventSafepointCleanupTask>(TIMED) {
5423 if (should_commit()) {
5424 set_safepointId(safepointId);
5425 set_name(name);
5426 }
5427 }
5428
5429 void commit(u8 safepointId,
5430 const char* name) {
5431 if (should_commit()) {
5432 set_safepointId(safepointId);
5433 set_name(name);
5434 commit();
5435 }
5436 }
5437
5438 static void commit(const Ticks& startTicks,
5439 const Ticks& endTicks,
5440 u8 safepointId,
5441 const char* name) {
5442 EventSafepointCleanupTask me(UNTIMED);
5443
5444 if (me.should_commit()) {
5445 me.set_starttime(startTicks);
5446 me.set_endtime(endTicks);
5447 me.set_safepointId(safepointId);
5448 me.set_name(name);
5449 me.commit();
5450 }
5451 }
5452
5453#ifdef ASSERT
5454 void verify() const {
5455 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_safepointId");
5456 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
5457 }
5458#endif
5459};
5460
5461class EventSafepointEnd : public JfrEvent<EventSafepointEnd>
5462{
5463 private:
5464 u8 _safepointId;
5465
5466 public:
5467 static const bool hasThread = true;
5468 static const bool hasStackTrace = false;
5469 static const bool isInstant = false;
5470 static const bool hasCutoff = false;
5471 static const bool isRequestable = false;
5472 static const JfrEventId eventId = JfrSafepointEndEvent;
5473
5474 EventSafepointEnd(EventStartTime timing=TIMED) : JfrEvent<EventSafepointEnd>(timing) {}
5475
5476 void set_safepointId(u8 new_value) {
5477 this->_safepointId = new_value;
5478 DEBUG_ONLY(set_field_bit(0));
5479 }
5480
5481 template <typename Writer>
5482 void writeData(Writer& w) {
5483 w.write(_safepointId);
5484 }
5485
5486 using JfrEvent<EventSafepointEnd>::commit; // else commit() is hidden by overloaded versions in this class
5487
5488 EventSafepointEnd(
5489 u8 safepointId) : JfrEvent<EventSafepointEnd>(TIMED) {
5490 if (should_commit()) {
5491 set_safepointId(safepointId);
5492 }
5493 }
5494
5495 void commit(u8 safepointId) {
5496 if (should_commit()) {
5497 set_safepointId(safepointId);
5498 commit();
5499 }
5500 }
5501
5502 static void commit(const Ticks& startTicks,
5503 const Ticks& endTicks,
5504 u8 safepointId) {
5505 EventSafepointEnd me(UNTIMED);
5506
5507 if (me.should_commit()) {
5508 me.set_starttime(startTicks);
5509 me.set_endtime(endTicks);
5510 me.set_safepointId(safepointId);
5511 me.commit();
5512 }
5513 }
5514
5515#ifdef ASSERT
5516 void verify() const {
5517 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_safepointId");
5518 }
5519#endif
5520};
5521
5522class EventExecuteVMOperation : public JfrEvent<EventExecuteVMOperation>
5523{
5524 private:
5525 u8 _operation;
5526 bool _safepoint;
5527 bool _blocking;
5528 u8 _caller;
5529 u8 _safepointId;
5530
5531 public:
5532 static const bool hasThread = true;
5533 static const bool hasStackTrace = false;
5534 static const bool isInstant = false;
5535 static const bool hasCutoff = false;
5536 static const bool isRequestable = false;
5537 static const JfrEventId eventId = JfrExecuteVMOperationEvent;
5538
5539 EventExecuteVMOperation(EventStartTime timing=TIMED) : JfrEvent<EventExecuteVMOperation>(timing) {}
5540
5541 void set_operation(u8 new_value) {
5542 this->_operation = new_value;
5543 DEBUG_ONLY(set_field_bit(0));
5544 }
5545 void set_safepoint(bool new_value) {
5546 this->_safepoint = new_value;
5547 DEBUG_ONLY(set_field_bit(1));
5548 }
5549 void set_blocking(bool new_value) {
5550 this->_blocking = new_value;
5551 DEBUG_ONLY(set_field_bit(2));
5552 }
5553 void set_caller(u8 new_value) {
5554 this->_caller = new_value;
5555 DEBUG_ONLY(set_field_bit(3));
5556 }
5557 void set_safepointId(u8 new_value) {
5558 this->_safepointId = new_value;
5559 DEBUG_ONLY(set_field_bit(4));
5560 }
5561
5562 template <typename Writer>
5563 void writeData(Writer& w) {
5564 w.write(_operation);
5565 w.write(_safepoint);
5566 w.write(_blocking);
5567 w.write(_caller);
5568 w.write(_safepointId);
5569 }
5570
5571 using JfrEvent<EventExecuteVMOperation>::commit; // else commit() is hidden by overloaded versions in this class
5572
5573 EventExecuteVMOperation(
5574 u8 operation,
5575 bool safepoint,
5576 bool blocking,
5577 u8 caller,
5578 u8 safepointId) : JfrEvent<EventExecuteVMOperation>(TIMED) {
5579 if (should_commit()) {
5580 set_operation(operation);
5581 set_safepoint(safepoint);
5582 set_blocking(blocking);
5583 set_caller(caller);
5584 set_safepointId(safepointId);
5585 }
5586 }
5587
5588 void commit(u8 operation,
5589 bool safepoint,
5590 bool blocking,
5591 u8 caller,
5592 u8 safepointId) {
5593 if (should_commit()) {
5594 set_operation(operation);
5595 set_safepoint(safepoint);
5596 set_blocking(blocking);
5597 set_caller(caller);
5598 set_safepointId(safepointId);
5599 commit();
5600 }
5601 }
5602
5603 static void commit(const Ticks& startTicks,
5604 const Ticks& endTicks,
5605 u8 operation,
5606 bool safepoint,
5607 bool blocking,
5608 u8 caller,
5609 u8 safepointId) {
5610 EventExecuteVMOperation me(UNTIMED);
5611
5612 if (me.should_commit()) {
5613 me.set_starttime(startTicks);
5614 me.set_endtime(endTicks);
5615 me.set_operation(operation);
5616 me.set_safepoint(safepoint);
5617 me.set_blocking(blocking);
5618 me.set_caller(caller);
5619 me.set_safepointId(safepointId);
5620 me.commit();
5621 }
5622 }
5623
5624#ifdef ASSERT
5625 void verify() const {
5626 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_operation");
5627 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_safepoint");
5628 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_blocking");
5629 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_caller");
5630 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_safepointId");
5631 }
5632#endif
5633};
5634
5635class EventShutdown : public JfrEvent<EventShutdown>
5636{
5637 private:
5638 const char* _reason;
5639
5640 public:
5641 static const bool hasThread = true;
5642 static const bool hasStackTrace = true;
5643 static const bool isInstant = true;
5644 static const bool hasCutoff = false;
5645 static const bool isRequestable = false;
5646 static const JfrEventId eventId = JfrShutdownEvent;
5647
5648 EventShutdown(EventStartTime timing=TIMED) : JfrEvent<EventShutdown>(timing) {}
5649
5650 void set_reason(const char* new_value) {
5651 this->_reason = new_value;
5652 DEBUG_ONLY(set_field_bit(0));
5653 }
5654
5655 template <typename Writer>
5656 void writeData(Writer& w) {
5657 w.write(_reason);
5658 }
5659
5660 using JfrEvent<EventShutdown>::commit; // else commit() is hidden by overloaded versions in this class
5661
5662
5663
5664 static void commit(const char* reason) {
5665 EventShutdown me(UNTIMED);
5666
5667 if (me.should_commit()) {
5668 me.set_reason(reason);
5669 me.commit();
5670 }
5671 }
5672
5673#ifdef ASSERT
5674 void verify() const {
5675 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_reason");
5676 }
5677#endif
5678};
5679
5680class EventObjectAllocationInNewTLAB : public JfrEvent<EventObjectAllocationInNewTLAB>
5681{
5682 private:
5683 const Klass* _objectClass;
5684 u8 _allocationSize;
5685 u8 _tlabSize;
5686
5687 public:
5688 static const bool hasThread = true;
5689 static const bool hasStackTrace = true;
5690 static const bool isInstant = true;
5691 static const bool hasCutoff = false;
5692 static const bool isRequestable = false;
5693 static const JfrEventId eventId = JfrObjectAllocationInNewTLABEvent;
5694
5695 EventObjectAllocationInNewTLAB(EventStartTime timing=TIMED) : JfrEvent<EventObjectAllocationInNewTLAB>(timing) {}
5696
5697 void set_objectClass(const Klass* new_value) {
5698 this->_objectClass = new_value;
5699 DEBUG_ONLY(set_field_bit(0));
5700 }
5701 void set_allocationSize(u8 new_value) {
5702 this->_allocationSize = new_value;
5703 DEBUG_ONLY(set_field_bit(1));
5704 }
5705 void set_tlabSize(u8 new_value) {
5706 this->_tlabSize = new_value;
5707 DEBUG_ONLY(set_field_bit(2));
5708 }
5709
5710 template <typename Writer>
5711 void writeData(Writer& w) {
5712 w.write(_objectClass);
5713 w.write(_allocationSize);
5714 w.write(_tlabSize);
5715 }
5716
5717 using JfrEvent<EventObjectAllocationInNewTLAB>::commit; // else commit() is hidden by overloaded versions in this class
5718
5719
5720
5721 static void commit(const Klass* objectClass,
5722 u8 allocationSize,
5723 u8 tlabSize) {
5724 EventObjectAllocationInNewTLAB me(UNTIMED);
5725
5726 if (me.should_commit()) {
5727 me.set_objectClass(objectClass);
5728 me.set_allocationSize(allocationSize);
5729 me.set_tlabSize(tlabSize);
5730 me.commit();
5731 }
5732 }
5733
5734#ifdef ASSERT
5735 void verify() const {
5736 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_objectClass");
5737 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_allocationSize");
5738 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_tlabSize");
5739 }
5740#endif
5741};
5742
5743class EventObjectAllocationOutsideTLAB : public JfrEvent<EventObjectAllocationOutsideTLAB>
5744{
5745 private:
5746 const Klass* _objectClass;
5747 u8 _allocationSize;
5748
5749 public:
5750 static const bool hasThread = true;
5751 static const bool hasStackTrace = true;
5752 static const bool isInstant = true;
5753 static const bool hasCutoff = false;
5754 static const bool isRequestable = false;
5755 static const JfrEventId eventId = JfrObjectAllocationOutsideTLABEvent;
5756
5757 EventObjectAllocationOutsideTLAB(EventStartTime timing=TIMED) : JfrEvent<EventObjectAllocationOutsideTLAB>(timing) {}
5758
5759 void set_objectClass(const Klass* new_value) {
5760 this->_objectClass = new_value;
5761 DEBUG_ONLY(set_field_bit(0));
5762 }
5763 void set_allocationSize(u8 new_value) {
5764 this->_allocationSize = new_value;
5765 DEBUG_ONLY(set_field_bit(1));
5766 }
5767
5768 template <typename Writer>
5769 void writeData(Writer& w) {
5770 w.write(_objectClass);
5771 w.write(_allocationSize);
5772 }
5773
5774 using JfrEvent<EventObjectAllocationOutsideTLAB>::commit; // else commit() is hidden by overloaded versions in this class
5775
5776
5777
5778 static void commit(const Klass* objectClass,
5779 u8 allocationSize) {
5780 EventObjectAllocationOutsideTLAB me(UNTIMED);
5781
5782 if (me.should_commit()) {
5783 me.set_objectClass(objectClass);
5784 me.set_allocationSize(allocationSize);
5785 me.commit();
5786 }
5787 }
5788
5789#ifdef ASSERT
5790 void verify() const {
5791 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_objectClass");
5792 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_allocationSize");
5793 }
5794#endif
5795};
5796
5797class EventOldObjectSample : public JfrEvent<EventOldObjectSample>
5798{
5799 private:
5800 Ticks _allocationTime;
5801 u8 _lastKnownHeapUsage;
5802 u8 _object;
5803 s4 _arrayElements;
5804 u8 _root;
5805
5806 public:
5807 static const bool hasThread = true;
5808 static const bool hasStackTrace = true;
5809 static const bool isInstant = true;
5810 static const bool hasCutoff = true;
5811 static const bool isRequestable = false;
5812 static const JfrEventId eventId = JfrOldObjectSampleEvent;
5813
5814 EventOldObjectSample(EventStartTime timing=TIMED) : JfrEvent<EventOldObjectSample>(timing) {}
5815
5816 void set_allocationTime(const Ticks& new_value) {
5817 this->_allocationTime = new_value;
5818 DEBUG_ONLY(set_field_bit(0));
5819 }
5820 void set_lastKnownHeapUsage(u8 new_value) {
5821 this->_lastKnownHeapUsage = new_value;
5822 DEBUG_ONLY(set_field_bit(1));
5823 }
5824 void set_object(u8 new_value) {
5825 this->_object = new_value;
5826 DEBUG_ONLY(set_field_bit(2));
5827 }
5828 void set_arrayElements(s4 new_value) {
5829 this->_arrayElements = new_value;
5830 DEBUG_ONLY(set_field_bit(3));
5831 }
5832 void set_root(u8 new_value) {
5833 this->_root = new_value;
5834 DEBUG_ONLY(set_field_bit(4));
5835 }
5836
5837 template <typename Writer>
5838 void writeData(Writer& w) {
5839 w.write(_allocationTime);
5840 w.write(_lastKnownHeapUsage);
5841 w.write(_object);
5842 w.write(_arrayElements);
5843 w.write(_root);
5844 }
5845
5846 using JfrEvent<EventOldObjectSample>::commit; // else commit() is hidden by overloaded versions in this class
5847
5848
5849
5850 static void commit(const Ticks& allocationTime,
5851 u8 lastKnownHeapUsage,
5852 u8 object,
5853 s4 arrayElements,
5854 u8 root) {
5855 EventOldObjectSample me(UNTIMED);
5856
5857 if (me.should_commit()) {
5858 me.set_allocationTime(allocationTime);
5859 me.set_lastKnownHeapUsage(lastKnownHeapUsage);
5860 me.set_object(object);
5861 me.set_arrayElements(arrayElements);
5862 me.set_root(root);
5863 me.commit();
5864 }
5865 }
5866
5867#ifdef ASSERT
5868 void verify() const {
5869 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_allocationTime");
5870 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_lastKnownHeapUsage");
5871 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_object");
5872 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_arrayElements");
5873 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_root");
5874 }
5875#endif
5876};
5877
5878class EventDumpReason : public JfrEvent<EventDumpReason>
5879{
5880 private:
5881 const char* _reason;
5882 s4 _recordingId;
5883
5884 public:
5885 static const bool hasThread = false;
5886 static const bool hasStackTrace = false;
5887 static const bool isInstant = true;
5888 static const bool hasCutoff = false;
5889 static const bool isRequestable = false;
5890 static const JfrEventId eventId = JfrDumpReasonEvent;
5891
5892 EventDumpReason(EventStartTime timing=TIMED) : JfrEvent<EventDumpReason>(timing) {}
5893
5894 void set_reason(const char* new_value) {
5895 this->_reason = new_value;
5896 DEBUG_ONLY(set_field_bit(0));
5897 }
5898 void set_recordingId(s4 new_value) {
5899 this->_recordingId = new_value;
5900 DEBUG_ONLY(set_field_bit(1));
5901 }
5902
5903 template <typename Writer>
5904 void writeData(Writer& w) {
5905 w.write(_reason);
5906 w.write(_recordingId);
5907 }
5908
5909 using JfrEvent<EventDumpReason>::commit; // else commit() is hidden by overloaded versions in this class
5910
5911
5912
5913 static void commit(const char* reason,
5914 s4 recordingId) {
5915 EventDumpReason me(UNTIMED);
5916
5917 if (me.should_commit()) {
5918 me.set_reason(reason);
5919 me.set_recordingId(recordingId);
5920 me.commit();
5921 }
5922 }
5923
5924#ifdef ASSERT
5925 void verify() const {
5926 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_reason");
5927 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_recordingId");
5928 }
5929#endif
5930};
5931
5932class EventDataLoss : public JfrEvent<EventDataLoss>
5933{
5934 private:
5935 u8 _amount;
5936 u8 _total;
5937
5938 public:
5939 static const bool hasThread = false;
5940 static const bool hasStackTrace = false;
5941 static const bool isInstant = true;
5942 static const bool hasCutoff = false;
5943 static const bool isRequestable = false;
5944 static const JfrEventId eventId = JfrDataLossEvent;
5945
5946 EventDataLoss(EventStartTime timing=TIMED) : JfrEvent<EventDataLoss>(timing) {}
5947
5948 void set_amount(u8 new_value) {
5949 this->_amount = new_value;
5950 DEBUG_ONLY(set_field_bit(0));
5951 }
5952 void set_total(u8 new_value) {
5953 this->_total = new_value;
5954 DEBUG_ONLY(set_field_bit(1));
5955 }
5956
5957 template <typename Writer>
5958 void writeData(Writer& w) {
5959 w.write(_amount);
5960 w.write(_total);
5961 }
5962
5963 using JfrEvent<EventDataLoss>::commit; // else commit() is hidden by overloaded versions in this class
5964
5965
5966
5967 static void commit(u8 amount,
5968 u8 total) {
5969 EventDataLoss me(UNTIMED);
5970
5971 if (me.should_commit()) {
5972 me.set_amount(amount);
5973 me.set_total(total);
5974 me.commit();
5975 }
5976 }
5977
5978#ifdef ASSERT
5979 void verify() const {
5980 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_amount");
5981 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_total");
5982 }
5983#endif
5984};
5985
5986class EventJVMInformation : public JfrEvent<EventJVMInformation>
5987{
5988 private:
5989 const char* _jvmName;
5990 const char* _jvmVersion;
5991 const char* _jvmArguments;
5992 const char* _jvmFlags;
5993 const char* _javaArguments;
5994 s8 _jvmStartTime;
5995 s8 _pid;
5996
5997 public:
5998 static const bool hasThread = false;
5999 static const bool hasStackTrace = false;
6000 static const bool isInstant = false;
6001 static const bool hasCutoff = false;
6002 static const bool isRequestable = true;
6003 static const JfrEventId eventId = JfrJVMInformationEvent;
6004
6005 EventJVMInformation(EventStartTime timing=TIMED) : JfrEvent<EventJVMInformation>(timing) {}
6006
6007 void set_jvmName(const char* new_value) {
6008 this->_jvmName = new_value;
6009 DEBUG_ONLY(set_field_bit(0));
6010 }
6011 void set_jvmVersion(const char* new_value) {
6012 this->_jvmVersion = new_value;
6013 DEBUG_ONLY(set_field_bit(1));
6014 }
6015 void set_jvmArguments(const char* new_value) {
6016 this->_jvmArguments = new_value;
6017 DEBUG_ONLY(set_field_bit(2));
6018 }
6019 void set_jvmFlags(const char* new_value) {
6020 this->_jvmFlags = new_value;
6021 DEBUG_ONLY(set_field_bit(3));
6022 }
6023 void set_javaArguments(const char* new_value) {
6024 this->_javaArguments = new_value;
6025 DEBUG_ONLY(set_field_bit(4));
6026 }
6027 void set_jvmStartTime(s8 new_value) {
6028 this->_jvmStartTime = new_value;
6029 DEBUG_ONLY(set_field_bit(5));
6030 }
6031 void set_pid(s8 new_value) {
6032 this->_pid = new_value;
6033 DEBUG_ONLY(set_field_bit(6));
6034 }
6035
6036 template <typename Writer>
6037 void writeData(Writer& w) {
6038 w.write(_jvmName);
6039 w.write(_jvmVersion);
6040 w.write(_jvmArguments);
6041 w.write(_jvmFlags);
6042 w.write(_javaArguments);
6043 w.write(_jvmStartTime);
6044 w.write(_pid);
6045 }
6046
6047 using JfrEvent<EventJVMInformation>::commit; // else commit() is hidden by overloaded versions in this class
6048
6049 EventJVMInformation(
6050 const char* jvmName,
6051 const char* jvmVersion,
6052 const char* jvmArguments,
6053 const char* jvmFlags,
6054 const char* javaArguments,
6055 s8 jvmStartTime,
6056 s8 pid) : JfrEvent<EventJVMInformation>(TIMED) {
6057 if (should_commit()) {
6058 set_jvmName(jvmName);
6059 set_jvmVersion(jvmVersion);
6060 set_jvmArguments(jvmArguments);
6061 set_jvmFlags(jvmFlags);
6062 set_javaArguments(javaArguments);
6063 set_jvmStartTime(jvmStartTime);
6064 set_pid(pid);
6065 }
6066 }
6067
6068 void commit(const char* jvmName,
6069 const char* jvmVersion,
6070 const char* jvmArguments,
6071 const char* jvmFlags,
6072 const char* javaArguments,
6073 s8 jvmStartTime,
6074 s8 pid) {
6075 if (should_commit()) {
6076 set_jvmName(jvmName);
6077 set_jvmVersion(jvmVersion);
6078 set_jvmArguments(jvmArguments);
6079 set_jvmFlags(jvmFlags);
6080 set_javaArguments(javaArguments);
6081 set_jvmStartTime(jvmStartTime);
6082 set_pid(pid);
6083 commit();
6084 }
6085 }
6086
6087 static void commit(const Ticks& startTicks,
6088 const Ticks& endTicks,
6089 const char* jvmName,
6090 const char* jvmVersion,
6091 const char* jvmArguments,
6092 const char* jvmFlags,
6093 const char* javaArguments,
6094 s8 jvmStartTime,
6095 s8 pid) {
6096 EventJVMInformation me(UNTIMED);
6097
6098 if (me.should_commit()) {
6099 me.set_starttime(startTicks);
6100 me.set_endtime(endTicks);
6101 me.set_jvmName(jvmName);
6102 me.set_jvmVersion(jvmVersion);
6103 me.set_jvmArguments(jvmArguments);
6104 me.set_jvmFlags(jvmFlags);
6105 me.set_javaArguments(javaArguments);
6106 me.set_jvmStartTime(jvmStartTime);
6107 me.set_pid(pid);
6108 me.commit();
6109 }
6110 }
6111
6112#ifdef ASSERT
6113 void verify() const {
6114 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_jvmName");
6115 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_jvmVersion");
6116 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_jvmArguments");
6117 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_jvmFlags");
6118 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_javaArguments");
6119 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_jvmStartTime");
6120 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_pid");
6121 }
6122#endif
6123};
6124
6125class EventOSInformation : public JfrEvent<EventOSInformation>
6126{
6127 private:
6128 const char* _osVersion;
6129
6130 public:
6131 static const bool hasThread = false;
6132 static const bool hasStackTrace = false;
6133 static const bool isInstant = false;
6134 static const bool hasCutoff = false;
6135 static const bool isRequestable = true;
6136 static const JfrEventId eventId = JfrOSInformationEvent;
6137
6138 EventOSInformation(EventStartTime timing=TIMED) : JfrEvent<EventOSInformation>(timing) {}
6139
6140 void set_osVersion(const char* new_value) {
6141 this->_osVersion = new_value;
6142 DEBUG_ONLY(set_field_bit(0));
6143 }
6144
6145 template <typename Writer>
6146 void writeData(Writer& w) {
6147 w.write(_osVersion);
6148 }
6149
6150 using JfrEvent<EventOSInformation>::commit; // else commit() is hidden by overloaded versions in this class
6151
6152 EventOSInformation(
6153 const char* osVersion) : JfrEvent<EventOSInformation>(TIMED) {
6154 if (should_commit()) {
6155 set_osVersion(osVersion);
6156 }
6157 }
6158
6159 void commit(const char* osVersion) {
6160 if (should_commit()) {
6161 set_osVersion(osVersion);
6162 commit();
6163 }
6164 }
6165
6166 static void commit(const Ticks& startTicks,
6167 const Ticks& endTicks,
6168 const char* osVersion) {
6169 EventOSInformation me(UNTIMED);
6170
6171 if (me.should_commit()) {
6172 me.set_starttime(startTicks);
6173 me.set_endtime(endTicks);
6174 me.set_osVersion(osVersion);
6175 me.commit();
6176 }
6177 }
6178
6179#ifdef ASSERT
6180 void verify() const {
6181 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_osVersion");
6182 }
6183#endif
6184};
6185
6186class EventVirtualizationInformation : public JfrEvent<EventVirtualizationInformation>
6187{
6188 private:
6189 const char* _name;
6190
6191 public:
6192 static const bool hasThread = false;
6193 static const bool hasStackTrace = false;
6194 static const bool isInstant = false;
6195 static const bool hasCutoff = false;
6196 static const bool isRequestable = true;
6197 static const JfrEventId eventId = JfrVirtualizationInformationEvent;
6198
6199 EventVirtualizationInformation(EventStartTime timing=TIMED) : JfrEvent<EventVirtualizationInformation>(timing) {}
6200
6201 void set_name(const char* new_value) {
6202 this->_name = new_value;
6203 DEBUG_ONLY(set_field_bit(0));
6204 }
6205
6206 template <typename Writer>
6207 void writeData(Writer& w) {
6208 w.write(_name);
6209 }
6210
6211 using JfrEvent<EventVirtualizationInformation>::commit; // else commit() is hidden by overloaded versions in this class
6212
6213 EventVirtualizationInformation(
6214 const char* name) : JfrEvent<EventVirtualizationInformation>(TIMED) {
6215 if (should_commit()) {
6216 set_name(name);
6217 }
6218 }
6219
6220 void commit(const char* name) {
6221 if (should_commit()) {
6222 set_name(name);
6223 commit();
6224 }
6225 }
6226
6227 static void commit(const Ticks& startTicks,
6228 const Ticks& endTicks,
6229 const char* name) {
6230 EventVirtualizationInformation me(UNTIMED);
6231
6232 if (me.should_commit()) {
6233 me.set_starttime(startTicks);
6234 me.set_endtime(endTicks);
6235 me.set_name(name);
6236 me.commit();
6237 }
6238 }
6239
6240#ifdef ASSERT
6241 void verify() const {
6242 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
6243 }
6244#endif
6245};
6246
6247class EventInitialSystemProperty : public JfrEvent<EventInitialSystemProperty>
6248{
6249 private:
6250 const char* _key;
6251 const char* _value;
6252
6253 public:
6254 static const bool hasThread = false;
6255 static const bool hasStackTrace = false;
6256 static const bool isInstant = false;
6257 static const bool hasCutoff = false;
6258 static const bool isRequestable = true;
6259 static const JfrEventId eventId = JfrInitialSystemPropertyEvent;
6260
6261 EventInitialSystemProperty(EventStartTime timing=TIMED) : JfrEvent<EventInitialSystemProperty>(timing) {}
6262
6263 void set_key(const char* new_value) {
6264 this->_key = new_value;
6265 DEBUG_ONLY(set_field_bit(0));
6266 }
6267 void set_value(const char* new_value) {
6268 this->_value = new_value;
6269 DEBUG_ONLY(set_field_bit(1));
6270 }
6271
6272 template <typename Writer>
6273 void writeData(Writer& w) {
6274 w.write(_key);
6275 w.write(_value);
6276 }
6277
6278 using JfrEvent<EventInitialSystemProperty>::commit; // else commit() is hidden by overloaded versions in this class
6279
6280 EventInitialSystemProperty(
6281 const char* key,
6282 const char* value) : JfrEvent<EventInitialSystemProperty>(TIMED) {
6283 if (should_commit()) {
6284 set_key(key);
6285 set_value(value);
6286 }
6287 }
6288
6289 void commit(const char* key,
6290 const char* value) {
6291 if (should_commit()) {
6292 set_key(key);
6293 set_value(value);
6294 commit();
6295 }
6296 }
6297
6298 static void commit(const Ticks& startTicks,
6299 const Ticks& endTicks,
6300 const char* key,
6301 const char* value) {
6302 EventInitialSystemProperty me(UNTIMED);
6303
6304 if (me.should_commit()) {
6305 me.set_starttime(startTicks);
6306 me.set_endtime(endTicks);
6307 me.set_key(key);
6308 me.set_value(value);
6309 me.commit();
6310 }
6311 }
6312
6313#ifdef ASSERT
6314 void verify() const {
6315 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_key");
6316 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
6317 }
6318#endif
6319};
6320
6321class EventInitialEnvironmentVariable : public JfrEvent<EventInitialEnvironmentVariable>
6322{
6323 private:
6324 const char* _key;
6325 const char* _value;
6326
6327 public:
6328 static const bool hasThread = false;
6329 static const bool hasStackTrace = false;
6330 static const bool isInstant = false;
6331 static const bool hasCutoff = false;
6332 static const bool isRequestable = true;
6333 static const JfrEventId eventId = JfrInitialEnvironmentVariableEvent;
6334
6335 EventInitialEnvironmentVariable(EventStartTime timing=TIMED) : JfrEvent<EventInitialEnvironmentVariable>(timing) {}
6336
6337 void set_key(const char* new_value) {
6338 this->_key = new_value;
6339 DEBUG_ONLY(set_field_bit(0));
6340 }
6341 void set_value(const char* new_value) {
6342 this->_value = new_value;
6343 DEBUG_ONLY(set_field_bit(1));
6344 }
6345
6346 template <typename Writer>
6347 void writeData(Writer& w) {
6348 w.write(_key);
6349 w.write(_value);
6350 }
6351
6352 using JfrEvent<EventInitialEnvironmentVariable>::commit; // else commit() is hidden by overloaded versions in this class
6353
6354 EventInitialEnvironmentVariable(
6355 const char* key,
6356 const char* value) : JfrEvent<EventInitialEnvironmentVariable>(TIMED) {
6357 if (should_commit()) {
6358 set_key(key);
6359 set_value(value);
6360 }
6361 }
6362
6363 void commit(const char* key,
6364 const char* value) {
6365 if (should_commit()) {
6366 set_key(key);
6367 set_value(value);
6368 commit();
6369 }
6370 }
6371
6372 static void commit(const Ticks& startTicks,
6373 const Ticks& endTicks,
6374 const char* key,
6375 const char* value) {
6376 EventInitialEnvironmentVariable me(UNTIMED);
6377
6378 if (me.should_commit()) {
6379 me.set_starttime(startTicks);
6380 me.set_endtime(endTicks);
6381 me.set_key(key);
6382 me.set_value(value);
6383 me.commit();
6384 }
6385 }
6386
6387#ifdef ASSERT
6388 void verify() const {
6389 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_key");
6390 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
6391 }
6392#endif
6393};
6394
6395class EventSystemProcess : public JfrEvent<EventSystemProcess>
6396{
6397 private:
6398 const char* _pid;
6399 const char* _commandLine;
6400
6401 public:
6402 static const bool hasThread = false;
6403 static const bool hasStackTrace = false;
6404 static const bool isInstant = false;
6405 static const bool hasCutoff = false;
6406 static const bool isRequestable = true;
6407 static const JfrEventId eventId = JfrSystemProcessEvent;
6408
6409 EventSystemProcess(EventStartTime timing=TIMED) : JfrEvent<EventSystemProcess>(timing) {}
6410
6411 void set_pid(const char* new_value) {
6412 this->_pid = new_value;
6413 DEBUG_ONLY(set_field_bit(0));
6414 }
6415 void set_commandLine(const char* new_value) {
6416 this->_commandLine = new_value;
6417 DEBUG_ONLY(set_field_bit(1));
6418 }
6419
6420 template <typename Writer>
6421 void writeData(Writer& w) {
6422 w.write(_pid);
6423 w.write(_commandLine);
6424 }
6425
6426 using JfrEvent<EventSystemProcess>::commit; // else commit() is hidden by overloaded versions in this class
6427
6428 EventSystemProcess(
6429 const char* pid,
6430 const char* commandLine) : JfrEvent<EventSystemProcess>(TIMED) {
6431 if (should_commit()) {
6432 set_pid(pid);
6433 set_commandLine(commandLine);
6434 }
6435 }
6436
6437 void commit(const char* pid,
6438 const char* commandLine) {
6439 if (should_commit()) {
6440 set_pid(pid);
6441 set_commandLine(commandLine);
6442 commit();
6443 }
6444 }
6445
6446 static void commit(const Ticks& startTicks,
6447 const Ticks& endTicks,
6448 const char* pid,
6449 const char* commandLine) {
6450 EventSystemProcess me(UNTIMED);
6451
6452 if (me.should_commit()) {
6453 me.set_starttime(startTicks);
6454 me.set_endtime(endTicks);
6455 me.set_pid(pid);
6456 me.set_commandLine(commandLine);
6457 me.commit();
6458 }
6459 }
6460
6461#ifdef ASSERT
6462 void verify() const {
6463 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_pid");
6464 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_commandLine");
6465 }
6466#endif
6467};
6468
6469class EventCPUInformation : public JfrEvent<EventCPUInformation>
6470{
6471 private:
6472 const char* _cpu;
6473 const char* _description;
6474 unsigned _sockets;
6475 unsigned _cores;
6476 unsigned _hwThreads;
6477
6478 public:
6479 static const bool hasThread = false;
6480 static const bool hasStackTrace = false;
6481 static const bool isInstant = false;
6482 static const bool hasCutoff = false;
6483 static const bool isRequestable = true;
6484 static const JfrEventId eventId = JfrCPUInformationEvent;
6485
6486 EventCPUInformation(EventStartTime timing=TIMED) : JfrEvent<EventCPUInformation>(timing) {}
6487
6488 void set_cpu(const char* new_value) {
6489 this->_cpu = new_value;
6490 DEBUG_ONLY(set_field_bit(0));
6491 }
6492 void set_description(const char* new_value) {
6493 this->_description = new_value;
6494 DEBUG_ONLY(set_field_bit(1));
6495 }
6496 void set_sockets(unsigned new_value) {
6497 this->_sockets = new_value;
6498 DEBUG_ONLY(set_field_bit(2));
6499 }
6500 void set_cores(unsigned new_value) {
6501 this->_cores = new_value;
6502 DEBUG_ONLY(set_field_bit(3));
6503 }
6504 void set_hwThreads(unsigned new_value) {
6505 this->_hwThreads = new_value;
6506 DEBUG_ONLY(set_field_bit(4));
6507 }
6508
6509 template <typename Writer>
6510 void writeData(Writer& w) {
6511 w.write(_cpu);
6512 w.write(_description);
6513 w.write(_sockets);
6514 w.write(_cores);
6515 w.write(_hwThreads);
6516 }
6517
6518 using JfrEvent<EventCPUInformation>::commit; // else commit() is hidden by overloaded versions in this class
6519
6520 EventCPUInformation(
6521 const char* cpu,
6522 const char* description,
6523 unsigned sockets,
6524 unsigned cores,
6525 unsigned hwThreads) : JfrEvent<EventCPUInformation>(TIMED) {
6526 if (should_commit()) {
6527 set_cpu(cpu);
6528 set_description(description);
6529 set_sockets(sockets);
6530 set_cores(cores);
6531 set_hwThreads(hwThreads);
6532 }
6533 }
6534
6535 void commit(const char* cpu,
6536 const char* description,
6537 unsigned sockets,
6538 unsigned cores,
6539 unsigned hwThreads) {
6540 if (should_commit()) {
6541 set_cpu(cpu);
6542 set_description(description);
6543 set_sockets(sockets);
6544 set_cores(cores);
6545 set_hwThreads(hwThreads);
6546 commit();
6547 }
6548 }
6549
6550 static void commit(const Ticks& startTicks,
6551 const Ticks& endTicks,
6552 const char* cpu,
6553 const char* description,
6554 unsigned sockets,
6555 unsigned cores,
6556 unsigned hwThreads) {
6557 EventCPUInformation me(UNTIMED);
6558
6559 if (me.should_commit()) {
6560 me.set_starttime(startTicks);
6561 me.set_endtime(endTicks);
6562 me.set_cpu(cpu);
6563 me.set_description(description);
6564 me.set_sockets(sockets);
6565 me.set_cores(cores);
6566 me.set_hwThreads(hwThreads);
6567 me.commit();
6568 }
6569 }
6570
6571#ifdef ASSERT
6572 void verify() const {
6573 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_cpu");
6574 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_description");
6575 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_sockets");
6576 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_cores");
6577 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_hwThreads");
6578 }
6579#endif
6580};
6581
6582class EventCPUTimeStampCounter : public JfrEvent<EventCPUTimeStampCounter>
6583{
6584 private:
6585 bool _fastTimeEnabled;
6586 bool _fastTimeAutoEnabled;
6587 s8 _osFrequency;
6588 s8 _fastTimeFrequency;
6589
6590 public:
6591 static const bool hasThread = false;
6592 static const bool hasStackTrace = false;
6593 static const bool isInstant = false;
6594 static const bool hasCutoff = false;
6595 static const bool isRequestable = true;
6596 static const JfrEventId eventId = JfrCPUTimeStampCounterEvent;
6597
6598 EventCPUTimeStampCounter(EventStartTime timing=TIMED) : JfrEvent<EventCPUTimeStampCounter>(timing) {}
6599
6600 void set_fastTimeEnabled(bool new_value) {
6601 this->_fastTimeEnabled = new_value;
6602 DEBUG_ONLY(set_field_bit(0));
6603 }
6604 void set_fastTimeAutoEnabled(bool new_value) {
6605 this->_fastTimeAutoEnabled = new_value;
6606 DEBUG_ONLY(set_field_bit(1));
6607 }
6608 void set_osFrequency(s8 new_value) {
6609 this->_osFrequency = new_value;
6610 DEBUG_ONLY(set_field_bit(2));
6611 }
6612 void set_fastTimeFrequency(s8 new_value) {
6613 this->_fastTimeFrequency = new_value;
6614 DEBUG_ONLY(set_field_bit(3));
6615 }
6616
6617 template <typename Writer>
6618 void writeData(Writer& w) {
6619 w.write(_fastTimeEnabled);
6620 w.write(_fastTimeAutoEnabled);
6621 w.write(_osFrequency);
6622 w.write(_fastTimeFrequency);
6623 }
6624
6625 using JfrEvent<EventCPUTimeStampCounter>::commit; // else commit() is hidden by overloaded versions in this class
6626
6627 EventCPUTimeStampCounter(
6628 bool fastTimeEnabled,
6629 bool fastTimeAutoEnabled,
6630 s8 osFrequency,
6631 s8 fastTimeFrequency) : JfrEvent<EventCPUTimeStampCounter>(TIMED) {
6632 if (should_commit()) {
6633 set_fastTimeEnabled(fastTimeEnabled);
6634 set_fastTimeAutoEnabled(fastTimeAutoEnabled);
6635 set_osFrequency(osFrequency);
6636 set_fastTimeFrequency(fastTimeFrequency);
6637 }
6638 }
6639
6640 void commit(bool fastTimeEnabled,
6641 bool fastTimeAutoEnabled,
6642 s8 osFrequency,
6643 s8 fastTimeFrequency) {
6644 if (should_commit()) {
6645 set_fastTimeEnabled(fastTimeEnabled);
6646 set_fastTimeAutoEnabled(fastTimeAutoEnabled);
6647 set_osFrequency(osFrequency);
6648 set_fastTimeFrequency(fastTimeFrequency);
6649 commit();
6650 }
6651 }
6652
6653 static void commit(const Ticks& startTicks,
6654 const Ticks& endTicks,
6655 bool fastTimeEnabled,
6656 bool fastTimeAutoEnabled,
6657 s8 osFrequency,
6658 s8 fastTimeFrequency) {
6659 EventCPUTimeStampCounter me(UNTIMED);
6660
6661 if (me.should_commit()) {
6662 me.set_starttime(startTicks);
6663 me.set_endtime(endTicks);
6664 me.set_fastTimeEnabled(fastTimeEnabled);
6665 me.set_fastTimeAutoEnabled(fastTimeAutoEnabled);
6666 me.set_osFrequency(osFrequency);
6667 me.set_fastTimeFrequency(fastTimeFrequency);
6668 me.commit();
6669 }
6670 }
6671
6672#ifdef ASSERT
6673 void verify() const {
6674 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_fastTimeEnabled");
6675 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_fastTimeAutoEnabled");
6676 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_osFrequency");
6677 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_fastTimeFrequency");
6678 }
6679#endif
6680};
6681
6682class EventCPULoad : public JfrEvent<EventCPULoad>
6683{
6684 private:
6685 float _jvmUser;
6686 float _jvmSystem;
6687 float _machineTotal;
6688
6689 public:
6690 static const bool hasThread = false;
6691 static const bool hasStackTrace = false;
6692 static const bool isInstant = false;
6693 static const bool hasCutoff = false;
6694 static const bool isRequestable = true;
6695 static const JfrEventId eventId = JfrCPULoadEvent;
6696
6697 EventCPULoad(EventStartTime timing=TIMED) : JfrEvent<EventCPULoad>(timing) {}
6698
6699 void set_jvmUser(float new_value) {
6700 this->_jvmUser = new_value;
6701 DEBUG_ONLY(set_field_bit(0));
6702 }
6703 void set_jvmSystem(float new_value) {
6704 this->_jvmSystem = new_value;
6705 DEBUG_ONLY(set_field_bit(1));
6706 }
6707 void set_machineTotal(float new_value) {
6708 this->_machineTotal = new_value;
6709 DEBUG_ONLY(set_field_bit(2));
6710 }
6711
6712 template <typename Writer>
6713 void writeData(Writer& w) {
6714 w.write(_jvmUser);
6715 w.write(_jvmSystem);
6716 w.write(_machineTotal);
6717 }
6718
6719 using JfrEvent<EventCPULoad>::commit; // else commit() is hidden by overloaded versions in this class
6720
6721 EventCPULoad(
6722 float jvmUser,
6723 float jvmSystem,
6724 float machineTotal) : JfrEvent<EventCPULoad>(TIMED) {
6725 if (should_commit()) {
6726 set_jvmUser(jvmUser);
6727 set_jvmSystem(jvmSystem);
6728 set_machineTotal(machineTotal);
6729 }
6730 }
6731
6732 void commit(float jvmUser,
6733 float jvmSystem,
6734 float machineTotal) {
6735 if (should_commit()) {
6736 set_jvmUser(jvmUser);
6737 set_jvmSystem(jvmSystem);
6738 set_machineTotal(machineTotal);
6739 commit();
6740 }
6741 }
6742
6743 static void commit(const Ticks& startTicks,
6744 const Ticks& endTicks,
6745 float jvmUser,
6746 float jvmSystem,
6747 float machineTotal) {
6748 EventCPULoad me(UNTIMED);
6749
6750 if (me.should_commit()) {
6751 me.set_starttime(startTicks);
6752 me.set_endtime(endTicks);
6753 me.set_jvmUser(jvmUser);
6754 me.set_jvmSystem(jvmSystem);
6755 me.set_machineTotal(machineTotal);
6756 me.commit();
6757 }
6758 }
6759
6760#ifdef ASSERT
6761 void verify() const {
6762 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_jvmUser");
6763 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_jvmSystem");
6764 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_machineTotal");
6765 }
6766#endif
6767};
6768
6769class EventThreadCPULoad : public JfrEvent<EventThreadCPULoad>
6770{
6771 private:
6772 float _user;
6773 float _system;
6774
6775 public:
6776 static const bool hasThread = true;
6777 static const bool hasStackTrace = false;
6778 static const bool isInstant = false;
6779 static const bool hasCutoff = false;
6780 static const bool isRequestable = true;
6781 static const JfrEventId eventId = JfrThreadCPULoadEvent;
6782
6783 EventThreadCPULoad(EventStartTime timing=TIMED) : JfrEvent<EventThreadCPULoad>(timing) {}
6784
6785 void set_user(float new_value) {
6786 this->_user = new_value;
6787 DEBUG_ONLY(set_field_bit(0));
6788 }
6789 void set_system(float new_value) {
6790 this->_system = new_value;
6791 DEBUG_ONLY(set_field_bit(1));
6792 }
6793
6794 template <typename Writer>
6795 void writeData(Writer& w) {
6796 w.write(_user);
6797 w.write(_system);
6798 }
6799
6800 using JfrEvent<EventThreadCPULoad>::commit; // else commit() is hidden by overloaded versions in this class
6801
6802 EventThreadCPULoad(
6803 float user,
6804 float system) : JfrEvent<EventThreadCPULoad>(TIMED) {
6805 if (should_commit()) {
6806 set_user(user);
6807 set_system(system);
6808 }
6809 }
6810
6811 void commit(float user,
6812 float system) {
6813 if (should_commit()) {
6814 set_user(user);
6815 set_system(system);
6816 commit();
6817 }
6818 }
6819
6820 static void commit(const Ticks& startTicks,
6821 const Ticks& endTicks,
6822 float user,
6823 float system) {
6824 EventThreadCPULoad me(UNTIMED);
6825
6826 if (me.should_commit()) {
6827 me.set_starttime(startTicks);
6828 me.set_endtime(endTicks);
6829 me.set_user(user);
6830 me.set_system(system);
6831 me.commit();
6832 }
6833 }
6834
6835#ifdef ASSERT
6836 void verify() const {
6837 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_user");
6838 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_system");
6839 }
6840#endif
6841};
6842
6843class EventThreadContextSwitchRate : public JfrEvent<EventThreadContextSwitchRate>
6844{
6845 private:
6846 float _switchRate;
6847
6848 public:
6849 static const bool hasThread = false;
6850 static const bool hasStackTrace = false;
6851 static const bool isInstant = false;
6852 static const bool hasCutoff = false;
6853 static const bool isRequestable = true;
6854 static const JfrEventId eventId = JfrThreadContextSwitchRateEvent;
6855
6856 EventThreadContextSwitchRate(EventStartTime timing=TIMED) : JfrEvent<EventThreadContextSwitchRate>(timing) {}
6857
6858 void set_switchRate(float new_value) {
6859 this->_switchRate = new_value;
6860 DEBUG_ONLY(set_field_bit(0));
6861 }
6862
6863 template <typename Writer>
6864 void writeData(Writer& w) {
6865 w.write(_switchRate);
6866 }
6867
6868 using JfrEvent<EventThreadContextSwitchRate>::commit; // else commit() is hidden by overloaded versions in this class
6869
6870 EventThreadContextSwitchRate(
6871 float switchRate) : JfrEvent<EventThreadContextSwitchRate>(TIMED) {
6872 if (should_commit()) {
6873 set_switchRate(switchRate);
6874 }
6875 }
6876
6877 void commit(float switchRate) {
6878 if (should_commit()) {
6879 set_switchRate(switchRate);
6880 commit();
6881 }
6882 }
6883
6884 static void commit(const Ticks& startTicks,
6885 const Ticks& endTicks,
6886 float switchRate) {
6887 EventThreadContextSwitchRate me(UNTIMED);
6888
6889 if (me.should_commit()) {
6890 me.set_starttime(startTicks);
6891 me.set_endtime(endTicks);
6892 me.set_switchRate(switchRate);
6893 me.commit();
6894 }
6895 }
6896
6897#ifdef ASSERT
6898 void verify() const {
6899 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_switchRate");
6900 }
6901#endif
6902};
6903
6904class EventNetworkUtilization : public JfrEvent<EventNetworkUtilization>
6905{
6906 private:
6907 u8 _networkInterface;
6908 s8 _readRate;
6909 s8 _writeRate;
6910
6911 public:
6912 static const bool hasThread = false;
6913 static const bool hasStackTrace = false;
6914 static const bool isInstant = false;
6915 static const bool hasCutoff = false;
6916 static const bool isRequestable = true;
6917 static const JfrEventId eventId = JfrNetworkUtilizationEvent;
6918
6919 EventNetworkUtilization(EventStartTime timing=TIMED) : JfrEvent<EventNetworkUtilization>(timing) {}
6920
6921 void set_networkInterface(u8 new_value) {
6922 this->_networkInterface = new_value;
6923 DEBUG_ONLY(set_field_bit(0));
6924 }
6925 void set_readRate(s8 new_value) {
6926 this->_readRate = new_value;
6927 DEBUG_ONLY(set_field_bit(1));
6928 }
6929 void set_writeRate(s8 new_value) {
6930 this->_writeRate = new_value;
6931 DEBUG_ONLY(set_field_bit(2));
6932 }
6933
6934 template <typename Writer>
6935 void writeData(Writer& w) {
6936 w.write(_networkInterface);
6937 w.write(_readRate);
6938 w.write(_writeRate);
6939 }
6940
6941 using JfrEvent<EventNetworkUtilization>::commit; // else commit() is hidden by overloaded versions in this class
6942
6943 EventNetworkUtilization(
6944 u8 networkInterface,
6945 s8 readRate,
6946 s8 writeRate) : JfrEvent<EventNetworkUtilization>(TIMED) {
6947 if (should_commit()) {
6948 set_networkInterface(networkInterface);
6949 set_readRate(readRate);
6950 set_writeRate(writeRate);
6951 }
6952 }
6953
6954 void commit(u8 networkInterface,
6955 s8 readRate,
6956 s8 writeRate) {
6957 if (should_commit()) {
6958 set_networkInterface(networkInterface);
6959 set_readRate(readRate);
6960 set_writeRate(writeRate);
6961 commit();
6962 }
6963 }
6964
6965 static void commit(const Ticks& startTicks,
6966 const Ticks& endTicks,
6967 u8 networkInterface,
6968 s8 readRate,
6969 s8 writeRate) {
6970 EventNetworkUtilization me(UNTIMED);
6971
6972 if (me.should_commit()) {
6973 me.set_starttime(startTicks);
6974 me.set_endtime(endTicks);
6975 me.set_networkInterface(networkInterface);
6976 me.set_readRate(readRate);
6977 me.set_writeRate(writeRate);
6978 me.commit();
6979 }
6980 }
6981
6982#ifdef ASSERT
6983 void verify() const {
6984 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_networkInterface");
6985 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_readRate");
6986 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_writeRate");
6987 }
6988#endif
6989};
6990
6991class EventJavaThreadStatistics : public JfrEvent<EventJavaThreadStatistics>
6992{
6993 private:
6994 s8 _activeCount;
6995 s8 _daemonCount;
6996 s8 _accumulatedCount;
6997 s8 _peakCount;
6998
6999 public:
7000 static const bool hasThread = false;
7001 static const bool hasStackTrace = false;
7002 static const bool isInstant = false;
7003 static const bool hasCutoff = false;
7004 static const bool isRequestable = true;
7005 static const JfrEventId eventId = JfrJavaThreadStatisticsEvent;
7006
7007 EventJavaThreadStatistics(EventStartTime timing=TIMED) : JfrEvent<EventJavaThreadStatistics>(timing) {}
7008
7009 void set_activeCount(s8 new_value) {
7010 this->_activeCount = new_value;
7011 DEBUG_ONLY(set_field_bit(0));
7012 }
7013 void set_daemonCount(s8 new_value) {
7014 this->_daemonCount = new_value;
7015 DEBUG_ONLY(set_field_bit(1));
7016 }
7017 void set_accumulatedCount(s8 new_value) {
7018 this->_accumulatedCount = new_value;
7019 DEBUG_ONLY(set_field_bit(2));
7020 }
7021 void set_peakCount(s8 new_value) {
7022 this->_peakCount = new_value;
7023 DEBUG_ONLY(set_field_bit(3));
7024 }
7025
7026 template <typename Writer>
7027 void writeData(Writer& w) {
7028 w.write(_activeCount);
7029 w.write(_daemonCount);
7030 w.write(_accumulatedCount);
7031 w.write(_peakCount);
7032 }
7033
7034 using JfrEvent<EventJavaThreadStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7035
7036 EventJavaThreadStatistics(
7037 s8 activeCount,
7038 s8 daemonCount,
7039 s8 accumulatedCount,
7040 s8 peakCount) : JfrEvent<EventJavaThreadStatistics>(TIMED) {
7041 if (should_commit()) {
7042 set_activeCount(activeCount);
7043 set_daemonCount(daemonCount);
7044 set_accumulatedCount(accumulatedCount);
7045 set_peakCount(peakCount);
7046 }
7047 }
7048
7049 void commit(s8 activeCount,
7050 s8 daemonCount,
7051 s8 accumulatedCount,
7052 s8 peakCount) {
7053 if (should_commit()) {
7054 set_activeCount(activeCount);
7055 set_daemonCount(daemonCount);
7056 set_accumulatedCount(accumulatedCount);
7057 set_peakCount(peakCount);
7058 commit();
7059 }
7060 }
7061
7062 static void commit(const Ticks& startTicks,
7063 const Ticks& endTicks,
7064 s8 activeCount,
7065 s8 daemonCount,
7066 s8 accumulatedCount,
7067 s8 peakCount) {
7068 EventJavaThreadStatistics me(UNTIMED);
7069
7070 if (me.should_commit()) {
7071 me.set_starttime(startTicks);
7072 me.set_endtime(endTicks);
7073 me.set_activeCount(activeCount);
7074 me.set_daemonCount(daemonCount);
7075 me.set_accumulatedCount(accumulatedCount);
7076 me.set_peakCount(peakCount);
7077 me.commit();
7078 }
7079 }
7080
7081#ifdef ASSERT
7082 void verify() const {
7083 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_activeCount");
7084 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_daemonCount");
7085 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_accumulatedCount");
7086 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_peakCount");
7087 }
7088#endif
7089};
7090
7091class EventClassLoadingStatistics : public JfrEvent<EventClassLoadingStatistics>
7092{
7093 private:
7094 s8 _loadedClassCount;
7095 s8 _unloadedClassCount;
7096
7097 public:
7098 static const bool hasThread = false;
7099 static const bool hasStackTrace = false;
7100 static const bool isInstant = false;
7101 static const bool hasCutoff = false;
7102 static const bool isRequestable = true;
7103 static const JfrEventId eventId = JfrClassLoadingStatisticsEvent;
7104
7105 EventClassLoadingStatistics(EventStartTime timing=TIMED) : JfrEvent<EventClassLoadingStatistics>(timing) {}
7106
7107 void set_loadedClassCount(s8 new_value) {
7108 this->_loadedClassCount = new_value;
7109 DEBUG_ONLY(set_field_bit(0));
7110 }
7111 void set_unloadedClassCount(s8 new_value) {
7112 this->_unloadedClassCount = new_value;
7113 DEBUG_ONLY(set_field_bit(1));
7114 }
7115
7116 template <typename Writer>
7117 void writeData(Writer& w) {
7118 w.write(_loadedClassCount);
7119 w.write(_unloadedClassCount);
7120 }
7121
7122 using JfrEvent<EventClassLoadingStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7123
7124 EventClassLoadingStatistics(
7125 s8 loadedClassCount,
7126 s8 unloadedClassCount) : JfrEvent<EventClassLoadingStatistics>(TIMED) {
7127 if (should_commit()) {
7128 set_loadedClassCount(loadedClassCount);
7129 set_unloadedClassCount(unloadedClassCount);
7130 }
7131 }
7132
7133 void commit(s8 loadedClassCount,
7134 s8 unloadedClassCount) {
7135 if (should_commit()) {
7136 set_loadedClassCount(loadedClassCount);
7137 set_unloadedClassCount(unloadedClassCount);
7138 commit();
7139 }
7140 }
7141
7142 static void commit(const Ticks& startTicks,
7143 const Ticks& endTicks,
7144 s8 loadedClassCount,
7145 s8 unloadedClassCount) {
7146 EventClassLoadingStatistics me(UNTIMED);
7147
7148 if (me.should_commit()) {
7149 me.set_starttime(startTicks);
7150 me.set_endtime(endTicks);
7151 me.set_loadedClassCount(loadedClassCount);
7152 me.set_unloadedClassCount(unloadedClassCount);
7153 me.commit();
7154 }
7155 }
7156
7157#ifdef ASSERT
7158 void verify() const {
7159 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_loadedClassCount");
7160 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_unloadedClassCount");
7161 }
7162#endif
7163};
7164
7165class EventClassLoaderStatistics : public JfrEvent<EventClassLoaderStatistics>
7166{
7167 private:
7168 const ClassLoaderData* _classLoader;
7169 const ClassLoaderData* _parentClassLoader;
7170 u8 _classLoaderData;
7171 s8 _classCount;
7172 u8 _chunkSize;
7173 u8 _blockSize;
7174 s8 _unsafeAnonymousClassCount;
7175 u8 _unsafeAnonymousChunkSize;
7176 u8 _unsafeAnonymousBlockSize;
7177
7178 public:
7179 static const bool hasThread = false;
7180 static const bool hasStackTrace = false;
7181 static const bool isInstant = false;
7182 static const bool hasCutoff = false;
7183 static const bool isRequestable = true;
7184 static const JfrEventId eventId = JfrClassLoaderStatisticsEvent;
7185
7186 EventClassLoaderStatistics(EventStartTime timing=TIMED) : JfrEvent<EventClassLoaderStatistics>(timing) {}
7187
7188 void set_classLoader(const ClassLoaderData* new_value) {
7189 this->_classLoader = new_value;
7190 DEBUG_ONLY(set_field_bit(0));
7191 }
7192 void set_parentClassLoader(const ClassLoaderData* new_value) {
7193 this->_parentClassLoader = new_value;
7194 DEBUG_ONLY(set_field_bit(1));
7195 }
7196 void set_classLoaderData(u8 new_value) {
7197 this->_classLoaderData = new_value;
7198 DEBUG_ONLY(set_field_bit(2));
7199 }
7200 void set_classCount(s8 new_value) {
7201 this->_classCount = new_value;
7202 DEBUG_ONLY(set_field_bit(3));
7203 }
7204 void set_chunkSize(u8 new_value) {
7205 this->_chunkSize = new_value;
7206 DEBUG_ONLY(set_field_bit(4));
7207 }
7208 void set_blockSize(u8 new_value) {
7209 this->_blockSize = new_value;
7210 DEBUG_ONLY(set_field_bit(5));
7211 }
7212 void set_unsafeAnonymousClassCount(s8 new_value) {
7213 this->_unsafeAnonymousClassCount = new_value;
7214 DEBUG_ONLY(set_field_bit(6));
7215 }
7216 void set_unsafeAnonymousChunkSize(u8 new_value) {
7217 this->_unsafeAnonymousChunkSize = new_value;
7218 DEBUG_ONLY(set_field_bit(7));
7219 }
7220 void set_unsafeAnonymousBlockSize(u8 new_value) {
7221 this->_unsafeAnonymousBlockSize = new_value;
7222 DEBUG_ONLY(set_field_bit(8));
7223 }
7224
7225 template <typename Writer>
7226 void writeData(Writer& w) {
7227 w.write(_classLoader);
7228 w.write(_parentClassLoader);
7229 w.write(_classLoaderData);
7230 w.write(_classCount);
7231 w.write(_chunkSize);
7232 w.write(_blockSize);
7233 w.write(_unsafeAnonymousClassCount);
7234 w.write(_unsafeAnonymousChunkSize);
7235 w.write(_unsafeAnonymousBlockSize);
7236 }
7237
7238 using JfrEvent<EventClassLoaderStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7239
7240 EventClassLoaderStatistics(
7241 const ClassLoaderData* classLoader,
7242 const ClassLoaderData* parentClassLoader,
7243 u8 classLoaderData,
7244 s8 classCount,
7245 u8 chunkSize,
7246 u8 blockSize,
7247 s8 unsafeAnonymousClassCount,
7248 u8 unsafeAnonymousChunkSize,
7249 u8 unsafeAnonymousBlockSize) : JfrEvent<EventClassLoaderStatistics>(TIMED) {
7250 if (should_commit()) {
7251 set_classLoader(classLoader);
7252 set_parentClassLoader(parentClassLoader);
7253 set_classLoaderData(classLoaderData);
7254 set_classCount(classCount);
7255 set_chunkSize(chunkSize);
7256 set_blockSize(blockSize);
7257 set_unsafeAnonymousClassCount(unsafeAnonymousClassCount);
7258 set_unsafeAnonymousChunkSize(unsafeAnonymousChunkSize);
7259 set_unsafeAnonymousBlockSize(unsafeAnonymousBlockSize);
7260 }
7261 }
7262
7263 void commit(const ClassLoaderData* classLoader,
7264 const ClassLoaderData* parentClassLoader,
7265 u8 classLoaderData,
7266 s8 classCount,
7267 u8 chunkSize,
7268 u8 blockSize,
7269 s8 unsafeAnonymousClassCount,
7270 u8 unsafeAnonymousChunkSize,
7271 u8 unsafeAnonymousBlockSize) {
7272 if (should_commit()) {
7273 set_classLoader(classLoader);
7274 set_parentClassLoader(parentClassLoader);
7275 set_classLoaderData(classLoaderData);
7276 set_classCount(classCount);
7277 set_chunkSize(chunkSize);
7278 set_blockSize(blockSize);
7279 set_unsafeAnonymousClassCount(unsafeAnonymousClassCount);
7280 set_unsafeAnonymousChunkSize(unsafeAnonymousChunkSize);
7281 set_unsafeAnonymousBlockSize(unsafeAnonymousBlockSize);
7282 commit();
7283 }
7284 }
7285
7286 static void commit(const Ticks& startTicks,
7287 const Ticks& endTicks,
7288 const ClassLoaderData* classLoader,
7289 const ClassLoaderData* parentClassLoader,
7290 u8 classLoaderData,
7291 s8 classCount,
7292 u8 chunkSize,
7293 u8 blockSize,
7294 s8 unsafeAnonymousClassCount,
7295 u8 unsafeAnonymousChunkSize,
7296 u8 unsafeAnonymousBlockSize) {
7297 EventClassLoaderStatistics me(UNTIMED);
7298
7299 if (me.should_commit()) {
7300 me.set_starttime(startTicks);
7301 me.set_endtime(endTicks);
7302 me.set_classLoader(classLoader);
7303 me.set_parentClassLoader(parentClassLoader);
7304 me.set_classLoaderData(classLoaderData);
7305 me.set_classCount(classCount);
7306 me.set_chunkSize(chunkSize);
7307 me.set_blockSize(blockSize);
7308 me.set_unsafeAnonymousClassCount(unsafeAnonymousClassCount);
7309 me.set_unsafeAnonymousChunkSize(unsafeAnonymousChunkSize);
7310 me.set_unsafeAnonymousBlockSize(unsafeAnonymousBlockSize);
7311 me.commit();
7312 }
7313 }
7314
7315#ifdef ASSERT
7316 void verify() const {
7317 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_classLoader");
7318 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_parentClassLoader");
7319 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_classLoaderData");
7320 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_classCount");
7321 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_chunkSize");
7322 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_blockSize");
7323 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_unsafeAnonymousClassCount");
7324 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_unsafeAnonymousChunkSize");
7325 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_unsafeAnonymousBlockSize");
7326 }
7327#endif
7328};
7329
7330class EventSymbolTableStatistics : public JfrEvent<EventSymbolTableStatistics>
7331{
7332 private:
7333 u8 _bucketCount;
7334 u8 _entryCount;
7335 u8 _totalFootprint;
7336 u8 _bucketCountMaximum;
7337 float _bucketCountAverage;
7338 float _bucketCountVariance;
7339 float _bucketCountStandardDeviation;
7340 float _insertionRate;
7341 float _removalRate;
7342
7343 public:
7344 static const bool hasThread = false;
7345 static const bool hasStackTrace = false;
7346 static const bool isInstant = false;
7347 static const bool hasCutoff = false;
7348 static const bool isRequestable = true;
7349 static const JfrEventId eventId = JfrSymbolTableStatisticsEvent;
7350
7351 EventSymbolTableStatistics(EventStartTime timing=TIMED) : JfrEvent<EventSymbolTableStatistics>(timing) {}
7352
7353 void set_bucketCount(u8 new_value) {
7354 this->_bucketCount = new_value;
7355 DEBUG_ONLY(set_field_bit(0));
7356 }
7357 void set_entryCount(u8 new_value) {
7358 this->_entryCount = new_value;
7359 DEBUG_ONLY(set_field_bit(1));
7360 }
7361 void set_totalFootprint(u8 new_value) {
7362 this->_totalFootprint = new_value;
7363 DEBUG_ONLY(set_field_bit(2));
7364 }
7365 void set_bucketCountMaximum(u8 new_value) {
7366 this->_bucketCountMaximum = new_value;
7367 DEBUG_ONLY(set_field_bit(3));
7368 }
7369 void set_bucketCountAverage(float new_value) {
7370 this->_bucketCountAverage = new_value;
7371 DEBUG_ONLY(set_field_bit(4));
7372 }
7373 void set_bucketCountVariance(float new_value) {
7374 this->_bucketCountVariance = new_value;
7375 DEBUG_ONLY(set_field_bit(5));
7376 }
7377 void set_bucketCountStandardDeviation(float new_value) {
7378 this->_bucketCountStandardDeviation = new_value;
7379 DEBUG_ONLY(set_field_bit(6));
7380 }
7381 void set_insertionRate(float new_value) {
7382 this->_insertionRate = new_value;
7383 DEBUG_ONLY(set_field_bit(7));
7384 }
7385 void set_removalRate(float new_value) {
7386 this->_removalRate = new_value;
7387 DEBUG_ONLY(set_field_bit(8));
7388 }
7389
7390 template <typename Writer>
7391 void writeData(Writer& w) {
7392 w.write(_bucketCount);
7393 w.write(_entryCount);
7394 w.write(_totalFootprint);
7395 w.write(_bucketCountMaximum);
7396 w.write(_bucketCountAverage);
7397 w.write(_bucketCountVariance);
7398 w.write(_bucketCountStandardDeviation);
7399 w.write(_insertionRate);
7400 w.write(_removalRate);
7401 }
7402
7403 using JfrEvent<EventSymbolTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7404
7405 EventSymbolTableStatistics(
7406 u8 bucketCount,
7407 u8 entryCount,
7408 u8 totalFootprint,
7409 u8 bucketCountMaximum,
7410 float bucketCountAverage,
7411 float bucketCountVariance,
7412 float bucketCountStandardDeviation,
7413 float insertionRate,
7414 float removalRate) : JfrEvent<EventSymbolTableStatistics>(TIMED) {
7415 if (should_commit()) {
7416 set_bucketCount(bucketCount);
7417 set_entryCount(entryCount);
7418 set_totalFootprint(totalFootprint);
7419 set_bucketCountMaximum(bucketCountMaximum);
7420 set_bucketCountAverage(bucketCountAverage);
7421 set_bucketCountVariance(bucketCountVariance);
7422 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7423 set_insertionRate(insertionRate);
7424 set_removalRate(removalRate);
7425 }
7426 }
7427
7428 void commit(u8 bucketCount,
7429 u8 entryCount,
7430 u8 totalFootprint,
7431 u8 bucketCountMaximum,
7432 float bucketCountAverage,
7433 float bucketCountVariance,
7434 float bucketCountStandardDeviation,
7435 float insertionRate,
7436 float removalRate) {
7437 if (should_commit()) {
7438 set_bucketCount(bucketCount);
7439 set_entryCount(entryCount);
7440 set_totalFootprint(totalFootprint);
7441 set_bucketCountMaximum(bucketCountMaximum);
7442 set_bucketCountAverage(bucketCountAverage);
7443 set_bucketCountVariance(bucketCountVariance);
7444 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7445 set_insertionRate(insertionRate);
7446 set_removalRate(removalRate);
7447 commit();
7448 }
7449 }
7450
7451 static void commit(const Ticks& startTicks,
7452 const Ticks& endTicks,
7453 u8 bucketCount,
7454 u8 entryCount,
7455 u8 totalFootprint,
7456 u8 bucketCountMaximum,
7457 float bucketCountAverage,
7458 float bucketCountVariance,
7459 float bucketCountStandardDeviation,
7460 float insertionRate,
7461 float removalRate) {
7462 EventSymbolTableStatistics me(UNTIMED);
7463
7464 if (me.should_commit()) {
7465 me.set_starttime(startTicks);
7466 me.set_endtime(endTicks);
7467 me.set_bucketCount(bucketCount);
7468 me.set_entryCount(entryCount);
7469 me.set_totalFootprint(totalFootprint);
7470 me.set_bucketCountMaximum(bucketCountMaximum);
7471 me.set_bucketCountAverage(bucketCountAverage);
7472 me.set_bucketCountVariance(bucketCountVariance);
7473 me.set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7474 me.set_insertionRate(insertionRate);
7475 me.set_removalRate(removalRate);
7476 me.commit();
7477 }
7478 }
7479
7480#ifdef ASSERT
7481 void verify() const {
7482 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_bucketCount");
7483 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_entryCount");
7484 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalFootprint");
7485 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_bucketCountMaximum");
7486 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_bucketCountAverage");
7487 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bucketCountVariance");
7488 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_bucketCountStandardDeviation");
7489 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_insertionRate");
7490 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_removalRate");
7491 }
7492#endif
7493};
7494
7495class EventStringTableStatistics : public JfrEvent<EventStringTableStatistics>
7496{
7497 private:
7498 u8 _bucketCount;
7499 u8 _entryCount;
7500 u8 _totalFootprint;
7501 u8 _bucketCountMaximum;
7502 float _bucketCountAverage;
7503 float _bucketCountVariance;
7504 float _bucketCountStandardDeviation;
7505 float _insertionRate;
7506 float _removalRate;
7507
7508 public:
7509 static const bool hasThread = false;
7510 static const bool hasStackTrace = false;
7511 static const bool isInstant = false;
7512 static const bool hasCutoff = false;
7513 static const bool isRequestable = true;
7514 static const JfrEventId eventId = JfrStringTableStatisticsEvent;
7515
7516 EventStringTableStatistics(EventStartTime timing=TIMED) : JfrEvent<EventStringTableStatistics>(timing) {}
7517
7518 void set_bucketCount(u8 new_value) {
7519 this->_bucketCount = new_value;
7520 DEBUG_ONLY(set_field_bit(0));
7521 }
7522 void set_entryCount(u8 new_value) {
7523 this->_entryCount = new_value;
7524 DEBUG_ONLY(set_field_bit(1));
7525 }
7526 void set_totalFootprint(u8 new_value) {
7527 this->_totalFootprint = new_value;
7528 DEBUG_ONLY(set_field_bit(2));
7529 }
7530 void set_bucketCountMaximum(u8 new_value) {
7531 this->_bucketCountMaximum = new_value;
7532 DEBUG_ONLY(set_field_bit(3));
7533 }
7534 void set_bucketCountAverage(float new_value) {
7535 this->_bucketCountAverage = new_value;
7536 DEBUG_ONLY(set_field_bit(4));
7537 }
7538 void set_bucketCountVariance(float new_value) {
7539 this->_bucketCountVariance = new_value;
7540 DEBUG_ONLY(set_field_bit(5));
7541 }
7542 void set_bucketCountStandardDeviation(float new_value) {
7543 this->_bucketCountStandardDeviation = new_value;
7544 DEBUG_ONLY(set_field_bit(6));
7545 }
7546 void set_insertionRate(float new_value) {
7547 this->_insertionRate = new_value;
7548 DEBUG_ONLY(set_field_bit(7));
7549 }
7550 void set_removalRate(float new_value) {
7551 this->_removalRate = new_value;
7552 DEBUG_ONLY(set_field_bit(8));
7553 }
7554
7555 template <typename Writer>
7556 void writeData(Writer& w) {
7557 w.write(_bucketCount);
7558 w.write(_entryCount);
7559 w.write(_totalFootprint);
7560 w.write(_bucketCountMaximum);
7561 w.write(_bucketCountAverage);
7562 w.write(_bucketCountVariance);
7563 w.write(_bucketCountStandardDeviation);
7564 w.write(_insertionRate);
7565 w.write(_removalRate);
7566 }
7567
7568 using JfrEvent<EventStringTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7569
7570 EventStringTableStatistics(
7571 u8 bucketCount,
7572 u8 entryCount,
7573 u8 totalFootprint,
7574 u8 bucketCountMaximum,
7575 float bucketCountAverage,
7576 float bucketCountVariance,
7577 float bucketCountStandardDeviation,
7578 float insertionRate,
7579 float removalRate) : JfrEvent<EventStringTableStatistics>(TIMED) {
7580 if (should_commit()) {
7581 set_bucketCount(bucketCount);
7582 set_entryCount(entryCount);
7583 set_totalFootprint(totalFootprint);
7584 set_bucketCountMaximum(bucketCountMaximum);
7585 set_bucketCountAverage(bucketCountAverage);
7586 set_bucketCountVariance(bucketCountVariance);
7587 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7588 set_insertionRate(insertionRate);
7589 set_removalRate(removalRate);
7590 }
7591 }
7592
7593 void commit(u8 bucketCount,
7594 u8 entryCount,
7595 u8 totalFootprint,
7596 u8 bucketCountMaximum,
7597 float bucketCountAverage,
7598 float bucketCountVariance,
7599 float bucketCountStandardDeviation,
7600 float insertionRate,
7601 float removalRate) {
7602 if (should_commit()) {
7603 set_bucketCount(bucketCount);
7604 set_entryCount(entryCount);
7605 set_totalFootprint(totalFootprint);
7606 set_bucketCountMaximum(bucketCountMaximum);
7607 set_bucketCountAverage(bucketCountAverage);
7608 set_bucketCountVariance(bucketCountVariance);
7609 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7610 set_insertionRate(insertionRate);
7611 set_removalRate(removalRate);
7612 commit();
7613 }
7614 }
7615
7616 static void commit(const Ticks& startTicks,
7617 const Ticks& endTicks,
7618 u8 bucketCount,
7619 u8 entryCount,
7620 u8 totalFootprint,
7621 u8 bucketCountMaximum,
7622 float bucketCountAverage,
7623 float bucketCountVariance,
7624 float bucketCountStandardDeviation,
7625 float insertionRate,
7626 float removalRate) {
7627 EventStringTableStatistics me(UNTIMED);
7628
7629 if (me.should_commit()) {
7630 me.set_starttime(startTicks);
7631 me.set_endtime(endTicks);
7632 me.set_bucketCount(bucketCount);
7633 me.set_entryCount(entryCount);
7634 me.set_totalFootprint(totalFootprint);
7635 me.set_bucketCountMaximum(bucketCountMaximum);
7636 me.set_bucketCountAverage(bucketCountAverage);
7637 me.set_bucketCountVariance(bucketCountVariance);
7638 me.set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7639 me.set_insertionRate(insertionRate);
7640 me.set_removalRate(removalRate);
7641 me.commit();
7642 }
7643 }
7644
7645#ifdef ASSERT
7646 void verify() const {
7647 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_bucketCount");
7648 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_entryCount");
7649 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalFootprint");
7650 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_bucketCountMaximum");
7651 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_bucketCountAverage");
7652 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bucketCountVariance");
7653 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_bucketCountStandardDeviation");
7654 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_insertionRate");
7655 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_removalRate");
7656 }
7657#endif
7658};
7659
7660class EventPlaceholderTableStatistics : public JfrEvent<EventPlaceholderTableStatistics>
7661{
7662 private:
7663 u8 _bucketCount;
7664 u8 _entryCount;
7665 u8 _totalFootprint;
7666 u8 _bucketCountMaximum;
7667 float _bucketCountAverage;
7668 float _bucketCountVariance;
7669 float _bucketCountStandardDeviation;
7670 float _insertionRate;
7671 float _removalRate;
7672
7673 public:
7674 static const bool hasThread = false;
7675 static const bool hasStackTrace = false;
7676 static const bool isInstant = false;
7677 static const bool hasCutoff = false;
7678 static const bool isRequestable = true;
7679 static const JfrEventId eventId = JfrPlaceholderTableStatisticsEvent;
7680
7681 EventPlaceholderTableStatistics(EventStartTime timing=TIMED) : JfrEvent<EventPlaceholderTableStatistics>(timing) {}
7682
7683 void set_bucketCount(u8 new_value) {
7684 this->_bucketCount = new_value;
7685 DEBUG_ONLY(set_field_bit(0));
7686 }
7687 void set_entryCount(u8 new_value) {
7688 this->_entryCount = new_value;
7689 DEBUG_ONLY(set_field_bit(1));
7690 }
7691 void set_totalFootprint(u8 new_value) {
7692 this->_totalFootprint = new_value;
7693 DEBUG_ONLY(set_field_bit(2));
7694 }
7695 void set_bucketCountMaximum(u8 new_value) {
7696 this->_bucketCountMaximum = new_value;
7697 DEBUG_ONLY(set_field_bit(3));
7698 }
7699 void set_bucketCountAverage(float new_value) {
7700 this->_bucketCountAverage = new_value;
7701 DEBUG_ONLY(set_field_bit(4));
7702 }
7703 void set_bucketCountVariance(float new_value) {
7704 this->_bucketCountVariance = new_value;
7705 DEBUG_ONLY(set_field_bit(5));
7706 }
7707 void set_bucketCountStandardDeviation(float new_value) {
7708 this->_bucketCountStandardDeviation = new_value;
7709 DEBUG_ONLY(set_field_bit(6));
7710 }
7711 void set_insertionRate(float new_value) {
7712 this->_insertionRate = new_value;
7713 DEBUG_ONLY(set_field_bit(7));
7714 }
7715 void set_removalRate(float new_value) {
7716 this->_removalRate = new_value;
7717 DEBUG_ONLY(set_field_bit(8));
7718 }
7719
7720 template <typename Writer>
7721 void writeData(Writer& w) {
7722 w.write(_bucketCount);
7723 w.write(_entryCount);
7724 w.write(_totalFootprint);
7725 w.write(_bucketCountMaximum);
7726 w.write(_bucketCountAverage);
7727 w.write(_bucketCountVariance);
7728 w.write(_bucketCountStandardDeviation);
7729 w.write(_insertionRate);
7730 w.write(_removalRate);
7731 }
7732
7733 using JfrEvent<EventPlaceholderTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7734
7735 EventPlaceholderTableStatistics(
7736 u8 bucketCount,
7737 u8 entryCount,
7738 u8 totalFootprint,
7739 u8 bucketCountMaximum,
7740 float bucketCountAverage,
7741 float bucketCountVariance,
7742 float bucketCountStandardDeviation,
7743 float insertionRate,
7744 float removalRate) : JfrEvent<EventPlaceholderTableStatistics>(TIMED) {
7745 if (should_commit()) {
7746 set_bucketCount(bucketCount);
7747 set_entryCount(entryCount);
7748 set_totalFootprint(totalFootprint);
7749 set_bucketCountMaximum(bucketCountMaximum);
7750 set_bucketCountAverage(bucketCountAverage);
7751 set_bucketCountVariance(bucketCountVariance);
7752 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7753 set_insertionRate(insertionRate);
7754 set_removalRate(removalRate);
7755 }
7756 }
7757
7758 void commit(u8 bucketCount,
7759 u8 entryCount,
7760 u8 totalFootprint,
7761 u8 bucketCountMaximum,
7762 float bucketCountAverage,
7763 float bucketCountVariance,
7764 float bucketCountStandardDeviation,
7765 float insertionRate,
7766 float removalRate) {
7767 if (should_commit()) {
7768 set_bucketCount(bucketCount);
7769 set_entryCount(entryCount);
7770 set_totalFootprint(totalFootprint);
7771 set_bucketCountMaximum(bucketCountMaximum);
7772 set_bucketCountAverage(bucketCountAverage);
7773 set_bucketCountVariance(bucketCountVariance);
7774 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7775 set_insertionRate(insertionRate);
7776 set_removalRate(removalRate);
7777 commit();
7778 }
7779 }
7780
7781 static void commit(const Ticks& startTicks,
7782 const Ticks& endTicks,
7783 u8 bucketCount,
7784 u8 entryCount,
7785 u8 totalFootprint,
7786 u8 bucketCountMaximum,
7787 float bucketCountAverage,
7788 float bucketCountVariance,
7789 float bucketCountStandardDeviation,
7790 float insertionRate,
7791 float removalRate) {
7792 EventPlaceholderTableStatistics me(UNTIMED);
7793
7794 if (me.should_commit()) {
7795 me.set_starttime(startTicks);
7796 me.set_endtime(endTicks);
7797 me.set_bucketCount(bucketCount);
7798 me.set_entryCount(entryCount);
7799 me.set_totalFootprint(totalFootprint);
7800 me.set_bucketCountMaximum(bucketCountMaximum);
7801 me.set_bucketCountAverage(bucketCountAverage);
7802 me.set_bucketCountVariance(bucketCountVariance);
7803 me.set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7804 me.set_insertionRate(insertionRate);
7805 me.set_removalRate(removalRate);
7806 me.commit();
7807 }
7808 }
7809
7810#ifdef ASSERT
7811 void verify() const {
7812 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_bucketCount");
7813 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_entryCount");
7814 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalFootprint");
7815 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_bucketCountMaximum");
7816 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_bucketCountAverage");
7817 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bucketCountVariance");
7818 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_bucketCountStandardDeviation");
7819 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_insertionRate");
7820 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_removalRate");
7821 }
7822#endif
7823};
7824
7825class EventLoaderConstraintsTableStatistics : public JfrEvent<EventLoaderConstraintsTableStatistics>
7826{
7827 private:
7828 u8 _bucketCount;
7829 u8 _entryCount;
7830 u8 _totalFootprint;
7831 u8 _bucketCountMaximum;
7832 float _bucketCountAverage;
7833 float _bucketCountVariance;
7834 float _bucketCountStandardDeviation;
7835 float _insertionRate;
7836 float _removalRate;
7837
7838 public:
7839 static const bool hasThread = false;
7840 static const bool hasStackTrace = false;
7841 static const bool isInstant = false;
7842 static const bool hasCutoff = false;
7843 static const bool isRequestable = true;
7844 static const JfrEventId eventId = JfrLoaderConstraintsTableStatisticsEvent;
7845
7846 EventLoaderConstraintsTableStatistics(EventStartTime timing=TIMED) : JfrEvent<EventLoaderConstraintsTableStatistics>(timing) {}
7847
7848 void set_bucketCount(u8 new_value) {
7849 this->_bucketCount = new_value;
7850 DEBUG_ONLY(set_field_bit(0));
7851 }
7852 void set_entryCount(u8 new_value) {
7853 this->_entryCount = new_value;
7854 DEBUG_ONLY(set_field_bit(1));
7855 }
7856 void set_totalFootprint(u8 new_value) {
7857 this->_totalFootprint = new_value;
7858 DEBUG_ONLY(set_field_bit(2));
7859 }
7860 void set_bucketCountMaximum(u8 new_value) {
7861 this->_bucketCountMaximum = new_value;
7862 DEBUG_ONLY(set_field_bit(3));
7863 }
7864 void set_bucketCountAverage(float new_value) {
7865 this->_bucketCountAverage = new_value;
7866 DEBUG_ONLY(set_field_bit(4));
7867 }
7868 void set_bucketCountVariance(float new_value) {
7869 this->_bucketCountVariance = new_value;
7870 DEBUG_ONLY(set_field_bit(5));
7871 }
7872 void set_bucketCountStandardDeviation(float new_value) {
7873 this->_bucketCountStandardDeviation = new_value;
7874 DEBUG_ONLY(set_field_bit(6));
7875 }
7876 void set_insertionRate(float new_value) {
7877 this->_insertionRate = new_value;
7878 DEBUG_ONLY(set_field_bit(7));
7879 }
7880 void set_removalRate(float new_value) {
7881 this->_removalRate = new_value;
7882 DEBUG_ONLY(set_field_bit(8));
7883 }
7884
7885 template <typename Writer>
7886 void writeData(Writer& w) {
7887 w.write(_bucketCount);
7888 w.write(_entryCount);
7889 w.write(_totalFootprint);
7890 w.write(_bucketCountMaximum);
7891 w.write(_bucketCountAverage);
7892 w.write(_bucketCountVariance);
7893 w.write(_bucketCountStandardDeviation);
7894 w.write(_insertionRate);
7895 w.write(_removalRate);
7896 }
7897
7898 using JfrEvent<EventLoaderConstraintsTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
7899
7900 EventLoaderConstraintsTableStatistics(
7901 u8 bucketCount,
7902 u8 entryCount,
7903 u8 totalFootprint,
7904 u8 bucketCountMaximum,
7905 float bucketCountAverage,
7906 float bucketCountVariance,
7907 float bucketCountStandardDeviation,
7908 float insertionRate,
7909 float removalRate) : JfrEvent<EventLoaderConstraintsTableStatistics>(TIMED) {
7910 if (should_commit()) {
7911 set_bucketCount(bucketCount);
7912 set_entryCount(entryCount);
7913 set_totalFootprint(totalFootprint);
7914 set_bucketCountMaximum(bucketCountMaximum);
7915 set_bucketCountAverage(bucketCountAverage);
7916 set_bucketCountVariance(bucketCountVariance);
7917 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7918 set_insertionRate(insertionRate);
7919 set_removalRate(removalRate);
7920 }
7921 }
7922
7923 void commit(u8 bucketCount,
7924 u8 entryCount,
7925 u8 totalFootprint,
7926 u8 bucketCountMaximum,
7927 float bucketCountAverage,
7928 float bucketCountVariance,
7929 float bucketCountStandardDeviation,
7930 float insertionRate,
7931 float removalRate) {
7932 if (should_commit()) {
7933 set_bucketCount(bucketCount);
7934 set_entryCount(entryCount);
7935 set_totalFootprint(totalFootprint);
7936 set_bucketCountMaximum(bucketCountMaximum);
7937 set_bucketCountAverage(bucketCountAverage);
7938 set_bucketCountVariance(bucketCountVariance);
7939 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7940 set_insertionRate(insertionRate);
7941 set_removalRate(removalRate);
7942 commit();
7943 }
7944 }
7945
7946 static void commit(const Ticks& startTicks,
7947 const Ticks& endTicks,
7948 u8 bucketCount,
7949 u8 entryCount,
7950 u8 totalFootprint,
7951 u8 bucketCountMaximum,
7952 float bucketCountAverage,
7953 float bucketCountVariance,
7954 float bucketCountStandardDeviation,
7955 float insertionRate,
7956 float removalRate) {
7957 EventLoaderConstraintsTableStatistics me(UNTIMED);
7958
7959 if (me.should_commit()) {
7960 me.set_starttime(startTicks);
7961 me.set_endtime(endTicks);
7962 me.set_bucketCount(bucketCount);
7963 me.set_entryCount(entryCount);
7964 me.set_totalFootprint(totalFootprint);
7965 me.set_bucketCountMaximum(bucketCountMaximum);
7966 me.set_bucketCountAverage(bucketCountAverage);
7967 me.set_bucketCountVariance(bucketCountVariance);
7968 me.set_bucketCountStandardDeviation(bucketCountStandardDeviation);
7969 me.set_insertionRate(insertionRate);
7970 me.set_removalRate(removalRate);
7971 me.commit();
7972 }
7973 }
7974
7975#ifdef ASSERT
7976 void verify() const {
7977 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_bucketCount");
7978 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_entryCount");
7979 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalFootprint");
7980 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_bucketCountMaximum");
7981 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_bucketCountAverage");
7982 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bucketCountVariance");
7983 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_bucketCountStandardDeviation");
7984 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_insertionRate");
7985 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_removalRate");
7986 }
7987#endif
7988};
7989
7990class EventProtectionDomainCacheTableStatistics : public JfrEvent<EventProtectionDomainCacheTableStatistics>
7991{
7992 private:
7993 u8 _bucketCount;
7994 u8 _entryCount;
7995 u8 _totalFootprint;
7996 u8 _bucketCountMaximum;
7997 float _bucketCountAverage;
7998 float _bucketCountVariance;
7999 float _bucketCountStandardDeviation;
8000 float _insertionRate;
8001 float _removalRate;
8002
8003 public:
8004 static const bool hasThread = false;
8005 static const bool hasStackTrace = false;
8006 static const bool isInstant = false;
8007 static const bool hasCutoff = false;
8008 static const bool isRequestable = true;
8009 static const JfrEventId eventId = JfrProtectionDomainCacheTableStatisticsEvent;
8010
8011 EventProtectionDomainCacheTableStatistics(EventStartTime timing=TIMED) : JfrEvent<EventProtectionDomainCacheTableStatistics>(timing) {}
8012
8013 void set_bucketCount(u8 new_value) {
8014 this->_bucketCount = new_value;
8015 DEBUG_ONLY(set_field_bit(0));
8016 }
8017 void set_entryCount(u8 new_value) {
8018 this->_entryCount = new_value;
8019 DEBUG_ONLY(set_field_bit(1));
8020 }
8021 void set_totalFootprint(u8 new_value) {
8022 this->_totalFootprint = new_value;
8023 DEBUG_ONLY(set_field_bit(2));
8024 }
8025 void set_bucketCountMaximum(u8 new_value) {
8026 this->_bucketCountMaximum = new_value;
8027 DEBUG_ONLY(set_field_bit(3));
8028 }
8029 void set_bucketCountAverage(float new_value) {
8030 this->_bucketCountAverage = new_value;
8031 DEBUG_ONLY(set_field_bit(4));
8032 }
8033 void set_bucketCountVariance(float new_value) {
8034 this->_bucketCountVariance = new_value;
8035 DEBUG_ONLY(set_field_bit(5));
8036 }
8037 void set_bucketCountStandardDeviation(float new_value) {
8038 this->_bucketCountStandardDeviation = new_value;
8039 DEBUG_ONLY(set_field_bit(6));
8040 }
8041 void set_insertionRate(float new_value) {
8042 this->_insertionRate = new_value;
8043 DEBUG_ONLY(set_field_bit(7));
8044 }
8045 void set_removalRate(float new_value) {
8046 this->_removalRate = new_value;
8047 DEBUG_ONLY(set_field_bit(8));
8048 }
8049
8050 template <typename Writer>
8051 void writeData(Writer& w) {
8052 w.write(_bucketCount);
8053 w.write(_entryCount);
8054 w.write(_totalFootprint);
8055 w.write(_bucketCountMaximum);
8056 w.write(_bucketCountAverage);
8057 w.write(_bucketCountVariance);
8058 w.write(_bucketCountStandardDeviation);
8059 w.write(_insertionRate);
8060 w.write(_removalRate);
8061 }
8062
8063 using JfrEvent<EventProtectionDomainCacheTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
8064
8065 EventProtectionDomainCacheTableStatistics(
8066 u8 bucketCount,
8067 u8 entryCount,
8068 u8 totalFootprint,
8069 u8 bucketCountMaximum,
8070 float bucketCountAverage,
8071 float bucketCountVariance,
8072 float bucketCountStandardDeviation,
8073 float insertionRate,
8074 float removalRate) : JfrEvent<EventProtectionDomainCacheTableStatistics>(TIMED) {
8075 if (should_commit()) {
8076 set_bucketCount(bucketCount);
8077 set_entryCount(entryCount);
8078 set_totalFootprint(totalFootprint);
8079 set_bucketCountMaximum(bucketCountMaximum);
8080 set_bucketCountAverage(bucketCountAverage);
8081 set_bucketCountVariance(bucketCountVariance);
8082 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
8083 set_insertionRate(insertionRate);
8084 set_removalRate(removalRate);
8085 }
8086 }
8087
8088 void commit(u8 bucketCount,
8089 u8 entryCount,
8090 u8 totalFootprint,
8091 u8 bucketCountMaximum,
8092 float bucketCountAverage,
8093 float bucketCountVariance,
8094 float bucketCountStandardDeviation,
8095 float insertionRate,
8096 float removalRate) {
8097 if (should_commit()) {
8098 set_bucketCount(bucketCount);
8099 set_entryCount(entryCount);
8100 set_totalFootprint(totalFootprint);
8101 set_bucketCountMaximum(bucketCountMaximum);
8102 set_bucketCountAverage(bucketCountAverage);
8103 set_bucketCountVariance(bucketCountVariance);
8104 set_bucketCountStandardDeviation(bucketCountStandardDeviation);
8105 set_insertionRate(insertionRate);
8106 set_removalRate(removalRate);
8107 commit();
8108 }
8109 }
8110
8111 static void commit(const Ticks& startTicks,
8112 const Ticks& endTicks,
8113 u8 bucketCount,
8114 u8 entryCount,
8115 u8 totalFootprint,
8116 u8 bucketCountMaximum,
8117 float bucketCountAverage,
8118 float bucketCountVariance,
8119 float bucketCountStandardDeviation,
8120 float insertionRate,
8121 float removalRate) {
8122 EventProtectionDomainCacheTableStatistics me(UNTIMED);
8123
8124 if (me.should_commit()) {
8125 me.set_starttime(startTicks);
8126 me.set_endtime(endTicks);
8127 me.set_bucketCount(bucketCount);
8128 me.set_entryCount(entryCount);
8129 me.set_totalFootprint(totalFootprint);
8130 me.set_bucketCountMaximum(bucketCountMaximum);
8131 me.set_bucketCountAverage(bucketCountAverage);
8132 me.set_bucketCountVariance(bucketCountVariance);
8133 me.set_bucketCountStandardDeviation(bucketCountStandardDeviation);
8134 me.set_insertionRate(insertionRate);
8135 me.set_removalRate(removalRate);
8136 me.commit();
8137 }
8138 }
8139
8140#ifdef ASSERT
8141 void verify() const {
8142 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_bucketCount");
8143 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_entryCount");
8144 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalFootprint");
8145 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_bucketCountMaximum");
8146 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_bucketCountAverage");
8147 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_bucketCountVariance");
8148 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_bucketCountStandardDeviation");
8149 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_insertionRate");
8150 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_removalRate");
8151 }
8152#endif
8153};
8154
8155class EventThreadAllocationStatistics : public JfrEvent<EventThreadAllocationStatistics>
8156{
8157 private:
8158 u8 _allocated;
8159 u8 _thread;
8160
8161 public:
8162 static const bool hasThread = false;
8163 static const bool hasStackTrace = false;
8164 static const bool isInstant = false;
8165 static const bool hasCutoff = false;
8166 static const bool isRequestable = true;
8167 static const JfrEventId eventId = JfrThreadAllocationStatisticsEvent;
8168
8169 EventThreadAllocationStatistics(EventStartTime timing=TIMED) : JfrEvent<EventThreadAllocationStatistics>(timing) {}
8170
8171 void set_allocated(u8 new_value) {
8172 this->_allocated = new_value;
8173 DEBUG_ONLY(set_field_bit(0));
8174 }
8175 void set_thread(u8 new_value) {
8176 this->_thread = new_value;
8177 DEBUG_ONLY(set_field_bit(1));
8178 }
8179
8180 template <typename Writer>
8181 void writeData(Writer& w) {
8182 w.write(_allocated);
8183 w.write(_thread);
8184 }
8185
8186 using JfrEvent<EventThreadAllocationStatistics>::commit; // else commit() is hidden by overloaded versions in this class
8187
8188 EventThreadAllocationStatistics(
8189 u8 allocated,
8190 u8 thread) : JfrEvent<EventThreadAllocationStatistics>(TIMED) {
8191 if (should_commit()) {
8192 set_allocated(allocated);
8193 set_thread(thread);
8194 }
8195 }
8196
8197 void commit(u8 allocated,
8198 u8 thread) {
8199 if (should_commit()) {
8200 set_allocated(allocated);
8201 set_thread(thread);
8202 commit();
8203 }
8204 }
8205
8206 static void commit(const Ticks& startTicks,
8207 const Ticks& endTicks,
8208 u8 allocated,
8209 u8 thread) {
8210 EventThreadAllocationStatistics me(UNTIMED);
8211
8212 if (me.should_commit()) {
8213 me.set_starttime(startTicks);
8214 me.set_endtime(endTicks);
8215 me.set_allocated(allocated);
8216 me.set_thread(thread);
8217 me.commit();
8218 }
8219 }
8220
8221#ifdef ASSERT
8222 void verify() const {
8223 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_allocated");
8224 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_thread");
8225 }
8226#endif
8227};
8228
8229class EventPhysicalMemory : public JfrEvent<EventPhysicalMemory>
8230{
8231 private:
8232 u8 _totalSize;
8233 u8 _usedSize;
8234
8235 public:
8236 static const bool hasThread = false;
8237 static const bool hasStackTrace = false;
8238 static const bool isInstant = false;
8239 static const bool hasCutoff = false;
8240 static const bool isRequestable = true;
8241 static const JfrEventId eventId = JfrPhysicalMemoryEvent;
8242
8243 EventPhysicalMemory(EventStartTime timing=TIMED) : JfrEvent<EventPhysicalMemory>(timing) {}
8244
8245 void set_totalSize(u8 new_value) {
8246 this->_totalSize = new_value;
8247 DEBUG_ONLY(set_field_bit(0));
8248 }
8249 void set_usedSize(u8 new_value) {
8250 this->_usedSize = new_value;
8251 DEBUG_ONLY(set_field_bit(1));
8252 }
8253
8254 template <typename Writer>
8255 void writeData(Writer& w) {
8256 w.write(_totalSize);
8257 w.write(_usedSize);
8258 }
8259
8260 using JfrEvent<EventPhysicalMemory>::commit; // else commit() is hidden by overloaded versions in this class
8261
8262 EventPhysicalMemory(
8263 u8 totalSize,
8264 u8 usedSize) : JfrEvent<EventPhysicalMemory>(TIMED) {
8265 if (should_commit()) {
8266 set_totalSize(totalSize);
8267 set_usedSize(usedSize);
8268 }
8269 }
8270
8271 void commit(u8 totalSize,
8272 u8 usedSize) {
8273 if (should_commit()) {
8274 set_totalSize(totalSize);
8275 set_usedSize(usedSize);
8276 commit();
8277 }
8278 }
8279
8280 static void commit(const Ticks& startTicks,
8281 const Ticks& endTicks,
8282 u8 totalSize,
8283 u8 usedSize) {
8284 EventPhysicalMemory me(UNTIMED);
8285
8286 if (me.should_commit()) {
8287 me.set_starttime(startTicks);
8288 me.set_endtime(endTicks);
8289 me.set_totalSize(totalSize);
8290 me.set_usedSize(usedSize);
8291 me.commit();
8292 }
8293 }
8294
8295#ifdef ASSERT
8296 void verify() const {
8297 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_totalSize");
8298 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_usedSize");
8299 }
8300#endif
8301};
8302
8303class EventExecutionSample : public JfrEvent<EventExecutionSample>
8304{
8305 private:
8306 u8 _sampledThread;
8307 u8 _stackTrace;
8308 u8 _state;
8309
8310 public:
8311 static const bool hasThread = false;
8312 static const bool hasStackTrace = false;
8313 static const bool isInstant = false;
8314 static const bool hasCutoff = false;
8315 static const bool isRequestable = true;
8316 static const JfrEventId eventId = JfrExecutionSampleEvent;
8317
8318 EventExecutionSample(EventStartTime timing=TIMED) : JfrEvent<EventExecutionSample>(timing) {}
8319
8320 void set_sampledThread(u8 new_value) {
8321 this->_sampledThread = new_value;
8322 DEBUG_ONLY(set_field_bit(0));
8323 }
8324 void set_stackTrace(u8 new_value) {
8325 this->_stackTrace = new_value;
8326 DEBUG_ONLY(set_field_bit(1));
8327 }
8328 void set_state(u8 new_value) {
8329 this->_state = new_value;
8330 DEBUG_ONLY(set_field_bit(2));
8331 }
8332
8333 template <typename Writer>
8334 void writeData(Writer& w) {
8335 w.write(_sampledThread);
8336 w.write(_stackTrace);
8337 w.write(_state);
8338 }
8339
8340 using JfrEvent<EventExecutionSample>::commit; // else commit() is hidden by overloaded versions in this class
8341
8342 EventExecutionSample(
8343 u8 sampledThread,
8344 u8 stackTrace,
8345 u8 state) : JfrEvent<EventExecutionSample>(TIMED) {
8346 if (should_commit()) {
8347 set_sampledThread(sampledThread);
8348 set_stackTrace(stackTrace);
8349 set_state(state);
8350 }
8351 }
8352
8353 void commit(u8 sampledThread,
8354 u8 stackTrace,
8355 u8 state) {
8356 if (should_commit()) {
8357 set_sampledThread(sampledThread);
8358 set_stackTrace(stackTrace);
8359 set_state(state);
8360 commit();
8361 }
8362 }
8363
8364 static void commit(const Ticks& startTicks,
8365 const Ticks& endTicks,
8366 u8 sampledThread,
8367 u8 stackTrace,
8368 u8 state) {
8369 EventExecutionSample me(UNTIMED);
8370
8371 if (me.should_commit()) {
8372 me.set_starttime(startTicks);
8373 me.set_endtime(endTicks);
8374 me.set_sampledThread(sampledThread);
8375 me.set_stackTrace(stackTrace);
8376 me.set_state(state);
8377 me.commit();
8378 }
8379 }
8380
8381#ifdef ASSERT
8382 void verify() const {
8383 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_sampledThread");
8384 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_stackTrace");
8385 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_state");
8386 }
8387#endif
8388};
8389
8390class EventNativeMethodSample : public JfrEvent<EventNativeMethodSample>
8391{
8392 private:
8393 u8 _sampledThread;
8394 u8 _stackTrace;
8395 u8 _state;
8396
8397 public:
8398 static const bool hasThread = false;
8399 static const bool hasStackTrace = false;
8400 static const bool isInstant = false;
8401 static const bool hasCutoff = false;
8402 static const bool isRequestable = true;
8403 static const JfrEventId eventId = JfrNativeMethodSampleEvent;
8404
8405 EventNativeMethodSample(EventStartTime timing=TIMED) : JfrEvent<EventNativeMethodSample>(timing) {}
8406
8407 void set_sampledThread(u8 new_value) {
8408 this->_sampledThread = new_value;
8409 DEBUG_ONLY(set_field_bit(0));
8410 }
8411 void set_stackTrace(u8 new_value) {
8412 this->_stackTrace = new_value;
8413 DEBUG_ONLY(set_field_bit(1));
8414 }
8415 void set_state(u8 new_value) {
8416 this->_state = new_value;
8417 DEBUG_ONLY(set_field_bit(2));
8418 }
8419
8420 template <typename Writer>
8421 void writeData(Writer& w) {
8422 w.write(_sampledThread);
8423 w.write(_stackTrace);
8424 w.write(_state);
8425 }
8426
8427 using JfrEvent<EventNativeMethodSample>::commit; // else commit() is hidden by overloaded versions in this class
8428
8429 EventNativeMethodSample(
8430 u8 sampledThread,
8431 u8 stackTrace,
8432 u8 state) : JfrEvent<EventNativeMethodSample>(TIMED) {
8433 if (should_commit()) {
8434 set_sampledThread(sampledThread);
8435 set_stackTrace(stackTrace);
8436 set_state(state);
8437 }
8438 }
8439
8440 void commit(u8 sampledThread,
8441 u8 stackTrace,
8442 u8 state) {
8443 if (should_commit()) {
8444 set_sampledThread(sampledThread);
8445 set_stackTrace(stackTrace);
8446 set_state(state);
8447 commit();
8448 }
8449 }
8450
8451 static void commit(const Ticks& startTicks,
8452 const Ticks& endTicks,
8453 u8 sampledThread,
8454 u8 stackTrace,
8455 u8 state) {
8456 EventNativeMethodSample me(UNTIMED);
8457
8458 if (me.should_commit()) {
8459 me.set_starttime(startTicks);
8460 me.set_endtime(endTicks);
8461 me.set_sampledThread(sampledThread);
8462 me.set_stackTrace(stackTrace);
8463 me.set_state(state);
8464 me.commit();
8465 }
8466 }
8467
8468#ifdef ASSERT
8469 void verify() const {
8470 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_sampledThread");
8471 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_stackTrace");
8472 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_state");
8473 }
8474#endif
8475};
8476
8477class EventThreadDump : public JfrEvent<EventThreadDump>
8478{
8479 private:
8480 const char* _result;
8481
8482 public:
8483 static const bool hasThread = false;
8484 static const bool hasStackTrace = false;
8485 static const bool isInstant = false;
8486 static const bool hasCutoff = false;
8487 static const bool isRequestable = true;
8488 static const JfrEventId eventId = JfrThreadDumpEvent;
8489
8490 EventThreadDump(EventStartTime timing=TIMED) : JfrEvent<EventThreadDump>(timing) {}
8491
8492 void set_result(const char* new_value) {
8493 this->_result = new_value;
8494 DEBUG_ONLY(set_field_bit(0));
8495 }
8496
8497 template <typename Writer>
8498 void writeData(Writer& w) {
8499 w.write(_result);
8500 }
8501
8502 using JfrEvent<EventThreadDump>::commit; // else commit() is hidden by overloaded versions in this class
8503
8504 EventThreadDump(
8505 const char* result) : JfrEvent<EventThreadDump>(TIMED) {
8506 if (should_commit()) {
8507 set_result(result);
8508 }
8509 }
8510
8511 void commit(const char* result) {
8512 if (should_commit()) {
8513 set_result(result);
8514 commit();
8515 }
8516 }
8517
8518 static void commit(const Ticks& startTicks,
8519 const Ticks& endTicks,
8520 const char* result) {
8521 EventThreadDump me(UNTIMED);
8522
8523 if (me.should_commit()) {
8524 me.set_starttime(startTicks);
8525 me.set_endtime(endTicks);
8526 me.set_result(result);
8527 me.commit();
8528 }
8529 }
8530
8531#ifdef ASSERT
8532 void verify() const {
8533 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_result");
8534 }
8535#endif
8536};
8537
8538class EventNativeLibrary : public JfrEvent<EventNativeLibrary>
8539{
8540 private:
8541 const char* _name;
8542 u8 _baseAddress;
8543 u8 _topAddress;
8544
8545 public:
8546 static const bool hasThread = false;
8547 static const bool hasStackTrace = false;
8548 static const bool isInstant = false;
8549 static const bool hasCutoff = false;
8550 static const bool isRequestable = true;
8551 static const JfrEventId eventId = JfrNativeLibraryEvent;
8552
8553 EventNativeLibrary(EventStartTime timing=TIMED) : JfrEvent<EventNativeLibrary>(timing) {}
8554
8555 void set_name(const char* new_value) {
8556 this->_name = new_value;
8557 DEBUG_ONLY(set_field_bit(0));
8558 }
8559 void set_baseAddress(u8 new_value) {
8560 this->_baseAddress = new_value;
8561 DEBUG_ONLY(set_field_bit(1));
8562 }
8563 void set_topAddress(u8 new_value) {
8564 this->_topAddress = new_value;
8565 DEBUG_ONLY(set_field_bit(2));
8566 }
8567
8568 template <typename Writer>
8569 void writeData(Writer& w) {
8570 w.write(_name);
8571 w.write(_baseAddress);
8572 w.write(_topAddress);
8573 }
8574
8575 using JfrEvent<EventNativeLibrary>::commit; // else commit() is hidden by overloaded versions in this class
8576
8577 EventNativeLibrary(
8578 const char* name,
8579 u8 baseAddress,
8580 u8 topAddress) : JfrEvent<EventNativeLibrary>(TIMED) {
8581 if (should_commit()) {
8582 set_name(name);
8583 set_baseAddress(baseAddress);
8584 set_topAddress(topAddress);
8585 }
8586 }
8587
8588 void commit(const char* name,
8589 u8 baseAddress,
8590 u8 topAddress) {
8591 if (should_commit()) {
8592 set_name(name);
8593 set_baseAddress(baseAddress);
8594 set_topAddress(topAddress);
8595 commit();
8596 }
8597 }
8598
8599 static void commit(const Ticks& startTicks,
8600 const Ticks& endTicks,
8601 const char* name,
8602 u8 baseAddress,
8603 u8 topAddress) {
8604 EventNativeLibrary me(UNTIMED);
8605
8606 if (me.should_commit()) {
8607 me.set_starttime(startTicks);
8608 me.set_endtime(endTicks);
8609 me.set_name(name);
8610 me.set_baseAddress(baseAddress);
8611 me.set_topAddress(topAddress);
8612 me.commit();
8613 }
8614 }
8615
8616#ifdef ASSERT
8617 void verify() const {
8618 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
8619 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_baseAddress");
8620 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_topAddress");
8621 }
8622#endif
8623};
8624
8625class EventModuleRequire : public JfrEvent<EventModuleRequire>
8626{
8627 private:
8628 const ModuleEntry* _source;
8629 const ModuleEntry* _requiredModule;
8630
8631 public:
8632 static const bool hasThread = false;
8633 static const bool hasStackTrace = false;
8634 static const bool isInstant = false;
8635 static const bool hasCutoff = false;
8636 static const bool isRequestable = true;
8637 static const JfrEventId eventId = JfrModuleRequireEvent;
8638
8639 EventModuleRequire(EventStartTime timing=TIMED) : JfrEvent<EventModuleRequire>(timing) {}
8640
8641 void set_source(const ModuleEntry* new_value) {
8642 this->_source = new_value;
8643 DEBUG_ONLY(set_field_bit(0));
8644 }
8645 void set_requiredModule(const ModuleEntry* new_value) {
8646 this->_requiredModule = new_value;
8647 DEBUG_ONLY(set_field_bit(1));
8648 }
8649
8650 template <typename Writer>
8651 void writeData(Writer& w) {
8652 w.write(_source);
8653 w.write(_requiredModule);
8654 }
8655
8656 using JfrEvent<EventModuleRequire>::commit; // else commit() is hidden by overloaded versions in this class
8657
8658 EventModuleRequire(
8659 const ModuleEntry* source,
8660 const ModuleEntry* requiredModule) : JfrEvent<EventModuleRequire>(TIMED) {
8661 if (should_commit()) {
8662 set_source(source);
8663 set_requiredModule(requiredModule);
8664 }
8665 }
8666
8667 void commit(const ModuleEntry* source,
8668 const ModuleEntry* requiredModule) {
8669 if (should_commit()) {
8670 set_source(source);
8671 set_requiredModule(requiredModule);
8672 commit();
8673 }
8674 }
8675
8676 static void commit(const Ticks& startTicks,
8677 const Ticks& endTicks,
8678 const ModuleEntry* source,
8679 const ModuleEntry* requiredModule) {
8680 EventModuleRequire me(UNTIMED);
8681
8682 if (me.should_commit()) {
8683 me.set_starttime(startTicks);
8684 me.set_endtime(endTicks);
8685 me.set_source(source);
8686 me.set_requiredModule(requiredModule);
8687 me.commit();
8688 }
8689 }
8690
8691#ifdef ASSERT
8692 void verify() const {
8693 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_source");
8694 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_requiredModule");
8695 }
8696#endif
8697};
8698
8699class EventModuleExport : public JfrEvent<EventModuleExport>
8700{
8701 private:
8702 const PackageEntry* _exportedPackage;
8703 const ModuleEntry* _targetModule;
8704
8705 public:
8706 static const bool hasThread = false;
8707 static const bool hasStackTrace = false;
8708 static const bool isInstant = false;
8709 static const bool hasCutoff = false;
8710 static const bool isRequestable = true;
8711 static const JfrEventId eventId = JfrModuleExportEvent;
8712
8713 EventModuleExport(EventStartTime timing=TIMED) : JfrEvent<EventModuleExport>(timing) {}
8714
8715 void set_exportedPackage(const PackageEntry* new_value) {
8716 this->_exportedPackage = new_value;
8717 DEBUG_ONLY(set_field_bit(0));
8718 }
8719 void set_targetModule(const ModuleEntry* new_value) {
8720 this->_targetModule = new_value;
8721 DEBUG_ONLY(set_field_bit(1));
8722 }
8723
8724 template <typename Writer>
8725 void writeData(Writer& w) {
8726 w.write(_exportedPackage);
8727 w.write(_targetModule);
8728 }
8729
8730 using JfrEvent<EventModuleExport>::commit; // else commit() is hidden by overloaded versions in this class
8731
8732 EventModuleExport(
8733 const PackageEntry* exportedPackage,
8734 const ModuleEntry* targetModule) : JfrEvent<EventModuleExport>(TIMED) {
8735 if (should_commit()) {
8736 set_exportedPackage(exportedPackage);
8737 set_targetModule(targetModule);
8738 }
8739 }
8740
8741 void commit(const PackageEntry* exportedPackage,
8742 const ModuleEntry* targetModule) {
8743 if (should_commit()) {
8744 set_exportedPackage(exportedPackage);
8745 set_targetModule(targetModule);
8746 commit();
8747 }
8748 }
8749
8750 static void commit(const Ticks& startTicks,
8751 const Ticks& endTicks,
8752 const PackageEntry* exportedPackage,
8753 const ModuleEntry* targetModule) {
8754 EventModuleExport me(UNTIMED);
8755
8756 if (me.should_commit()) {
8757 me.set_starttime(startTicks);
8758 me.set_endtime(endTicks);
8759 me.set_exportedPackage(exportedPackage);
8760 me.set_targetModule(targetModule);
8761 me.commit();
8762 }
8763 }
8764
8765#ifdef ASSERT
8766 void verify() const {
8767 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_exportedPackage");
8768 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_targetModule");
8769 }
8770#endif
8771};
8772
8773class EventCompilerStatistics : public JfrEvent<EventCompilerStatistics>
8774{
8775 private:
8776 s4 _compileCount;
8777 s4 _bailoutCount;
8778 s4 _invalidatedCount;
8779 s4 _osrCompileCount;
8780 s4 _standardCompileCount;
8781 u8 _osrBytesCompiled;
8782 u8 _standardBytesCompiled;
8783 u8 _nmetodsSize;
8784 u8 _nmetodCodeSize;
8785 s8 _peakTimeSpent;
8786 s8 _totalTimeSpent;
8787
8788 public:
8789 static const bool hasThread = false;
8790 static const bool hasStackTrace = false;
8791 static const bool isInstant = true;
8792 static const bool hasCutoff = false;
8793 static const bool isRequestable = true;
8794 static const JfrEventId eventId = JfrCompilerStatisticsEvent;
8795
8796 EventCompilerStatistics(EventStartTime timing=TIMED) : JfrEvent<EventCompilerStatistics>(timing) {}
8797
8798 void set_compileCount(s4 new_value) {
8799 this->_compileCount = new_value;
8800 DEBUG_ONLY(set_field_bit(0));
8801 }
8802 void set_bailoutCount(s4 new_value) {
8803 this->_bailoutCount = new_value;
8804 DEBUG_ONLY(set_field_bit(1));
8805 }
8806 void set_invalidatedCount(s4 new_value) {
8807 this->_invalidatedCount = new_value;
8808 DEBUG_ONLY(set_field_bit(2));
8809 }
8810 void set_osrCompileCount(s4 new_value) {
8811 this->_osrCompileCount = new_value;
8812 DEBUG_ONLY(set_field_bit(3));
8813 }
8814 void set_standardCompileCount(s4 new_value) {
8815 this->_standardCompileCount = new_value;
8816 DEBUG_ONLY(set_field_bit(4));
8817 }
8818 void set_osrBytesCompiled(u8 new_value) {
8819 this->_osrBytesCompiled = new_value;
8820 DEBUG_ONLY(set_field_bit(5));
8821 }
8822 void set_standardBytesCompiled(u8 new_value) {
8823 this->_standardBytesCompiled = new_value;
8824 DEBUG_ONLY(set_field_bit(6));
8825 }
8826 void set_nmetodsSize(u8 new_value) {
8827 this->_nmetodsSize = new_value;
8828 DEBUG_ONLY(set_field_bit(7));
8829 }
8830 void set_nmetodCodeSize(u8 new_value) {
8831 this->_nmetodCodeSize = new_value;
8832 DEBUG_ONLY(set_field_bit(8));
8833 }
8834 void set_peakTimeSpent(s8 new_value) {
8835 this->_peakTimeSpent = new_value;
8836 DEBUG_ONLY(set_field_bit(9));
8837 }
8838 void set_totalTimeSpent(s8 new_value) {
8839 this->_totalTimeSpent = new_value;
8840 DEBUG_ONLY(set_field_bit(10));
8841 }
8842
8843 template <typename Writer>
8844 void writeData(Writer& w) {
8845 w.write(_compileCount);
8846 w.write(_bailoutCount);
8847 w.write(_invalidatedCount);
8848 w.write(_osrCompileCount);
8849 w.write(_standardCompileCount);
8850 w.write(_osrBytesCompiled);
8851 w.write(_standardBytesCompiled);
8852 w.write(_nmetodsSize);
8853 w.write(_nmetodCodeSize);
8854 w.write(_peakTimeSpent);
8855 w.write(_totalTimeSpent);
8856 }
8857
8858 using JfrEvent<EventCompilerStatistics>::commit; // else commit() is hidden by overloaded versions in this class
8859
8860
8861
8862 static void commit(s4 compileCount,
8863 s4 bailoutCount,
8864 s4 invalidatedCount,
8865 s4 osrCompileCount,
8866 s4 standardCompileCount,
8867 u8 osrBytesCompiled,
8868 u8 standardBytesCompiled,
8869 u8 nmetodsSize,
8870 u8 nmetodCodeSize,
8871 s8 peakTimeSpent,
8872 s8 totalTimeSpent) {
8873 EventCompilerStatistics me(UNTIMED);
8874
8875 if (me.should_commit()) {
8876 me.set_compileCount(compileCount);
8877 me.set_bailoutCount(bailoutCount);
8878 me.set_invalidatedCount(invalidatedCount);
8879 me.set_osrCompileCount(osrCompileCount);
8880 me.set_standardCompileCount(standardCompileCount);
8881 me.set_osrBytesCompiled(osrBytesCompiled);
8882 me.set_standardBytesCompiled(standardBytesCompiled);
8883 me.set_nmetodsSize(nmetodsSize);
8884 me.set_nmetodCodeSize(nmetodCodeSize);
8885 me.set_peakTimeSpent(peakTimeSpent);
8886 me.set_totalTimeSpent(totalTimeSpent);
8887 me.commit();
8888 }
8889 }
8890
8891#ifdef ASSERT
8892 void verify() const {
8893 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_compileCount");
8894 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_bailoutCount");
8895 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_invalidatedCount");
8896 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_osrCompileCount");
8897 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_standardCompileCount");
8898 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_osrBytesCompiled");
8899 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_standardBytesCompiled");
8900 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_nmetodsSize");
8901 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_nmetodCodeSize");
8902 assert(verify_field_bit(9), "Attempting to write an uninitialized event field: %s", "_peakTimeSpent");
8903 assert(verify_field_bit(10), "Attempting to write an uninitialized event field: %s", "_totalTimeSpent");
8904 }
8905#endif
8906};
8907
8908class EventCompilerConfiguration : public JfrEvent<EventCompilerConfiguration>
8909{
8910 private:
8911 s4 _threadCount;
8912 bool _tieredCompilation;
8913
8914 public:
8915 static const bool hasThread = false;
8916 static const bool hasStackTrace = false;
8917 static const bool isInstant = true;
8918 static const bool hasCutoff = false;
8919 static const bool isRequestable = true;
8920 static const JfrEventId eventId = JfrCompilerConfigurationEvent;
8921
8922 EventCompilerConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventCompilerConfiguration>(timing) {}
8923
8924 void set_threadCount(s4 new_value) {
8925 this->_threadCount = new_value;
8926 DEBUG_ONLY(set_field_bit(0));
8927 }
8928 void set_tieredCompilation(bool new_value) {
8929 this->_tieredCompilation = new_value;
8930 DEBUG_ONLY(set_field_bit(1));
8931 }
8932
8933 template <typename Writer>
8934 void writeData(Writer& w) {
8935 w.write(_threadCount);
8936 w.write(_tieredCompilation);
8937 }
8938
8939 using JfrEvent<EventCompilerConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
8940
8941
8942
8943 static void commit(s4 threadCount,
8944 bool tieredCompilation) {
8945 EventCompilerConfiguration me(UNTIMED);
8946
8947 if (me.should_commit()) {
8948 me.set_threadCount(threadCount);
8949 me.set_tieredCompilation(tieredCompilation);
8950 me.commit();
8951 }
8952 }
8953
8954#ifdef ASSERT
8955 void verify() const {
8956 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_threadCount");
8957 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_tieredCompilation");
8958 }
8959#endif
8960};
8961
8962class EventCodeCacheStatistics : public JfrEvent<EventCodeCacheStatistics>
8963{
8964 private:
8965 u8 _codeBlobType;
8966 u8 _startAddress;
8967 u8 _reservedTopAddress;
8968 s4 _entryCount;
8969 s4 _methodCount;
8970 s4 _adaptorCount;
8971 u8 _unallocatedCapacity;
8972 s4 _fullCount;
8973
8974 public:
8975 static const bool hasThread = false;
8976 static const bool hasStackTrace = false;
8977 static const bool isInstant = true;
8978 static const bool hasCutoff = false;
8979 static const bool isRequestable = true;
8980 static const JfrEventId eventId = JfrCodeCacheStatisticsEvent;
8981
8982 EventCodeCacheStatistics(EventStartTime timing=TIMED) : JfrEvent<EventCodeCacheStatistics>(timing) {}
8983
8984 void set_codeBlobType(u8 new_value) {
8985 this->_codeBlobType = new_value;
8986 DEBUG_ONLY(set_field_bit(0));
8987 }
8988 void set_startAddress(u8 new_value) {
8989 this->_startAddress = new_value;
8990 DEBUG_ONLY(set_field_bit(1));
8991 }
8992 void set_reservedTopAddress(u8 new_value) {
8993 this->_reservedTopAddress = new_value;
8994 DEBUG_ONLY(set_field_bit(2));
8995 }
8996 void set_entryCount(s4 new_value) {
8997 this->_entryCount = new_value;
8998 DEBUG_ONLY(set_field_bit(3));
8999 }
9000 void set_methodCount(s4 new_value) {
9001 this->_methodCount = new_value;
9002 DEBUG_ONLY(set_field_bit(4));
9003 }
9004 void set_adaptorCount(s4 new_value) {
9005 this->_adaptorCount = new_value;
9006 DEBUG_ONLY(set_field_bit(5));
9007 }
9008 void set_unallocatedCapacity(u8 new_value) {
9009 this->_unallocatedCapacity = new_value;
9010 DEBUG_ONLY(set_field_bit(6));
9011 }
9012 void set_fullCount(s4 new_value) {
9013 this->_fullCount = new_value;
9014 DEBUG_ONLY(set_field_bit(7));
9015 }
9016
9017 template <typename Writer>
9018 void writeData(Writer& w) {
9019 w.write(_codeBlobType);
9020 w.write(_startAddress);
9021 w.write(_reservedTopAddress);
9022 w.write(_entryCount);
9023 w.write(_methodCount);
9024 w.write(_adaptorCount);
9025 w.write(_unallocatedCapacity);
9026 w.write(_fullCount);
9027 }
9028
9029 using JfrEvent<EventCodeCacheStatistics>::commit; // else commit() is hidden by overloaded versions in this class
9030
9031
9032
9033 static void commit(u8 codeBlobType,
9034 u8 startAddress,
9035 u8 reservedTopAddress,
9036 s4 entryCount,
9037 s4 methodCount,
9038 s4 adaptorCount,
9039 u8 unallocatedCapacity,
9040 s4 fullCount) {
9041 EventCodeCacheStatistics me(UNTIMED);
9042
9043 if (me.should_commit()) {
9044 me.set_codeBlobType(codeBlobType);
9045 me.set_startAddress(startAddress);
9046 me.set_reservedTopAddress(reservedTopAddress);
9047 me.set_entryCount(entryCount);
9048 me.set_methodCount(methodCount);
9049 me.set_adaptorCount(adaptorCount);
9050 me.set_unallocatedCapacity(unallocatedCapacity);
9051 me.set_fullCount(fullCount);
9052 me.commit();
9053 }
9054 }
9055
9056#ifdef ASSERT
9057 void verify() const {
9058 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_codeBlobType");
9059 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_startAddress");
9060 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_reservedTopAddress");
9061 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_entryCount");
9062 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_methodCount");
9063 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_adaptorCount");
9064 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_unallocatedCapacity");
9065 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_fullCount");
9066 }
9067#endif
9068};
9069
9070class EventCodeCacheConfiguration : public JfrEvent<EventCodeCacheConfiguration>
9071{
9072 private:
9073 u8 _initialSize;
9074 u8 _reservedSize;
9075 u8 _nonNMethodSize;
9076 u8 _profiledSize;
9077 u8 _nonProfiledSize;
9078 u8 _expansionSize;
9079 u8 _minBlockLength;
9080 u8 _startAddress;
9081 u8 _reservedTopAddress;
9082
9083 public:
9084 static const bool hasThread = false;
9085 static const bool hasStackTrace = false;
9086 static const bool isInstant = true;
9087 static const bool hasCutoff = false;
9088 static const bool isRequestable = true;
9089 static const JfrEventId eventId = JfrCodeCacheConfigurationEvent;
9090
9091 EventCodeCacheConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventCodeCacheConfiguration>(timing) {}
9092
9093 void set_initialSize(u8 new_value) {
9094 this->_initialSize = new_value;
9095 DEBUG_ONLY(set_field_bit(0));
9096 }
9097 void set_reservedSize(u8 new_value) {
9098 this->_reservedSize = new_value;
9099 DEBUG_ONLY(set_field_bit(1));
9100 }
9101 void set_nonNMethodSize(u8 new_value) {
9102 this->_nonNMethodSize = new_value;
9103 DEBUG_ONLY(set_field_bit(2));
9104 }
9105 void set_profiledSize(u8 new_value) {
9106 this->_profiledSize = new_value;
9107 DEBUG_ONLY(set_field_bit(3));
9108 }
9109 void set_nonProfiledSize(u8 new_value) {
9110 this->_nonProfiledSize = new_value;
9111 DEBUG_ONLY(set_field_bit(4));
9112 }
9113 void set_expansionSize(u8 new_value) {
9114 this->_expansionSize = new_value;
9115 DEBUG_ONLY(set_field_bit(5));
9116 }
9117 void set_minBlockLength(u8 new_value) {
9118 this->_minBlockLength = new_value;
9119 DEBUG_ONLY(set_field_bit(6));
9120 }
9121 void set_startAddress(u8 new_value) {
9122 this->_startAddress = new_value;
9123 DEBUG_ONLY(set_field_bit(7));
9124 }
9125 void set_reservedTopAddress(u8 new_value) {
9126 this->_reservedTopAddress = new_value;
9127 DEBUG_ONLY(set_field_bit(8));
9128 }
9129
9130 template <typename Writer>
9131 void writeData(Writer& w) {
9132 w.write(_initialSize);
9133 w.write(_reservedSize);
9134 w.write(_nonNMethodSize);
9135 w.write(_profiledSize);
9136 w.write(_nonProfiledSize);
9137 w.write(_expansionSize);
9138 w.write(_minBlockLength);
9139 w.write(_startAddress);
9140 w.write(_reservedTopAddress);
9141 }
9142
9143 using JfrEvent<EventCodeCacheConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
9144
9145
9146
9147 static void commit(u8 initialSize,
9148 u8 reservedSize,
9149 u8 nonNMethodSize,
9150 u8 profiledSize,
9151 u8 nonProfiledSize,
9152 u8 expansionSize,
9153 u8 minBlockLength,
9154 u8 startAddress,
9155 u8 reservedTopAddress) {
9156 EventCodeCacheConfiguration me(UNTIMED);
9157
9158 if (me.should_commit()) {
9159 me.set_initialSize(initialSize);
9160 me.set_reservedSize(reservedSize);
9161 me.set_nonNMethodSize(nonNMethodSize);
9162 me.set_profiledSize(profiledSize);
9163 me.set_nonProfiledSize(nonProfiledSize);
9164 me.set_expansionSize(expansionSize);
9165 me.set_minBlockLength(minBlockLength);
9166 me.set_startAddress(startAddress);
9167 me.set_reservedTopAddress(reservedTopAddress);
9168 me.commit();
9169 }
9170 }
9171
9172#ifdef ASSERT
9173 void verify() const {
9174 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_initialSize");
9175 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_reservedSize");
9176 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_nonNMethodSize");
9177 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_profiledSize");
9178 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_nonProfiledSize");
9179 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_expansionSize");
9180 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_minBlockLength");
9181 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_startAddress");
9182 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_reservedTopAddress");
9183 }
9184#endif
9185};
9186
9187class EventCodeSweeperStatistics : public JfrEvent<EventCodeSweeperStatistics>
9188{
9189 private:
9190 s4 _sweepCount;
9191 s4 _methodReclaimedCount;
9192 Tickspan _totalSweepTime;
9193 Tickspan _peakFractionTime;
9194 Tickspan _peakSweepTime;
9195
9196 public:
9197 static const bool hasThread = false;
9198 static const bool hasStackTrace = false;
9199 static const bool isInstant = true;
9200 static const bool hasCutoff = false;
9201 static const bool isRequestable = true;
9202 static const JfrEventId eventId = JfrCodeSweeperStatisticsEvent;
9203
9204 EventCodeSweeperStatistics(EventStartTime timing=TIMED) : JfrEvent<EventCodeSweeperStatistics>(timing) {}
9205
9206 void set_sweepCount(s4 new_value) {
9207 this->_sweepCount = new_value;
9208 DEBUG_ONLY(set_field_bit(0));
9209 }
9210 void set_methodReclaimedCount(s4 new_value) {
9211 this->_methodReclaimedCount = new_value;
9212 DEBUG_ONLY(set_field_bit(1));
9213 }
9214 void set_totalSweepTime(const Tickspan& new_value) {
9215 this->_totalSweepTime = new_value;
9216 DEBUG_ONLY(set_field_bit(2));
9217 }
9218 void set_peakFractionTime(const Tickspan& new_value) {
9219 this->_peakFractionTime = new_value;
9220 DEBUG_ONLY(set_field_bit(3));
9221 }
9222 void set_peakSweepTime(const Tickspan& new_value) {
9223 this->_peakSweepTime = new_value;
9224 DEBUG_ONLY(set_field_bit(4));
9225 }
9226
9227 template <typename Writer>
9228 void writeData(Writer& w) {
9229 w.write(_sweepCount);
9230 w.write(_methodReclaimedCount);
9231 w.write(_totalSweepTime);
9232 w.write(_peakFractionTime);
9233 w.write(_peakSweepTime);
9234 }
9235
9236 using JfrEvent<EventCodeSweeperStatistics>::commit; // else commit() is hidden by overloaded versions in this class
9237
9238
9239
9240 static void commit(s4 sweepCount,
9241 s4 methodReclaimedCount,
9242 const Tickspan& totalSweepTime,
9243 const Tickspan& peakFractionTime,
9244 const Tickspan& peakSweepTime) {
9245 EventCodeSweeperStatistics me(UNTIMED);
9246
9247 if (me.should_commit()) {
9248 me.set_sweepCount(sweepCount);
9249 me.set_methodReclaimedCount(methodReclaimedCount);
9250 me.set_totalSweepTime(totalSweepTime);
9251 me.set_peakFractionTime(peakFractionTime);
9252 me.set_peakSweepTime(peakSweepTime);
9253 me.commit();
9254 }
9255 }
9256
9257#ifdef ASSERT
9258 void verify() const {
9259 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_sweepCount");
9260 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_methodReclaimedCount");
9261 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_totalSweepTime");
9262 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_peakFractionTime");
9263 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_peakSweepTime");
9264 }
9265#endif
9266};
9267
9268class EventCodeSweeperConfiguration : public JfrEvent<EventCodeSweeperConfiguration>
9269{
9270 private:
9271 bool _sweeperEnabled;
9272 bool _flushingEnabled;
9273
9274 public:
9275 static const bool hasThread = false;
9276 static const bool hasStackTrace = false;
9277 static const bool isInstant = true;
9278 static const bool hasCutoff = false;
9279 static const bool isRequestable = true;
9280 static const JfrEventId eventId = JfrCodeSweeperConfigurationEvent;
9281
9282 EventCodeSweeperConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventCodeSweeperConfiguration>(timing) {}
9283
9284 void set_sweeperEnabled(bool new_value) {
9285 this->_sweeperEnabled = new_value;
9286 DEBUG_ONLY(set_field_bit(0));
9287 }
9288 void set_flushingEnabled(bool new_value) {
9289 this->_flushingEnabled = new_value;
9290 DEBUG_ONLY(set_field_bit(1));
9291 }
9292
9293 template <typename Writer>
9294 void writeData(Writer& w) {
9295 w.write(_sweeperEnabled);
9296 w.write(_flushingEnabled);
9297 }
9298
9299 using JfrEvent<EventCodeSweeperConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
9300
9301
9302
9303 static void commit(bool sweeperEnabled,
9304 bool flushingEnabled) {
9305 EventCodeSweeperConfiguration me(UNTIMED);
9306
9307 if (me.should_commit()) {
9308 me.set_sweeperEnabled(sweeperEnabled);
9309 me.set_flushingEnabled(flushingEnabled);
9310 me.commit();
9311 }
9312 }
9313
9314#ifdef ASSERT
9315 void verify() const {
9316 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_sweeperEnabled");
9317 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_flushingEnabled");
9318 }
9319#endif
9320};
9321
9322class EventIntFlag : public JfrEvent<EventIntFlag>
9323{
9324 private:
9325 const char* _name;
9326 s4 _value;
9327 u8 _origin;
9328
9329 public:
9330 static const bool hasThread = false;
9331 static const bool hasStackTrace = false;
9332 static const bool isInstant = false;
9333 static const bool hasCutoff = false;
9334 static const bool isRequestable = true;
9335 static const JfrEventId eventId = JfrIntFlagEvent;
9336
9337 EventIntFlag(EventStartTime timing=TIMED) : JfrEvent<EventIntFlag>(timing) {}
9338
9339 void set_name(const char* new_value) {
9340 this->_name = new_value;
9341 DEBUG_ONLY(set_field_bit(0));
9342 }
9343 void set_value(s4 new_value) {
9344 this->_value = new_value;
9345 DEBUG_ONLY(set_field_bit(1));
9346 }
9347 void set_origin(u8 new_value) {
9348 this->_origin = new_value;
9349 DEBUG_ONLY(set_field_bit(2));
9350 }
9351
9352 template <typename Writer>
9353 void writeData(Writer& w) {
9354 w.write(_name);
9355 w.write(_value);
9356 w.write(_origin);
9357 }
9358
9359 using JfrEvent<EventIntFlag>::commit; // else commit() is hidden by overloaded versions in this class
9360
9361 EventIntFlag(
9362 const char* name,
9363 s4 value,
9364 u8 origin) : JfrEvent<EventIntFlag>(TIMED) {
9365 if (should_commit()) {
9366 set_name(name);
9367 set_value(value);
9368 set_origin(origin);
9369 }
9370 }
9371
9372 void commit(const char* name,
9373 s4 value,
9374 u8 origin) {
9375 if (should_commit()) {
9376 set_name(name);
9377 set_value(value);
9378 set_origin(origin);
9379 commit();
9380 }
9381 }
9382
9383 static void commit(const Ticks& startTicks,
9384 const Ticks& endTicks,
9385 const char* name,
9386 s4 value,
9387 u8 origin) {
9388 EventIntFlag me(UNTIMED);
9389
9390 if (me.should_commit()) {
9391 me.set_starttime(startTicks);
9392 me.set_endtime(endTicks);
9393 me.set_name(name);
9394 me.set_value(value);
9395 me.set_origin(origin);
9396 me.commit();
9397 }
9398 }
9399
9400#ifdef ASSERT
9401 void verify() const {
9402 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9403 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9404 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9405 }
9406#endif
9407};
9408
9409class EventUnsignedIntFlag : public JfrEvent<EventUnsignedIntFlag>
9410{
9411 private:
9412 const char* _name;
9413 unsigned _value;
9414 u8 _origin;
9415
9416 public:
9417 static const bool hasThread = false;
9418 static const bool hasStackTrace = false;
9419 static const bool isInstant = false;
9420 static const bool hasCutoff = false;
9421 static const bool isRequestable = true;
9422 static const JfrEventId eventId = JfrUnsignedIntFlagEvent;
9423
9424 EventUnsignedIntFlag(EventStartTime timing=TIMED) : JfrEvent<EventUnsignedIntFlag>(timing) {}
9425
9426 void set_name(const char* new_value) {
9427 this->_name = new_value;
9428 DEBUG_ONLY(set_field_bit(0));
9429 }
9430 void set_value(unsigned new_value) {
9431 this->_value = new_value;
9432 DEBUG_ONLY(set_field_bit(1));
9433 }
9434 void set_origin(u8 new_value) {
9435 this->_origin = new_value;
9436 DEBUG_ONLY(set_field_bit(2));
9437 }
9438
9439 template <typename Writer>
9440 void writeData(Writer& w) {
9441 w.write(_name);
9442 w.write(_value);
9443 w.write(_origin);
9444 }
9445
9446 using JfrEvent<EventUnsignedIntFlag>::commit; // else commit() is hidden by overloaded versions in this class
9447
9448 EventUnsignedIntFlag(
9449 const char* name,
9450 unsigned value,
9451 u8 origin) : JfrEvent<EventUnsignedIntFlag>(TIMED) {
9452 if (should_commit()) {
9453 set_name(name);
9454 set_value(value);
9455 set_origin(origin);
9456 }
9457 }
9458
9459 void commit(const char* name,
9460 unsigned value,
9461 u8 origin) {
9462 if (should_commit()) {
9463 set_name(name);
9464 set_value(value);
9465 set_origin(origin);
9466 commit();
9467 }
9468 }
9469
9470 static void commit(const Ticks& startTicks,
9471 const Ticks& endTicks,
9472 const char* name,
9473 unsigned value,
9474 u8 origin) {
9475 EventUnsignedIntFlag me(UNTIMED);
9476
9477 if (me.should_commit()) {
9478 me.set_starttime(startTicks);
9479 me.set_endtime(endTicks);
9480 me.set_name(name);
9481 me.set_value(value);
9482 me.set_origin(origin);
9483 me.commit();
9484 }
9485 }
9486
9487#ifdef ASSERT
9488 void verify() const {
9489 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9490 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9491 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9492 }
9493#endif
9494};
9495
9496class EventLongFlag : public JfrEvent<EventLongFlag>
9497{
9498 private:
9499 const char* _name;
9500 s8 _value;
9501 u8 _origin;
9502
9503 public:
9504 static const bool hasThread = false;
9505 static const bool hasStackTrace = false;
9506 static const bool isInstant = false;
9507 static const bool hasCutoff = false;
9508 static const bool isRequestable = true;
9509 static const JfrEventId eventId = JfrLongFlagEvent;
9510
9511 EventLongFlag(EventStartTime timing=TIMED) : JfrEvent<EventLongFlag>(timing) {}
9512
9513 void set_name(const char* new_value) {
9514 this->_name = new_value;
9515 DEBUG_ONLY(set_field_bit(0));
9516 }
9517 void set_value(s8 new_value) {
9518 this->_value = new_value;
9519 DEBUG_ONLY(set_field_bit(1));
9520 }
9521 void set_origin(u8 new_value) {
9522 this->_origin = new_value;
9523 DEBUG_ONLY(set_field_bit(2));
9524 }
9525
9526 template <typename Writer>
9527 void writeData(Writer& w) {
9528 w.write(_name);
9529 w.write(_value);
9530 w.write(_origin);
9531 }
9532
9533 using JfrEvent<EventLongFlag>::commit; // else commit() is hidden by overloaded versions in this class
9534
9535 EventLongFlag(
9536 const char* name,
9537 s8 value,
9538 u8 origin) : JfrEvent<EventLongFlag>(TIMED) {
9539 if (should_commit()) {
9540 set_name(name);
9541 set_value(value);
9542 set_origin(origin);
9543 }
9544 }
9545
9546 void commit(const char* name,
9547 s8 value,
9548 u8 origin) {
9549 if (should_commit()) {
9550 set_name(name);
9551 set_value(value);
9552 set_origin(origin);
9553 commit();
9554 }
9555 }
9556
9557 static void commit(const Ticks& startTicks,
9558 const Ticks& endTicks,
9559 const char* name,
9560 s8 value,
9561 u8 origin) {
9562 EventLongFlag me(UNTIMED);
9563
9564 if (me.should_commit()) {
9565 me.set_starttime(startTicks);
9566 me.set_endtime(endTicks);
9567 me.set_name(name);
9568 me.set_value(value);
9569 me.set_origin(origin);
9570 me.commit();
9571 }
9572 }
9573
9574#ifdef ASSERT
9575 void verify() const {
9576 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9577 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9578 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9579 }
9580#endif
9581};
9582
9583class EventUnsignedLongFlag : public JfrEvent<EventUnsignedLongFlag>
9584{
9585 private:
9586 const char* _name;
9587 u8 _value;
9588 u8 _origin;
9589
9590 public:
9591 static const bool hasThread = false;
9592 static const bool hasStackTrace = false;
9593 static const bool isInstant = false;
9594 static const bool hasCutoff = false;
9595 static const bool isRequestable = true;
9596 static const JfrEventId eventId = JfrUnsignedLongFlagEvent;
9597
9598 EventUnsignedLongFlag(EventStartTime timing=TIMED) : JfrEvent<EventUnsignedLongFlag>(timing) {}
9599
9600 void set_name(const char* new_value) {
9601 this->_name = new_value;
9602 DEBUG_ONLY(set_field_bit(0));
9603 }
9604 void set_value(u8 new_value) {
9605 this->_value = new_value;
9606 DEBUG_ONLY(set_field_bit(1));
9607 }
9608 void set_origin(u8 new_value) {
9609 this->_origin = new_value;
9610 DEBUG_ONLY(set_field_bit(2));
9611 }
9612
9613 template <typename Writer>
9614 void writeData(Writer& w) {
9615 w.write(_name);
9616 w.write(_value);
9617 w.write(_origin);
9618 }
9619
9620 using JfrEvent<EventUnsignedLongFlag>::commit; // else commit() is hidden by overloaded versions in this class
9621
9622 EventUnsignedLongFlag(
9623 const char* name,
9624 u8 value,
9625 u8 origin) : JfrEvent<EventUnsignedLongFlag>(TIMED) {
9626 if (should_commit()) {
9627 set_name(name);
9628 set_value(value);
9629 set_origin(origin);
9630 }
9631 }
9632
9633 void commit(const char* name,
9634 u8 value,
9635 u8 origin) {
9636 if (should_commit()) {
9637 set_name(name);
9638 set_value(value);
9639 set_origin(origin);
9640 commit();
9641 }
9642 }
9643
9644 static void commit(const Ticks& startTicks,
9645 const Ticks& endTicks,
9646 const char* name,
9647 u8 value,
9648 u8 origin) {
9649 EventUnsignedLongFlag me(UNTIMED);
9650
9651 if (me.should_commit()) {
9652 me.set_starttime(startTicks);
9653 me.set_endtime(endTicks);
9654 me.set_name(name);
9655 me.set_value(value);
9656 me.set_origin(origin);
9657 me.commit();
9658 }
9659 }
9660
9661#ifdef ASSERT
9662 void verify() const {
9663 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9664 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9665 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9666 }
9667#endif
9668};
9669
9670class EventDoubleFlag : public JfrEvent<EventDoubleFlag>
9671{
9672 private:
9673 const char* _name;
9674 double _value;
9675 u8 _origin;
9676
9677 public:
9678 static const bool hasThread = false;
9679 static const bool hasStackTrace = false;
9680 static const bool isInstant = false;
9681 static const bool hasCutoff = false;
9682 static const bool isRequestable = true;
9683 static const JfrEventId eventId = JfrDoubleFlagEvent;
9684
9685 EventDoubleFlag(EventStartTime timing=TIMED) : JfrEvent<EventDoubleFlag>(timing) {}
9686
9687 void set_name(const char* new_value) {
9688 this->_name = new_value;
9689 DEBUG_ONLY(set_field_bit(0));
9690 }
9691 void set_value(double new_value) {
9692 this->_value = new_value;
9693 DEBUG_ONLY(set_field_bit(1));
9694 }
9695 void set_origin(u8 new_value) {
9696 this->_origin = new_value;
9697 DEBUG_ONLY(set_field_bit(2));
9698 }
9699
9700 template <typename Writer>
9701 void writeData(Writer& w) {
9702 w.write(_name);
9703 w.write(_value);
9704 w.write(_origin);
9705 }
9706
9707 using JfrEvent<EventDoubleFlag>::commit; // else commit() is hidden by overloaded versions in this class
9708
9709 EventDoubleFlag(
9710 const char* name,
9711 double value,
9712 u8 origin) : JfrEvent<EventDoubleFlag>(TIMED) {
9713 if (should_commit()) {
9714 set_name(name);
9715 set_value(value);
9716 set_origin(origin);
9717 }
9718 }
9719
9720 void commit(const char* name,
9721 double value,
9722 u8 origin) {
9723 if (should_commit()) {
9724 set_name(name);
9725 set_value(value);
9726 set_origin(origin);
9727 commit();
9728 }
9729 }
9730
9731 static void commit(const Ticks& startTicks,
9732 const Ticks& endTicks,
9733 const char* name,
9734 double value,
9735 u8 origin) {
9736 EventDoubleFlag me(UNTIMED);
9737
9738 if (me.should_commit()) {
9739 me.set_starttime(startTicks);
9740 me.set_endtime(endTicks);
9741 me.set_name(name);
9742 me.set_value(value);
9743 me.set_origin(origin);
9744 me.commit();
9745 }
9746 }
9747
9748#ifdef ASSERT
9749 void verify() const {
9750 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9751 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9752 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9753 }
9754#endif
9755};
9756
9757class EventBooleanFlag : public JfrEvent<EventBooleanFlag>
9758{
9759 private:
9760 const char* _name;
9761 bool _value;
9762 u8 _origin;
9763
9764 public:
9765 static const bool hasThread = false;
9766 static const bool hasStackTrace = false;
9767 static const bool isInstant = false;
9768 static const bool hasCutoff = false;
9769 static const bool isRequestable = true;
9770 static const JfrEventId eventId = JfrBooleanFlagEvent;
9771
9772 EventBooleanFlag(EventStartTime timing=TIMED) : JfrEvent<EventBooleanFlag>(timing) {}
9773
9774 void set_name(const char* new_value) {
9775 this->_name = new_value;
9776 DEBUG_ONLY(set_field_bit(0));
9777 }
9778 void set_value(bool new_value) {
9779 this->_value = new_value;
9780 DEBUG_ONLY(set_field_bit(1));
9781 }
9782 void set_origin(u8 new_value) {
9783 this->_origin = new_value;
9784 DEBUG_ONLY(set_field_bit(2));
9785 }
9786
9787 template <typename Writer>
9788 void writeData(Writer& w) {
9789 w.write(_name);
9790 w.write(_value);
9791 w.write(_origin);
9792 }
9793
9794 using JfrEvent<EventBooleanFlag>::commit; // else commit() is hidden by overloaded versions in this class
9795
9796 EventBooleanFlag(
9797 const char* name,
9798 bool value,
9799 u8 origin) : JfrEvent<EventBooleanFlag>(TIMED) {
9800 if (should_commit()) {
9801 set_name(name);
9802 set_value(value);
9803 set_origin(origin);
9804 }
9805 }
9806
9807 void commit(const char* name,
9808 bool value,
9809 u8 origin) {
9810 if (should_commit()) {
9811 set_name(name);
9812 set_value(value);
9813 set_origin(origin);
9814 commit();
9815 }
9816 }
9817
9818 static void commit(const Ticks& startTicks,
9819 const Ticks& endTicks,
9820 const char* name,
9821 bool value,
9822 u8 origin) {
9823 EventBooleanFlag me(UNTIMED);
9824
9825 if (me.should_commit()) {
9826 me.set_starttime(startTicks);
9827 me.set_endtime(endTicks);
9828 me.set_name(name);
9829 me.set_value(value);
9830 me.set_origin(origin);
9831 me.commit();
9832 }
9833 }
9834
9835#ifdef ASSERT
9836 void verify() const {
9837 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9838 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9839 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9840 }
9841#endif
9842};
9843
9844class EventStringFlag : public JfrEvent<EventStringFlag>
9845{
9846 private:
9847 const char* _name;
9848 const char* _value;
9849 u8 _origin;
9850
9851 public:
9852 static const bool hasThread = false;
9853 static const bool hasStackTrace = false;
9854 static const bool isInstant = false;
9855 static const bool hasCutoff = false;
9856 static const bool isRequestable = true;
9857 static const JfrEventId eventId = JfrStringFlagEvent;
9858
9859 EventStringFlag(EventStartTime timing=TIMED) : JfrEvent<EventStringFlag>(timing) {}
9860
9861 void set_name(const char* new_value) {
9862 this->_name = new_value;
9863 DEBUG_ONLY(set_field_bit(0));
9864 }
9865 void set_value(const char* new_value) {
9866 this->_value = new_value;
9867 DEBUG_ONLY(set_field_bit(1));
9868 }
9869 void set_origin(u8 new_value) {
9870 this->_origin = new_value;
9871 DEBUG_ONLY(set_field_bit(2));
9872 }
9873
9874 template <typename Writer>
9875 void writeData(Writer& w) {
9876 w.write(_name);
9877 w.write(_value);
9878 w.write(_origin);
9879 }
9880
9881 using JfrEvent<EventStringFlag>::commit; // else commit() is hidden by overloaded versions in this class
9882
9883 EventStringFlag(
9884 const char* name,
9885 const char* value,
9886 u8 origin) : JfrEvent<EventStringFlag>(TIMED) {
9887 if (should_commit()) {
9888 set_name(name);
9889 set_value(value);
9890 set_origin(origin);
9891 }
9892 }
9893
9894 void commit(const char* name,
9895 const char* value,
9896 u8 origin) {
9897 if (should_commit()) {
9898 set_name(name);
9899 set_value(value);
9900 set_origin(origin);
9901 commit();
9902 }
9903 }
9904
9905 static void commit(const Ticks& startTicks,
9906 const Ticks& endTicks,
9907 const char* name,
9908 const char* value,
9909 u8 origin) {
9910 EventStringFlag me(UNTIMED);
9911
9912 if (me.should_commit()) {
9913 me.set_starttime(startTicks);
9914 me.set_endtime(endTicks);
9915 me.set_name(name);
9916 me.set_value(value);
9917 me.set_origin(origin);
9918 me.commit();
9919 }
9920 }
9921
9922#ifdef ASSERT
9923 void verify() const {
9924 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_name");
9925 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
9926 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_origin");
9927 }
9928#endif
9929};
9930
9931class EventObjectCount : public JfrEvent<EventObjectCount>
9932{
9933 private:
9934 unsigned _gcId;
9935 const Klass* _objectClass;
9936 s8 _count;
9937 u8 _totalSize;
9938
9939 public:
9940 static const bool hasThread = false;
9941 static const bool hasStackTrace = false;
9942 static const bool isInstant = true;
9943 static const bool hasCutoff = false;
9944 static const bool isRequestable = true;
9945 static const JfrEventId eventId = JfrObjectCountEvent;
9946
9947 EventObjectCount(EventStartTime timing=TIMED) : JfrEvent<EventObjectCount>(timing) {}
9948
9949 void set_gcId(unsigned new_value) {
9950 this->_gcId = new_value;
9951 DEBUG_ONLY(set_field_bit(0));
9952 }
9953 void set_objectClass(const Klass* new_value) {
9954 this->_objectClass = new_value;
9955 DEBUG_ONLY(set_field_bit(1));
9956 }
9957 void set_count(s8 new_value) {
9958 this->_count = new_value;
9959 DEBUG_ONLY(set_field_bit(2));
9960 }
9961 void set_totalSize(u8 new_value) {
9962 this->_totalSize = new_value;
9963 DEBUG_ONLY(set_field_bit(3));
9964 }
9965
9966 template <typename Writer>
9967 void writeData(Writer& w) {
9968 w.write(_gcId);
9969 w.write(_objectClass);
9970 w.write(_count);
9971 w.write(_totalSize);
9972 }
9973
9974 using JfrEvent<EventObjectCount>::commit; // else commit() is hidden by overloaded versions in this class
9975
9976
9977
9978 static void commit(unsigned gcId,
9979 const Klass* objectClass,
9980 s8 count,
9981 u8 totalSize) {
9982 EventObjectCount me(UNTIMED);
9983
9984 if (me.should_commit()) {
9985 me.set_gcId(gcId);
9986 me.set_objectClass(objectClass);
9987 me.set_count(count);
9988 me.set_totalSize(totalSize);
9989 me.commit();
9990 }
9991 }
9992
9993#ifdef ASSERT
9994 void verify() const {
9995 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
9996 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_objectClass");
9997 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_count");
9998 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_totalSize");
9999 }
10000#endif
10001};
10002
10003class EventG1HeapRegionInformation : public JfrEvent<EventG1HeapRegionInformation>
10004{
10005 private:
10006 unsigned _index;
10007 u8 _type;
10008 u8 _start;
10009 u8 _used;
10010
10011 public:
10012 static const bool hasThread = false;
10013 static const bool hasStackTrace = false;
10014 static const bool isInstant = false;
10015 static const bool hasCutoff = false;
10016 static const bool isRequestable = true;
10017 static const JfrEventId eventId = JfrG1HeapRegionInformationEvent;
10018
10019 EventG1HeapRegionInformation(EventStartTime timing=TIMED) : JfrEvent<EventG1HeapRegionInformation>(timing) {}
10020
10021 void set_index(unsigned new_value) {
10022 this->_index = new_value;
10023 DEBUG_ONLY(set_field_bit(0));
10024 }
10025 void set_type(u8 new_value) {
10026 this->_type = new_value;
10027 DEBUG_ONLY(set_field_bit(1));
10028 }
10029 void set_start(u8 new_value) {
10030 this->_start = new_value;
10031 DEBUG_ONLY(set_field_bit(2));
10032 }
10033 void set_used(u8 new_value) {
10034 this->_used = new_value;
10035 DEBUG_ONLY(set_field_bit(3));
10036 }
10037
10038 template <typename Writer>
10039 void writeData(Writer& w) {
10040 w.write(_index);
10041 w.write(_type);
10042 w.write(_start);
10043 w.write(_used);
10044 }
10045
10046 using JfrEvent<EventG1HeapRegionInformation>::commit; // else commit() is hidden by overloaded versions in this class
10047
10048 EventG1HeapRegionInformation(
10049 unsigned index,
10050 u8 type,
10051 u8 start,
10052 u8 used) : JfrEvent<EventG1HeapRegionInformation>(TIMED) {
10053 if (should_commit()) {
10054 set_index(index);
10055 set_type(type);
10056 set_start(start);
10057 set_used(used);
10058 }
10059 }
10060
10061 void commit(unsigned index,
10062 u8 type,
10063 u8 start,
10064 u8 used) {
10065 if (should_commit()) {
10066 set_index(index);
10067 set_type(type);
10068 set_start(start);
10069 set_used(used);
10070 commit();
10071 }
10072 }
10073
10074 static void commit(const Ticks& startTicks,
10075 const Ticks& endTicks,
10076 unsigned index,
10077 u8 type,
10078 u8 start,
10079 u8 used) {
10080 EventG1HeapRegionInformation me(UNTIMED);
10081
10082 if (me.should_commit()) {
10083 me.set_starttime(startTicks);
10084 me.set_endtime(endTicks);
10085 me.set_index(index);
10086 me.set_type(type);
10087 me.set_start(start);
10088 me.set_used(used);
10089 me.commit();
10090 }
10091 }
10092
10093#ifdef ASSERT
10094 void verify() const {
10095 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_index");
10096 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_type");
10097 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_start");
10098 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_used");
10099 }
10100#endif
10101};
10102
10103class EventGCConfiguration : public JfrEvent<EventGCConfiguration>
10104{
10105 private:
10106 u8 _youngCollector;
10107 u8 _oldCollector;
10108 unsigned _parallelGCThreads;
10109 unsigned _concurrentGCThreads;
10110 bool _usesDynamicGCThreads;
10111 bool _isExplicitGCConcurrent;
10112 bool _isExplicitGCDisabled;
10113 s8 _pauseTarget;
10114 unsigned _gcTimeRatio;
10115
10116 public:
10117 static const bool hasThread = false;
10118 static const bool hasStackTrace = false;
10119 static const bool isInstant = false;
10120 static const bool hasCutoff = false;
10121 static const bool isRequestable = true;
10122 static const JfrEventId eventId = JfrGCConfigurationEvent;
10123
10124 EventGCConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventGCConfiguration>(timing) {}
10125
10126 void set_youngCollector(u8 new_value) {
10127 this->_youngCollector = new_value;
10128 DEBUG_ONLY(set_field_bit(0));
10129 }
10130 void set_oldCollector(u8 new_value) {
10131 this->_oldCollector = new_value;
10132 DEBUG_ONLY(set_field_bit(1));
10133 }
10134 void set_parallelGCThreads(unsigned new_value) {
10135 this->_parallelGCThreads = new_value;
10136 DEBUG_ONLY(set_field_bit(2));
10137 }
10138 void set_concurrentGCThreads(unsigned new_value) {
10139 this->_concurrentGCThreads = new_value;
10140 DEBUG_ONLY(set_field_bit(3));
10141 }
10142 void set_usesDynamicGCThreads(bool new_value) {
10143 this->_usesDynamicGCThreads = new_value;
10144 DEBUG_ONLY(set_field_bit(4));
10145 }
10146 void set_isExplicitGCConcurrent(bool new_value) {
10147 this->_isExplicitGCConcurrent = new_value;
10148 DEBUG_ONLY(set_field_bit(5));
10149 }
10150 void set_isExplicitGCDisabled(bool new_value) {
10151 this->_isExplicitGCDisabled = new_value;
10152 DEBUG_ONLY(set_field_bit(6));
10153 }
10154 void set_pauseTarget(s8 new_value) {
10155 this->_pauseTarget = new_value;
10156 DEBUG_ONLY(set_field_bit(7));
10157 }
10158 void set_gcTimeRatio(unsigned new_value) {
10159 this->_gcTimeRatio = new_value;
10160 DEBUG_ONLY(set_field_bit(8));
10161 }
10162
10163 template <typename Writer>
10164 void writeData(Writer& w) {
10165 w.write(_youngCollector);
10166 w.write(_oldCollector);
10167 w.write(_parallelGCThreads);
10168 w.write(_concurrentGCThreads);
10169 w.write(_usesDynamicGCThreads);
10170 w.write(_isExplicitGCConcurrent);
10171 w.write(_isExplicitGCDisabled);
10172 w.write(_pauseTarget);
10173 w.write(_gcTimeRatio);
10174 }
10175
10176 using JfrEvent<EventGCConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
10177
10178 EventGCConfiguration(
10179 u8 youngCollector,
10180 u8 oldCollector,
10181 unsigned parallelGCThreads,
10182 unsigned concurrentGCThreads,
10183 bool usesDynamicGCThreads,
10184 bool isExplicitGCConcurrent,
10185 bool isExplicitGCDisabled,
10186 s8 pauseTarget,
10187 unsigned gcTimeRatio) : JfrEvent<EventGCConfiguration>(TIMED) {
10188 if (should_commit()) {
10189 set_youngCollector(youngCollector);
10190 set_oldCollector(oldCollector);
10191 set_parallelGCThreads(parallelGCThreads);
10192 set_concurrentGCThreads(concurrentGCThreads);
10193 set_usesDynamicGCThreads(usesDynamicGCThreads);
10194 set_isExplicitGCConcurrent(isExplicitGCConcurrent);
10195 set_isExplicitGCDisabled(isExplicitGCDisabled);
10196 set_pauseTarget(pauseTarget);
10197 set_gcTimeRatio(gcTimeRatio);
10198 }
10199 }
10200
10201 void commit(u8 youngCollector,
10202 u8 oldCollector,
10203 unsigned parallelGCThreads,
10204 unsigned concurrentGCThreads,
10205 bool usesDynamicGCThreads,
10206 bool isExplicitGCConcurrent,
10207 bool isExplicitGCDisabled,
10208 s8 pauseTarget,
10209 unsigned gcTimeRatio) {
10210 if (should_commit()) {
10211 set_youngCollector(youngCollector);
10212 set_oldCollector(oldCollector);
10213 set_parallelGCThreads(parallelGCThreads);
10214 set_concurrentGCThreads(concurrentGCThreads);
10215 set_usesDynamicGCThreads(usesDynamicGCThreads);
10216 set_isExplicitGCConcurrent(isExplicitGCConcurrent);
10217 set_isExplicitGCDisabled(isExplicitGCDisabled);
10218 set_pauseTarget(pauseTarget);
10219 set_gcTimeRatio(gcTimeRatio);
10220 commit();
10221 }
10222 }
10223
10224 static void commit(const Ticks& startTicks,
10225 const Ticks& endTicks,
10226 u8 youngCollector,
10227 u8 oldCollector,
10228 unsigned parallelGCThreads,
10229 unsigned concurrentGCThreads,
10230 bool usesDynamicGCThreads,
10231 bool isExplicitGCConcurrent,
10232 bool isExplicitGCDisabled,
10233 s8 pauseTarget,
10234 unsigned gcTimeRatio) {
10235 EventGCConfiguration me(UNTIMED);
10236
10237 if (me.should_commit()) {
10238 me.set_starttime(startTicks);
10239 me.set_endtime(endTicks);
10240 me.set_youngCollector(youngCollector);
10241 me.set_oldCollector(oldCollector);
10242 me.set_parallelGCThreads(parallelGCThreads);
10243 me.set_concurrentGCThreads(concurrentGCThreads);
10244 me.set_usesDynamicGCThreads(usesDynamicGCThreads);
10245 me.set_isExplicitGCConcurrent(isExplicitGCConcurrent);
10246 me.set_isExplicitGCDisabled(isExplicitGCDisabled);
10247 me.set_pauseTarget(pauseTarget);
10248 me.set_gcTimeRatio(gcTimeRatio);
10249 me.commit();
10250 }
10251 }
10252
10253#ifdef ASSERT
10254 void verify() const {
10255 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_youngCollector");
10256 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_oldCollector");
10257 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_parallelGCThreads");
10258 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_concurrentGCThreads");
10259 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_usesDynamicGCThreads");
10260 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_isExplicitGCConcurrent");
10261 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_isExplicitGCDisabled");
10262 assert(verify_field_bit(7), "Attempting to write an uninitialized event field: %s", "_pauseTarget");
10263 assert(verify_field_bit(8), "Attempting to write an uninitialized event field: %s", "_gcTimeRatio");
10264 }
10265#endif
10266};
10267
10268class EventGCSurvivorConfiguration : public JfrEvent<EventGCSurvivorConfiguration>
10269{
10270 private:
10271 u1 _maxTenuringThreshold;
10272 u1 _initialTenuringThreshold;
10273
10274 public:
10275 static const bool hasThread = false;
10276 static const bool hasStackTrace = false;
10277 static const bool isInstant = false;
10278 static const bool hasCutoff = false;
10279 static const bool isRequestable = true;
10280 static const JfrEventId eventId = JfrGCSurvivorConfigurationEvent;
10281
10282 EventGCSurvivorConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventGCSurvivorConfiguration>(timing) {}
10283
10284 void set_maxTenuringThreshold(u1 new_value) {
10285 this->_maxTenuringThreshold = new_value;
10286 DEBUG_ONLY(set_field_bit(0));
10287 }
10288 void set_initialTenuringThreshold(u1 new_value) {
10289 this->_initialTenuringThreshold = new_value;
10290 DEBUG_ONLY(set_field_bit(1));
10291 }
10292
10293 template <typename Writer>
10294 void writeData(Writer& w) {
10295 w.write(_maxTenuringThreshold);
10296 w.write(_initialTenuringThreshold);
10297 }
10298
10299 using JfrEvent<EventGCSurvivorConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
10300
10301 EventGCSurvivorConfiguration(
10302 u1 maxTenuringThreshold,
10303 u1 initialTenuringThreshold) : JfrEvent<EventGCSurvivorConfiguration>(TIMED) {
10304 if (should_commit()) {
10305 set_maxTenuringThreshold(maxTenuringThreshold);
10306 set_initialTenuringThreshold(initialTenuringThreshold);
10307 }
10308 }
10309
10310 void commit(u1 maxTenuringThreshold,
10311 u1 initialTenuringThreshold) {
10312 if (should_commit()) {
10313 set_maxTenuringThreshold(maxTenuringThreshold);
10314 set_initialTenuringThreshold(initialTenuringThreshold);
10315 commit();
10316 }
10317 }
10318
10319 static void commit(const Ticks& startTicks,
10320 const Ticks& endTicks,
10321 u1 maxTenuringThreshold,
10322 u1 initialTenuringThreshold) {
10323 EventGCSurvivorConfiguration me(UNTIMED);
10324
10325 if (me.should_commit()) {
10326 me.set_starttime(startTicks);
10327 me.set_endtime(endTicks);
10328 me.set_maxTenuringThreshold(maxTenuringThreshold);
10329 me.set_initialTenuringThreshold(initialTenuringThreshold);
10330 me.commit();
10331 }
10332 }
10333
10334#ifdef ASSERT
10335 void verify() const {
10336 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_maxTenuringThreshold");
10337 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_initialTenuringThreshold");
10338 }
10339#endif
10340};
10341
10342class EventGCTLABConfiguration : public JfrEvent<EventGCTLABConfiguration>
10343{
10344 private:
10345 bool _usesTLABs;
10346 u8 _minTLABSize;
10347 u8 _tlabRefillWasteLimit;
10348
10349 public:
10350 static const bool hasThread = false;
10351 static const bool hasStackTrace = false;
10352 static const bool isInstant = false;
10353 static const bool hasCutoff = false;
10354 static const bool isRequestable = true;
10355 static const JfrEventId eventId = JfrGCTLABConfigurationEvent;
10356
10357 EventGCTLABConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventGCTLABConfiguration>(timing) {}
10358
10359 void set_usesTLABs(bool new_value) {
10360 this->_usesTLABs = new_value;
10361 DEBUG_ONLY(set_field_bit(0));
10362 }
10363 void set_minTLABSize(u8 new_value) {
10364 this->_minTLABSize = new_value;
10365 DEBUG_ONLY(set_field_bit(1));
10366 }
10367 void set_tlabRefillWasteLimit(u8 new_value) {
10368 this->_tlabRefillWasteLimit = new_value;
10369 DEBUG_ONLY(set_field_bit(2));
10370 }
10371
10372 template <typename Writer>
10373 void writeData(Writer& w) {
10374 w.write(_usesTLABs);
10375 w.write(_minTLABSize);
10376 w.write(_tlabRefillWasteLimit);
10377 }
10378
10379 using JfrEvent<EventGCTLABConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
10380
10381 EventGCTLABConfiguration(
10382 bool usesTLABs,
10383 u8 minTLABSize,
10384 u8 tlabRefillWasteLimit) : JfrEvent<EventGCTLABConfiguration>(TIMED) {
10385 if (should_commit()) {
10386 set_usesTLABs(usesTLABs);
10387 set_minTLABSize(minTLABSize);
10388 set_tlabRefillWasteLimit(tlabRefillWasteLimit);
10389 }
10390 }
10391
10392 void commit(bool usesTLABs,
10393 u8 minTLABSize,
10394 u8 tlabRefillWasteLimit) {
10395 if (should_commit()) {
10396 set_usesTLABs(usesTLABs);
10397 set_minTLABSize(minTLABSize);
10398 set_tlabRefillWasteLimit(tlabRefillWasteLimit);
10399 commit();
10400 }
10401 }
10402
10403 static void commit(const Ticks& startTicks,
10404 const Ticks& endTicks,
10405 bool usesTLABs,
10406 u8 minTLABSize,
10407 u8 tlabRefillWasteLimit) {
10408 EventGCTLABConfiguration me(UNTIMED);
10409
10410 if (me.should_commit()) {
10411 me.set_starttime(startTicks);
10412 me.set_endtime(endTicks);
10413 me.set_usesTLABs(usesTLABs);
10414 me.set_minTLABSize(minTLABSize);
10415 me.set_tlabRefillWasteLimit(tlabRefillWasteLimit);
10416 me.commit();
10417 }
10418 }
10419
10420#ifdef ASSERT
10421 void verify() const {
10422 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_usesTLABs");
10423 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_minTLABSize");
10424 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_tlabRefillWasteLimit");
10425 }
10426#endif
10427};
10428
10429class EventGCHeapConfiguration : public JfrEvent<EventGCHeapConfiguration>
10430{
10431 private:
10432 u8 _minSize;
10433 u8 _maxSize;
10434 u8 _initialSize;
10435 bool _usesCompressedOops;
10436 u8 _compressedOopsMode;
10437 u8 _objectAlignment;
10438 u1 _heapAddressBits;
10439
10440 public:
10441 static const bool hasThread = false;
10442 static const bool hasStackTrace = false;
10443 static const bool isInstant = false;
10444 static const bool hasCutoff = false;
10445 static const bool isRequestable = true;
10446 static const JfrEventId eventId = JfrGCHeapConfigurationEvent;
10447
10448 EventGCHeapConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventGCHeapConfiguration>(timing) {}
10449
10450 void set_minSize(u8 new_value) {
10451 this->_minSize = new_value;
10452 DEBUG_ONLY(set_field_bit(0));
10453 }
10454 void set_maxSize(u8 new_value) {
10455 this->_maxSize = new_value;
10456 DEBUG_ONLY(set_field_bit(1));
10457 }
10458 void set_initialSize(u8 new_value) {
10459 this->_initialSize = new_value;
10460 DEBUG_ONLY(set_field_bit(2));
10461 }
10462 void set_usesCompressedOops(bool new_value) {
10463 this->_usesCompressedOops = new_value;
10464 DEBUG_ONLY(set_field_bit(3));
10465 }
10466 void set_compressedOopsMode(u8 new_value) {
10467 this->_compressedOopsMode = new_value;
10468 DEBUG_ONLY(set_field_bit(4));
10469 }
10470 void set_objectAlignment(u8 new_value) {
10471 this->_objectAlignment = new_value;
10472 DEBUG_ONLY(set_field_bit(5));
10473 }
10474 void set_heapAddressBits(u1 new_value) {
10475 this->_heapAddressBits = new_value;
10476 DEBUG_ONLY(set_field_bit(6));
10477 }
10478
10479 template <typename Writer>
10480 void writeData(Writer& w) {
10481 w.write(_minSize);
10482 w.write(_maxSize);
10483 w.write(_initialSize);
10484 w.write(_usesCompressedOops);
10485 w.write(_compressedOopsMode);
10486 w.write(_objectAlignment);
10487 w.write(_heapAddressBits);
10488 }
10489
10490 using JfrEvent<EventGCHeapConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
10491
10492 EventGCHeapConfiguration(
10493 u8 minSize,
10494 u8 maxSize,
10495 u8 initialSize,
10496 bool usesCompressedOops,
10497 u8 compressedOopsMode,
10498 u8 objectAlignment,
10499 u1 heapAddressBits) : JfrEvent<EventGCHeapConfiguration>(TIMED) {
10500 if (should_commit()) {
10501 set_minSize(minSize);
10502 set_maxSize(maxSize);
10503 set_initialSize(initialSize);
10504 set_usesCompressedOops(usesCompressedOops);
10505 set_compressedOopsMode(compressedOopsMode);
10506 set_objectAlignment(objectAlignment);
10507 set_heapAddressBits(heapAddressBits);
10508 }
10509 }
10510
10511 void commit(u8 minSize,
10512 u8 maxSize,
10513 u8 initialSize,
10514 bool usesCompressedOops,
10515 u8 compressedOopsMode,
10516 u8 objectAlignment,
10517 u1 heapAddressBits) {
10518 if (should_commit()) {
10519 set_minSize(minSize);
10520 set_maxSize(maxSize);
10521 set_initialSize(initialSize);
10522 set_usesCompressedOops(usesCompressedOops);
10523 set_compressedOopsMode(compressedOopsMode);
10524 set_objectAlignment(objectAlignment);
10525 set_heapAddressBits(heapAddressBits);
10526 commit();
10527 }
10528 }
10529
10530 static void commit(const Ticks& startTicks,
10531 const Ticks& endTicks,
10532 u8 minSize,
10533 u8 maxSize,
10534 u8 initialSize,
10535 bool usesCompressedOops,
10536 u8 compressedOopsMode,
10537 u8 objectAlignment,
10538 u1 heapAddressBits) {
10539 EventGCHeapConfiguration me(UNTIMED);
10540
10541 if (me.should_commit()) {
10542 me.set_starttime(startTicks);
10543 me.set_endtime(endTicks);
10544 me.set_minSize(minSize);
10545 me.set_maxSize(maxSize);
10546 me.set_initialSize(initialSize);
10547 me.set_usesCompressedOops(usesCompressedOops);
10548 me.set_compressedOopsMode(compressedOopsMode);
10549 me.set_objectAlignment(objectAlignment);
10550 me.set_heapAddressBits(heapAddressBits);
10551 me.commit();
10552 }
10553 }
10554
10555#ifdef ASSERT
10556 void verify() const {
10557 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_minSize");
10558 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_maxSize");
10559 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_initialSize");
10560 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_usesCompressedOops");
10561 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_compressedOopsMode");
10562 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_objectAlignment");
10563 assert(verify_field_bit(6), "Attempting to write an uninitialized event field: %s", "_heapAddressBits");
10564 }
10565#endif
10566};
10567
10568class EventYoungGenerationConfiguration : public JfrEvent<EventYoungGenerationConfiguration>
10569{
10570 private:
10571 u8 _minSize;
10572 u8 _maxSize;
10573 unsigned _newRatio;
10574
10575 public:
10576 static const bool hasThread = false;
10577 static const bool hasStackTrace = false;
10578 static const bool isInstant = false;
10579 static const bool hasCutoff = false;
10580 static const bool isRequestable = true;
10581 static const JfrEventId eventId = JfrYoungGenerationConfigurationEvent;
10582
10583 EventYoungGenerationConfiguration(EventStartTime timing=TIMED) : JfrEvent<EventYoungGenerationConfiguration>(timing) {}
10584
10585 void set_minSize(u8 new_value) {
10586 this->_minSize = new_value;
10587 DEBUG_ONLY(set_field_bit(0));
10588 }
10589 void set_maxSize(u8 new_value) {
10590 this->_maxSize = new_value;
10591 DEBUG_ONLY(set_field_bit(1));
10592 }
10593 void set_newRatio(unsigned new_value) {
10594 this->_newRatio = new_value;
10595 DEBUG_ONLY(set_field_bit(2));
10596 }
10597
10598 template <typename Writer>
10599 void writeData(Writer& w) {
10600 w.write(_minSize);
10601 w.write(_maxSize);
10602 w.write(_newRatio);
10603 }
10604
10605 using JfrEvent<EventYoungGenerationConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
10606
10607 EventYoungGenerationConfiguration(
10608 u8 minSize,
10609 u8 maxSize,
10610 unsigned newRatio) : JfrEvent<EventYoungGenerationConfiguration>(TIMED) {
10611 if (should_commit()) {
10612 set_minSize(minSize);
10613 set_maxSize(maxSize);
10614 set_newRatio(newRatio);
10615 }
10616 }
10617
10618 void commit(u8 minSize,
10619 u8 maxSize,
10620 unsigned newRatio) {
10621 if (should_commit()) {
10622 set_minSize(minSize);
10623 set_maxSize(maxSize);
10624 set_newRatio(newRatio);
10625 commit();
10626 }
10627 }
10628
10629 static void commit(const Ticks& startTicks,
10630 const Ticks& endTicks,
10631 u8 minSize,
10632 u8 maxSize,
10633 unsigned newRatio) {
10634 EventYoungGenerationConfiguration me(UNTIMED);
10635
10636 if (me.should_commit()) {
10637 me.set_starttime(startTicks);
10638 me.set_endtime(endTicks);
10639 me.set_minSize(minSize);
10640 me.set_maxSize(maxSize);
10641 me.set_newRatio(newRatio);
10642 me.commit();
10643 }
10644 }
10645
10646#ifdef ASSERT
10647 void verify() const {
10648 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_minSize");
10649 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_maxSize");
10650 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_newRatio");
10651 }
10652#endif
10653};
10654
10655class EventZPageAllocation : public JfrEvent<EventZPageAllocation>
10656{
10657 private:
10658 u8 _pageSize;
10659 u8 _usedAfter;
10660 u8 _freeAfter;
10661 u8 _inCacheAfter;
10662 bool _nonBlocking;
10663 bool _noReserve;
10664
10665 public:
10666 static const bool hasThread = true;
10667 static const bool hasStackTrace = false;
10668 static const bool isInstant = false;
10669 static const bool hasCutoff = false;
10670 static const bool isRequestable = false;
10671 static const JfrEventId eventId = JfrZPageAllocationEvent;
10672
10673 EventZPageAllocation(EventStartTime timing=TIMED) : JfrEvent<EventZPageAllocation>(timing) {}
10674
10675 void set_pageSize(u8 new_value) {
10676 this->_pageSize = new_value;
10677 DEBUG_ONLY(set_field_bit(0));
10678 }
10679 void set_usedAfter(u8 new_value) {
10680 this->_usedAfter = new_value;
10681 DEBUG_ONLY(set_field_bit(1));
10682 }
10683 void set_freeAfter(u8 new_value) {
10684 this->_freeAfter = new_value;
10685 DEBUG_ONLY(set_field_bit(2));
10686 }
10687 void set_inCacheAfter(u8 new_value) {
10688 this->_inCacheAfter = new_value;
10689 DEBUG_ONLY(set_field_bit(3));
10690 }
10691 void set_nonBlocking(bool new_value) {
10692 this->_nonBlocking = new_value;
10693 DEBUG_ONLY(set_field_bit(4));
10694 }
10695 void set_noReserve(bool new_value) {
10696 this->_noReserve = new_value;
10697 DEBUG_ONLY(set_field_bit(5));
10698 }
10699
10700 template <typename Writer>
10701 void writeData(Writer& w) {
10702 w.write(_pageSize);
10703 w.write(_usedAfter);
10704 w.write(_freeAfter);
10705 w.write(_inCacheAfter);
10706 w.write(_nonBlocking);
10707 w.write(_noReserve);
10708 }
10709
10710 using JfrEvent<EventZPageAllocation>::commit; // else commit() is hidden by overloaded versions in this class
10711
10712 EventZPageAllocation(
10713 u8 pageSize,
10714 u8 usedAfter,
10715 u8 freeAfter,
10716 u8 inCacheAfter,
10717 bool nonBlocking,
10718 bool noReserve) : JfrEvent<EventZPageAllocation>(TIMED) {
10719 if (should_commit()) {
10720 set_pageSize(pageSize);
10721 set_usedAfter(usedAfter);
10722 set_freeAfter(freeAfter);
10723 set_inCacheAfter(inCacheAfter);
10724 set_nonBlocking(nonBlocking);
10725 set_noReserve(noReserve);
10726 }
10727 }
10728
10729 void commit(u8 pageSize,
10730 u8 usedAfter,
10731 u8 freeAfter,
10732 u8 inCacheAfter,
10733 bool nonBlocking,
10734 bool noReserve) {
10735 if (should_commit()) {
10736 set_pageSize(pageSize);
10737 set_usedAfter(usedAfter);
10738 set_freeAfter(freeAfter);
10739 set_inCacheAfter(inCacheAfter);
10740 set_nonBlocking(nonBlocking);
10741 set_noReserve(noReserve);
10742 commit();
10743 }
10744 }
10745
10746 static void commit(const Ticks& startTicks,
10747 const Ticks& endTicks,
10748 u8 pageSize,
10749 u8 usedAfter,
10750 u8 freeAfter,
10751 u8 inCacheAfter,
10752 bool nonBlocking,
10753 bool noReserve) {
10754 EventZPageAllocation me(UNTIMED);
10755
10756 if (me.should_commit()) {
10757 me.set_starttime(startTicks);
10758 me.set_endtime(endTicks);
10759 me.set_pageSize(pageSize);
10760 me.set_usedAfter(usedAfter);
10761 me.set_freeAfter(freeAfter);
10762 me.set_inCacheAfter(inCacheAfter);
10763 me.set_nonBlocking(nonBlocking);
10764 me.set_noReserve(noReserve);
10765 me.commit();
10766 }
10767 }
10768
10769#ifdef ASSERT
10770 void verify() const {
10771 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_pageSize");
10772 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_usedAfter");
10773 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_freeAfter");
10774 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_inCacheAfter");
10775 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_nonBlocking");
10776 assert(verify_field_bit(5), "Attempting to write an uninitialized event field: %s", "_noReserve");
10777 }
10778#endif
10779};
10780
10781class EventZThreadPhase : public JfrEvent<EventZThreadPhase>
10782{
10783 private:
10784 unsigned _gcId;
10785 const char* _name;
10786
10787 public:
10788 static const bool hasThread = true;
10789 static const bool hasStackTrace = false;
10790 static const bool isInstant = false;
10791 static const bool hasCutoff = false;
10792 static const bool isRequestable = false;
10793 static const JfrEventId eventId = JfrZThreadPhaseEvent;
10794
10795 EventZThreadPhase(EventStartTime timing=TIMED) : JfrEvent<EventZThreadPhase>(timing) {}
10796
10797 void set_gcId(unsigned new_value) {
10798 this->_gcId = new_value;
10799 DEBUG_ONLY(set_field_bit(0));
10800 }
10801 void set_name(const char* new_value) {
10802 this->_name = new_value;
10803 DEBUG_ONLY(set_field_bit(1));
10804 }
10805
10806 template <typename Writer>
10807 void writeData(Writer& w) {
10808 w.write(_gcId);
10809 w.write(_name);
10810 }
10811
10812 using JfrEvent<EventZThreadPhase>::commit; // else commit() is hidden by overloaded versions in this class
10813
10814 EventZThreadPhase(
10815 unsigned gcId,
10816 const char* name) : JfrEvent<EventZThreadPhase>(TIMED) {
10817 if (should_commit()) {
10818 set_gcId(gcId);
10819 set_name(name);
10820 }
10821 }
10822
10823 void commit(unsigned gcId,
10824 const char* name) {
10825 if (should_commit()) {
10826 set_gcId(gcId);
10827 set_name(name);
10828 commit();
10829 }
10830 }
10831
10832 static void commit(const Ticks& startTicks,
10833 const Ticks& endTicks,
10834 unsigned gcId,
10835 const char* name) {
10836 EventZThreadPhase me(UNTIMED);
10837
10838 if (me.should_commit()) {
10839 me.set_starttime(startTicks);
10840 me.set_endtime(endTicks);
10841 me.set_gcId(gcId);
10842 me.set_name(name);
10843 me.commit();
10844 }
10845 }
10846
10847#ifdef ASSERT
10848 void verify() const {
10849 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_gcId");
10850 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_name");
10851 }
10852#endif
10853};
10854
10855class EventZStatisticsCounter : public JfrEvent<EventZStatisticsCounter>
10856{
10857 private:
10858 u8 _id;
10859 u8 _increment;
10860 u8 _value;
10861
10862 public:
10863 static const bool hasThread = true;
10864 static const bool hasStackTrace = false;
10865 static const bool isInstant = false;
10866 static const bool hasCutoff = false;
10867 static const bool isRequestable = false;
10868 static const JfrEventId eventId = JfrZStatisticsCounterEvent;
10869
10870 EventZStatisticsCounter(EventStartTime timing=TIMED) : JfrEvent<EventZStatisticsCounter>(timing) {}
10871
10872 void set_id(u8 new_value) {
10873 this->_id = new_value;
10874 DEBUG_ONLY(set_field_bit(0));
10875 }
10876 void set_increment(u8 new_value) {
10877 this->_increment = new_value;
10878 DEBUG_ONLY(set_field_bit(1));
10879 }
10880 void set_value(u8 new_value) {
10881 this->_value = new_value;
10882 DEBUG_ONLY(set_field_bit(2));
10883 }
10884
10885 template <typename Writer>
10886 void writeData(Writer& w) {
10887 w.write(_id);
10888 w.write(_increment);
10889 w.write(_value);
10890 }
10891
10892 using JfrEvent<EventZStatisticsCounter>::commit; // else commit() is hidden by overloaded versions in this class
10893
10894 EventZStatisticsCounter(
10895 u8 id,
10896 u8 increment,
10897 u8 value) : JfrEvent<EventZStatisticsCounter>(TIMED) {
10898 if (should_commit()) {
10899 set_id(id);
10900 set_increment(increment);
10901 set_value(value);
10902 }
10903 }
10904
10905 void commit(u8 id,
10906 u8 increment,
10907 u8 value) {
10908 if (should_commit()) {
10909 set_id(id);
10910 set_increment(increment);
10911 set_value(value);
10912 commit();
10913 }
10914 }
10915
10916 static void commit(const Ticks& startTicks,
10917 const Ticks& endTicks,
10918 u8 id,
10919 u8 increment,
10920 u8 value) {
10921 EventZStatisticsCounter me(UNTIMED);
10922
10923 if (me.should_commit()) {
10924 me.set_starttime(startTicks);
10925 me.set_endtime(endTicks);
10926 me.set_id(id);
10927 me.set_increment(increment);
10928 me.set_value(value);
10929 me.commit();
10930 }
10931 }
10932
10933#ifdef ASSERT
10934 void verify() const {
10935 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_id");
10936 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_increment");
10937 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_value");
10938 }
10939#endif
10940};
10941
10942class EventZStatisticsSampler : public JfrEvent<EventZStatisticsSampler>
10943{
10944 private:
10945 u8 _id;
10946 u8 _value;
10947
10948 public:
10949 static const bool hasThread = true;
10950 static const bool hasStackTrace = false;
10951 static const bool isInstant = false;
10952 static const bool hasCutoff = false;
10953 static const bool isRequestable = false;
10954 static const JfrEventId eventId = JfrZStatisticsSamplerEvent;
10955
10956 EventZStatisticsSampler(EventStartTime timing=TIMED) : JfrEvent<EventZStatisticsSampler>(timing) {}
10957
10958 void set_id(u8 new_value) {
10959 this->_id = new_value;
10960 DEBUG_ONLY(set_field_bit(0));
10961 }
10962 void set_value(u8 new_value) {
10963 this->_value = new_value;
10964 DEBUG_ONLY(set_field_bit(1));
10965 }
10966
10967 template <typename Writer>
10968 void writeData(Writer& w) {
10969 w.write(_id);
10970 w.write(_value);
10971 }
10972
10973 using JfrEvent<EventZStatisticsSampler>::commit; // else commit() is hidden by overloaded versions in this class
10974
10975 EventZStatisticsSampler(
10976 u8 id,
10977 u8 value) : JfrEvent<EventZStatisticsSampler>(TIMED) {
10978 if (should_commit()) {
10979 set_id(id);
10980 set_value(value);
10981 }
10982 }
10983
10984 void commit(u8 id,
10985 u8 value) {
10986 if (should_commit()) {
10987 set_id(id);
10988 set_value(value);
10989 commit();
10990 }
10991 }
10992
10993 static void commit(const Ticks& startTicks,
10994 const Ticks& endTicks,
10995 u8 id,
10996 u8 value) {
10997 EventZStatisticsSampler me(UNTIMED);
10998
10999 if (me.should_commit()) {
11000 me.set_starttime(startTicks);
11001 me.set_endtime(endTicks);
11002 me.set_id(id);
11003 me.set_value(value);
11004 me.commit();
11005 }
11006 }
11007
11008#ifdef ASSERT
11009 void verify() const {
11010 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_id");
11011 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_value");
11012 }
11013#endif
11014};
11015
11016class EventShenandoahHeapRegionStateChange : public JfrEvent<EventShenandoahHeapRegionStateChange>
11017{
11018 private:
11019 unsigned _index;
11020 u8 _from;
11021 u8 _to;
11022 u8 _start;
11023 u8 _used;
11024
11025 public:
11026 static const bool hasThread = false;
11027 static const bool hasStackTrace = false;
11028 static const bool isInstant = true;
11029 static const bool hasCutoff = false;
11030 static const bool isRequestable = false;
11031 static const JfrEventId eventId = JfrShenandoahHeapRegionStateChangeEvent;
11032
11033 EventShenandoahHeapRegionStateChange(EventStartTime timing=TIMED) : JfrEvent<EventShenandoahHeapRegionStateChange>(timing) {}
11034
11035 void set_index(unsigned new_value) {
11036 this->_index = new_value;
11037 DEBUG_ONLY(set_field_bit(0));
11038 }
11039 void set_from(u8 new_value) {
11040 this->_from = new_value;
11041 DEBUG_ONLY(set_field_bit(1));
11042 }
11043 void set_to(u8 new_value) {
11044 this->_to = new_value;
11045 DEBUG_ONLY(set_field_bit(2));
11046 }
11047 void set_start(u8 new_value) {
11048 this->_start = new_value;
11049 DEBUG_ONLY(set_field_bit(3));
11050 }
11051 void set_used(u8 new_value) {
11052 this->_used = new_value;
11053 DEBUG_ONLY(set_field_bit(4));
11054 }
11055
11056 template <typename Writer>
11057 void writeData(Writer& w) {
11058 w.write(_index);
11059 w.write(_from);
11060 w.write(_to);
11061 w.write(_start);
11062 w.write(_used);
11063 }
11064
11065 using JfrEvent<EventShenandoahHeapRegionStateChange>::commit; // else commit() is hidden by overloaded versions in this class
11066
11067
11068
11069 static void commit(unsigned index,
11070 u8 from,
11071 u8 to,
11072 u8 start,
11073 u8 used) {
11074 EventShenandoahHeapRegionStateChange me(UNTIMED);
11075
11076 if (me.should_commit()) {
11077 me.set_index(index);
11078 me.set_from(from);
11079 me.set_to(to);
11080 me.set_start(start);
11081 me.set_used(used);
11082 me.commit();
11083 }
11084 }
11085
11086#ifdef ASSERT
11087 void verify() const {
11088 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_index");
11089 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_from");
11090 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_to");
11091 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_start");
11092 assert(verify_field_bit(4), "Attempting to write an uninitialized event field: %s", "_used");
11093 }
11094#endif
11095};
11096
11097class EventShenandoahHeapRegionInformation : public JfrEvent<EventShenandoahHeapRegionInformation>
11098{
11099 private:
11100 unsigned _index;
11101 u8 _state;
11102 u8 _start;
11103 u8 _used;
11104
11105 public:
11106 static const bool hasThread = false;
11107 static const bool hasStackTrace = false;
11108 static const bool isInstant = false;
11109 static const bool hasCutoff = false;
11110 static const bool isRequestable = true;
11111 static const JfrEventId eventId = JfrShenandoahHeapRegionInformationEvent;
11112
11113 EventShenandoahHeapRegionInformation(EventStartTime timing=TIMED) : JfrEvent<EventShenandoahHeapRegionInformation>(timing) {}
11114
11115 void set_index(unsigned new_value) {
11116 this->_index = new_value;
11117 DEBUG_ONLY(set_field_bit(0));
11118 }
11119 void set_state(u8 new_value) {
11120 this->_state = new_value;
11121 DEBUG_ONLY(set_field_bit(1));
11122 }
11123 void set_start(u8 new_value) {
11124 this->_start = new_value;
11125 DEBUG_ONLY(set_field_bit(2));
11126 }
11127 void set_used(u8 new_value) {
11128 this->_used = new_value;
11129 DEBUG_ONLY(set_field_bit(3));
11130 }
11131
11132 template <typename Writer>
11133 void writeData(Writer& w) {
11134 w.write(_index);
11135 w.write(_state);
11136 w.write(_start);
11137 w.write(_used);
11138 }
11139
11140 using JfrEvent<EventShenandoahHeapRegionInformation>::commit; // else commit() is hidden by overloaded versions in this class
11141
11142 EventShenandoahHeapRegionInformation(
11143 unsigned index,
11144 u8 state,
11145 u8 start,
11146 u8 used) : JfrEvent<EventShenandoahHeapRegionInformation>(TIMED) {
11147 if (should_commit()) {
11148 set_index(index);
11149 set_state(state);
11150 set_start(start);
11151 set_used(used);
11152 }
11153 }
11154
11155 void commit(unsigned index,
11156 u8 state,
11157 u8 start,
11158 u8 used) {
11159 if (should_commit()) {
11160 set_index(index);
11161 set_state(state);
11162 set_start(start);
11163 set_used(used);
11164 commit();
11165 }
11166 }
11167
11168 static void commit(const Ticks& startTicks,
11169 const Ticks& endTicks,
11170 unsigned index,
11171 u8 state,
11172 u8 start,
11173 u8 used) {
11174 EventShenandoahHeapRegionInformation me(UNTIMED);
11175
11176 if (me.should_commit()) {
11177 me.set_starttime(startTicks);
11178 me.set_endtime(endTicks);
11179 me.set_index(index);
11180 me.set_state(state);
11181 me.set_start(start);
11182 me.set_used(used);
11183 me.commit();
11184 }
11185 }
11186
11187#ifdef ASSERT
11188 void verify() const {
11189 assert(verify_field_bit(0), "Attempting to write an uninitialized event field: %s", "_index");
11190 assert(verify_field_bit(1), "Attempting to write an uninitialized event field: %s", "_state");
11191 assert(verify_field_bit(2), "Attempting to write an uninitialized event field: %s", "_start");
11192 assert(verify_field_bit(3), "Attempting to write an uninitialized event field: %s", "_used");
11193 }
11194#endif
11195};
11196
11197
11198
11199#else // !INCLUDE_JFR
11200
11201template <typename T>
11202class JfrEvent {
11203 public:
11204 JfrEvent() {}
11205 void set_starttime(const Ticks&) const {}
11206 void set_endtime(const Ticks&) const {}
11207 bool should_commit() const { return false; }
11208 static bool is_enabled() { return false; }
11209 void commit() {}
11210};
11211
11212struct JfrStructVirtualSpace
11213{
11214 public:
11215 void set_start(u8 new_value) { }
11216 void set_committedEnd(u8 new_value) { }
11217 void set_committedSize(u8 new_value) { }
11218 void set_reservedEnd(u8 new_value) { }
11219 void set_reservedSize(u8 new_value) { }
11220
11221};
11222
11223
11224struct JfrStructObjectSpace
11225{
11226 public:
11227 void set_start(u8 new_value) { }
11228 void set_end(u8 new_value) { }
11229 void set_used(u8 new_value) { }
11230 void set_size(u8 new_value) { }
11231
11232};
11233
11234
11235struct JfrStructMetaspaceSizes
11236{
11237 public:
11238 void set_committed(u8 new_value) { }
11239 void set_used(u8 new_value) { }
11240 void set_reserved(u8 new_value) { }
11241
11242};
11243
11244
11245struct JfrStructCopyFailed
11246{
11247 public:
11248 void set_objectCount(u8 new_value) { }
11249 void set_firstSize(u8 new_value) { }
11250 void set_smallestSize(u8 new_value) { }
11251 void set_totalSize(u8 new_value) { }
11252
11253};
11254
11255
11256struct JfrStructG1EvacuationStatistics
11257{
11258 public:
11259 void set_gcId(unsigned new_value) { }
11260 void set_allocated(u8 new_value) { }
11261 void set_wasted(u8 new_value) { }
11262 void set_used(u8 new_value) { }
11263 void set_undoWaste(u8 new_value) { }
11264 void set_regionEndWaste(u8 new_value) { }
11265 void set_regionsRefilled(unsigned new_value) { }
11266 void set_directAllocated(u8 new_value) { }
11267 void set_failureUsed(u8 new_value) { }
11268 void set_failureWaste(u8 new_value) { }
11269
11270};
11271
11272
11273struct JfrStructCalleeMethod
11274{
11275 public:
11276 void set_type(const char* new_value) { }
11277 void set_name(const char* new_value) { }
11278 void set_descriptor(const char* new_value) { }
11279
11280};
11281
11282
11283struct JfrStructStackFrame
11284{
11285 public:
11286 void set_method(const Method* new_value) { }
11287 void set_lineNumber(s4 new_value) { }
11288 void set_bytecodeIndex(s4 new_value) { }
11289 void set_type(u8 new_value) { }
11290
11291};
11292
11293
11294class EventThreadStart : public JfrEvent<EventThreadStart>
11295{
11296 public:
11297 EventThreadStart(EventStartTime timing=TIMED) {}
11298
11299 void set_thread(u8 new_value) {
11300 }
11301
11302 using JfrEvent<EventThreadStart>::commit; // else commit() is hidden by overloaded versions in this class
11303
11304
11305
11306 static void commit(u8 thread) {
11307 }
11308};
11309
11310class EventThreadEnd : public JfrEvent<EventThreadEnd>
11311{
11312 public:
11313 EventThreadEnd(EventStartTime timing=TIMED) {}
11314
11315 void set_thread(u8 new_value) {
11316 }
11317
11318 using JfrEvent<EventThreadEnd>::commit; // else commit() is hidden by overloaded versions in this class
11319
11320
11321
11322 static void commit(u8 thread) {
11323 }
11324};
11325
11326class EventThreadSleep : public JfrEvent<EventThreadSleep>
11327{
11328 public:
11329 EventThreadSleep(EventStartTime timing=TIMED) {}
11330
11331 void set_time(s8 new_value) {
11332 }
11333
11334 using JfrEvent<EventThreadSleep>::commit; // else commit() is hidden by overloaded versions in this class
11335
11336 EventThreadSleep(
11337 s8 time) {
11338 }
11339
11340 void commit(s8 time) {
11341 }
11342
11343 static void commit(const Ticks& startTicks,
11344 const Ticks& endTicks,
11345 s8 time) {
11346 }
11347};
11348
11349class EventThreadPark : public JfrEvent<EventThreadPark>
11350{
11351 public:
11352 EventThreadPark(EventStartTime timing=TIMED) {}
11353
11354 void set_parkedClass(const Klass* new_value) {
11355 }
11356 void set_timeout(s8 new_value) {
11357 }
11358 void set_until(s8 new_value) {
11359 }
11360 void set_address(u8 new_value) {
11361 }
11362
11363 using JfrEvent<EventThreadPark>::commit; // else commit() is hidden by overloaded versions in this class
11364
11365 EventThreadPark(
11366 const Klass* parkedClass,
11367 s8 timeout,
11368 s8 until,
11369 u8 address) {
11370 }
11371
11372 void commit(const Klass* parkedClass,
11373 s8 timeout,
11374 s8 until,
11375 u8 address) {
11376 }
11377
11378 static void commit(const Ticks& startTicks,
11379 const Ticks& endTicks,
11380 const Klass* parkedClass,
11381 s8 timeout,
11382 s8 until,
11383 u8 address) {
11384 }
11385};
11386
11387class EventJavaMonitorEnter : public JfrEvent<EventJavaMonitorEnter>
11388{
11389 public:
11390 EventJavaMonitorEnter(EventStartTime timing=TIMED) {}
11391
11392 void set_monitorClass(const Klass* new_value) {
11393 }
11394 void set_previousOwner(u8 new_value) {
11395 }
11396 void set_address(u8 new_value) {
11397 }
11398
11399 using JfrEvent<EventJavaMonitorEnter>::commit; // else commit() is hidden by overloaded versions in this class
11400
11401 EventJavaMonitorEnter(
11402 const Klass* monitorClass,
11403 u8 previousOwner,
11404 u8 address) {
11405 }
11406
11407 void commit(const Klass* monitorClass,
11408 u8 previousOwner,
11409 u8 address) {
11410 }
11411
11412 static void commit(const Ticks& startTicks,
11413 const Ticks& endTicks,
11414 const Klass* monitorClass,
11415 u8 previousOwner,
11416 u8 address) {
11417 }
11418};
11419
11420class EventJavaMonitorWait : public JfrEvent<EventJavaMonitorWait>
11421{
11422 public:
11423 EventJavaMonitorWait(EventStartTime timing=TIMED) {}
11424
11425 void set_monitorClass(const Klass* new_value) {
11426 }
11427 void set_notifier(u8 new_value) {
11428 }
11429 void set_timeout(s8 new_value) {
11430 }
11431 void set_timedOut(bool new_value) {
11432 }
11433 void set_address(u8 new_value) {
11434 }
11435
11436 using JfrEvent<EventJavaMonitorWait>::commit; // else commit() is hidden by overloaded versions in this class
11437
11438 EventJavaMonitorWait(
11439 const Klass* monitorClass,
11440 u8 notifier,
11441 s8 timeout,
11442 bool timedOut,
11443 u8 address) {
11444 }
11445
11446 void commit(const Klass* monitorClass,
11447 u8 notifier,
11448 s8 timeout,
11449 bool timedOut,
11450 u8 address) {
11451 }
11452
11453 static void commit(const Ticks& startTicks,
11454 const Ticks& endTicks,
11455 const Klass* monitorClass,
11456 u8 notifier,
11457 s8 timeout,
11458 bool timedOut,
11459 u8 address) {
11460 }
11461};
11462
11463class EventJavaMonitorInflate : public JfrEvent<EventJavaMonitorInflate>
11464{
11465 public:
11466 EventJavaMonitorInflate(EventStartTime timing=TIMED) {}
11467
11468 void set_monitorClass(const Klass* new_value) {
11469 }
11470 void set_address(u8 new_value) {
11471 }
11472 void set_cause(u8 new_value) {
11473 }
11474
11475 using JfrEvent<EventJavaMonitorInflate>::commit; // else commit() is hidden by overloaded versions in this class
11476
11477 EventJavaMonitorInflate(
11478 const Klass* monitorClass,
11479 u8 address,
11480 u8 cause) {
11481 }
11482
11483 void commit(const Klass* monitorClass,
11484 u8 address,
11485 u8 cause) {
11486 }
11487
11488 static void commit(const Ticks& startTicks,
11489 const Ticks& endTicks,
11490 const Klass* monitorClass,
11491 u8 address,
11492 u8 cause) {
11493 }
11494};
11495
11496class EventBiasedLockRevocation : public JfrEvent<EventBiasedLockRevocation>
11497{
11498 public:
11499 EventBiasedLockRevocation(EventStartTime timing=TIMED) {}
11500
11501 void set_lockClass(const Klass* new_value) {
11502 }
11503 void set_safepointId(u8 new_value) {
11504 }
11505 void set_previousOwner(u8 new_value) {
11506 }
11507
11508 using JfrEvent<EventBiasedLockRevocation>::commit; // else commit() is hidden by overloaded versions in this class
11509
11510 EventBiasedLockRevocation(
11511 const Klass* lockClass,
11512 u8 safepointId,
11513 u8 previousOwner) {
11514 }
11515
11516 void commit(const Klass* lockClass,
11517 u8 safepointId,
11518 u8 previousOwner) {
11519 }
11520
11521 static void commit(const Ticks& startTicks,
11522 const Ticks& endTicks,
11523 const Klass* lockClass,
11524 u8 safepointId,
11525 u8 previousOwner) {
11526 }
11527};
11528
11529class EventBiasedLockSelfRevocation : public JfrEvent<EventBiasedLockSelfRevocation>
11530{
11531 public:
11532 EventBiasedLockSelfRevocation(EventStartTime timing=TIMED) {}
11533
11534 void set_lockClass(const Klass* new_value) {
11535 }
11536
11537 using JfrEvent<EventBiasedLockSelfRevocation>::commit; // else commit() is hidden by overloaded versions in this class
11538
11539 EventBiasedLockSelfRevocation(
11540 const Klass* lockClass) {
11541 }
11542
11543 void commit(const Klass* lockClass) {
11544 }
11545
11546 static void commit(const Ticks& startTicks,
11547 const Ticks& endTicks,
11548 const Klass* lockClass) {
11549 }
11550};
11551
11552class EventBiasedLockClassRevocation : public JfrEvent<EventBiasedLockClassRevocation>
11553{
11554 public:
11555 EventBiasedLockClassRevocation(EventStartTime timing=TIMED) {}
11556
11557 void set_revokedClass(const Klass* new_value) {
11558 }
11559 void set_disableBiasing(bool new_value) {
11560 }
11561 void set_safepointId(u8 new_value) {
11562 }
11563
11564 using JfrEvent<EventBiasedLockClassRevocation>::commit; // else commit() is hidden by overloaded versions in this class
11565
11566 EventBiasedLockClassRevocation(
11567 const Klass* revokedClass,
11568 bool disableBiasing,
11569 u8 safepointId) {
11570 }
11571
11572 void commit(const Klass* revokedClass,
11573 bool disableBiasing,
11574 u8 safepointId) {
11575 }
11576
11577 static void commit(const Ticks& startTicks,
11578 const Ticks& endTicks,
11579 const Klass* revokedClass,
11580 bool disableBiasing,
11581 u8 safepointId) {
11582 }
11583};
11584
11585class EventReservedStackActivation : public JfrEvent<EventReservedStackActivation>
11586{
11587 public:
11588 EventReservedStackActivation(EventStartTime timing=TIMED) {}
11589
11590 void set_method(const Method* new_value) {
11591 }
11592
11593 using JfrEvent<EventReservedStackActivation>::commit; // else commit() is hidden by overloaded versions in this class
11594
11595
11596
11597 static void commit(const Method* method) {
11598 }
11599};
11600
11601class EventClassLoad : public JfrEvent<EventClassLoad>
11602{
11603 public:
11604 EventClassLoad(EventStartTime timing=TIMED) {}
11605
11606 void set_loadedClass(const Klass* new_value) {
11607 }
11608 void set_definingClassLoader(const ClassLoaderData* new_value) {
11609 }
11610 void set_initiatingClassLoader(const ClassLoaderData* new_value) {
11611 }
11612
11613 using JfrEvent<EventClassLoad>::commit; // else commit() is hidden by overloaded versions in this class
11614
11615 EventClassLoad(
11616 const Klass* loadedClass,
11617 const ClassLoaderData* definingClassLoader,
11618 const ClassLoaderData* initiatingClassLoader) {
11619 }
11620
11621 void commit(const Klass* loadedClass,
11622 const ClassLoaderData* definingClassLoader,
11623 const ClassLoaderData* initiatingClassLoader) {
11624 }
11625
11626 static void commit(const Ticks& startTicks,
11627 const Ticks& endTicks,
11628 const Klass* loadedClass,
11629 const ClassLoaderData* definingClassLoader,
11630 const ClassLoaderData* initiatingClassLoader) {
11631 }
11632};
11633
11634class EventClassDefine : public JfrEvent<EventClassDefine>
11635{
11636 public:
11637 EventClassDefine(EventStartTime timing=TIMED) {}
11638
11639 void set_definedClass(const Klass* new_value) {
11640 }
11641 void set_definingClassLoader(const ClassLoaderData* new_value) {
11642 }
11643
11644 using JfrEvent<EventClassDefine>::commit; // else commit() is hidden by overloaded versions in this class
11645
11646
11647
11648 static void commit(const Klass* definedClass,
11649 const ClassLoaderData* definingClassLoader) {
11650 }
11651};
11652
11653class EventClassUnload : public JfrEvent<EventClassUnload>
11654{
11655 public:
11656 EventClassUnload(EventStartTime timing=TIMED) {}
11657
11658 void set_unloadedClass(const Klass* new_value) {
11659 }
11660 void set_definingClassLoader(const ClassLoaderData* new_value) {
11661 }
11662
11663 using JfrEvent<EventClassUnload>::commit; // else commit() is hidden by overloaded versions in this class
11664
11665
11666
11667 static void commit(const Klass* unloadedClass,
11668 const ClassLoaderData* definingClassLoader) {
11669 }
11670};
11671
11672class EventIntFlagChanged : public JfrEvent<EventIntFlagChanged>
11673{
11674 public:
11675 EventIntFlagChanged(EventStartTime timing=TIMED) {}
11676
11677 void set_name(const char* new_value) {
11678 }
11679 void set_oldValue(s4 new_value) {
11680 }
11681 void set_newValue(s4 new_value) {
11682 }
11683 void set_origin(u8 new_value) {
11684 }
11685
11686 using JfrEvent<EventIntFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11687
11688
11689
11690 static void commit(const char* name,
11691 s4 oldValue,
11692 s4 newValue,
11693 u8 origin) {
11694 }
11695};
11696
11697class EventUnsignedIntFlagChanged : public JfrEvent<EventUnsignedIntFlagChanged>
11698{
11699 public:
11700 EventUnsignedIntFlagChanged(EventStartTime timing=TIMED) {}
11701
11702 void set_name(const char* new_value) {
11703 }
11704 void set_oldValue(unsigned new_value) {
11705 }
11706 void set_newValue(unsigned new_value) {
11707 }
11708 void set_origin(u8 new_value) {
11709 }
11710
11711 using JfrEvent<EventUnsignedIntFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11712
11713
11714
11715 static void commit(const char* name,
11716 unsigned oldValue,
11717 unsigned newValue,
11718 u8 origin) {
11719 }
11720};
11721
11722class EventLongFlagChanged : public JfrEvent<EventLongFlagChanged>
11723{
11724 public:
11725 EventLongFlagChanged(EventStartTime timing=TIMED) {}
11726
11727 void set_name(const char* new_value) {
11728 }
11729 void set_oldValue(s8 new_value) {
11730 }
11731 void set_newValue(s8 new_value) {
11732 }
11733 void set_origin(u8 new_value) {
11734 }
11735
11736 using JfrEvent<EventLongFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11737
11738
11739
11740 static void commit(const char* name,
11741 s8 oldValue,
11742 s8 newValue,
11743 u8 origin) {
11744 }
11745};
11746
11747class EventUnsignedLongFlagChanged : public JfrEvent<EventUnsignedLongFlagChanged>
11748{
11749 public:
11750 EventUnsignedLongFlagChanged(EventStartTime timing=TIMED) {}
11751
11752 void set_name(const char* new_value) {
11753 }
11754 void set_oldValue(u8 new_value) {
11755 }
11756 void set_newValue(u8 new_value) {
11757 }
11758 void set_origin(u8 new_value) {
11759 }
11760
11761 using JfrEvent<EventUnsignedLongFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11762
11763
11764
11765 static void commit(const char* name,
11766 u8 oldValue,
11767 u8 newValue,
11768 u8 origin) {
11769 }
11770};
11771
11772class EventDoubleFlagChanged : public JfrEvent<EventDoubleFlagChanged>
11773{
11774 public:
11775 EventDoubleFlagChanged(EventStartTime timing=TIMED) {}
11776
11777 void set_name(const char* new_value) {
11778 }
11779 void set_oldValue(double new_value) {
11780 }
11781 void set_newValue(double new_value) {
11782 }
11783 void set_origin(u8 new_value) {
11784 }
11785
11786 using JfrEvent<EventDoubleFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11787
11788
11789
11790 static void commit(const char* name,
11791 double oldValue,
11792 double newValue,
11793 u8 origin) {
11794 }
11795};
11796
11797class EventBooleanFlagChanged : public JfrEvent<EventBooleanFlagChanged>
11798{
11799 public:
11800 EventBooleanFlagChanged(EventStartTime timing=TIMED) {}
11801
11802 void set_name(const char* new_value) {
11803 }
11804 void set_oldValue(bool new_value) {
11805 }
11806 void set_newValue(bool new_value) {
11807 }
11808 void set_origin(u8 new_value) {
11809 }
11810
11811 using JfrEvent<EventBooleanFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11812
11813
11814
11815 static void commit(const char* name,
11816 bool oldValue,
11817 bool newValue,
11818 u8 origin) {
11819 }
11820};
11821
11822class EventStringFlagChanged : public JfrEvent<EventStringFlagChanged>
11823{
11824 public:
11825 EventStringFlagChanged(EventStartTime timing=TIMED) {}
11826
11827 void set_name(const char* new_value) {
11828 }
11829 void set_oldValue(const char* new_value) {
11830 }
11831 void set_newValue(const char* new_value) {
11832 }
11833 void set_origin(u8 new_value) {
11834 }
11835
11836 using JfrEvent<EventStringFlagChanged>::commit; // else commit() is hidden by overloaded versions in this class
11837
11838
11839
11840 static void commit(const char* name,
11841 const char* oldValue,
11842 const char* newValue,
11843 u8 origin) {
11844 }
11845};
11846
11847class EventGCHeapSummary : public JfrEvent<EventGCHeapSummary>
11848{
11849 public:
11850 EventGCHeapSummary(EventStartTime timing=TIMED) {}
11851
11852 void set_gcId(unsigned new_value) {
11853 }
11854 void set_when(u8 new_value) {
11855 }
11856 void set_heapSpace(const JfrStructVirtualSpace& value) {
11857 }
11858 void set_heapUsed(u8 new_value) {
11859 }
11860
11861 using JfrEvent<EventGCHeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
11862
11863
11864
11865 static void commit(unsigned gcId,
11866 u8 when,
11867 const JfrStructVirtualSpace& heapSpace,
11868 u8 heapUsed) {
11869 }
11870};
11871
11872class EventMetaspaceSummary : public JfrEvent<EventMetaspaceSummary>
11873{
11874 public:
11875 EventMetaspaceSummary(EventStartTime timing=TIMED) {}
11876
11877 void set_gcId(unsigned new_value) {
11878 }
11879 void set_when(u8 new_value) {
11880 }
11881 void set_gcThreshold(u8 new_value) {
11882 }
11883 void set_metaspace(const JfrStructMetaspaceSizes& value) {
11884 }
11885 void set_dataSpace(const JfrStructMetaspaceSizes& value) {
11886 }
11887 void set_classSpace(const JfrStructMetaspaceSizes& value) {
11888 }
11889
11890 using JfrEvent<EventMetaspaceSummary>::commit; // else commit() is hidden by overloaded versions in this class
11891
11892
11893
11894 static void commit(unsigned gcId,
11895 u8 when,
11896 u8 gcThreshold,
11897 const JfrStructMetaspaceSizes& metaspace,
11898 const JfrStructMetaspaceSizes& dataSpace,
11899 const JfrStructMetaspaceSizes& classSpace) {
11900 }
11901};
11902
11903class EventMetaspaceGCThreshold : public JfrEvent<EventMetaspaceGCThreshold>
11904{
11905 public:
11906 EventMetaspaceGCThreshold(EventStartTime timing=TIMED) {}
11907
11908 void set_oldValue(u8 new_value) {
11909 }
11910 void set_newValue(u8 new_value) {
11911 }
11912 void set_updater(u8 new_value) {
11913 }
11914
11915 using JfrEvent<EventMetaspaceGCThreshold>::commit; // else commit() is hidden by overloaded versions in this class
11916
11917
11918
11919 static void commit(u8 oldValue,
11920 u8 newValue,
11921 u8 updater) {
11922 }
11923};
11924
11925class EventMetaspaceAllocationFailure : public JfrEvent<EventMetaspaceAllocationFailure>
11926{
11927 public:
11928 EventMetaspaceAllocationFailure(EventStartTime timing=TIMED) {}
11929
11930 void set_classLoader(const ClassLoaderData* new_value) {
11931 }
11932 void set_unsafeAnonymousClassLoader(bool new_value) {
11933 }
11934 void set_size(u8 new_value) {
11935 }
11936 void set_metadataType(u8 new_value) {
11937 }
11938 void set_metaspaceObjectType(u8 new_value) {
11939 }
11940
11941 using JfrEvent<EventMetaspaceAllocationFailure>::commit; // else commit() is hidden by overloaded versions in this class
11942
11943
11944
11945 static void commit(const ClassLoaderData* classLoader,
11946 bool unsafeAnonymousClassLoader,
11947 u8 size,
11948 u8 metadataType,
11949 u8 metaspaceObjectType) {
11950 }
11951};
11952
11953class EventMetaspaceOOM : public JfrEvent<EventMetaspaceOOM>
11954{
11955 public:
11956 EventMetaspaceOOM(EventStartTime timing=TIMED) {}
11957
11958 void set_classLoader(const ClassLoaderData* new_value) {
11959 }
11960 void set_unsafeAnonymousClassLoader(bool new_value) {
11961 }
11962 void set_size(u8 new_value) {
11963 }
11964 void set_metadataType(u8 new_value) {
11965 }
11966 void set_metaspaceObjectType(u8 new_value) {
11967 }
11968
11969 using JfrEvent<EventMetaspaceOOM>::commit; // else commit() is hidden by overloaded versions in this class
11970
11971
11972
11973 static void commit(const ClassLoaderData* classLoader,
11974 bool unsafeAnonymousClassLoader,
11975 u8 size,
11976 u8 metadataType,
11977 u8 metaspaceObjectType) {
11978 }
11979};
11980
11981class EventMetaspaceChunkFreeListSummary : public JfrEvent<EventMetaspaceChunkFreeListSummary>
11982{
11983 public:
11984 EventMetaspaceChunkFreeListSummary(EventStartTime timing=TIMED) {}
11985
11986 void set_gcId(unsigned new_value) {
11987 }
11988 void set_when(u8 new_value) {
11989 }
11990 void set_metadataType(u8 new_value) {
11991 }
11992 void set_specializedChunks(u8 new_value) {
11993 }
11994 void set_specializedChunksTotalSize(u8 new_value) {
11995 }
11996 void set_smallChunks(u8 new_value) {
11997 }
11998 void set_smallChunksTotalSize(u8 new_value) {
11999 }
12000 void set_mediumChunks(u8 new_value) {
12001 }
12002 void set_mediumChunksTotalSize(u8 new_value) {
12003 }
12004 void set_humongousChunks(u8 new_value) {
12005 }
12006 void set_humongousChunksTotalSize(u8 new_value) {
12007 }
12008
12009 using JfrEvent<EventMetaspaceChunkFreeListSummary>::commit; // else commit() is hidden by overloaded versions in this class
12010
12011
12012
12013 static void commit(unsigned gcId,
12014 u8 when,
12015 u8 metadataType,
12016 u8 specializedChunks,
12017 u8 specializedChunksTotalSize,
12018 u8 smallChunks,
12019 u8 smallChunksTotalSize,
12020 u8 mediumChunks,
12021 u8 mediumChunksTotalSize,
12022 u8 humongousChunks,
12023 u8 humongousChunksTotalSize) {
12024 }
12025};
12026
12027class EventPSHeapSummary : public JfrEvent<EventPSHeapSummary>
12028{
12029 public:
12030 EventPSHeapSummary(EventStartTime timing=TIMED) {}
12031
12032 void set_gcId(unsigned new_value) {
12033 }
12034 void set_when(u8 new_value) {
12035 }
12036 void set_oldSpace(const JfrStructVirtualSpace& value) {
12037 }
12038 void set_oldObjectSpace(const JfrStructObjectSpace& value) {
12039 }
12040 void set_youngSpace(const JfrStructVirtualSpace& value) {
12041 }
12042 void set_edenSpace(const JfrStructObjectSpace& value) {
12043 }
12044 void set_fromSpace(const JfrStructObjectSpace& value) {
12045 }
12046 void set_toSpace(const JfrStructObjectSpace& value) {
12047 }
12048
12049 using JfrEvent<EventPSHeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
12050
12051
12052
12053 static void commit(unsigned gcId,
12054 u8 when,
12055 const JfrStructVirtualSpace& oldSpace,
12056 const JfrStructObjectSpace& oldObjectSpace,
12057 const JfrStructVirtualSpace& youngSpace,
12058 const JfrStructObjectSpace& edenSpace,
12059 const JfrStructObjectSpace& fromSpace,
12060 const JfrStructObjectSpace& toSpace) {
12061 }
12062};
12063
12064class EventG1HeapSummary : public JfrEvent<EventG1HeapSummary>
12065{
12066 public:
12067 EventG1HeapSummary(EventStartTime timing=TIMED) {}
12068
12069 void set_gcId(unsigned new_value) {
12070 }
12071 void set_when(u8 new_value) {
12072 }
12073 void set_edenUsedSize(u8 new_value) {
12074 }
12075 void set_edenTotalSize(u8 new_value) {
12076 }
12077 void set_survivorUsedSize(u8 new_value) {
12078 }
12079 void set_numberOfRegions(unsigned new_value) {
12080 }
12081
12082 using JfrEvent<EventG1HeapSummary>::commit; // else commit() is hidden by overloaded versions in this class
12083
12084
12085
12086 static void commit(unsigned gcId,
12087 u8 when,
12088 u8 edenUsedSize,
12089 u8 edenTotalSize,
12090 u8 survivorUsedSize,
12091 unsigned numberOfRegions) {
12092 }
12093};
12094
12095class EventGarbageCollection : public JfrEvent<EventGarbageCollection>
12096{
12097 public:
12098 EventGarbageCollection(EventStartTime timing=TIMED) {}
12099
12100 void set_gcId(unsigned new_value) {
12101 }
12102 void set_name(u8 new_value) {
12103 }
12104 void set_cause(u8 new_value) {
12105 }
12106 void set_sumOfPauses(const Tickspan& new_value) {
12107 }
12108 void set_longestPause(const Tickspan& new_value) {
12109 }
12110
12111 using JfrEvent<EventGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
12112
12113 EventGarbageCollection(
12114 unsigned gcId,
12115 u8 name,
12116 u8 cause,
12117 const Tickspan& sumOfPauses,
12118 const Tickspan& longestPause) {
12119 }
12120
12121 void commit(unsigned gcId,
12122 u8 name,
12123 u8 cause,
12124 const Tickspan& sumOfPauses,
12125 const Tickspan& longestPause) {
12126 }
12127
12128 static void commit(const Ticks& startTicks,
12129 const Ticks& endTicks,
12130 unsigned gcId,
12131 u8 name,
12132 u8 cause,
12133 const Tickspan& sumOfPauses,
12134 const Tickspan& longestPause) {
12135 }
12136};
12137
12138class EventParallelOldGarbageCollection : public JfrEvent<EventParallelOldGarbageCollection>
12139{
12140 public:
12141 EventParallelOldGarbageCollection(EventStartTime timing=TIMED) {}
12142
12143 void set_gcId(unsigned new_value) {
12144 }
12145 void set_densePrefix(u8 new_value) {
12146 }
12147
12148 using JfrEvent<EventParallelOldGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
12149
12150 EventParallelOldGarbageCollection(
12151 unsigned gcId,
12152 u8 densePrefix) {
12153 }
12154
12155 void commit(unsigned gcId,
12156 u8 densePrefix) {
12157 }
12158
12159 static void commit(const Ticks& startTicks,
12160 const Ticks& endTicks,
12161 unsigned gcId,
12162 u8 densePrefix) {
12163 }
12164};
12165
12166class EventYoungGarbageCollection : public JfrEvent<EventYoungGarbageCollection>
12167{
12168 public:
12169 EventYoungGarbageCollection(EventStartTime timing=TIMED) {}
12170
12171 void set_gcId(unsigned new_value) {
12172 }
12173 void set_tenuringThreshold(unsigned new_value) {
12174 }
12175
12176 using JfrEvent<EventYoungGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
12177
12178 EventYoungGarbageCollection(
12179 unsigned gcId,
12180 unsigned tenuringThreshold) {
12181 }
12182
12183 void commit(unsigned gcId,
12184 unsigned tenuringThreshold) {
12185 }
12186
12187 static void commit(const Ticks& startTicks,
12188 const Ticks& endTicks,
12189 unsigned gcId,
12190 unsigned tenuringThreshold) {
12191 }
12192};
12193
12194class EventOldGarbageCollection : public JfrEvent<EventOldGarbageCollection>
12195{
12196 public:
12197 EventOldGarbageCollection(EventStartTime timing=TIMED) {}
12198
12199 void set_gcId(unsigned new_value) {
12200 }
12201
12202 using JfrEvent<EventOldGarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
12203
12204 EventOldGarbageCollection(
12205 unsigned gcId) {
12206 }
12207
12208 void commit(unsigned gcId) {
12209 }
12210
12211 static void commit(const Ticks& startTicks,
12212 const Ticks& endTicks,
12213 unsigned gcId) {
12214 }
12215};
12216
12217class EventG1GarbageCollection : public JfrEvent<EventG1GarbageCollection>
12218{
12219 public:
12220 EventG1GarbageCollection(EventStartTime timing=TIMED) {}
12221
12222 void set_gcId(unsigned new_value) {
12223 }
12224 void set_type(u8 new_value) {
12225 }
12226
12227 using JfrEvent<EventG1GarbageCollection>::commit; // else commit() is hidden by overloaded versions in this class
12228
12229 EventG1GarbageCollection(
12230 unsigned gcId,
12231 u8 type) {
12232 }
12233
12234 void commit(unsigned gcId,
12235 u8 type) {
12236 }
12237
12238 static void commit(const Ticks& startTicks,
12239 const Ticks& endTicks,
12240 unsigned gcId,
12241 u8 type) {
12242 }
12243};
12244
12245class EventG1MMU : public JfrEvent<EventG1MMU>
12246{
12247 public:
12248 EventG1MMU(EventStartTime timing=TIMED) {}
12249
12250 void set_gcId(unsigned new_value) {
12251 }
12252 void set_timeSlice(s8 new_value) {
12253 }
12254 void set_gcTime(s8 new_value) {
12255 }
12256 void set_pauseTarget(s8 new_value) {
12257 }
12258
12259 using JfrEvent<EventG1MMU>::commit; // else commit() is hidden by overloaded versions in this class
12260
12261
12262
12263 static void commit(unsigned gcId,
12264 s8 timeSlice,
12265 s8 gcTime,
12266 s8 pauseTarget) {
12267 }
12268};
12269
12270class EventEvacuationInformation : public JfrEvent<EventEvacuationInformation>
12271{
12272 public:
12273 EventEvacuationInformation(EventStartTime timing=TIMED) {}
12274
12275 void set_gcId(unsigned new_value) {
12276 }
12277 void set_cSetRegions(unsigned new_value) {
12278 }
12279 void set_cSetUsedBefore(u8 new_value) {
12280 }
12281 void set_cSetUsedAfter(u8 new_value) {
12282 }
12283 void set_allocationRegions(unsigned new_value) {
12284 }
12285 void set_allocationRegionsUsedBefore(u8 new_value) {
12286 }
12287 void set_allocationRegionsUsedAfter(u8 new_value) {
12288 }
12289 void set_bytesCopied(u8 new_value) {
12290 }
12291 void set_regionsFreed(unsigned new_value) {
12292 }
12293
12294 using JfrEvent<EventEvacuationInformation>::commit; // else commit() is hidden by overloaded versions in this class
12295
12296
12297
12298 static void commit(unsigned gcId,
12299 unsigned cSetRegions,
12300 u8 cSetUsedBefore,
12301 u8 cSetUsedAfter,
12302 unsigned allocationRegions,
12303 u8 allocationRegionsUsedBefore,
12304 u8 allocationRegionsUsedAfter,
12305 u8 bytesCopied,
12306 unsigned regionsFreed) {
12307 }
12308};
12309
12310class EventGCReferenceStatistics : public JfrEvent<EventGCReferenceStatistics>
12311{
12312 public:
12313 EventGCReferenceStatistics(EventStartTime timing=TIMED) {}
12314
12315 void set_gcId(unsigned new_value) {
12316 }
12317 void set_type(u8 new_value) {
12318 }
12319 void set_count(u8 new_value) {
12320 }
12321
12322 using JfrEvent<EventGCReferenceStatistics>::commit; // else commit() is hidden by overloaded versions in this class
12323
12324
12325
12326 static void commit(unsigned gcId,
12327 u8 type,
12328 u8 count) {
12329 }
12330};
12331
12332class EventObjectCountAfterGC : public JfrEvent<EventObjectCountAfterGC>
12333{
12334 public:
12335 EventObjectCountAfterGC(EventStartTime timing=TIMED) {}
12336
12337 void set_gcId(unsigned new_value) {
12338 }
12339 void set_objectClass(const Klass* new_value) {
12340 }
12341 void set_count(s8 new_value) {
12342 }
12343 void set_totalSize(u8 new_value) {
12344 }
12345
12346 using JfrEvent<EventObjectCountAfterGC>::commit; // else commit() is hidden by overloaded versions in this class
12347
12348
12349
12350 static void commit(unsigned gcId,
12351 const Klass* objectClass,
12352 s8 count,
12353 u8 totalSize) {
12354 }
12355};
12356
12357class EventG1EvacuationYoungStatistics : public JfrEvent<EventG1EvacuationYoungStatistics>
12358{
12359 public:
12360 EventG1EvacuationYoungStatistics(EventStartTime timing=TIMED) {}
12361
12362 void set_statistics(const JfrStructG1EvacuationStatistics& value) {
12363 }
12364
12365 using JfrEvent<EventG1EvacuationYoungStatistics>::commit; // else commit() is hidden by overloaded versions in this class
12366
12367
12368
12369 static void commit(const JfrStructG1EvacuationStatistics& statistics) {
12370 }
12371};
12372
12373class EventG1EvacuationOldStatistics : public JfrEvent<EventG1EvacuationOldStatistics>
12374{
12375 public:
12376 EventG1EvacuationOldStatistics(EventStartTime timing=TIMED) {}
12377
12378 void set_statistics(const JfrStructG1EvacuationStatistics& value) {
12379 }
12380
12381 using JfrEvent<EventG1EvacuationOldStatistics>::commit; // else commit() is hidden by overloaded versions in this class
12382
12383
12384
12385 static void commit(const JfrStructG1EvacuationStatistics& statistics) {
12386 }
12387};
12388
12389class EventG1BasicIHOP : public JfrEvent<EventG1BasicIHOP>
12390{
12391 public:
12392 EventG1BasicIHOP(EventStartTime timing=TIMED) {}
12393
12394 void set_gcId(unsigned new_value) {
12395 }
12396 void set_threshold(u8 new_value) {
12397 }
12398 void set_thresholdPercentage(float new_value) {
12399 }
12400 void set_targetOccupancy(u8 new_value) {
12401 }
12402 void set_currentOccupancy(u8 new_value) {
12403 }
12404 void set_recentMutatorAllocationSize(u8 new_value) {
12405 }
12406 void set_recentMutatorDuration(s8 new_value) {
12407 }
12408 void set_recentAllocationRate(double new_value) {
12409 }
12410 void set_lastMarkingDuration(s8 new_value) {
12411 }
12412
12413 using JfrEvent<EventG1BasicIHOP>::commit; // else commit() is hidden by overloaded versions in this class
12414
12415
12416
12417 static void commit(unsigned gcId,
12418 u8 threshold,
12419 float thresholdPercentage,
12420 u8 targetOccupancy,
12421 u8 currentOccupancy,
12422 u8 recentMutatorAllocationSize,
12423 s8 recentMutatorDuration,
12424 double recentAllocationRate,
12425 s8 lastMarkingDuration) {
12426 }
12427};
12428
12429class EventG1AdaptiveIHOP : public JfrEvent<EventG1AdaptiveIHOP>
12430{
12431 public:
12432 EventG1AdaptiveIHOP(EventStartTime timing=TIMED) {}
12433
12434 void set_gcId(unsigned new_value) {
12435 }
12436 void set_threshold(u8 new_value) {
12437 }
12438 void set_thresholdPercentage(float new_value) {
12439 }
12440 void set_ihopTargetOccupancy(u8 new_value) {
12441 }
12442 void set_currentOccupancy(u8 new_value) {
12443 }
12444 void set_additionalBufferSize(u8 new_value) {
12445 }
12446 void set_predictedAllocationRate(double new_value) {
12447 }
12448 void set_predictedMarkingDuration(s8 new_value) {
12449 }
12450 void set_predictionActive(bool new_value) {
12451 }
12452
12453 using JfrEvent<EventG1AdaptiveIHOP>::commit; // else commit() is hidden by overloaded versions in this class
12454
12455
12456
12457 static void commit(unsigned gcId,
12458 u8 threshold,
12459 float thresholdPercentage,
12460 u8 ihopTargetOccupancy,
12461 u8 currentOccupancy,
12462 u8 additionalBufferSize,
12463 double predictedAllocationRate,
12464 s8 predictedMarkingDuration,
12465 bool predictionActive) {
12466 }
12467};
12468
12469class EventPromoteObjectInNewPLAB : public JfrEvent<EventPromoteObjectInNewPLAB>
12470{
12471 public:
12472 EventPromoteObjectInNewPLAB(EventStartTime timing=TIMED) {}
12473
12474 void set_gcId(unsigned new_value) {
12475 }
12476 void set_objectClass(const Klass* new_value) {
12477 }
12478 void set_objectSize(u8 new_value) {
12479 }
12480 void set_tenuringAge(unsigned new_value) {
12481 }
12482 void set_tenured(bool new_value) {
12483 }
12484 void set_plabSize(u8 new_value) {
12485 }
12486
12487 using JfrEvent<EventPromoteObjectInNewPLAB>::commit; // else commit() is hidden by overloaded versions in this class
12488
12489
12490
12491 static void commit(unsigned gcId,
12492 const Klass* objectClass,
12493 u8 objectSize,
12494 unsigned tenuringAge,
12495 bool tenured,
12496 u8 plabSize) {
12497 }
12498};
12499
12500class EventPromoteObjectOutsidePLAB : public JfrEvent<EventPromoteObjectOutsidePLAB>
12501{
12502 public:
12503 EventPromoteObjectOutsidePLAB(EventStartTime timing=TIMED) {}
12504
12505 void set_gcId(unsigned new_value) {
12506 }
12507 void set_objectClass(const Klass* new_value) {
12508 }
12509 void set_objectSize(u8 new_value) {
12510 }
12511 void set_tenuringAge(unsigned new_value) {
12512 }
12513 void set_tenured(bool new_value) {
12514 }
12515
12516 using JfrEvent<EventPromoteObjectOutsidePLAB>::commit; // else commit() is hidden by overloaded versions in this class
12517
12518
12519
12520 static void commit(unsigned gcId,
12521 const Klass* objectClass,
12522 u8 objectSize,
12523 unsigned tenuringAge,
12524 bool tenured) {
12525 }
12526};
12527
12528class EventPromotionFailed : public JfrEvent<EventPromotionFailed>
12529{
12530 public:
12531 EventPromotionFailed(EventStartTime timing=TIMED) {}
12532
12533 void set_gcId(unsigned new_value) {
12534 }
12535 void set_promotionFailed(const JfrStructCopyFailed& value) {
12536 }
12537 void set_thread(u8 new_value) {
12538 }
12539
12540 using JfrEvent<EventPromotionFailed>::commit; // else commit() is hidden by overloaded versions in this class
12541
12542
12543
12544 static void commit(unsigned gcId,
12545 const JfrStructCopyFailed& promotionFailed,
12546 u8 thread) {
12547 }
12548};
12549
12550class EventEvacuationFailed : public JfrEvent<EventEvacuationFailed>
12551{
12552 public:
12553 EventEvacuationFailed(EventStartTime timing=TIMED) {}
12554
12555 void set_gcId(unsigned new_value) {
12556 }
12557 void set_evacuationFailed(const JfrStructCopyFailed& value) {
12558 }
12559
12560 using JfrEvent<EventEvacuationFailed>::commit; // else commit() is hidden by overloaded versions in this class
12561
12562
12563
12564 static void commit(unsigned gcId,
12565 const JfrStructCopyFailed& evacuationFailed) {
12566 }
12567};
12568
12569class EventConcurrentModeFailure : public JfrEvent<EventConcurrentModeFailure>
12570{
12571 public:
12572 EventConcurrentModeFailure(EventStartTime timing=TIMED) {}
12573
12574 void set_gcId(unsigned new_value) {
12575 }
12576
12577 using JfrEvent<EventConcurrentModeFailure>::commit; // else commit() is hidden by overloaded versions in this class
12578
12579
12580
12581 static void commit(unsigned gcId) {
12582 }
12583};
12584
12585class EventGCPhasePause : public JfrEvent<EventGCPhasePause>
12586{
12587 public:
12588 EventGCPhasePause(EventStartTime timing=TIMED) {}
12589
12590 void set_gcId(unsigned new_value) {
12591 }
12592 void set_name(const char* new_value) {
12593 }
12594
12595 using JfrEvent<EventGCPhasePause>::commit; // else commit() is hidden by overloaded versions in this class
12596
12597 EventGCPhasePause(
12598 unsigned gcId,
12599 const char* name) {
12600 }
12601
12602 void commit(unsigned gcId,
12603 const char* name) {
12604 }
12605
12606 static void commit(const Ticks& startTicks,
12607 const Ticks& endTicks,
12608 unsigned gcId,
12609 const char* name) {
12610 }
12611};
12612
12613class EventGCPhasePauseLevel1 : public JfrEvent<EventGCPhasePauseLevel1>
12614{
12615 public:
12616 EventGCPhasePauseLevel1(EventStartTime timing=TIMED) {}
12617
12618 void set_gcId(unsigned new_value) {
12619 }
12620 void set_name(const char* new_value) {
12621 }
12622
12623 using JfrEvent<EventGCPhasePauseLevel1>::commit; // else commit() is hidden by overloaded versions in this class
12624
12625 EventGCPhasePauseLevel1(
12626 unsigned gcId,
12627 const char* name) {
12628 }
12629
12630 void commit(unsigned gcId,
12631 const char* name) {
12632 }
12633
12634 static void commit(const Ticks& startTicks,
12635 const Ticks& endTicks,
12636 unsigned gcId,
12637 const char* name) {
12638 }
12639};
12640
12641class EventGCPhasePauseLevel2 : public JfrEvent<EventGCPhasePauseLevel2>
12642{
12643 public:
12644 EventGCPhasePauseLevel2(EventStartTime timing=TIMED) {}
12645
12646 void set_gcId(unsigned new_value) {
12647 }
12648 void set_name(const char* new_value) {
12649 }
12650
12651 using JfrEvent<EventGCPhasePauseLevel2>::commit; // else commit() is hidden by overloaded versions in this class
12652
12653 EventGCPhasePauseLevel2(
12654 unsigned gcId,
12655 const char* name) {
12656 }
12657
12658 void commit(unsigned gcId,
12659 const char* name) {
12660 }
12661
12662 static void commit(const Ticks& startTicks,
12663 const Ticks& endTicks,
12664 unsigned gcId,
12665 const char* name) {
12666 }
12667};
12668
12669class EventGCPhasePauseLevel3 : public JfrEvent<EventGCPhasePauseLevel3>
12670{
12671 public:
12672 EventGCPhasePauseLevel3(EventStartTime timing=TIMED) {}
12673
12674 void set_gcId(unsigned new_value) {
12675 }
12676 void set_name(const char* new_value) {
12677 }
12678
12679 using JfrEvent<EventGCPhasePauseLevel3>::commit; // else commit() is hidden by overloaded versions in this class
12680
12681 EventGCPhasePauseLevel3(
12682 unsigned gcId,
12683 const char* name) {
12684 }
12685
12686 void commit(unsigned gcId,
12687 const char* name) {
12688 }
12689
12690 static void commit(const Ticks& startTicks,
12691 const Ticks& endTicks,
12692 unsigned gcId,
12693 const char* name) {
12694 }
12695};
12696
12697class EventGCPhasePauseLevel4 : public JfrEvent<EventGCPhasePauseLevel4>
12698{
12699 public:
12700 EventGCPhasePauseLevel4(EventStartTime timing=TIMED) {}
12701
12702 void set_gcId(unsigned new_value) {
12703 }
12704 void set_name(const char* new_value) {
12705 }
12706
12707 using JfrEvent<EventGCPhasePauseLevel4>::commit; // else commit() is hidden by overloaded versions in this class
12708
12709 EventGCPhasePauseLevel4(
12710 unsigned gcId,
12711 const char* name) {
12712 }
12713
12714 void commit(unsigned gcId,
12715 const char* name) {
12716 }
12717
12718 static void commit(const Ticks& startTicks,
12719 const Ticks& endTicks,
12720 unsigned gcId,
12721 const char* name) {
12722 }
12723};
12724
12725class EventGCPhaseConcurrent : public JfrEvent<EventGCPhaseConcurrent>
12726{
12727 public:
12728 EventGCPhaseConcurrent(EventStartTime timing=TIMED) {}
12729
12730 void set_gcId(unsigned new_value) {
12731 }
12732 void set_name(const char* new_value) {
12733 }
12734
12735 using JfrEvent<EventGCPhaseConcurrent>::commit; // else commit() is hidden by overloaded versions in this class
12736
12737 EventGCPhaseConcurrent(
12738 unsigned gcId,
12739 const char* name) {
12740 }
12741
12742 void commit(unsigned gcId,
12743 const char* name) {
12744 }
12745
12746 static void commit(const Ticks& startTicks,
12747 const Ticks& endTicks,
12748 unsigned gcId,
12749 const char* name) {
12750 }
12751};
12752
12753class EventGCPhaseParallel : public JfrEvent<EventGCPhaseParallel>
12754{
12755 public:
12756 EventGCPhaseParallel(EventStartTime timing=TIMED) {}
12757
12758 void set_gcId(unsigned new_value) {
12759 }
12760 void set_gcWorkerId(unsigned new_value) {
12761 }
12762 void set_name(const char* new_value) {
12763 }
12764
12765 using JfrEvent<EventGCPhaseParallel>::commit; // else commit() is hidden by overloaded versions in this class
12766
12767 EventGCPhaseParallel(
12768 unsigned gcId,
12769 unsigned gcWorkerId,
12770 const char* name) {
12771 }
12772
12773 void commit(unsigned gcId,
12774 unsigned gcWorkerId,
12775 const char* name) {
12776 }
12777
12778 static void commit(const Ticks& startTicks,
12779 const Ticks& endTicks,
12780 unsigned gcId,
12781 unsigned gcWorkerId,
12782 const char* name) {
12783 }
12784};
12785
12786class EventAllocationRequiringGC : public JfrEvent<EventAllocationRequiringGC>
12787{
12788 public:
12789 EventAllocationRequiringGC(EventStartTime timing=TIMED) {}
12790
12791 void set_gcId(unsigned new_value) {
12792 }
12793 void set_size(u8 new_value) {
12794 }
12795
12796 using JfrEvent<EventAllocationRequiringGC>::commit; // else commit() is hidden by overloaded versions in this class
12797
12798
12799
12800 static void commit(unsigned gcId,
12801 u8 size) {
12802 }
12803};
12804
12805class EventTenuringDistribution : public JfrEvent<EventTenuringDistribution>
12806{
12807 public:
12808 EventTenuringDistribution(EventStartTime timing=TIMED) {}
12809
12810 void set_gcId(unsigned new_value) {
12811 }
12812 void set_age(unsigned new_value) {
12813 }
12814 void set_size(u8 new_value) {
12815 }
12816
12817 using JfrEvent<EventTenuringDistribution>::commit; // else commit() is hidden by overloaded versions in this class
12818
12819
12820
12821 static void commit(unsigned gcId,
12822 unsigned age,
12823 u8 size) {
12824 }
12825};
12826
12827class EventG1HeapRegionTypeChange : public JfrEvent<EventG1HeapRegionTypeChange>
12828{
12829 public:
12830 EventG1HeapRegionTypeChange(EventStartTime timing=TIMED) {}
12831
12832 void set_index(unsigned new_value) {
12833 }
12834 void set_from(u8 new_value) {
12835 }
12836 void set_to(u8 new_value) {
12837 }
12838 void set_start(u8 new_value) {
12839 }
12840 void set_used(u8 new_value) {
12841 }
12842
12843 using JfrEvent<EventG1HeapRegionTypeChange>::commit; // else commit() is hidden by overloaded versions in this class
12844
12845
12846
12847 static void commit(unsigned index,
12848 u8 from,
12849 u8 to,
12850 u8 start,
12851 u8 used) {
12852 }
12853};
12854
12855class EventCompilation : public JfrEvent<EventCompilation>
12856{
12857 public:
12858 EventCompilation(EventStartTime timing=TIMED) {}
12859
12860 void set_method(const Method* new_value) {
12861 }
12862 void set_compileId(unsigned new_value) {
12863 }
12864 void set_compileLevel(u2 new_value) {
12865 }
12866 void set_succeded(bool new_value) {
12867 }
12868 void set_isOsr(bool new_value) {
12869 }
12870 void set_codeSize(u8 new_value) {
12871 }
12872 void set_inlinedBytes(u8 new_value) {
12873 }
12874
12875 using JfrEvent<EventCompilation>::commit; // else commit() is hidden by overloaded versions in this class
12876
12877 EventCompilation(
12878 const Method* method,
12879 unsigned compileId,
12880 u2 compileLevel,
12881 bool succeded,
12882 bool isOsr,
12883 u8 codeSize,
12884 u8 inlinedBytes) {
12885 }
12886
12887 void commit(const Method* method,
12888 unsigned compileId,
12889 u2 compileLevel,
12890 bool succeded,
12891 bool isOsr,
12892 u8 codeSize,
12893 u8 inlinedBytes) {
12894 }
12895
12896 static void commit(const Ticks& startTicks,
12897 const Ticks& endTicks,
12898 const Method* method,
12899 unsigned compileId,
12900 u2 compileLevel,
12901 bool succeded,
12902 bool isOsr,
12903 u8 codeSize,
12904 u8 inlinedBytes) {
12905 }
12906};
12907
12908class EventCompilerPhase : public JfrEvent<EventCompilerPhase>
12909{
12910 public:
12911 EventCompilerPhase(EventStartTime timing=TIMED) {}
12912
12913 void set_phase(u8 new_value) {
12914 }
12915 void set_compileId(unsigned new_value) {
12916 }
12917 void set_phaseLevel(u2 new_value) {
12918 }
12919
12920 using JfrEvent<EventCompilerPhase>::commit; // else commit() is hidden by overloaded versions in this class
12921
12922 EventCompilerPhase(
12923 u8 phase,
12924 unsigned compileId,
12925 u2 phaseLevel) {
12926 }
12927
12928 void commit(u8 phase,
12929 unsigned compileId,
12930 u2 phaseLevel) {
12931 }
12932
12933 static void commit(const Ticks& startTicks,
12934 const Ticks& endTicks,
12935 u8 phase,
12936 unsigned compileId,
12937 u2 phaseLevel) {
12938 }
12939};
12940
12941class EventCompilationFailure : public JfrEvent<EventCompilationFailure>
12942{
12943 public:
12944 EventCompilationFailure(EventStartTime timing=TIMED) {}
12945
12946 void set_failureMessage(const char* new_value) {
12947 }
12948 void set_compileId(unsigned new_value) {
12949 }
12950
12951 using JfrEvent<EventCompilationFailure>::commit; // else commit() is hidden by overloaded versions in this class
12952
12953
12954
12955 static void commit(const char* failureMessage,
12956 unsigned compileId) {
12957 }
12958};
12959
12960class EventCompilerInlining : public JfrEvent<EventCompilerInlining>
12961{
12962 public:
12963 EventCompilerInlining(EventStartTime timing=TIMED) {}
12964
12965 void set_compileId(unsigned new_value) {
12966 }
12967 void set_caller(const Method* new_value) {
12968 }
12969 void set_callee(const JfrStructCalleeMethod& value) {
12970 }
12971 void set_succeeded(bool new_value) {
12972 }
12973 void set_message(const char* new_value) {
12974 }
12975 void set_bci(s4 new_value) {
12976 }
12977
12978 using JfrEvent<EventCompilerInlining>::commit; // else commit() is hidden by overloaded versions in this class
12979
12980
12981
12982 static void commit(unsigned compileId,
12983 const Method* caller,
12984 const JfrStructCalleeMethod& callee,
12985 bool succeeded,
12986 const char* message,
12987 s4 bci) {
12988 }
12989};
12990
12991class EventSweepCodeCache : public JfrEvent<EventSweepCodeCache>
12992{
12993 public:
12994 EventSweepCodeCache(EventStartTime timing=TIMED) {}
12995
12996 void set_sweepId(s4 new_value) {
12997 }
12998 void set_sweptCount(unsigned new_value) {
12999 }
13000 void set_flushedCount(unsigned new_value) {
13001 }
13002 void set_zombifiedCount(unsigned new_value) {
13003 }
13004
13005 using JfrEvent<EventSweepCodeCache>::commit; // else commit() is hidden by overloaded versions in this class
13006
13007 EventSweepCodeCache(
13008 s4 sweepId,
13009 unsigned sweptCount,
13010 unsigned flushedCount,
13011 unsigned zombifiedCount) {
13012 }
13013
13014 void commit(s4 sweepId,
13015 unsigned sweptCount,
13016 unsigned flushedCount,
13017 unsigned zombifiedCount) {
13018 }
13019
13020 static void commit(const Ticks& startTicks,
13021 const Ticks& endTicks,
13022 s4 sweepId,
13023 unsigned sweptCount,
13024 unsigned flushedCount,
13025 unsigned zombifiedCount) {
13026 }
13027};
13028
13029class EventCodeCacheFull : public JfrEvent<EventCodeCacheFull>
13030{
13031 public:
13032 EventCodeCacheFull(EventStartTime timing=TIMED) {}
13033
13034 void set_codeBlobType(u8 new_value) {
13035 }
13036 void set_startAddress(u8 new_value) {
13037 }
13038 void set_commitedTopAddress(u8 new_value) {
13039 }
13040 void set_reservedTopAddress(u8 new_value) {
13041 }
13042 void set_entryCount(s4 new_value) {
13043 }
13044 void set_methodCount(s4 new_value) {
13045 }
13046 void set_adaptorCount(s4 new_value) {
13047 }
13048 void set_unallocatedCapacity(u8 new_value) {
13049 }
13050 void set_fullCount(s4 new_value) {
13051 }
13052
13053 using JfrEvent<EventCodeCacheFull>::commit; // else commit() is hidden by overloaded versions in this class
13054
13055
13056
13057 static void commit(u8 codeBlobType,
13058 u8 startAddress,
13059 u8 commitedTopAddress,
13060 u8 reservedTopAddress,
13061 s4 entryCount,
13062 s4 methodCount,
13063 s4 adaptorCount,
13064 u8 unallocatedCapacity,
13065 s4 fullCount) {
13066 }
13067};
13068
13069class EventSafepointBegin : public JfrEvent<EventSafepointBegin>
13070{
13071 public:
13072 EventSafepointBegin(EventStartTime timing=TIMED) {}
13073
13074 void set_safepointId(u8 new_value) {
13075 }
13076 void set_totalThreadCount(s4 new_value) {
13077 }
13078 void set_jniCriticalThreadCount(s4 new_value) {
13079 }
13080
13081 using JfrEvent<EventSafepointBegin>::commit; // else commit() is hidden by overloaded versions in this class
13082
13083 EventSafepointBegin(
13084 u8 safepointId,
13085 s4 totalThreadCount,
13086 s4 jniCriticalThreadCount) {
13087 }
13088
13089 void commit(u8 safepointId,
13090 s4 totalThreadCount,
13091 s4 jniCriticalThreadCount) {
13092 }
13093
13094 static void commit(const Ticks& startTicks,
13095 const Ticks& endTicks,
13096 u8 safepointId,
13097 s4 totalThreadCount,
13098 s4 jniCriticalThreadCount) {
13099 }
13100};
13101
13102class EventSafepointStateSynchronization : public JfrEvent<EventSafepointStateSynchronization>
13103{
13104 public:
13105 EventSafepointStateSynchronization(EventStartTime timing=TIMED) {}
13106
13107 void set_safepointId(u8 new_value) {
13108 }
13109 void set_initialThreadCount(s4 new_value) {
13110 }
13111 void set_runningThreadCount(s4 new_value) {
13112 }
13113 void set_iterations(s4 new_value) {
13114 }
13115
13116 using JfrEvent<EventSafepointStateSynchronization>::commit; // else commit() is hidden by overloaded versions in this class
13117
13118 EventSafepointStateSynchronization(
13119 u8 safepointId,
13120 s4 initialThreadCount,
13121 s4 runningThreadCount,
13122 s4 iterations) {
13123 }
13124
13125 void commit(u8 safepointId,
13126 s4 initialThreadCount,
13127 s4 runningThreadCount,
13128 s4 iterations) {
13129 }
13130
13131 static void commit(const Ticks& startTicks,
13132 const Ticks& endTicks,
13133 u8 safepointId,
13134 s4 initialThreadCount,
13135 s4 runningThreadCount,
13136 s4 iterations) {
13137 }
13138};
13139
13140class EventSafepointCleanup : public JfrEvent<EventSafepointCleanup>
13141{
13142 public:
13143 EventSafepointCleanup(EventStartTime timing=TIMED) {}
13144
13145 void set_safepointId(u8 new_value) {
13146 }
13147
13148 using JfrEvent<EventSafepointCleanup>::commit; // else commit() is hidden by overloaded versions in this class
13149
13150 EventSafepointCleanup(
13151 u8 safepointId) {
13152 }
13153
13154 void commit(u8 safepointId) {
13155 }
13156
13157 static void commit(const Ticks& startTicks,
13158 const Ticks& endTicks,
13159 u8 safepointId) {
13160 }
13161};
13162
13163class EventSafepointCleanupTask : public JfrEvent<EventSafepointCleanupTask>
13164{
13165 public:
13166 EventSafepointCleanupTask(EventStartTime timing=TIMED) {}
13167
13168 void set_safepointId(u8 new_value) {
13169 }
13170 void set_name(const char* new_value) {
13171 }
13172
13173 using JfrEvent<EventSafepointCleanupTask>::commit; // else commit() is hidden by overloaded versions in this class
13174
13175 EventSafepointCleanupTask(
13176 u8 safepointId,
13177 const char* name) {
13178 }
13179
13180 void commit(u8 safepointId,
13181 const char* name) {
13182 }
13183
13184 static void commit(const Ticks& startTicks,
13185 const Ticks& endTicks,
13186 u8 safepointId,
13187 const char* name) {
13188 }
13189};
13190
13191class EventSafepointEnd : public JfrEvent<EventSafepointEnd>
13192{
13193 public:
13194 EventSafepointEnd(EventStartTime timing=TIMED) {}
13195
13196 void set_safepointId(u8 new_value) {
13197 }
13198
13199 using JfrEvent<EventSafepointEnd>::commit; // else commit() is hidden by overloaded versions in this class
13200
13201 EventSafepointEnd(
13202 u8 safepointId) {
13203 }
13204
13205 void commit(u8 safepointId) {
13206 }
13207
13208 static void commit(const Ticks& startTicks,
13209 const Ticks& endTicks,
13210 u8 safepointId) {
13211 }
13212};
13213
13214class EventExecuteVMOperation : public JfrEvent<EventExecuteVMOperation>
13215{
13216 public:
13217 EventExecuteVMOperation(EventStartTime timing=TIMED) {}
13218
13219 void set_operation(u8 new_value) {
13220 }
13221 void set_safepoint(bool new_value) {
13222 }
13223 void set_blocking(bool new_value) {
13224 }
13225 void set_caller(u8 new_value) {
13226 }
13227 void set_safepointId(u8 new_value) {
13228 }
13229
13230 using JfrEvent<EventExecuteVMOperation>::commit; // else commit() is hidden by overloaded versions in this class
13231
13232 EventExecuteVMOperation(
13233 u8 operation,
13234 bool safepoint,
13235 bool blocking,
13236 u8 caller,
13237 u8 safepointId) {
13238 }
13239
13240 void commit(u8 operation,
13241 bool safepoint,
13242 bool blocking,
13243 u8 caller,
13244 u8 safepointId) {
13245 }
13246
13247 static void commit(const Ticks& startTicks,
13248 const Ticks& endTicks,
13249 u8 operation,
13250 bool safepoint,
13251 bool blocking,
13252 u8 caller,
13253 u8 safepointId) {
13254 }
13255};
13256
13257class EventShutdown : public JfrEvent<EventShutdown>
13258{
13259 public:
13260 EventShutdown(EventStartTime timing=TIMED) {}
13261
13262 void set_reason(const char* new_value) {
13263 }
13264
13265 using JfrEvent<EventShutdown>::commit; // else commit() is hidden by overloaded versions in this class
13266
13267
13268
13269 static void commit(const char* reason) {
13270 }
13271};
13272
13273class EventObjectAllocationInNewTLAB : public JfrEvent<EventObjectAllocationInNewTLAB>
13274{
13275 public:
13276 EventObjectAllocationInNewTLAB(EventStartTime timing=TIMED) {}
13277
13278 void set_objectClass(const Klass* new_value) {
13279 }
13280 void set_allocationSize(u8 new_value) {
13281 }
13282 void set_tlabSize(u8 new_value) {
13283 }
13284
13285 using JfrEvent<EventObjectAllocationInNewTLAB>::commit; // else commit() is hidden by overloaded versions in this class
13286
13287
13288
13289 static void commit(const Klass* objectClass,
13290 u8 allocationSize,
13291 u8 tlabSize) {
13292 }
13293};
13294
13295class EventObjectAllocationOutsideTLAB : public JfrEvent<EventObjectAllocationOutsideTLAB>
13296{
13297 public:
13298 EventObjectAllocationOutsideTLAB(EventStartTime timing=TIMED) {}
13299
13300 void set_objectClass(const Klass* new_value) {
13301 }
13302 void set_allocationSize(u8 new_value) {
13303 }
13304
13305 using JfrEvent<EventObjectAllocationOutsideTLAB>::commit; // else commit() is hidden by overloaded versions in this class
13306
13307
13308
13309 static void commit(const Klass* objectClass,
13310 u8 allocationSize) {
13311 }
13312};
13313
13314class EventOldObjectSample : public JfrEvent<EventOldObjectSample>
13315{
13316 public:
13317 EventOldObjectSample(EventStartTime timing=TIMED) {}
13318
13319 void set_allocationTime(const Ticks& new_value) {
13320 }
13321 void set_lastKnownHeapUsage(u8 new_value) {
13322 }
13323 void set_object(u8 new_value) {
13324 }
13325 void set_arrayElements(s4 new_value) {
13326 }
13327 void set_root(u8 new_value) {
13328 }
13329
13330 using JfrEvent<EventOldObjectSample>::commit; // else commit() is hidden by overloaded versions in this class
13331
13332
13333
13334 static void commit(const Ticks& allocationTime,
13335 u8 lastKnownHeapUsage,
13336 u8 object,
13337 s4 arrayElements,
13338 u8 root) {
13339 }
13340};
13341
13342class EventDumpReason : public JfrEvent<EventDumpReason>
13343{
13344 public:
13345 EventDumpReason(EventStartTime timing=TIMED) {}
13346
13347 void set_reason(const char* new_value) {
13348 }
13349 void set_recordingId(s4 new_value) {
13350 }
13351
13352 using JfrEvent<EventDumpReason>::commit; // else commit() is hidden by overloaded versions in this class
13353
13354
13355
13356 static void commit(const char* reason,
13357 s4 recordingId) {
13358 }
13359};
13360
13361class EventDataLoss : public JfrEvent<EventDataLoss>
13362{
13363 public:
13364 EventDataLoss(EventStartTime timing=TIMED) {}
13365
13366 void set_amount(u8 new_value) {
13367 }
13368 void set_total(u8 new_value) {
13369 }
13370
13371 using JfrEvent<EventDataLoss>::commit; // else commit() is hidden by overloaded versions in this class
13372
13373
13374
13375 static void commit(u8 amount,
13376 u8 total) {
13377 }
13378};
13379
13380class EventJVMInformation : public JfrEvent<EventJVMInformation>
13381{
13382 public:
13383 EventJVMInformation(EventStartTime timing=TIMED) {}
13384
13385 void set_jvmName(const char* new_value) {
13386 }
13387 void set_jvmVersion(const char* new_value) {
13388 }
13389 void set_jvmArguments(const char* new_value) {
13390 }
13391 void set_jvmFlags(const char* new_value) {
13392 }
13393 void set_javaArguments(const char* new_value) {
13394 }
13395 void set_jvmStartTime(s8 new_value) {
13396 }
13397 void set_pid(s8 new_value) {
13398 }
13399
13400 using JfrEvent<EventJVMInformation>::commit; // else commit() is hidden by overloaded versions in this class
13401
13402 EventJVMInformation(
13403 const char* jvmName,
13404 const char* jvmVersion,
13405 const char* jvmArguments,
13406 const char* jvmFlags,
13407 const char* javaArguments,
13408 s8 jvmStartTime,
13409 s8 pid) {
13410 }
13411
13412 void commit(const char* jvmName,
13413 const char* jvmVersion,
13414 const char* jvmArguments,
13415 const char* jvmFlags,
13416 const char* javaArguments,
13417 s8 jvmStartTime,
13418 s8 pid) {
13419 }
13420
13421 static void commit(const Ticks& startTicks,
13422 const Ticks& endTicks,
13423 const char* jvmName,
13424 const char* jvmVersion,
13425 const char* jvmArguments,
13426 const char* jvmFlags,
13427 const char* javaArguments,
13428 s8 jvmStartTime,
13429 s8 pid) {
13430 }
13431};
13432
13433class EventOSInformation : public JfrEvent<EventOSInformation>
13434{
13435 public:
13436 EventOSInformation(EventStartTime timing=TIMED) {}
13437
13438 void set_osVersion(const char* new_value) {
13439 }
13440
13441 using JfrEvent<EventOSInformation>::commit; // else commit() is hidden by overloaded versions in this class
13442
13443 EventOSInformation(
13444 const char* osVersion) {
13445 }
13446
13447 void commit(const char* osVersion) {
13448 }
13449
13450 static void commit(const Ticks& startTicks,
13451 const Ticks& endTicks,
13452 const char* osVersion) {
13453 }
13454};
13455
13456class EventVirtualizationInformation : public JfrEvent<EventVirtualizationInformation>
13457{
13458 public:
13459 EventVirtualizationInformation(EventStartTime timing=TIMED) {}
13460
13461 void set_name(const char* new_value) {
13462 }
13463
13464 using JfrEvent<EventVirtualizationInformation>::commit; // else commit() is hidden by overloaded versions in this class
13465
13466 EventVirtualizationInformation(
13467 const char* name) {
13468 }
13469
13470 void commit(const char* name) {
13471 }
13472
13473 static void commit(const Ticks& startTicks,
13474 const Ticks& endTicks,
13475 const char* name) {
13476 }
13477};
13478
13479class EventInitialSystemProperty : public JfrEvent<EventInitialSystemProperty>
13480{
13481 public:
13482 EventInitialSystemProperty(EventStartTime timing=TIMED) {}
13483
13484 void set_key(const char* new_value) {
13485 }
13486 void set_value(const char* new_value) {
13487 }
13488
13489 using JfrEvent<EventInitialSystemProperty>::commit; // else commit() is hidden by overloaded versions in this class
13490
13491 EventInitialSystemProperty(
13492 const char* key,
13493 const char* value) {
13494 }
13495
13496 void commit(const char* key,
13497 const char* value) {
13498 }
13499
13500 static void commit(const Ticks& startTicks,
13501 const Ticks& endTicks,
13502 const char* key,
13503 const char* value) {
13504 }
13505};
13506
13507class EventInitialEnvironmentVariable : public JfrEvent<EventInitialEnvironmentVariable>
13508{
13509 public:
13510 EventInitialEnvironmentVariable(EventStartTime timing=TIMED) {}
13511
13512 void set_key(const char* new_value) {
13513 }
13514 void set_value(const char* new_value) {
13515 }
13516
13517 using JfrEvent<EventInitialEnvironmentVariable>::commit; // else commit() is hidden by overloaded versions in this class
13518
13519 EventInitialEnvironmentVariable(
13520 const char* key,
13521 const char* value) {
13522 }
13523
13524 void commit(const char* key,
13525 const char* value) {
13526 }
13527
13528 static void commit(const Ticks& startTicks,
13529 const Ticks& endTicks,
13530 const char* key,
13531 const char* value) {
13532 }
13533};
13534
13535class EventSystemProcess : public JfrEvent<EventSystemProcess>
13536{
13537 public:
13538 EventSystemProcess(EventStartTime timing=TIMED) {}
13539
13540 void set_pid(const char* new_value) {
13541 }
13542 void set_commandLine(const char* new_value) {
13543 }
13544
13545 using JfrEvent<EventSystemProcess>::commit; // else commit() is hidden by overloaded versions in this class
13546
13547 EventSystemProcess(
13548 const char* pid,
13549 const char* commandLine) {
13550 }
13551
13552 void commit(const char* pid,
13553 const char* commandLine) {
13554 }
13555
13556 static void commit(const Ticks& startTicks,
13557 const Ticks& endTicks,
13558 const char* pid,
13559 const char* commandLine) {
13560 }
13561};
13562
13563class EventCPUInformation : public JfrEvent<EventCPUInformation>
13564{
13565 public:
13566 EventCPUInformation(EventStartTime timing=TIMED) {}
13567
13568 void set_cpu(const char* new_value) {
13569 }
13570 void set_description(const char* new_value) {
13571 }
13572 void set_sockets(unsigned new_value) {
13573 }
13574 void set_cores(unsigned new_value) {
13575 }
13576 void set_hwThreads(unsigned new_value) {
13577 }
13578
13579 using JfrEvent<EventCPUInformation>::commit; // else commit() is hidden by overloaded versions in this class
13580
13581 EventCPUInformation(
13582 const char* cpu,
13583 const char* description,
13584 unsigned sockets,
13585 unsigned cores,
13586 unsigned hwThreads) {
13587 }
13588
13589 void commit(const char* cpu,
13590 const char* description,
13591 unsigned sockets,
13592 unsigned cores,
13593 unsigned hwThreads) {
13594 }
13595
13596 static void commit(const Ticks& startTicks,
13597 const Ticks& endTicks,
13598 const char* cpu,
13599 const char* description,
13600 unsigned sockets,
13601 unsigned cores,
13602 unsigned hwThreads) {
13603 }
13604};
13605
13606class EventCPUTimeStampCounter : public JfrEvent<EventCPUTimeStampCounter>
13607{
13608 public:
13609 EventCPUTimeStampCounter(EventStartTime timing=TIMED) {}
13610
13611 void set_fastTimeEnabled(bool new_value) {
13612 }
13613 void set_fastTimeAutoEnabled(bool new_value) {
13614 }
13615 void set_osFrequency(s8 new_value) {
13616 }
13617 void set_fastTimeFrequency(s8 new_value) {
13618 }
13619
13620 using JfrEvent<EventCPUTimeStampCounter>::commit; // else commit() is hidden by overloaded versions in this class
13621
13622 EventCPUTimeStampCounter(
13623 bool fastTimeEnabled,
13624 bool fastTimeAutoEnabled,
13625 s8 osFrequency,
13626 s8 fastTimeFrequency) {
13627 }
13628
13629 void commit(bool fastTimeEnabled,
13630 bool fastTimeAutoEnabled,
13631 s8 osFrequency,
13632 s8 fastTimeFrequency) {
13633 }
13634
13635 static void commit(const Ticks& startTicks,
13636 const Ticks& endTicks,
13637 bool fastTimeEnabled,
13638 bool fastTimeAutoEnabled,
13639 s8 osFrequency,
13640 s8 fastTimeFrequency) {
13641 }
13642};
13643
13644class EventCPULoad : public JfrEvent<EventCPULoad>
13645{
13646 public:
13647 EventCPULoad(EventStartTime timing=TIMED) {}
13648
13649 void set_jvmUser(float new_value) {
13650 }
13651 void set_jvmSystem(float new_value) {
13652 }
13653 void set_machineTotal(float new_value) {
13654 }
13655
13656 using JfrEvent<EventCPULoad>::commit; // else commit() is hidden by overloaded versions in this class
13657
13658 EventCPULoad(
13659 float jvmUser,
13660 float jvmSystem,
13661 float machineTotal) {
13662 }
13663
13664 void commit(float jvmUser,
13665 float jvmSystem,
13666 float machineTotal) {
13667 }
13668
13669 static void commit(const Ticks& startTicks,
13670 const Ticks& endTicks,
13671 float jvmUser,
13672 float jvmSystem,
13673 float machineTotal) {
13674 }
13675};
13676
13677class EventThreadCPULoad : public JfrEvent<EventThreadCPULoad>
13678{
13679 public:
13680 EventThreadCPULoad(EventStartTime timing=TIMED) {}
13681
13682 void set_user(float new_value) {
13683 }
13684 void set_system(float new_value) {
13685 }
13686
13687 using JfrEvent<EventThreadCPULoad>::commit; // else commit() is hidden by overloaded versions in this class
13688
13689 EventThreadCPULoad(
13690 float user,
13691 float system) {
13692 }
13693
13694 void commit(float user,
13695 float system) {
13696 }
13697
13698 static void commit(const Ticks& startTicks,
13699 const Ticks& endTicks,
13700 float user,
13701 float system) {
13702 }
13703};
13704
13705class EventThreadContextSwitchRate : public JfrEvent<EventThreadContextSwitchRate>
13706{
13707 public:
13708 EventThreadContextSwitchRate(EventStartTime timing=TIMED) {}
13709
13710 void set_switchRate(float new_value) {
13711 }
13712
13713 using JfrEvent<EventThreadContextSwitchRate>::commit; // else commit() is hidden by overloaded versions in this class
13714
13715 EventThreadContextSwitchRate(
13716 float switchRate) {
13717 }
13718
13719 void commit(float switchRate) {
13720 }
13721
13722 static void commit(const Ticks& startTicks,
13723 const Ticks& endTicks,
13724 float switchRate) {
13725 }
13726};
13727
13728class EventNetworkUtilization : public JfrEvent<EventNetworkUtilization>
13729{
13730 public:
13731 EventNetworkUtilization(EventStartTime timing=TIMED) {}
13732
13733 void set_networkInterface(u8 new_value) {
13734 }
13735 void set_readRate(s8 new_value) {
13736 }
13737 void set_writeRate(s8 new_value) {
13738 }
13739
13740 using JfrEvent<EventNetworkUtilization>::commit; // else commit() is hidden by overloaded versions in this class
13741
13742 EventNetworkUtilization(
13743 u8 networkInterface,
13744 s8 readRate,
13745 s8 writeRate) {
13746 }
13747
13748 void commit(u8 networkInterface,
13749 s8 readRate,
13750 s8 writeRate) {
13751 }
13752
13753 static void commit(const Ticks& startTicks,
13754 const Ticks& endTicks,
13755 u8 networkInterface,
13756 s8 readRate,
13757 s8 writeRate) {
13758 }
13759};
13760
13761class EventJavaThreadStatistics : public JfrEvent<EventJavaThreadStatistics>
13762{
13763 public:
13764 EventJavaThreadStatistics(EventStartTime timing=TIMED) {}
13765
13766 void set_activeCount(s8 new_value) {
13767 }
13768 void set_daemonCount(s8 new_value) {
13769 }
13770 void set_accumulatedCount(s8 new_value) {
13771 }
13772 void set_peakCount(s8 new_value) {
13773 }
13774
13775 using JfrEvent<EventJavaThreadStatistics>::commit; // else commit() is hidden by overloaded versions in this class
13776
13777 EventJavaThreadStatistics(
13778 s8 activeCount,
13779 s8 daemonCount,
13780 s8 accumulatedCount,
13781 s8 peakCount) {
13782 }
13783
13784 void commit(s8 activeCount,
13785 s8 daemonCount,
13786 s8 accumulatedCount,
13787 s8 peakCount) {
13788 }
13789
13790 static void commit(const Ticks& startTicks,
13791 const Ticks& endTicks,
13792 s8 activeCount,
13793 s8 daemonCount,
13794 s8 accumulatedCount,
13795 s8 peakCount) {
13796 }
13797};
13798
13799class EventClassLoadingStatistics : public JfrEvent<EventClassLoadingStatistics>
13800{
13801 public:
13802 EventClassLoadingStatistics(EventStartTime timing=TIMED) {}
13803
13804 void set_loadedClassCount(s8 new_value) {
13805 }
13806 void set_unloadedClassCount(s8 new_value) {
13807 }
13808
13809 using JfrEvent<EventClassLoadingStatistics>::commit; // else commit() is hidden by overloaded versions in this class
13810
13811 EventClassLoadingStatistics(
13812 s8 loadedClassCount,
13813 s8 unloadedClassCount) {
13814 }
13815
13816 void commit(s8 loadedClassCount,
13817 s8 unloadedClassCount) {
13818 }
13819
13820 static void commit(const Ticks& startTicks,
13821 const Ticks& endTicks,
13822 s8 loadedClassCount,
13823 s8 unloadedClassCount) {
13824 }
13825};
13826
13827class EventClassLoaderStatistics : public JfrEvent<EventClassLoaderStatistics>
13828{
13829 public:
13830 EventClassLoaderStatistics(EventStartTime timing=TIMED) {}
13831
13832 void set_classLoader(const ClassLoaderData* new_value) {
13833 }
13834 void set_parentClassLoader(const ClassLoaderData* new_value) {
13835 }
13836 void set_classLoaderData(u8 new_value) {
13837 }
13838 void set_classCount(s8 new_value) {
13839 }
13840 void set_chunkSize(u8 new_value) {
13841 }
13842 void set_blockSize(u8 new_value) {
13843 }
13844 void set_unsafeAnonymousClassCount(s8 new_value) {
13845 }
13846 void set_unsafeAnonymousChunkSize(u8 new_value) {
13847 }
13848 void set_unsafeAnonymousBlockSize(u8 new_value) {
13849 }
13850
13851 using JfrEvent<EventClassLoaderStatistics>::commit; // else commit() is hidden by overloaded versions in this class
13852
13853 EventClassLoaderStatistics(
13854 const ClassLoaderData* classLoader,
13855 const ClassLoaderData* parentClassLoader,
13856 u8 classLoaderData,
13857 s8 classCount,
13858 u8 chunkSize,
13859 u8 blockSize,
13860 s8 unsafeAnonymousClassCount,
13861 u8 unsafeAnonymousChunkSize,
13862 u8 unsafeAnonymousBlockSize) {
13863 }
13864
13865 void commit(const ClassLoaderData* classLoader,
13866 const ClassLoaderData* parentClassLoader,
13867 u8 classLoaderData,
13868 s8 classCount,
13869 u8 chunkSize,
13870 u8 blockSize,
13871 s8 unsafeAnonymousClassCount,
13872 u8 unsafeAnonymousChunkSize,
13873 u8 unsafeAnonymousBlockSize) {
13874 }
13875
13876 static void commit(const Ticks& startTicks,
13877 const Ticks& endTicks,
13878 const ClassLoaderData* classLoader,
13879 const ClassLoaderData* parentClassLoader,
13880 u8 classLoaderData,
13881 s8 classCount,
13882 u8 chunkSize,
13883 u8 blockSize,
13884 s8 unsafeAnonymousClassCount,
13885 u8 unsafeAnonymousChunkSize,
13886 u8 unsafeAnonymousBlockSize) {
13887 }
13888};
13889
13890class EventSymbolTableStatistics : public JfrEvent<EventSymbolTableStatistics>
13891{
13892 public:
13893 EventSymbolTableStatistics(EventStartTime timing=TIMED) {}
13894
13895 void set_bucketCount(u8 new_value) {
13896 }
13897 void set_entryCount(u8 new_value) {
13898 }
13899 void set_totalFootprint(u8 new_value) {
13900 }
13901 void set_bucketCountMaximum(u8 new_value) {
13902 }
13903 void set_bucketCountAverage(float new_value) {
13904 }
13905 void set_bucketCountVariance(float new_value) {
13906 }
13907 void set_bucketCountStandardDeviation(float new_value) {
13908 }
13909 void set_insertionRate(float new_value) {
13910 }
13911 void set_removalRate(float new_value) {
13912 }
13913
13914 using JfrEvent<EventSymbolTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
13915
13916 EventSymbolTableStatistics(
13917 u8 bucketCount,
13918 u8 entryCount,
13919 u8 totalFootprint,
13920 u8 bucketCountMaximum,
13921 float bucketCountAverage,
13922 float bucketCountVariance,
13923 float bucketCountStandardDeviation,
13924 float insertionRate,
13925 float removalRate) {
13926 }
13927
13928 void commit(u8 bucketCount,
13929 u8 entryCount,
13930 u8 totalFootprint,
13931 u8 bucketCountMaximum,
13932 float bucketCountAverage,
13933 float bucketCountVariance,
13934 float bucketCountStandardDeviation,
13935 float insertionRate,
13936 float removalRate) {
13937 }
13938
13939 static void commit(const Ticks& startTicks,
13940 const Ticks& endTicks,
13941 u8 bucketCount,
13942 u8 entryCount,
13943 u8 totalFootprint,
13944 u8 bucketCountMaximum,
13945 float bucketCountAverage,
13946 float bucketCountVariance,
13947 float bucketCountStandardDeviation,
13948 float insertionRate,
13949 float removalRate) {
13950 }
13951};
13952
13953class EventStringTableStatistics : public JfrEvent<EventStringTableStatistics>
13954{
13955 public:
13956 EventStringTableStatistics(EventStartTime timing=TIMED) {}
13957
13958 void set_bucketCount(u8 new_value) {
13959 }
13960 void set_entryCount(u8 new_value) {
13961 }
13962 void set_totalFootprint(u8 new_value) {
13963 }
13964 void set_bucketCountMaximum(u8 new_value) {
13965 }
13966 void set_bucketCountAverage(float new_value) {
13967 }
13968 void set_bucketCountVariance(float new_value) {
13969 }
13970 void set_bucketCountStandardDeviation(float new_value) {
13971 }
13972 void set_insertionRate(float new_value) {
13973 }
13974 void set_removalRate(float new_value) {
13975 }
13976
13977 using JfrEvent<EventStringTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
13978
13979 EventStringTableStatistics(
13980 u8 bucketCount,
13981 u8 entryCount,
13982 u8 totalFootprint,
13983 u8 bucketCountMaximum,
13984 float bucketCountAverage,
13985 float bucketCountVariance,
13986 float bucketCountStandardDeviation,
13987 float insertionRate,
13988 float removalRate) {
13989 }
13990
13991 void commit(u8 bucketCount,
13992 u8 entryCount,
13993 u8 totalFootprint,
13994 u8 bucketCountMaximum,
13995 float bucketCountAverage,
13996 float bucketCountVariance,
13997 float bucketCountStandardDeviation,
13998 float insertionRate,
13999 float removalRate) {
14000 }
14001
14002 static void commit(const Ticks& startTicks,
14003 const Ticks& endTicks,
14004 u8 bucketCount,
14005 u8 entryCount,
14006 u8 totalFootprint,
14007 u8 bucketCountMaximum,
14008 float bucketCountAverage,
14009 float bucketCountVariance,
14010 float bucketCountStandardDeviation,
14011 float insertionRate,
14012 float removalRate) {
14013 }
14014};
14015
14016class EventPlaceholderTableStatistics : public JfrEvent<EventPlaceholderTableStatistics>
14017{
14018 public:
14019 EventPlaceholderTableStatistics(EventStartTime timing=TIMED) {}
14020
14021 void set_bucketCount(u8 new_value) {
14022 }
14023 void set_entryCount(u8 new_value) {
14024 }
14025 void set_totalFootprint(u8 new_value) {
14026 }
14027 void set_bucketCountMaximum(u8 new_value) {
14028 }
14029 void set_bucketCountAverage(float new_value) {
14030 }
14031 void set_bucketCountVariance(float new_value) {
14032 }
14033 void set_bucketCountStandardDeviation(float new_value) {
14034 }
14035 void set_insertionRate(float new_value) {
14036 }
14037 void set_removalRate(float new_value) {
14038 }
14039
14040 using JfrEvent<EventPlaceholderTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14041
14042 EventPlaceholderTableStatistics(
14043 u8 bucketCount,
14044 u8 entryCount,
14045 u8 totalFootprint,
14046 u8 bucketCountMaximum,
14047 float bucketCountAverage,
14048 float bucketCountVariance,
14049 float bucketCountStandardDeviation,
14050 float insertionRate,
14051 float removalRate) {
14052 }
14053
14054 void commit(u8 bucketCount,
14055 u8 entryCount,
14056 u8 totalFootprint,
14057 u8 bucketCountMaximum,
14058 float bucketCountAverage,
14059 float bucketCountVariance,
14060 float bucketCountStandardDeviation,
14061 float insertionRate,
14062 float removalRate) {
14063 }
14064
14065 static void commit(const Ticks& startTicks,
14066 const Ticks& endTicks,
14067 u8 bucketCount,
14068 u8 entryCount,
14069 u8 totalFootprint,
14070 u8 bucketCountMaximum,
14071 float bucketCountAverage,
14072 float bucketCountVariance,
14073 float bucketCountStandardDeviation,
14074 float insertionRate,
14075 float removalRate) {
14076 }
14077};
14078
14079class EventLoaderConstraintsTableStatistics : public JfrEvent<EventLoaderConstraintsTableStatistics>
14080{
14081 public:
14082 EventLoaderConstraintsTableStatistics(EventStartTime timing=TIMED) {}
14083
14084 void set_bucketCount(u8 new_value) {
14085 }
14086 void set_entryCount(u8 new_value) {
14087 }
14088 void set_totalFootprint(u8 new_value) {
14089 }
14090 void set_bucketCountMaximum(u8 new_value) {
14091 }
14092 void set_bucketCountAverage(float new_value) {
14093 }
14094 void set_bucketCountVariance(float new_value) {
14095 }
14096 void set_bucketCountStandardDeviation(float new_value) {
14097 }
14098 void set_insertionRate(float new_value) {
14099 }
14100 void set_removalRate(float new_value) {
14101 }
14102
14103 using JfrEvent<EventLoaderConstraintsTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14104
14105 EventLoaderConstraintsTableStatistics(
14106 u8 bucketCount,
14107 u8 entryCount,
14108 u8 totalFootprint,
14109 u8 bucketCountMaximum,
14110 float bucketCountAverage,
14111 float bucketCountVariance,
14112 float bucketCountStandardDeviation,
14113 float insertionRate,
14114 float removalRate) {
14115 }
14116
14117 void commit(u8 bucketCount,
14118 u8 entryCount,
14119 u8 totalFootprint,
14120 u8 bucketCountMaximum,
14121 float bucketCountAverage,
14122 float bucketCountVariance,
14123 float bucketCountStandardDeviation,
14124 float insertionRate,
14125 float removalRate) {
14126 }
14127
14128 static void commit(const Ticks& startTicks,
14129 const Ticks& endTicks,
14130 u8 bucketCount,
14131 u8 entryCount,
14132 u8 totalFootprint,
14133 u8 bucketCountMaximum,
14134 float bucketCountAverage,
14135 float bucketCountVariance,
14136 float bucketCountStandardDeviation,
14137 float insertionRate,
14138 float removalRate) {
14139 }
14140};
14141
14142class EventProtectionDomainCacheTableStatistics : public JfrEvent<EventProtectionDomainCacheTableStatistics>
14143{
14144 public:
14145 EventProtectionDomainCacheTableStatistics(EventStartTime timing=TIMED) {}
14146
14147 void set_bucketCount(u8 new_value) {
14148 }
14149 void set_entryCount(u8 new_value) {
14150 }
14151 void set_totalFootprint(u8 new_value) {
14152 }
14153 void set_bucketCountMaximum(u8 new_value) {
14154 }
14155 void set_bucketCountAverage(float new_value) {
14156 }
14157 void set_bucketCountVariance(float new_value) {
14158 }
14159 void set_bucketCountStandardDeviation(float new_value) {
14160 }
14161 void set_insertionRate(float new_value) {
14162 }
14163 void set_removalRate(float new_value) {
14164 }
14165
14166 using JfrEvent<EventProtectionDomainCacheTableStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14167
14168 EventProtectionDomainCacheTableStatistics(
14169 u8 bucketCount,
14170 u8 entryCount,
14171 u8 totalFootprint,
14172 u8 bucketCountMaximum,
14173 float bucketCountAverage,
14174 float bucketCountVariance,
14175 float bucketCountStandardDeviation,
14176 float insertionRate,
14177 float removalRate) {
14178 }
14179
14180 void commit(u8 bucketCount,
14181 u8 entryCount,
14182 u8 totalFootprint,
14183 u8 bucketCountMaximum,
14184 float bucketCountAverage,
14185 float bucketCountVariance,
14186 float bucketCountStandardDeviation,
14187 float insertionRate,
14188 float removalRate) {
14189 }
14190
14191 static void commit(const Ticks& startTicks,
14192 const Ticks& endTicks,
14193 u8 bucketCount,
14194 u8 entryCount,
14195 u8 totalFootprint,
14196 u8 bucketCountMaximum,
14197 float bucketCountAverage,
14198 float bucketCountVariance,
14199 float bucketCountStandardDeviation,
14200 float insertionRate,
14201 float removalRate) {
14202 }
14203};
14204
14205class EventThreadAllocationStatistics : public JfrEvent<EventThreadAllocationStatistics>
14206{
14207 public:
14208 EventThreadAllocationStatistics(EventStartTime timing=TIMED) {}
14209
14210 void set_allocated(u8 new_value) {
14211 }
14212 void set_thread(u8 new_value) {
14213 }
14214
14215 using JfrEvent<EventThreadAllocationStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14216
14217 EventThreadAllocationStatistics(
14218 u8 allocated,
14219 u8 thread) {
14220 }
14221
14222 void commit(u8 allocated,
14223 u8 thread) {
14224 }
14225
14226 static void commit(const Ticks& startTicks,
14227 const Ticks& endTicks,
14228 u8 allocated,
14229 u8 thread) {
14230 }
14231};
14232
14233class EventPhysicalMemory : public JfrEvent<EventPhysicalMemory>
14234{
14235 public:
14236 EventPhysicalMemory(EventStartTime timing=TIMED) {}
14237
14238 void set_totalSize(u8 new_value) {
14239 }
14240 void set_usedSize(u8 new_value) {
14241 }
14242
14243 using JfrEvent<EventPhysicalMemory>::commit; // else commit() is hidden by overloaded versions in this class
14244
14245 EventPhysicalMemory(
14246 u8 totalSize,
14247 u8 usedSize) {
14248 }
14249
14250 void commit(u8 totalSize,
14251 u8 usedSize) {
14252 }
14253
14254 static void commit(const Ticks& startTicks,
14255 const Ticks& endTicks,
14256 u8 totalSize,
14257 u8 usedSize) {
14258 }
14259};
14260
14261class EventExecutionSample : public JfrEvent<EventExecutionSample>
14262{
14263 public:
14264 EventExecutionSample(EventStartTime timing=TIMED) {}
14265
14266 void set_sampledThread(u8 new_value) {
14267 }
14268 void set_stackTrace(u8 new_value) {
14269 }
14270 void set_state(u8 new_value) {
14271 }
14272
14273 using JfrEvent<EventExecutionSample>::commit; // else commit() is hidden by overloaded versions in this class
14274
14275 EventExecutionSample(
14276 u8 sampledThread,
14277 u8 stackTrace,
14278 u8 state) {
14279 }
14280
14281 void commit(u8 sampledThread,
14282 u8 stackTrace,
14283 u8 state) {
14284 }
14285
14286 static void commit(const Ticks& startTicks,
14287 const Ticks& endTicks,
14288 u8 sampledThread,
14289 u8 stackTrace,
14290 u8 state) {
14291 }
14292};
14293
14294class EventNativeMethodSample : public JfrEvent<EventNativeMethodSample>
14295{
14296 public:
14297 EventNativeMethodSample(EventStartTime timing=TIMED) {}
14298
14299 void set_sampledThread(u8 new_value) {
14300 }
14301 void set_stackTrace(u8 new_value) {
14302 }
14303 void set_state(u8 new_value) {
14304 }
14305
14306 using JfrEvent<EventNativeMethodSample>::commit; // else commit() is hidden by overloaded versions in this class
14307
14308 EventNativeMethodSample(
14309 u8 sampledThread,
14310 u8 stackTrace,
14311 u8 state) {
14312 }
14313
14314 void commit(u8 sampledThread,
14315 u8 stackTrace,
14316 u8 state) {
14317 }
14318
14319 static void commit(const Ticks& startTicks,
14320 const Ticks& endTicks,
14321 u8 sampledThread,
14322 u8 stackTrace,
14323 u8 state) {
14324 }
14325};
14326
14327class EventThreadDump : public JfrEvent<EventThreadDump>
14328{
14329 public:
14330 EventThreadDump(EventStartTime timing=TIMED) {}
14331
14332 void set_result(const char* new_value) {
14333 }
14334
14335 using JfrEvent<EventThreadDump>::commit; // else commit() is hidden by overloaded versions in this class
14336
14337 EventThreadDump(
14338 const char* result) {
14339 }
14340
14341 void commit(const char* result) {
14342 }
14343
14344 static void commit(const Ticks& startTicks,
14345 const Ticks& endTicks,
14346 const char* result) {
14347 }
14348};
14349
14350class EventNativeLibrary : public JfrEvent<EventNativeLibrary>
14351{
14352 public:
14353 EventNativeLibrary(EventStartTime timing=TIMED) {}
14354
14355 void set_name(const char* new_value) {
14356 }
14357 void set_baseAddress(u8 new_value) {
14358 }
14359 void set_topAddress(u8 new_value) {
14360 }
14361
14362 using JfrEvent<EventNativeLibrary>::commit; // else commit() is hidden by overloaded versions in this class
14363
14364 EventNativeLibrary(
14365 const char* name,
14366 u8 baseAddress,
14367 u8 topAddress) {
14368 }
14369
14370 void commit(const char* name,
14371 u8 baseAddress,
14372 u8 topAddress) {
14373 }
14374
14375 static void commit(const Ticks& startTicks,
14376 const Ticks& endTicks,
14377 const char* name,
14378 u8 baseAddress,
14379 u8 topAddress) {
14380 }
14381};
14382
14383class EventModuleRequire : public JfrEvent<EventModuleRequire>
14384{
14385 public:
14386 EventModuleRequire(EventStartTime timing=TIMED) {}
14387
14388 void set_source(const ModuleEntry* new_value) {
14389 }
14390 void set_requiredModule(const ModuleEntry* new_value) {
14391 }
14392
14393 using JfrEvent<EventModuleRequire>::commit; // else commit() is hidden by overloaded versions in this class
14394
14395 EventModuleRequire(
14396 const ModuleEntry* source,
14397 const ModuleEntry* requiredModule) {
14398 }
14399
14400 void commit(const ModuleEntry* source,
14401 const ModuleEntry* requiredModule) {
14402 }
14403
14404 static void commit(const Ticks& startTicks,
14405 const Ticks& endTicks,
14406 const ModuleEntry* source,
14407 const ModuleEntry* requiredModule) {
14408 }
14409};
14410
14411class EventModuleExport : public JfrEvent<EventModuleExport>
14412{
14413 public:
14414 EventModuleExport(EventStartTime timing=TIMED) {}
14415
14416 void set_exportedPackage(const PackageEntry* new_value) {
14417 }
14418 void set_targetModule(const ModuleEntry* new_value) {
14419 }
14420
14421 using JfrEvent<EventModuleExport>::commit; // else commit() is hidden by overloaded versions in this class
14422
14423 EventModuleExport(
14424 const PackageEntry* exportedPackage,
14425 const ModuleEntry* targetModule) {
14426 }
14427
14428 void commit(const PackageEntry* exportedPackage,
14429 const ModuleEntry* targetModule) {
14430 }
14431
14432 static void commit(const Ticks& startTicks,
14433 const Ticks& endTicks,
14434 const PackageEntry* exportedPackage,
14435 const ModuleEntry* targetModule) {
14436 }
14437};
14438
14439class EventCompilerStatistics : public JfrEvent<EventCompilerStatistics>
14440{
14441 public:
14442 EventCompilerStatistics(EventStartTime timing=TIMED) {}
14443
14444 void set_compileCount(s4 new_value) {
14445 }
14446 void set_bailoutCount(s4 new_value) {
14447 }
14448 void set_invalidatedCount(s4 new_value) {
14449 }
14450 void set_osrCompileCount(s4 new_value) {
14451 }
14452 void set_standardCompileCount(s4 new_value) {
14453 }
14454 void set_osrBytesCompiled(u8 new_value) {
14455 }
14456 void set_standardBytesCompiled(u8 new_value) {
14457 }
14458 void set_nmetodsSize(u8 new_value) {
14459 }
14460 void set_nmetodCodeSize(u8 new_value) {
14461 }
14462 void set_peakTimeSpent(s8 new_value) {
14463 }
14464 void set_totalTimeSpent(s8 new_value) {
14465 }
14466
14467 using JfrEvent<EventCompilerStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14468
14469
14470
14471 static void commit(s4 compileCount,
14472 s4 bailoutCount,
14473 s4 invalidatedCount,
14474 s4 osrCompileCount,
14475 s4 standardCompileCount,
14476 u8 osrBytesCompiled,
14477 u8 standardBytesCompiled,
14478 u8 nmetodsSize,
14479 u8 nmetodCodeSize,
14480 s8 peakTimeSpent,
14481 s8 totalTimeSpent) {
14482 }
14483};
14484
14485class EventCompilerConfiguration : public JfrEvent<EventCompilerConfiguration>
14486{
14487 public:
14488 EventCompilerConfiguration(EventStartTime timing=TIMED) {}
14489
14490 void set_threadCount(s4 new_value) {
14491 }
14492 void set_tieredCompilation(bool new_value) {
14493 }
14494
14495 using JfrEvent<EventCompilerConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
14496
14497
14498
14499 static void commit(s4 threadCount,
14500 bool tieredCompilation) {
14501 }
14502};
14503
14504class EventCodeCacheStatistics : public JfrEvent<EventCodeCacheStatistics>
14505{
14506 public:
14507 EventCodeCacheStatistics(EventStartTime timing=TIMED) {}
14508
14509 void set_codeBlobType(u8 new_value) {
14510 }
14511 void set_startAddress(u8 new_value) {
14512 }
14513 void set_reservedTopAddress(u8 new_value) {
14514 }
14515 void set_entryCount(s4 new_value) {
14516 }
14517 void set_methodCount(s4 new_value) {
14518 }
14519 void set_adaptorCount(s4 new_value) {
14520 }
14521 void set_unallocatedCapacity(u8 new_value) {
14522 }
14523 void set_fullCount(s4 new_value) {
14524 }
14525
14526 using JfrEvent<EventCodeCacheStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14527
14528
14529
14530 static void commit(u8 codeBlobType,
14531 u8 startAddress,
14532 u8 reservedTopAddress,
14533 s4 entryCount,
14534 s4 methodCount,
14535 s4 adaptorCount,
14536 u8 unallocatedCapacity,
14537 s4 fullCount) {
14538 }
14539};
14540
14541class EventCodeCacheConfiguration : public JfrEvent<EventCodeCacheConfiguration>
14542{
14543 public:
14544 EventCodeCacheConfiguration(EventStartTime timing=TIMED) {}
14545
14546 void set_initialSize(u8 new_value) {
14547 }
14548 void set_reservedSize(u8 new_value) {
14549 }
14550 void set_nonNMethodSize(u8 new_value) {
14551 }
14552 void set_profiledSize(u8 new_value) {
14553 }
14554 void set_nonProfiledSize(u8 new_value) {
14555 }
14556 void set_expansionSize(u8 new_value) {
14557 }
14558 void set_minBlockLength(u8 new_value) {
14559 }
14560 void set_startAddress(u8 new_value) {
14561 }
14562 void set_reservedTopAddress(u8 new_value) {
14563 }
14564
14565 using JfrEvent<EventCodeCacheConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
14566
14567
14568
14569 static void commit(u8 initialSize,
14570 u8 reservedSize,
14571 u8 nonNMethodSize,
14572 u8 profiledSize,
14573 u8 nonProfiledSize,
14574 u8 expansionSize,
14575 u8 minBlockLength,
14576 u8 startAddress,
14577 u8 reservedTopAddress) {
14578 }
14579};
14580
14581class EventCodeSweeperStatistics : public JfrEvent<EventCodeSweeperStatistics>
14582{
14583 public:
14584 EventCodeSweeperStatistics(EventStartTime timing=TIMED) {}
14585
14586 void set_sweepCount(s4 new_value) {
14587 }
14588 void set_methodReclaimedCount(s4 new_value) {
14589 }
14590 void set_totalSweepTime(const Tickspan& new_value) {
14591 }
14592 void set_peakFractionTime(const Tickspan& new_value) {
14593 }
14594 void set_peakSweepTime(const Tickspan& new_value) {
14595 }
14596
14597 using JfrEvent<EventCodeSweeperStatistics>::commit; // else commit() is hidden by overloaded versions in this class
14598
14599
14600
14601 static void commit(s4 sweepCount,
14602 s4 methodReclaimedCount,
14603 const Tickspan& totalSweepTime,
14604 const Tickspan& peakFractionTime,
14605 const Tickspan& peakSweepTime) {
14606 }
14607};
14608
14609class EventCodeSweeperConfiguration : public JfrEvent<EventCodeSweeperConfiguration>
14610{
14611 public:
14612 EventCodeSweeperConfiguration(EventStartTime timing=TIMED) {}
14613
14614 void set_sweeperEnabled(bool new_value) {
14615 }
14616 void set_flushingEnabled(bool new_value) {
14617 }
14618
14619 using JfrEvent<EventCodeSweeperConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
14620
14621
14622
14623 static void commit(bool sweeperEnabled,
14624 bool flushingEnabled) {
14625 }
14626};
14627
14628class EventIntFlag : public JfrEvent<EventIntFlag>
14629{
14630 public:
14631 EventIntFlag(EventStartTime timing=TIMED) {}
14632
14633 void set_name(const char* new_value) {
14634 }
14635 void set_value(s4 new_value) {
14636 }
14637 void set_origin(u8 new_value) {
14638 }
14639
14640 using JfrEvent<EventIntFlag>::commit; // else commit() is hidden by overloaded versions in this class
14641
14642 EventIntFlag(
14643 const char* name,
14644 s4 value,
14645 u8 origin) {
14646 }
14647
14648 void commit(const char* name,
14649 s4 value,
14650 u8 origin) {
14651 }
14652
14653 static void commit(const Ticks& startTicks,
14654 const Ticks& endTicks,
14655 const char* name,
14656 s4 value,
14657 u8 origin) {
14658 }
14659};
14660
14661class EventUnsignedIntFlag : public JfrEvent<EventUnsignedIntFlag>
14662{
14663 public:
14664 EventUnsignedIntFlag(EventStartTime timing=TIMED) {}
14665
14666 void set_name(const char* new_value) {
14667 }
14668 void set_value(unsigned new_value) {
14669 }
14670 void set_origin(u8 new_value) {
14671 }
14672
14673 using JfrEvent<EventUnsignedIntFlag>::commit; // else commit() is hidden by overloaded versions in this class
14674
14675 EventUnsignedIntFlag(
14676 const char* name,
14677 unsigned value,
14678 u8 origin) {
14679 }
14680
14681 void commit(const char* name,
14682 unsigned value,
14683 u8 origin) {
14684 }
14685
14686 static void commit(const Ticks& startTicks,
14687 const Ticks& endTicks,
14688 const char* name,
14689 unsigned value,
14690 u8 origin) {
14691 }
14692};
14693
14694class EventLongFlag : public JfrEvent<EventLongFlag>
14695{
14696 public:
14697 EventLongFlag(EventStartTime timing=TIMED) {}
14698
14699 void set_name(const char* new_value) {
14700 }
14701 void set_value(s8 new_value) {
14702 }
14703 void set_origin(u8 new_value) {
14704 }
14705
14706 using JfrEvent<EventLongFlag>::commit; // else commit() is hidden by overloaded versions in this class
14707
14708 EventLongFlag(
14709 const char* name,
14710 s8 value,
14711 u8 origin) {
14712 }
14713
14714 void commit(const char* name,
14715 s8 value,
14716 u8 origin) {
14717 }
14718
14719 static void commit(const Ticks& startTicks,
14720 const Ticks& endTicks,
14721 const char* name,
14722 s8 value,
14723 u8 origin) {
14724 }
14725};
14726
14727class EventUnsignedLongFlag : public JfrEvent<EventUnsignedLongFlag>
14728{
14729 public:
14730 EventUnsignedLongFlag(EventStartTime timing=TIMED) {}
14731
14732 void set_name(const char* new_value) {
14733 }
14734 void set_value(u8 new_value) {
14735 }
14736 void set_origin(u8 new_value) {
14737 }
14738
14739 using JfrEvent<EventUnsignedLongFlag>::commit; // else commit() is hidden by overloaded versions in this class
14740
14741 EventUnsignedLongFlag(
14742 const char* name,
14743 u8 value,
14744 u8 origin) {
14745 }
14746
14747 void commit(const char* name,
14748 u8 value,
14749 u8 origin) {
14750 }
14751
14752 static void commit(const Ticks& startTicks,
14753 const Ticks& endTicks,
14754 const char* name,
14755 u8 value,
14756 u8 origin) {
14757 }
14758};
14759
14760class EventDoubleFlag : public JfrEvent<EventDoubleFlag>
14761{
14762 public:
14763 EventDoubleFlag(EventStartTime timing=TIMED) {}
14764
14765 void set_name(const char* new_value) {
14766 }
14767 void set_value(double new_value) {
14768 }
14769 void set_origin(u8 new_value) {
14770 }
14771
14772 using JfrEvent<EventDoubleFlag>::commit; // else commit() is hidden by overloaded versions in this class
14773
14774 EventDoubleFlag(
14775 const char* name,
14776 double value,
14777 u8 origin) {
14778 }
14779
14780 void commit(const char* name,
14781 double value,
14782 u8 origin) {
14783 }
14784
14785 static void commit(const Ticks& startTicks,
14786 const Ticks& endTicks,
14787 const char* name,
14788 double value,
14789 u8 origin) {
14790 }
14791};
14792
14793class EventBooleanFlag : public JfrEvent<EventBooleanFlag>
14794{
14795 public:
14796 EventBooleanFlag(EventStartTime timing=TIMED) {}
14797
14798 void set_name(const char* new_value) {
14799 }
14800 void set_value(bool new_value) {
14801 }
14802 void set_origin(u8 new_value) {
14803 }
14804
14805 using JfrEvent<EventBooleanFlag>::commit; // else commit() is hidden by overloaded versions in this class
14806
14807 EventBooleanFlag(
14808 const char* name,
14809 bool value,
14810 u8 origin) {
14811 }
14812
14813 void commit(const char* name,
14814 bool value,
14815 u8 origin) {
14816 }
14817
14818 static void commit(const Ticks& startTicks,
14819 const Ticks& endTicks,
14820 const char* name,
14821 bool value,
14822 u8 origin) {
14823 }
14824};
14825
14826class EventStringFlag : public JfrEvent<EventStringFlag>
14827{
14828 public:
14829 EventStringFlag(EventStartTime timing=TIMED) {}
14830
14831 void set_name(const char* new_value) {
14832 }
14833 void set_value(const char* new_value) {
14834 }
14835 void set_origin(u8 new_value) {
14836 }
14837
14838 using JfrEvent<EventStringFlag>::commit; // else commit() is hidden by overloaded versions in this class
14839
14840 EventStringFlag(
14841 const char* name,
14842 const char* value,
14843 u8 origin) {
14844 }
14845
14846 void commit(const char* name,
14847 const char* value,
14848 u8 origin) {
14849 }
14850
14851 static void commit(const Ticks& startTicks,
14852 const Ticks& endTicks,
14853 const char* name,
14854 const char* value,
14855 u8 origin) {
14856 }
14857};
14858
14859class EventObjectCount : public JfrEvent<EventObjectCount>
14860{
14861 public:
14862 EventObjectCount(EventStartTime timing=TIMED) {}
14863
14864 void set_gcId(unsigned new_value) {
14865 }
14866 void set_objectClass(const Klass* new_value) {
14867 }
14868 void set_count(s8 new_value) {
14869 }
14870 void set_totalSize(u8 new_value) {
14871 }
14872
14873 using JfrEvent<EventObjectCount>::commit; // else commit() is hidden by overloaded versions in this class
14874
14875
14876
14877 static void commit(unsigned gcId,
14878 const Klass* objectClass,
14879 s8 count,
14880 u8 totalSize) {
14881 }
14882};
14883
14884class EventG1HeapRegionInformation : public JfrEvent<EventG1HeapRegionInformation>
14885{
14886 public:
14887 EventG1HeapRegionInformation(EventStartTime timing=TIMED) {}
14888
14889 void set_index(unsigned new_value) {
14890 }
14891 void set_type(u8 new_value) {
14892 }
14893 void set_start(u8 new_value) {
14894 }
14895 void set_used(u8 new_value) {
14896 }
14897
14898 using JfrEvent<EventG1HeapRegionInformation>::commit; // else commit() is hidden by overloaded versions in this class
14899
14900 EventG1HeapRegionInformation(
14901 unsigned index,
14902 u8 type,
14903 u8 start,
14904 u8 used) {
14905 }
14906
14907 void commit(unsigned index,
14908 u8 type,
14909 u8 start,
14910 u8 used) {
14911 }
14912
14913 static void commit(const Ticks& startTicks,
14914 const Ticks& endTicks,
14915 unsigned index,
14916 u8 type,
14917 u8 start,
14918 u8 used) {
14919 }
14920};
14921
14922class EventGCConfiguration : public JfrEvent<EventGCConfiguration>
14923{
14924 public:
14925 EventGCConfiguration(EventStartTime timing=TIMED) {}
14926
14927 void set_youngCollector(u8 new_value) {
14928 }
14929 void set_oldCollector(u8 new_value) {
14930 }
14931 void set_parallelGCThreads(unsigned new_value) {
14932 }
14933 void set_concurrentGCThreads(unsigned new_value) {
14934 }
14935 void set_usesDynamicGCThreads(bool new_value) {
14936 }
14937 void set_isExplicitGCConcurrent(bool new_value) {
14938 }
14939 void set_isExplicitGCDisabled(bool new_value) {
14940 }
14941 void set_pauseTarget(s8 new_value) {
14942 }
14943 void set_gcTimeRatio(unsigned new_value) {
14944 }
14945
14946 using JfrEvent<EventGCConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
14947
14948 EventGCConfiguration(
14949 u8 youngCollector,
14950 u8 oldCollector,
14951 unsigned parallelGCThreads,
14952 unsigned concurrentGCThreads,
14953 bool usesDynamicGCThreads,
14954 bool isExplicitGCConcurrent,
14955 bool isExplicitGCDisabled,
14956 s8 pauseTarget,
14957 unsigned gcTimeRatio) {
14958 }
14959
14960 void commit(u8 youngCollector,
14961 u8 oldCollector,
14962 unsigned parallelGCThreads,
14963 unsigned concurrentGCThreads,
14964 bool usesDynamicGCThreads,
14965 bool isExplicitGCConcurrent,
14966 bool isExplicitGCDisabled,
14967 s8 pauseTarget,
14968 unsigned gcTimeRatio) {
14969 }
14970
14971 static void commit(const Ticks& startTicks,
14972 const Ticks& endTicks,
14973 u8 youngCollector,
14974 u8 oldCollector,
14975 unsigned parallelGCThreads,
14976 unsigned concurrentGCThreads,
14977 bool usesDynamicGCThreads,
14978 bool isExplicitGCConcurrent,
14979 bool isExplicitGCDisabled,
14980 s8 pauseTarget,
14981 unsigned gcTimeRatio) {
14982 }
14983};
14984
14985class EventGCSurvivorConfiguration : public JfrEvent<EventGCSurvivorConfiguration>
14986{
14987 public:
14988 EventGCSurvivorConfiguration(EventStartTime timing=TIMED) {}
14989
14990 void set_maxTenuringThreshold(u1 new_value) {
14991 }
14992 void set_initialTenuringThreshold(u1 new_value) {
14993 }
14994
14995 using JfrEvent<EventGCSurvivorConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
14996
14997 EventGCSurvivorConfiguration(
14998 u1 maxTenuringThreshold,
14999 u1 initialTenuringThreshold) {
15000 }
15001
15002 void commit(u1 maxTenuringThreshold,
15003 u1 initialTenuringThreshold) {
15004 }
15005
15006 static void commit(const Ticks& startTicks,
15007 const Ticks& endTicks,
15008 u1 maxTenuringThreshold,
15009 u1 initialTenuringThreshold) {
15010 }
15011};
15012
15013class EventGCTLABConfiguration : public JfrEvent<EventGCTLABConfiguration>
15014{
15015 public:
15016 EventGCTLABConfiguration(EventStartTime timing=TIMED) {}
15017
15018 void set_usesTLABs(bool new_value) {
15019 }
15020 void set_minTLABSize(u8 new_value) {
15021 }
15022 void set_tlabRefillWasteLimit(u8 new_value) {
15023 }
15024
15025 using JfrEvent<EventGCTLABConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
15026
15027 EventGCTLABConfiguration(
15028 bool usesTLABs,
15029 u8 minTLABSize,
15030 u8 tlabRefillWasteLimit) {
15031 }
15032
15033 void commit(bool usesTLABs,
15034 u8 minTLABSize,
15035 u8 tlabRefillWasteLimit) {
15036 }
15037
15038 static void commit(const Ticks& startTicks,
15039 const Ticks& endTicks,
15040 bool usesTLABs,
15041 u8 minTLABSize,
15042 u8 tlabRefillWasteLimit) {
15043 }
15044};
15045
15046class EventGCHeapConfiguration : public JfrEvent<EventGCHeapConfiguration>
15047{
15048 public:
15049 EventGCHeapConfiguration(EventStartTime timing=TIMED) {}
15050
15051 void set_minSize(u8 new_value) {
15052 }
15053 void set_maxSize(u8 new_value) {
15054 }
15055 void set_initialSize(u8 new_value) {
15056 }
15057 void set_usesCompressedOops(bool new_value) {
15058 }
15059 void set_compressedOopsMode(u8 new_value) {
15060 }
15061 void set_objectAlignment(u8 new_value) {
15062 }
15063 void set_heapAddressBits(u1 new_value) {
15064 }
15065
15066 using JfrEvent<EventGCHeapConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
15067
15068 EventGCHeapConfiguration(
15069 u8 minSize,
15070 u8 maxSize,
15071 u8 initialSize,
15072 bool usesCompressedOops,
15073 u8 compressedOopsMode,
15074 u8 objectAlignment,
15075 u1 heapAddressBits) {
15076 }
15077
15078 void commit(u8 minSize,
15079 u8 maxSize,
15080 u8 initialSize,
15081 bool usesCompressedOops,
15082 u8 compressedOopsMode,
15083 u8 objectAlignment,
15084 u1 heapAddressBits) {
15085 }
15086
15087 static void commit(const Ticks& startTicks,
15088 const Ticks& endTicks,
15089 u8 minSize,
15090 u8 maxSize,
15091 u8 initialSize,
15092 bool usesCompressedOops,
15093 u8 compressedOopsMode,
15094 u8 objectAlignment,
15095 u1 heapAddressBits) {
15096 }
15097};
15098
15099class EventYoungGenerationConfiguration : public JfrEvent<EventYoungGenerationConfiguration>
15100{
15101 public:
15102 EventYoungGenerationConfiguration(EventStartTime timing=TIMED) {}
15103
15104 void set_minSize(u8 new_value) {
15105 }
15106 void set_maxSize(u8 new_value) {
15107 }
15108 void set_newRatio(unsigned new_value) {
15109 }
15110
15111 using JfrEvent<EventYoungGenerationConfiguration>::commit; // else commit() is hidden by overloaded versions in this class
15112
15113 EventYoungGenerationConfiguration(
15114 u8 minSize,
15115 u8 maxSize,
15116 unsigned newRatio) {
15117 }
15118
15119 void commit(u8 minSize,
15120 u8 maxSize,
15121 unsigned newRatio) {
15122 }
15123
15124 static void commit(const Ticks& startTicks,
15125 const Ticks& endTicks,
15126 u8 minSize,
15127 u8 maxSize,
15128 unsigned newRatio) {
15129 }
15130};
15131
15132class EventZPageAllocation : public JfrEvent<EventZPageAllocation>
15133{
15134 public:
15135 EventZPageAllocation(EventStartTime timing=TIMED) {}
15136
15137 void set_pageSize(u8 new_value) {
15138 }
15139 void set_usedAfter(u8 new_value) {
15140 }
15141 void set_freeAfter(u8 new_value) {
15142 }
15143 void set_inCacheAfter(u8 new_value) {
15144 }
15145 void set_nonBlocking(bool new_value) {
15146 }
15147 void set_noReserve(bool new_value) {
15148 }
15149
15150 using JfrEvent<EventZPageAllocation>::commit; // else commit() is hidden by overloaded versions in this class
15151
15152 EventZPageAllocation(
15153 u8 pageSize,
15154 u8 usedAfter,
15155 u8 freeAfter,
15156 u8 inCacheAfter,
15157 bool nonBlocking,
15158 bool noReserve) {
15159 }
15160
15161 void commit(u8 pageSize,
15162 u8 usedAfter,
15163 u8 freeAfter,
15164 u8 inCacheAfter,
15165 bool nonBlocking,
15166 bool noReserve) {
15167 }
15168
15169 static void commit(const Ticks& startTicks,
15170 const Ticks& endTicks,
15171 u8 pageSize,
15172 u8 usedAfter,
15173 u8 freeAfter,
15174 u8 inCacheAfter,
15175 bool nonBlocking,
15176 bool noReserve) {
15177 }
15178};
15179
15180class EventZThreadPhase : public JfrEvent<EventZThreadPhase>
15181{
15182 public:
15183 EventZThreadPhase(EventStartTime timing=TIMED) {}
15184
15185 void set_gcId(unsigned new_value) {
15186 }
15187 void set_name(const char* new_value) {
15188 }
15189
15190 using JfrEvent<EventZThreadPhase>::commit; // else commit() is hidden by overloaded versions in this class
15191
15192 EventZThreadPhase(
15193 unsigned gcId,
15194 const char* name) {
15195 }
15196
15197 void commit(unsigned gcId,
15198 const char* name) {
15199 }
15200
15201 static void commit(const Ticks& startTicks,
15202 const Ticks& endTicks,
15203 unsigned gcId,
15204 const char* name) {
15205 }
15206};
15207
15208class EventZStatisticsCounter : public JfrEvent<EventZStatisticsCounter>
15209{
15210 public:
15211 EventZStatisticsCounter(EventStartTime timing=TIMED) {}
15212
15213 void set_id(u8 new_value) {
15214 }
15215 void set_increment(u8 new_value) {
15216 }
15217 void set_value(u8 new_value) {
15218 }
15219
15220 using JfrEvent<EventZStatisticsCounter>::commit; // else commit() is hidden by overloaded versions in this class
15221
15222 EventZStatisticsCounter(
15223 u8 id,
15224 u8 increment,
15225 u8 value) {
15226 }
15227
15228 void commit(u8 id,
15229 u8 increment,
15230 u8 value) {
15231 }
15232
15233 static void commit(const Ticks& startTicks,
15234 const Ticks& endTicks,
15235 u8 id,
15236 u8 increment,
15237 u8 value) {
15238 }
15239};
15240
15241class EventZStatisticsSampler : public JfrEvent<EventZStatisticsSampler>
15242{
15243 public:
15244 EventZStatisticsSampler(EventStartTime timing=TIMED) {}
15245
15246 void set_id(u8 new_value) {
15247 }
15248 void set_value(u8 new_value) {
15249 }
15250
15251 using JfrEvent<EventZStatisticsSampler>::commit; // else commit() is hidden by overloaded versions in this class
15252
15253 EventZStatisticsSampler(
15254 u8 id,
15255 u8 value) {
15256 }
15257
15258 void commit(u8 id,
15259 u8 value) {
15260 }
15261
15262 static void commit(const Ticks& startTicks,
15263 const Ticks& endTicks,
15264 u8 id,
15265 u8 value) {
15266 }
15267};
15268
15269class EventShenandoahHeapRegionStateChange : public JfrEvent<EventShenandoahHeapRegionStateChange>
15270{
15271 public:
15272 EventShenandoahHeapRegionStateChange(EventStartTime timing=TIMED) {}
15273
15274 void set_index(unsigned new_value) {
15275 }
15276 void set_from(u8 new_value) {
15277 }
15278 void set_to(u8 new_value) {
15279 }
15280 void set_start(u8 new_value) {
15281 }
15282 void set_used(u8 new_value) {
15283 }
15284
15285 using JfrEvent<EventShenandoahHeapRegionStateChange>::commit; // else commit() is hidden by overloaded versions in this class
15286
15287
15288
15289 static void commit(unsigned index,
15290 u8 from,
15291 u8 to,
15292 u8 start,
15293 u8 used) {
15294 }
15295};
15296
15297class EventShenandoahHeapRegionInformation : public JfrEvent<EventShenandoahHeapRegionInformation>
15298{
15299 public:
15300 EventShenandoahHeapRegionInformation(EventStartTime timing=TIMED) {}
15301
15302 void set_index(unsigned new_value) {
15303 }
15304 void set_state(u8 new_value) {
15305 }
15306 void set_start(u8 new_value) {
15307 }
15308 void set_used(u8 new_value) {
15309 }
15310
15311 using JfrEvent<EventShenandoahHeapRegionInformation>::commit; // else commit() is hidden by overloaded versions in this class
15312
15313 EventShenandoahHeapRegionInformation(
15314 unsigned index,
15315 u8 state,
15316 u8 start,
15317 u8 used) {
15318 }
15319
15320 void commit(unsigned index,
15321 u8 state,
15322 u8 start,
15323 u8 used) {
15324 }
15325
15326 static void commit(const Ticks& startTicks,
15327 const Ticks& endTicks,
15328 unsigned index,
15329 u8 state,
15330 u8 start,
15331 u8 used) {
15332 }
15333};
15334
15335
15336
15337#endif // INCLUDE_JFR
15338#endif // JFRFILES_JFREVENTCLASSES_HPP
15339