PAPI 7.1.0.0
Loading...
Searching...
No Matches
Functions | Variables
branch.c File Reference
Include dependency graph for branch.c:

Go to the source code of this file.

Functions

void branch_driver (char *papi_event_name, int junk, hw_desc_t *hw_desc, char *outdir)
 
long long int branch_char_b1 (int size, int event_set)
 
long long int branch_char_b2 (int size, int event_set)
 
long long int branch_char_b3 (int size, int event_set)
 
long long int branch_char_b4 (int size, int event_set)
 
long long int branch_char_b4a (int size, int event_set)
 
long long int branch_char_b4b (int size, int event_set)
 
long long int branch_char_b5 (int size, int event_set)
 
long long int branch_char_b5a (int size, int event_set)
 
long long int branch_char_b5b (int size, int event_set)
 
long long int branch_char_b6 (int size, int event_set)
 
long long int branch_char_b7 (int size, int event_set)
 

Variables

volatile int iter_count
 
volatile int global_var1
 
volatile int global_var2
 
volatile int result
 
volatile unsigned int b
 
volatile unsigned int z1
 
volatile unsigned int z2
 
volatile unsigned int z3
 
volatile unsigned int z4
 

Function Documentation

◆ branch_char_b1()

long long int branch_char_b1 ( int  size,
int  event_set 
)

Definition at line 83 of file branch.c.

83 {
84 int retval;
85 long long int value;
86
87 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
88 return -1;
89 }
90
91 /*
92 1. Conditional EXECUTED = 2
93 1. Conditional RETIRED = 2
94 2. Conditional TAKEN = 1.5
95 4. Direct JUMP = 0
96 3. Branch MISPREDICT = 0
97 5. All Branches = 2
98 */
99
100 iter_count = 1;
101 global_var2 = 1;
102 do{
103 if ( iter_count < (size/2) ){
104 global_var2 += 2;
105 }
106 BRNG();
107 iter_count++;
108 }while(iter_count<size);
109
110 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
111 return -1;
112 }
113
114 return value;
115
116}
BRNG
#define BRNG()
Definition: Lib_With_Created_Counter.c:9
iter_count
volatile int iter_count
Definition: branch.c:11
global_var2
volatile int global_var2
Definition: branch.c:11
PAPI_start
Start counting hardware events in an event set.
PAPI_stop
Stop counting hardware events in an event set.
PAPI_OK
#define PAPI_OK
Definition: f90papi.h:73
retval
int retval
Definition: zero_fork.c:53

◆ branch_char_b2()

long long int branch_char_b2 ( int  size,
int  event_set 
)

Definition at line 118 of file branch.c.

118 {
119 int retval;
120 long long int value;
121
122 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
123 return -1;
124 }
125
126 /*
127 1. Conditional EXECUTED = 2
128 1. Conditional RETIRED = 2
129 2. Conditional TAKEN = 1
130 4. Direct JUMP = 0
131 3. Branch MISPREDICT = 0
132 5. All Branches = 2
133 */
134 iter_count = 1;
135 global_var2 = 1;
136 do{
137 global_var2+=2;
138 if ( iter_count < global_var2 ){
139 global_var1+=2;
140 }
141 BRNG();
142 iter_count++;
143 }while(iter_count<size);
144
145
146 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
147 return -1;
148 }
149 return value;
150
151}
global_var1
volatile int global_var1
Definition: branch.c:11

◆ branch_char_b3()

long long int branch_char_b3 ( int  size,
int  event_set 
)

Definition at line 153 of file branch.c.

153 {
154 int retval;
155 long long int value;
156
157 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
158 return -1;
159 }
160
161 /*
162 1. Conditional EXECUTED = 2
163 1. Conditional RETIRED = 2
164 2. Conditional TAKEN = 2
165 4. Direct JUMP = 0
166 3. Branch MISPREDICT = 0
167 5. All Branches = 2
168 */
169 iter_count = 1;
170 global_var2 = 1;
171 do{
172 global_var2+=2;
173 if ( iter_count > global_var2 ){
174 global_var1+=2;
175 }
176 BRNG();
177 iter_count++;
178 }while(iter_count<size);
179
180
181 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
182 return -1;
183 }
184 return value;
185
186}

◆ branch_char_b4()

long long int branch_char_b4 ( int  size,
int  event_set 
)

Definition at line 188 of file branch.c.

188 {
189 int retval;
190 long long int value;
191
192 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
193 return -1;
194 }
195
196 /*
197 1. Conditional EXECUTED = 2
198 1. Conditional RETIRED = 2
199 2. Conditional TAKEN = 1.5
200 4. Direct JUMP = 0
201 3. Branch MISPREDICT = 0.5
202 5. All Branches = 2
203 */
204
205 iter_count = 1;
206 do{
207 iter_count++;
208 BUSY_WORK();
209 BRNG();
210 if ( (result % 2) == 0 ){
211 global_var1+=2;
212 }
213 BUSY_WORK();
214 }while(iter_count<size);
215
216 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
217 return -1;
218 }
219
220 return value;
221
222}
result
volatile int result
Definition: branch.c:12
BUSY_WORK
#define BUSY_WORK()
Definition: branch.h:46

