mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-13 22:25:03 +00:00
1706623e94
Avoid compiler warning about format %llu that expects long long unsigned
int but argument has type __u64.
Reported-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Fixes: c3afd6e50f
("perf dlfilter: Add dlfilter-show-cycles")
Signed-off-by: Adrian Hunter <adrian.hunter@intel.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Namhyung Kim <namhyung@kernel.org>
Link: https://lore.kernel.org/r/20220905074735.4513-1-adrian.hunter@intel.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
144 lines
2.9 KiB
C
144 lines
2.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* dlfilter-show-cycles.c: Print the number of cycles at the start of each line
|
|
* Copyright (c) 2021, Intel Corporation.
|
|
*/
|
|
#include <perf/perf_dlfilter.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#define MAX_CPU 4096
|
|
|
|
enum {
|
|
INSTR_CYC,
|
|
BRNCH_CYC,
|
|
OTHER_CYC,
|
|
MAX_ENTRY
|
|
};
|
|
|
|
static __u64 cycles[MAX_CPU][MAX_ENTRY];
|
|
static __u64 cycles_rpt[MAX_CPU][MAX_ENTRY];
|
|
|
|
#define BITS 16
|
|
#define TABLESZ (1 << BITS)
|
|
#define TABLEMAX (TABLESZ / 2)
|
|
#define MASK (TABLESZ - 1)
|
|
|
|
static struct entry {
|
|
__u32 used;
|
|
__s32 tid;
|
|
__u64 cycles[MAX_ENTRY];
|
|
__u64 cycles_rpt[MAX_ENTRY];
|
|
} table[TABLESZ];
|
|
|
|
static int tid_cnt;
|
|
|
|
static int event_entry(const char *event)
|
|
{
|
|
if (!event)
|
|
return OTHER_CYC;
|
|
if (!strncmp(event, "instructions", 12))
|
|
return INSTR_CYC;
|
|
if (!strncmp(event, "branches", 8))
|
|
return BRNCH_CYC;
|
|
return OTHER_CYC;
|
|
}
|
|
|
|
static struct entry *find_entry(__s32 tid)
|
|
{
|
|
__u32 pos = tid & MASK;
|
|
struct entry *e;
|
|
|
|
e = &table[pos];
|
|
while (e->used) {
|
|
if (e->tid == tid)
|
|
return e;
|
|
if (++pos == TABLESZ)
|
|
pos = 0;
|
|
e = &table[pos];
|
|
}
|
|
|
|
if (tid_cnt >= TABLEMAX) {
|
|
fprintf(stderr, "Too many threads\n");
|
|
return NULL;
|
|
}
|
|
|
|
tid_cnt += 1;
|
|
e->used = 1;
|
|
e->tid = tid;
|
|
return e;
|
|
}
|
|
|
|
static void add_entry(__s32 tid, int pos, __u64 cnt)
|
|
{
|
|
struct entry *e = find_entry(tid);
|
|
|
|
if (e)
|
|
e->cycles[pos] += cnt;
|
|
}
|
|
|
|
int filter_event_early(void *data, const struct perf_dlfilter_sample *sample, void *ctx)
|
|
{
|
|
__s32 cpu = sample->cpu;
|
|
__s32 tid = sample->tid;
|
|
int pos;
|
|
|
|
if (!sample->cyc_cnt)
|
|
return 0;
|
|
|
|
pos = event_entry(sample->event);
|
|
|
|
if (cpu >= 0 && cpu < MAX_CPU)
|
|
cycles[cpu][pos] += sample->cyc_cnt;
|
|
else if (tid != -1)
|
|
add_entry(tid, pos, sample->cyc_cnt);
|
|
return 0;
|
|
}
|
|
|
|
static void print_vals(__u64 cycles, __u64 delta)
|
|
{
|
|
if (delta)
|
|
printf("%10llu %10llu ", (unsigned long long)cycles, (unsigned long long)delta);
|
|
else
|
|
printf("%10llu %10s ", (unsigned long long)cycles, "");
|
|
}
|
|
|
|
int filter_event(void *data, const struct perf_dlfilter_sample *sample, void *ctx)
|
|
{
|
|
__s32 cpu = sample->cpu;
|
|
__s32 tid = sample->tid;
|
|
int pos;
|
|
|
|
pos = event_entry(sample->event);
|
|
|
|
if (cpu >= 0 && cpu < MAX_CPU) {
|
|
print_vals(cycles[cpu][pos], cycles[cpu][pos] - cycles_rpt[cpu][pos]);
|
|
cycles_rpt[cpu][pos] = cycles[cpu][pos];
|
|
return 0;
|
|
}
|
|
|
|
if (tid != -1) {
|
|
struct entry *e = find_entry(tid);
|
|
|
|
if (e) {
|
|
print_vals(e->cycles[pos], e->cycles[pos] - e->cycles_rpt[pos]);
|
|
e->cycles_rpt[pos] = e->cycles[pos];
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
printf("%22s", "");
|
|
return 0;
|
|
}
|
|
|
|
const char *filter_description(const char **long_description)
|
|
{
|
|
static char *long_desc = "Cycle counts are accumulated per CPU (or "
|
|
"per thread if CPU is not recorded) from IPC information, and "
|
|
"printed together with the change since the last print, at the "
|
|
"start of each line. Separate counts are kept for branches, "
|
|
"instructions or other events.";
|
|
|
|
*long_description = long_desc;
|
|
return "Print the number of cycles at the start of each line";
|
|
}
|