?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d: Merge upstream dmd, druntime 4c18eed967, phobos d945686a4.
[official-gcc.git] / libphobos / libdruntime / core / sys / linux / perf_event.d
blobe0a0c99514cb8284016a87941a6c282d825de0bd
1 /**
2 * D header file for perf_event_open system call.
3 *
4 * Converted from linux userspace header, comments included.
5 *
6 * Authors: Max Haughton
7 */
8 module core.sys.linux.perf_event;
9 version (linux) : extern (C):
10 @nogc:
11 nothrow:
12
13 import core.sys.posix.sys.ioctl;
14 import core.sys.posix.unistd;
15
16 version (HPPA) version = HPPA_Any;
17 version (HPPA64) version = HPPA_Any;
18 version (PPC) version = PPC_Any;
19 version (PPC64) version = PPC_Any;
20 version (RISCV32) version = RISCV_Any;
21 version (RISCV64) version = RISCV_Any;
22 version (S390) version = IBMZ_Any;
23 version (SPARC) version = SPARC_Any;
24 version (SPARC64) version = SPARC_Any;
25 version (SystemZ) version = IBMZ_Any;
26
27 version (X86_64)
28 {
29 version (D_X32)
30 enum __NR_perf_event_open = 0x40000000 + 298;
31 else
32 enum __NR_perf_event_open = 298;
33 }
34 else version (X86)
35 {
36 enum __NR_perf_event_open = 336;
37 }
38 else version (ARM)
39 {
40 enum __NR_perf_event_open = 364;
41 }
42 else version (AArch64)
43 {
44 enum __NR_perf_event_open = 241;
45 }
46 else version (HPPA_Any)
47 {
48 enum __NR_perf_event_open = 318;
49 }
50 else version (IBMZ_Any)
51 {
52 enum __NR_perf_event_open = 331;
53 }
54 else version (MIPS32)
55 {
56 enum __NR_perf_event_open = 4333;
57 }
58 else version (MIPS64)
59 {
60 version (MIPS_N32)
61 enum __NR_perf_event_open = 6296;
62 else version (MIPS_N64)
63 enum __NR_perf_event_open = 5292;
64 else
65 static assert(0, "Architecture not supported");
66 }
67 else version (PPC_Any)
68 {
69 enum __NR_perf_event_open = 319;
70 }
71 else version (RISCV_Any)
72 {
73 enum __NR_perf_event_open = 241;
74 }
75 else version (SPARC_Any)
76 {
77 enum __NR_perf_event_open = 327;
78 }
79 else version (LoongArch64)
80 {
81 enum __NR_perf_event_open = 241;
82 }
83 else
84 {
85 static assert(0, "Architecture not supported");
86 }
87 extern (C) extern long syscall(long __sysno, ...);
88 static long perf_event_open(perf_event_attr* hw_event, pid_t pid, int cpu, int group_fd, ulong flags)
89 {
90 return syscall(__NR_perf_event_open, hw_event, pid, cpu, group_fd, flags);
91 }
92 /*
93 * User-space ABI bits:
94 */
95
96 /**
97 * attr.type
98 */
99 enum perf_type_id
100 {
101 PERF_TYPE_HARDWARE = 0,
102 PERF_TYPE_SOFTWARE = 1,
103 PERF_TYPE_TRACEPOINT = 2,
104 PERF_TYPE_HW_CACHE = 3,
105 PERF_TYPE_RAW = 4,
106 PERF_TYPE_BREAKPOINT = 5,
107
108 PERF_TYPE_MAX = 6 /* non-ABI */
109 }
110 /**
111 * Generalized performance event event_id types, used by the
112 * attr.event_id parameter of the sys_perf_event_open()
113 * syscall:
114 */
115 enum perf_hw_id
116 {
117 ///
118 PERF_COUNT_HW_CPU_CYCLES = 0,
119 ///
120 PERF_COUNT_HW_INSTRUCTIONS = 1,
121 ///
122 PERF_COUNT_HW_CACHE_REFERENCES = 2,
123 ///
124 PERF_COUNT_HW_CACHE_MISSES = 3,
125 ///
126 PERF_COUNT_HW_BRANCH_INSTRUCTIONS = 4,
127 ///
128 PERF_COUNT_HW_BRANCH_MISSES = 5,
129 ///
130 PERF_COUNT_HW_BUS_CYCLES = 6,
131 ///
132 PERF_COUNT_HW_STALLED_CYCLES_FRONTEND = 7,
133 ///
134 PERF_COUNT_HW_STALLED_CYCLES_BACKEND = 8,
135 ///
136 PERF_COUNT_HW_REF_CPU_CYCLES = 9,
137 ///
138 PERF_COUNT_HW_MAX = 10 /* non-ABI */
139 }
140
141 /**
142 * Generalized hardware cache events:
143 *
144 * { L1-D, L1-I, LLC, ITLB, DTLB, BPU, NODE } x
145 * { read, write, prefetch } x
146 * { accesses, misses }
147 */
148 enum perf_hw_cache_id
149 {
150 ///
151 PERF_COUNT_HW_CACHE_L1D = 0,
152 ///
153 PERF_COUNT_HW_CACHE_L1I = 1,
154 ///
155 PERF_COUNT_HW_CACHE_LL = 2,
156 ///
157 PERF_COUNT_HW_CACHE_DTLB = 3,
158 ///
159 PERF_COUNT_HW_CACHE_ITLB = 4,
160 ///
161 PERF_COUNT_HW_CACHE_BPU = 5,
162 ///
163 PERF_COUNT_HW_CACHE_NODE = 6,
164 ///
165 PERF_COUNT_HW_CACHE_MAX = 7 /* non-ABI */
166 }
167 ///
168 enum perf_hw_cache_op_id
169 {
170 ///
171 PERF_COUNT_HW_CACHE_OP_READ = 0,
172 ///
173 PERF_COUNT_HW_CACHE_OP_WRITE = 1,
174 ///
175 PERF_COUNT_HW_CACHE_OP_PREFETCH = 2,
176 ///
177 PERF_COUNT_HW_CACHE_OP_MAX = 3 /* non-ABI */
178 }
179 ///
180 enum perf_hw_cache_op_result_id
181 {
182 ///
183 PERF_COUNT_HW_CACHE_RESULT_ACCESS = 0,
184 ///
185 PERF_COUNT_HW_CACHE_RESULT_MISS = 1,
186 ///
187 PERF_COUNT_HW_CACHE_RESULT_MAX = 2 /* non-ABI */
188 }
189
190 /**
191 * Special "software" events provided by the kernel, even if the hardware
192 * does not support performance events. These events measure various
193 * physical and sw events of the kernel (and allow the profiling of them as
194 * well):
195 */
196 enum perf_sw_ids
197 {
198 ///
199 PERF_COUNT_SW_CPU_CLOCK = 0,
200 ///
201 PERF_COUNT_SW_TASK_CLOCK = 1,
202 ///
203 PERF_COUNT_SW_PAGE_FAULTS = 2,
204 ///
205 PERF_COUNT_SW_CONTEXT_SWITCHES = 3,
206 ///
207 PERF_COUNT_SW_CPU_MIGRATIONS = 4,
208 ///
209 PERF_COUNT_SW_PAGE_FAULTS_MIN = 5,
210 ///
211 PERF_COUNT_SW_PAGE_FAULTS_MAJ = 6,
212 ///
213 PERF_COUNT_SW_ALIGNMENT_FAULTS = 7,
214 ///
215 PERF_COUNT_SW_EMULATION_FAULTS = 8,
216 ///
217 PERF_COUNT_SW_DUMMY = 9,
218 ///
219 PERF_COUNT_SW_BPF_OUTPUT = 10,
220 ///
221 PERF_COUNT_SW_MAX = 11 /* non-ABI */
222 }
223
224 /**
225 * Bits that can be set in attr.sample_type to request information
226 * in the overflow packets.
227 */
228 enum perf_event_sample_format
229 {
230 ///
231 PERF_SAMPLE_IP = 1U << 0,
232 ///
233 PERF_SAMPLE_TID = 1U << 1,
234 ///
235 PERF_SAMPLE_TIME = 1U << 2,
236 ///
237 PERF_SAMPLE_ADDR = 1U << 3,
238 ///
239 PERF_SAMPLE_READ = 1U << 4,
240 ///
241 PERF_SAMPLE_CALLCHAIN = 1U << 5,
242 ///
243 PERF_SAMPLE_ID = 1U << 6,
244 ///
245 PERF_SAMPLE_CPU = 1U << 7,
246 ///
247 PERF_SAMPLE_PERIOD = 1U << 8,
248 ///
249 PERF_SAMPLE_STREAM_ID = 1U << 9,
250 ///
251 PERF_SAMPLE_RAW = 1U << 10,
252 ///
253 PERF_SAMPLE_BRANCH_STACK = 1U << 11,
254 ///
255 PERF_SAMPLE_REGS_USER = 1U << 12,
256 ///
257 PERF_SAMPLE_STACK_USER = 1U << 13,
258 ///
259 PERF_SAMPLE_WEIGHT = 1U << 14,
260 ///
261 PERF_SAMPLE_DATA_SRC = 1U << 15,
262 ///
263 PERF_SAMPLE_IDENTIFIER = 1U << 16,
264 ///
265 PERF_SAMPLE_TRANSACTION = 1U << 17,
266 ///
267 PERF_SAMPLE_REGS_INTR = 1U << 18,
268 ///
269 PERF_SAMPLE_PHYS_ADDR = 1U << 19,
270 ///
271 PERF_SAMPLE_MAX = 1U << 20 /* non-ABI */
272 }
273
274 /**
275 * values to program into branch_sample_type when PERF_SAMPLE_BRANCH is set
276 *
277 * If the user does not pass priv level information via branch_sample_type,
278 * the kernel uses the event's priv level. Branch and event priv levels do
279 * not have to match. Branch priv level is checked for permissions.
280 *
281 * The branch types can be combined, however BRANCH_ANY covers all types
282 * of branches and therefore it supersedes all the other types.
283 */
284 enum perf_branch_sample_type_shift
285 {
286 PERF_SAMPLE_BRANCH_USER_SHIFT = 0, /** user branches */
287 PERF_SAMPLE_BRANCH_KERNEL_SHIFT = 1, /** kernel branches */
288 PERF_SAMPLE_BRANCH_HV_SHIFT = 2, /** hypervisor branches */
289
290 PERF_SAMPLE_BRANCH_ANY_SHIFT = 3, /** any branch types */
291 PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT = 4, /** any call branch */
292 PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT = 5, /** any return branch */
293 PERF_SAMPLE_BRANCH_IND_CALL_SHIFT = 6, /** indirect calls */
294 PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT = 7, /** transaction aborts */
295 PERF_SAMPLE_BRANCH_IN_TX_SHIFT = 8, /** in transaction */
296 PERF_SAMPLE_BRANCH_NO_TX_SHIFT = 9, /** not in transaction */
297 PERF_SAMPLE_BRANCH_COND_SHIFT = 10, /** conditional branches */
298
299 PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT = 11, /** call/ret stack */
300 PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT = 12, /** indirect jumps */
301 PERF_SAMPLE_BRANCH_CALL_SHIFT = 13, /** direct call */
302
303 PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT = 14, /** no flags */
304 PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT = 15, /** no cycles */
305
306 PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT = 16, /** save branch type */
307
308 PERF_SAMPLE_BRANCH_MAX_SHIFT = 17 /** non-ABI */
309 }
310 ///
311 enum perf_branch_sample_type
312 {
313 PERF_SAMPLE_BRANCH_USER = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_USER_SHIFT,
314 PERF_SAMPLE_BRANCH_KERNEL = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_KERNEL_SHIFT,
315 PERF_SAMPLE_BRANCH_HV = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_HV_SHIFT,
316 PERF_SAMPLE_BRANCH_ANY = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_ANY_SHIFT,
317 PERF_SAMPLE_BRANCH_ANY_CALL = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_ANY_CALL_SHIFT,
318 PERF_SAMPLE_BRANCH_ANY_RETURN = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_ANY_RETURN_SHIFT,
319 PERF_SAMPLE_BRANCH_IND_CALL = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_IND_CALL_SHIFT,
320 PERF_SAMPLE_BRANCH_ABORT_TX = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_ABORT_TX_SHIFT,
321 PERF_SAMPLE_BRANCH_IN_TX = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_IN_TX_SHIFT,
322 PERF_SAMPLE_BRANCH_NO_TX = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_NO_TX_SHIFT,
323 PERF_SAMPLE_BRANCH_COND = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_COND_SHIFT,
324 PERF_SAMPLE_BRANCH_CALL_STACK = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_CALL_STACK_SHIFT,
325 PERF_SAMPLE_BRANCH_IND_JUMP = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_IND_JUMP_SHIFT,
326 PERF_SAMPLE_BRANCH_CALL = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_CALL_SHIFT,
327 PERF_SAMPLE_BRANCH_NO_FLAGS = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_NO_FLAGS_SHIFT,
328 PERF_SAMPLE_BRANCH_NO_CYCLES = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_NO_CYCLES_SHIFT,
329 PERF_SAMPLE_BRANCH_TYPE_SAVE = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_TYPE_SAVE_SHIFT,
330 PERF_SAMPLE_BRANCH_MAX = 1U << perf_branch_sample_type_shift.PERF_SAMPLE_BRANCH_MAX_SHIFT
331 }
332
333 /**
334 * Common flow change classification
335 */
336 enum
337 {
338 PERF_BR_UNKNOWN = 0, /** unknown */
339 PERF_BR_COND = 1, /** conditional */
340 PERF_BR_UNCOND = 2, /** unconditional */
341 PERF_BR_IND = 3, /** indirect */
342 PERF_BR_CALL = 4, /** function call */
343 PERF_BR_IND_CALL = 5, /** indirect function call */
344 PERF_BR_RET = 6, /** function return */
345 PERF_BR_SYSCALL = 7, /** syscall */
346 PERF_BR_SYSRET = 8, /** syscall return */
347 PERF_BR_COND_CALL = 9, /** conditional function call */
348 PERF_BR_COND_RET = 10, /** conditional function return */
349 PERF_BR_MAX = 11
350 }
351
352 ///
353 enum PERF_SAMPLE_BRANCH_PLM_ALL = perf_branch_sample_type.PERF_SAMPLE_BRANCH_USER
354 | perf_branch_sample_type.PERF_SAMPLE_BRANCH_KERNEL
355 | perf_branch_sample_type.PERF_SAMPLE_BRANCH_HV;
356
357 /**
358 * Values to determine ABI of the registers dump.
359 */
360 enum perf_sample_regs_abi
361 {
362 ///
363 PERF_SAMPLE_REGS_ABI_NONE = 0,
364 ///
365 PERF_SAMPLE_REGS_ABI_32 = 1,
366 ///
367 PERF_SAMPLE_REGS_ABI_64 = 2
368 }
369
370 /**
371 * Values for the memory transaction event qualifier, mostly for
372 * abort events. Multiple bits can be set.
373 */
374 enum
375 {
376 PERF_TXN_ELISION = 1 << 0, /** From elision */
377 PERF_TXN_TRANSACTION = 1 << 1, /** From transaction */
378 PERF_TXN_SYNC = 1 << 2, /** Instruction is related */
379 PERF_TXN_ASYNC = 1 << 3, /** Instruction not related */
380 PERF_TXN_RETRY = 1 << 4, /** Retry possible */
381 PERF_TXN_CONFLICT = 1 << 5, /** Conflict abort */
382 PERF_TXN_CAPACITY_WRITE = 1 << 6, /** Capacity write abort */
383 PERF_TXN_CAPACITY_READ = 1 << 7, /** Capacity read abort */
384
385 PERF_TXN_MAX = 1 << 8, /** non-ABI */
386
387 /** bits 32..63 are reserved for the abort code */
388
389 ///PERF_TXN_ABORT_MASK = 0xffffffff << 32,
390 PERF_TXN_ABORT_SHIFT = 32
391 }
392
393 /**
394 * The format of the data returned by read() on a perf event fd,
395 * as specified by attr.read_format:
396 * ---
397 * struct read_format {
398 * { u64 value;
399 * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
400 * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
401 * { u64 id; } && PERF_FORMAT_ID
402 * } && !PERF_FORMAT_GROUP
403 *
404 * { u64 nr;
405 * { u64 time_enabled; } && PERF_FORMAT_TOTAL_TIME_ENABLED
406 * { u64 time_running; } && PERF_FORMAT_TOTAL_TIME_RUNNING
407 * { u64 value;
408 * { u64 id; } && PERF_FORMAT_ID
409 * } cntr[nr];
410 * } && PERF_FORMAT_GROUP
411 * };
412 * ---
413 */
414 enum perf_event_read_format
415 {
416 ///
417 PERF_FORMAT_TOTAL_TIME_ENABLED = 1U << 0,
418 ///
419 PERF_FORMAT_TOTAL_TIME_RUNNING = 1U << 1,
420 ///
421 PERF_FORMAT_ID = 1U << 2,
422 ///
423 PERF_FORMAT_GROUP = 1U << 3,
424 PERF_FORMAT_MAX = 1U << 4 /** non-ABI */
425 }
426
427 enum PERF_ATTR_SIZE_VER0 = 64; /** sizeof first published struct */
428 enum PERF_ATTR_SIZE_VER1 = 72; /** add: config2 */
429 enum PERF_ATTR_SIZE_VER2 = 80; /** add: branch_sample_type */
430 enum PERF_ATTR_SIZE_VER3 = 96; /** add: sample_regs_user */
431 /* add: sample_stack_user */
432 enum PERF_ATTR_SIZE_VER4 = 104; /** add: sample_regs_intr */
433 enum PERF_ATTR_SIZE_VER5 = 112; /** add: aux_watermark */
434
435 /**
436 * Hardware event_id to monitor via a performance monitoring event:
437 *
438 * @sample_max_stack: Max number of frame pointers in a callchain,
439 * should be < /proc/sys/kernel/perf_event_max_stack
440 */
441 struct perf_event_attr
442 {
443 /**
444 *Major type: hardware/software/tracepoint/etc.
445 */
446 uint type;
447
448 /**
449 * Size of the attr structure, for fwd/bwd compat.
450 */
451 uint size;
452
453 /**
454 * Type specific configuration information.
455 */
456 ulong config;
457 ///
458 union
459 {
460 ///
461 ulong sample_period;
462 ///
463 ulong sample_freq;
464 }
465 ///
466 ulong sample_type;
467 ///
468 ulong read_format;
469
470 // mixin(bitfields!(
471 // ulong, "disabled", 1,
472 // ulong, "inherit", 1,
473 // ulong, "pinned", 1,
474 // ulong, "exclusive", 1,
475 // ulong, "exclude_user", 1,
476 // ulong, "exclude_kernel", 1,
477 // ulong, "exclude_hv", 1,
478 // ulong, "exclude_idle", 1,
479 // ulong, "mmap", 1,
480 // ulong, "comm", 1,
481 // ulong, "freq", 1,
482 // ulong, "inherit_stat", 1,
483 // ulong, "enable_on_exec", 1,
484 // ulong, "task", 1,
485 // ulong, "watermark", 1,
486 // ulong, "precise_ip", 2,
487 // ulong, "mmap_data", 1,
488 // ulong, "sample_id_all", 1,
489 // ulong, "exclude_host", 1,
490 // ulong, "exclude_guest", 1,
491 // ulong, "exclude_callchain_kernel", 1,
492 // ulong, "exclude_callchain_user", 1,
493 // ulong, "mmap2", 1,
494 // ulong, "comm_exec", 1,
495 // ulong, "use_clockid", 1,
496 // ulong, "context_switch", 1,
497 // ulong, "write_backward", 1,
498 // ulong, "namespaces", 1,
499 // ulong, "__reserved_1", 35));
500 private ulong perf_event_attr_bitmanip;
501 ///
502 @property ulong disabled() @safe pure nothrow @nogc const
503 {
504 auto result = (perf_event_attr_bitmanip & 1U) >> 0U;
505 return cast(ulong) result;
506 }
507 ///
508 @property void disabled(ulong v) @safe pure nothrow @nogc
509 {
510 assert(v >= disabled_min,
511 "Value is smaller than the minimum value of bitfield 'disabled'");
512 assert(v <= disabled_max,
513 "Value is greater than the maximum value of bitfield 'disabled'");
514 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
515 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 1U)) | (
516 (cast(typeof(perf_event_attr_bitmanip)) v << 0U) & 1U));
517 }
518
519 enum ulong disabled_min = cast(ulong) 0U;
520 enum ulong disabled_max = cast(ulong) 1U;
521 ///
522 @property ulong inherit() @safe pure nothrow @nogc const
523 {
524 auto result = (perf_event_attr_bitmanip & 2U) >> 1U;
525 return cast(ulong) result;
526 }
527 ///
528 @property void inherit(ulong v) @safe pure nothrow @nogc
529 {
530 assert(v >= inherit_min,
531 "Value is smaller than the minimum value of bitfield 'inherit'");
532 assert(v <= inherit_max,
533 "Value is greater than the maximum value of bitfield 'inherit'");
534 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
535 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 2U)) | (
536 (cast(typeof(perf_event_attr_bitmanip)) v << 1U) & 2U));
537 }
538
539 enum ulong inherit_min = cast(ulong) 0U;
540 enum ulong inherit_max = cast(ulong) 1U;
541 ///
542 @property ulong pinned() @safe pure nothrow @nogc const
543 {
544 auto result = (perf_event_attr_bitmanip & 4U) >> 2U;
545 return cast(ulong) result;
546 }
547 ///
548 @property void pinned(ulong v) @safe pure nothrow @nogc
549 {
550 assert(v >= pinned_min,
551 "Value is smaller than the minimum value of bitfield 'pinned'");
552 assert(v <= pinned_max,
553 "Value is greater than the maximum value of bitfield 'pinned'");
554 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
555 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 4U)) | (
556 (cast(typeof(perf_event_attr_bitmanip)) v << 2U) & 4U));
557 }
558
559 enum ulong pinned_min = cast(ulong) 0U;
560 enum ulong pinned_max = cast(ulong) 1U;
561 ///
562 @property ulong exclusive() @safe pure nothrow @nogc const
563 {
564 auto result = (perf_event_attr_bitmanip & 8U) >> 3U;
565 return cast(ulong) result;
566 }
567 ///
568 @property void exclusive(ulong v) @safe pure nothrow @nogc
569 {
570 assert(v >= exclusive_min,
571 "Value is smaller than the minimum value of bitfield 'exclusive'");
572 assert(v <= exclusive_max,
573 "Value is greater than the maximum value of bitfield 'exclusive'");
574 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
575 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 8U)) | (
576 (cast(typeof(perf_event_attr_bitmanip)) v << 3U) & 8U));
577 }
578
579 enum ulong exclusive_min = cast(ulong) 0U;
580 enum ulong exclusive_max = cast(ulong) 1U;
581 ///
582 @property ulong exclude_user() @safe pure nothrow @nogc const
583 {
584 auto result = (perf_event_attr_bitmanip & 16U) >> 4U;
585 return cast(ulong) result;
586 }
587 ///
588 @property void exclude_user(ulong v) @safe pure nothrow @nogc
589 {
590 assert(v >= exclude_user_min,
591 "Value is smaller than the minimum value of bitfield 'exclude_user'");
592 assert(v <= exclude_user_max,
593 "Value is greater than the maximum value of bitfield 'exclude_user'");
594 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
595 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 16U)) | (
596 (cast(typeof(perf_event_attr_bitmanip)) v << 4U) & 16U));
597 }
598
599 enum ulong exclude_user_min = cast(ulong) 0U;
600 enum ulong exclude_user_max = cast(ulong) 1U;
601 ///
602 @property ulong exclude_kernel() @safe pure nothrow @nogc const
603 {
604 auto result = (perf_event_attr_bitmanip & 32U) >> 5U;
605 return cast(ulong) result;
606 }
607 ///
608 @property void exclude_kernel(ulong v) @safe pure nothrow @nogc
609 {
610 assert(v >= exclude_kernel_min,
611 "Value is smaller than the minimum value of bitfield 'exclude_kernel'");
612 assert(v <= exclude_kernel_max,
613 "Value is greater than the maximum value of bitfield 'exclude_kernel'");
614 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
615 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 32U)) | (
616 (cast(typeof(perf_event_attr_bitmanip)) v << 5U) & 32U));
617 }
618
619 enum ulong exclude_kernel_min = cast(ulong) 0U;
620 enum ulong exclude_kernel_max = cast(ulong) 1U;
621 ///
622 @property ulong exclude_hv() @safe pure nothrow @nogc const
623 {
624 auto result = (perf_event_attr_bitmanip & 64U) >> 6U;
625 return cast(ulong) result;
626 }
627 ///
628 @property void exclude_hv(ulong v) @safe pure nothrow @nogc
629 {
630 assert(v >= exclude_hv_min,
631 "Value is smaller than the minimum value of bitfield 'exclude_hv'");
632 assert(v <= exclude_hv_max,
633 "Value is greater than the maximum value of bitfield 'exclude_hv'");
634 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
635 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 64U)) | (
636 (cast(typeof(perf_event_attr_bitmanip)) v << 6U) & 64U));
637 }
638
639 enum ulong exclude_hv_min = cast(ulong) 0U;
640 enum ulong exclude_hv_max = cast(ulong) 1U;
641 ///
642 @property ulong exclude_idle() @safe pure nothrow @nogc const
643 {
644 auto result = (perf_event_attr_bitmanip & 128U) >> 7U;
645 return cast(ulong) result;
646 }
647 ///
648 @property void exclude_idle(ulong v) @safe pure nothrow @nogc
649 {
650 assert(v >= exclude_idle_min,
651 "Value is smaller than the minimum value of bitfield 'exclude_idle'");
652 assert(v <= exclude_idle_max,
653 "Value is greater than the maximum value of bitfield 'exclude_idle'");
654 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
655 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 128U)) | (
656 (cast(typeof(perf_event_attr_bitmanip)) v << 7U) & 128U));
657 }
658
659 enum ulong exclude_idle_min = cast(ulong) 0U;
660 enum ulong exclude_idle_max = cast(ulong) 1U;
661 ///
662 @property ulong mmap() @safe pure nothrow @nogc const
663 {
664 auto result = (perf_event_attr_bitmanip & 256U) >> 8U;
665 return cast(ulong) result;
666 }
667 ///
668 @property void mmap(ulong v) @safe pure nothrow @nogc
669 {
670 assert(v >= mmap_min, "Value is smaller than the minimum value of bitfield 'mmap'");
671 assert(v <= mmap_max, "Value is greater than the maximum value of bitfield 'mmap'");
672 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
673 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 256U)) | (
674 (cast(typeof(perf_event_attr_bitmanip)) v << 8U) & 256U));
675 }
676
677 enum ulong mmap_min = cast(ulong) 0U;
678 enum ulong mmap_max = cast(ulong) 1U;
679 ///
680 @property ulong comm() @safe pure nothrow @nogc const
681 {
682 auto result = (perf_event_attr_bitmanip & 512U) >> 9U;
683 return cast(ulong) result;
684 }
685 ///
686 @property void comm(ulong v) @safe pure nothrow @nogc
687 {
688 assert(v >= comm_min, "Value is smaller than the minimum value of bitfield 'comm'");
689 assert(v <= comm_max, "Value is greater than the maximum value of bitfield 'comm'");
690 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
691 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 512U)) | (
692 (cast(typeof(perf_event_attr_bitmanip)) v << 9U) & 512U));
693 }
694
695 enum ulong comm_min = cast(ulong) 0U;
696 enum ulong comm_max = cast(ulong) 1U;
697 ///
698 @property ulong freq() @safe pure nothrow @nogc const
699 {
700 auto result = (perf_event_attr_bitmanip & 1024U) >> 10U;
701 return cast(ulong) result;
702 }
703 ///
704 @property void freq(ulong v) @safe pure nothrow @nogc
705 {
706 assert(v >= freq_min, "Value is smaller than the minimum value of bitfield 'freq'");
707 assert(v <= freq_max, "Value is greater than the maximum value of bitfield 'freq'");
708 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
709 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 1024U)) | (
710 (cast(typeof(perf_event_attr_bitmanip)) v << 10U) & 1024U));
711 }
712
713 enum ulong freq_min = cast(ulong) 0U;
714 enum ulong freq_max = cast(ulong) 1U;
715 ///
716 @property ulong inherit_stat() @safe pure nothrow @nogc const
717 {
718 auto result = (perf_event_attr_bitmanip & 2048U) >> 11U;
719 return cast(ulong) result;
720 }
721 ///
722 @property void inherit_stat(ulong v) @safe pure nothrow @nogc
723 {
724 assert(v >= inherit_stat_min,
725 "Value is smaller than the minimum value of bitfield 'inherit_stat'");
726 assert(v <= inherit_stat_max,
727 "Value is greater than the maximum value of bitfield 'inherit_stat'");
728 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
729 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 2048U)) | (
730 (cast(typeof(perf_event_attr_bitmanip)) v << 11U) & 2048U));
731 }
732
733 enum ulong inherit_stat_min = cast(ulong) 0U;
734 enum ulong inherit_stat_max = cast(ulong) 1U;
735 ///
736 @property ulong enable_on_exec() @safe pure nothrow @nogc const
737 {
738 auto result = (perf_event_attr_bitmanip & 4096U) >> 12U;
739 return cast(ulong) result;
740 }
741 ///
742 @property void enable_on_exec(ulong v) @safe pure nothrow @nogc
743 {
744 assert(v >= enable_on_exec_min,
745 "Value is smaller than the minimum value of bitfield 'enable_on_exec'");
746 assert(v <= enable_on_exec_max,
747 "Value is greater than the maximum value of bitfield 'enable_on_exec'");
748 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
749 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 4096U)) | (
750 (cast(typeof(perf_event_attr_bitmanip)) v << 12U) & 4096U));
751 }
752
753 enum ulong enable_on_exec_min = cast(ulong) 0U;
754 enum ulong enable_on_exec_max = cast(ulong) 1U;
755 ///
756 @property ulong task() @safe pure nothrow @nogc const
757 {
758 auto result = (perf_event_attr_bitmanip & 8192U) >> 13U;
759 return cast(ulong) result;
760 }
761 ///
762 @property void task(ulong v) @safe pure nothrow @nogc
763 {
764 assert(v >= task_min, "Value is smaller than the minimum value of bitfield 'task'");
765 assert(v <= task_max, "Value is greater than the maximum value of bitfield 'task'");
766 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
767 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 8192U)) | (
768 (cast(typeof(perf_event_attr_bitmanip)) v << 13U) & 8192U));
769 }
770
771 enum ulong task_min = cast(ulong) 0U;
772 enum ulong task_max = cast(ulong) 1U;
773 ///
774 @property ulong watermark() @safe pure nothrow @nogc const
775 {
776 auto result = (perf_event_attr_bitmanip & 16384U) >> 14U;
777 return cast(ulong) result;
778 }
779 ///
780 @property void watermark(ulong v) @safe pure nothrow @nogc
781 {
782 assert(v >= watermark_min,
783 "Value is smaller than the minimum value of bitfield 'watermark'");
784 assert(v <= watermark_max,
785 "Value is greater than the maximum value of bitfield 'watermark'");
786 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
787 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 16384U)) | (
788 (cast(typeof(perf_event_attr_bitmanip)) v << 14U) & 16384U));
789 }
790
791 enum ulong watermark_min = cast(ulong) 0U;
792 enum ulong watermark_max = cast(ulong) 1U;
793 ///
794 @property ulong precise_ip() @safe pure nothrow @nogc const
795 {
796 auto result = (perf_event_attr_bitmanip & 98304U) >> 15U;
797 return cast(ulong) result;
798 }
799 ///
800 @property void precise_ip(ulong v) @safe pure nothrow @nogc
801 {
802 assert(v >= precise_ip_min,
803 "Value is smaller than the minimum value of bitfield 'precise_ip'");
804 assert(v <= precise_ip_max,
805 "Value is greater than the maximum value of bitfield 'precise_ip'");
806 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
807 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 98304U)) | (
808 (cast(typeof(perf_event_attr_bitmanip)) v << 15U) & 98304U));
809 }
810
811 enum ulong precise_ip_min = cast(ulong) 0U;
812 enum ulong precise_ip_max = cast(ulong) 3U;
813 ///
814 @property ulong mmap_data() @safe pure nothrow @nogc const
815 {
816 auto result = (perf_event_attr_bitmanip & 131072U) >> 17U;
817 return cast(ulong) result;
818 }
819 ///
820 @property void mmap_data(ulong v) @safe pure nothrow @nogc
821 {
822 assert(v >= mmap_data_min,
823 "Value is smaller than the minimum value of bitfield 'mmap_data'");
824 assert(v <= mmap_data_max,
825 "Value is greater than the maximum value of bitfield 'mmap_data'");
826 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
827 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 131072U)) | (
828 (cast(typeof(perf_event_attr_bitmanip)) v << 17U) & 131072U));
829 }
830
831 enum ulong mmap_data_min = cast(ulong) 0U;
832 enum ulong mmap_data_max = cast(ulong) 1U;
833 ///
834 @property ulong sample_id_all() @safe pure nothrow @nogc const
835 {
836 auto result = (perf_event_attr_bitmanip & 262144U) >> 18U;
837 return cast(ulong) result;
838 }
839 ///
840 @property void sample_id_all(ulong v) @safe pure nothrow @nogc
841 {
842 assert(v >= sample_id_all_min,
843 "Value is smaller than the minimum value of bitfield 'sample_id_all'");
844 assert(v <= sample_id_all_max,
845 "Value is greater than the maximum value of bitfield 'sample_id_all'");
846 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
847 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 262144U)) | (
848 (cast(typeof(perf_event_attr_bitmanip)) v << 18U) & 262144U));
849 }
850
851 enum ulong sample_id_all_min = cast(ulong) 0U;
852 enum ulong sample_id_all_max = cast(ulong) 1U;
853 ///
854 @property ulong exclude_host() @safe pure nothrow @nogc const
855 {
856 auto result = (perf_event_attr_bitmanip & 524288U) >> 19U;
857 return cast(ulong) result;
858 }
859 ///
860 @property void exclude_host(ulong v) @safe pure nothrow @nogc
861 {
862 assert(v >= exclude_host_min,
863 "Value is smaller than the minimum value of bitfield 'exclude_host'");
864 assert(v <= exclude_host_max,
865 "Value is greater than the maximum value of bitfield 'exclude_host'");
866 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
867 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 524288U)) | (
868 (cast(typeof(perf_event_attr_bitmanip)) v << 19U) & 524288U));
869 }
870
871 enum ulong exclude_host_min = cast(ulong) 0U;
872 enum ulong exclude_host_max = cast(ulong) 1U;
873 ///
874 @property ulong exclude_guest() @safe pure nothrow @nogc const
875 {
876 auto result = (perf_event_attr_bitmanip & 1048576U) >> 20U;
877 return cast(ulong) result;
878 }
879 ///
880 @property void exclude_guest(ulong v) @safe pure nothrow @nogc
881 {
882 assert(v >= exclude_guest_min,
883 "Value is smaller than the minimum value of bitfield 'exclude_guest'");
884 assert(v <= exclude_guest_max,
885 "Value is greater than the maximum value of bitfield 'exclude_guest'");
886 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
887 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 1048576U)) | (
888 (cast(typeof(perf_event_attr_bitmanip)) v << 20U) & 1048576U));
889 }
890
891 enum ulong exclude_guest_min = cast(ulong) 0U;
892 enum ulong exclude_guest_max = cast(ulong) 1U;
893 ///
894 @property ulong exclude_callchain_kernel() @safe pure nothrow @nogc const
895 {
896 auto result = (perf_event_attr_bitmanip & 2097152U) >> 21U;
897 return cast(ulong) result;
898 }
899 ///
900 @property void exclude_callchain_kernel(ulong v) @safe pure nothrow @nogc
901 {
902 assert(v >= exclude_callchain_kernel_min,
903 "Value is smaller than the minimum value of bitfield 'exclude_callchain_kernel'");
904 assert(v <= exclude_callchain_kernel_max,
905 "Value is greater than the maximum value of bitfield 'exclude_callchain_kernel'");
906 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
907 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 2097152U)) | (
908 (cast(typeof(perf_event_attr_bitmanip)) v << 21U) & 2097152U));
909 }
910
911 enum ulong exclude_callchain_kernel_min = cast(ulong) 0U;
912 enum ulong exclude_callchain_kernel_max = cast(ulong) 1U;
913 ///
914 @property ulong exclude_callchain_user() @safe pure nothrow @nogc const
915 {
916 auto result = (perf_event_attr_bitmanip & 4194304U) >> 22U;
917 return cast(ulong) result;
918 }
919 ///
920 @property void exclude_callchain_user(ulong v) @safe pure nothrow @nogc
921 {
922 assert(v >= exclude_callchain_user_min,
923 "Value is smaller than the minimum value of bitfield 'exclude_callchain_user'");
924 assert(v <= exclude_callchain_user_max,
925 "Value is greater than the maximum value of bitfield 'exclude_callchain_user'");
926 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
927 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 4194304U)) | (
928 (cast(typeof(perf_event_attr_bitmanip)) v << 22U) & 4194304U));
929 }
930
931 enum ulong exclude_callchain_user_min = cast(ulong) 0U;
932 enum ulong exclude_callchain_user_max = cast(ulong) 1U;
933 ///
934 @property ulong mmap2() @safe pure nothrow @nogc const
935 {
936 auto result = (perf_event_attr_bitmanip & 8388608U) >> 23U;
937 return cast(ulong) result;
938 }
939 ///
940 @property void mmap2(ulong v) @safe pure nothrow @nogc
941 {
942 assert(v >= mmap2_min,
943 "Value is smaller than the minimum value of bitfield 'mmap2'");
944 assert(v <= mmap2_max,
945 "Value is greater than the maximum value of bitfield 'mmap2'");
946 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
947 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 8388608U)) | (
948 (cast(typeof(perf_event_attr_bitmanip)) v << 23U) & 8388608U));
949 }
950
951 enum ulong mmap2_min = cast(ulong) 0U;
952 enum ulong mmap2_max = cast(ulong) 1U;
953 ///
954 @property ulong comm_exec() @safe pure nothrow @nogc const
955 {
956 auto result = (perf_event_attr_bitmanip & 16777216U) >> 24U;
957 return cast(ulong) result;
958 }
959 ///
960 @property void comm_exec(ulong v) @safe pure nothrow @nogc
961 {
962 assert(v >= comm_exec_min,
963 "Value is smaller than the minimum value of bitfield 'comm_exec'");
964 assert(v <= comm_exec_max,
965 "Value is greater than the maximum value of bitfield 'comm_exec'");
966 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
967 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 16777216U)) | (
968 (cast(typeof(perf_event_attr_bitmanip)) v << 24U) & 16777216U));
969 }
970
971 enum ulong comm_exec_min = cast(ulong) 0U;
972 enum ulong comm_exec_max = cast(ulong) 1U;
973 ///
974 @property ulong use_clockid() @safe pure nothrow @nogc const
975 {
976 auto result = (perf_event_attr_bitmanip & 33554432U) >> 25U;
977 return cast(ulong) result;
978 }
979 ///
980 @property void use_clockid(ulong v) @safe pure nothrow @nogc
981 {
982 assert(v >= use_clockid_min,
983 "Value is smaller than the minimum value of bitfield 'use_clockid'");
984 assert(v <= use_clockid_max,
985 "Value is greater than the maximum value of bitfield 'use_clockid'");
986 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
987 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 33554432U)) | (
988 (cast(typeof(perf_event_attr_bitmanip)) v << 25U) & 33554432U));
989 }
990
991 enum ulong use_clockid_min = cast(ulong) 0U;
992 enum ulong use_clockid_max = cast(ulong) 1U;
993 ///
994 @property ulong context_switch() @safe pure nothrow @nogc const
995 {
996 auto result = (perf_event_attr_bitmanip & 67108864U) >> 26U;
997 return cast(ulong) result;
998 }
999 ///
1000 @property void context_switch(ulong v) @safe pure nothrow @nogc
1001 {
1002 assert(v >= context_switch_min,
1003 "Value is smaller than the minimum value of bitfield 'context_switch'");
1004 assert(v <= context_switch_max,
1005 "Value is greater than the maximum value of bitfield 'context_switch'");
1006 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
1007 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 67108864U)) | (
1008 (cast(typeof(perf_event_attr_bitmanip)) v << 26U) & 67108864U));
1009 }
1010
1011 enum ulong context_switch_min = cast(ulong) 0U;
1012 enum ulong context_switch_max = cast(ulong) 1U;
1013 ///
1014 @property ulong write_backward() @safe pure nothrow @nogc const
1015 {
1016 auto result = (perf_event_attr_bitmanip & 134217728U) >> 27U;
1017 return cast(ulong) result;
1018 }
1019 ///
1020 @property void write_backward(ulong v) @safe pure nothrow @nogc
1021 {
1022 assert(v >= write_backward_min,
1023 "Value is smaller than the minimum value of bitfield 'write_backward'");
1024 assert(v <= write_backward_max,
1025 "Value is greater than the maximum value of bitfield 'write_backward'");
1026 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
1027 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 134217728U)) | (
1028 (cast(typeof(perf_event_attr_bitmanip)) v << 27U) & 134217728U));
1029 }
1030
1031 enum ulong write_backward_min = cast(ulong) 0U;
1032 enum ulong write_backward_max = cast(ulong) 1U;
1033 ///
1034 @property ulong namespaces() @safe pure nothrow @nogc const
1035 {
1036 auto result = (perf_event_attr_bitmanip & 268435456U) >> 28U;
1037 return cast(ulong) result;
1038 }
1039 ///
1040 @property void namespaces(ulong v) @safe pure nothrow @nogc
1041 {
1042 assert(v >= namespaces_min,
1043 "Value is smaller than the minimum value of bitfield 'namespaces'");
1044 assert(v <= namespaces_max,
1045 "Value is greater than the maximum value of bitfield 'namespaces'");
1046 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
1047 (perf_event_attr_bitmanip & (-1 - cast(typeof(perf_event_attr_bitmanip)) 268435456U)) | (
1048 (cast(typeof(perf_event_attr_bitmanip)) v << 28U) & 268435456U));
1049 }
1050
1051 enum ulong namespaces_min = cast(ulong) 0U;
1052 enum ulong namespaces_max = cast(ulong) 1U;
1053 ///
1054 @property ulong __reserved_1() @safe pure nothrow @nogc const
1055 {
1056 auto result = (perf_event_attr_bitmanip & 18446744073172680704UL) >> 29U;
1057 return cast(ulong) result;
1058 }
1059 ///
1060 @property void __reserved_1(ulong v) @safe pure nothrow @nogc
1061 {
1062 assert(v >= __reserved_1_min,
1063 "Value is smaller than the minimum value of bitfield '__reserved_1'");
1064 assert(v <= __reserved_1_max,
1065 "Value is greater than the maximum value of bitfield '__reserved_1'");
1066 perf_event_attr_bitmanip = cast(typeof(perf_event_attr_bitmanip))(
1067 (perf_event_attr_bitmanip & (-1 - cast(
1068 typeof(perf_event_attr_bitmanip)) 18446744073172680704UL)) | (
1069 (cast(typeof(perf_event_attr_bitmanip)) v << 29U) & 18446744073172680704UL));
1070 }
1071
1072 enum ulong __reserved_1_min = cast(ulong) 0U;
1073 enum ulong __reserved_1_max = cast(ulong) 34359738367UL;
1074 ///
1075 union
1076 {
1077 uint wakeup_events; /** wakeup every n events */
1078 uint wakeup_watermark; /** bytes before wakeup */
1079 }
1080 ///
1081 uint bp_type;
1082
1083 union
1084 {
1085 ///
1086 ulong bp_addr;
1087 ulong config1; /** extension of config */
1088 }
1089
1090 union
1091 {
1092 ///
1093 ulong bp_len;
1094 ulong config2; /** extension of config1 */
1095 }
1096
1097 ulong branch_sample_type; /** enum perf_branch_sample_type */
1098
1099 /**
1100 * Defines set of user regs to dump on samples.
1101 * See asm/perf_regs.h for details.
1102 */
1103 ulong sample_regs_user;
1104
1105 /**
1106 * Defines size of the user stack to dump on samples.
1107 */
1108 uint sample_stack_user;
1109 ///
1110 int clockid;
1111
1112 /**
1113 * Defines set of regs to dump for each sample
1114 * state captured on:
1115 * - precise = 0: PMU interrupt
1116 * - precise > 0: sampled instruction
1117 *
1118 * See asm/perf_regs.h for details.
1119 */
1120 ulong sample_regs_intr;
1121
1122 /**
1123 * Wakeup watermark for AUX area
1124 */
1125 uint aux_watermark;
1126 ///
1127 ushort sample_max_stack;
1128 /** align to __u64 */
1129 ushort __reserved_2;
1130 }
1131 ///
1132 extern (D) auto perf_flags(T)(auto ref T attr)
1133 {
1134 return *(&attr.read_format + 1);
1135 }
1136
1137 /**
1138 * Ioctls that can be done on a perf event fd:
1139 */
1140 enum PERF_EVENT_IOC_ENABLE = _IO('$', 0);
1141 ///
1142 enum PERF_EVENT_IOC_DISABLE = _IO('$', 1);
1143 ///
1144 enum PERF_EVENT_IOC_REFRESH = _IO('$', 2);
1145 ///
1146 enum PERF_EVENT_IOC_RESET = _IO('$', 3);
1147 ///
1148 enum PERF_EVENT_IOC_PERIOD = _IOW!ulong('$', 4);
1149 ///
1150 enum PERF_EVENT_IOC_SET_OUTPUT = _IO('$', 5);
1151 ///
1152 enum PERF_EVENT_IOC_SET_FILTER = _IOW!(char*)('$', 6);
1153 ///
1154 enum PERF_EVENT_IOC_ID = _IOR!(ulong*)('$', 7);
1155 ///
1156 enum PERF_EVENT_IOC_SET_BPF = _IOW!uint('$', 8);
1157 ///
1158 enum PERF_EVENT_IOC_PAUSE_OUTPUT = _IOW!uint('$', 9);
1159
1160 ///
1161 enum perf_event_ioc_flags
1162 {
1163 PERF_IOC_FLAG_GROUP = 1U << 0
1164 }
1165
1166 /**
1167 * Structure of the page that can be mapped via mmap
1168 */
1169 struct perf_event_mmap_page
1170 {
1171 uint version_; /** version number of this structure */
1172 uint compat_version; /** lowest version this is compat with */
1173
1174 /**
1175 * Bits needed to read the hw events in user-space.
1176 * ---
1177 * u32 seq, time_mult, time_shift, index, width;
1178 * u64 count, enabled, running;
1179 * u64 cyc, time_offset;
1180 * s64 pmc = 0;
1181 *
1182 * do {
1183 * seq = pc->lock;
1184 * barrier()
1185 *
1186 * enabled = pc->time_enabled;
1187 * running = pc->time_running;
1188 *
1189 * if (pc->cap_usr_time && enabled != running) {
1190 * cyc = rdtsc();
1191 * time_offset = pc->time_offset;
1192 * time_mult = pc->time_mult;
1193 * time_shift = pc->time_shift;
1194 * }
1195 *
1196 * index = pc->index;
1197 * count = pc->offset;
1198 * if (pc->cap_user_rdpmc && index) {
1199 * width = pc->pmc_width;
1200 * pmc = rdpmc(index - 1);
1201 * }
1202 *
1203 * barrier();
1204 * } while (pc->lock != seq);
1205 * ---
1206 * NOTE: for obvious reason this only works on self-monitoring
1207 * processes.
1208 */
1209 uint lock; /** seqlock for synchronization */
1210 uint index; /** hardware event identifier */
1211 long offset; /** add to hardware event value */
1212 ulong time_enabled; /** time event active */
1213 ulong time_running; /** time event on cpu */
1214 ///
1215 union
1216 {
1217 ///
1218 ulong capabilities;
1219
1220 struct
1221 {
1222 /* mixin(bitfields!(ulong, "cap_bit0", 1, ulong, "cap_bit0_is_deprecated", 1, ulong,
1223 "cap_user_rdpmc", 1, ulong, "cap_user_time", 1, ulong,
1224 "cap_user_time_zero", 1, ulong, "cap_____res", 59)); */
1225
1226 private ulong mmap_page_bitmanip;
1227 ///
1228 @property ulong cap_bit0() @safe pure nothrow @nogc const
1229 {
1230 auto result = (mmap_page_bitmanip & 1U) >> 0U;
1231 return cast(ulong) result;
1232 }
1233 ///
1234 @property void cap_bit0(ulong v) @safe pure nothrow @nogc
1235 {
1236 assert(v >= cap_bit0_min,
1237 "Value is smaller than the minimum value of bitfield 'cap_bit0'");
1238 assert(v <= cap_bit0_max,
1239 "Value is greater than the maximum value of bitfield 'cap_bit0'");
1240 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))(
1241 (mmap_page_bitmanip & (-1 - cast(typeof(mmap_page_bitmanip)) 1U)) | (
1242 (cast(typeof(mmap_page_bitmanip)) v << 0U) & 1U));
1243 }
1244
1245 enum ulong cap_bit0_min = cast(ulong) 0U;
1246 enum ulong cap_bit0_max = cast(ulong) 1U;
1247 ///
1248 @property ulong cap_bit0_is_deprecated() @safe pure nothrow @nogc const
1249 {
1250 auto result = (mmap_page_bitmanip & 2U) >> 1U;
1251 return cast(ulong) result;
1252 }
1253 ///
1254 @property void cap_bit0_is_deprecated(ulong v) @safe pure nothrow @nogc
1255 {
1256 assert(v >= cap_bit0_is_deprecated_min,
1257 "Value is smaller than the minimum value of bitfield 'cap_bit0_is_deprecated'");
1258 assert(v <= cap_bit0_is_deprecated_max,
1259 "Value is greater than the maximum value of bitfield 'cap_bit0_is_deprecated'");
1260 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))(
1261 (mmap_page_bitmanip & (-1 - cast(typeof(mmap_page_bitmanip)) 2U)) | (
1262 (cast(typeof(mmap_page_bitmanip)) v << 1U) & 2U));
1263 }
1264
1265 enum ulong cap_bit0_is_deprecated_min = cast(ulong) 0U;
1266 enum ulong cap_bit0_is_deprecated_max = cast(ulong) 1U;
1267 ///
1268 @property ulong cap_user_rdpmc() @safe pure nothrow @nogc const
1269 {
1270 auto result = (mmap_page_bitmanip & 4U) >> 2U;
1271 return cast(ulong) result;
1272 }
1273 ///
1274 @property void cap_user_rdpmc(ulong v) @safe pure nothrow @nogc
1275 {
1276 assert(v >= cap_user_rdpmc_min,
1277 "Value is smaller than the minimum value of bitfield 'cap_user_rdpmc'");
1278 assert(v <= cap_user_rdpmc_max,
1279 "Value is greater than the maximum value of bitfield 'cap_user_rdpmc'");
1280 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))(
1281 (mmap_page_bitmanip & (-1 - cast(typeof(mmap_page_bitmanip)) 4U)) | (
1282 (cast(typeof(mmap_page_bitmanip)) v << 2U) & 4U));
1283 }
1284
1285 enum ulong cap_user_rdpmc_min = cast(ulong) 0U;
1286 enum ulong cap_user_rdpmc_max = cast(ulong) 1U;
1287 ///
1288 @property ulong cap_user_time() @safe pure nothrow @nogc const
1289 {
1290 auto result = (mmap_page_bitmanip & 8U) >> 3U;
1291 return cast(ulong) result;
1292 }
1293 ///
1294 @property void cap_user_time(ulong v) @safe pure nothrow @nogc
1295 {
1296 assert(v >= cap_user_time_min,
1297 "Value is smaller than the minimum value of bitfield 'cap_user_time'");
1298 assert(v <= cap_user_time_max,
1299 "Value is greater than the maximum value of bitfield 'cap_user_time'");
1300 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))(
1301 (mmap_page_bitmanip & (-1 - cast(typeof(mmap_page_bitmanip)) 8U)) | (
1302 (cast(typeof(mmap_page_bitmanip)) v << 3U) & 8U));
1303 }
1304
1305 enum ulong cap_user_time_min = cast(ulong) 0U;
1306 enum ulong cap_user_time_max = cast(ulong) 1U;
1307 ///
1308 @property ulong cap_user_time_zero() @safe pure nothrow @nogc const
1309 {
1310 auto result = (mmap_page_bitmanip & 16U) >> 4U;
1311 return cast(ulong) result;
1312 }
1313 ///
1314 @property void cap_user_time_zero(ulong v) @safe pure nothrow @nogc
1315 {
1316 assert(v >= cap_user_time_zero_min,
1317 "Value is smaller than the minimum value of bitfield 'cap_user_time_zero'");
1318 assert(v <= cap_user_time_zero_max,
1319 "Value is greater than the maximum value of bitfield 'cap_user_time_zero'");
1320 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))(
1321 (mmap_page_bitmanip & (-1 - cast(typeof(mmap_page_bitmanip)) 16U)) | (
1322 (cast(typeof(mmap_page_bitmanip)) v << 4U) & 16U));
1323 }
1324
1325 enum ulong cap_user_time_zero_min = cast(ulong) 0U;
1326 enum ulong cap_user_time_zero_max = cast(ulong) 1U;
1327 ///
1328 @property ulong cap_____res() @safe pure nothrow @nogc const
1329 {
1330 auto result = (mmap_page_bitmanip & 18446744073709551584UL) >> 5U;
1331 return cast(ulong) result;
1332 }
1333 ///
1334 @property void cap_____res(ulong v) @safe pure nothrow @nogc
1335 {
1336 assert(v >= cap_____res_min,
1337 "Value is smaller than the minimum value of bitfield 'cap_____res'");
1338 assert(v <= cap_____res_max,
1339 "Value is greater than the maximum value of bitfield 'cap_____res'");
1340 mmap_page_bitmanip = cast(typeof(mmap_page_bitmanip))((mmap_page_bitmanip & (
1341 -1 - cast(typeof(mmap_page_bitmanip)) 18446744073709551584UL)) | (
1342 (cast(typeof(mmap_page_bitmanip)) v << 5U) & 18446744073709551584UL));
1343 }
1344
1345 enum ulong cap_____res_min = cast(ulong) 0U;
1346 enum ulong cap_____res_max = cast(ulong) 576460752303423487UL;
1347 }
1348 }
1349
1350 /**
1351 * If cap_user_rdpmc this field provides the bit-width of the value
1352 * read using the rdpmc() or equivalent instruction. This can be used
1353 * to sign extend the result like:
1354 *
1355 * pmc <<= 64 - width;
1356 * pmc >>= 64 - width; // signed shift right
1357 * count += pmc;
1358 */
1359 ushort pmc_width;
1360
1361 /**
1362 * If cap_usr_time the below fields can be used to compute the time
1363 * delta since time_enabled (in ns) using rdtsc or similar.
1364 *
1365 * u64 quot, rem;
1366 * u64 delta;
1367 *
1368 * quot = (cyc >> time_shift);
1369 * rem = cyc & (((u64)1 << time_shift) - 1);
1370 * delta = time_offset + quot * time_mult +
1371 * ((rem * time_mult) >> time_shift);
1372 *
1373 * Where time_offset,time_mult,time_shift and cyc are read in the
1374 * seqcount loop described above. This delta can then be added to
1375 * enabled and possible running (if index), improving the scaling:
1376 *
1377 * enabled += delta;
1378 * if (index)
1379 * running += delta;
1380 *
1381 * quot = count / running;
1382 * rem = count % running;
1383 * count = quot * enabled + (rem * enabled) / running;
1384 */
1385 ushort time_shift;
1386 ///
1387 uint time_mult;
1388 ///
1389 ulong time_offset;
1390 /**
1391 * If cap_usr_time_zero, the hardware clock (e.g. TSC) can be calculated
1392 * from sample timestamps.
1393 *
1394 * time = timestamp - time_zero;
1395 * quot = time / time_mult;
1396 * rem = time % time_mult;
1397 * cyc = (quot << time_shift) + (rem << time_shift) / time_mult;
1398 *
1399 * And vice versa:
1400 *
1401 * quot = cyc >> time_shift;
1402 * rem = cyc & (((u64)1 << time_shift) - 1);
1403 * timestamp = time_zero + quot * time_mult +
1404 * ((rem * time_mult) >> time_shift);
1405 */
1406 ulong time_zero;
1407 uint size; /** Header size up to __reserved[] fields. */
1408
1409 /**
1410 * Hole for extension of the self monitor capabilities
1411 */
1412
1413 ubyte[948] __reserved; /** align to 1k. */
1414
1415 /**
1416 * Control data for the mmap() data buffer.
1417 *
1418 * User-space reading the @data_head value should issue an smp_rmb(),
1419 * after reading this value.
1420 *
1421 * When the mapping is PROT_WRITE the @data_tail value should be
1422 * written by userspace to reflect the last read data, after issueing
1423 * an smp_mb() to separate the data read from the ->data_tail store.
1424 * In this case the kernel will not over-write unread data.
1425 *
1426 * See perf_output_put_handle() for the data ordering.
1427 *
1428 * data_{offset,size} indicate the location and size of the perf record
1429 * buffer within the mmapped area.
1430 */
1431 ulong data_head; /** head in the data section */
1432 ulong data_tail; /** user-space written tail */
1433 ulong data_offset; /** where the buffer starts */
1434 ulong data_size; /** data buffer size */
1435
1436 /**
1437 * AUX area is defined by aux_{offset,size} fields that should be set
1438 * by the userspace, so that
1439 * ---
1440 * aux_offset >= data_offset + data_size
1441 * ---
1442 * prior to mmap()ing it. Size of the mmap()ed area should be aux_size.
1443 *
1444 * Ring buffer pointers aux_{head,tail} have the same semantics as
1445 * data_{head,tail} and same ordering rules apply.
1446 */
1447 ulong aux_head;
1448 ///
1449 ulong aux_tail;
1450 ///
1451 ulong aux_offset;
1452 ///
1453 ulong aux_size;
1454 }
1455 ///
1456 enum PERF_RECORD_MISC_CPUMODE_MASK = 7 << 0;
1457 ///
1458 enum PERF_RECORD_MISC_CPUMODE_UNKNOWN = 0 << 0;
1459 ///
1460 enum PERF_RECORD_MISC_KERNEL = 1 << 0;
1461 ///
1462 enum PERF_RECORD_MISC_USER = 2 << 0;
1463 ///
1464 enum PERF_RECORD_MISC_HYPERVISOR = 3 << 0;
1465 ///
1466 enum PERF_RECORD_MISC_GUEST_KERNEL = 4 << 0;
1467 ///
1468 enum PERF_RECORD_MISC_GUEST_USER = 5 << 0;
1469
1470 /**
1471 * Indicates that /proc/PID/maps parsing are truncated by time out.
1472 */
1473 enum PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT = 1 << 12;
1474 /**
1475 * PERF_RECORD_MISC_MMAP_DATA and PERF_RECORD_MISC_COMM_EXEC are used on
1476 * different events so can reuse the same bit position.
1477 * Ditto PERF_RECORD_MISC_SWITCH_OUT.
1478 */
1479 enum PERF_RECORD_MISC_MMAP_DATA = 1 << 13;
1480 ///
1481 enum PERF_RECORD_MISC_COMM_EXEC = 1 << 13;
1482 ///
1483 enum PERF_RECORD_MISC_SWITCH_OUT = 1 << 13;
1484 /**
1485 * Indicates that the content of PERF_SAMPLE_IP points to
1486 * the actual instruction that triggered the event. See also
1487 * perf_event_attr::precise_ip.
1488 */
1489 enum PERF_RECORD_MISC_EXACT_IP = 1 << 14;
1490 /**
1491 * Reserve the last bit to indicate some extended misc field
1492 */
1493 enum PERF_RECORD_MISC_EXT_RESERVED = 1 << 15;
1494 ///
1495 struct perf_event_header
1496 {
1497 ///
1498 uint type;
1499 ///
1500 ushort misc;
1501 ///
1502 ushort size;
1503 }
1504 ///
1505 struct perf_ns_link_info
1506 {
1507 ///
1508 ulong dev;
1509 ///
1510 ulong ino;
1511 }
1512
1513 enum
1514 {
1515 ///
1516 NET_NS_INDEX = 0,
1517 ///
1518 UTS_NS_INDEX = 1,
1519 ///
1520 IPC_NS_INDEX = 2,
1521 ///
1522 PID_NS_INDEX = 3,
1523 ///
1524 USER_NS_INDEX = 4,
1525 ///
1526 MNT_NS_INDEX = 5,
1527 ///
1528 CGROUP_NS_INDEX = 6,
1529 NR_NAMESPACES = 7 /** number of available namespaces */
1530 }
1531 ///
1532 enum perf_event_type
1533 {
1534 /**
1535 * If perf_event_attr.sample_id_all is set then all event types will
1536 * have the sample_type selected fields related to where/when
1537 * (identity) an event took place (TID, TIME, ID, STREAM_ID, CPU,
1538 * IDENTIFIER) described in PERF_RECORD_SAMPLE below, it will be stashed
1539 * just after the perf_event_header and the fields already present for
1540 * the existing fields, i.e. at the end of the payload. That way a newer
1541 * perf.data file will be supported by older perf tools, with these new
1542 * optional fields being ignored.
1543 * ---
1544 * struct sample_id {
1545 * { u32 pid, tid; } && PERF_SAMPLE_TID
1546 * { u64 time; } && PERF_SAMPLE_TIME
1547 * { u64 id; } && PERF_SAMPLE_ID
1548 * { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
1549 * { u32 cpu, res; } && PERF_SAMPLE_CPU
1550 * { u64 id; } && PERF_SAMPLE_IDENTIFIER
1551 * } && perf_event_attr::sample_id_all
1552 * ---
1553 * Note that PERF_SAMPLE_IDENTIFIER duplicates PERF_SAMPLE_ID. The
1554 * advantage of PERF_SAMPLE_IDENTIFIER is that its position is fixed
1555 * relative to header.size.
1556 */
1557
1558 /*
1559 * The MMAP events record the PROT_EXEC mappings so that we can
1560 * correlate userspace IPs to code. They have the following structure:
1561 * ---
1562 * struct {
1563 * struct perf_event_header header;
1564 *
1565 * u32 pid, tid;
1566 * u64 addr;
1567 * u64 len;
1568 * u64 pgoff;
1569 * char filename[];
1570 * struct sample_id sample_id;
1571 * };
1572 * ---
1573 */
1574 PERF_RECORD_MMAP = 1,
1575
1576 /**
1577 * ---
1578 * struct {
1579 * struct perf_event_header header;
1580 * u64 id;
1581 * u64 lost;
1582 * struct sample_id sample_id;
1583 * };
1584 * ---
1585 */
1586 PERF_RECORD_LOST = 2,
1587
1588 /**
1589 * ---
1590 * struct {
1591 * struct perf_event_header header;
1592 *
1593 * u32 pid, tid;
1594 * char comm[];
1595 * struct sample_id sample_id;
1596 * };
1597 * ---
1598 */
1599 PERF_RECORD_COMM = 3,
1600
1601 /**
1602 * ---
1603 * struct {
1604 * struct perf_event_header header;
1605 * u32 pid, ppid;
1606 * u32 tid, ptid;
1607 * u64 time;
1608 * struct sample_id sample_id;
1609 * };
1610 * ---
1611 */
1612 PERF_RECORD_EXIT = 4,
1613
1614 /**
1615 * ---
1616 * struct {
1617 * struct perf_event_header header;
1618 * u64 time;
1619 * u64 id;
1620 * u64 stream_id;
1621 * struct sample_id sample_id;
1622 * };
1623 * ---
1624 */
1625 PERF_RECORD_THROTTLE = 5,
1626 PERF_RECORD_UNTHROTTLE = 6,
1627 /**
1628 * ---
1629 * struct {
1630 * struct perf_event_header header;
1631 * u32 pid, ppid;
1632 * u32 tid, ptid;
1633 * u64 time;
1634 * struct sample_id sample_id;
1635 * };
1636 * ---
1637 */
1638 PERF_RECORD_FORK = 7,
1639 /**
1640 * ---
1641 * struct {
1642 * struct perf_event_header header;
1643 * u32 pid, tid;
1644 *
1645 * struct read_format values;
1646 * struct sample_id sample_id;
1647 * };
1648 * ---
1649 */
1650 PERF_RECORD_READ = 8,
1651 /**
1652 * ---
1653 * struct {
1654 * struct perf_event_header header;
1655 *
1656 * #
1657 * # Note that PERF_SAMPLE_IDENTIFIER duplicates PERF_SAMPLE_ID.
1658 * # The advantage of PERF_SAMPLE_IDENTIFIER is that its position
1659 * # is fixed relative to header.
1660 * #
1661 *
1662 * { u64 id; } && PERF_SAMPLE_IDENTIFIER
1663 * { u64 ip; } && PERF_SAMPLE_IP
1664 * { u32 pid, tid; } && PERF_SAMPLE_TID
1665 * { u64 time; } && PERF_SAMPLE_TIME
1666 * { u64 addr; } && PERF_SAMPLE_ADDR
1667 * { u64 id; } && PERF_SAMPLE_ID
1668 * { u64 stream_id;} && PERF_SAMPLE_STREAM_ID
1669 * { u32 cpu, res; } && PERF_SAMPLE_CPU
1670 * { u64 period; } && PERF_SAMPLE_PERIOD
1671 *
1672 * { struct read_format values; } && PERF_SAMPLE_READ
1673 *
1674 * { u64 nr,
1675 * u64 ips[nr]; } && PERF_SAMPLE_CALLCHAIN
1676 *
1677 * #
1678 * # The RAW record below is opaque data wrt the ABI
1679 * #
1680 * # That is, the ABI doesn't make any promises wrt to
1681 * # the stability of its content, it may vary depending
1682 * # on event, hardware, kernel version and phase of
1683 * # the moon.
1684 * #
1685 * # In other words, PERF_SAMPLE_RAW contents are not an ABI.
1686 * #
1687 *
1688 * { u32 size;
1689 * char data[size];}&& PERF_SAMPLE_RAW
1690 *
1691 * { u64 nr;
1692 * { u64 from, to, flags } lbr[nr];} && PERF_SAMPLE_BRANCH_STACK
1693 *
1694 * { u64 abi; # enum perf_sample_regs_abi
1695 * u64 regs[weight(mask)]; } && PERF_SAMPLE_REGS_USER
1696 *
1697 * { u64 size;
1698 * char data[size];
1699 * u64 dyn_size; } && PERF_SAMPLE_STACK_USER
1700 *
1701 * { u64 weight; } && PERF_SAMPLE_WEIGHT
1702 * { u64 data_src; } && PERF_SAMPLE_DATA_SRC
1703 * { u64 transaction; } && PERF_SAMPLE_TRANSACTION
1704 * { u64 abi; # enum perf_sample_regs_abi
1705 * u64 regs[weight(mask)]; } && PERF_SAMPLE_REGS_INTR
1706 * { u64 phys_addr;} && PERF_SAMPLE_PHYS_ADDR
1707 * };
1708 * ---
1709 */
1710 PERF_RECORD_SAMPLE = 9,
1711
1712 /**
1713 * ---
1714 * The MMAP2 records are an augmented version of MMAP, they add
1715 * maj, min, ino numbers to be used to uniquely identify each mapping
1716 *
1717 * struct {
1718 * struct perf_event_header header;
1719 *
1720 * u32 pid, tid;
1721 * u64 addr;
1722 * u64 len;
1723 * u64 pgoff;
1724 * u32 maj;
1725 * u32 min;
1726 * u64 ino;
1727 * u64 ino_generation;
1728 * u32 prot, flags;
1729 * char filename[];
1730 * struct sample_id sample_id;
1731 * };
1732 * ---
1733 */
1734 PERF_RECORD_MMAP2 = 10,
1735
1736 /**
1737 * Records that new data landed in the AUX buffer part.
1738 * ---
1739 * struct {
1740 * struct perf_event_header header;
1741 *
1742 * u64 aux_offset;
1743 * u64 aux_size;
1744 * u64 flags;
1745 * struct sample_id sample_id;
1746 * };
1747 * ---
1748 */
1749 PERF_RECORD_AUX = 11,
1750
1751 /**
1752 * ---
1753 * Indicates that instruction trace has started
1754 *
1755 * struct {
1756 * struct perf_event_header header;
1757 * u32 pid;
1758 * u32 tid;
1759 * };
1760 * ---
1761 */
1762 PERF_RECORD_ITRACE_START = 12,
1763
1764 /**
1765 * Records the dropped/lost sample number.
1766 * ---
1767 * struct {
1768 * struct perf_event_header header;
1769 *
1770 * u64 lost;
1771 * struct sample_id sample_id;
1772 * };
1773 * ---
1774 */
1775 PERF_RECORD_LOST_SAMPLES = 13,
1776
1777 /**
1778 *
1779 * Records a context switch in or out (flagged by
1780 * PERF_RECORD_MISC_SWITCH_OUT). See also
1781 * PERF_RECORD_SWITCH_CPU_WIDE.
1782 * ---
1783 * struct {
1784 * struct perf_event_header header;
1785 * struct sample_id sample_id;
1786 * };
1787 * ---
1788 */
1789 PERF_RECORD_SWITCH = 14,
1790
1791 /**
1792 * CPU-wide version of PERF_RECORD_SWITCH with next_prev_pid and
1793 * next_prev_tid that are the next (switching out) or previous
1794 * (switching in) pid/tid.
1795 * ---
1796 * struct {
1797 * struct perf_event_header header;
1798 * u32 next_prev_pid;
1799 * u32 next_prev_tid;
1800 * struct sample_id sample_id;
1801 * };
1802 * ---
1803 */
1804 PERF_RECORD_SWITCH_CPU_WIDE = 15,
1805
1806 /**
1807 * ---
1808 * struct {
1809 * struct perf_event_header header;
1810 * u32 pid;
1811 * u32 tid;
1812 * u64 nr_namespaces;
1813 * { u64 dev, inode; } [nr_namespaces];
1814 * struct sample_id sample_id;
1815 * };
1816 * ---
1817 */
1818 PERF_RECORD_NAMESPACES = 16,
1819
1820 PERF_RECORD_MAX = 17 /* non-ABI */
1821 }
1822 ///
1823 enum PERF_MAX_STACK_DEPTH = 127;
1824 ///
1825 enum PERF_MAX_CONTEXTS_PER_STACK = 8;
1826 ///
1827 enum perf_callchain_context
1828 {
1829 ///
1830 PERF_CONTEXT_HV = cast(ulong)-32,
1831 ///
1832 PERF_CONTEXT_KERNEL = cast(ulong)-128,
1833 ///
1834 PERF_CONTEXT_USER = cast(ulong)-512,
1835 ///
1836 PERF_CONTEXT_GUEST = cast(ulong)-2048,
1837 ///
1838 PERF_CONTEXT_GUEST_KERNEL = cast(ulong)-2176,
1839 ///
1840 PERF_CONTEXT_GUEST_USER = cast(ulong)-2560,
1841 ///
1842 PERF_CONTEXT_MAX = cast(ulong)-4095
1843 }
1844
1845 /**
1846 * PERF_RECORD_AUX::flags bits
1847 */
1848 enum PERF_AUX_FLAG_TRUNCATED = 0x01; /** record was truncated to fit */
1849 enum PERF_AUX_FLAG_OVERWRITE = 0x02; /** snapshot from overwrite mode */
1850 enum PERF_AUX_FLAG_PARTIAL = 0x04; /** record contains gaps */
1851 enum PERF_AUX_FLAG_COLLISION = 0x08; /** sample collided with another */
1852 ///
1853 enum PERF_FLAG_FD_NO_GROUP = 1UL << 0;
1854 ///
1855 enum PERF_FLAG_FD_OUTPUT = 1UL << 1;
1856 enum PERF_FLAG_PID_CGROUP = 1UL << 2; /** pid=cgroup id, per-cpu mode only */
1857 enum PERF_FLAG_FD_CLOEXEC = 1UL << 3; /** O_CLOEXEC */
1858 ///perm_mem_data_src is endian specific.
1859 version (LittleEndian)
1860 {
1861 ///
1862 union perf_mem_data_src
1863 {
1864 ///
1865 ulong val;
1866
1867 struct
1868 {
1869 /* mixin(bitfields!(ulong, "mem_op", 5, ulong, "mem_lvl", 14, ulong,
1870 "mem_snoop", 5, ulong, "mem_lock", 2, ulong, "mem_dtlb", 7, ulong,
1871 "mem_lvl_num", 4, ulong, "mem_remote", 1, ulong,
1872 "mem_snoopx", 2, ulong, "mem_rsvd", 24)); */
1873
1874 private ulong perf_mem_data_src_bitmanip;
1875 ///
1876 @property ulong mem_op() @safe pure nothrow @nogc const
1877 {
1878 auto result = (perf_mem_data_src_bitmanip & 31U) >> 0U;
1879 return cast(ulong) result;
1880 }
1881 ///
1882 @property void mem_op(ulong v) @safe pure nothrow @nogc
1883 {
1884 assert(v >= mem_op_min,
1885 "Value is smaller than the minimum value of bitfield 'mem_op'");
1886 assert(v <= mem_op_max,
1887 "Value is greater than the maximum value of bitfield 'mem_op'");
1888 perf_mem_data_src_bitmanip = cast(
1889 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1890 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 31U)) | (
1891 (cast(typeof(perf_mem_data_src_bitmanip)) v << 0U) & 31U));
1892 }
1893
1894 enum ulong mem_op_min = cast(ulong) 0U;
1895 enum ulong mem_op_max = cast(ulong) 31U;
1896 ///
1897 @property ulong mem_lvl() @safe pure nothrow @nogc const
1898 {
1899 auto result = (perf_mem_data_src_bitmanip & 524256U) >> 5U;
1900 return cast(ulong) result;
1901 }
1902 ///
1903 @property void mem_lvl(ulong v) @safe pure nothrow @nogc
1904 {
1905 assert(v >= mem_lvl_min,
1906 "Value is smaller than the minimum value of bitfield 'mem_lvl'");
1907 assert(v <= mem_lvl_max,
1908 "Value is greater than the maximum value of bitfield 'mem_lvl'");
1909 perf_mem_data_src_bitmanip = cast(
1910 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1911 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 524256U)) | (
1912 (cast(typeof(perf_mem_data_src_bitmanip)) v << 5U) & 524256U));
1913 }
1914
1915 enum ulong mem_lvl_min = cast(ulong) 0U;
1916 enum ulong mem_lvl_max = cast(ulong) 16383U;
1917 ///
1918 @property ulong mem_snoop() @safe pure nothrow @nogc const
1919 {
1920 auto result = (perf_mem_data_src_bitmanip & 16252928U) >> 19U;
1921 return cast(ulong) result;
1922 }
1923 ///
1924 @property void mem_snoop(ulong v) @safe pure nothrow @nogc
1925 {
1926 assert(v >= mem_snoop_min,
1927 "Value is smaller than the minimum value of bitfield 'mem_snoop'");
1928 assert(v <= mem_snoop_max,
1929 "Value is greater than the maximum value of bitfield 'mem_snoop'");
1930 perf_mem_data_src_bitmanip = cast(
1931 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1932 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 16252928U)) | (
1933 (cast(typeof(perf_mem_data_src_bitmanip)) v << 19U) & 16252928U));
1934 }
1935
1936 enum ulong mem_snoop_min = cast(ulong) 0U;
1937 enum ulong mem_snoop_max = cast(ulong) 31U;
1938 ///
1939 @property ulong mem_lock() @safe pure nothrow @nogc const
1940 {
1941 auto result = (perf_mem_data_src_bitmanip & 50331648U) >> 24U;
1942 return cast(ulong) result;
1943 }
1944 ///
1945 @property void mem_lock(ulong v) @safe pure nothrow @nogc
1946 {
1947 assert(v >= mem_lock_min,
1948 "Value is smaller than the minimum value of bitfield 'mem_lock'");
1949 assert(v <= mem_lock_max,
1950 "Value is greater than the maximum value of bitfield 'mem_lock'");
1951 perf_mem_data_src_bitmanip = cast(
1952 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1953 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 50331648U)) | (
1954 (cast(typeof(perf_mem_data_src_bitmanip)) v << 24U) & 50331648U));
1955 }
1956
1957 enum ulong mem_lock_min = cast(ulong) 0U;
1958 enum ulong mem_lock_max = cast(ulong) 3U;
1959 ///
1960 @property ulong mem_dtlb() @safe pure nothrow @nogc const
1961 {
1962 auto result = (perf_mem_data_src_bitmanip & 8522825728UL) >> 26U;
1963 return cast(ulong) result;
1964 }
1965 ///
1966 @property void mem_dtlb(ulong v) @safe pure nothrow @nogc
1967 {
1968 assert(v >= mem_dtlb_min,
1969 "Value is smaller than the minimum value of bitfield 'mem_dtlb'");
1970 assert(v <= mem_dtlb_max,
1971 "Value is greater than the maximum value of bitfield 'mem_dtlb'");
1972 perf_mem_data_src_bitmanip = cast(
1973 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1974 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 8522825728UL)) | (
1975 (cast(typeof(perf_mem_data_src_bitmanip)) v << 26U) & 8522825728UL));
1976 }
1977
1978 enum ulong mem_dtlb_min = cast(ulong) 0U;
1979 enum ulong mem_dtlb_max = cast(ulong) 127U;
1980 ///
1981 @property ulong mem_lvl_num() @safe pure nothrow @nogc const
1982 {
1983 auto result = (perf_mem_data_src_bitmanip & 128849018880UL) >> 33U;
1984 return cast(ulong) result;
1985 }
1986 ///
1987 @property void mem_lvl_num(ulong v) @safe pure nothrow @nogc
1988 {
1989 assert(v >= mem_lvl_num_min,
1990 "Value is smaller than the minimum value of bitfield 'mem_lvl_num'");
1991 assert(v <= mem_lvl_num_max,
1992 "Value is greater than the maximum value of bitfield 'mem_lvl_num'");
1993 perf_mem_data_src_bitmanip = cast(
1994 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
1995 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 128849018880UL)) | (
1996 (cast(typeof(perf_mem_data_src_bitmanip)) v << 33U) & 128849018880UL));
1997 }
1998
1999 enum ulong mem_lvl_num_min = cast(ulong) 0U;
2000 enum ulong mem_lvl_num_max = cast(ulong) 15U;
2001 ///
2002 @property ulong mem_remote() @safe pure nothrow @nogc const
2003 {
2004 auto result = (perf_mem_data_src_bitmanip & 137438953472UL) >> 37U;
2005 return cast(ulong) result;
2006 }
2007 ///
2008 @property void mem_remote(ulong v) @safe pure nothrow @nogc
2009 {
2010 assert(v >= mem_remote_min,
2011 "Value is smaller than the minimum value of bitfield 'mem_remote'");
2012 assert(v <= mem_remote_max,
2013 "Value is greater than the maximum value of bitfield 'mem_remote'");
2014 perf_mem_data_src_bitmanip = cast(
2015 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
2016 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 137438953472UL)) | (
2017 (cast(typeof(perf_mem_data_src_bitmanip)) v << 37U) & 137438953472UL));
2018 }
2019
2020 enum ulong mem_remote_min = cast(ulong) 0U;
2021 enum ulong mem_remote_max = cast(ulong) 1U;
2022 ///
2023 @property ulong mem_snoopx() @safe pure nothrow @nogc const
2024 {
2025 auto result = (perf_mem_data_src_bitmanip & 824633720832UL) >> 38U;
2026 return cast(ulong) result;
2027 }
2028 ///
2029 @property void mem_snoopx(ulong v) @safe pure nothrow @nogc
2030 {
2031 assert(v >= mem_snoopx_min,
2032 "Value is smaller than the minimum value of bitfield 'mem_snoopx'");
2033 assert(v <= mem_snoopx_max,
2034 "Value is greater than the maximum value of bitfield 'mem_snoopx'");
2035 perf_mem_data_src_bitmanip = cast(
2036 typeof(perf_mem_data_src_bitmanip))((perf_mem_data_src_bitmanip & (
2037 -1 - cast(typeof(perf_mem_data_src_bitmanip)) 824633720832UL)) | (
2038 (cast(typeof(perf_mem_data_src_bitmanip)) v << 38U) & 824633720832UL));
2039 }
2040
2041 enum ulong mem_snoopx_min = cast(ulong) 0U;
2042 enum ulong mem_snoopx_max = cast(ulong) 3U;
2043 ///
2044 @property ulong mem_rsvd() @safe pure nothrow @nogc const
2045 {
2046 auto result = (perf_mem_data_src_bitmanip & 18446742974197923840UL) >> 40U;
2047 return cast(ulong) result;
2048 }
2049 ///
2050 @property void mem_rsvd(ulong v) @safe pure nothrow @nogc
2051 {
2052 assert(v >= mem_rsvd_min,
2053 "Value is smaller than the minimum value of bitfield 'mem_rsvd'");
2054 assert(v <= mem_rsvd_max,
2055 "Value is greater than the maximum value of bitfield 'mem_rsvd'");
2056 perf_mem_data_src_bitmanip = cast(
2057 typeof(perf_mem_data_src_bitmanip))(
2058 (perf_mem_data_src_bitmanip & (-1 - cast(
2059 typeof(perf_mem_data_src_bitmanip)) 18446742974197923840UL)) | (
2060 (cast(typeof(perf_mem_data_src_bitmanip)) v << 40U) & 18446742974197923840UL));
2061 }
2062
2063 enum ulong mem_rsvd_min = cast(ulong) 0U;
2064 enum ulong mem_rsvd_max = cast(ulong) 16777215U;
2065
2066 }
2067 }
2068 }
2069 else
2070 {
2071 ///
2072 union perf_mem_data_src
2073 {
2074 ///
2075 ulong val;
2076
2077 struct
2078 {
2079 /* mixin(bitfields!(ulong, "mem_rsvd", 24, ulong, "mem_snoopx", 2, ulong,
2080 "mem_remote", 1, ulong, "mem_lvl_num", 4, ulong, "mem_dtlb", 7, ulong,
2081 "mem_lock", 2, ulong, "mem_snoop", 5, ulong, "mem_lvl",
2082 14, ulong, "mem_op", 5)); */
2083 private ulong perf_mem_data_src;
2084 ///
2085 @property ulong mem_rsvd() @safe pure nothrow @nogc const
2086 {
2087 auto result = (perf_mem_data_src & 16777215U) >> 0U;
2088 return cast(ulong) result;
2089 }
2090 ///
2091 @property void mem_rsvd(ulong v) @safe pure nothrow @nogc
2092 {
2093 assert(v >= mem_rsvd_min,
2094 "Value is smaller than the minimum value of bitfield 'mem_rsvd'");
2095 assert(v <= mem_rsvd_max,
2096 "Value is greater than the maximum value of bitfield 'mem_rsvd'");
2097 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2098 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 16777215U)) | (
2099 (cast(typeof(perf_mem_data_src)) v << 0U) & 16777215U));
2100 }
2101
2102 enum ulong mem_rsvd_min = cast(ulong) 0U;
2103 enum ulong mem_rsvd_max = cast(ulong) 16777215U;
2104 ///
2105 @property ulong mem_snoopx() @safe pure nothrow @nogc const
2106 {
2107 auto result = (perf_mem_data_src & 50331648U) >> 24U;
2108 return cast(ulong) result;
2109 }
2110 ///
2111 @property void mem_snoopx(ulong v) @safe pure nothrow @nogc
2112 {
2113 assert(v >= mem_snoopx_min,
2114 "Value is smaller than the minimum value of bitfield 'mem_snoopx'");
2115 assert(v <= mem_snoopx_max,
2116 "Value is greater than the maximum value of bitfield 'mem_snoopx'");
2117 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2118 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 50331648U)) | (
2119 (cast(typeof(perf_mem_data_src)) v << 24U) & 50331648U));
2120 }
2121
2122 enum ulong mem_snoopx_min = cast(ulong) 0U;
2123 enum ulong mem_snoopx_max = cast(ulong) 3U;
2124 ///
2125 @property ulong mem_remote() @safe pure nothrow @nogc const
2126 {
2127 auto result = (perf_mem_data_src & 67108864U) >> 26U;
2128 return cast(ulong) result;
2129 }
2130 ///
2131 @property void mem_remote(ulong v) @safe pure nothrow @nogc
2132 {
2133 assert(v >= mem_remote_min,
2134 "Value is smaller than the minimum value of bitfield 'mem_remote'");
2135 assert(v <= mem_remote_max,
2136 "Value is greater than the maximum value of bitfield 'mem_remote'");
2137 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2138 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 67108864U)) | (
2139 (cast(typeof(perf_mem_data_src)) v << 26U) & 67108864U));
2140 }
2141
2142 enum ulong mem_remote_min = cast(ulong) 0U;
2143 enum ulong mem_remote_max = cast(ulong) 1U;
2144 ///
2145 @property ulong mem_lvl_num() @safe pure nothrow @nogc const
2146 {
2147 auto result = (perf_mem_data_src & 2013265920U) >> 27U;
2148 return cast(ulong) result;
2149 }
2150 ///
2151 @property void mem_lvl_num(ulong v) @safe pure nothrow @nogc
2152 {
2153 assert(v >= mem_lvl_num_min,
2154 "Value is smaller than the minimum value of bitfield 'mem_lvl_num'");
2155 assert(v <= mem_lvl_num_max,
2156 "Value is greater than the maximum value of bitfield 'mem_lvl_num'");
2157 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2158 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 2013265920U)) | (
2159 (cast(typeof(perf_mem_data_src)) v << 27U) & 2013265920U));
2160 }
2161
2162 enum ulong mem_lvl_num_min = cast(ulong) 0U;
2163 enum ulong mem_lvl_num_max = cast(ulong) 15U;
2164 ///
2165 @property ulong mem_dtlb() @safe pure nothrow @nogc const
2166 {
2167 auto result = (perf_mem_data_src & 272730423296UL) >> 31U;
2168 return cast(ulong) result;
2169 }
2170 ///
2171 @property void mem_dtlb(ulong v) @safe pure nothrow @nogc
2172 {
2173 assert(v >= mem_dtlb_min,
2174 "Value is smaller than the minimum value of bitfield 'mem_dtlb'");
2175 assert(v <= mem_dtlb_max,
2176 "Value is greater than the maximum value of bitfield 'mem_dtlb'");
2177 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2178 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 272730423296UL)) | (
2179 (cast(typeof(perf_mem_data_src)) v << 31U) & 272730423296UL));
2180 }
2181
2182 enum ulong mem_dtlb_min = cast(ulong) 0U;
2183 enum ulong mem_dtlb_max = cast(ulong) 127U;
2184 ///
2185 @property ulong mem_lock() @safe pure nothrow @nogc const
2186 {
2187 auto result = (perf_mem_data_src & 824633720832UL) >> 38U;
2188 return cast(ulong) result;
2189 }
2190 ///
2191 @property void mem_lock(ulong v) @safe pure nothrow @nogc
2192 {
2193 assert(v >= mem_lock_min,
2194 "Value is smaller than the minimum value of bitfield 'mem_lock'");
2195 assert(v <= mem_lock_max,
2196 "Value is greater than the maximum value of bitfield 'mem_lock'");
2197 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2198 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 824633720832UL)) | (
2199 (cast(typeof(perf_mem_data_src)) v << 38U) & 824633720832UL));
2200 }
2201
2202 enum ulong mem_lock_min = cast(ulong) 0U;
2203 enum ulong mem_lock_max = cast(ulong) 3U;
2204 ///
2205 @property ulong mem_snoop() @safe pure nothrow @nogc const
2206 {
2207 auto result = (perf_mem_data_src & 34084860461056UL) >> 40U;
2208 return cast(ulong) result;
2209 }
2210 ///
2211 @property void mem_snoop(ulong v) @safe pure nothrow @nogc
2212 {
2213 assert(v >= mem_snoop_min,
2214 "Value is smaller than the minimum value of bitfield 'mem_snoop'");
2215 assert(v <= mem_snoop_max,
2216 "Value is greater than the maximum value of bitfield 'mem_snoop'");
2217 perf_mem_data_src = cast(typeof(perf_mem_data_src))(
2218 (perf_mem_data_src & (-1 - cast(typeof(perf_mem_data_src)) 34084860461056UL)) | (
2219 (cast(typeof(perf_mem_data_src)) v << 40U) & 34084860461056UL));
2220 }
2221
2222 enum ulong mem_snoop_min = cast(ulong) 0U;
2223 enum ulong mem_snoop_max = cast(ulong) 31U;
2224 ///
2225 @property ulong mem_lvl() @safe pure nothrow @nogc const
2226 {
2227 auto result = (perf_mem_data_src & 576425567931334656UL) >> 45U;
2228 return cast(ulong) result;
2229 }
2230 ///
2231 @property void mem_lvl(ulong v) @safe pure nothrow @nogc
2232 {
2233 assert(v >= mem_lvl_min,
2234 "Value is smaller than the minimum value of bitfield 'mem_lvl'");
2235 assert(v <= mem_lvl_max,
2236 "Value is greater than the maximum value of bitfield 'mem_lvl'");
2237 perf_mem_data_src = cast(typeof(perf_mem_data_src))((perf_mem_data_src & (
2238 -1 - cast(typeof(perf_mem_data_src)) 576425567931334656UL)) | (
2239 (cast(typeof(perf_mem_data_src)) v << 45U) & 576425567931334656UL));
2240 }
2241
2242 enum ulong mem_lvl_min = cast(ulong) 0U;
2243 enum ulong mem_lvl_max = cast(ulong) 16383U;
2244 ///
2245 @property ulong mem_op() @safe pure nothrow @nogc const
2246 {
2247 auto result = (perf_mem_data_src & 17870283321406128128UL) >> 59U;
2248 return cast(ulong) result;
2249 }
2250 ///
2251 @property void mem_op(ulong v) @safe pure nothrow @nogc
2252 {
2253 assert(v >= mem_op_min,
2254 "Value is smaller than the minimum value of bitfield 'mem_op'");
2255 assert(v <= mem_op_max,
2256 "Value is greater than the maximum value of bitfield 'mem_op'");
2257 perf_mem_data_src = cast(typeof(perf_mem_data_src))((perf_mem_data_src & (
2258 -1 - cast(typeof(perf_mem_data_src)) 17870283321406128128UL)) | (
2259 (cast(typeof(perf_mem_data_src)) v << 59U) & 17870283321406128128UL));
2260 }
2261
2262 enum ulong mem_op_min = cast(ulong) 0U;
2263 enum ulong mem_op_max = cast(ulong) 31U;
2264 }
2265 }
2266 }
2267
2268 /* snoop mode, ext */
2269 /* remote */
2270 /* memory hierarchy level number */
2271 /* tlb access */
2272 /* lock instr */
2273 /* snoop mode */
2274 /* memory hierarchy level */
2275 /* type of opcode */
2276
2277 /** type of opcode (load/store/prefetch,code) */
2278 enum PERF_MEM_OP_NA = 0x01; /** not available */
2279 enum PERF_MEM_OP_LOAD = 0x02; /** load instruction */
2280 enum PERF_MEM_OP_STORE = 0x04; /** store instruction */
2281 enum PERF_MEM_OP_PFETCH = 0x08; /** prefetch */
2282 enum PERF_MEM_OP_EXEC = 0x10; /** code (execution) */
2283 enum PERF_MEM_OP_SHIFT = 0;
2284
2285 /* memory hierarchy (memory level, hit or miss) */
2286 enum PERF_MEM_LVL_NA = 0x01; /** not available */
2287 enum PERF_MEM_LVL_HIT = 0x02; /** hit level */
2288 enum PERF_MEM_LVL_MISS = 0x04; /** miss level */
2289 enum PERF_MEM_LVL_L1 = 0x08; /** L1 */
2290 enum PERF_MEM_LVL_LFB = 0x10; /** Line Fill Buffer */
2291 enum PERF_MEM_LVL_L2 = 0x20; /** L2 */
2292 enum PERF_MEM_LVL_L3 = 0x40; /** L3 */
2293 enum PERF_MEM_LVL_LOC_RAM = 0x80; /** Local DRAM */
2294 enum PERF_MEM_LVL_REM_RAM1 = 0x100; /** Remote DRAM (1 hop) */
2295 enum PERF_MEM_LVL_REM_RAM2 = 0x200; /** Remote DRAM (2 hops) */
2296 enum PERF_MEM_LVL_REM_CCE1 = 0x400; /** Remote Cache (1 hop) */
2297 enum PERF_MEM_LVL_REM_CCE2 = 0x800; /** Remote Cache (2 hops) */
2298 enum PERF_MEM_LVL_IO = 0x1000; /** I/O memory */
2299 enum PERF_MEM_LVL_UNC = 0x2000; /** Uncached memory */
2300 ///
2301 enum PERF_MEM_LVL_SHIFT = 5;
2302
2303 enum PERF_MEM_REMOTE_REMOTE = 0x01; /** Remote */
2304 ///
2305 enum PERF_MEM_REMOTE_SHIFT = 37;
2306
2307 enum PERF_MEM_LVLNUM_L1 = 0x01; /** L1 */
2308 enum PERF_MEM_LVLNUM_L2 = 0x02; /** L2 */
2309 enum PERF_MEM_LVLNUM_L3 = 0x03; /** L3 */
2310 enum PERF_MEM_LVLNUM_L4 = 0x04; /** L4 */
2311 /* 5-0xa available */
2312 enum PERF_MEM_LVLNUM_ANY_CACHE = 0x0b; /** Any cache */
2313 enum PERF_MEM_LVLNUM_LFB = 0x0c; /** LFB */
2314 enum PERF_MEM_LVLNUM_RAM = 0x0d; /** RAM */
2315 enum PERF_MEM_LVLNUM_PMEM = 0x0e; /** PMEM */
2316 enum PERF_MEM_LVLNUM_NA = 0x0f; /** N/A */
2317 ///
2318 enum PERF_MEM_LVLNUM_SHIFT = 33;
2319
2320 /* snoop mode */
2321 enum PERF_MEM_SNOOP_NA = 0x01; /** not available */
2322 enum PERF_MEM_SNOOP_NONE = 0x02; /** no snoop */
2323 enum PERF_MEM_SNOOP_HIT = 0x04; /** snoop hit */
2324 enum PERF_MEM_SNOOP_MISS = 0x08; /** snoop miss */
2325 enum PERF_MEM_SNOOP_HITM = 0x10; /** snoop hit modified */
2326 ///
2327 enum PERF_MEM_SNOOP_SHIFT = 19;
2328
2329 enum PERF_MEM_SNOOPX_FWD = 0x01; /** forward */
2330 /** 1 free */
2331 enum PERF_MEM_SNOOPX_SHIFT = 37;
2332
2333 /** locked instruction */
2334 enum PERF_MEM_LOCK_NA = 0x01; /** not available */
2335 enum PERF_MEM_LOCK_LOCKED = 0x02; /** locked transaction */
2336 ///
2337 enum PERF_MEM_LOCK_SHIFT = 24;
2338
2339 /* TLB access */
2340 enum PERF_MEM_TLB_NA = 0x01; /** not available */
2341 enum PERF_MEM_TLB_HIT = 0x02; /** hit level */
2342 enum PERF_MEM_TLB_MISS = 0x04; /** miss level */
2343 enum PERF_MEM_TLB_L1 = 0x08; /** L1 */
2344 enum PERF_MEM_TLB_L2 = 0x10; /** L2 */
2345 enum PERF_MEM_TLB_WK = 0x20; /** Hardware Walker*/
2346 enum PERF_MEM_TLB_OS = 0x40; /** OS fault handler */
2347 ///
2348 enum PERF_MEM_TLB_SHIFT = 26;
2349
2350 /**
2351 * single taken branch record layout:
2352 *
2353 * from: source instruction (may not always be a branch insn)
2354 * to: branch target
2355 * mispred: branch target was mispredicted
2356 * predicted: branch target was predicted
2357 *
2358 * support for mispred, predicted is optional. In case it
2359 * is not supported mispred = predicted = 0.
2360 *
2361 * in_tx: running in a hardware transaction
2362 * abort: aborting a hardware transaction
2363 * cycles: cycles from last branch (or 0 if not supported)
2364 * type: branch type
2365 */
2366 struct perf_branch_entry
2367 {
2368 ///
2369 ulong from;
2370 ///
2371 ulong to;
2372
2373 /* mixin(bitfields!(ulong, "mispred", 1, ulong, "predicted", 1, ulong,
2374 "in_tx", 1, ulong, "abort", 1, ulong, "cycles", 16, ulong, "type",
2375 4, ulong, "reserved", 40)); */
2376 private ulong perf_branch_entry_bitmanip;
2377 ///
2378 @property ulong mispred() @safe pure nothrow @nogc const
2379 {
2380 auto result = (perf_branch_entry_bitmanip & 1U) >> 0U;
2381 return cast(ulong) result;
2382 }
2383 ///
2384 @property void mispred(ulong v) @safe pure nothrow @nogc
2385 {
2386 assert(v >= mispred_min,
2387 "Value is smaller than the minimum value of bitfield 'mispred'");
2388 assert(v <= mispred_max,
2389 "Value is greater than the maximum value of bitfield 'mispred'");
2390 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2391 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 1U)) | (
2392 (cast(typeof(perf_branch_entry_bitmanip)) v << 0U) & 1U));
2393 }
2394
2395 enum ulong mispred_min = cast(ulong) 0U;
2396 enum ulong mispred_max = cast(ulong) 1U;
2397 ///
2398 @property ulong predicted() @safe pure nothrow @nogc const
2399 {
2400 auto result = (perf_branch_entry_bitmanip & 2U) >> 1U;
2401 return cast(ulong) result;
2402 }
2403 ///
2404 @property void predicted(ulong v) @safe pure nothrow @nogc
2405 {
2406 assert(v >= predicted_min,
2407 "Value is smaller than the minimum value of bitfield 'predicted'");
2408 assert(v <= predicted_max,
2409 "Value is greater than the maximum value of bitfield 'predicted'");
2410 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2411 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 2U)) | (
2412 (cast(typeof(perf_branch_entry_bitmanip)) v << 1U) & 2U));
2413 }
2414
2415 enum ulong predicted_min = cast(ulong) 0U;
2416 enum ulong predicted_max = cast(ulong) 1U;
2417 ///
2418 @property ulong in_tx() @safe pure nothrow @nogc const
2419 {
2420 auto result = (perf_branch_entry_bitmanip & 4U) >> 2U;
2421 return cast(ulong) result;
2422 }
2423 ///
2424 @property void in_tx(ulong v) @safe pure nothrow @nogc
2425 {
2426 assert(v >= in_tx_min,
2427 "Value is smaller than the minimum value of bitfield 'in_tx'");
2428 assert(v <= in_tx_max,
2429 "Value is greater than the maximum value of bitfield 'in_tx'");
2430 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2431 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 4U)) | (
2432 (cast(typeof(perf_branch_entry_bitmanip)) v << 2U) & 4U));
2433 }
2434
2435 enum ulong in_tx_min = cast(ulong) 0U;
2436 enum ulong in_tx_max = cast(ulong) 1U;
2437 ///
2438 @property ulong abort() @safe pure nothrow @nogc const
2439 {
2440 auto result = (perf_branch_entry_bitmanip & 8U) >> 3U;
2441 return cast(ulong) result;
2442 }
2443 ///
2444 @property void abort(ulong v) @safe pure nothrow @nogc
2445 {
2446 assert(v >= abort_min,
2447 "Value is smaller than the minimum value of bitfield 'abort'");
2448 assert(v <= abort_max,
2449 "Value is greater than the maximum value of bitfield 'abort'");
2450 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2451 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 8U)) | (
2452 (cast(typeof(perf_branch_entry_bitmanip)) v << 3U) & 8U));
2453 }
2454
2455 enum ulong abort_min = cast(ulong) 0U;
2456 enum ulong abort_max = cast(ulong) 1U;
2457 ///
2458 @property ulong cycles() @safe pure nothrow @nogc const
2459 {
2460 auto result = (perf_branch_entry_bitmanip & 1048560U) >> 4U;
2461 return cast(ulong) result;
2462 }
2463 ///
2464 @property void cycles(ulong v) @safe pure nothrow @nogc
2465 {
2466 assert(v >= cycles_min,
2467 "Value is smaller than the minimum value of bitfield 'cycles'");
2468 assert(v <= cycles_max,
2469 "Value is greater than the maximum value of bitfield 'cycles'");
2470 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2471 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 1048560U)) | (
2472 (cast(typeof(perf_branch_entry_bitmanip)) v << 4U) & 1048560U));
2473 }
2474
2475 enum ulong cycles_min = cast(ulong) 0U;
2476 enum ulong cycles_max = cast(ulong) 65535U;
2477 ///
2478 @property ulong type() @safe pure nothrow @nogc const
2479 {
2480 auto result = (perf_branch_entry_bitmanip & 15728640U) >> 20U;
2481 return cast(ulong) result;
2482 }
2483 ///
2484 @property void type(ulong v) @safe pure nothrow @nogc
2485 {
2486 assert(v >= type_min, "Value is smaller than the minimum value of bitfield 'type'");
2487 assert(v <= type_max, "Value is greater than the maximum value of bitfield 'type'");
2488 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2489 (perf_branch_entry_bitmanip & (-1 - cast(typeof(perf_branch_entry_bitmanip)) 15728640U)) | (
2490 (cast(typeof(perf_branch_entry_bitmanip)) v << 20U) & 15728640U));
2491 }
2492
2493 enum ulong type_min = cast(ulong) 0U;
2494 enum ulong type_max = cast(ulong) 15U;
2495 ///
2496 @property ulong reserved() @safe pure nothrow @nogc const
2497 {
2498 auto result = (perf_branch_entry_bitmanip & 18446744073692774400UL) >> 24U;
2499 return cast(ulong) result;
2500 }
2501 ///
2502 @property void reserved(ulong v) @safe pure nothrow @nogc
2503 {
2504 assert(v >= reserved_min,
2505 "Value is smaller than the minimum value of bitfield 'reserved'");
2506 assert(v <= reserved_max,
2507 "Value is greater than the maximum value of bitfield 'reserved'");
2508 perf_branch_entry_bitmanip = cast(typeof(perf_branch_entry_bitmanip))(
2509 (perf_branch_entry_bitmanip & (-1 - cast(
2510 typeof(perf_branch_entry_bitmanip)) 18446744073692774400UL)) | (
2511 (cast(typeof(perf_branch_entry_bitmanip)) v << 24U) & 18446744073692774400UL));
2512 }
2513
2514 enum ulong reserved_min = cast(ulong) 0U;
2515 enum ulong reserved_max = cast(ulong) 1099511627775UL;
2516 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org