#include <vnet/vnet.h>
#include <vnet/plugin/plugin.h>
#include <perfmon/perfmon.h>
+#include <perfmon/perfmon_intel.h>
#include <vlibapi/api.h>
#include <vlibmemory/api.h>
perfmon_main_t perfmon_main;
-static char *perfmon_json_path = "/usr/share/vpp/plugins/perfmon";
-
-static void
-set_perfmon_json_path ()
+void
+perfmon_register_intel_pmc (perfmon_intel_pmc_cpu_model_t * m, int n_models,
+ perfmon_intel_pmc_event_t * e, int n_events)
{
- char *p, path[PATH_MAX];
- int rv;
- u8 *s;
-
- /* find executable path */
- if ((rv = readlink ("/proc/self/exe", path, PATH_MAX - 1)) == -1)
- return;
-
- /* readlink doesn't provide null termination */
- path[rv] = 0;
-
- /* strip filename */
- if ((p = strrchr (path, '/')) == 0)
- return;
- *p = 0;
-
- /* strip bin/ */
- if ((p = strrchr (path, '/')) == 0)
- return;
- *p = 0;
-
- /* cons up the .json file path */
- s = format (0, "%s/share/vpp/plugins/perfmon", path);
- vec_add1 (s, 0);
- perfmon_json_path = (char *) s;
-}
+ perfmon_main_t *pm = &perfmon_main;
+ perfmon_intel_pmc_registration_t r;
-#define foreach_cpuid_table \
-_(0x0306C3, haswell_core_v28.json) \
-_(0x0306F2, haswell_core_v28.json) \
-_(0x0406E3, skylake_core_v42.json) \
-_(0x0506E3, skylake_core_v42.json)
+ r.events = e;
+ r.models = m;
+ r.n_events = n_events;
+ r.n_models = n_models;
+
+ vec_add1 (pm->perfmon_tables, r);
+}
static inline u32
get_cpuid (void)
#endif
}
+static int
+perfmon_cpu_model_matches (perfmon_intel_pmc_cpu_model_t * mt,
+ u32 n_models, u8 model, u8 stepping)
+{
+ u32 i;
+ for (i = 0; i < n_models; i++)
+ {
+ if (mt[i].model != model)
+ continue;
+
+ if (mt[i].has_stepping)
+ {
+ if (mt[i].stepping != stepping)
+ continue;
+ }
+
+ return 1;
+ }
+ return 0;
+}
+
+static perfmon_intel_pmc_event_t *
+perfmon_find_table_by_model_stepping (perfmon_main_t * pm,
+ u8 model, u8 stepping)
+{
+ perfmon_intel_pmc_registration_t *rt;
+
+ vec_foreach (rt, pm->perfmon_tables)
+ {
+ if (perfmon_cpu_model_matches (rt->models, rt->n_models, model, stepping))
+ return rt->events;
+ }
+ return 0;
+}
+
static clib_error_t *
perfmon_init (vlib_main_t * vm)
{
perfmon_main_t *pm = &perfmon_main;
clib_error_t *error = 0;
u32 cpuid;
- uword *ht;
- int found_a_table = 0;
+ u8 model, stepping;
+ perfmon_intel_pmc_event_t *ev;
pm->vlib_main = vm;
pm->vnet_main = vnet_get_main ();
pm->log_class = vlib_log_register_class ("perfmon", 0);
/* Default data collection interval */
- pm->timeout_interval = 3.0;
- vec_validate (pm->pm_fds, vec_len (vlib_mains) - 1);
- vec_validate (pm->perf_event_pages, vec_len (vlib_mains) - 1);
- vec_validate (pm->rdpmc_indices, vec_len (vlib_mains) - 1);
+ pm->timeout_interval = 2.0; /* seconds */
+ vec_validate (pm->pm_fds, 1);
+ vec_validate (pm->perf_event_pages, 1);
+ vec_validate (pm->rdpmc_indices, 1);
pm->page_size = getpagesize ();
- ht = pm->perfmon_table = 0;
-
- set_perfmon_json_path ();
+ pm->perfmon_table = 0;
+ pm->pmc_event_by_name = 0;
cpuid = get_cpuid ();
+ model = ((cpuid >> 12) & 0xf0) | ((cpuid >> 4) & 0xf);
+ stepping = cpuid & 0xf;
+
+ pm->perfmon_table = perfmon_find_table_by_model_stepping (pm,
+ model, stepping);
- if (0)
+ if (pm->perfmon_table == 0)
{
+ vlib_log_err (pm->log_class, "No table for cpuid %x", cpuid);
+ vlib_log_err (pm->log_class, " model %x, stepping %x",
+ model, stepping);
}
-#define _(id,table) \
- else if (cpuid == id) \
- { \
- vlib_log_debug (pm->log_class, "Found table %s", #table); \
- ht = perfmon_parse_table (pm, perfmon_json_path, #table); \
- found_a_table = 1; \
- }
- foreach_cpuid_table;
-#undef _
-
- pm->perfmon_table = ht;
+ else
+ {
+ pm->pmc_event_by_name = hash_create_string (0, sizeof (u32));
+ ev = pm->perfmon_table;
- if (found_a_table == 0)
- vlib_log_err (pm->log_class, "No table for cpuid %x", cpuid);
+ for (; ev->event_name; ev++)
+ {
+ hash_set_mem (pm->pmc_event_by_name, ev->event_name,
+ ev - pm->perfmon_table);
+ }
+ }
return error;
}
VLIB_PLUGIN_REGISTER () =
{
.version = VPP_BUILD_VER,
- .description = "Performance monitor plugin",
+ .description = "Performance Monitor",
#if !defined(__x86_64__)
.default_disabled = 1,
#endif
};
/* *INDENT-ON* */
-static uword
-atox (u8 * s)
-{
- uword rv = 0;
-
- while (*s)
- {
- if (*s >= '0' && *s <= '9')
- rv = (rv << 4) | (*s - '0');
- else if (*s >= 'a' && *s <= 'f')
- rv = (rv << 4) | (*s - 'a' + 10);
- else if (*s >= 'A' && *s <= 'A')
- rv = (rv << 4) | (*s - 'A' + 10);
- else if (*s == 'x')
- ;
- else
- break;
- s++;
- }
- return rv;
-}
-
static uword
unformat_processor_event (unformat_input_t * input, va_list * args)
{
perfmon_main_t *pm = va_arg (*args, perfmon_main_t *);
perfmon_event_config_t *ep = va_arg (*args, perfmon_event_config_t *);
u8 *s = 0;
- name_value_pair_t **nvps, *nvp;
hash_pair_t *hp;
- int i;
- int set_values = 0;
+ u32 idx;
u32 pe_config = 0;
- if (pm->perfmon_table == 0)
+ if (pm->perfmon_table == 0 || pm->pmc_event_by_name == 0)
return 0;
if (!unformat (input, "%s", &s))
return 0;
- hp = hash_get_pair_mem (pm->perfmon_table, s);
+ hp = hash_get_pair_mem (pm->pmc_event_by_name, s);
vec_free (s);
if (hp == 0)
return 0;
- nvps = (name_value_pair_t **) (hp->value[0]);
-
- for (i = 0; i < vec_len (nvps); i++)
- {
- nvp = nvps[i];
- if (!strncmp ((char *) nvp->name, "EventCode", 9))
- {
- pe_config |= atox (nvp->value);
- set_values++;
- }
- else if (!strncmp ((char *) nvp->name, "UMask", 5))
- {
- pe_config |= (atox (nvp->value) << 8);
- set_values++;
- }
- if (set_values == 2)
- break;
- }
+ idx = (u32) (hp->value[0]);
- if (set_values != 2)
- {
- clib_warning ("BUG: only found %d values", set_values);
- return 0;
- }
+ pe_config |= pm->perfmon_table[idx].event_code[0];
+ pe_config |= pm->perfmon_table[idx].umask << 8;
ep->name = (char *) hp->key;
ep->pe_type = PERF_TYPE_RAW;
unformat_input_t * input, vlib_cli_command_t * cmd)
{
perfmon_main_t *pm = &perfmon_main;
+ vlib_thread_main_t *vtm = vlib_get_thread_main ();
+ int num_threads = 1 + vtm->n_threads;
unformat_input_t _line_input, *line_input = &_line_input;
perfmon_event_config_t ec;
+ f64 delay;
u32 timeout_seconds;
u32 deadman;
+ int last_set;
+ clib_error_t *error;
- vec_reset_length (pm->events_to_collect);
+ vec_reset_length (pm->single_events_to_collect);
+ vec_reset_length (pm->paired_events_to_collect);
pm->ipc_event_index = ~0;
pm->mispredict_event_index = ~0;
if (!unformat_user (input, unformat_line_input, line_input))
return clib_error_return (0, "counter names required...");
+ clib_bitmap_zero (pm->thread_bitmap);
+
while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (line_input, "timeout %u", &timeout_seconds))
ec.name = "instructions";
ec.pe_type = PERF_TYPE_HARDWARE;
ec.pe_config = PERF_COUNT_HW_INSTRUCTIONS;
- pm->ipc_event_index = vec_len (pm->events_to_collect);
- vec_add1 (pm->events_to_collect, ec);
+ pm->ipc_event_index = vec_len (pm->paired_events_to_collect);
+ vec_add1 (pm->paired_events_to_collect, ec);
ec.name = "cpu-cycles";
ec.pe_type = PERF_TYPE_HARDWARE;
ec.pe_config = PERF_COUNT_HW_CPU_CYCLES;
- vec_add1 (pm->events_to_collect, ec);
+ vec_add1 (pm->paired_events_to_collect, ec);
}
else if (unformat (line_input, "branch-mispredict-rate"))
{
ec.name = "branch-misses";
ec.pe_type = PERF_TYPE_HARDWARE;
ec.pe_config = PERF_COUNT_HW_BRANCH_MISSES;
- pm->mispredict_event_index = vec_len (pm->events_to_collect);
- vec_add1 (pm->events_to_collect, ec);
+ pm->mispredict_event_index = vec_len (pm->paired_events_to_collect);
+ vec_add1 (pm->paired_events_to_collect, ec);
ec.name = "branches";
ec.pe_type = PERF_TYPE_HARDWARE;
ec.pe_config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS;
- vec_add1 (pm->events_to_collect, ec);
+ vec_add1 (pm->paired_events_to_collect, ec);
}
+ else if (unformat (line_input, "threads %U",
+ unformat_bitmap_list, &pm->thread_bitmap))
+ ;
+ else if (unformat (line_input, "thread %U",
+ unformat_bitmap_list, &pm->thread_bitmap))
+ ;
else if (unformat (line_input, "%U", unformat_processor_event, pm, &ec))
{
- vec_add1 (pm->events_to_collect, ec);
+ vec_add1 (pm->single_events_to_collect, ec);
}
#define _(type,event,str) \
else if (unformat (line_input, str)) \
ec.name = str; \
ec.pe_type = type; \
ec.pe_config = event; \
- vec_add1 (pm->events_to_collect, ec); \
+ vec_add1 (pm->single_events_to_collect, ec); \
}
foreach_perfmon_event
#undef _
else
- return clib_error_return (0, "unknown input '%U'",
- format_unformat_error, line_input);
+ {
+ error = clib_error_return (0, "unknown input '%U'",
+ format_unformat_error, line_input);
+ unformat_free (line_input);
+ return error;
+ }
}
- if (vec_len (pm->events_to_collect) == 0)
+ unformat_free (line_input);
+
+ last_set = clib_bitmap_last_set (pm->thread_bitmap);
+ if (last_set != ~0 && last_set >= num_threads)
+ return clib_error_return (0, "thread %d does not exist", last_set);
+
+ /* Stick paired events at the front of the (unified) list */
+ if (vec_len (pm->paired_events_to_collect) > 0)
+ {
+ perfmon_event_config_t *tmp;
+ /* first 2n events are pairs... */
+ vec_append (pm->paired_events_to_collect, pm->single_events_to_collect);
+ tmp = pm->single_events_to_collect;
+ pm->single_events_to_collect = pm->paired_events_to_collect;
+ pm->paired_events_to_collect = tmp;
+ }
+
+ if (vec_len (pm->single_events_to_collect) == 0)
return clib_error_return (0, "no events specified...");
+ /* Figure out how long data collection will take */
+ delay =
+ ((f64) vec_len (pm->single_events_to_collect)) * pm->timeout_interval;
+ delay /= 2.0; /* collect 2 stats at once */
+
vlib_cli_output (vm, "Start collection for %d events, wait %.2f seconds",
- vec_len (pm->events_to_collect),
- (f64) (vec_len (pm->events_to_collect))
- * pm->timeout_interval);
+ vec_len (pm->single_events_to_collect), delay);
vlib_process_signal_event (pm->vlib_main, perfmon_periodic_node.index,
PERFMON_START, 0);
/* Coarse-grained wait */
- vlib_process_suspend (vm,
- ((f64) (vec_len (pm->events_to_collect)
- * pm->timeout_interval)));
+ vlib_process_suspend (vm, delay);
deadman = 0;
/* Reasonable to guess that collection may not be quite done... */
VLIB_CLI_COMMAND (set_pmc_command, static) =
{
.path = "set pmc",
- .short_help = "set pmc c1 [..., use \"show pmc events\"]",
+ .short_help = "set pmc [threads n,n1-n2] c1... [see \"show pmc events\"]",
.function = set_pmc_command_fn,
.is_mp_safe = 1,
};
if (i == pm->ipc_event_index)
{
f64 ipc_rate;
- ASSERT (i + 1 < vec_len (c->counter_names));
+ ASSERT ((i + 1) < vec_len (c->counter_names));
if (c->counter_values[i + 1] > 0)
ipc_rate = (f64) c->counter_values[i]
typedef struct
{
u8 *name;
- name_value_pair_t **nvps;
+ u32 index;
} sort_nvp_t;
static int
return strcmp ((char *) nvp1->name, (char *) nvp2->name);
}
+static u8 *
+format_pmc_event (u8 * s, va_list * args)
+{
+ perfmon_intel_pmc_event_t *ev = va_arg (*args, perfmon_intel_pmc_event_t *);
+
+ s = format (s, "%s\n", ev->event_name);
+ s = format (s, " umask: 0x%x\n", ev->umask);
+ s = format (s, " code: 0x%x", ev->event_code[0]);
+
+ if (ev->event_code[1])
+ s = format (s, " , 0x%x\n", ev->event_code[1]);
+ else
+ s = format (s, "\n");
+
+ return s;
+}
+
static u8 *
format_processor_events (u8 * s, va_list * args)
{
perfmon_main_t *pm = va_arg (*args, perfmon_main_t *);
int verbose = va_arg (*args, int);
- int i, j;
sort_nvp_t *sort_nvps = 0;
sort_nvp_t *sn;
u8 *key;
- name_value_pair_t **value;
+ u32 value;
/* *INDENT-OFF* */
- hash_foreach_mem (key, value, pm->perfmon_table,
+ hash_foreach_mem (key, value, pm->pmc_event_by_name,
({
vec_add2 (sort_nvps, sn, 1);
sn->name = key;
- sn->nvps = value;
+ sn->index = value;
}));
vec_sort_with_function (sort_nvps, sort_nvps_by_name);
if (verbose == 0)
{
- for (i = 0; i < vec_len (sort_nvps); i++)
- s = format (s, "\n %s ", sort_nvps[i].name);
+ vec_foreach (sn, sort_nvps)
+ s = format (s, "\n %s ", sn->name);
}
else
{
- for (i = 0; i < vec_len (sort_nvps); i++)
- {
- name_value_pair_t **nvps;
- s = format (s, "\n %s:", sort_nvps[i].name);
-
- nvps = sort_nvps[i].nvps;
-
- for (j = 0; j < vec_len (nvps); j++)
- s = format (s, "\n %s = %s", nvps[j]->name, nvps[j]->value);
- }
+ vec_foreach (sn, sort_nvps)
+ s = format(s, "%U", format_pmc_event, &pm->perfmon_table[sn->index]);
}
vec_free (sort_nvps);
return s;