diff options
author | rrs <rrs@FreeBSD.org> | 2015-03-24 20:00:11 +0000 |
---|---|---|
committer | rrs <rrs@FreeBSD.org> | 2015-03-24 20:00:11 +0000 |
commit | 0444d8258d3c6c2219b8aadd39daf2fe9473512c (patch) | |
tree | 4d16eb1cb375dcd059efa00e91a45c0fbf17563a /usr.sbin | |
parent | f5cf31bac5259172697ccde44e661519990bc4b4 (diff) | |
download | FreeBSD-src-0444d8258d3c6c2219b8aadd39daf2fe9473512c.zip FreeBSD-src-0444d8258d3c6c2219b8aadd39daf2fe9473512c.tar.gz |
MFC of r277177 and r279894 with the fixes for the PMC for Haswell.
Sponsored by: Netflix Inc.
Diffstat (limited to 'usr.sbin')
-rw-r--r-- | usr.sbin/Makefile | 1 | ||||
-rw-r--r-- | usr.sbin/pmcstudy/Makefile | 11 | ||||
-rw-r--r-- | usr.sbin/pmcstudy/eval_expr.c | 717 | ||||
-rw-r--r-- | usr.sbin/pmcstudy/eval_expr.h | 58 | ||||
-rw-r--r-- | usr.sbin/pmcstudy/pmcstudy.1 | 65 | ||||
-rw-r--r-- | usr.sbin/pmcstudy/pmcstudy.c | 2425 |
6 files changed, 3277 insertions, 0 deletions
diff --git a/usr.sbin/Makefile b/usr.sbin/Makefile index d2e55e2..b501d1c 100644 --- a/usr.sbin/Makefile +++ b/usr.sbin/Makefile @@ -279,6 +279,7 @@ SUBDIR+= pkg_install SUBDIR+= pmcannotate SUBDIR+= pmccontrol SUBDIR+= pmcstat +SUBDIR+= pmcstudy .endif .if ${MK_PORTSNAP} != "no" diff --git a/usr.sbin/pmcstudy/Makefile b/usr.sbin/pmcstudy/Makefile new file mode 100644 index 0000000..87a6d66 --- /dev/null +++ b/usr.sbin/pmcstudy/Makefile @@ -0,0 +1,11 @@ +# @(#)Makefile 8.1 (Berkeley) 6/9/93 +# $FreeBSD$ + +PROG= pmcstudy +SRCS= pmcstudy.c eval_expr.c +CFLAGS+= -Wall -Werror + +BINDIR= /usr/bin + +.include <bsd.prog.mk> + diff --git a/usr.sbin/pmcstudy/eval_expr.c b/usr.sbin/pmcstudy/eval_expr.c new file mode 100644 index 0000000..c225391 --- /dev/null +++ b/usr.sbin/pmcstudy/eval_expr.c @@ -0,0 +1,717 @@ +/*- + * Copyright (c) 2015 Netflix Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include <sys/types.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <strings.h> +#include <ctype.h> +#include "eval_expr.h" +__FBSDID("$FreeBSD$"); + +static struct expression * +alloc_and_hook_expr(struct expression **exp_p, struct expression **last_p) +{ + struct expression *ex, *at; + + ex = malloc(sizeof(struct expression)); + if (ex == NULL) { + printf("Out of memory in exp allocation\n"); + exit(-2); + } + memset(ex, 0, sizeof(struct expression)); + if (*exp_p == NULL) { + *exp_p = ex; + } + at = *last_p; + if (at == NULL) { + /* First one, its last */ + *last_p = ex; + } else { + /* Chain it to the end and update last */ + at->next = ex; + ex->prev = at; + *last_p = ex; + } + return (ex); +} + + +static int +validate_expr(struct expression *exp, int val1_is_set, int op_is_set, int val2_is_set, + int *op_cnt) +{ + int val1, op, val2; + int open_cnt; + val1 = op = val2 = 0; + if (val1_is_set) { + val1 = 1; + } + if (op_is_set) { + op = 1; + } + if (val2_is_set) { + val2 = 1; + } + open_cnt = *op_cnt; + if (exp == NULL) { + /* End of the road */ + if (val1 && op && val2 && (open_cnt == 0)) { + return(0); + } else { + return(1); + } + } + switch(exp->type) { + case TYPE_OP_PLUS: + case TYPE_OP_MINUS: + case TYPE_OP_MULT: + case TYPE_OP_DIVIDE: + if (val1 && op && val2) { + /* We are at x + y + + * collapse back to val/op + */ + val1 = 1; + op = 1; + val2 = 0; + } else if ((op == 0) && (val1)) { + op = 1; + } else { + printf("Op but no val1 set\n"); + return(-1); + } + break; + case TYPE_PARN_OPEN: + if (exp->next == NULL) { + printf("NULL after open paren\n"); + exit(-1); + } + if ((exp->next->type == TYPE_OP_PLUS) || + (exp->next->type == TYPE_OP_MINUS) || + (exp->next->type == TYPE_OP_DIVIDE) || + (exp->next->type == TYPE_OP_MULT)) { + printf("'( OP' -- not allowed\n"); + return(-1); + } + if (val1 && (op == 0)) { + printf("'Val (' -- not allowed\n"); + return(-1); + } + if (val1 && op && val2) { + printf("'Val OP Val (' -- not allowed\n"); + return(-1); + } + open_cnt++; + *op_cnt = open_cnt; + if (val1) { + if (validate_expr(exp->next, 0, 0, 0, op_cnt) == 0) { + val2 = 1; + } else { + return(-1); + } + } else { + return(validate_expr(exp->next, 0, 0, 0, op_cnt)); + } + break; + case TYPE_PARN_CLOSE: + open_cnt--; + *op_cnt = open_cnt; + if (val1 && op && val2) { + return(0); + } else { + printf("Found close paren and not complete\n"); + return(-1); + } + break; + case TYPE_VALUE_CON: + case TYPE_VALUE_PMC: + if (val1 == 0) { + val1 = 1; + } else if (val1 && op) { + val2 = 1; + } else { + printf("val1 set, val2 about to be set op empty\n"); + return(-1); + } + break; + default: + printf("unknown type %d\n", exp->type); + exit(-5); + break; + } + return(validate_expr(exp->next, val1, op, val2, op_cnt)); +} + +void +print_exp(struct expression *exp) +{ + if (exp == NULL) { + printf("\n"); + return; + } + switch(exp->type) { + case TYPE_OP_PLUS: + printf(" + "); + break; + case TYPE_OP_MINUS: + printf(" - "); + break; + case TYPE_OP_MULT: + printf(" * "); + break; + case TYPE_OP_DIVIDE: + printf(" / "); + break; + case TYPE_PARN_OPEN: + printf(" ( "); + break; + case TYPE_PARN_CLOSE: + printf(" ) "); + break; + case TYPE_VALUE_CON: + printf("%f", exp->value); + break; + case TYPE_VALUE_PMC: + printf("%s", exp->name); + break; + default: + printf("Unknown op %d\n", exp->type); + break; + } + print_exp(exp->next); +} + +static void +walk_back_and_insert_paren(struct expression **beg, struct expression *frm) +{ + struct expression *at, *ex; + + /* Setup our new open paren */ + ex = malloc(sizeof(struct expression)); + if (ex == NULL) { + printf("Out of memory in exp allocation\n"); + exit(-2); + } + memset(ex, 0, sizeof(struct expression)); + ex->type = TYPE_PARN_OPEN; + /* Now lets place it */ + at = frm->prev; + if (at == *beg) { + /* We are inserting at the head of the list */ + in_beg: + ex->next = at; + at->prev = ex; + *beg = ex; + return; + } else if ((at->type == TYPE_VALUE_CON) || + (at->type == TYPE_VALUE_PMC)) { + /* Simple case we have a value in the previous position */ + in_mid: + ex->prev = at->prev; + ex->prev->next = ex; + ex->next = at; + at->prev = ex; + return; + } else if (at->type == TYPE_PARN_CLOSE) { + /* Skip through until we reach beg or all ( closes */ + int par_cnt=1; + + at = at->prev; + while(par_cnt) { + if (at->type == TYPE_PARN_CLOSE) { + par_cnt++; + } else if (at->type == TYPE_PARN_OPEN) { + par_cnt--; + if (par_cnt == 0) { + break; + } + } + at = at->prev; + } + if (at == *beg) { + /* At beginning we insert */ + goto in_beg; + } else { + goto in_mid; + } + } else { + printf("%s:Unexpected type:%d?\n", + __FUNCTION__, at->type); + exit(-1); + } +} + +static void +walk_fwd_and_insert_paren(struct expression *frm, struct expression **added) +{ + struct expression *at, *ex; + /* Setup our new close paren */ + ex = malloc(sizeof(struct expression)); + if (ex == NULL) { + printf("Out of memory in exp allocation\n"); + exit(-2); + } + memset(ex, 0, sizeof(struct expression)); + ex->type = TYPE_PARN_CLOSE; + *added = ex; + /* Now lets place it */ + at = frm->next; + if ((at->type == TYPE_VALUE_CON) || + (at->type == TYPE_VALUE_PMC)) { + /* Simple case we have a value in the previous position */ + insertit: + ex->next = at->next; + ex->prev = at; + at->next = ex; + return; + } else if (at->type == TYPE_PARN_OPEN) { + int par_cnt=1; + at = at->next; + while(par_cnt) { + if (at->type == TYPE_PARN_OPEN) { + par_cnt++; + } else if (at->type == TYPE_PARN_CLOSE) { + par_cnt--; + if (par_cnt == 0) { + break; + } + } + at = at->next; + } + goto insertit; + } else { + printf("%s:Unexpected type:%d?\n", + __FUNCTION__, + at->type); + exit(-1); + } +} + + +static void +add_precendence(struct expression **beg, struct expression *start, struct expression *end) +{ + /* + * Between start and end add () around any * or /. This + * is quite tricky since if there is a () set inside the + * list we need to skip over everything in the ()'s considering + * that just a value. + */ + struct expression *at, *newone; + int open_cnt; + + at = start; + open_cnt = 0; + while(at != end) { + if (at->type == TYPE_PARN_OPEN) { + open_cnt++; + } + if (at->type == TYPE_PARN_CLOSE) { + open_cnt--; + } + if (open_cnt == 0) { + if ((at->type == TYPE_OP_MULT) || + (at->type == TYPE_OP_DIVIDE)) { + walk_back_and_insert_paren(beg, at); + walk_fwd_and_insert_paren(at, &newone); + at = newone->next; + continue; + } + } + at = at->next; + } + +} + +static void +set_math_precidence(struct expression **beg, struct expression *exp, struct expression **stopped) +{ + struct expression *at, *start, *end; + int cnt_lower, cnt_upper; + /* + * Walk through and set any math precedence to + * get proper precedence we insert () around * / over + - + */ + end = NULL; + start = at = exp; + cnt_lower = cnt_upper = 0; + while(at) { + if (at->type == TYPE_PARN_CLOSE) { + /* Done with that paren */ + if (stopped) { + *stopped = at; + } + if (cnt_lower && cnt_upper) { + /* We have a mixed set ... add precedence between start/end */ + add_precendence(beg, start, end); + } + return; + } + if (at->type == TYPE_PARN_OPEN) { + set_math_precidence(beg, at->next, &end); + at = end; + continue; + } else if ((at->type == TYPE_OP_PLUS) || + (at->type == TYPE_OP_MINUS)) { + cnt_lower++; + } else if ((at->type == TYPE_OP_DIVIDE) || + (at->type == TYPE_OP_MULT)) { + cnt_upper++; + } + at = at->next; + } + if (cnt_lower && cnt_upper) { + add_precendence(beg, start, NULL); + } +} + +extern char **valid_pmcs; +extern int valid_pmc_cnt; + +static void +pmc_name_set(struct expression *at) +{ + int i, idx, fnd; + + if (at->name[0] == '%') { + /* Special number after $ gives index */ + idx = strtol(&at->name[1], NULL, 0); + if (idx >= valid_pmc_cnt) { + printf("Unknown PMC %s -- largest we have is $%d -- can't run your expression\n", + at->name, valid_pmc_cnt); + exit(-1); + } + strcpy(at->name, valid_pmcs[idx]); + } else { + for(i=0, fnd=0; i<valid_pmc_cnt; i++) { + if (strcmp(valid_pmcs[i], at->name) == 0) { + fnd = 1; + break; + } + } + if (!fnd) { + printf("PMC %s does not exist on this machine -- can't run your expression\n", + at->name); + exit(-1); + } + } +} + +struct expression * +parse_expression(char *str) +{ + struct expression *exp=NULL, *last=NULL, *at; + int open_par, close_par; + int op_cnt=0; + size_t siz, i, x; + /* + * Walk through a string expression and convert + * it to a linked list of actions. We do this by: + * a) Counting the open/close paren's, there must + * be a matching number. + * b) If we have balanced paren's then create a linked list + * of the operators, then we validate that expression further. + * c) Validating that we have: + * val OP val <or> + * val OP ( <and> + * inside every paran you have a: + * val OP val <or> + * val OP ( <recursively> + * d) A final optional step (not implemented yet) would be + * to insert the mathimatical precedence paran's. For + * the start we will just do the left to right evaluation and + * then later we can add this guy to add paran's to make it + * mathimatically correct... i.e instead of 1 + 2 * 3 we + * would translate it into 1 + ( 2 * 3). + */ + open_par = close_par = 0; + siz = strlen(str); + /* No trailing newline please */ + if (str[(siz-1)] == '\n') { + str[(siz-1)] = 0; + siz--; + } + for(i=0; i<siz; i++) { + if (str[i] == '(') { + open_par++; + } else if (str[i] == ')') { + close_par++; + } + } + if (open_par != close_par) { + printf("Invalid expression '%s' %d open paren's and %d close?\n", + str, open_par, close_par); + exit(-1); + } + for(i=0; i<siz; i++) { + if (str[i] == '(') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_PARN_OPEN; + } else if (str[i] == ')') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_PARN_CLOSE; + } else if (str[i] == ' ') { + /* Extra blank */ + continue; + } else if (str[i] == '\t') { + /* Extra tab */ + continue; + } else if (str[i] == '+') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_OP_PLUS; + } else if (str[i] == '-') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_OP_MINUS; + } else if (str[i] == '/') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_OP_DIVIDE; + } else if (str[i] == '*') { + at = alloc_and_hook_expr(&exp, &last); + at->type = TYPE_OP_MULT; + } else { + /* Its a value or PMC constant */ + at = alloc_and_hook_expr(&exp, &last); + if (isdigit(str[i]) || (str[i] == '.')) { + at->type = TYPE_VALUE_CON; + } else { + at->type = TYPE_VALUE_PMC; + } + x = 0; + while ((str[i] != ' ') && + (str[i] != '\t') && + (str[i] != 0) && + (str[i] != ')') && + (str[i] != '(')) { + /* We collect the constant until a space or tab */ + at->name[x] = str[i]; + i++; + x++; + if (x >=(sizeof(at->name)-1)) { + printf("Value/Constant too long %d max:%d\n", + (int)x, (int)(sizeof(at->name)-1)); + exit(-3); + } + } + if (str[i] != 0) { + /* Need to back up and see the last char since + * the for will increment the loop. + */ + i--; + } + /* Now we have pulled the string, set it up */ + if (at->type == TYPE_VALUE_CON) { + at->state = STATE_FILLED; + at->value = strtod(at->name, NULL); + } else { + pmc_name_set(at); + } + } + } + /* Now lets validate its a workable expression */ + if (validate_expr(exp, 0, 0, 0, &op_cnt)) { + printf("Invalid expression\n"); + exit(-4); + } + set_math_precidence(&exp, exp, NULL); + return (exp); +} + + + +static struct expression * +gather_exp_to_paren_close(struct expression *exp, double *val_fill) +{ + /* + * I have been given ( ??? + * so I could see either + * ( + * or + * Val Op + * + */ + struct expression *lastproc; + double val; + + if (exp->type == TYPE_PARN_OPEN) { + lastproc = gather_exp_to_paren_close(exp->next, &val); + *val_fill = val; + } else { + *val_fill = run_expr(exp, 0, &lastproc); + } + return(lastproc); +} + + +double +run_expr(struct expression *exp, int initial_call, struct expression **lastone) +{ + /* + * We expect to find either + * a) A Open Paren + * or + * b) Val-> Op -> Val + * or + * c) Val-> Op -> Open Paren + */ + double val1, val2, res; + struct expression *op, *other_half, *rest; + + if (exp->type == TYPE_PARN_OPEN) { + op = gather_exp_to_paren_close(exp->next, &val1); + } else if(exp->type == TYPE_VALUE_CON) { + val1 = exp->value; + op = exp->next; + } else if (exp->type == TYPE_VALUE_PMC) { + val1 = exp->value; + op = exp->next; + } else { + printf("Illegal value in %s huh?\n", __FUNCTION__); + exit(-1); + } + if (op == NULL) { + return (val1); + } +more_to_do: + other_half = op->next; + if (other_half->type == TYPE_PARN_OPEN) { + rest = gather_exp_to_paren_close(other_half->next, &val2); + } else if(other_half->type == TYPE_VALUE_CON) { + val2 = other_half->value; + rest = other_half->next; + } else if (other_half->type == TYPE_VALUE_PMC) { + val2 = other_half->value; + rest = other_half->next; + } else { + printf("Illegal2 value in %s huh?\n", __FUNCTION__); + exit(-1); + } + switch(op->type) { + case TYPE_OP_PLUS: + res = val1 + val2; + break; + case TYPE_OP_MINUS: + res = val1 - val2; + break; + case TYPE_OP_MULT: + res = val1 * val2; + break; + case TYPE_OP_DIVIDE: + if (val2 != 0.0) + res = val1 / val2; + else { + printf("Division by zero averted\n"); + res = 1.0; + } + break; + default: + printf("Op is not an operator -- its %d\n", + op->type); + exit(-1); + break; + } + if (rest == NULL) { + if (lastone) { + *lastone = NULL; + } + return (res); + } + if ((rest->type == TYPE_PARN_CLOSE) && (initial_call == 0)) { + if (lastone) { + *lastone = rest->next; + } + return(res); + } + /* There is more, as in + * a + b + c + * where we just did a + b + * so now it becomes val1 is set to res and + * we need to proceed with the rest of it. + */ + val1 = res; + op = rest; + if ((op->type != TYPE_OP_PLUS) && + (op->type != TYPE_OP_MULT) && + (op->type != TYPE_OP_MINUS) && + (op->type != TYPE_OP_DIVIDE)) { + printf("%s ending on type:%d not an op??\n", __FUNCTION__, op->type); + return(res); + } + if (op) + goto more_to_do; + return (res); +} + +#ifdef STAND_ALONE_TESTING + +static double +calc_expr(struct expression *exp) +{ + struct expression *at; + double xx; + + /* First clear PMC's setting */ + for(at = exp; at != NULL; at = at->next) { + if (at->type == TYPE_VALUE_PMC) { + at->state = STATE_UNSET; + } + } + /* Now for all pmc's make up values .. here is where I would pull them */ + for(at = exp; at != NULL; at = at->next) { + if (at->type == TYPE_VALUE_PMC) { + at->value = (random() * 1.0); + at->state = STATE_FILLED; + if (at->value == 0.0) { + /* So we don't have div by 0 */ + at->value = 1.0; + } + } + } + /* Now lets calculate the expression */ + print_exp(exp); + xx = run_expr(exp, 1, NULL); + printf("Answer is %f\n", xx); + return(xx); +} + + +int +main(int argc, char **argv) +{ + struct expression *exp; + if (argc < 2) { + printf("Use %s expression\n", argv[0]); + return(-1); + } + exp = parse_expression(argv[1]); + printf("Now the calc\n"); + calc_expr(exp); + return(0); +} + +#endif diff --git a/usr.sbin/pmcstudy/eval_expr.h b/usr.sbin/pmcstudy/eval_expr.h new file mode 100644 index 0000000..f095513 --- /dev/null +++ b/usr.sbin/pmcstudy/eval_expr.h @@ -0,0 +1,58 @@ +#ifndef __eval_expr_h__ +#define __eval_expr_h__ +/*- + * Copyright (c) 2015 Netflix Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +__FBSDID("$FreeBSD$"); + +enum exptype { + TYPE_OP_PLUS, + TYPE_OP_MINUS, + TYPE_OP_MULT, + TYPE_OP_DIVIDE, + TYPE_PARN_OPEN, + TYPE_PARN_CLOSE, + TYPE_VALUE_CON, + TYPE_VALUE_PMC +}; + +#define STATE_UNSET 0 /* We have no setting yet in value */ +#define STATE_FILLED 1 /* We have filled in value */ + +struct expression { + struct expression *next; /* Next in expression. */ + struct expression *prev; /* Prev in expression. */ + double value; /* If there is a value to set */ + enum exptype type; /* What is it */ + uint8_t state; /* Current state if value type */ + char name[252]; /* If a PMC whats the name, con value*/ +}; + +struct expression *parse_expression(char *str); +double run_expr(struct expression *exp, int initial_call, struct expression **lastone); +void print_exp(struct expression *exp); +#endif diff --git a/usr.sbin/pmcstudy/pmcstudy.1 b/usr.sbin/pmcstudy/pmcstudy.1 new file mode 100644 index 0000000..ad779b9 --- /dev/null +++ b/usr.sbin/pmcstudy/pmcstudy.1 @@ -0,0 +1,65 @@ +.\" Copyright (c) 2015 +.\" Netflix Inc. +.\" +.\" Redistribution and use in source and binary forms, with or without +.\" modification, are permitted provided that the following conditions +.\" are met: +.\" 1. Redistributions of source code must retain the above copyright +.\" notice, this list of conditions and the following disclaimer. +.\" 2. Redistributions in binary form must reproduce the above copyright +.\" notice, this list of conditions and the following disclaimer in the +.\" documentation and/or other materials provided with the distribution. +.\" +.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND +.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +.\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE +.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS +.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) +.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +.\" SUCH DAMAGE. +.\" +.\" $FreeBSD$ +.\" +.Dd Dec 2, 2014 +.Dt PMC_COUNTER_STUDY 1 +.Os +.Sh NAME +.Nm pmc_counter_study +.Nd Perform various study's on a systems overall PMC's. +.Sh SYNOPSIS +.Nm +.Sh DESCRIPTION +The +.Nm +The pmc_counter_study program is designed to run various tests against +your systems performance. There are roughly 20-22 canned tests that +setup specific PMC's and then run various formulas on the output information. +These formulas can be found in Intel documentation "Using Intel Vtune +amplifier xe on NNN Generation Intel Core Processors". The NNN is either +2nd, 3rd or 4th generation i.e. Sandy Bridge, Ivy Bridge and Haswell. +Currently the program only works on these three Intel processor types. +You can see the complete list of formula's by running the program +with the -H option. If you know a formula name you can run it by +typing -e name. If you know a name and want what the formula is you +can run the program with -e name -h and the program will not run but +it will tell you what that name will do (if known). The -T option can +be used to test all PMC's that are known to your system. When running a +test you will want to specify -m N where N is the number of 1 second samples +to collect and analize (it bounds the time the test runs). Finally for +those that have there own ideas on what formulas that you want to run +you can type your own formula in with -E "formula". The formula can +declare directly the PMC's by name or you can use an abbreviation +%NNN. To find out the abbreviations on your system you may run +pmc_counter_study -L and it will tell you each PMC name and the +abbreviation you can use. An example of a formula of your own might +be -E "FP_ASSIST.ANY / INST_RETIRED.ANY_P" <or short hand on Haswell> +-E " %176 / %150". You must have spaces between each entry and +you may use paraenthisis to prioritize the operators. Add (+), Subtract (-1), +Divide (/) and Multiplication (*) is supported. You may also introduce +constant numbers as well. So for example you can do a standard efficency +test like -E "UOPS_RETIRED.RETIRE_SLOTS / (4 * CPU_CLK_UNHALTED.THREAD_P)". + diff --git a/usr.sbin/pmcstudy/pmcstudy.c b/usr.sbin/pmcstudy/pmcstudy.c new file mode 100644 index 0000000..6547489 --- /dev/null +++ b/usr.sbin/pmcstudy/pmcstudy.c @@ -0,0 +1,2425 @@ +/*- + * Copyright (c) 2014, 2015 Netflix Inc. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * in this position and unchanged. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include <sys/types.h> +#include <stdio.h> +#include <stdlib.h> +#include <unistd.h> +#include <string.h> +#include <strings.h> +#include <sys/errno.h> +#include <signal.h> +#include <sys/wait.h> +#include <getopt.h> +#include "eval_expr.h" +__FBSDID("$FreeBSD$"); + +#define MAX_COUNTER_SLOTS 1024 +#define MAX_NLEN 64 +#define MAX_CPU 64 +static int verbose = 0; + +extern char **environ; +extern struct expression *master_exp; +struct expression *master_exp=NULL; + +#define PMC_INITIAL_ALLOC 512 +extern char **valid_pmcs; +char **valid_pmcs = NULL; +extern int valid_pmc_cnt; +int valid_pmc_cnt=0; +extern int pmc_allocated_cnt; +int pmc_allocated_cnt=0; + +/* + * The following two varients on popen and pclose with + * the cavet that they get you the PID so that you + * can supply it to pclose so it can send a SIGTERM + * to the process. + */ +static FILE * +my_popen(const char *command, const char *dir, pid_t *p_pid) +{ + FILE *io_out, *io_in; + int pdesin[2], pdesout[2]; + char *argv[4]; + pid_t pid; + char cmd[4]; + char cmd2[1024]; + char arg1[4]; + + if ((strcmp(dir, "r") != 0) && + (strcmp(dir, "w") != 0)) { + errno = EINVAL; + return(NULL); + } + if (pipe(pdesin) < 0) + return (NULL); + + if (pipe(pdesout) < 0) { + (void)close(pdesin[0]); + (void)close(pdesin[1]); + return (NULL); + } + strcpy(cmd, "sh"); + strcpy(arg1, "-c"); + strcpy(cmd2, command); + argv[0] = cmd; + argv[1] = arg1; + argv[2] = cmd2; + argv[3] = NULL; + + switch (pid = fork()) { + case -1: /* Error. */ + (void)close(pdesin[0]); + (void)close(pdesin[1]); + (void)close(pdesout[0]); + (void)close(pdesout[1]); + return (NULL); + /* NOTREACHED */ + case 0: /* Child. */ + /* Close out un-used sides */ + (void)close(pdesin[1]); + (void)close(pdesout[0]); + /* Now prepare the stdin of the process */ + close(0); + (void)dup(pdesin[0]); + (void)close(pdesin[0]); + /* Now prepare the stdout of the process */ + close(1); + (void)dup(pdesout[1]); + /* And lets do stderr just in case */ + close(2); + (void)dup(pdesout[1]); + (void)close(pdesout[1]); + /* Now run it */ + execve("/bin/sh", argv, environ); + exit(127); + /* NOTREACHED */ + } + /* Parent; assume fdopen can't fail. */ + /* Store the pid */ + *p_pid = pid; + if (strcmp(dir, "r") != 0) { + io_out = fdopen(pdesin[1], "w"); + (void)close(pdesin[0]); + (void)close(pdesout[0]); + (void)close(pdesout[1]); + return(io_out); + } else { + /* Prepare the input stream */ + io_in = fdopen(pdesout[0], "r"); + (void)close(pdesout[1]); + (void)close(pdesin[0]); + (void)close(pdesin[1]); + return (io_in); + } +} + +/* + * pclose -- + * Pclose returns -1 if stream is not associated with a `popened' command, + * if already `pclosed', or waitpid returns an error. + */ +static void +my_pclose(FILE *io, pid_t the_pid) +{ + int pstat; + pid_t pid; + + /* + * Find the appropriate file pointer and remove it from the list. + */ + (void)fclose(io); + /* Die if you are not dead! */ + kill(the_pid, SIGTERM); + do { + pid = wait4(the_pid, &pstat, 0, (struct rusage *)0); + } while (pid == -1 && errno == EINTR); +} + +struct counters { + struct counters *next_cpu; + char counter_name[MAX_NLEN]; /* Name of counter */ + int cpu; /* CPU we are on */ + int pos; /* Index we are filling to. */ + uint64_t vals[MAX_COUNTER_SLOTS]; /* Last 64 entries */ + uint64_t sum; /* Summary of entries */ +}; + +extern struct counters *glob_cpu[MAX_CPU]; +struct counters *glob_cpu[MAX_CPU]; + +extern struct counters *cnts; +struct counters *cnts=NULL; + +extern int ncnts; +int ncnts=0; + +extern int (*expression)(struct counters *, int); +int (*expression)(struct counters *, int); + +static const char *threshold=NULL; +static const char *command; + +struct cpu_entry { + const char *name; + const char *thresh; + const char *command; + int (*func)(struct counters *, int); +}; + + +struct cpu_type { + char cputype[32]; + int number; + struct cpu_entry *ents; + void (*explain)(const char *name); +}; +extern struct cpu_type the_cpu; +struct cpu_type the_cpu; + +static void +explain_name_sb(const char *name) +{ + const char *mythresh; + if (strcmp(name, "allocstall1") == 0) { + printf("Examine PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "allocstall2") == 0) { + printf("Examine PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP_CYCLES/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "br_miss") == 0) { + printf("Examine (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "splitload") == 0) { + printf("Examine MEM_UOP_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "splitstore") == 0) { + printf("Examine MEM_UOP_RETIRED.SPLIT_STORES / MEM_UOP_RETIRED.ALL_STORES\n"); + mythresh = "thresh >= .01"; + } else if (strcmp(name, "contested") == 0) { + printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "blockstorefwd") == 0) { + printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "cache2") == 0) { + printf("Examine ((MEM_LOAD_RETIRED.L3_HIT * 26) + \n"); + printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 43) + \n"); + printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60)) / CPU_CLK_UNHALTED.THREAD_P\n"); + printf("**Note we have it labeled MEM_LOAD_UOPS_RETIRED.LLC_HIT not MEM_LOAD_RETIRED.L3_HIT\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "cache1") == 0) { + printf("Examine (MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "dtlbmissload") == 0) { + printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "frontendstall") == 0) { + printf("Examine IDQ_UOPS_NOT_DELIVERED.CORE / (CPU_CLK_UNHALTED.THREAD_P * 4)\n"); + mythresh = "thresh >= .15"; + } else if (strcmp(name, "clears") == 0) { + printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); + printf(" MACHINE_CLEARS.SMC + \n"); + printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .02"; + } else if (strcmp(name, "microassist") == 0) { + printf("Examine IDQ.MS_CYCLES / (CPU_CLK_UNHALTED.THREAD_P * 4)\n"); + printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "aliasing_4k") == 0) { + printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "fpassist") == 0) { + printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistavx") == 0) { + printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistsse") == 0) { + printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "eff1") == 0) { + printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh < .9"; + } else if (strcmp(name, "eff2") == 0) { + printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); + mythresh = "thresh > 1.0"; + } else if (strcmp(name, "dtlbmissstore") == 0) { + printf("Examine (((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION)\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh >= .05"; + } else { + printf("Unknown name:%s\n", name); + mythresh = "unknown entry"; + } + printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); +} + +static void +explain_name_ib(const char *name) +{ + const char *mythresh; + if (strcmp(name, "br_miss") == 0) { + printf("Examine ((BR_MISP_RETIRED.ALL_BRANCHES /(BR_MISP_RETIRED.ALL_BRANCHES +\n"); + printf(" MACHINE_CLEAR.COUNT) * ((UOPS_ISSUED.ANY - UOPS_RETIRED.RETIRE_SLOTS + 4 * INT_MISC.RECOVERY_CYCLES)\n"); + printf("/ (4 * CPU_CLK_UNHALTED.THREAD))))\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "eff1") == 0) { + printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh < .9"; + } else if (strcmp(name, "eff2") == 0) { + printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); + mythresh = "thresh > 1.0"; + } else if (strcmp(name, "cache1") == 0) { + printf("Examine (MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "cache2") == 0) { + printf("Examine (MEM_LOAD_UOPS_RETIRED.LLC_HIT / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "itlbmiss") == 0) { + printf("Examine ITLB_MISSES.WALK_DURATION / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "icachemiss") == 0) { + printf("Examine (ICACHE.IFETCH_STALL - ITLB_MISSES.WALK_DURATION)/ CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "lcpstall") == 0) { + printf("Examine ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "datashare") == 0) { + printf("Examine (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "blockstorefwd") == 0) { + printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "splitload") == 0) { + printf("Examine ((L1D_PEND_MISS.PENDING / MEM_LOAD_UOPS_RETIRED.L1_MISS) *\n"); + printf(" LD_BLOCKS.NO_SR)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "splitstore") == 0) { + printf("Examine MEM_UOP_RETIRED.SPLIT_STORES / MEM_UOP_RETIRED.ALL_STORES\n"); + mythresh = "thresh >= .01"; + } else if (strcmp(name, "aliasing_4k") == 0) { + printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "dtlbmissload") == 0) { + printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "dtlbmissstore") == 0) { + printf("Examine (((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION)\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "contested") == 0) { + printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "clears") == 0) { + printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); + printf(" MACHINE_CLEARS.SMC + \n"); + printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .02"; + } else if (strcmp(name, "microassist") == 0) { + printf("Examine IDQ.MS_CYCLES / (4 * CPU_CLK_UNHALTED.THREAD_P)\n"); + printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "fpassist") == 0) { + printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistavx") == 0) { + printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistsse") == 0) { + printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else { + printf("Unknown name:%s\n", name); + mythresh = "unknown entry"; + } + printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); +} + + +static void +explain_name_has(const char *name) +{ + const char *mythresh; + if (strcmp(name, "eff1") == 0) { + printf("Examine (UOPS_RETIRED.RETIRE_SLOTS)/(4 *CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh < .75"; + } else if (strcmp(name, "eff2") == 0) { + printf("Examine CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P\n"); + mythresh = "thresh > 1.0"; + } else if (strcmp(name, "itlbmiss") == 0) { + printf("Examine ITLB_MISSES.WALK_DURATION / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "icachemiss") == 0) { + printf("Examine (36 * ICACHE.MISSES)/ CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "lcpstall") == 0) { + printf("Examine ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "cache1") == 0) { + printf("Examine (MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "cache2") == 0) { + printf("Examine ((MEM_LOAD_UOPS_RETIRED.LLC_HIT * 36) + \n"); + printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 72) + \n"); + printf(" (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84))\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "contested") == 0) { + printf("Examine (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "datashare") == 0) { + printf("Examine (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 72)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh > .05"; + } else if (strcmp(name, "blockstorefwd") == 0) { + printf("Examine (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "splitload") == 0) { + printf("Examine (MEM_UOP_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "splitstore") == 0) { + printf("Examine MEM_UOP_RETIRED.SPLIT_STORES / MEM_UOP_RETIRED.ALL_STORES\n"); + mythresh = "thresh >= .01"; + } else if (strcmp(name, "aliasing_4k") == 0) { + printf("Examine (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "dtlbmissload") == 0) { + printf("Examine (((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION)\n"); + printf(" / CPU_CLK_UNHALTED.THREAD_P)\n"); + mythresh = "thresh >= .1"; + } else if (strcmp(name, "br_miss") == 0) { + printf("Examine (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD\n"); + mythresh = "thresh >= .2"; + } else if (strcmp(name, "clears") == 0) { + printf("Examine ((MACHINE_CLEARS.MEMORY_ORDERING + \n"); + printf(" MACHINE_CLEARS.SMC + \n"); + printf(" MACHINE_CLEARS.MASKMOV ) * 100 ) / CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "thresh >= .02"; + } else if (strcmp(name, "microassist") == 0) { + printf("Examine IDQ.MS_CYCLES / (4 * CPU_CLK_UNHALTED.THREAD_P)\n"); + printf("***We use IDQ.MS_UOPS,cmask=1 to get cycles\n"); + mythresh = "thresh >= .05"; + } else if (strcmp(name, "fpassist") == 0) { + printf("Examine FP_ASSIST.ANY/INST_RETIRED.ANY_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistavx") == 0) { + printf("Examine (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else if (strcmp(name, "otherassistsse") == 0) { + printf("Examine (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P\n"); + mythresh = "look for a excessive value"; + } else { + printf("Unknown name:%s\n", name); + mythresh = "unknown entry"; + } + printf("If the value printed is %s we may have the ability to improve performance\n", mythresh); +} + + +static struct counters * +find_counter(struct counters *base, const char *name) +{ + struct counters *at; + int len; + + at = base; + len = strlen(name); + while(at) { + if (strncmp(at->counter_name, name, len) == 0) { + return(at); + } + at = at->next_cpu; + } + printf("Can't find counter %s\n", name); + printf("We have:\n"); + at = base; + while(at) { + printf("- %s\n", at->counter_name); + at = at->next_cpu; + } + exit(-1); +} + +static int +allocstall1(struct counters *cpu, int pos) +{ +/* 1 - PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW/CPU_CLK_UNHALTED.THREAD_P (thresh > .05)*/ + int ret; + struct counters *partial; + struct counters *unhalt; + double un, par, res; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + partial = find_counter(cpu, "PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW"); + if (pos != -1) { + par = partial->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + par = partial->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = par/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +allocstall2(struct counters *cpu, int pos) +{ +/* 2 - PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP_CYCLES/CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ + int ret; + struct counters *partial; + struct counters *unhalt; + double un, par, res; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + partial = find_counter(cpu, "PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP"); + if (pos != -1) { + par = partial->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + par = partial->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = par/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +br_mispredict(struct counters *cpu, int pos) +{ + struct counters *brctr; + struct counters *unhalt; + int ret; +/* 3 - (20 * BR_MISP_RETIRED.ALL_BRANCHES)/CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ + double br, un, con, res; + con = 20.0; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + brctr = find_counter(cpu, "BR_MISP_RETIRED.ALL_BRANCHES"); + if (pos != -1) { + br = brctr->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + br = brctr->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (con * br)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +br_mispredictib(struct counters *cpu, int pos) +{ + struct counters *brctr; + struct counters *unhalt; + struct counters *clear, *clear2, *clear3; + struct counters *uops; + struct counters *recv; + struct counters *iss; +/* "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",*/ + int ret; + /* + * (BR_MISP_RETIRED.ALL_BRANCHES / + * (BR_MISP_RETIRED.ALL_BRANCHES + + * MACHINE_CLEAR.COUNT) * + * ((UOPS_ISSUED.ANY - UOPS_RETIRED.RETIRE_SLOTS + 4 * INT_MISC.RECOVERY_CYCLES) / (4 * CPU_CLK_UNHALTED.THREAD))) + * + */ + double br, cl, cl2, cl3, uo, re, un, con, res, is; + con = 4.0; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + brctr = find_counter(cpu, "BR_MISP_RETIRED.ALL_BRANCHES"); + clear = find_counter(cpu, "MACHINE_CLEARS.MEMORY_ORDERING"); + clear2 = find_counter(cpu, "MACHINE_CLEARS.SMC"); + clear3 = find_counter(cpu, "MACHINE_CLEARS.MASKMOV"); + uops = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); + iss = find_counter(cpu, "UOPS_ISSUED.ANY"); + recv = find_counter(cpu, "INT_MISC.RECOVERY_CYCLES"); + if (pos != -1) { + br = brctr->vals[pos] * 1.0; + cl = clear->vals[pos] * 1.0; + cl2 = clear2->vals[pos] * 1.0; + cl3 = clear3->vals[pos] * 1.0; + uo = uops->vals[pos] * 1.0; + re = recv->vals[pos] * 1.0; + is = iss->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + br = brctr->sum * 1.0; + cl = clear->sum * 1.0; + cl2 = clear2->sum * 1.0; + cl3 = clear3->sum * 1.0; + uo = uops->sum * 1.0; + re = recv->sum * 1.0; + is = iss->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (br/(br + cl + cl2 + cl3) * ((is - uo + con * re) / (con * un))); + ret = printf("%1.3f", res); + return(ret); +} + +static int +splitloadib(struct counters *cpu, int pos) +{ + int ret; + struct counters *mem; + struct counters *l1d, *ldblock; + struct counters *unhalt; + double un, memd, res, l1, ldb; + /* + * ((L1D_PEND_MISS.PENDING / MEM_LOAD_UOPS_RETIRED.L1_MISS) * LD_BLOCKS.NO_SR) / CPU_CLK_UNHALTED.THREAD_P + * "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", + */ + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.L1_MISS"); + l1d = find_counter(cpu, "L1D_PEND_MISS.PENDING"); + ldblock = find_counter(cpu, "LD_BLOCKS.NO_SR"); + if (pos != -1) { + memd = mem->vals[pos] * 1.0; + l1 = l1d->vals[pos] * 1.0; + ldb = ldblock->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + memd = mem->sum * 1.0; + l1 = l1d->sum * 1.0; + ldb = ldblock->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((l1 / memd) * ldb)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +splitload(struct counters *cpu, int pos) +{ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, memd, res; +/* 4 - (MEM_UOP_RETIRED.SPLIT_LOADS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .1)*/ + + con = 5.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_UOP_RETIRED.SPLIT_LOADS"); + if (pos != -1) { + memd = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + memd = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (memd * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +splitstore(struct counters *cpu, int pos) +{ + /* 5 - MEM_UOP_RETIRED.SPLIT_STORES / MEM_UOP_RETIRED.ALL_STORES (thresh > 0.01) */ + int ret; + struct counters *mem_split; + struct counters *mem_stores; + double memsplit, memstore, res; + mem_split = find_counter(cpu, "MEM_UOP_RETIRED.SPLIT_STORES"); + mem_stores = find_counter(cpu, "MEM_UOP_RETIRED.ALL_STORES"); + if (pos != -1) { + memsplit = mem_split->vals[pos] * 1.0; + memstore = mem_stores->vals[pos] * 1.0; + } else { + memsplit = mem_split->sum * 1.0; + memstore = mem_stores->sum * 1.0; + } + res = memsplit/memstore; + ret = printf("%1.3f", res); + return(ret); +} + + +static int +contested(struct counters *cpu, int pos) +{ + /* 6 - (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60) / CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, memd, res; + + con = 60.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); + if (pos != -1) { + memd = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + memd = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (memd * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +contested_has(struct counters *cpu, int pos) +{ + /* 6 - (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84) / CPU_CLK_UNHALTED.THREAD_P (thresh >.05) */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, memd, res; + + con = 84.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); + if (pos != -1) { + memd = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + memd = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (memd * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + + +static int +blockstoreforward(struct counters *cpu, int pos) +{ + /* 7 - (LD_BLOCKS_STORE_FORWARD * 13) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .05)*/ + int ret; + struct counters *ldb; + struct counters *unhalt; + double con, un, ld, res; + + con = 13.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + ldb = find_counter(cpu, "LD_BLOCKS_STORE_FORWARD"); + if (pos != -1) { + ld = ldb->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ld = ldb->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (ld * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +cache2(struct counters *cpu, int pos) +{ + /* ** Suspect *** + * 8 - ((MEM_LOAD_RETIRED.L3_HIT * 26) + (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 43) + + * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 60)) / CPU_CLK_UNHALTED.THREAD_P (thresh >.2) + */ + int ret; + struct counters *mem1, *mem2, *mem3; + struct counters *unhalt; + double con1, con2, con3, un, me_1, me_2, me_3, res; + + con1 = 26.0; + con2 = 43.0; + con3 = 60.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); +/* Call for MEM_LOAD_RETIRED.L3_HIT possibly MEM_LOAD_UOPS_RETIRED.LLC_HIT ?*/ + mem1 = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); + mem2 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); + mem3 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); + if (pos != -1) { + me_1 = mem1->vals[pos] * 1.0; + me_2 = mem2->vals[pos] * 1.0; + me_3 = mem3->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me_1 = mem1->sum * 1.0; + me_2 = mem2->sum * 1.0; + me_3 = mem3->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((me_1 * con1) + (me_2 * con2) + (me_3 * con3))/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +datasharing(struct counters *cpu, int pos) +{ + /* + * (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/ CPU_CLK_UNHALTED.THREAD_P (thresh >.2) + */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, res, me, un; + + con = 43.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); + if (pos != -1) { + me = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (me * con)/un; + ret = printf("%1.3f", res); + return(ret); + +} + + +static int +datasharing_has(struct counters *cpu, int pos) +{ + /* + * (MEM_LOAD_UOPS_L3_HIT_RETIRED.XSNP_HIT * 43)/ CPU_CLK_UNHALTED.THREAD_P (thresh >.2) + */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, res, me, un; + + con = 72.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); + if (pos != -1) { + me = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (me * con)/un; + ret = printf("%1.3f", res); + return(ret); + +} + + +static int +cache2ib(struct counters *cpu, int pos) +{ + /* + * (29 * MEM_LOAD_UOPS_RETIRED.LLC_HIT / CPU_CLK_UNHALTED.THREAD_P (thresh >.2) + */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, me, res; + + con = 29.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); + if (pos != -1) { + me = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (con * me)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +cache2has(struct counters *cpu, int pos) +{ + /* + * Examine ((MEM_LOAD_UOPS_RETIRED.LLC_HIT * 36) + \ + * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT * 72) + + * (MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM * 84)) + * / CPU_CLK_UNHALTED.THREAD_P + */ + int ret; + struct counters *mem1, *mem2, *mem3; + struct counters *unhalt; + double con1, con2, con3, un, me1, me2, me3, res; + + con1 = 36.0; + con2 = 72.0; + con3 = 84.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem1 = find_counter(cpu, "MEM_LOAD_UOPS_RETIRED.LLC_HIT"); + mem2 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT"); + mem3 = find_counter(cpu, "MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM"); + if (pos != -1) { + me1 = mem1->vals[pos] * 1.0; + me2 = mem2->vals[pos] * 1.0; + me3 = mem3->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me1 = mem1->sum * 1.0; + me2 = mem2->sum * 1.0; + me3 = mem3->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((me1 * con1) + (me2 * con2) + (me3 * con3))/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +cache1(struct counters *cpu, int pos) +{ + /* 9 - (MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS * 180) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, me, res; + + con = 180.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS"); + if (pos != -1) { + me = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (me * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +cache1ib(struct counters *cpu, int pos) +{ + /* 9 - (MEM_LOAD_UOPS_L3_MISS_RETIRED.LCOAL_DRAM * 180) / CPU_CLK_UNHALTED.THREAD_P (thresh >= .2) */ + int ret; + struct counters *mem; + struct counters *unhalt; + double con, un, me, res; + + con = 180.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + mem = find_counter(cpu, "MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM"); + if (pos != -1) { + me = mem->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + me = mem->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (me * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + + +static int +dtlb_missload(struct counters *cpu, int pos) +{ + /* 10 - ((DTLB_LOAD_MISSES.STLB_HIT * 7) + DTLB_LOAD_MISSES.WALK_DURATION) / CPU_CLK_UNHALTED.THREAD_P (t >=.1) */ + int ret; + struct counters *dtlb_m, *dtlb_d; + struct counters *unhalt; + double con, un, d1, d2, res; + + con = 7.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + dtlb_m = find_counter(cpu, "DTLB_LOAD_MISSES.STLB_HIT"); + dtlb_d = find_counter(cpu, "DTLB_LOAD_MISSES.WALK_DURATION"); + if (pos != -1) { + d1 = dtlb_m->vals[pos] * 1.0; + d2 = dtlb_d->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + d1 = dtlb_m->sum * 1.0; + d2 = dtlb_d->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((d1 * con) + d2)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +dtlb_missstore(struct counters *cpu, int pos) +{ + /* + * ((DTLB_STORE_MISSES.STLB_HIT * 7) + DTLB_STORE_MISSES.WALK_DURATION) / + * CPU_CLK_UNHALTED.THREAD_P (t >= .1) + */ + int ret; + struct counters *dtsb_m, *dtsb_d; + struct counters *unhalt; + double con, un, d1, d2, res; + + con = 7.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + dtsb_m = find_counter(cpu, "DTLB_STORE_MISSES.STLB_HIT"); + dtsb_d = find_counter(cpu, "DTLB_STORE_MISSES.WALK_DURATION"); + if (pos != -1) { + d1 = dtsb_m->vals[pos] * 1.0; + d2 = dtsb_d->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + d1 = dtsb_m->sum * 1.0; + d2 = dtsb_d->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((d1 * con) + d2)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +itlb_miss(struct counters *cpu, int pos) +{ + /* ITLB_MISSES.WALK_DURATION / CPU_CLK_UNTHREAD_P IB */ + int ret; + struct counters *itlb; + struct counters *unhalt; + double un, d1, res; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + itlb = find_counter(cpu, "ITLB_MISSES.WALK_DURATION"); + if (pos != -1) { + d1 = itlb->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + d1 = itlb->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = d1/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +icache_miss(struct counters *cpu, int pos) +{ + /* (ICACHE.IFETCH_STALL - ITLB_MISSES.WALK_DURATION) / CPU_CLK_UNHALTED.THREAD_P IB */ + + int ret; + struct counters *itlb, *icache; + struct counters *unhalt; + double un, d1, ic, res; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + itlb = find_counter(cpu, "ITLB_MISSES.WALK_DURATION"); + icache = find_counter(cpu, "ICACHE.IFETCH_STALL"); + if (pos != -1) { + d1 = itlb->vals[pos] * 1.0; + ic = icache->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + d1 = itlb->sum * 1.0; + ic = icache->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (ic-d1)/un; + ret = printf("%1.3f", res); + return(ret); + +} + +static int +icache_miss_has(struct counters *cpu, int pos) +{ + /* (36 * ICACHE.MISSES) / CPU_CLK_UNHALTED.THREAD_P */ + + int ret; + struct counters *icache; + struct counters *unhalt; + double un, con, ic, res; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + icache = find_counter(cpu, "ICACHE.MISSES"); + con = 36.0; + if (pos != -1) { + ic = icache->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ic = icache->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (con * ic)/un; + ret = printf("%1.3f", res); + return(ret); + +} + +static int +lcp_stall(struct counters *cpu, int pos) +{ + /* ILD_STALL.LCP/CPU_CLK_UNHALTED.THREAD_P IB */ + int ret; + struct counters *ild; + struct counters *unhalt; + double un, d1, res; + + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + ild = find_counter(cpu, "ILD_STALL.LCP"); + if (pos != -1) { + d1 = ild->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + d1 = ild->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = d1/un; + ret = printf("%1.3f", res); + return(ret); + +} + + +static int +frontendstall(struct counters *cpu, int pos) +{ + /* 12 - IDQ_UOPS_NOT_DELIVERED.CORE / (CPU_CLK_UNHALTED.THREAD_P * 4) (thresh >= .15) */ + int ret; + struct counters *idq; + struct counters *unhalt; + double con, un, id, res; + + con = 4.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + idq = find_counter(cpu, "IDQ_UOPS_NOT_DELIVERED.CORE"); + if (pos != -1) { + id = idq->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + id = idq->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = id/(un * con); + ret = printf("%1.3f", res); + return(ret); +} + +static int +clears(struct counters *cpu, int pos) +{ + /* 13 - ((MACHINE_CLEARS.MEMORY_ORDERING + MACHINE_CLEARS.SMC + MACHINE_CLEARS.MASKMOV ) * 100 ) + * / CPU_CLK_UNHALTED.THREAD_P (thresh >= .02)*/ + + int ret; + struct counters *clr1, *clr2, *clr3; + struct counters *unhalt; + double con, un, cl1, cl2, cl3, res; + + con = 100.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + clr1 = find_counter(cpu, "MACHINE_CLEARS.MEMORY_ORDERING"); + clr2 = find_counter(cpu, "MACHINE_CLEARS.SMC"); + clr3 = find_counter(cpu, "MACHINE_CLEARS.MASKMOV"); + + if (pos != -1) { + cl1 = clr1->vals[pos] * 1.0; + cl2 = clr2->vals[pos] * 1.0; + cl3 = clr3->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + cl1 = clr1->sum * 1.0; + cl2 = clr2->sum * 1.0; + cl3 = clr3->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ((cl1 + cl2 + cl3) * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +microassist(struct counters *cpu, int pos) +{ + /* 14 - IDQ.MS_CYCLES / CPU_CLK_UNHALTED.THREAD_P (thresh > .05) */ + int ret; + struct counters *idq; + struct counters *unhalt; + double un, id, res, con; + + con = 4.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + idq = find_counter(cpu, "IDQ.MS_UOPS"); + if (pos != -1) { + id = idq->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + id = idq->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = id/(un * con); + ret = printf("%1.3f", res); + return(ret); +} + + +static int +aliasing(struct counters *cpu, int pos) +{ + /* 15 - (LD_BLOCKS_PARTIAL.ADDRESS_ALIAS * 5) / CPU_CLK_UNHALTED.THREAD_P (thresh > .1) */ + int ret; + struct counters *ld; + struct counters *unhalt; + double un, lds, con, res; + + con = 5.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + ld = find_counter(cpu, "LD_BLOCKS_PARTIAL.ADDRESS_ALIAS"); + if (pos != -1) { + lds = ld->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + lds = ld->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (lds * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +fpassists(struct counters *cpu, int pos) +{ + /* 16 - FP_ASSIST.ANY/INST_RETIRED.ANY_P */ + int ret; + struct counters *fp; + struct counters *inst; + double un, fpd, res; + + inst = find_counter(cpu, "INST_RETIRED.ANY_P"); + fp = find_counter(cpu, "FP_ASSIST.ANY"); + if (pos != -1) { + fpd = fp->vals[pos] * 1.0; + un = inst->vals[pos] * 1.0; + } else { + fpd = fp->sum * 1.0; + un = inst->sum * 1.0; + } + res = fpd/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +otherassistavx(struct counters *cpu, int pos) +{ + /* 17 - (OTHER_ASSISTS.AVX_TO_SSE * 75)/CPU_CLK_UNHALTED.THREAD_P thresh .1*/ + int ret; + struct counters *oth; + struct counters *unhalt; + double un, ot, con, res; + + con = 75.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + oth = find_counter(cpu, "OTHER_ASSISTS.AVX_TO_SSE"); + if (pos != -1) { + ot = oth->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ot = oth->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (ot * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +otherassistsse(struct counters *cpu, int pos) +{ + + int ret; + struct counters *oth; + struct counters *unhalt; + double un, ot, con, res; + + /* 18 (OTHER_ASSISTS.SSE_TO_AVX * 75)/CPU_CLK_UNHALTED.THREAD_P thresh .1*/ + con = 75.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + oth = find_counter(cpu, "OTHER_ASSISTS.SSE_TO_AVX"); + if (pos != -1) { + ot = oth->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ot = oth->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = (ot * con)/un; + ret = printf("%1.3f", res); + return(ret); +} + +static int +efficiency1(struct counters *cpu, int pos) +{ + + int ret; + struct counters *uops; + struct counters *unhalt; + double un, ot, con, res; + + /* 19 (UOPS_RETIRED.RETIRE_SLOTS/(4*CPU_CLK_UNHALTED.THREAD_P) look if thresh < .9*/ + con = 4.0; + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + uops = find_counter(cpu, "UOPS_RETIRED.RETIRE_SLOTS"); + if (pos != -1) { + ot = uops->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ot = uops->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = ot/(con * un); + ret = printf("%1.3f", res); + return(ret); +} + +static int +efficiency2(struct counters *cpu, int pos) +{ + + int ret; + struct counters *uops; + struct counters *unhalt; + double un, ot, res; + + /* 20 - CPU_CLK_UNHALTED.THREAD_P/INST_RETIRED.ANY_P good if > 1. (comp factor)*/ + unhalt = find_counter(cpu, "CPU_CLK_UNHALTED.THREAD_P"); + uops = find_counter(cpu, "INST_RETIRED.ANY_P"); + if (pos != -1) { + ot = uops->vals[pos] * 1.0; + un = unhalt->vals[pos] * 1.0; + } else { + ot = uops->sum * 1.0; + un = unhalt->sum * 1.0; + } + res = un/ot; + ret = printf("%1.3f", res); + return(ret); +} + +#define SANDY_BRIDGE_COUNT 20 +static struct cpu_entry sandy_bridge[SANDY_BRIDGE_COUNT] = { +/*01*/ { "allocstall1", "thresh > .05", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s PARTIAL_RAT_STALLS.SLOW_LEA_WINDOW -w 1", + allocstall1 }, +/*02*/ { "allocstall2", "thresh > .05", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s PARTIAL_RAT_STALLS.FLAGS_MERGE_UOP_CYCLES -w 1", + allocstall2 }, +/*03*/ { "br_miss", "thresh >= .2", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -w 1", + br_mispredict }, +/*04*/ { "splitload", "thresh >= .1", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s MEM_UOP_RETIRED.SPLIT_LOADS -w 1", + splitload }, +/*05*/ { "splitstore", "thresh >= .01", + "pmcstat -s MEM_UOP_RETIRED.SPLIT_STORES -s MEM_UOP_RETIRED.ALL_STORES -w 1", + splitstore }, +/*06*/ { "contested", "thresh >= .05", + "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", + contested }, +/*07*/ { "blockstorefwd", "thresh >= .05", + "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", + blockstoreforward }, +/*08*/ { "cache2", "thresh >= .2", + "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", + cache2 }, +/*09*/ { "cache1", "thresh >= .2", + "pmcstat -s MEM_LOAD_UOPS_MISC_RETIRED.LLC_MISS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + cache1 }, +/*10*/ { "dtlbmissload", "thresh >= .1", + "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + dtlb_missload }, +/*11*/ { "dtlbmissstore", "thresh >= .05", + "pmcstat -s DTLB_STORE_MISSES.STLB_HIT -s DTLB_STORE_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + dtlb_missstore }, +/*12*/ { "frontendstall", "thresh >= .15", + "pmcstat -s IDQ_UOPS_NOT_DELIVERED.CORE -s CPU_CLK_UNHALTED.THREAD_P -w 1", + frontendstall }, +/*13*/ { "clears", "thresh >= .02", + "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", + clears }, +/*14*/ { "microassist", "thresh >= .05", + "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", + microassist }, +/*15*/ { "aliasing_4k", "thresh >= .1", + "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + aliasing }, +/*16*/ { "fpassist", "look for a excessive value", + "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", + fpassists }, +/*17*/ { "otherassistavx", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistavx }, +/*18*/ { "otherassistsse", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistsse }, +/*19*/ { "eff1", "thresh < .9", + "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency1 }, +/*20*/ { "eff2", "thresh > 1.0", + "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency2 }, +}; + + +#define IVY_BRIDGE_COUNT 21 +static struct cpu_entry ivy_bridge[IVY_BRIDGE_COUNT] = { +/*1*/ { "eff1", "thresh < .75", + "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency1 }, +/*2*/ { "eff2", "thresh > 1.0", + "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency2 }, +/*3*/ { "itlbmiss", "thresh > .05", + "pmcstat -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + itlb_miss }, +/*4*/ { "icachemiss", "thresh > .05", + "pmcstat -s ICACHE.IFETCH_STALL -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + icache_miss }, +/*5*/ { "lcpstall", "thresh > .05", + "pmcstat -s ILD_STALL.LCP -s CPU_CLK_UNHALTED.THREAD_P -w 1", + lcp_stall }, +/*6*/ { "cache1", "thresh >= .2", + "pmcstat -s MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM -s CPU_CLK_UNHALTED.THREAD_P -w 1", + cache1ib }, +/*7*/ { "cache2", "thresh >= .2", + "pmcstat -s MEM_LOAD_UOPS_RETIRED.LLC_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", + cache2ib }, +/*8*/ { "contested", "thresh >= .05", + "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", + contested }, +/*9*/ { "datashare", "thresh >= .05", + "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", + datasharing }, +/*10*/ { "blockstorefwd", "thresh >= .05", + "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", + blockstoreforward }, +/*11*/ { "splitload", "thresh >= .1", + "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", + splitloadib }, +/*12*/ { "splitstore", "thresh >= .01", + "pmcstat -s MEM_UOP_RETIRED.SPLIT_STORES -s MEM_UOP_RETIRED.ALL_STORES -w 1", + splitstore }, +/*13*/ { "aliasing_4k", "thresh >= .1", + "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + aliasing }, +/*14*/ { "dtlbmissload", "thresh >= .1", + "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + dtlb_missload }, +/*15*/ { "dtlbmissstore", "thresh >= .05", + "pmcstat -s DTLB_STORE_MISSES.STLB_HIT -s DTLB_STORE_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + dtlb_missstore }, +/*16*/ { "br_miss", "thresh >= .2", + "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", + br_mispredictib }, +/*17*/ { "clears", "thresh >= .02", + "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", + clears }, +/*18*/ { "microassist", "thresh >= .05", + "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", + microassist }, +/*19*/ { "fpassist", "look for a excessive value", + "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", + fpassists }, +/*20*/ { "otherassistavx", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistavx }, +/*21*/ { "otherassistsse", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistsse }, +}; + +#define HASWELL_COUNT 20 +static struct cpu_entry haswell[HASWELL_COUNT] = { +/*1*/ { "eff1", "thresh < .75", + "pmcstat -s UOPS_RETIRED.RETIRE_SLOTS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency1 }, +/*2*/ { "eff2", "thresh > 1.0", + "pmcstat -s INST_RETIRED.ANY_P -s CPU_CLK_UNHALTED.THREAD_P -w 1", + efficiency2 }, +/*3*/ { "itlbmiss", "thresh > .05", + "pmcstat -s ITLB_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + itlb_miss }, +/*4*/ { "icachemiss", "thresh > .05", + "pmcstat -s ICACHE.MISSES --s CPU_CLK_UNHALTED.THREAD_P -w 1", + icache_miss_has }, +/*5*/ { "lcpstall", "thresh > .05", + "pmcstat -s ILD_STALL.LCP -s CPU_CLK_UNHALTED.THREAD_P -w 1", + lcp_stall }, +/*6*/ { "cache1", "thresh >= .2", + "pmcstat -s MEM_LOAD_UOPS_LLC_MISS_RETIRED.LOCAL_DRAM -s CPU_CLK_UNHALTED.THREAD_P -w 1", + cache1ib }, +/*7*/ { "cache2", "thresh >= .2", + "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", + cache2has }, +/*8*/ { "contested", "thresh >= .05", + "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HITM -s CPU_CLK_UNHALTED.THREAD_P -w 1", + contested_has }, +/*9*/ { "datashare", "thresh >= .05", + "pmcstat -s MEM_LOAD_UOPS_LLC_HIT_RETIRED.XSNP_HIT -s CPU_CLK_UNHALTED.THREAD_P -w 1", + datasharing_has }, +/*10*/ { "blockstorefwd", "thresh >= .05", + "pmcstat -s LD_BLOCKS_STORE_FORWARD -s CPU_CLK_UNHALTED.THREAD_P -w 1", + blockstoreforward }, +/*11*/ { "splitload", "thresh >= .1", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s MEM_UOP_RETIRED.SPLIT_LOADS -w 1", + splitload }, +/*12*/ { "splitstore", "thresh >= .01", + "pmcstat -s MEM_UOP_RETIRED.SPLIT_STORES -s MEM_UOP_RETIRED.ALL_STORES -w 1", + splitstore }, +/*13*/ { "aliasing_4k", "thresh >= .1", + "pmcstat -s LD_BLOCKS_PARTIAL.ADDRESS_ALIAS -s CPU_CLK_UNHALTED.THREAD_P -w 1", + aliasing }, +/*14*/ { "dtlbmissload", "thresh >= .1", + "pmcstat -s DTLB_LOAD_MISSES.STLB_HIT -s DTLB_LOAD_MISSES.WALK_DURATION -s CPU_CLK_UNHALTED.THREAD_P -w 1", + dtlb_missload }, +/*15*/ { "br_miss", "thresh >= .2", + "pmcstat -s CPU_CLK_UNHALTED.THREAD_P -s BR_MISP_RETIRED.ALL_BRANCHES -w 1", + br_mispredict }, +/*16*/ { "clears", "thresh >= .02", + "pmcstat -s MACHINE_CLEARS.MEMORY_ORDERING -s MACHINE_CLEARS.SMC -s MACHINE_CLEARS.MASKMOV -s CPU_CLK_UNHALTED.THREAD_P -w 1", + clears }, +/*17*/ { "microassist", "thresh >= .05", + "pmcstat -s IDQ.MS_UOPS,cmask=1 -s CPU_CLK_UNHALTED.THREAD_P -w 1", + microassist }, +/*18*/ { "fpassist", "look for a excessive value", + "pmcstat -s FP_ASSIST.ANY -s INST_RETIRED.ANY_P -w 1", + fpassists }, +/*19*/ { "otherassistavx", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.AVX_TO_SSE -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistavx }, +/*20*/ { "otherassistsse", "look for a excessive value", + "pmcstat -s OTHER_ASSISTS.SSE_TO_AVX -s CPU_CLK_UNHALTED.THREAD_P -w 1", + otherassistsse }, +}; + + +static void +set_sandybridge(void) +{ + strcpy(the_cpu.cputype, "SandyBridge PMC"); + the_cpu.number = SANDY_BRIDGE_COUNT; + the_cpu.ents = sandy_bridge; + the_cpu.explain = explain_name_sb; +} + +static void +set_ivybridge(void) +{ + strcpy(the_cpu.cputype, "IvyBridge PMC"); + the_cpu.number = IVY_BRIDGE_COUNT; + the_cpu.ents = ivy_bridge; + the_cpu.explain = explain_name_ib; +} + + +static void +set_haswell(void) +{ + strcpy(the_cpu.cputype, "HASWELL PMC"); + the_cpu.number = HASWELL_COUNT; + the_cpu.ents = haswell; + the_cpu.explain = explain_name_has; +} + +static void +set_expression(char *name) +{ + int found = 0, i; + for(i=0 ; i< the_cpu.number; i++) { + if (strcmp(name, the_cpu.ents[i].name) == 0) { + found = 1; + expression = the_cpu.ents[i].func; + command = the_cpu.ents[i].command; + threshold = the_cpu.ents[i].thresh; + break; + } + } + if (!found) { + printf("For CPU type %s we have no expression:%s\n", + the_cpu.cputype, name); + exit(-1); + } +} + + + + + +static int +validate_expression(char *name) +{ + int i, found; + + found = 0; + for(i=0 ; i< the_cpu.number; i++) { + if (strcmp(name, the_cpu.ents[i].name) == 0) { + found = 1; + break; + } + } + if (!found) { + return(-1); + } + return (0); +} + +static void +do_expression(struct counters *cpu, int pos) +{ + if (expression == NULL) + return; + (*expression)(cpu, pos); +} + +static void +process_header(int idx, char *p) +{ + struct counters *up; + int i, len, nlen; + /* + * Given header element idx, at p in + * form 's/NN/nameof' + * process the entry to pull out the name and + * the CPU number. + */ + if (strncmp(p, "s/", 2)) { + printf("Check -- invalid header no s/ in %s\n", + p); + return; + } + up = &cnts[idx]; + up->cpu = strtol(&p[2], NULL, 10); + len = strlen(p); + for (i=2; i<len; i++) { + if (p[i] == '/') { + nlen = strlen(&p[(i+1)]); + if (nlen < (MAX_NLEN-1)) { + strcpy(up->counter_name, &p[(i+1)]); + } else { + strncpy(up->counter_name, &p[(i+1)], (MAX_NLEN-1)); + } + } + } +} + +static void +build_counters_from_header(FILE *io) +{ + char buffer[8192], *p; + int i, len, cnt; + size_t mlen; + + /* We have a new start, lets + * setup our headers and cpus. + */ + if (fgets(buffer, sizeof(buffer), io) == NULL) { + printf("First line can't be read from file err:%d\n", errno); + return; + } + /* + * Ok output is an array of counters. Once + * we start to read the values in we must + * put them in there slot to match there CPU and + * counter being updated. We create a mass array + * of the counters, filling in the CPU and + * counter name. + */ + /* How many do we get? */ + len = strlen(buffer); + for (i=0, cnt=0; i<len; i++) { + if (strncmp(&buffer[i], "s/", 2) == 0) { + cnt++; + for(;i<len;i++) { + if (buffer[i] == ' ') + break; + } + } + } + mlen = sizeof(struct counters) * cnt; + cnts = malloc(mlen); + ncnts = cnt; + if (cnts == NULL) { + printf("No memory err:%d\n", errno); + return; + } + memset(cnts, 0, mlen); + for (i=0, cnt=0; i<len; i++) { + if (strncmp(&buffer[i], "s/", 2) == 0) { + p = &buffer[i]; + for(;i<len;i++) { + if (buffer[i] == ' ') { + buffer[i] = 0; + break; + } + } + process_header(cnt, p); + cnt++; + } + } + if (verbose) + printf("We have %d entries\n", cnt); +} +extern int max_to_collect; +int max_to_collect = MAX_COUNTER_SLOTS; + +static int +read_a_line(FILE *io) +{ + char buffer[8192], *p, *stop; + int pos, i; + + if (fgets(buffer, sizeof(buffer), io) == NULL) { + return(0); + } + p = buffer; + for (i=0; i<ncnts; i++) { + pos = cnts[i].pos; + cnts[i].vals[pos] = strtol(p, &stop, 0); + cnts[i].pos++; + cnts[i].sum += cnts[i].vals[pos]; + p = stop; + } + return (1); +} + +extern int cpu_count_out; +int cpu_count_out=0; + +static void +print_header(void) +{ + int i, cnt, printed_cnt; + + printf("*********************************\n"); + for(i=0, cnt=0; i<MAX_CPU; i++) { + if (glob_cpu[i]) { + cnt++; + } + } + cpu_count_out = cnt; + for(i=0, printed_cnt=0; i<MAX_CPU; i++) { + if (glob_cpu[i]) { + printf("CPU%d", i); + printed_cnt++; + } + if (printed_cnt == cnt) { + printf("\n"); + break; + } else { + printf("\t"); + } + } +} + +static void +lace_cpus_together(void) +{ + int i, j, lace_cpu; + struct counters *cpat, *at; + + for(i=0; i<ncnts; i++) { + cpat = &cnts[i]; + if (cpat->next_cpu) { + /* Already laced in */ + continue; + } + lace_cpu = cpat->cpu; + if (lace_cpu >= MAX_CPU) { + printf("CPU %d to big\n", lace_cpu); + continue; + } + if (glob_cpu[lace_cpu] == NULL) { + glob_cpu[lace_cpu] = cpat; + } else { + /* Already processed this cpu */ + continue; + } + /* Ok look forward for cpu->cpu and link in */ + for(j=(i+1); j<ncnts; j++) { + at = &cnts[j]; + if (at->next_cpu) { + continue; + } + if (at->cpu == lace_cpu) { + /* Found one */ + cpat->next_cpu = at; + cpat = at; + } + } + } +} + + +static void +process_file(char *filename) +{ + FILE *io; + int i; + int line_at, not_done; + pid_t pid_of_command=0; + + if (filename == NULL) { + io = my_popen(command, "r", &pid_of_command); + } else { + io = fopen(filename, "r"); + if (io == NULL) { + printf("Can't process file %s err:%d\n", + filename, errno); + return; + } + } + build_counters_from_header(io); + if (cnts == NULL) { + /* Nothing we can do */ + printf("Nothing to do -- no counters built\n"); + return; + } + lace_cpus_together(); + print_header(); + if (verbose) { + for (i=0; i<ncnts; i++) { + printf("Counter:%s cpu:%d index:%d\n", + cnts[i].counter_name, + cnts[i].cpu, i); + } + } + line_at = 0; + not_done = 1; + while(not_done) { + if (read_a_line(io)) { + line_at++; + } else { + break; + } + if (line_at >= max_to_collect) { + not_done = 0; + } + if (filename == NULL) { + int cnt; + /* For the ones we dynamically open we print now */ + for(i=0, cnt=0; i<MAX_CPU; i++) { + do_expression(glob_cpu[i], (line_at-1)); + cnt++; + if (cnt == cpu_count_out) { + printf("\n"); + break; + } else { + printf("\t"); + } + } + } + } + if (filename) { + fclose(io); + } else { + my_pclose(io, pid_of_command); + } +} +#if defined(__amd64__) +#define cpuid(in,a,b,c,d)\ + asm("cpuid": "=a" (a), "=b" (b), "=c" (c), "=d" (d) : "a" (in)); +#else +#define cpuid(in, a, b, c, d) +#endif + +static void +get_cpuid_set(void) +{ + unsigned long eax, ebx, ecx, edx; + int model; + pid_t pid_of_command=0; + size_t sz, len; + FILE *io; + char linebuf[1024], *str; + + eax = ebx = ecx = edx = 0; + + cpuid(0, eax, ebx, ecx, edx); + if (ebx == 0x68747541) { + printf("AMD processors are not supported by this program\n"); + printf("Sorry\n"); + exit(0); + } else if (ebx == 0x6972794) { + printf("Cyrix processors are not supported by this program\n"); + printf("Sorry\n"); + exit(0); + } else if (ebx == 0x756e6547) { + printf("Genuine Intel\n"); + } else { + printf("Unknown processor type 0x%lx Only Intel AMD64 types are supported by this routine!\n", ebx); + exit(0); + } + cpuid(1, eax, ebx, ecx, edx); + model = (((eax & 0xF0000) >> 12) | ((eax & 0xF0) >> 4)); + printf("CPU model is 0x%x id:0x%lx\n", model, eax); + switch (eax & 0xF00) { + case 0x500: /* Pentium family processors */ + printf("Intel Pentium P5\n"); + goto not_supported; + break; + case 0x600: /* Pentium Pro, Celeron, Pentium II & III */ + switch (model) { + case 0x1: + printf("Intel Pentium P6\n"); + goto not_supported; + break; + case 0x3: + case 0x5: + printf("Intel PII\n"); + goto not_supported; + break; + case 0x6: case 0x16: + printf("Intel CL\n"); + goto not_supported; + break; + case 0x7: case 0x8: case 0xA: case 0xB: + printf("Intel PIII\n"); + goto not_supported; + break; + case 0x9: case 0xD: + printf("Intel PM\n"); + goto not_supported; + break; + case 0xE: + printf("Intel CORE\n"); + goto not_supported; + break; + case 0xF: + printf("Intel CORE2\n"); + goto not_supported; + break; + case 0x17: + printf("Intel CORE2EXTREME\n"); + goto not_supported; + break; + case 0x1C: /* Per Intel document 320047-002. */ + printf("Intel ATOM\n"); + goto not_supported; + break; + case 0x1A: + case 0x1E: /* + * Per Intel document 253669-032 9/2009, + * pages A-2 and A-57 + */ + case 0x1F: /* + * Per Intel document 253669-032 9/2009, + * pages A-2 and A-57 + */ + printf("Intel COREI7\n"); + goto not_supported; + break; + case 0x2E: + printf("Intel NEHALEM\n"); + goto not_supported; + break; + case 0x25: /* Per Intel document 253669-033US 12/2009. */ + case 0x2C: /* Per Intel document 253669-033US 12/2009. */ + printf("Intel WESTMERE\n"); + goto not_supported; + break; + case 0x2F: /* Westmere-EX, seen in wild */ + printf("Intel WESTMERE\n"); + goto not_supported; + break; + case 0x2A: /* Per Intel document 253669-039US 05/2011. */ + printf("Intel SANDYBRIDGE\n"); + set_sandybridge(); + break; + case 0x2D: /* Per Intel document 253669-044US 08/2012. */ + printf("Intel SANDYBRIDGE_XEON\n"); + set_sandybridge(); + break; + case 0x3A: /* Per Intel document 253669-043US 05/2012. */ + printf("Intel IVYBRIDGE\n"); + set_ivybridge(); + break; + case 0x3E: /* Per Intel document 325462-045US 01/2013. */ + printf("Intel IVYBRIDGE_XEON\n"); + set_ivybridge(); + break; + case 0x3F: /* Per Intel document 325462-045US 09/2014. */ + printf("Intel HASWELL (Xeon)\n"); + set_haswell(); + break; + case 0x3C: /* Per Intel document 325462-045US 01/2013. */ + case 0x45: + case 0x46: + printf("Intel HASWELL\n"); + set_haswell(); + break; + case 0x4D: + /* Per Intel document 330061-001 01/2014. */ + printf("Intel ATOM_SILVERMONT\n"); + goto not_supported; + break; + default: + printf("Intel model 0x%x is not known -- sorry\n", + model); + goto not_supported; + break; + } + break; + case 0xF00: /* P4 */ + printf("Intel unknown model %d\n", model); + goto not_supported; + break; + } + /* Ok lets load the list of all known PMC's */ + io = my_popen("/usr/sbin/pmccontrol -L", "r", &pid_of_command); + if (valid_pmcs == NULL) { + /* Likely */ + pmc_allocated_cnt = PMC_INITIAL_ALLOC; + sz = sizeof(char *) * pmc_allocated_cnt; + valid_pmcs = malloc(sz); + if (valid_pmcs == NULL) { + printf("No memory allocation fails at startup?\n"); + exit(-1); + } + memset(valid_pmcs, 0, sz); + } + + while (fgets(linebuf, sizeof(linebuf), io) != NULL) { + if (linebuf[0] != '\t') { + /* sometimes headers ;-) */ + continue; + } + len = strlen(linebuf); + if (linebuf[(len-1)] == '\n') { + /* Likely */ + linebuf[(len-1)] = 0; + } + str = &linebuf[1]; + len = strlen(str) + 1; + valid_pmcs[valid_pmc_cnt] = malloc(len); + if (valid_pmcs[valid_pmc_cnt] == NULL) { + printf("No memory2 allocation fails at startup?\n"); + exit(-1); + } + memset(valid_pmcs[valid_pmc_cnt], 0, len); + strcpy(valid_pmcs[valid_pmc_cnt], str); + valid_pmc_cnt++; + if (valid_pmc_cnt >= pmc_allocated_cnt) { + /* Got to expand -- unlikely */ + char **more; + + sz = sizeof(char *) * (pmc_allocated_cnt * 2); + more = malloc(sz); + if (more == NULL) { + printf("No memory3 allocation fails at startup?\n"); + exit(-1); + } + memset(more, sz, 0); + memcpy(more, valid_pmcs, sz); + pmc_allocated_cnt *= 2; + free(valid_pmcs); + valid_pmcs = more; + } + } + my_pclose(io, pid_of_command); + return; +not_supported: + printf("Not supported\n"); + exit(-1); +} + +static void +explain_all(void) +{ + int i; + printf("For CPU's of type %s the following expressions are available:\n",the_cpu.cputype); + printf("-------------------------------------------------------------\n"); + for(i=0; i<the_cpu.number; i++){ + printf("For -e %s ", the_cpu.ents[i].name); + (*the_cpu.explain)(the_cpu.ents[i].name); + printf("----------------------------\n"); + } +} + +static void +test_for_a_pmc(const char *pmc, int out_so_far) +{ + FILE *io; + pid_t pid_of_command=0; + char my_command[1024]; + char line[1024]; + char resp[1024]; + int len, llen, i; + + if (out_so_far < 50) { + len = 50 - out_so_far; + for(i=0; i<len; i++) { + printf(" "); + } + } + sprintf(my_command, "/usr/sbin/pmcstat -w .25 -c 0 -s %s", pmc); + io = my_popen(my_command, "r", &pid_of_command); + if (io == NULL) { + printf("Failed -- popen fails\n"); + return; + } + /* Setup what we expect */ + len = sprintf(resp, "%s", pmc); + if (fgets(line, sizeof(line), io) == NULL) { + printf("Failed -- no output from pmstat\n"); + goto out; + } + llen = strlen(line); + if (line[(llen-1)] == '\n') { + line[(llen-1)] = 0; + llen--; + } + for(i=2; i<(llen-len); i++) { + if (strncmp(&line[i], "ERROR", 5) == 0) { + printf("Failed %s\n", line); + goto out; + } else if (strncmp(&line[i], resp, len) == 0) { + int j, k; + + if (fgets(line, sizeof(line), io) == NULL) { + printf("Failed -- no second output from pmstat\n"); + goto out; + } + len = strlen(line); + for (j=0; j<len; j++) { + if (line[j] == ' ') { + j++; + } else { + break; + } + } + printf("Pass"); + len = strlen(&line[j]); + if (len < 20) { + for(k=0; k<(20-len); k++) { + printf(" "); + } + } + printf("%s", &line[j]); + goto out; + } + } + printf("Failed -- '%s' not '%s'\n", line, resp); +out: + my_pclose(io, pid_of_command); + +} + +static int +add_it_to(char **vars, int cur_cnt, char *name) +{ + int i; + size_t len; + for(i=0; i<cur_cnt; i++) { + if (strcmp(vars[i], name) == 0) { + /* Already have */ + return(0); + } + } + if (vars[cur_cnt] != NULL) { + printf("Cur_cnt:%d filled with %s??\n", + cur_cnt, vars[cur_cnt]); + exit(-1); + } + /* Ok its new */ + len = strlen(name) + 1; + vars[cur_cnt] = malloc(len); + if (vars[cur_cnt] == NULL) { + printf("No memory %s\n", __FUNCTION__); + exit(-1); + } + memset(vars[cur_cnt], 0, len); + strcpy(vars[cur_cnt], name); + return(1); +} + +static char * +build_command_for_exp(struct expression *exp) +{ + /* + * Build the pmcstat command to handle + * the passed in expression. + * /usr/sbin/pmcstat -w 1 -s NNN -s QQQ + * where NNN and QQQ represent the PMC's in the expression + * uniquely.. + */ + char forming[1024]; + int cnt_pmc, alloced_pmcs, i; + struct expression *at; + char **vars, *cmd; + size_t mal; + + alloced_pmcs = cnt_pmc = 0; + /* first how many do we have */ + at = exp; + while (at) { + if (at->type == TYPE_VALUE_PMC) { + cnt_pmc++; + } + at = at->next; + } + if (cnt_pmc == 0) { + printf("No PMC's in your expression -- nothing to do!!\n"); + exit(0); + } + mal = cnt_pmc * sizeof(char *); + vars = malloc(mal); + if (vars == NULL) { + printf("No memory\n"); + exit(-1); + } + memset(vars, 0, mal); + at = exp; + while (at) { + if (at->type == TYPE_VALUE_PMC) { + if(add_it_to(vars, alloced_pmcs, at->name)) { + alloced_pmcs++; + } + } + at = at->next; + } + /* Now we have a unique list in vars so create our command */ + mal = 23; /* "/usr/sbin/pmcstat -w 1" + \0 */ + for(i=0; i<alloced_pmcs; i++) { + mal += strlen(vars[i]) + 4; /* var + " -s " */ + } + cmd = malloc((mal+2)); + if (cmd == NULL) { + printf("%s out of mem\n", __FUNCTION__); + exit(-1); + } + memset(cmd, 0, (mal+2)); + strcpy(cmd, "/usr/sbin/pmcstat -w 1"); + at = exp; + for(i=0; i<alloced_pmcs; i++) { + sprintf(forming, " -s %s", vars[i]); + strcat(cmd, forming); + free(vars[i]); + vars[i] = NULL; + } + free(vars); + return(cmd); +} + +static int +user_expr(struct counters *cpu, int pos) +{ + int ret; + double res; + struct counters *var; + struct expression *at; + + at = master_exp; + while (at) { + if (at->type == TYPE_VALUE_PMC) { + var = find_counter(cpu, at->name); + if (var == NULL) { + printf("%s:Can't find counter %s?\n", __FUNCTION__, at->name); + exit(-1); + } + if (pos != -1) { + at->value = var->vals[pos] * 1.0; + } else { + at->value = var->sum * 1.0; + } + } + at = at->next; + } + res = run_expr(master_exp, 1, NULL); + ret = printf("%1.3f", res); + return(ret); +} + + +static void +set_manual_exp(struct expression *exp) +{ + expression = user_expr; + command = build_command_for_exp(exp); + threshold = "User defined threshold"; +} + +static void +run_tests(void) +{ + int i, lenout; + printf("Running tests on %d PMC's this may take some time\n", valid_pmc_cnt); + printf("------------------------------------------------------------------------\n"); + for(i=0; i<valid_pmc_cnt; i++) { + lenout = printf("%s", valid_pmcs[i]); + fflush(stdout); + test_for_a_pmc(valid_pmcs[i], lenout); + } +} +static void +list_all(void) +{ + int i, cnt, j; + printf("PMC Abbreviation\n"); + printf("--------------------------------------------------------------\n"); + for(i=0; i<valid_pmc_cnt; i++) { + cnt = printf("%s", valid_pmcs[i]); + for(j=cnt; j<52; j++) { + printf(" "); + } + printf("%%%d\n", i); + } +} + + +int +main(int argc, char **argv) +{ + int i, j, cnt; + char *filename=NULL; + char *name=NULL; + int help_only = 0; + int test_mode = 0; + + get_cpuid_set(); + memset(glob_cpu, 0, sizeof(glob_cpu)); + while ((i = getopt(argc, argv, "LHhvm:i:?e:TE:")) != -1) { + switch (i) { + case 'L': + list_all(); + return(0); + case 'H': + printf("**********************************\n"); + explain_all(); + printf("**********************************\n"); + return(0); + break; + case 'T': + test_mode = 1; + break; + case 'E': + master_exp = parse_expression(optarg); + if (master_exp) { + set_manual_exp(master_exp); + } + break; + case 'e': + if (validate_expression(optarg)) { + printf("Unknown expression %s\n", optarg); + return(0); + } + name = optarg; + set_expression(optarg); + break; + case 'm': + max_to_collect = strtol(optarg, NULL, 0); + if (max_to_collect > MAX_COUNTER_SLOTS) { + /* You can't collect more than max in array */ + max_to_collect = MAX_COUNTER_SLOTS; + } + break; + case 'v': + verbose++; + break; + case 'h': + help_only = 1; + break; + case 'i': + filename = optarg; + break; + case '?': + default: + use: + printf("Use %s [ -i inputfile -v -m max_to_collect -e expr -E -h -? -H]\n", + argv[0]); + printf("-i inputfile -- use source as inputfile not stdin (if stdin collect)\n"); + printf("-v -- verbose dump debug type things -- you don't want this\n"); + printf("-m N -- maximum to collect is N measurments\n"); + printf("-e expr-name -- Do expression expr-name\n"); + printf("-E 'your expression' -- Do your expression\n"); + printf("-h -- Don't do the expression I put in -e xxx just explain what it does and exit\n"); + printf("-H -- Don't run anything, just explain all canned expressions\n"); + printf("-T -- Test all PMC's defined by this processor\n"); + return(0); + break; + }; + } + if ((name == NULL) && (filename == NULL) && (test_mode == 0) && (master_exp == NULL)) { + printf("Without setting an expression we cannot dynamically gather information\n"); + printf("you must supply a filename (and you probably want verbosity)\n"); + goto use; + } + if (test_mode) { + run_tests(); + return(0); + } + printf("*********************************\n"); + if (master_exp == NULL) { + (*the_cpu.explain)(name); + } else { + printf("Examine your expression "); + print_exp(master_exp); + printf("User defined threshold\n"); + } + if (help_only) { + return(0); + } + process_file(filename); + if (verbose >= 2) { + for (i=0; i<ncnts; i++) { + printf("Counter:%s cpu:%d index:%d\n", + cnts[i].counter_name, + cnts[i].cpu, i); + for(j=0; j<cnts[i].pos; j++) { + printf(" val - %ld\n", (long int)cnts[i].vals[j]); + } + printf(" sum - %ld\n", (long int)cnts[i].sum); + } + } + if (expression == NULL) { + return(0); + } + for(i=0, cnt=0; i<MAX_CPU; i++) { + if (glob_cpu[i]) { + do_expression(glob_cpu[i], -1); + cnt++; + if (cnt == cpu_count_out) { + printf("\n"); + break; + } else { + printf("\t"); + } + } + } + return(0); +} |