1 /*- 2 * Copyright (c) 2014, 2015 Netflix Inc. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * in this position and unchanged. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. The name of the author may not be used to endorse or promote products 15 * derived from this software without specific prior written permission 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 #include <sys/types.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <unistd.h> 32 #include <string.h> 33 #include <strings.h> 34 #include <sys/errno.h> 35 #include <signal.h> 36 #include <sys/wait.h> 37 #include <getopt.h> 38 #include "eval_expr.h" 39 __FBSDID("$FreeBSD$"); 40 41 static int max_pmc_counters = 1; 42 static int run_all = 0; 43 44 #define MAX_COUNTER_SLOTS 1024 45 #define MAX_NLEN 64 46 #define MAX_CPU 64 47 static int verbose = 0; 48 49 extern char **environ; 50 extern struct expression *master_exp; 51 struct expression *master_exp=NULL; 52 53 #define PMC_INITIAL_ALLOC 512 54 extern char **valid_pmcs; 55 char **valid_pmcs = NULL; 56 extern int valid_pmc_cnt; 57 int valid_pmc_cnt=0; 58 extern int pmc_allocated_cnt; 59 int pmc_allocated_cnt=0; 60 61 /* 62 * The following two varients on popen and pclose with 63 * the cavet that they get you the PID so that you 64 * can supply it to pclose so it can send a SIGTERM 65 * to the process. 66 */ 67 static FILE * 68 my_popen(const char *command, const char *dir, pid_t *p_pid) 69 { 70 FILE *io_out, *io_in; 71 int pdesin[2], pdesout[2]; 72 char *argv[4]; 73 pid_t pid; 74 char cmd[4]; 75 char cmd2[1024]; 76 char arg1[4]; 77 78 if ((strcmp(dir, "r") != 0) && 79 (strcmp(dir, "w") != 0)) { 80 errno = EINVAL; 81 return(NULL); 82 } 83 if (pipe(pdesin) < 0) 84 return (NULL); 85 86 if (pipe(pdesout) < 0) { 87 (void)close(pdesin[0]); 88 (void)close(pdesin[1]); 89 return (NULL); 90 } 91 strcpy(cmd, "sh"); 92 strcpy(arg1, "-c"); 93 strcpy(cmd2, command); 94 argv[0] = cmd; 95 argv[1] = arg1; 96 argv[2] = cmd2; 97 argv[3] = NULL; 98 99 switch (pid = fork()) { 100 case -1: /* Error. */ 101 (void)close(pdesin[0]); 102 (void)close(pdesin[1]); 103 (void)close(pdesout[0]); 104 (void)close(pdesout[1]); 105 return (NULL); 106 /* NOTREACHED */ 107 case 0: /* Child. */ 108 /* Close out un-used sides */ 109 (void)close(pdesin[1]); 110 (void)close(pdesout[0]); 111 /* Now prepare the stdin of the process */ 112 close(0); 113 (void)dup(pdesin[0]); 114 (void)close(pdesin[0]); 115 /* Now prepare the stdout of the process */ 116 close(1); 117 (void)dup(pdesout[1]); 118 /* And lets do stderr just in case */ 119 close(2); 120 (void)dup(pdesout[1]); 121 (void)close(pdesout[1]); 122 /* Now run it */ 123 execve("/bin/sh", argv, environ); 124 exit(127); 125 /* NOTREACHED */ 126 } 127 /* Parent; assume fdopen can't fail. */ 128 /* Store the pid */ 129 *p_pid = pid; 130 if (strcmp(dir, "r") != 0) { 131 io_out = fdopen(pdesin[1], "w"); 132 (void)close(pdesin[0]); 133 (void)close(pdesout[0]); 134 (void)close(pdesout[1]); 135 return(io_out); 136 } else { 137 /* Prepare the input stream */ 138 io_in = fdopen(pdesout[0], "r"); 139 (void)close(pdesout[1]); 140 (void)close(pdesin[0]); 141 (void)close(pdesin[1]); 142 return (io_in); 143 } 144 } 145 146 /* 147 * pclose -- 148 * Pclose returns -1 if stream is not associated with a `popened' command, 149 * if already `pclosed', or waitpid returns an error. 150 */ 151 static void 152 my_pclose(FILE *io, pid_t the_pid) 153 { 154 int pstat; 155 pid_t pid; 156 157 /* 158 * Find the appropriate file pointer and remove it from the list. 159 */ 160 (void)fclose(io); 161 /* Die if you are not dead! */ 162 kill(the_pid, SIGTERM); 163 do { 164 pid = wait4(the_pid, &pstat, 0, (struct rusage *)0); 165 } while (pid == -1 && errno == EINTR); 166 } 167 168 struct counters { 169 struct counters *next_cpu; 170 char counter_name[MAX_NLEN]; /* Name of counter */ 171 int cpu; /* CPU we are on */ 172 int pos; /* Index we are filling to. */ 173 uint64_t vals[MAX_COUNTER_SLOTS]; /* Last 64 entries */ 174 uint64_t sum; /* Summary of entries */ 175 }; 176 177 extern struct counters *glob_cpu[MAX_CPU]; 178 struct counters *glob_cpu[MAX_CPU]; 179 180 extern struct counters *cnts; 181 struct counters *cnts=NULL; 182 183 extern int ncnts; 184 int ncnts=0; 185 186 extern int (*expression)(struct counters *, int); 187 int (*expression)(struct counters *, int); 188 189 static const char *threshold=NULL; 190 static const char *command; 191 192 struct cpu_entry { 193 const char *name; 194 const char *thresh; 195 const char *command; 196 int (*func)(struct counters *, int); 197 int counters_required; 198 }; 199 200 struct cpu_type { 201 char cputype[32]; 202 int number; 203 struct cpu_entry *ents; 204 void (*explain)(const char *name); 205 }; 206 extern struct cpu_type the_cpu; 207 struct cpu_type the_cpu; 208 209 static void 210 explain_name_sb(const char *name) 211 { 212 const char *mythresh; 213 if (strcmp(name, "allocstall1") == 0) { 214 printf("Examine PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW / CPU_CLK_UNHALTED.THREAD_P\n"); 215 mythresh = "thresh > .05"; 216 } else if (strcmp(name, "allocstall2") == 0) { 217 printf("Examine PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP_CYCLES/CPU_CLK_UNHALTED.THREAD_P\n"); 218 mythresh = "thresh > .05"; 219 } else if (strcmp(name, "br_miss") == 0) { 220 printf("Examine (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD_P\n"); 221 mythresh = "thresh >= .2"; 222 } else if (strcmp(name, "splitload") == 0) { 223 printf("Examine MEM_UOPS_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); 224 mythresh = "thresh >= .1"; 225 } else if (strcmp(name, "splitstore") == 0) { 226 printf("Examine MEM_UOPS_RETIRED.SPLIT_STORES / MEM_UOPS_RETIRED.ALL_STORES\n"); 227 mythresh = "thresh >= .01"; 228 } else if (strcmp(name, "contested") == 0) { 229 printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P\n"); 230 mythresh = "thresh >= .05"; 231 } else if (strcmp(name, "blockstorefwd") == 0) { 232 printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); 233 mythresh = "thresh >= .05"; 234 } else if (strcmp(name, "cache2") == 0) { 235 printf("Examine ((MEM_LOAD_RETIRED.L3_HIT * 26) + \n"); 236 printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 43) + \n"); 237 printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60)) / CPU_CLK_UNHALTED.THREAD_P\n"); 238 printf("**Note we have it labeled MEM_LOAD_UOPS_RETIRED.LLC_HIT not MEM_LOAD_RETIRED.L3_HIT\n"); 239 mythresh = "thresh >= .2"; 240 } else if (strcmp(name, "cache1") == 0) { 241 printf("Examine (MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); 242 mythresh = "thresh >= .2"; 243 } else if (strcmp(name, "dtlbmissload") == 0) { 244 printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); 245 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 246 mythresh = "thresh >= .1"; 247 } else if (strcmp(name, "frontendstall") == 0) { 248 printf("Examine IDQ_UOPS_NOT_DELIVERED.CORE / (CPU_CLK_UNHALTED.THREAD_P * 4)\n"); 249 mythresh = "thresh >= .15"; 250 } else if (strcmp(name, "clears") == 0) { 251 printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); 252 printf(" MACHINE_CLEARS.SMC + \n"); 253 printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); 254 mythresh = "thresh >= .02"; 255 } else if (strcmp(name, "microassist") == 0) { 256 printf("Examine IDQ.MS_CYCLES / (CPU_CLK_UNHALTED.THREAD_P * 4)\n"); 257 printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); 258 mythresh = "thresh >= .05"; 259 } else if (strcmp(name, "aliasing_4k") == 0) { 260 printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); 261 mythresh = "thresh >= .1"; 262 } else if (strcmp(name, "fpassist") == 0) { 263 printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); 264 mythresh = "look for a excessive value"; 265 } else if (strcmp(name, "otherassistavx") == 0) { 266 printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 267 mythresh = "look for a excessive value"; 268 } else if (strcmp(name, "otherassistsse") == 0) { 269 printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 270 mythresh = "look for a excessive value"; 271 } else if (strcmp(name, "eff1") == 0) { 272 printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); 273 mythresh = "thresh < .9"; 274 } else if (strcmp(name, "eff2") == 0) { 275 printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); 276 mythresh = "thresh > 1.0"; 277 } else if (strcmp(name, "dtlbmissstore") == 0) { 278 printf("Examine (((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION)\n"); 279 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 280 mythresh = "thresh >= .05"; 281 } else { 282 printf("Unknown name:%s\n", name); 283 mythresh = "unknown entry"; 284 } 285 printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); 286 } 287 288 static void 289 explain_name_ib(const char *name) 290 { 291 const char *mythresh; 292 if (strcmp(name, "br_miss") == 0) { 293 printf("Examine ((BR_MISP_RETIRED.ALL_BRANCHES /(BR_MISP_RETIRED.ALL_BRANCHES +\n"); 294 printf(" MACHINE_CLEAR.COUNT) * ((UOPS_ISSUED.ANY - UOPS_RETIRED.RETIRE_SLOTS + 4 * INT_MISC.RECOVERY_CYCLES)\n"); 295 printf("/ (4 * CPU_CLK_UNHALTED.THREAD))))\n"); 296 mythresh = "thresh >= .2"; 297 } else if (strcmp(name, "eff1") == 0) { 298 printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); 299 mythresh = "thresh < .9"; 300 } else if (strcmp(name, "eff2") == 0) { 301 printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); 302 mythresh = "thresh > 1.0"; 303 } else if (strcmp(name, "cache1") == 0) { 304 printf("Examine (MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); 305 mythresh = "thresh >= .2"; 306 } else if (strcmp(name, "cache2") == 0) { 307 printf("Examine (MEM_LOAD_UOPS_RETIRED.LLC_HIT / CPU_CLK_UNHALTED.THREAD_P\n"); 308 mythresh = "thresh >= .2"; 309 } else if (strcmp(name, "itlbmiss") == 0) { 310 printf("Examine ITLB_MISSES.WALK_DURATION / CPU_CLK_UNHALTED.THREAD_P\n"); 311 mythresh = "thresh > .05"; 312 } else if (strcmp(name, "icachemiss") == 0) { 313 printf("Examine (ICACHE.IFETCH_STALL - ITLB_MISSES.WALK_DURATION)/ CPU_CLK_UNHALTED.THREAD_P\n"); 314 mythresh = "thresh > .05"; 315 } else if (strcmp(name, "lcpstall") == 0) { 316 printf("Examine ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P\n"); 317 mythresh = "thresh > .05"; 318 } else if (strcmp(name, "datashare") == 0) { 319 printf("Examine (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/CPU_CLK_UNHALTED.THREAD_P\n"); 320 mythresh = "thresh > .05"; 321 } else if (strcmp(name, "blockstorefwd") == 0) { 322 printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); 323 mythresh = "thresh >= .05"; 324 } else if (strcmp(name, "splitload") == 0) { 325 printf("Examine ((L1D_PEND_MISS.PENDING / MEM_LOAD_UOPS_RETIRED.L1_MISS) *\n"); 326 printf(" LD_BLOCKS.NO_SR)/CPU_CLK_UNHALTED.THREAD_P\n"); 327 mythresh = "thresh >= .1"; 328 } else if (strcmp(name, "splitstore") == 0) { 329 printf("Examine MEM_UOPS_RETIRED.SPLIT_STORES / MEM_UOPS_RETIRED.ALL_STORES\n"); 330 mythresh = "thresh >= .01"; 331 } else if (strcmp(name, "aliasing_4k") == 0) { 332 printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); 333 mythresh = "thresh >= .1"; 334 } else if (strcmp(name, "dtlbmissload") == 0) { 335 printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); 336 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 337 mythresh = "thresh >= .1"; 338 } else if (strcmp(name, "dtlbmissstore") == 0) { 339 printf("Examine (((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION)\n"); 340 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 341 mythresh = "thresh >= .05"; 342 } else if (strcmp(name, "contested") == 0) { 343 printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P\n"); 344 mythresh = "thresh >= .05"; 345 } else if (strcmp(name, "clears") == 0) { 346 printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); 347 printf(" MACHINE_CLEARS.SMC + \n"); 348 printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); 349 mythresh = "thresh >= .02"; 350 } else if (strcmp(name, "microassist") == 0) { 351 printf("Examine IDQ.MS_CYCLES / (4 * CPU_CLK_UNHALTED.THREAD_P)\n"); 352 printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); 353 mythresh = "thresh >= .05"; 354 } else if (strcmp(name, "fpassist") == 0) { 355 printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); 356 mythresh = "look for a excessive value"; 357 } else if (strcmp(name, "otherassistavx") == 0) { 358 printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 359 mythresh = "look for a excessive value"; 360 } else if (strcmp(name, "otherassistsse") == 0) { 361 printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 362 mythresh = "look for a excessive value"; 363 } else { 364 printf("Unknown name:%s\n", name); 365 mythresh = "unknown entry"; 366 } 367 printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); 368 } 369 370 371 static void 372 explain_name_has(const char *name) 373 { 374 const char *mythresh; 375 if (strcmp(name, "eff1") == 0) { 376 printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); 377 mythresh = "thresh < .75"; 378 } else if (strcmp(name, "eff2") == 0) { 379 printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); 380 mythresh = "thresh > 1.0"; 381 } else if (strcmp(name, "itlbmiss") == 0) { 382 printf("Examine ITLB_MISSES.WALK_DURATION / CPU_CLK_UNHALTED.THREAD_P\n"); 383 mythresh = "thresh > .05"; 384 } else if (strcmp(name, "icachemiss") == 0) { 385 printf("Examine (36 * ICACHE.MISSES)/ CPU_CLK_UNHALTED.THREAD_P\n"); 386 mythresh = "thresh > .05"; 387 } else if (strcmp(name, "lcpstall") == 0) { 388 printf("Examine ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P\n"); 389 mythresh = "thresh > .05"; 390 } else if (strcmp(name, "cache1") == 0) { 391 printf("Examine (MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); 392 mythresh = "thresh >= .2"; 393 } else if (strcmp(name, "cache2") == 0) { 394 printf("Examine ((MEM_LOAD_UOPS_RETIRED.LLC_HIT * 36) + \n"); 395 printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 72) + \n"); 396 printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84))\n"); 397 printf(" / CPU_CLK_UNHALTED.THREAD_P\n"); 398 mythresh = "thresh >= .2"; 399 } else if (strcmp(name, "contested") == 0) { 400 printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) / CPU_CLK_UNHALTED.THREAD_P\n"); 401 mythresh = "thresh >= .05"; 402 } else if (strcmp(name, "datashare") == 0) { 403 printf("Examine (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 72)/CPU_CLK_UNHALTED.THREAD_P\n"); 404 mythresh = "thresh > .05"; 405 } else if (strcmp(name, "blockstorefwd") == 0) { 406 printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); 407 mythresh = "thresh >= .05"; 408 } else if (strcmp(name, "splitload") == 0) { 409 printf("Examine (MEM_UOPS_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); 410 mythresh = "thresh >= .1"; 411 } else if (strcmp(name, "splitstore") == 0) { 412 printf("Examine MEM_UOPS_RETIRED.SPLIT_STORES / MEM_UOPS_RETIRED.ALL_STORES\n"); 413 mythresh = "thresh >= .01"; 414 } else if (strcmp(name, "aliasing_4k") == 0) { 415 printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); 416 mythresh = "thresh >= .1"; 417 } else if (strcmp(name, "dtlbmissload") == 0) { 418 printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); 419 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 420 mythresh = "thresh >= .1"; 421 } else if (strcmp(name, "br_miss") == 0) { 422 printf("Examine (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD\n"); 423 mythresh = "thresh >= .2"; 424 } else if (strcmp(name, "clears") == 0) { 425 printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); 426 printf(" MACHINE_CLEARS.SMC + \n"); 427 printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); 428 mythresh = "thresh >= .02"; 429 } else if (strcmp(name, "microassist") == 0) { 430 printf("Examine IDQ.MS_CYCLES / (4 * CPU_CLK_UNHALTED.THREAD_P)\n"); 431 printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); 432 mythresh = "thresh >= .05"; 433 } else if (strcmp(name, "fpassist") == 0) { 434 printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); 435 mythresh = "look for a excessive value"; 436 } else if (strcmp(name, "otherassistavx") == 0) { 437 printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 438 mythresh = "look for a excessive value"; 439 } else if (strcmp(name, "otherassistsse") == 0) { 440 printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 441 mythresh = "look for a excessive value"; 442 } else { 443 printf("Unknown name:%s\n", name); 444 mythresh = "unknown entry"; 445 } 446 printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); 447 } 448 449 450 451 static struct counters * 452 find_counter(struct counters *base, const char *name) 453 { 454 struct counters *at; 455 int len; 456 457 at = base; 458 len = strlen(name); 459 while(at) { 460 if (strncmp(at->counter_name, name, len) == 0) { 461 return(at); 462 } 463 at = at->next_cpu; 464 } 465 printf("Can't find counter %s\n", name); 466 printf("We have:\n"); 467 at = base; 468 while(at) { 469 printf("- %s\n", at->counter_name); 470 at = at->next_cpu; 471 } 472 exit(-1); 473 } 474 475 static int 476 allocstall1(struct counters *cpu, int pos) 477 { 478 /* 1 - PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW/CPU_CLK_UNHALTED.THREAD_P (thresh > .05)*/ 479 int ret; 480 struct counters *partial; 481 struct counters *unhalt; 482 double un, par, res; 483 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 484 partial = find_counter(cpu, "PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW"); 485 if (pos != -1) { 486 par = partial->vals[pos] * 1.0; 487 un = unhalt->vals[pos] * 1.0; 488 } else { 489 par = partial->sum * 1.0; 490 un = unhalt->sum * 1.0; 491 } 492 res = par/un; 493 ret = printf("%1.3f", res); 494 return(ret); 495 } 496 497 static int 498 allocstall2(struct counters *cpu, int pos) 499 { 500 /* 2 - PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP_CYCLES/CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ 501 int ret; 502 struct counters *partial; 503 struct counters *unhalt; 504 double un, par, res; 505 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 506 partial = find_counter(cpu, "PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP"); 507 if (pos != -1) { 508 par = partial->vals[pos] * 1.0; 509 un = unhalt->vals[pos] * 1.0; 510 } else { 511 par = partial->sum * 1.0; 512 un = unhalt->sum * 1.0; 513 } 514 res = par/un; 515 ret = printf("%1.3f", res); 516 return(ret); 517 } 518 519 static int 520 br_mispredict(struct counters *cpu, int pos) 521 { 522 struct counters *brctr; 523 struct counters *unhalt; 524 int ret; 525 /* 3 - (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ 526 double br, un, con, res; 527 con = 20.0; 528 529 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 530 brctr = find_counter(cpu, "BR_MISP_RETIRED.ALL_BRANCHES"); 531 if (pos != -1) { 532 br = brctr->vals[pos] * 1.0; 533 un = unhalt->vals[pos] * 1.0; 534 } else { 535 br = brctr->sum * 1.0; 536 un = unhalt->sum * 1.0; 537 } 538 res = (con * br)/un; 539 ret = printf("%1.3f", res); 540 return(ret); 541 } 542 543 static int 544 br_mispredictib(struct counters *cpu, int pos) 545 { 546 struct counters *brctr; 547 struct counters *unhalt; 548 struct counters *clear, *clear2, *clear3; 549 struct counters *uops; 550 struct counters *recv; 551 struct counters *iss; 552 /* "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s UOPS_ISSUED.ANY -s UOPS_RETIRED.RETIRE_SLOTS -s INT_MISC.RECOVERY_CYCLES -w 1",*/ 553 int ret; 554 /* 555 * (BR_MISP_RETIRED.ALL_BRANCHES / 556 * (BR_MISP_RETIRED.ALL_BRANCHES + 557 * MACHINE_CLEAR.COUNT) * 558 * ((UOPS_ISSUED.ANY - UOPS_RETIRED.RETIRE_SLOTS + 4 * INT_MISC.RECOVERY_CYCLES) / (4 * CPU_CLK_UNHALTED.THREAD))) 559 * 560 */ 561 double br, cl, cl2, cl3, uo, re, un, con, res, is; 562 con = 4.0; 563 564 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 565 brctr = find_counter(cpu, "BR_MISP_RETIRED.ALL_BRANCHES"); 566 clear = find_counter(cpu, "MACHINE_CLEARS.MEMORY_ORDERING"); 567 clear2 = find_counter(cpu, "MACHINE_CLEARS.SMC"); 568 clear3 = find_counter(cpu, "MACHINE_CLEARS.MASKMOV"); 569 uops = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); 570 iss = find_counter(cpu, "UOPS_ISSUED.ANY"); 571 recv = find_counter(cpu, "INT_MISC.RECOVERY_CYCLES"); 572 if (pos != -1) { 573 br = brctr->vals[pos] * 1.0; 574 cl = clear->vals[pos] * 1.0; 575 cl2 = clear2->vals[pos] * 1.0; 576 cl3 = clear3->vals[pos] * 1.0; 577 uo = uops->vals[pos] * 1.0; 578 re = recv->vals[pos] * 1.0; 579 is = iss->vals[pos] * 1.0; 580 un = unhalt->vals[pos] * 1.0; 581 } else { 582 br = brctr->sum * 1.0; 583 cl = clear->sum * 1.0; 584 cl2 = clear2->sum * 1.0; 585 cl3 = clear3->sum * 1.0; 586 uo = uops->sum * 1.0; 587 re = recv->sum * 1.0; 588 is = iss->sum * 1.0; 589 un = unhalt->sum * 1.0; 590 } 591 res = (br/(br + cl + cl2 + cl3) * ((is - uo + con * re) / (con * un))); 592 ret = printf("%1.3f", res); 593 return(ret); 594 } 595 596 597 static int 598 br_mispredict_broad(struct counters *cpu, int pos) 599 { 600 struct counters *brctr; 601 struct counters *unhalt; 602 struct counters *clear; 603 struct counters *uops; 604 struct counters *uops_ret; 605 struct counters *recv; 606 int ret; 607 double br, cl, uo, uo_r, re, con, un, res; 608 609 con = 4.0; 610 611 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 612 brctr = find_counter(cpu, "BR_MISP_RETIRED.ALL_BRANCHES"); 613 clear = find_counter(cpu, "MACHINE_CLEARS.CYCLES"); 614 uops = find_counter(cpu, "UOPS_ISSUED.ANY"); 615 uops_ret = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); 616 recv = find_counter(cpu, "INT_MISC.RECOVERY_CYCLES"); 617 618 if (pos != -1) { 619 un = unhalt->vals[pos] * 1.0; 620 br = brctr->vals[pos] * 1.0; 621 cl = clear->vals[pos] * 1.0; 622 uo = uops->vals[pos] * 1.0; 623 uo_r = uops_ret->vals[pos] * 1.0; 624 re = recv->vals[pos] * 1.0; 625 } else { 626 un = unhalt->sum * 1.0; 627 br = brctr->sum * 1.0; 628 cl = clear->sum * 1.0; 629 uo = uops->sum * 1.0; 630 uo_r = uops_ret->sum * 1.0; 631 re = recv->sum * 1.0; 632 } 633 res = br / (br + cl) * (uo - uo_r + con * re) / (un * con); 634 ret = printf("%1.3f", res); 635 return(ret); 636 } 637 638 static int 639 splitloadib(struct counters *cpu, int pos) 640 { 641 int ret; 642 struct counters *mem; 643 struct counters *l1d, *ldblock; 644 struct counters *unhalt; 645 double un, memd, res, l1, ldb; 646 /* 647 * ((L1D_PEND_MISS.PENDING / MEM_LOAD_UOPS_RETIRED.L1_MISS) * LD_BLOCKS.NO_SR) / CPU_CLK_UNHALTED.THREAD_P 648 * "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s L1D_PEND_MISS.PENDING -s MEM_LOAD_UOPS_RETIRED.L1_MISS -s LD_BLOCKS.NO_SR -w 1", 649 */ 650 651 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 652 mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.L1_MISS"); 653 l1d = find_counter(cpu, "L1D_PEND_MISS.PENDING"); 654 ldblock = find_counter(cpu, "LD_BLOCKS.NO_SR"); 655 if (pos != -1) { 656 memd = mem->vals[pos] * 1.0; 657 l1 = l1d->vals[pos] * 1.0; 658 ldb = ldblock->vals[pos] * 1.0; 659 un = unhalt->vals[pos] * 1.0; 660 } else { 661 memd = mem->sum * 1.0; 662 l1 = l1d->sum * 1.0; 663 ldb = ldblock->sum * 1.0; 664 un = unhalt->sum * 1.0; 665 } 666 res = ((l1 / memd) * ldb)/un; 667 ret = printf("%1.3f", res); 668 return(ret); 669 } 670 671 672 static int 673 splitload(struct counters *cpu, int pos) 674 { 675 int ret; 676 struct counters *mem; 677 struct counters *unhalt; 678 double con, un, memd, res; 679 /* 4 - (MEM_UOPS_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .1)*/ 680 681 con = 5.0; 682 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 683 mem = find_counter(cpu, "MEM_UOPS_RETIRED.SPLIT_LOADS"); 684 if (pos != -1) { 685 memd = mem->vals[pos] * 1.0; 686 un = unhalt->vals[pos] * 1.0; 687 } else { 688 memd = mem->sum * 1.0; 689 un = unhalt->sum * 1.0; 690 } 691 res = (memd * con)/un; 692 ret = printf("%1.3f", res); 693 return(ret); 694 } 695 696 697 static int 698 splitload_sb(struct counters *cpu, int pos) 699 { 700 int ret; 701 struct counters *mem; 702 struct counters *unhalt; 703 double con, un, memd, res; 704 /* 4 - (MEM_UOP_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .1)*/ 705 706 con = 5.0; 707 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 708 mem = find_counter(cpu, "MEM_UOP_RETIRED.SPLIT_LOADS"); 709 if (pos != -1) { 710 memd = mem->vals[pos] * 1.0; 711 un = unhalt->vals[pos] * 1.0; 712 } else { 713 memd = mem->sum * 1.0; 714 un = unhalt->sum * 1.0; 715 } 716 res = (memd * con)/un; 717 ret = printf("%1.3f", res); 718 return(ret); 719 } 720 721 722 static int 723 splitstore_sb(struct counters *cpu, int pos) 724 { 725 /* 5 - MEM_UOP_RETIRED.SPLIT_STORES / MEM_UOP_RETIRED.ALL_STORES (thresh > 0.01) */ 726 int ret; 727 struct counters *mem_split; 728 struct counters *mem_stores; 729 double memsplit, memstore, res; 730 mem_split = find_counter(cpu, "MEM_UOP_RETIRED.SPLIT_STORES"); 731 mem_stores = find_counter(cpu, "MEM_UOP_RETIRED.ALL_STORES"); 732 if (pos != -1) { 733 memsplit = mem_split->vals[pos] * 1.0; 734 memstore = mem_stores->vals[pos] * 1.0; 735 } else { 736 memsplit = mem_split->sum * 1.0; 737 memstore = mem_stores->sum * 1.0; 738 } 739 res = memsplit/memstore; 740 ret = printf("%1.3f", res); 741 return(ret); 742 } 743 744 745 746 static int 747 splitstore(struct counters *cpu, int pos) 748 { 749 /* 5 - MEM_UOPS_RETIRED.SPLIT_STORES / MEM_UOPS_RETIRED.ALL_STORES (thresh > 0.01) */ 750 int ret; 751 struct counters *mem_split; 752 struct counters *mem_stores; 753 double memsplit, memstore, res; 754 mem_split = find_counter(cpu, "MEM_UOPS_RETIRED.SPLIT_STORES"); 755 mem_stores = find_counter(cpu, "MEM_UOPS_RETIRED.ALL_STORES"); 756 if (pos != -1) { 757 memsplit = mem_split->vals[pos] * 1.0; 758 memstore = mem_stores->vals[pos] * 1.0; 759 } else { 760 memsplit = mem_split->sum * 1.0; 761 memstore = mem_stores->sum * 1.0; 762 } 763 res = memsplit/memstore; 764 ret = printf("%1.3f", res); 765 return(ret); 766 } 767 768 769 static int 770 contested(struct counters *cpu, int pos) 771 { 772 /* 6 - (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ 773 int ret; 774 struct counters *mem; 775 struct counters *unhalt; 776 double con, un, memd, res; 777 778 con = 60.0; 779 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 780 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); 781 if (pos != -1) { 782 memd = mem->vals[pos] * 1.0; 783 un = unhalt->vals[pos] * 1.0; 784 } else { 785 memd = mem->sum * 1.0; 786 un = unhalt->sum * 1.0; 787 } 788 res = (memd * con)/un; 789 ret = printf("%1.3f", res); 790 return(ret); 791 } 792 793 static int 794 contested_has(struct counters *cpu, int pos) 795 { 796 /* 6 - (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) / CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ 797 int ret; 798 struct counters *mem; 799 struct counters *unhalt; 800 double con, un, memd, res; 801 802 con = 84.0; 803 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 804 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); 805 if (pos != -1) { 806 memd = mem->vals[pos] * 1.0; 807 un = unhalt->vals[pos] * 1.0; 808 } else { 809 memd = mem->sum * 1.0; 810 un = unhalt->sum * 1.0; 811 } 812 res = (memd * con)/un; 813 ret = printf("%1.3f", res); 814 return(ret); 815 } 816 817 static int 818 contestedbroad(struct counters *cpu, int pos) 819 { 820 /* 6 - (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) / CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ 821 int ret; 822 struct counters *mem; 823 struct counters *mem2; 824 struct counters *unhalt; 825 double con, un, memd, memtoo, res; 826 827 con = 84.0; 828 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 829 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); 830 mem2 = find_counter(cpu,"MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_MISS"); 831 832 if (pos != -1) { 833 memd = mem->vals[pos] * 1.0; 834 memtoo = mem2->vals[pos] * 1.0; 835 un = unhalt->vals[pos] * 1.0; 836 } else { 837 memd = mem->sum * 1.0; 838 memtoo = mem2->sum * 1.0; 839 un = unhalt->sum * 1.0; 840 } 841 res = ((memd * con) + memtoo)/un; 842 ret = printf("%1.3f", res); 843 return(ret); 844 } 845 846 847 static int 848 blockstoreforward(struct counters *cpu, int pos) 849 { 850 /* 7 - (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .05)*/ 851 int ret; 852 struct counters *ldb; 853 struct counters *unhalt; 854 double con, un, ld, res; 855 856 con = 13.0; 857 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 858 ldb = find_counter(cpu, "LD_BLOCKS_STORE_FORWARD"); 859 if (pos != -1) { 860 ld = ldb->vals[pos] * 1.0; 861 un = unhalt->vals[pos] * 1.0; 862 } else { 863 ld = ldb->sum * 1.0; 864 un = unhalt->sum * 1.0; 865 } 866 res = (ld * con)/un; 867 ret = printf("%1.3f", res); 868 return(ret); 869 } 870 871 static int 872 cache2(struct counters *cpu, int pos) 873 { 874 /* ** Suspect *** 875 * 8 - ((MEM_LOAD_RETIRED.L3_HIT * 26) + (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 43) + 876 * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60)) / CPU_CLK_UNHALTED.THREAD_P (thresh >.2) 877 */ 878 int ret; 879 struct counters *mem1, *mem2, *mem3; 880 struct counters *unhalt; 881 double con1, con2, con3, un, me_1, me_2, me_3, res; 882 883 con1 = 26.0; 884 con2 = 43.0; 885 con3 = 60.0; 886 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 887 /* Call for MEM_LOAD_RETIRED.L3_HIT possibly MEM_LOAD_UOPS_RETIRED.LLC_HIT ?*/ 888 mem1 = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); 889 mem2 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); 890 mem3 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); 891 if (pos != -1) { 892 me_1 = mem1->vals[pos] * 1.0; 893 me_2 = mem2->vals[pos] * 1.0; 894 me_3 = mem3->vals[pos] * 1.0; 895 un = unhalt->vals[pos] * 1.0; 896 } else { 897 me_1 = mem1->sum * 1.0; 898 me_2 = mem2->sum * 1.0; 899 me_3 = mem3->sum * 1.0; 900 un = unhalt->sum * 1.0; 901 } 902 res = ((me_1 * con1) + (me_2 * con2) + (me_3 * con3))/un; 903 ret = printf("%1.3f", res); 904 return(ret); 905 } 906 907 static int 908 datasharing(struct counters *cpu, int pos) 909 { 910 /* 911 * (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/ CPU_CLK_UNHALTED.THREAD_P (thresh >.2) 912 */ 913 int ret; 914 struct counters *mem; 915 struct counters *unhalt; 916 double con, res, me, un; 917 918 con = 43.0; 919 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 920 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); 921 if (pos != -1) { 922 me = mem->vals[pos] * 1.0; 923 un = unhalt->vals[pos] * 1.0; 924 } else { 925 me = mem->sum * 1.0; 926 un = unhalt->sum * 1.0; 927 } 928 res = (me * con)/un; 929 ret = printf("%1.3f", res); 930 return(ret); 931 932 } 933 934 935 static int 936 datasharing_has(struct counters *cpu, int pos) 937 { 938 /* 939 * (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/ CPU_CLK_UNHALTED.THREAD_P (thresh >.2) 940 */ 941 int ret; 942 struct counters *mem; 943 struct counters *unhalt; 944 double con, res, me, un; 945 946 con = 72.0; 947 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 948 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); 949 if (pos != -1) { 950 me = mem->vals[pos] * 1.0; 951 un = unhalt->vals[pos] * 1.0; 952 } else { 953 me = mem->sum * 1.0; 954 un = unhalt->sum * 1.0; 955 } 956 res = (me * con)/un; 957 ret = printf("%1.3f", res); 958 return(ret); 959 960 } 961 962 963 static int 964 cache2ib(struct counters *cpu, int pos) 965 { 966 /* 967 * (29 * MEM_LOAD_UOPS_RETIRED.LLC_HIT / CPU_CLK_UNHALTED.THREAD_P (thresh >.2) 968 */ 969 int ret; 970 struct counters *mem; 971 struct counters *unhalt; 972 double con, un, me, res; 973 974 con = 29.0; 975 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 976 mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); 977 if (pos != -1) { 978 me = mem->vals[pos] * 1.0; 979 un = unhalt->vals[pos] * 1.0; 980 } else { 981 me = mem->sum * 1.0; 982 un = unhalt->sum * 1.0; 983 } 984 res = (con * me)/un; 985 ret = printf("%1.3f", res); 986 return(ret); 987 } 988 989 static int 990 cache2has(struct counters *cpu, int pos) 991 { 992 /* 993 * Examine ((MEM_LOAD_UOPS_RETIRED.LLC_HIT * 36) + \ 994 * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 72) + 995 * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84)) 996 * / CPU_CLK_UNHALTED.THREAD_P 997 */ 998 int ret; 999 struct counters *mem1, *mem2, *mem3; 1000 struct counters *unhalt; 1001 double con1, con2, con3, un, me1, me2, me3, res; 1002 1003 con1 = 36.0; 1004 con2 = 72.0; 1005 con3 = 84.0; 1006 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1007 mem1 = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); 1008 mem2 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); 1009 mem3 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); 1010 if (pos != -1) { 1011 me1 = mem1->vals[pos] * 1.0; 1012 me2 = mem2->vals[pos] * 1.0; 1013 me3 = mem3->vals[pos] * 1.0; 1014 un = unhalt->vals[pos] * 1.0; 1015 } else { 1016 me1 = mem1->sum * 1.0; 1017 me2 = mem2->sum * 1.0; 1018 me3 = mem3->sum * 1.0; 1019 un = unhalt->sum * 1.0; 1020 } 1021 res = ((me1 * con1) + (me2 * con2) + (me3 * con3))/un; 1022 ret = printf("%1.3f", res); 1023 return(ret); 1024 } 1025 1026 1027 static int 1028 cache2broad(struct counters *cpu, int pos) 1029 { 1030 /* 1031 * (29 * MEM_LOAD_UOPS_RETIRED.LLC_HIT / CPU_CLK_UNHALTED.THREAD_P (thresh >.2) 1032 */ 1033 int ret; 1034 struct counters *mem; 1035 struct counters *unhalt; 1036 double con, un, me, res; 1037 1038 con = 36.0; 1039 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1040 mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.L3_HIT"); 1041 if (pos != -1) { 1042 me = mem->vals[pos] * 1.0; 1043 un = unhalt->vals[pos] * 1.0; 1044 } else { 1045 me = mem->sum * 1.0; 1046 un = unhalt->sum * 1.0; 1047 } 1048 res = (con * me)/un; 1049 ret = printf("%1.3f", res); 1050 return(ret); 1051 } 1052 1053 1054 static int 1055 cache1(struct counters *cpu, int pos) 1056 { 1057 /* 9 - (MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS * 180) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ 1058 int ret; 1059 struct counters *mem; 1060 struct counters *unhalt; 1061 double con, un, me, res; 1062 1063 con = 180.0; 1064 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1065 mem = find_counter(cpu, "MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS"); 1066 if (pos != -1) { 1067 me = mem->vals[pos] * 1.0; 1068 un = unhalt->vals[pos] * 1.0; 1069 } else { 1070 me = mem->sum * 1.0; 1071 un = unhalt->sum * 1.0; 1072 } 1073 res = (me * con)/un; 1074 ret = printf("%1.3f", res); 1075 return(ret); 1076 } 1077 1078 static int 1079 cache1ib(struct counters *cpu, int pos) 1080 { 1081 /* 9 - (MEM_LOAD_UOPS_L3_MISS_RETIRED.LCOAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ 1082 int ret; 1083 struct counters *mem; 1084 struct counters *unhalt; 1085 double con, un, me, res; 1086 1087 con = 180.0; 1088 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1089 mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM"); 1090 if (pos != -1) { 1091 me = mem->vals[pos] * 1.0; 1092 un = unhalt->vals[pos] * 1.0; 1093 } else { 1094 me = mem->sum * 1.0; 1095 un = unhalt->sum * 1.0; 1096 } 1097 res = (me * con)/un; 1098 ret = printf("%1.3f", res); 1099 return(ret); 1100 } 1101 1102 1103 static int 1104 cache1broad(struct counters *cpu, int pos) 1105 { 1106 /* 9 - (MEM_LOAD_UOPS_L3_MISS_RETIRED.LCOAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ 1107 int ret; 1108 struct counters *mem; 1109 struct counters *unhalt; 1110 double con, un, me, res; 1111 1112 con = 180.0; 1113 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1114 mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.L3_MISS"); 1115 if (pos != -1) { 1116 me = mem->vals[pos] * 1.0; 1117 un = unhalt->vals[pos] * 1.0; 1118 } else { 1119 me = mem->sum * 1.0; 1120 un = unhalt->sum * 1.0; 1121 } 1122 res = (me * con)/un; 1123 ret = printf("%1.3f", res); 1124 return(ret); 1125 } 1126 1127 1128 static int 1129 dtlb_missload(struct counters *cpu, int pos) 1130 { 1131 /* 10 - ((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION) / CPU_CLK_UNHALTED.THREAD_P (t >=.1) */ 1132 int ret; 1133 struct counters *dtlb_m, *dtlb_d; 1134 struct counters *unhalt; 1135 double con, un, d1, d2, res; 1136 1137 con = 7.0; 1138 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1139 dtlb_m = find_counter(cpu, "DTLB_LOAD_MISSES.STLB_HIT"); 1140 dtlb_d = find_counter(cpu, "DTLB_LOAD_MISSES.WALK_DURATION"); 1141 if (pos != -1) { 1142 d1 = dtlb_m->vals[pos] * 1.0; 1143 d2 = dtlb_d->vals[pos] * 1.0; 1144 un = unhalt->vals[pos] * 1.0; 1145 } else { 1146 d1 = dtlb_m->sum * 1.0; 1147 d2 = dtlb_d->sum * 1.0; 1148 un = unhalt->sum * 1.0; 1149 } 1150 res = ((d1 * con) + d2)/un; 1151 ret = printf("%1.3f", res); 1152 return(ret); 1153 } 1154 1155 static int 1156 dtlb_missstore(struct counters *cpu, int pos) 1157 { 1158 /* 1159 * ((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION) / 1160 * CPU_CLK_UNHALTED.THREAD_P (t >= .1) 1161 */ 1162 int ret; 1163 struct counters *dtsb_m, *dtsb_d; 1164 struct counters *unhalt; 1165 double con, un, d1, d2, res; 1166 1167 con = 7.0; 1168 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1169 dtsb_m = find_counter(cpu, "DTLB_STORE_MISSES.STLB_HIT"); 1170 dtsb_d = find_counter(cpu, "DTLB_STORE_MISSES.WALK_DURATION"); 1171 if (pos != -1) { 1172 d1 = dtsb_m->vals[pos] * 1.0; 1173 d2 = dtsb_d->vals[pos] * 1.0; 1174 un = unhalt->vals[pos] * 1.0; 1175 } else { 1176 d1 = dtsb_m->sum * 1.0; 1177 d2 = dtsb_d->sum * 1.0; 1178 un = unhalt->sum * 1.0; 1179 } 1180 res = ((d1 * con) + d2)/un; 1181 ret = printf("%1.3f", res); 1182 return(ret); 1183 } 1184 1185 static int 1186 itlb_miss(struct counters *cpu, int pos) 1187 { 1188 /* ITLB_MISSES.WALK_DURATION / CPU_CLK_UNTHREAD_P IB */ 1189 int ret; 1190 struct counters *itlb; 1191 struct counters *unhalt; 1192 double un, d1, res; 1193 1194 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1195 itlb = find_counter(cpu, "ITLB_MISSES.WALK_DURATION"); 1196 if (pos != -1) { 1197 d1 = itlb->vals[pos] * 1.0; 1198 un = unhalt->vals[pos] * 1.0; 1199 } else { 1200 d1 = itlb->sum * 1.0; 1201 un = unhalt->sum * 1.0; 1202 } 1203 res = d1/un; 1204 ret = printf("%1.3f", res); 1205 return(ret); 1206 } 1207 1208 1209 static int 1210 itlb_miss_broad(struct counters *cpu, int pos) 1211 { 1212 /* (7 * ITLB_MISSES.STLB_HIT_4K + ITLB_MISSES.WALK_DURATION) / CPU_CLK_UNTHREAD_P */ 1213 int ret; 1214 struct counters *itlb; 1215 struct counters *unhalt; 1216 struct counters *four_k; 1217 double un, d1, res, k; 1218 1219 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1220 itlb = find_counter(cpu, "ITLB_MISSES.WALK_DURATION"); 1221 four_k = find_counter(cpu, "ITLB_MISSES.STLB_HIT_4K"); 1222 if (pos != -1) { 1223 d1 = itlb->vals[pos] * 1.0; 1224 un = unhalt->vals[pos] * 1.0; 1225 k = four_k->vals[pos] * 1.0; 1226 } else { 1227 d1 = itlb->sum * 1.0; 1228 un = unhalt->sum * 1.0; 1229 k = four_k->sum * 1.0; 1230 } 1231 res = (7.0 * k + d1)/un; 1232 ret = printf("%1.3f", res); 1233 return(ret); 1234 } 1235 1236 1237 static int 1238 icache_miss(struct counters *cpu, int pos) 1239 { 1240 /* (ICACHE.IFETCH_STALL - ITLB_MISSES.WALK_DURATION) / CPU_CLK_UNHALTED.THREAD_P IB */ 1241 1242 int ret; 1243 struct counters *itlb, *icache; 1244 struct counters *unhalt; 1245 double un, d1, ic, res; 1246 1247 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1248 itlb = find_counter(cpu, "ITLB_MISSES.WALK_DURATION"); 1249 icache = find_counter(cpu, "ICACHE.IFETCH_STALL"); 1250 if (pos != -1) { 1251 d1 = itlb->vals[pos] * 1.0; 1252 ic = icache->vals[pos] * 1.0; 1253 un = unhalt->vals[pos] * 1.0; 1254 } else { 1255 d1 = itlb->sum * 1.0; 1256 ic = icache->sum * 1.0; 1257 un = unhalt->sum * 1.0; 1258 } 1259 res = (ic-d1)/un; 1260 ret = printf("%1.3f", res); 1261 return(ret); 1262 1263 } 1264 1265 static int 1266 icache_miss_has(struct counters *cpu, int pos) 1267 { 1268 /* (36 * ICACHE.MISSES) / CPU_CLK_UNHALTED.THREAD_P */ 1269 1270 int ret; 1271 struct counters *icache; 1272 struct counters *unhalt; 1273 double un, con, ic, res; 1274 1275 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1276 icache = find_counter(cpu, "ICACHE.MISSES"); 1277 con = 36.0; 1278 if (pos != -1) { 1279 ic = icache->vals[pos] * 1.0; 1280 un = unhalt->vals[pos] * 1.0; 1281 } else { 1282 ic = icache->sum * 1.0; 1283 un = unhalt->sum * 1.0; 1284 } 1285 res = (con * ic)/un; 1286 ret = printf("%1.3f", res); 1287 return(ret); 1288 1289 } 1290 1291 static int 1292 lcp_stall(struct counters *cpu, int pos) 1293 { 1294 /* ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P IB */ 1295 int ret; 1296 struct counters *ild; 1297 struct counters *unhalt; 1298 double un, d1, res; 1299 1300 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1301 ild = find_counter(cpu, "ILD_STALL.LCP"); 1302 if (pos != -1) { 1303 d1 = ild->vals[pos] * 1.0; 1304 un = unhalt->vals[pos] * 1.0; 1305 } else { 1306 d1 = ild->sum * 1.0; 1307 un = unhalt->sum * 1.0; 1308 } 1309 res = d1/un; 1310 ret = printf("%1.3f", res); 1311 return(ret); 1312 1313 } 1314 1315 1316 static int 1317 frontendstall(struct counters *cpu, int pos) 1318 { 1319 /* 12 - IDQ_UOPS_NOT_DELIVERED.CORE / (CPU_CLK_UNHALTED.THREAD_P * 4) (thresh >= .15) */ 1320 int ret; 1321 struct counters *idq; 1322 struct counters *unhalt; 1323 double con, un, id, res; 1324 1325 con = 4.0; 1326 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1327 idq = find_counter(cpu, "IDQ_UOPS_NOT_DELIVERED.CORE"); 1328 if (pos != -1) { 1329 id = idq->vals[pos] * 1.0; 1330 un = unhalt->vals[pos] * 1.0; 1331 } else { 1332 id = idq->sum * 1.0; 1333 un = unhalt->sum * 1.0; 1334 } 1335 res = id/(un * con); 1336 ret = printf("%1.3f", res); 1337 return(ret); 1338 } 1339 1340 static int 1341 clears(struct counters *cpu, int pos) 1342 { 1343 /* 13 - ((MACHINE_CLEARS.MEMORY_ORDERING + MACHINE_CLEARS.SMC + MACHINE_CLEARS.MASKMOV ) * 100 ) 1344 * / CPU_CLK_UNHALTED.THREAD_P (thresh >= .02)*/ 1345 1346 int ret; 1347 struct counters *clr1, *clr2, *clr3; 1348 struct counters *unhalt; 1349 double con, un, cl1, cl2, cl3, res; 1350 1351 con = 100.0; 1352 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1353 clr1 = find_counter(cpu, "MACHINE_CLEARS.MEMORY_ORDERING"); 1354 clr2 = find_counter(cpu, "MACHINE_CLEARS.SMC"); 1355 clr3 = find_counter(cpu, "MACHINE_CLEARS.MASKMOV"); 1356 1357 if (pos != -1) { 1358 cl1 = clr1->vals[pos] * 1.0; 1359 cl2 = clr2->vals[pos] * 1.0; 1360 cl3 = clr3->vals[pos] * 1.0; 1361 un = unhalt->vals[pos] * 1.0; 1362 } else { 1363 cl1 = clr1->sum * 1.0; 1364 cl2 = clr2->sum * 1.0; 1365 cl3 = clr3->sum * 1.0; 1366 un = unhalt->sum * 1.0; 1367 } 1368 res = ((cl1 + cl2 + cl3) * con)/un; 1369 ret = printf("%1.3f", res); 1370 return(ret); 1371 } 1372 1373 1374 1375 static int 1376 clears_broad(struct counters *cpu, int pos) 1377 { 1378 int ret; 1379 struct counters *clr1, *clr2, *clr3, *cyc; 1380 struct counters *unhalt; 1381 double con, un, cl1, cl2, cl3, cy, res; 1382 1383 con = 100.0; 1384 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1385 clr1 = find_counter(cpu, "MACHINE_CLEARS.MEMORY_ORDERING"); 1386 clr2 = find_counter(cpu, "MACHINE_CLEARS.SMC"); 1387 clr3 = find_counter(cpu, "MACHINE_CLEARS.MASKMOV"); 1388 cyc = find_counter(cpu, "MACHINE_CLEARS.CYCLES"); 1389 if (pos != -1) { 1390 cl1 = clr1->vals[pos] * 1.0; 1391 cl2 = clr2->vals[pos] * 1.0; 1392 cl3 = clr3->vals[pos] * 1.0; 1393 cy = cyc->vals[pos] * 1.0; 1394 un = unhalt->vals[pos] * 1.0; 1395 } else { 1396 cl1 = clr1->sum * 1.0; 1397 cl2 = clr2->sum * 1.0; 1398 cl3 = clr3->sum * 1.0; 1399 cy = cyc->sum * 1.0; 1400 un = unhalt->sum * 1.0; 1401 } 1402 /* Formula not listed but extrapulated to add the cy ?? */ 1403 res = ((cl1 + cl2 + cl3 + cy) * con)/un; 1404 ret = printf("%1.3f", res); 1405 return(ret); 1406 } 1407 1408 1409 1410 1411 1412 static int 1413 microassist(struct counters *cpu, int pos) 1414 { 1415 /* 14 - IDQ.MS_CYCLES / CPU_CLK_UNHALTED.THREAD_P (thresh > .05) */ 1416 int ret; 1417 struct counters *idq; 1418 struct counters *unhalt; 1419 double un, id, res, con; 1420 1421 con = 4.0; 1422 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1423 idq = find_counter(cpu, "IDQ.MS_UOPS"); 1424 if (pos != -1) { 1425 id = idq->vals[pos] * 1.0; 1426 un = unhalt->vals[pos] * 1.0; 1427 } else { 1428 id = idq->sum * 1.0; 1429 un = unhalt->sum * 1.0; 1430 } 1431 res = id/(un * con); 1432 ret = printf("%1.3f", res); 1433 return(ret); 1434 } 1435 1436 1437 static int 1438 microassist_broad(struct counters *cpu, int pos) 1439 { 1440 int ret; 1441 struct counters *idq; 1442 struct counters *unhalt; 1443 struct counters *uopiss; 1444 struct counters *uopret; 1445 double un, id, res, con, uoi, uor; 1446 1447 con = 4.0; 1448 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1449 idq = find_counter(cpu, "IDQ.MS_UOPS"); 1450 uopiss = find_counter(cpu, "UOPS_ISSUED.ANY"); 1451 uopret = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); 1452 if (pos != -1) { 1453 id = idq->vals[pos] * 1.0; 1454 un = unhalt->vals[pos] * 1.0; 1455 uoi = uopiss->vals[pos] * 1.0; 1456 uor = uopret->vals[pos] * 1.0; 1457 } else { 1458 id = idq->sum * 1.0; 1459 un = unhalt->sum * 1.0; 1460 uoi = uopiss->sum * 1.0; 1461 uor = uopret->sum * 1.0; 1462 } 1463 res = (uor/uoi) * (id/(un * con)); 1464 ret = printf("%1.3f", res); 1465 return(ret); 1466 } 1467 1468 1469 static int 1470 aliasing(struct counters *cpu, int pos) 1471 { 1472 /* 15 - (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh > .1) */ 1473 int ret; 1474 struct counters *ld; 1475 struct counters *unhalt; 1476 double un, lds, con, res; 1477 1478 con = 5.0; 1479 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1480 ld = find_counter(cpu, "LD_BLOCKS_PARTIAL.ADDRESS_ALIAS"); 1481 if (pos != -1) { 1482 lds = ld->vals[pos] * 1.0; 1483 un = unhalt->vals[pos] * 1.0; 1484 } else { 1485 lds = ld->sum * 1.0; 1486 un = unhalt->sum * 1.0; 1487 } 1488 res = (lds * con)/un; 1489 ret = printf("%1.3f", res); 1490 return(ret); 1491 } 1492 1493 static int 1494 aliasing_broad(struct counters *cpu, int pos) 1495 { 1496 /* 15 - (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh > .1) */ 1497 int ret; 1498 struct counters *ld; 1499 struct counters *unhalt; 1500 double un, lds, con, res; 1501 1502 con = 7.0; 1503 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1504 ld = find_counter(cpu, "LD_BLOCKS_PARTIAL.ADDRESS_ALIAS"); 1505 if (pos != -1) { 1506 lds = ld->vals[pos] * 1.0; 1507 un = unhalt->vals[pos] * 1.0; 1508 } else { 1509 lds = ld->sum * 1.0; 1510 un = unhalt->sum * 1.0; 1511 } 1512 res = (lds * con)/un; 1513 ret = printf("%1.3f", res); 1514 return(ret); 1515 } 1516 1517 1518 static int 1519 fpassists(struct counters *cpu, int pos) 1520 { 1521 /* 16 - FP_ASSIST.ANY/INST_RETIRED.ANY_P */ 1522 int ret; 1523 struct counters *fp; 1524 struct counters *inst; 1525 double un, fpd, res; 1526 1527 inst = find_counter(cpu, "INST_RETIRED.ANY_P"); 1528 fp = find_counter(cpu, "FP_ASSIST.ANY"); 1529 if (pos != -1) { 1530 fpd = fp->vals[pos] * 1.0; 1531 un = inst->vals[pos] * 1.0; 1532 } else { 1533 fpd = fp->sum * 1.0; 1534 un = inst->sum * 1.0; 1535 } 1536 res = fpd/un; 1537 ret = printf("%1.3f", res); 1538 return(ret); 1539 } 1540 1541 static int 1542 otherassistavx(struct counters *cpu, int pos) 1543 { 1544 /* 17 - (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P thresh .1*/ 1545 int ret; 1546 struct counters *oth; 1547 struct counters *unhalt; 1548 double un, ot, con, res; 1549 1550 con = 75.0; 1551 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1552 oth = find_counter(cpu, "OTHER_ASSISTS.AVX_TO_SSE"); 1553 if (pos != -1) { 1554 ot = oth->vals[pos] * 1.0; 1555 un = unhalt->vals[pos] * 1.0; 1556 } else { 1557 ot = oth->sum * 1.0; 1558 un = unhalt->sum * 1.0; 1559 } 1560 res = (ot * con)/un; 1561 ret = printf("%1.3f", res); 1562 return(ret); 1563 } 1564 1565 static int 1566 otherassistsse(struct counters *cpu, int pos) 1567 { 1568 1569 int ret; 1570 struct counters *oth; 1571 struct counters *unhalt; 1572 double un, ot, con, res; 1573 1574 /* 18 (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P thresh .1*/ 1575 con = 75.0; 1576 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1577 oth = find_counter(cpu, "OTHER_ASSISTS.SSE_TO_AVX"); 1578 if (pos != -1) { 1579 ot = oth->vals[pos] * 1.0; 1580 un = unhalt->vals[pos] * 1.0; 1581 } else { 1582 ot = oth->sum * 1.0; 1583 un = unhalt->sum * 1.0; 1584 } 1585 res = (ot * con)/un; 1586 ret = printf("%1.3f", res); 1587 return(ret); 1588 } 1589 1590 static int 1591 efficiency1(struct counters *cpu, int pos) 1592 { 1593 1594 int ret; 1595 struct counters *uops; 1596 struct counters *unhalt; 1597 double un, ot, con, res; 1598 1599 /* 19 (UOPS_RETIRED.RETIRE_SLOTS/(4*CPU_CLK_UNHALTED.THREAD_P) look if thresh < .9*/ 1600 con = 4.0; 1601 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1602 uops = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); 1603 if (pos != -1) { 1604 ot = uops->vals[pos] * 1.0; 1605 un = unhalt->vals[pos] * 1.0; 1606 } else { 1607 ot = uops->sum * 1.0; 1608 un = unhalt->sum * 1.0; 1609 } 1610 res = ot/(con * un); 1611 ret = printf("%1.3f", res); 1612 return(ret); 1613 } 1614 1615 static int 1616 efficiency2(struct counters *cpu, int pos) 1617 { 1618 1619 int ret; 1620 struct counters *uops; 1621 struct counters *unhalt; 1622 double un, ot, res; 1623 1624 /* 20 - CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P good if > 1. (comp factor)*/ 1625 unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); 1626 uops = find_counter(cpu, "INST_RETIRED.ANY_P"); 1627 if (pos != -1) { 1628 ot = uops->vals[pos] * 1.0; 1629 un = unhalt->vals[pos] * 1.0; 1630 } else { 1631 ot = uops->sum * 1.0; 1632 un = unhalt->sum * 1.0; 1633 } 1634 res = un/ot; 1635 ret = printf("%1.3f", res); 1636 return(ret); 1637 } 1638 1639 #define SANDY_BRIDGE_COUNT 20 1640 static struct cpu_entry sandy_bridge[SANDY_BRIDGE_COUNT] = { 1641 /*01*/ { "allocstall1", "thresh > .05", 1642 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW -w 1", 1643 allocstall1, 2 }, 1644 /* -- not defined for SB right (partial-rat_stalls) 02*/ 1645 { "allocstall2", "thresh > .05", 1646 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP -w 1", 1647 allocstall2, 2 }, 1648 /*03*/ { "br_miss", "thresh >= .2", 1649 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -w 1", 1650 br_mispredict, 2 }, 1651 /*04*/ { "splitload", "thresh >= .1", 1652 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s MEM_UOP_RETIRED.SPLIT_LOADS -w 1", 1653 splitload_sb, 2 }, 1654 /* 05*/ { "splitstore", "thresh >= .01", 1655 "pmcstat -s MEM_UOP_RETIRED.SPLIT_STORES -s MEM_UOP_RETIRED.ALL_STORES -w 1", 1656 splitstore_sb, 2 }, 1657 /*06*/ { "contested", "thresh >= .05", 1658 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1659 contested, 2 }, 1660 /*07*/ { "blockstorefwd", "thresh >= .05", 1661 "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1662 blockstoreforward, 2 }, 1663 /*08*/ { "cache2", "thresh >= .2", 1664 "pmcstat -s MEM_LOAD_UOPS_RETIRED.LLC_HIT -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1665 cache2, 4 }, 1666 /*09*/ { "cache1", "thresh >= .2", 1667 "pmcstat -s MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1668 cache1, 2 }, 1669 /*10*/ { "dtlbmissload", "thresh >= .1", 1670 "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1671 dtlb_missload, 3 }, 1672 /*11*/ { "dtlbmissstore", "thresh >= .05", 1673 "pmcstat -s DTLB_STORE_MISSES.STLB_HIT -s DTLB_STORE_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1674 dtlb_missstore, 3 }, 1675 /*12*/ { "frontendstall", "thresh >= .15", 1676 "pmcstat -s IDQ_UOPS_NOT_DELIVERED.CORE -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1677 frontendstall, 2 }, 1678 /*13*/ { "clears", "thresh >= .02", 1679 "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1680 clears, 4 }, 1681 /*14*/ { "microassist", "thresh >= .05", 1682 "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1683 microassist, 2 }, 1684 /*15*/ { "aliasing_4k", "thresh >= .1", 1685 "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1686 aliasing, 2 }, 1687 /*16*/ { "fpassist", "look for a excessive value", 1688 "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", 1689 fpassists, 2 }, 1690 /*17*/ { "otherassistavx", "look for a excessive value", 1691 "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1692 otherassistavx, 2}, 1693 /*18*/ { "otherassistsse", "look for a excessive value", 1694 "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1695 otherassistsse, 2 }, 1696 /*19*/ { "eff1", "thresh < .9", 1697 "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1698 efficiency1, 2 }, 1699 /*20*/ { "eff2", "thresh > 1.0", 1700 "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1701 efficiency2, 2 }, 1702 }; 1703 1704 1705 #define IVY_BRIDGE_COUNT 21 1706 static struct cpu_entry ivy_bridge[IVY_BRIDGE_COUNT] = { 1707 /*1*/ { "eff1", "thresh < .75", 1708 "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1709 efficiency1, 2 }, 1710 /*2*/ { "eff2", "thresh > 1.0", 1711 "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1712 efficiency2, 2 }, 1713 /*3*/ { "itlbmiss", "thresh > .05", 1714 "pmcstat -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1715 itlb_miss, 2 }, 1716 /*4*/ { "icachemiss", "thresh > .05", 1717 "pmcstat -s ICACHE.IFETCH_STALL -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1718 icache_miss, 3 }, 1719 /*5*/ { "lcpstall", "thresh > .05", 1720 "pmcstat -s ILD_STALL.LCP -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1721 lcp_stall, 2 }, 1722 /*6*/ { "cache1", "thresh >= .2", 1723 "pmcstat -s MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1724 cache1ib, 2 }, 1725 /*7*/ { "cache2", "thresh >= .2", 1726 "pmcstat -s MEM_LOAD_UOPS_RETIRED.LLC_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1727 cache2ib, 2 }, 1728 /*8*/ { "contested", "thresh >= .05", 1729 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1730 contested, 2 }, 1731 /*9*/ { "datashare", "thresh >= .05", 1732 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1733 datasharing, 2 }, 1734 /*10*/ { "blockstorefwd", "thresh >= .05", 1735 "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1736 blockstoreforward, 2 }, 1737 /*11*/ { "splitload", "thresh >= .1", 1738 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s L1D_PEND_MISS.PENDING -s MEM_LOAD_UOPS_RETIRED.L1_MISS -s LD_BLOCKS.NO_SR -w 1", 1739 splitloadib, 4 }, 1740 /*12*/ { "splitstore", "thresh >= .01", 1741 "pmcstat -s MEM_UOPS_RETIRED.SPLIT_STORES -s MEM_UOPS_RETIRED.ALL_STORES -w 1", 1742 splitstore, 2 }, 1743 /*13*/ { "aliasing_4k", "thresh >= .1", 1744 "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1745 aliasing, 2 }, 1746 /*14*/ { "dtlbmissload", "thresh >= .1", 1747 "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1748 dtlb_missload , 3}, 1749 /*15*/ { "dtlbmissstore", "thresh >= .05", 1750 "pmcstat -s DTLB_STORE_MISSES.STLB_HIT -s DTLB_STORE_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1751 dtlb_missstore, 3 }, 1752 /*16*/ { "br_miss", "thresh >= .2", 1753 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s UOPS_ISSUED.ANY -s UOPS_RETIRED.RETIRE_SLOTS -s INT_MISC.RECOVERY_CYCLES -w 1", 1754 br_mispredictib, 8 }, 1755 /*17*/ { "clears", "thresh >= .02", 1756 "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1757 clears, 4 }, 1758 /*18*/ { "microassist", "thresh >= .05", 1759 "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1760 microassist, 2 }, 1761 /*19*/ { "fpassist", "look for a excessive value", 1762 "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", 1763 fpassists, 2 }, 1764 /*20*/ { "otherassistavx", "look for a excessive value", 1765 "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1766 otherassistavx , 2}, 1767 /*21*/ { "otherassistsse", "look for a excessive value", 1768 "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1769 otherassistsse, 2 }, 1770 }; 1771 1772 #define HASWELL_COUNT 20 1773 static struct cpu_entry haswell[HASWELL_COUNT] = { 1774 /*1*/ { "eff1", "thresh < .75", 1775 "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1776 efficiency1, 2 }, 1777 /*2*/ { "eff2", "thresh > 1.0", 1778 "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1779 efficiency2, 2 }, 1780 /*3*/ { "itlbmiss", "thresh > .05", 1781 "pmcstat -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1782 itlb_miss, 2 }, 1783 /*4*/ { "icachemiss", "thresh > .05", 1784 "pmcstat -s ICACHE.MISSES -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1785 icache_miss_has, 2 }, 1786 /*5*/ { "lcpstall", "thresh > .05", 1787 "pmcstat -s ILD_STALL.LCP -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1788 lcp_stall, 2 }, 1789 /*6*/ { "cache1", "thresh >= .2", 1790 "pmcstat -s MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1791 cache1ib, 2 }, 1792 /*7*/ { "cache2", "thresh >= .2", 1793 "pmcstat -s MEM_LOAD_UOPS_RETIRED.LLC_HIT -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1794 cache2has, 4 }, 1795 /*8*/ { "contested", "thresh >= .05", 1796 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1797 contested_has, 2 }, 1798 /*9*/ { "datashare", "thresh >= .05", 1799 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1800 datasharing_has, 2 }, 1801 /*10*/ { "blockstorefwd", "thresh >= .05", 1802 "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1803 blockstoreforward, 2 }, 1804 /*11*/ { "splitload", "thresh >= .1", 1805 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s MEM_UOPS_RETIRED.SPLIT_LOADS -w 1", 1806 splitload , 2}, 1807 /*12*/ { "splitstore", "thresh >= .01", 1808 "pmcstat -s MEM_UOPS_RETIRED.SPLIT_STORES -s MEM_UOPS_RETIRED.ALL_STORES -w 1", 1809 splitstore, 2 }, 1810 /*13*/ { "aliasing_4k", "thresh >= .1", 1811 "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1812 aliasing, 2 }, 1813 /*14*/ { "dtlbmissload", "thresh >= .1", 1814 "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1815 dtlb_missload, 3 }, 1816 /*15*/ { "br_miss", "thresh >= .2", 1817 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -w 1", 1818 br_mispredict, 2 }, 1819 /*16*/ { "clears", "thresh >= .02", 1820 "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1821 clears, 4 }, 1822 /*17*/ { "microassist", "thresh >= .05", 1823 "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1824 microassist, 2 }, 1825 /*18*/ { "fpassist", "look for a excessive value", 1826 "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", 1827 fpassists, 2 }, 1828 /*19*/ { "otherassistavx", "look for a excessive value", 1829 "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1830 otherassistavx, 2 }, 1831 /*20*/ { "otherassistsse", "look for a excessive value", 1832 "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1833 otherassistsse, 2 }, 1834 }; 1835 1836 1837 static void 1838 explain_name_broad(const char *name) 1839 { 1840 const char *mythresh; 1841 if (strcmp(name, "eff1") == 0) { 1842 printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); 1843 mythresh = "thresh < .75"; 1844 } else if (strcmp(name, "eff2") == 0) { 1845 printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); 1846 mythresh = "thresh > 1.0"; 1847 } else if (strcmp(name, "itlbmiss") == 0) { 1848 printf("Examine (7 * ITLB_MISSES_STLB_HIT_4K + ITLB_MISSES.WALK_DURATION)/ CPU_CLK_UNHALTED.THREAD_P\n"); 1849 mythresh = "thresh > .05"; 1850 } else if (strcmp(name, "icachemiss") == 0) { 1851 printf("Examine ( 36.0 * ICACHE.MISSES)/ CPU_CLK_UNHALTED.THREAD_P ??? may not be right \n"); 1852 mythresh = "thresh > .05"; 1853 } else if (strcmp(name, "lcpstall") == 0) { 1854 printf("Examine ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P\n"); 1855 mythresh = "thresh > .05"; 1856 } else if (strcmp(name, "cache1") == 0) { 1857 printf("Examine (MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); 1858 mythresh = "thresh >= .1"; 1859 } else if (strcmp(name, "cache2") == 0) { 1860 printf("Examine (36.0 * MEM_LOAD_UOPS_RETIRED.L3_HIT / CPU_CLK_UNHALTED.THREAD_P)\n"); 1861 mythresh = "thresh >= .2"; 1862 } else if (strcmp(name, "contested") == 0) { 1863 printf("Examine ((MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) + MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_MISS)/ CPU_CLK_UNHALTED.THREAD_P\n"); 1864 mythresh = "thresh >= .05"; 1865 } else if (strcmp(name, "datashare") == 0) { 1866 printf("Examine (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 72)/CPU_CLK_UNHALTED.THREAD_P\n"); 1867 mythresh = "thresh > .05"; 1868 } else if (strcmp(name, "blockstorefwd") == 0) { 1869 printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); 1870 mythresh = "thresh >= .05"; 1871 } else if (strcmp(name, "aliasing_4k") == 0) { 1872 printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 7) / CPU_CLK_UNHALTED.THREAD_P\n"); 1873 mythresh = "thresh >= .1"; 1874 } else if (strcmp(name, "dtlbmissload") == 0) { 1875 printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); 1876 printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); 1877 mythresh = "thresh >= .1"; 1878 1879 } else if (strcmp(name, "br_miss") == 0) { 1880 printf("Examine BR_MISP_RETIRED.ALL_BRANCHS_PS / (BR_MISP_RETIED.ALL_BRANCHES_PS + MACHINE_CLEARS.COUNT) *\n"); 1881 printf(" (UOPS_ISSUEDF.ANY - UOPS_RETIRED.RETIRE_SLOTS + 4 * INT_MISC.RECOVERY_CYCLES) /\n"); 1882 printf("CPU_CLK_UNHALTED.THREAD * 4)\n"); 1883 mythresh = "thresh >= .2"; 1884 } else if (strcmp(name, "clears") == 0) { 1885 printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); 1886 printf(" MACHINE_CLEARS.SMC + \n"); 1887 printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); 1888 mythresh = "thresh >= .02"; 1889 } else if (strcmp(name, "fpassist") == 0) { 1890 printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); 1891 mythresh = "look for a excessive value"; 1892 } else if (strcmp(name, "otherassistavx") == 0) { 1893 printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); 1894 mythresh = "look for a excessive value"; 1895 } else if (strcmp(name, "microassist") == 0) { 1896 printf("Examine (UOPS_RETIRED.RETIRE_SLOTS/UOPS_ISSUED.ANY) * (IDQ.MS_CYCLES / (4 * CPU_CLK_UNHALTED.THREAD_P)\n"); 1897 printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); 1898 mythresh = "thresh >= .05"; 1899 } else { 1900 printf("Unknown name:%s\n", name); 1901 mythresh = "unknown entry"; 1902 } 1903 printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); 1904 } 1905 1906 1907 #define BROADWELL_COUNT 17 1908 static struct cpu_entry broadwell[BROADWELL_COUNT] = { 1909 /*1*/ { "eff1", "thresh < .75", 1910 "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1911 efficiency1, 2 }, 1912 /*2*/ { "eff2", "thresh > 1.0", 1913 "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1914 efficiency2, 2 }, 1915 /*3*/ { "itlbmiss", "thresh > .05", 1916 "pmcstat -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -s ITLB_MISSES.STLB_HIT_4K -w 1", 1917 itlb_miss_broad, 3 }, 1918 /*4*/ { "icachemiss", "thresh > .05", 1919 "pmcstat -s ICACHE.MISSES -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1920 icache_miss_has, 2 }, 1921 /*5*/ { "lcpstall", "thresh > .05", 1922 "pmcstat -s ILD_STALL.LCP -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1923 lcp_stall, 2 }, 1924 /*6*/ { "cache1", "thresh >= .1", 1925 "pmcstat -s MEM_LOAD_UOPS_RETIRED.L3_MISS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1926 cache1broad, 2 }, 1927 /*7*/ { "cache2", "thresh >= .2", 1928 "pmcstat -s MEM_LOAD_UOPS_RETIRED.L3_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1929 cache2broad, 2 }, 1930 /*8*/ { "contested", "thresh >= .05", 1931 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_MISS -w 1", 1932 contestedbroad, 2 }, 1933 /*9*/ { "datashare", "thresh >= .05", 1934 "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1935 datasharing_has, 2 }, 1936 /*10*/ { "blockstorefwd", "thresh >= .05", 1937 "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1938 blockstoreforward, 2 }, 1939 /*11*/ { "aliasing_4k", "thresh >= .1", 1940 "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1941 aliasing_broad, 2 }, 1942 /*12*/ { "dtlbmissload", "thresh >= .1", 1943 "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT_4K -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1944 dtlb_missload, 3 }, 1945 /*13*/ { "br_miss", "thresh >= .2", 1946 "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -s MACHINE_CLEARS.CYCLES -s UOPS_ISSUED.ANY -s UOPS_RETIRED.RETIRE_SLOTS -s INT_MISC.RECOVERY_CYCLES -w 1", 1947 br_mispredict_broad, 7 }, 1948 /*14*/ { "clears", "thresh >= .02", 1949 "pmcstat -s MACHINE_CLEARS.CYCLES -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1950 clears_broad, 5 }, 1951 /*15*/ { "fpassist", "look for a excessive value", 1952 "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", 1953 fpassists, 2 }, 1954 /*16*/ { "otherassistavx", "look for a excessive value", 1955 "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", 1956 otherassistavx, 2 }, 1957 /*17*/ { "microassist", "thresh >= .2", 1958 "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -s UOPS_ISSUED.ANY -s UOPS_RETIRED.RETIRE_SLOTS -w 1", 1959 microassist_broad, 4 }, 1960 }; 1961 1962 1963 static void 1964 set_sandybridge(void) 1965 { 1966 strcpy(the_cpu.cputype, "SandyBridge PMC"); 1967 the_cpu.number = SANDY_BRIDGE_COUNT; 1968 the_cpu.ents = sandy_bridge; 1969 the_cpu.explain = explain_name_sb; 1970 } 1971 1972 static void 1973 set_ivybridge(void) 1974 { 1975 strcpy(the_cpu.cputype, "IvyBridge PMC"); 1976 the_cpu.number = IVY_BRIDGE_COUNT; 1977 the_cpu.ents = ivy_bridge; 1978 the_cpu.explain = explain_name_ib; 1979 } 1980 1981 1982 static void 1983 set_haswell(void) 1984 { 1985 strcpy(the_cpu.cputype, "HASWELL PMC"); 1986 the_cpu.number = HASWELL_COUNT; 1987 the_cpu.ents = haswell; 1988 the_cpu.explain = explain_name_has; 1989 } 1990 1991 1992 static void 1993 set_broadwell(void) 1994 { 1995 strcpy(the_cpu.cputype, "HASWELL PMC"); 1996 the_cpu.number = BROADWELL_COUNT; 1997 the_cpu.ents = broadwell; 1998 the_cpu.explain = explain_name_broad; 1999 } 2000 2001 2002 static int 2003 set_expression(const char *name) 2004 { 2005 int found = 0, i; 2006 for(i=0 ; i< the_cpu.number; i++) { 2007 if (strcmp(name, the_cpu.ents[i].name) == 0) { 2008 found = 1; 2009 expression = the_cpu.ents[i].func; 2010 command = the_cpu.ents[i].command; 2011 threshold = the_cpu.ents[i].thresh; 2012 if (the_cpu.ents[i].counters_required > max_pmc_counters) { 2013 printf("Test %s requires that the CPU have %d counters and this CPU has only %d\n", 2014 the_cpu.ents[i].name, 2015 the_cpu.ents[i].counters_required, max_pmc_counters); 2016 printf("Sorry this test can not be run\n"); 2017 if (run_all == 0) { 2018 exit(-1); 2019 } else { 2020 return(-1); 2021 } 2022 } 2023 break; 2024 } 2025 } 2026 if (!found) { 2027 printf("For CPU type %s we have no expression:%s\n", 2028 the_cpu.cputype, name); 2029 exit(-1); 2030 } 2031 return(0); 2032 } 2033 2034 2035 2036 2037 2038 static int 2039 validate_expression(char *name) 2040 { 2041 int i, found; 2042 2043 found = 0; 2044 for(i=0 ; i< the_cpu.number; i++) { 2045 if (strcmp(name, the_cpu.ents[i].name) == 0) { 2046 found = 1; 2047 break; 2048 } 2049 } 2050 if (!found) { 2051 return(-1); 2052 } 2053 return (0); 2054 } 2055 2056 static void 2057 do_expression(struct counters *cpu, int pos) 2058 { 2059 if (expression == NULL) 2060 return; 2061 (*expression)(cpu, pos); 2062 } 2063 2064 static void 2065 process_header(int idx, char *p) 2066 { 2067 struct counters *up; 2068 int i, len, nlen; 2069 /* 2070 * Given header element idx, at p in 2071 * form 's/NN/nameof' 2072 * process the entry to pull out the name and 2073 * the CPU number. 2074 */ 2075 if (strncmp(p, "s/", 2)) { 2076 printf("Check -- invalid header no s/ in %s\n", 2077 p); 2078 return; 2079 } 2080 up = &cnts[idx]; 2081 up->cpu = strtol(&p[2], NULL, 10); 2082 len = strlen(p); 2083 for (i=2; i<len; i++) { 2084 if (p[i] == '/') { 2085 nlen = strlen(&p[(i+1)]); 2086 if (nlen < (MAX_NLEN-1)) { 2087 strcpy(up->counter_name, &p[(i+1)]); 2088 } else { 2089 strncpy(up->counter_name, &p[(i+1)], (MAX_NLEN-1)); 2090 } 2091 } 2092 } 2093 } 2094 2095 static void 2096 build_counters_from_header(FILE *io) 2097 { 2098 char buffer[8192], *p; 2099 int i, len, cnt; 2100 size_t mlen; 2101 2102 /* We have a new start, lets 2103 * setup our headers and cpus. 2104 */ 2105 if (fgets(buffer, sizeof(buffer), io) == NULL) { 2106 printf("First line can't be read from file err:%d\n", errno); 2107 return; 2108 } 2109 /* 2110 * Ok output is an array of counters. Once 2111 * we start to read the values in we must 2112 * put them in there slot to match there CPU and 2113 * counter being updated. We create a mass array 2114 * of the counters, filling in the CPU and 2115 * counter name. 2116 */ 2117 /* How many do we get? */ 2118 len = strlen(buffer); 2119 for (i=0, cnt=0; i<len; i++) { 2120 if (strncmp(&buffer[i], "s/", 2) == 0) { 2121 cnt++; 2122 for(;i<len;i++) { 2123 if (buffer[i] == ' ') 2124 break; 2125 } 2126 } 2127 } 2128 mlen = sizeof(struct counters) * cnt; 2129 cnts = malloc(mlen); 2130 ncnts = cnt; 2131 if (cnts == NULL) { 2132 printf("No memory err:%d\n", errno); 2133 return; 2134 } 2135 memset(cnts, 0, mlen); 2136 for (i=0, cnt=0; i<len; i++) { 2137 if (strncmp(&buffer[i], "s/", 2) == 0) { 2138 p = &buffer[i]; 2139 for(;i<len;i++) { 2140 if (buffer[i] == ' ') { 2141 buffer[i] = 0; 2142 break; 2143 } 2144 } 2145 process_header(cnt, p); 2146 cnt++; 2147 } 2148 } 2149 if (verbose) 2150 printf("We have %d entries\n", cnt); 2151 } 2152 extern int max_to_collect; 2153 int max_to_collect = MAX_COUNTER_SLOTS; 2154 2155 static int 2156 read_a_line(FILE *io) 2157 { 2158 char buffer[8192], *p, *stop; 2159 int pos, i; 2160 2161 if (fgets(buffer, sizeof(buffer), io) == NULL) { 2162 return(0); 2163 } 2164 p = buffer; 2165 for (i=0; i<ncnts; i++) { 2166 pos = cnts[i].pos; 2167 cnts[i].vals[pos] = strtol(p, &stop, 0); 2168 cnts[i].pos++; 2169 cnts[i].sum += cnts[i].vals[pos]; 2170 p = stop; 2171 } 2172 return (1); 2173 } 2174 2175 extern int cpu_count_out; 2176 int cpu_count_out=0; 2177 2178 static void 2179 print_header(void) 2180 { 2181 int i, cnt, printed_cnt; 2182 2183 printf("*********************************\n"); 2184 for(i=0, cnt=0; i<MAX_CPU; i++) { 2185 if (glob_cpu[i]) { 2186 cnt++; 2187 } 2188 } 2189 cpu_count_out = cnt; 2190 for(i=0, printed_cnt=0; i<MAX_CPU; i++) { 2191 if (glob_cpu[i]) { 2192 printf("CPU%d", i); 2193 printed_cnt++; 2194 } 2195 if (printed_cnt == cnt) { 2196 printf("\n"); 2197 break; 2198 } else { 2199 printf("\t"); 2200 } 2201 } 2202 } 2203 2204 static void 2205 lace_cpus_together(void) 2206 { 2207 int i, j, lace_cpu; 2208 struct counters *cpat, *at; 2209 2210 for(i=0; i<ncnts; i++) { 2211 cpat = &cnts[i]; 2212 if (cpat->next_cpu) { 2213 /* Already laced in */ 2214 continue; 2215 } 2216 lace_cpu = cpat->cpu; 2217 if (lace_cpu >= MAX_CPU) { 2218 printf("CPU %d to big\n", lace_cpu); 2219 continue; 2220 } 2221 if (glob_cpu[lace_cpu] == NULL) { 2222 glob_cpu[lace_cpu] = cpat; 2223 } else { 2224 /* Already processed this cpu */ 2225 continue; 2226 } 2227 /* Ok look forward for cpu->cpu and link in */ 2228 for(j=(i+1); j<ncnts; j++) { 2229 at = &cnts[j]; 2230 if (at->next_cpu) { 2231 continue; 2232 } 2233 if (at->cpu == lace_cpu) { 2234 /* Found one */ 2235 cpat->next_cpu = at; 2236 cpat = at; 2237 } 2238 } 2239 } 2240 } 2241 2242 2243 static void 2244 process_file(char *filename) 2245 { 2246 FILE *io; 2247 int i; 2248 int line_at, not_done; 2249 pid_t pid_of_command=0; 2250 2251 if (filename == NULL) { 2252 io = my_popen(command, "r", &pid_of_command); 2253 } else { 2254 io = fopen(filename, "r"); 2255 if (io == NULL) { 2256 printf("Can't process file %s err:%d\n", 2257 filename, errno); 2258 return; 2259 } 2260 } 2261 build_counters_from_header(io); 2262 if (cnts == NULL) { 2263 /* Nothing we can do */ 2264 printf("Nothing to do -- no counters built\n"); 2265 if (io) { 2266 fclose(io); 2267 } 2268 return; 2269 } 2270 lace_cpus_together(); 2271 print_header(); 2272 if (verbose) { 2273 for (i=0; i<ncnts; i++) { 2274 printf("Counter:%s cpu:%d index:%d\n", 2275 cnts[i].counter_name, 2276 cnts[i].cpu, i); 2277 } 2278 } 2279 line_at = 0; 2280 not_done = 1; 2281 while(not_done) { 2282 if (read_a_line(io)) { 2283 line_at++; 2284 } else { 2285 break; 2286 } 2287 if (line_at >= max_to_collect) { 2288 not_done = 0; 2289 } 2290 if (filename == NULL) { 2291 int cnt; 2292 /* For the ones we dynamically open we print now */ 2293 for(i=0, cnt=0; i<MAX_CPU; i++) { 2294 do_expression(glob_cpu[i], (line_at-1)); 2295 cnt++; 2296 if (cnt == cpu_count_out) { 2297 printf("\n"); 2298 break; 2299 } else { 2300 printf("\t"); 2301 } 2302 } 2303 } 2304 } 2305 if (filename) { 2306 fclose(io); 2307 } else { 2308 my_pclose(io, pid_of_command); 2309 } 2310 } 2311 #if defined(__amd64__) 2312 #define cpuid(in,a,b,c,d)\ 2313 asm("cpuid": "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "a" (in)); 2314 2315 static __inline void 2316 do_cpuid(u_int ax, u_int cx, u_int *p) 2317 { 2318 __asm __volatile("cpuid" 2319 : "=a" (p[0]), "=b" (p[1]), "=c" (p[2]), "=d" (p[3]) 2320 : "0" (ax), "c" (cx) ); 2321 } 2322 2323 #else 2324 #define cpuid(in, a, b, c, d) 2325 #define do_cpuid(ax, cx, p) 2326 #endif 2327 2328 static void 2329 get_cpuid_set(void) 2330 { 2331 unsigned long eax, ebx, ecx, edx; 2332 int model; 2333 pid_t pid_of_command=0; 2334 size_t sz, len; 2335 FILE *io; 2336 char linebuf[1024], *str; 2337 u_int reg[4]; 2338 2339 eax = ebx = ecx = edx = 0; 2340 2341 cpuid(0, eax, ebx, ecx, edx); 2342 if (ebx == 0x68747541) { 2343 printf("AMD processors are not supported by this program\n"); 2344 printf("Sorry\n"); 2345 exit(0); 2346 } else if (ebx == 0x6972794) { 2347 printf("Cyrix processors are not supported by this program\n"); 2348 printf("Sorry\n"); 2349 exit(0); 2350 } else if (ebx == 0x756e6547) { 2351 printf("Genuine Intel\n"); 2352 } else { 2353 printf("Unknown processor type 0x%lx Only Intel AMD64 types are supported by this routine!\n", ebx); 2354 exit(0); 2355 } 2356 cpuid(1, eax, ebx, ecx, edx); 2357 model = (((eax & 0xF0000) >> 12) | ((eax & 0xF0) >> 4)); 2358 printf("CPU model is 0x%x id:0x%lx\n", model, eax); 2359 switch (eax & 0xF00) { 2360 case 0x500: /* Pentium family processors */ 2361 printf("Intel Pentium P5\n"); 2362 goto not_supported; 2363 break; 2364 case 0x600: /* Pentium Pro, Celeron, Pentium II & III */ 2365 switch (model) { 2366 case 0x1: 2367 printf("Intel Pentium P6\n"); 2368 goto not_supported; 2369 break; 2370 case 0x3: 2371 case 0x5: 2372 printf("Intel PII\n"); 2373 goto not_supported; 2374 break; 2375 case 0x6: case 0x16: 2376 printf("Intel CL\n"); 2377 goto not_supported; 2378 break; 2379 case 0x7: case 0x8: case 0xA: case 0xB: 2380 printf("Intel PIII\n"); 2381 goto not_supported; 2382 break; 2383 case 0x9: case 0xD: 2384 printf("Intel PM\n"); 2385 goto not_supported; 2386 break; 2387 case 0xE: 2388 printf("Intel CORE\n"); 2389 goto not_supported; 2390 break; 2391 case 0xF: 2392 printf("Intel CORE2\n"); 2393 goto not_supported; 2394 break; 2395 case 0x17: 2396 printf("Intel CORE2EXTREME\n"); 2397 goto not_supported; 2398 break; 2399 case 0x1C: /* Per Intel document 320047-002. */ 2400 printf("Intel ATOM\n"); 2401 goto not_supported; 2402 break; 2403 case 0x1A: 2404 case 0x1E: /* 2405 * Per Intel document 253669-032 9/2009, 2406 * pages A-2 and A-57 2407 */ 2408 case 0x1F: /* 2409 * Per Intel document 253669-032 9/2009, 2410 * pages A-2 and A-57 2411 */ 2412 printf("Intel COREI7\n"); 2413 goto not_supported; 2414 break; 2415 case 0x2E: 2416 printf("Intel NEHALEM\n"); 2417 goto not_supported; 2418 break; 2419 case 0x25: /* Per Intel document 253669-033US 12/2009. */ 2420 case 0x2C: /* Per Intel document 253669-033US 12/2009. */ 2421 printf("Intel WESTMERE\n"); 2422 goto not_supported; 2423 break; 2424 case 0x2F: /* Westmere-EX, seen in wild */ 2425 printf("Intel WESTMERE\n"); 2426 goto not_supported; 2427 break; 2428 case 0x2A: /* Per Intel document 253669-039US 05/2011. */ 2429 printf("Intel SANDYBRIDGE\n"); 2430 set_sandybridge(); 2431 break; 2432 case 0x2D: /* Per Intel document 253669-044US 08/2012. */ 2433 printf("Intel SANDYBRIDGE_XEON\n"); 2434 set_sandybridge(); 2435 break; 2436 case 0x3A: /* Per Intel document 253669-043US 05/2012. */ 2437 printf("Intel IVYBRIDGE\n"); 2438 set_ivybridge(); 2439 break; 2440 case 0x3E: /* Per Intel document 325462-045US 01/2013. */ 2441 printf("Intel IVYBRIDGE_XEON\n"); 2442 set_ivybridge(); 2443 break; 2444 case 0x3F: /* Per Intel document 325462-045US 09/2014. */ 2445 printf("Intel HASWELL (Xeon)\n"); 2446 set_haswell(); 2447 break; 2448 case 0x3C: /* Per Intel document 325462-045US 01/2013. */ 2449 case 0x45: 2450 case 0x46: 2451 printf("Intel HASWELL\n"); 2452 set_haswell(); 2453 break; 2454 2455 case 0x4e: 2456 case 0x5e: 2457 printf("Intel SKY-LAKE\n"); 2458 goto not_supported; 2459 break; 2460 case 0x3D: 2461 case 0x47: 2462 printf("Intel BROADWELL\n"); 2463 set_broadwell(); 2464 break; 2465 case 0x4f: 2466 case 0x56: 2467 printf("Intel BROADWEL (Xeon)\n"); 2468 set_broadwell(); 2469 break; 2470 2471 case 0x4D: 2472 /* Per Intel document 330061-001 01/2014. */ 2473 printf("Intel ATOM_SILVERMONT\n"); 2474 goto not_supported; 2475 break; 2476 default: 2477 printf("Intel model 0x%x is not known -- sorry\n", 2478 model); 2479 goto not_supported; 2480 break; 2481 } 2482 break; 2483 case 0xF00: /* P4 */ 2484 printf("Intel unknown model %d\n", model); 2485 goto not_supported; 2486 break; 2487 } 2488 do_cpuid(0xa, 0, reg); 2489 max_pmc_counters = (reg[3] & 0x0000000f) + 1; 2490 printf("We have %d PMC counters to work with\n", max_pmc_counters); 2491 /* Ok lets load the list of all known PMC's */ 2492 io = my_popen("/usr/sbin/pmccontrol -L", "r", &pid_of_command); 2493 if (valid_pmcs == NULL) { 2494 /* Likely */ 2495 pmc_allocated_cnt = PMC_INITIAL_ALLOC; 2496 sz = sizeof(char *) * pmc_allocated_cnt; 2497 valid_pmcs = malloc(sz); 2498 if (valid_pmcs == NULL) { 2499 printf("No memory allocation fails at startup?\n"); 2500 exit(-1); 2501 } 2502 memset(valid_pmcs, 0, sz); 2503 } 2504 2505 while (fgets(linebuf, sizeof(linebuf), io) != NULL) { 2506 if (linebuf[0] != '\t') { 2507 /* sometimes headers ;-) */ 2508 continue; 2509 } 2510 len = strlen(linebuf); 2511 if (linebuf[(len-1)] == '\n') { 2512 /* Likely */ 2513 linebuf[(len-1)] = 0; 2514 } 2515 str = &linebuf[1]; 2516 len = strlen(str) + 1; 2517 valid_pmcs[valid_pmc_cnt] = malloc(len); 2518 if (valid_pmcs[valid_pmc_cnt] == NULL) { 2519 printf("No memory2 allocation fails at startup?\n"); 2520 exit(-1); 2521 } 2522 memset(valid_pmcs[valid_pmc_cnt], 0, len); 2523 strcpy(valid_pmcs[valid_pmc_cnt], str); 2524 valid_pmc_cnt++; 2525 if (valid_pmc_cnt >= pmc_allocated_cnt) { 2526 /* Got to expand -- unlikely */ 2527 char **more; 2528 2529 sz = sizeof(char *) * (pmc_allocated_cnt * 2); 2530 more = malloc(sz); 2531 if (more == NULL) { 2532 printf("No memory3 allocation fails at startup?\n"); 2533 exit(-1); 2534 } 2535 memset(more, 0, sz); 2536 memcpy(more, valid_pmcs, sz); 2537 pmc_allocated_cnt *= 2; 2538 free(valid_pmcs); 2539 valid_pmcs = more; 2540 } 2541 } 2542 my_pclose(io, pid_of_command); 2543 return; 2544 not_supported: 2545 printf("Not supported\n"); 2546 exit(-1); 2547 } 2548 2549 static void 2550 explain_all(void) 2551 { 2552 int i; 2553 printf("For CPU's of type %s the following expressions are available:\n",the_cpu.cputype); 2554 printf("-------------------------------------------------------------\n"); 2555 for(i=0; i<the_cpu.number; i++){ 2556 printf("For -e %s ", the_cpu.ents[i].name); 2557 (*the_cpu.explain)(the_cpu.ents[i].name); 2558 printf("----------------------------\n"); 2559 } 2560 } 2561 2562 static void 2563 test_for_a_pmc(const char *pmc, int out_so_far) 2564 { 2565 FILE *io; 2566 pid_t pid_of_command=0; 2567 char my_command[1024]; 2568 char line[1024]; 2569 char resp[1024]; 2570 int len, llen, i; 2571 2572 if (out_so_far < 50) { 2573 len = 50 - out_so_far; 2574 for(i=0; i<len; i++) { 2575 printf(" "); 2576 } 2577 } 2578 sprintf(my_command, "/usr/sbin/pmcstat -w .25 -c 0 -s %s", pmc); 2579 io = my_popen(my_command, "r", &pid_of_command); 2580 if (io == NULL) { 2581 printf("Failed -- popen fails\n"); 2582 return; 2583 } 2584 /* Setup what we expect */ 2585 len = sprintf(resp, "%s", pmc); 2586 if (fgets(line, sizeof(line), io) == NULL) { 2587 printf("Failed -- no output from pmstat\n"); 2588 goto out; 2589 } 2590 llen = strlen(line); 2591 if (line[(llen-1)] == '\n') { 2592 line[(llen-1)] = 0; 2593 llen--; 2594 } 2595 for(i=2; i<(llen-len); i++) { 2596 if (strncmp(&line[i], "ERROR", 5) == 0) { 2597 printf("Failed %s\n", line); 2598 goto out; 2599 } else if (strncmp(&line[i], resp, len) == 0) { 2600 int j, k; 2601 2602 if (fgets(line, sizeof(line), io) == NULL) { 2603 printf("Failed -- no second output from pmstat\n"); 2604 goto out; 2605 } 2606 len = strlen(line); 2607 for (j=0; j<len; j++) { 2608 if (line[j] == ' ') { 2609 j++; 2610 } else { 2611 break; 2612 } 2613 } 2614 printf("Pass"); 2615 len = strlen(&line[j]); 2616 if (len < 20) { 2617 for(k=0; k<(20-len); k++) { 2618 printf(" "); 2619 } 2620 } 2621 if (len) { 2622 printf("%s", &line[j]); 2623 } else { 2624 printf("\n"); 2625 } 2626 goto out; 2627 } 2628 } 2629 printf("Failed -- '%s' not '%s'\n", line, resp); 2630 out: 2631 my_pclose(io, pid_of_command); 2632 2633 } 2634 2635 static int 2636 add_it_to(char **vars, int cur_cnt, char *name) 2637 { 2638 int i; 2639 size_t len; 2640 for(i=0; i<cur_cnt; i++) { 2641 if (strcmp(vars[i], name) == 0) { 2642 /* Already have */ 2643 return(0); 2644 } 2645 } 2646 if (vars[cur_cnt] != NULL) { 2647 printf("Cur_cnt:%d filled with %s??\n", 2648 cur_cnt, vars[cur_cnt]); 2649 exit(-1); 2650 } 2651 /* Ok its new */ 2652 len = strlen(name) + 1; 2653 vars[cur_cnt] = malloc(len); 2654 if (vars[cur_cnt] == NULL) { 2655 printf("No memory %s\n", __FUNCTION__); 2656 exit(-1); 2657 } 2658 memset(vars[cur_cnt], 0, len); 2659 strcpy(vars[cur_cnt], name); 2660 return(1); 2661 } 2662 2663 static char * 2664 build_command_for_exp(struct expression *exp) 2665 { 2666 /* 2667 * Build the pmcstat command to handle 2668 * the passed in expression. 2669 * /usr/sbin/pmcstat -w 1 -s NNN -s QQQ 2670 * where NNN and QQQ represent the PMC's in the expression 2671 * uniquely.. 2672 */ 2673 char forming[1024]; 2674 int cnt_pmc, alloced_pmcs, i; 2675 struct expression *at; 2676 char **vars, *cmd; 2677 size_t mal; 2678 2679 alloced_pmcs = cnt_pmc = 0; 2680 /* first how many do we have */ 2681 at = exp; 2682 while (at) { 2683 if (at->type == TYPE_VALUE_PMC) { 2684 cnt_pmc++; 2685 } 2686 at = at->next; 2687 } 2688 if (cnt_pmc == 0) { 2689 printf("No PMC's in your expression -- nothing to do!!\n"); 2690 exit(0); 2691 } 2692 mal = cnt_pmc * sizeof(char *); 2693 vars = malloc(mal); 2694 if (vars == NULL) { 2695 printf("No memory\n"); 2696 exit(-1); 2697 } 2698 memset(vars, 0, mal); 2699 at = exp; 2700 while (at) { 2701 if (at->type == TYPE_VALUE_PMC) { 2702 if(add_it_to(vars, alloced_pmcs, at->name)) { 2703 alloced_pmcs++; 2704 } 2705 } 2706 at = at->next; 2707 } 2708 /* Now we have a unique list in vars so create our command */ 2709 mal = 23; /* "/usr/sbin/pmcstat -w 1" + \0 */ 2710 for(i=0; i<alloced_pmcs; i++) { 2711 mal += strlen(vars[i]) + 4; /* var + " -s " */ 2712 } 2713 cmd = malloc((mal+2)); 2714 if (cmd == NULL) { 2715 printf("%s out of mem\n", __FUNCTION__); 2716 exit(-1); 2717 } 2718 memset(cmd, 0, (mal+2)); 2719 strcpy(cmd, "/usr/sbin/pmcstat -w 1"); 2720 at = exp; 2721 for(i=0; i<alloced_pmcs; i++) { 2722 sprintf(forming, " -s %s", vars[i]); 2723 strcat(cmd, forming); 2724 free(vars[i]); 2725 vars[i] = NULL; 2726 } 2727 free(vars); 2728 return(cmd); 2729 } 2730 2731 static int 2732 user_expr(struct counters *cpu, int pos) 2733 { 2734 int ret; 2735 double res; 2736 struct counters *var; 2737 struct expression *at; 2738 2739 at = master_exp; 2740 while (at) { 2741 if (at->type == TYPE_VALUE_PMC) { 2742 var = find_counter(cpu, at->name); 2743 if (var == NULL) { 2744 printf("%s:Can't find counter %s?\n", __FUNCTION__, at->name); 2745 exit(-1); 2746 } 2747 if (pos != -1) { 2748 at->value = var->vals[pos] * 1.0; 2749 } else { 2750 at->value = var->sum * 1.0; 2751 } 2752 } 2753 at = at->next; 2754 } 2755 res = run_expr(master_exp, 1, NULL); 2756 ret = printf("%1.3f", res); 2757 return(ret); 2758 } 2759 2760 2761 static void 2762 set_manual_exp(struct expression *exp) 2763 { 2764 expression = user_expr; 2765 command = build_command_for_exp(exp); 2766 threshold = "User defined threshold"; 2767 } 2768 2769 static void 2770 run_tests(void) 2771 { 2772 int i, lenout; 2773 printf("Running tests on %d PMC's this may take some time\n", valid_pmc_cnt); 2774 printf("------------------------------------------------------------------------\n"); 2775 for(i=0; i<valid_pmc_cnt; i++) { 2776 lenout = printf("%s", valid_pmcs[i]); 2777 fflush(stdout); 2778 test_for_a_pmc(valid_pmcs[i], lenout); 2779 } 2780 } 2781 static void 2782 list_all(void) 2783 { 2784 int i, cnt, j; 2785 printf("PMC Abbreviation\n"); 2786 printf("--------------------------------------------------------------\n"); 2787 for(i=0; i<valid_pmc_cnt; i++) { 2788 cnt = printf("%s", valid_pmcs[i]); 2789 for(j=cnt; j<52; j++) { 2790 printf(" "); 2791 } 2792 printf("%%%d\n", i); 2793 } 2794 } 2795 2796 2797 int 2798 main(int argc, char **argv) 2799 { 2800 int i, j, cnt; 2801 char *filename=NULL; 2802 const char *name=NULL; 2803 int help_only = 0; 2804 int test_mode = 0; 2805 int test_at = 0; 2806 2807 get_cpuid_set(); 2808 memset(glob_cpu, 0, sizeof(glob_cpu)); 2809 while ((i = getopt(argc, argv, "ALHhvm:i:?e:TE:")) != -1) { 2810 switch (i) { 2811 case 'A': 2812 run_all = 1; 2813 break; 2814 case 'L': 2815 list_all(); 2816 return(0); 2817 case 'H': 2818 printf("**********************************\n"); 2819 explain_all(); 2820 printf("**********************************\n"); 2821 return(0); 2822 break; 2823 case 'T': 2824 test_mode = 1; 2825 break; 2826 case 'E': 2827 master_exp = parse_expression(optarg); 2828 if (master_exp) { 2829 set_manual_exp(master_exp); 2830 } 2831 break; 2832 case 'e': 2833 if (validate_expression(optarg)) { 2834 printf("Unknown expression %s\n", optarg); 2835 return(0); 2836 } 2837 name = optarg; 2838 set_expression(optarg); 2839 break; 2840 case 'm': 2841 max_to_collect = strtol(optarg, NULL, 0); 2842 if (max_to_collect > MAX_COUNTER_SLOTS) { 2843 /* You can't collect more than max in array */ 2844 max_to_collect = MAX_COUNTER_SLOTS; 2845 } 2846 break; 2847 case 'v': 2848 verbose++; 2849 break; 2850 case 'h': 2851 help_only = 1; 2852 break; 2853 case 'i': 2854 filename = optarg; 2855 break; 2856 case '?': 2857 default: 2858 use: 2859 printf("Use %s [ -i inputfile -v -m max_to_collect -e expr -E -h -? -H]\n", 2860 argv[0]); 2861 printf("-i inputfile -- use source as inputfile not stdin (if stdin collect)\n"); 2862 printf("-v -- verbose dump debug type things -- you don't want this\n"); 2863 printf("-m N -- maximum to collect is N measurments\n"); 2864 printf("-e expr-name -- Do expression expr-name\n"); 2865 printf("-E 'your expression' -- Do your expression\n"); 2866 printf("-h -- Don't do the expression I put in -e xxx just explain what it does and exit\n"); 2867 printf("-H -- Don't run anything, just explain all canned expressions\n"); 2868 printf("-T -- Test all PMC's defined by this processor\n"); 2869 printf("-A -- Run all canned tests\n"); 2870 return(0); 2871 break; 2872 } 2873 } 2874 if ((run_all == 0) && (name == NULL) && (filename == NULL) && 2875 (test_mode == 0) && (master_exp == NULL)) { 2876 printf("Without setting an expression we cannot dynamically gather information\n"); 2877 printf("you must supply a filename (and you probably want verbosity)\n"); 2878 goto use; 2879 } 2880 if (run_all && max_to_collect > 10) { 2881 max_to_collect = 3; 2882 } 2883 if (test_mode) { 2884 run_tests(); 2885 return(0); 2886 } 2887 printf("*********************************\n"); 2888 if ((master_exp == NULL) && name) { 2889 (*the_cpu.explain)(name); 2890 } else if (master_exp) { 2891 printf("Examine your expression "); 2892 print_exp(master_exp); 2893 printf("User defined threshold\n"); 2894 } 2895 if (help_only) { 2896 return(0); 2897 } 2898 if (run_all) { 2899 more: 2900 name = the_cpu.ents[test_at].name; 2901 printf("***Test %s (threshold %s)****\n", name, the_cpu.ents[test_at].thresh); 2902 test_at++; 2903 if (set_expression(name) == -1) { 2904 if (test_at >= the_cpu.number) { 2905 goto done; 2906 } else 2907 goto more; 2908 } 2909 2910 } 2911 process_file(filename); 2912 if (verbose >= 2) { 2913 for (i=0; i<ncnts; i++) { 2914 printf("Counter:%s cpu:%d index:%d\n", 2915 cnts[i].counter_name, 2916 cnts[i].cpu, i); 2917 for(j=0; j<cnts[i].pos; j++) { 2918 printf(" val - %ld\n", (long int)cnts[i].vals[j]); 2919 } 2920 printf(" sum - %ld\n", (long int)cnts[i].sum); 2921 } 2922 } 2923 if (expression == NULL) { 2924 return(0); 2925 } 2926 if (max_to_collect > 1) { 2927 for(i=0, cnt=0; i<MAX_CPU; i++) { 2928 if (glob_cpu[i]) { 2929 do_expression(glob_cpu[i], -1); 2930 cnt++; 2931 if (cnt == cpu_count_out) { 2932 printf("\n"); 2933 break; 2934 } else { 2935 printf("\t"); 2936 } 2937 } 2938 } 2939 } 2940 if (run_all && (test_at < the_cpu.number)) { 2941 memset(glob_cpu, 0, sizeof(glob_cpu)); 2942 ncnts = 0; 2943 printf("*********************************\n"); 2944 goto more; 2945 } else if (run_all) { 2946 done: 2947 printf("*********************************\n"); 2948 } 2949 return(0); 2950 } 2951