◆ branch_char_b4a()

long long int branch_char_b4a ( int  size,
int  event_set 
)

Definition at line 224 of file branch.c.

224 {
225 int retval;
226 long long int value;
227
228 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
229 return -1;
230 }
231
232 iter_count = 1;
233 do{
234 iter_count++;
235 BUSY_WORK();
236 BRNG();
237 if ( (result % 2) == 0 ){
238 BUSY_WORK();
239 if( (global_var1 % 2) == 0 ){
240 global_var2++;
241 }
242 global_var1+=2;
243 }
244 BUSY_WORK();
245 }while(iter_count<size);
246
247 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
248 return -1;
249 }
250
251 return value;
252
253}

◆ branch_char_b4b()

long long int branch_char_b4b ( int  size,
int  event_set 
)

Definition at line 255 of file branch.c.

255 {
256 int retval;
257 long long int value;
258
259 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
260 return -1;
261 }
262
263 iter_count = 1;
264 do{
265 iter_count++;
266 BUSY_WORK();
267 BRNG();
268 if ( (result % 2) == 0 ){
269 BUSY_WORK();
270 if( (global_var1 % 2) != 0 ){
271 global_var2++;
272 }
273 global_var1+=2;
274 }
275 BUSY_WORK();
276 }while(iter_count<size);
277
278 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
279 return -1;
280 }
281
282 return value;
283
284}

◆ branch_char_b5()

long long int branch_char_b5 ( int  size,
int  event_set 
)

Definition at line 286 of file branch.c.

286 {
287 int retval;
288 long long int value;
289
290 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
291 return -1;
292 }
293
294 /*
295 1. Conditional EXECUTED = 2.5
296 1. Conditional RETIRED = 2
297 2. Conditional TAKEN = 1.5
298 4. Direct JUMP = 0
299 3. Branch MISPREDICT = 0.5
300 5. All Branches = ??
301 */
302
303 iter_count = 1;
304 global_var2 = 0;
305 do{
306 iter_count++;
307 BUSY_WORK();
308 BRNG();
309 if ( (result % 2) == 0 ){
310 global_var1+=2;
311 }
312 }while(iter_count<size);
313
314 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
315 return -1;
316 }
317
318 return value;
319
320}

◆ branch_char_b5a()

long long int branch_char_b5a ( int  size,
int  event_set 
)

Definition at line 322 of file branch.c.

322 {
323 int retval;
324 long long int value;
325
326 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
327 return -1;
328 }
329
330
331 iter_count = 1;
332 global_var2 = 0;
333 do{
334 iter_count++;
335 BUSY_WORK();
336 BRNG();
337 if ( (result % 2) == 0 ){
338 if( (global_var1 % 2) == 0 ){
339 global_var2++;
340 }
341 global_var1+=2;
342 BUSY_WORK();
343 }
344 }while(iter_count<size);
345
346 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
347 return -1;
348 }
349
350 return value;
351
352}

◆ branch_char_b5b()

long long int branch_char_b5b ( int  size,
int  event_set 
)

Definition at line 354 of file branch.c.

354 {
355 int retval;
356 long long int value;
357
358 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
359 return -1;
360 }
361
362
363 iter_count = 1;
364 global_var2 = 0;
365 do{
366 iter_count++;
367 BUSY_WORK();
368 BRNG();
369 if ( (result % 2) == 0 ){
370 if( (global_var1 % 2) != 0 ){
371 global_var2++;
372 }
373 global_var1+=2;
374 BUSY_WORK();
375 }
376 }while(iter_count<size);
377
378 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
379 return -1;
380 }
381
382 return value;
383
384}

◆ branch_char_b6()

long long int branch_char_b6 ( int  size,
int  event_set 
)

Definition at line 386 of file branch.c.

386 {
387 int retval;
388 long long int value;
389
390 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
391 return -1;
392 }
393
394 /*
395 1. Conditional JUMP = 2
396 2. Conditional TAKEN = 1
397 3. Branch MISPREDICT = 0
398 4. Direct JUMP = 1
399 5. All Branches = 3
400 */
401
402 iter_count = 1;
403 global_var2 = 1;
404 do{
405 BRNG();
406 global_var2+=2;
407 if ( iter_count < global_var2 ){
408 global_var1+=2;
409 goto zzz;
410 }
411 BRNG();
412 zzz: iter_count++;
413 BRNG();
414 }while(iter_count<size);
415
416
417 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
418 return -1;
419 }
420 return value;
421
422}

◆ branch_char_b7()

long long int branch_char_b7 ( int  size,
int  event_set 
)

Definition at line 424 of file branch.c.

