PAPI 7.1.0.0
Loading...
Searching...
No Matches
Data Structures | Macros | Functions | Variables
overflow_index.c File Reference
Include dependency graph for overflow_index.c:

Go to the source code of this file.

Data Structures

struct  ocount_t
 

Macros

#define OVER_FMT   "handler(%d) Overflow at %p! vector=%#llx\n"
 
#define OUT_FMT   "%-12s : %16lld%16lld\n"
 
#define INDEX_FMT   "Overflows vector %#llx: \n"
 

Functions

static void handler (int EventSet, void *address, long long overflow_vector, void *context)
 
int main (int argc, char **argv)
 

Variables

static ocount_t overflow_counts [3] = { {0, 0}, {0, 0}, {0, 0} }
 
static int total_unknown = 0
 

Macro Definition Documentation

◆ INDEX_FMT

#define INDEX_FMT   "Overflows vector %#llx: \n"

Definition at line 19 of file overflow_index.c.

◆ OUT_FMT

#define OUT_FMT   "%-12s : %16lld%16lld\n"

Definition at line 18 of file overflow_index.c.

◆ OVER_FMT

#define OVER_FMT   "handler(%d) Overflow at %p! vector=%#llx\n"

Definition at line 17 of file overflow_index.c.

Function Documentation

◆ handler()

static void handler ( int  EventSet,
void *  address,
long long  overflow_vector,
void *  context 
)
static

Definition at line 33 of file overflow_index.c.

34{
35 int i;
36
37 ( void ) context;
38
39 if ( !TESTS_QUIET ) {
40 fprintf( stderr, OVER_FMT, EventSet, address, overflow_vector );
41 }
42
43 /* Look for the overflow_vector entry */
44
45 for ( i = 0; i < 3; i++ ) {
46 if ( overflow_counts[i].mask == overflow_vector ) {
47 overflow_counts[i].count++;
48 return;
49 }
50 }
51
52 /* Didn't find it so add it. */
53
54 for ( i = 0; i < 3; i++ ) {
55 if ( overflow_counts[i].mask == ( long long ) 0 ) {
56 overflow_counts[i].mask = overflow_vector;
57 overflow_counts[i].count = 1;
58 return;
59 }
60 }
61
62 /* Unknown entry!?! */
63
64 total_unknown++;
65}
i
int i
Definition: PAPI_get_virt_cyc.c:10
EventSet
static int EventSet
Definition: init_fini.c:8
TESTS_QUIET
int TESTS_QUIET
Definition: test_utils.c:18
OVER_FMT
#define OVER_FMT
Definition: overflow_index.c:17
total_unknown
static int total_unknown
Definition: overflow_index.c:30
overflow_counts
static ocount_t overflow_counts[3]
Definition: overflow_index.c:29
stderr
FILE * stderr
ocount_t::count
int count
Definition: overflow_index.c:24
ocount_t::mask
long long mask
Definition: overflow_index.c:23
Here is the caller graph for this function:

◆ main()

int main ( int  argc,
char **  argv 
)

Definition at line 68 of file overflow_index.c.

