PAPI  5.3.0.0
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
linux-mx.c
Go to the documentation of this file.
1 
7 #include "papi.h"
8 #include "papi_internal.h"
9 #include "papi_vector.h"
10 
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <unistd.h>
14 #include <string.h>
15 #include <ctype.h>
16 
17 #define MX_MAX_COUNTERS 100
18 #define MX_MAX_COUNTER_TERMS MX_MAX_COUNTERS
19 
20 #define LINELEN 128
21 
22 typedef struct MX_register
23 {
24  /* indicate which counters this event can live on */
25  unsigned int selector;
27 
28 typedef struct MX_native_event_entry
29 {
30  /* description of the resources required by this native event */
32  /* If it exists, then this is the name of this event */
33  char *name;
34  /* If it exists, then this is the description of this event */
35  char *description;
37 
38 typedef struct MX_reg_alloc
39 {
42 
43 typedef struct MX_control_state
44 {
45  long long start_count[MX_MAX_COUNTERS];
46  long long current_count[MX_MAX_COUNTERS];
47  long long difference[MX_MAX_COUNTERS];
48  int which_counter[MX_MAX_COUNTERS];
51 
52 typedef struct MX_context
53 {
55 } MX_context_t;
56 
57 
59  {{1, }, "LANAI_UPTIME", "Lanai uptime (seconds)"},
60  {{2, }, "COUNTERS_UPTIME", "Counters uptime (seconds)"},
61  {{3, }, "BAD_CRC8", "Bad CRC8 (Port 0)"},
62  {{4, }, "BAD_CRC32", "Bad CRC32 (Port 0)"},
63  {{5, }, "UNSTRIPPED_ROUTE", "Unstripped route (Port 0)"},
64  {{6, }, "PKT_DESC_INVALID", "pkt_desc_invalid (Port 0)"},
65  {{7, }, "RECV_PKT_ERRORS", "recv_pkt_errors (Port 0)"},
66  {{8, }, "PKT_MISROUTED", "pkt_misrouted (Port 0)"},
67  {{9, }, "DATA_SRC_UNKNOWN", "data_src_unknown"},
68  {{10, }, "DATA_BAD_ENDPT", "data_bad_endpt"},
69  {{11, }, "DATA_ENDPT_CLOSED", "data_endpt_closed"},
70  {{12, }, "DATA_BAD_SESSION", "data_bad_session"},
71  {{13, }, "PUSH_BAD_WINDOW", "push_bad_window"},
72  {{14, }, "PUSH_DUPLICATE", "push_duplicate"},
73  {{15, }, "PUSH_OBSOLETE", "push_obsolete"},
74  {{16, }, "PUSH_RACE_DRIVER", "push_race_driver"},
75  {{17, }, "PUSH_BAD_SEND_HANDLE_MAGIC", "push_bad_send_handle_magic"},
76  {{18, }, "PUSH_BAD_SRC_MAGIC", "push_bad_src_magic"},
77  {{19, }, "PULL_OBSOLETE", "pull_obsolete"},
78  {{20, }, "PULL_NOTIFY_OBSOLETE", "pull_notify_obsolete"},
79  {{21, }, "PULL_RACE_DRIVER", "pull_race_driver"},
80  {{22, }, "ACK_BAD_TYPE", "ack_bad_type"},
81  {{23, }, "ACK_BAD_MAGIC", "ack_bad_magic"},
82  {{24, }, "ACK_RESEND_RACE", "ack_resend_race"},
83  {{25, }, "LATE_ACK", "Late ack"},
84  {{26, }, "ACK_NACK_FRAMES_IN_PIPE", "ack_nack_frames_in_pipe"},
85  {{27, }, "NACK_BAD_ENDPT", "nack_bad_endpt"},
86  {{28, }, "NACK_ENDPT_CLOSED", "nack_endpt_closed"},
87  {{29, }, "NACK_BAD_SESSION", "nack_bad_session"},
88  {{30, }, "NACK_BAD_RDMAWIN", "nack_bad_rdmawin"},
89  {{31, }, "NACK_EVENTQ_FULL", "nack_eventq_full"},
90  {{32, }, "SEND_BAD_RDMAWIN", "send_bad_rdmawin"},
91  {{33, }, "CONNECT_TIMEOUT", "connect_timeout"},
92  {{34, }, "CONNECT_SRC_UNKNOWN", "connect_src_unknown"},
93  {{35, }, "QUERY_BAD_MAGIC", "query_bad_magic"},
94  {{36, }, "QUERY_TIMED_OUT", "query_timed_out"},
95  {{37, }, "QUERY_SRC_UNKNOWN", "query_src_unknown"},
96  {{38, }, "RAW_SENDS", "Raw sends (Port 0)"},
97  {{39, }, "RAW_RECEIVES", "Raw receives (Port 0)"},
98  {{40, }, "RAW_OVERSIZED_PACKETS", "Raw oversized packets (Port 0)"},
99  {{41, }, "RAW_RECV_OVERRUN", "raw_recv_overrun"},
100  {{42, }, "RAW_DISABLED", "raw_disabled"},
101  {{43, }, "CONNECT_SEND", "connect_send"},
102  {{44, }, "CONNECT_RECV", "connect_recv"},
103  {{45, }, "ACK_SEND", "ack_send (Port 0)"},
104  {{46, }, "ACK_RECV", "ack_recv (Port 0)"},
105  {{47, }, "PUSH_SEND", "push_send (Port 0)"},
106  {{48, }, "PUSH_RECV", "push_recv (Port 0)"},
107  {{49, }, "QUERY_SEND", "query_send (Port 0)"},
108  {{50, }, "QUERY_RECV", "query_recv (Port 0)"},
109  {{51, }, "REPLY_SEND", "reply_send (Port 0)"},
110  {{52, }, "REPLY_RECV", "reply_recv (Port 0)"},
111  {{53, }, "QUERY_UNKNOWN", "query_unknown (Port 0)"},
112 /* {{ 54, }, "QUERY_UNKNOWN", "query_unknown (Port 0)"},*/
113  {{55, }, "DATA_SEND_NULL", "data_send_null (Port 0)"},
114  {{56, }, "DATA_SEND_SMALL", "data_send_small (Port 0)"},
115  {{57, }, "DATA_SEND_MEDIUM", "data_send_medium (Port 0)"},
116  {{58, }, "DATA_SEND_RNDV", "data_send_rndv (Port 0)"},
117  {{59, }, "DATA_SEND_PULL", "data_send_pull (Port 0)"},
118  {{60, }, "DATA_RECV_NULL", "data_recv_null (Port 0)"},
119  {{61, }, "DATA_RECV_SMALL_INLINE", "data_recv_small_inline (Port 0)"},
120  {{62, }, "DATA_RECV_SMALL_COPY", "data_recv_small_copy (Port 0)"},
121  {{63, }, "DATA_RECV_MEDIUM", "data_recv_medium (Port 0)"},
122  {{64, }, "DATA_RECV_RNDV", "data_recv_rndv (Port 0)"},
123  {{65, }, "DATA_RECV_PULL", "data_recv_pull (Port 0)"},
124  {{66, }, "ETHER_SEND_UNICAST_CNT", "ether_send_unicast_cnt (Port 0)"},
125  {{67, }, "ETHER_SEND_MULTICAST_CNT", "ether_send_multicast_cnt (Port 0)"},
126  {{68, }, "ETHER_RECV_SMALL_CNT", "ether_recv_small_cnt (Port 0)"},
127  {{69, }, "ETHER_RECV_BIG_CNT", "ether_recv_big_cnt (Port 0)"},
128  {{70, }, "ETHER_OVERRUN", "ether_overrun"},
129  {{71, }, "ETHER_OVERSIZED", "ether_oversized"},
130  {{72, }, "DATA_RECV_NO_CREDITS", "data_recv_no_credits"},
131  {{73, }, "PACKETS_RECENT", "Packets resent"},
132  {{74, }, "PACKETS_DROPPED", "Packets dropped (data send side)"},
133  {{75, }, "MAPPER_ROUTES_UPDATE", "Mapper routes update"},
134  {{76, }, "ROUTE_DISPERSION", "Route dispersion (Port 0)"},
135  {{77, }, "OUT_OF_SEND_HANDLES", "out_of_send_handles"},
136  {{78, }, "OUT_OF_PULL_HANDLES", "out_of_pull_handles"},
137  {{79, }, "OUT_OF_PUSH_HANDLES", "out_of_push_handles"},
138  {{80, }, "MEDIUM_CONT_RACE", "medium_cont_race"},
139  {{81, }, "CMD_TYPE_UNKNOWN", "cmd_type_unknown"},
140  {{82, }, "UREQ_TYPE_UNKNOWN", "ureq_type_unknown"},
141  {{83, }, "INTERRUPTS_OVERRUN", "Interrupts overrun"},
142  {{84, }, "WAITING_FOR_INTERRUPT_DMA", "Waiting for interrupt DMA"},
143  {{85, }, "WAITING_FOR_INTERRUPT_ACK", "Waiting for interrupt Ack"},
144  {{86, }, "WAITING_FOR_INTERRUPT_TIMER", "Waiting for interrupt Timer"},
145  {{87, }, "SLABS_RECYCLING", "Slabs recycling"},
146  {{88, }, "SLABS_PRESSURE", "Slabs pressure"},
147  {{89, }, "SLABS_STARVATION", "Slabs starvation"},
148  {{90, }, "OUT_OF_RDMA_HANDLES", "out_of_rdma handles"},
149  {{91, }, "EVENTQ_FULL", "eventq_full"},
150  {{92, }, "BUFFER_DROP", "buffer_drop (Port 0)"},
151  {{93, }, "MEMORY_DROP", "memory_drop (Port 0)"},
152  {{94, }, "HARDWARE_FLOW_CONTROL", "Hardware flow control (Port 0)"},
153  {{95, }, "SIMULATED_PACKETS_LOST", "(Devel) Simulated packets lost (Port 0)"},
154  {{96, }, "LOGGING_FRAMES_DUMPED", "(Logging) Logging frames dumped"},
155  {{97, }, "WAKE_INTERRUPTS", "Wake interrupts"},
156  {{98, }, "AVERTED_WAKEUP_RACE", "Averted wakeup race"},
157  {{99, }, "DMA_METADATA_RACE", "Dma metadata race"},
158  {{0, }, "", ""}
159 };
160 
161 static int num_events=0;
163 
164 static char mx_counters_exe[BUFSIZ];
165 
166 static int
167 read_mx_counters( long long *counters )
168 {
169  FILE *fp;
170  char line[LINELEN];
171  int i, linenum;
172 
173  /* Open a pipe to the mx_counters executable */
174 
175  fp = popen( mx_counters_exe, "r" );
176  if ( !fp ) {
177  perror( "popen" );
178  return PAPI_ECMP;
179  }
180 
181 
182  /* A line of output looks something similar to: */
183  /* " Lanai uptime (seconds): 766268 (0xbb13c)" */
184 
185  /* This code may fail if number of ports on card > 1 */
186 
187  linenum = 0;
188  while ( fgets( line, LINELEN, fp ) ) {
189  // printf("%s",line);
190  for(i=0; line[i]!= '\0' && i<LINELEN-1;i++) {
191 
192  /* skip to colon */
193  if (line[i]==':') {
194 
195  /* read in value */
196  if (line[i+1]!='\0') {
197  // printf("Line %d trying %s",linenum,&line[i+1]);
198  sscanf(&line[i+1],"%lld",&counters[linenum]);
199  linenum++;
200  break;
201  }
202  }
203  }
204  if (linenum>=MX_MAX_COUNTERS) break;
205  }
206 
207  pclose( fp );
208 
209  return PAPI_OK;
210 }
211 
212 
213 
214 /*
215  * Component setup and shutdown
216  */
217 
218 /* Initialize hardware counters, setup the function vector table
219  * and get hardware information, this routine is called when the
220  * PAPI process is initialized (IE PAPI_library_init)
221  */
222 int
224 {
225 
226  FILE *fff;
227  char test_string[BUFSIZ];
228 
229  /* detect if MX available */
230 
231  strncpy(mx_counters_exe,"mx_counters 2> /dev/null",BUFSIZ);
232  fff=popen(mx_counters_exe,"r");
233  /* popen only returns NULL if "sh" fails, not the actual command */
234  if (fgets(test_string,BUFSIZ,fff)==NULL) {
235  pclose(fff);
236  strncpy(mx_counters_exe,"./components/mx/utils/fake_mx_counters 2> /dev/null",BUFSIZ);
237  fff=popen(mx_counters_exe,"r");
238  if (fgets(test_string,BUFSIZ,fff)==NULL) {
239  pclose(fff);
240  /* neither real nor fake found */
241  strncpy(_mx_vector.cmp_info.disabled_reason,
242  "No MX utilities found",PAPI_MAX_STR_LEN);
243  return PAPI_ECMP;
244  }
245  }
246  pclose(fff);
247 
250 
251  /* Export the component id */
252  _mx_vector.cmp_info.CmpIdx = cidx;
253 
254 
255  return PAPI_OK;
256 }
257 
258 
259 /*
260  * This is called whenever a thread is initialized
261  */
262 int
264 {
265  ( void ) ctx; /*unused */
266  return PAPI_OK;
267 }
268 
269 
270 int
272 {
273  return PAPI_OK;
274 }
275 
276 int
278 {
279  ( void ) ctx; /*unused */
280  return PAPI_OK;
281 }
282 
283 
284 
285 /*
286  * Control of counters (Reading/Writing/Starting/Stopping/Setup)
287  * functions
288  */
289 int
291 {
292  ( void ) ctl; /*unused */
293 
294  return PAPI_OK;
295 }
296 
297 int
299  int count, hwd_context_t *ctx )
300 {
301  ( void ) ctx; /*unused */
302  int i, index;
303 
304  MX_control_state_t *mx_ctl = (MX_control_state_t *)ctl;
305 
306  for(i=0; i<count; i++ ) {
307  index = native[i].ni_event;
308  mx_ctl->which_counter[i]=index;
309  // printf("Mapping event# %d to HW counter %d (count=%d)\n",
310  // i,index,count);
311  native[i].ni_position = i;
312  }
313 
314  mx_ctl->num_events=count;
315 
316  return PAPI_OK;
317 }
318 
319 
320 int
322 {
323 
324  long long mx_counters[MX_MAX_COUNTERS];
325 
326  ( void ) ctx; /*unused */
327 
328  MX_control_state_t *mx_ctl = (MX_control_state_t *)ctl;
329  int i;
330 
331  read_mx_counters( mx_counters );
332 
333  // for(i=0;i<MX_MAX_COUNTERS;i++) printf("%d %lld\n",i,mx_counters[i]);
334 
335  for(i=0;i<mx_ctl->num_events;i++) {
336  mx_ctl->current_count[i]=
337  mx_counters[mx_ctl->which_counter[i]];
338  mx_ctl->start_count[i]=mx_ctl->current_count[i];
339  }
340 
341  return PAPI_OK;
342 }
343 
344 
345 int
347 {
348  ( void ) ctx; /*unused */
349 
350  long long mx_counters[MX_MAX_COUNTERS];
351  MX_control_state_t *mx_ctl = (MX_control_state_t *)ctl;
352  int i;
353 
354  read_mx_counters( mx_counters );
355 
356  for(i=0;i<mx_ctl->num_events;i++) {
357  mx_ctl->current_count[i]=
358  mx_counters[mx_ctl->which_counter[i]];
359  }
360 
361  return PAPI_OK;
362 }
363 
364 int
366  int flags )
367 {
368  ( void ) ctx; /*unused */
369  ( void ) flags; /*unused */
370  int i;
371  long long mx_counters[MX_MAX_COUNTERS];
372 
373  MX_control_state_t *mx_ctl = (MX_control_state_t *)ctl;
374 
375  read_mx_counters( mx_counters );
376 
377  for ( i = 0; i < mx_ctl->num_events; i++ ) {
378  mx_ctl->current_count[i]=
379  mx_counters[mx_ctl->which_counter[i]];
380  mx_ctl->difference[i] = mx_ctl->current_count[i]-
381  mx_ctl->start_count[i];
382  }
383  *events = mx_ctl->difference;
384 
385  return PAPI_OK;
386 }
387 
388 
389 int
391 {
392  _mx_start( ctx, ctrl );
393  return PAPI_OK;
394 }
395 
396 int
397 _mx_write( hwd_context_t * ctx, hwd_control_state_t * ctrl, long long *from )
398 {
399  ( void ) ctx; /*unused */
400  ( void ) ctrl; /*unused */
401  ( void ) from; /*unused */
402 
403  return PAPI_OK;
404 }
405 
406 /*
407  * Functions for setting up various options
408  */
409 
410 /* This function sets various options in the component
411  * The valid codes being passed in are PAPI_SET_DEFDOM,
412  * PAPI_SET_DOMAIN, PAPI_SETDEFGRN, PAPI_SET_GRANUL * and PAPI_SET_INHERIT
413  */
414 int
415 _mx_ctl( hwd_context_t * ctx, int code, _papi_int_option_t * option )
416 {
417  ( void ) ctx; /*unused */
418  ( void ) code; /*unused */
419  ( void ) option; /*unused */
420 
421  return PAPI_OK;
422 }
423 
424 /*
425  * This function has to set the bits needed to count different domains
426  * In particular: PAPI_DOM_USER, PAPI_DOM_KERNEL PAPI_DOM_OTHER
427  * By default return PAPI_EINVAL if none of those are specified
428  * and PAPI_OK with success
429  * PAPI_DOM_USER is only user context is counted
430  * PAPI_DOM_KERNEL is only the Kernel/OS context is counted
431  * PAPI_DOM_OTHER is Exception/transient mode (like user TLB misses)
432  * PAPI_DOM_ALL is all of the domains
433  */
434 int
435 _mx_set_domain( hwd_control_state_t * cntrl, int domain )
436 {
437  ( void ) cntrl; /*unused */
438  int found = 0;
439  if ( PAPI_DOM_USER & domain ) {
440  found = 1;
441  }
442  if ( PAPI_DOM_KERNEL & domain ) {
443  found = 1;
444  }
445  if ( PAPI_DOM_OTHER & domain ) {
446  found = 1;
447  }
448  if ( !found )
449  return PAPI_EINVAL;
450  return PAPI_OK;
451 }
452 
453 
454 
455 int
456 _mx_ntv_code_to_name( unsigned int EventCode, char *name, int len )
457 {
458 
459  int event=EventCode;
460 
461  if (event >=0 && event < num_events) {
462  strncpy( name, mx_native_table[event].name, len );
463  return PAPI_OK;
464  }
465  return PAPI_ENOEVNT;
466 
467 
468 }
469 
470 int
471 _mx_ntv_code_to_descr( unsigned int EventCode, char *name, int len )
472 {
473  int event=EventCode;
474 
475  if (event >=0 && event < num_events) {
476  strncpy( name, mx_native_table[event].description, len );
477  return PAPI_OK;
478  }
479  return PAPI_ENOEVNT;
480 }
481 
482 
483 
484 int
485 _mx_ntv_enum_events( unsigned int *EventCode, int modifier )
486 {
487 
488  if ( modifier == PAPI_ENUM_FIRST ) {
489  if (num_events==0) return PAPI_ENOEVNT;
490  *EventCode = 0;
491  return PAPI_OK;
492  }
493 
494  if ( modifier == PAPI_ENUM_EVENTS ) {
495  int index = *EventCode;
496 
497  if ( mx_native_table[index + 1].resources.selector ) {
498  *EventCode = *EventCode + 1;
499  return PAPI_OK;
500  } else {
501  return PAPI_ENOEVNT;
502  }
503  }
504 
505  return PAPI_EINVAL;
506 }
507 
508 
509 papi_vector_t _mx_vector = {
510  .cmp_info = {
511  .name = "mx",
512  .short_name = "mx",
513  .version = "1.4",
514  .description = "Myricom MX (Myrinet Express) statistics",
515  .num_mpx_cntrs = MX_MAX_COUNTERS,
516  .num_cntrs = MX_MAX_COUNTERS,
517  .default_domain = PAPI_DOM_USER,
518  .default_granularity = PAPI_GRN_THR,
519  .available_granularities = PAPI_GRN_THR,
520  .hardware_intr_sig = PAPI_INT_SIGNAL,
521 
522  /* component specific cmp_info initializations */
523  .fast_real_timer = 0,
524  .fast_virtual_timer = 0,
525  .attach = 0,
526  .attach_must_ptrace = 0,
527  .available_domains = PAPI_DOM_USER | PAPI_DOM_KERNEL,
528  },
529 
530  /* sizes of framework-opaque component-private structures */
531  .size = {
532  .context = sizeof ( MX_context_t ),
533  .control_state = sizeof ( MX_control_state_t ),
534  .reg_value = sizeof ( MX_register_t ),
535  .reg_alloc = sizeof ( MX_reg_alloc_t ),
536  },
537  /* function pointers in this component */
538  .init_thread = _mx_init_thread,
539  .init_component = _mx_init_component,
540  .init_control_state = _mx_init_control_state,
541  .start = _mx_start,
542  .stop = _mx_stop,
543  .read = _mx_read,
544  .shutdown_thread = _mx_shutdown_thread,
545  .shutdown_component = _mx_shutdown_component,
546  .ctl = _mx_ctl,
547  .update_control_state = _mx_update_control_state,
548  .set_domain = _mx_set_domain,
549  .reset = _mx_reset,
550 
551  .ntv_enum_events = _mx_ntv_enum_events,
552  .ntv_code_to_name = _mx_ntv_code_to_name,
553  .ntv_code_to_descr = _mx_ntv_code_to_descr,
554 };
char name[PAPI_MAX_STR_LEN]
Definition: papi.h:625
long long start_count[MX_MAX_COUNTERS]
Definition: linux-mx.c:45
long long flags
Definition: iozone.c:12330
long long current_count[MX_MAX_COUNTERS]
Definition: linux-mx.c:46
#define PAPI_MAX_STR_LEN
Definition: fpapi.h:43
static int read_mx_counters(long long *counters)
Definition: linux-mx.c:167
#define PAPI_ENOEVNT
Definition: fpapi.h:112
int _mx_init_control_state(hwd_control_state_t *ctl)
Definition: linux-mx.c:290
static int num_events
device[deviceId] domain[domainId] event
Definition: linux-cuda.c:306
return PAPI_OK
Definition: linux-nvml.c:458
int count
Definition: iozone.c:22422
#define PAPI_DOM_OTHER
Definition: fpapi.h:23
static char mx_counters_exe[BUFSIZ]
Definition: linux-mx.c:164
#define PAPI_DOM_KERNEL
Definition: fpapi.h:22
void
Definition: iozone.c:18627
return PAPI_EINVAL
Definition: linux-nvml.c:408
PAPI_component_info_t cmp_info
Definition: papi_vector.h:20
int _mx_read(hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
Definition: linux-mx.c:365
#define LINELEN
Definition: linux-mx.c:20
Return codes and api definitions.
FILE * fff[MAX_EVENTS]
int _mx_ntv_enum_events(unsigned int *EventCode, int modifier)
Definition: linux-mx.c:485
papi_vector_t _mx_vector
Definition: linux-mx.c:162
char disabled_reason[PAPI_MAX_STR_LEN]
Definition: papi.h:632
int i
Definition: fileop.c:140
char * name
Definition: linux-mx.c:33
long long found
Definition: libasync.c:735
static int cidx
Definition: event_info.c:40
MX_native_event_entry_t mx_native_table[]
Definition: linux-mx.c:58
#define PAPI_ECMP
Definition: fpapi.h:109
static int native
Definition: event_info.c:39
int _mx_set_domain(hwd_control_state_t *cntrl, int domain)
Definition: linux-mx.c:435
unsigned int selector
Definition: linux-mx.c:25
static FILE * fp
char events[MAX_EVENTS][BUFSIZ]
#define MX_MAX_COUNTERS
Definition: linux-mx.c:17
#define PAPI_INT_SIGNAL
Definition: papi_internal.h:53
int which_counter[MX_MAX_COUNTERS]
Definition: linux-mx.c:48
int _mx_ntv_code_to_descr(unsigned int EventCode, char *name, int len)
Definition: linux-mx.c:471
int _mx_shutdown_thread(hwd_context_t *ctx)
Definition: linux-mx.c:277
int _mx_write(hwd_context_t *ctx, hwd_control_state_t *ctrl, long long *from)
Definition: linux-mx.c:397
long long difference[MX_MAX_COUNTERS]
Definition: linux-mx.c:47
sscanf(mnc->m_child_port,"%d",&mc.m_child_port)
int _mx_init_component(int cidx)
Definition: linux-mx.c:223
MX_control_state_t state
Definition: linux-mx.c:54
char * name
Definition: iozone.c:23648
int _mx_update_control_state(hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
Definition: linux-mx.c:298
int _mx_stop(hwd_context_t *ctx, hwd_control_state_t *ctl)
Definition: linux-mx.c:346
int _mx_ntv_code_to_name(unsigned int EventCode, char *name, int len)
Definition: linux-mx.c:456
int _mx_start(hwd_context_t *ctx, hwd_control_state_t *ctl)
Definition: linux-mx.c:321
#define PAPI_DOM_USER
Definition: fpapi.h:21
int _mx_ctl(hwd_context_t *ctx, int code, _papi_int_option_t *option)
Definition: linux-mx.c:415
int _mx_shutdown_component(void)
Definition: linux-mx.c:271
Definition: linux-mx.c:28
int _mx_init_thread(hwd_context_t *ctx)
Definition: linux-mx.c:263
MX_register_t resources
Definition: linux-mx.c:31
MX_register_t ra_bits
Definition: linux-mx.c:40
#define PAPI_GRN_THR
Definition: fpapi.h:67
int _mx_reset(hwd_context_t *ctx, hwd_control_state_t *ctrl)
Definition: linux-mx.c:390
char * description
Definition: linux-mx.c:35