424 {
425 int retval;
426 long long int value;
427
428 if ( (retval=PAPI_start(event_set)) != PAPI_OK){
429 return -1;
430 }
431
432 /*
433 1. Conditional JUMP = 1
434 2. Conditional TAKEN = 1
435 3. Branch MISPREDICT = 0
436 4. Direct JUMP = 0
437 5. All Branches = 1
438 */
439
440 iter_count = 1;
441 global_var2 = 1;
442 do{
443 global_var2=global_var2+2;
444 iter_count++;
445 }while(iter_count<size);
446
447 if ( (retval=PAPI_stop(event_set, &value)) != PAPI_OK){
448 return -1;
449 }
450 return value;
451
452}

◆ branch_driver()

void branch_driver ( char *  papi_event_name,
int  junk,
hw_desc_t *  hw_desc,
char *  outdir 
)

Definition at line 15 of file branch.c.

15 {
16 int papi_eventset = PAPI_NULL;
17 int i, iter, sz, ret_val, max_iter = 16*1024;
18 long long int cnt;
19 double avg, round;
20 FILE* ofp_papi;
21 const char *sufx = ".branch";
22 int l = strlen(outdir)+strlen(papi_event_name)+strlen(sufx);
23
24 (void)hw_desc;
25
26 char *papiFileName = (char *)calloc( 1+l, sizeof(char) );
27 if (l != (sprintf(papiFileName, "%s%s%s", outdir, papi_event_name, sufx))) {
28 goto error0;
29 }
30 if (NULL == (ofp_papi = fopen(papiFileName,"w"))) {
31 fprintf(stderr, "Unable to open file %s.\n", papiFileName);
32 goto error0;
33 }
34
35 // Initialize undecidible values for the BRNG macro.
36 z1 = junk*7;
37 z2 = (junk+4)/(junk+1);
38 z3 = junk;
39 z4 = (z3+z2)/z1;
40
41 ret_val = PAPI_create_eventset( &papi_eventset );
42 if (ret_val != PAPI_OK){
43 goto error1;
44 }
45
46 ret_val = PAPI_add_named_event( papi_eventset, papi_event_name );
47 if (ret_val != PAPI_OK){
48 goto error1;
49 }
50
51 BRANCH_BENCH(1);
52 BRANCH_BENCH(2);
53 BRANCH_BENCH(3);
54 BRANCH_BENCH(4);
55 BRANCH_BENCH(4a);
56 BRANCH_BENCH(4b);
57 BRANCH_BENCH(5);
58 BRANCH_BENCH(5a);
59 BRANCH_BENCH(5b);
60 BRANCH_BENCH(6);
61 BRANCH_BENCH(7);
62
63 if( result == 143526 ){
64 printf("Random side effect\n");
65 }
66
67 ret_val = PAPI_cleanup_eventset( papi_eventset );
68 if (ret_val != PAPI_OK ){
69 goto error1;
70 }
71 ret_val = PAPI_destroy_eventset( &papi_eventset );
72 if (ret_val != PAPI_OK ){
73 goto error1;
74 }
75
76error1:
77 fclose(ofp_papi);
78error0:
79 free(papiFileName);
80 return;
81}
i
int i
Definition: PAPI_get_virt_cyc.c:10
z1
volatile unsigned int z1
Definition: branch.c:13
b
volatile unsigned int b
Definition: branch.c:13
z2
volatile unsigned int z2
Definition: branch.c:13
z3
volatile unsigned int z3
Definition: branch.c:13
z4
volatile unsigned int z4
Definition: branch.c:13
BRANCH_BENCH
#define BRANCH_BENCH(_I_)
Definition: branch.h:6
PAPI_add_named_event
add PAPI preset or native hardware event by name to an EventSet
PAPI_cleanup_eventset
Empty and destroy an EventSet.
PAPI_create_eventset
Create a new empty PAPI EventSet.
PAPI_destroy_eventset
Empty and destroy an EventSet.
PAPI_NULL
#define PAPI_NULL
Definition: f90papi.h:78
iter
static long iter[MAX_THREADS]
Definition: krentel_pthreads.c:22
a
static double a[MATRIX_SIZE][MATRIX_SIZE]
Definition: libmsr_basic.c:38
stderr
FILE * stderr
fclose
int fclose(FILE *__stream)
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ b

volatile unsigned int b

Definition at line 13 of file branch.c.

◆ global_var1

volatile int global_var1

Definition at line 11 of file branch.c.

◆ global_var2

volatile int global_var2

Definition at line 11 of file branch.c.

◆ iter_count

volatile int iter_count

Definition at line 11 of file branch.c.

◆ result

volatile int result

Definition at line 12 of file branch.c.

◆ z1

volatile unsigned int z1

Definition at line 13 of file branch.c.

◆ z2

volatile unsigned int z2

Definition at line 13 of file branch.c.

◆ z3

volatile unsigned int z3

Definition at line 13 of file branch.c.

◆ z4

volatile unsigned int z4

Definition at line 13 of file branch.c.