69{
70 int EventSet = PAPI_NULL;
71 long long ( values[3] )[2];
72 int retval;
73 int PAPI_event, k, i;
74 char event_name[PAPI_MAX_STR_LEN];
75 int index_array[2], number;
76 int num_events1, mask1;
77 int quiet;
78
79 /* Set TESTS_QUIET variable */
80 quiet = tests_quiet( argc, argv );
81
82 retval = PAPI_library_init( PAPI_VER_CURRENT );
83 if ( retval != PAPI_VER_CURRENT ) {
84 test_fail( __FILE__, __LINE__, "PAPI_library_init", retval );
85 }
86
87 /* add PAPI_TOT_CYC and one of the events in PAPI_FP_INS, PAPI_FP_OPS or
88 PAPI_TOT_INS, depends on the availability of the event on the
89 platform */
90 EventSet = add_two_nonderived_events( &num_events1, &PAPI_event, &mask1 );
91
92 if (num_events1==0) {
93 if (!quiet) printf("Trouble adding events\n");
94 test_skip(__FILE__,__LINE__,"Adding events",0);
95 }
96
97 retval = PAPI_start( EventSet );
98 if ( retval != PAPI_OK )
99 test_fail( __FILE__, __LINE__, "PAPI_start", retval );
100
101 do_flops( NUM_FLOPS );
102
103 retval = PAPI_stop( EventSet, values[0] );
104 if ( retval != PAPI_OK )
105 test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
106
107 retval = PAPI_overflow( EventSet, PAPI_event, THRESHOLD, 0, handler );
108 if ( retval != PAPI_OK )
109 test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
110 retval = PAPI_overflow( EventSet, PAPI_TOT_CYC, THRESHOLD, 0, handler );
111 if ( retval != PAPI_OK )
112 test_fail( __FILE__, __LINE__, "PAPI_overflow", retval );
113
114 retval = PAPI_start( EventSet );
115 if ( retval != PAPI_OK )
116 test_fail( __FILE__, __LINE__, "PAPI_start", retval );
117
118 do_flops( NUM_FLOPS );
119
120 retval = PAPI_stop( EventSet, values[1] );
121 if ( retval != PAPI_OK )
122 test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
123
124 retval = PAPI_event_code_to_name( PAPI_event, event_name );
125 if (retval != PAPI_OK ) {
126 test_fail( __FILE__, __LINE__, "PAPI_event_code_to_name", retval );
127 }
128
129 if (!quiet) {
130 printf( "Test case: Overflow dispatch of 2nd event in set with 2 events.\n" );
131 printf( "---------------------------------------------------------------\n" );
132 printf( "Threshold for overflow is: %d\n", THRESHOLD );
133 printf( "Using %d iterations of c += a*b\n", NUM_FLOPS );
134 printf( "-----------------------------------------------\n" );
135
136 printf( "Test type : %16d%16d\n", 1, 2 );
137 printf( OUT_FMT, "PAPI_TOT_CYC", ( values[0] )[0], ( values[1] )[0] );
138 printf( OUT_FMT, event_name, ( values[0] )[1], ( values[1] )[1] );
139 }
140
141 if ( overflow_counts[0].count == 0 && overflow_counts[1].count == 0 ) {
142 test_fail( __FILE__, __LINE__,
143 "one counter had no overflows", 1 );
144 }
145
146 for ( k = 0; k < 3; k++ ) {
147 if ( overflow_counts[k].mask ) {
148 number = 2;
149 retval = PAPI_get_overflow_event_index( EventSet,
150 overflow_counts[k].mask,
151 index_array, &number );
152 if ( retval != PAPI_OK ) {
153 test_fail( __FILE__, __LINE__,
154 "PAPI_get_overflow_event_index", retval );
155 }
156 if (!quiet) {
157 printf( INDEX_FMT, ( long long ) overflow_counts[k].mask );
158 printf( " counts: %d ", overflow_counts[k].count );
159 for ( i = 0; i < number; i++ )
160 printf( " Event Index %d ", index_array[i] );
161 printf( "\n" );
162 }
163 }
164 }
165
166 if (!quiet) {
167 printf( "Case 2 %s Overflows: %d\n", "Unknown", total_unknown );
168 printf( "-----------------------------------------------\n" );
169 }
170
171 if ( total_unknown > 0 ) {
172 test_fail( __FILE__, __LINE__, "Unknown counter had overflows", 1 );
173 }
174
175 retval = PAPI_cleanup_eventset( EventSet );
176 if ( retval != PAPI_OK ) {
177 test_fail( __FILE__, __LINE__, "PAPI_stop", retval );
178 }
179
180 test_pass( __FILE__ );
181
182 return 0;
183}
count
static long count
Definition: child_overflow.c:33
PAPI_cleanup_eventset
Empty and destroy an EventSet.
PAPI_event_code_to_name
Convert a numeric hardware event code to a name.
PAPI_get_overflow_event_index
converts an overflow vector into an array of indexes to overflowing events
PAPI_library_init
initialize the PAPI library.
PAPI_overflow
Set up an event set to begin registering overflows.
PAPI_start
Start counting hardware events in an event set.
PAPI_stop
Stop counting hardware events in an event set.
PAPI_event
int PAPI_event[2]
Definition: data_range.c:30
event_name
char event_name[2][PAPI_MAX_STR_LEN]
Definition: data_range.c:29
THRESHOLD
#define THRESHOLD
Definition: earprofile.c:37
PAPI_VER_CURRENT
#define PAPI_VER_CURRENT
Definition: f90papi.h:54
PAPI_OK
#define PAPI_OK
Definition: f90papi.h:73
PAPI_NULL
#define PAPI_NULL
Definition: f90papi.h:78
PAPI_TOT_CYC
#define PAPI_TOT_CYC
Definition: f90papi.h:308
PAPI_MAX_STR_LEN
#define PAPI_MAX_STR_LEN
Definition: f90papi.h:77
values
static long long values[NUM_EVENTS]
Definition: init_fini.c:10
do_flops
void do_flops(int n)
Definition: multiplex.c:23
handler
static void handler(int EventSet, void *address, long long overflow_vector, void *context)
Definition: overflow_index.c:33
INDEX_FMT
#define INDEX_FMT
Definition: overflow_index.c:19
OUT_FMT
#define OUT_FMT
Definition: overflow_index.c:18
tests_quiet
int tests_quiet(int argc, char **argv)
Definition: test_utils.c:376
add_two_nonderived_events
int add_two_nonderived_events(int *num_events, int *papi_event, int *mask)
Definition: test_utils.c:671
test_fail
void PAPI_NORETURN test_fail(const char *file, int line, const char *call, int retval)
Definition: test_utils.c:491
test_pass
void PAPI_NORETURN test_pass(const char *filename)
Definition: test_utils.c:432
test_skip
void PAPI_NORETURN test_skip(const char *file, int line, const char *call, int retval)
Definition: test_utils.c:584
quiet
int quiet
Definition: rapl_overflow.c:19
long
long long int long long
Definition: sde_internal.h:85
NUM_FLOPS
#define NUM_FLOPS
Definition: sdsc-mpx.c:24
num_events1
int num_events1
Definition: zero_fork.c:49
mask1
int mask1
Definition: zero_fork.c:48
retval
int retval
Definition: zero_fork.c:53
Here is the call graph for this function:

Variable Documentation

◆ overflow_counts

ocount_t overflow_counts[3] = { {0, 0}, {0, 0}, {0, 0} }
static

Definition at line 29 of file overflow_index.c.

◆ total_unknown

int total_unknown = 0
static

Definition at line 30 of file overflow_index.c.