perf-perf stat用户层代码分析

perf_event 源码分析

前言

简单来说，perf是一种性能监测工具，它首先对通用处理器提供的performance counter进行编程，设定计数器阈值和事件，然后性能计数器就会在设定事件发生时递增计数器，直至这个计数器的计数值达到阈值，在不同的结构中对于计数器数值的提取有不同的方式，例如MIPS上会注册一个硬件中断，这样在计数器溢出时触发一个硬件中断，在中断处理函数中记录数值，x86中则是利用通知链机制，将溢出处理函数注册到die_chain通知链上，它会利用任何一个硬件中断发生的时机，检测性能计数器是否溢出，是则记录这个数值，这种实现方式就避免了单独为性能计数器溢出注册一个硬件中断。

perf源码分为用户层和内核层，用户层代码为用户提供命令行指定事件与采样方式，perf的一大特点就体现在丰富的用户层工具，可以说，内核部分代码只是为perf提供采样引擎，用户层才是perf的精华。用户层代码位于src/tools/perf目录下，c代码有13000行左右，此外还有大量的脚本程序。内核层代码分为结构无关代码（位于src/kernel/core/目录），和结构相关代码（位于src/arch/x86/cpu/**）。

这里先列个框架：首先从系统启动初始化开始，perf-init的相关工作，之后介绍用户层指定事件，通过系统调用转入内核，执行采样，采样数据通过内存映射返回给用户层，用户层工具进行上层分析并显示

perf_event源码分析(一)——cmd_record

perf's main entry

tools/perf/perf.c

static struct cmd_struct commands[] = {
    { "buildid-cache", cmd_buildid_cache, 0 },
    { "buildid-list", cmd_buildid_list, 0 },
    { "diff",   cmd_diff,   0 },
    { "evlist", cmd_evlist, 0 },
    { "help",   cmd_help,   0 },
    { "list",   cmd_list,   0 },
    { "record", cmd_record, 0 },
    { "report", cmd_report, 0 },
    { "bench",  cmd_bench,  0 },
    { "stat",   cmd_stat,   0 },
    { "timechart",  cmd_timechart,  0 },
    { "top",    cmd_top,    0 },
    { "annotate",   cmd_annotate,   0 },
    { "version",    cmd_version,    0 },
    { "script", cmd_script, 0 },
    { "sched",  cmd_sched,  0 },
#ifdef HAVE_LIBELF_SUPPORT
    { "probe",  cmd_probe,  0 },
#endif
    { "kmem",   cmd_kmem,   0 },
    { "lock",   cmd_lock,   0 },
    { "kvm",    cmd_kvm,    0 },
    { "test",   cmd_test,   0 },
#ifdef HAVE_LIBAUDIT_SUPPORT
    { "trace",  cmd_trace,  0 },
#endif
    { "inject", cmd_inject, 0 },
    { "mem",    cmd_mem,    0 },
    { "data",   cmd_data,   0 },
};

perf record's CALL CHAIN:

cmd_record
	;; new a struct "record" rec, and a struct "evlist" in rec->evlist;
	perf_evlist__new
	perf_config
	__cmd_record(&record, argc, argv); // fill out "struct record"
		perf_session__new(file, false, tool); // New a sesssion for this rec, rec->session, attention: file is "struct perf_data_file *file",  &rec->file;
			machines__init(&session->machines);
			ordered_events__init(&session->ordered_events, ordered_events__deliver_event);
			perf_data_file__open(file)
				check_pipe(file)
				file->path = "perf.data" // If not specified name, fill out file->path
				open_file(file);
					fd = perf_data_file__is_read(file) ? open_file_read(file) : open_file_write(file);
					file->fd = fd;
			perf_session__create_kernel_maps(session) //
		fd = perf_data_file__fd(file); // Get rec's fd, rec->file->fd
		record__init_features(rec);
			perf_header__set_feat // Fill out session's header of this rec, rec->session->header
		record__open(rec)
			perf_evlist__config(evlist, opts); // perf_evlist
				perf_evsel__config(evsel, opts); // perf_evsel
		perf_header__clear_feat
		perf_header__write_pipe / perf_session__write_header
		perf_event__synthesize_kernel_mmap(tool, process_synthesized_event, machine);
		perf_event__synthesize_modules(tool, process_synthesized_event, machine);
		machines__process_guests(&session->machines,perf_event__synthesize_guest_os, tool);
		__machine__synthesize_threads(machine, tool, &opts->target, rec->evlist->threads,process_synthesized_event, opts->sample_address);

tools/perf/builtin-record.c

int cmd_record(int argc, const char **argv, const char *prefix __maybe_unused)
{
    int err = -ENOMEM;
    struct record *rec = &record;
    char errbuf[BUFSIZ];

    rec->evlist = perf_evlist__new();
    if (rec->evlist == NULL)
        return -ENOMEM;

    perf_config(perf_record_config, rec);  // 解析, tools/perf/util/config.c

    argc = parse_options(argc, argv, record_options, record_usage,
                PARSE_OPT_STOP_AT_NON_OPTION);
    if (!argc && target__none(&rec->opts.target))
        usage_with_options(record_usage, record_options);

    if (nr_cgroups && !rec->opts.target.system_wide) {
        ui__error("cgroup monitoring only available in"
              " system-wide mode\n");
        usage_with_options(record_usage, record_options);
    }
}

tools/perf/util/parse-events.c

setup_events // tools/perf/builtin-stat.c
	parse_events // tools/perf/util/parse-events.c

parse_events  // tools/perf/util/parse-events.c

int parse_events(struct perf_evlist *evlist, const char *str)
{
    struct parse_events_evlist data = {
        .list = LIST_HEAD_INIT(data.list),
        .idx  = evlist->nr_entries,
    };
    int ret;

    ret = parse_events__scanner(str, &data, PE_START_EVENTS);
    perf_pmu__parse_cleanup();
    if (!ret) {
        int entries = data.idx - evlist->nr_entries;
        perf_evlist__splice_list_tail(evlist, &data.list, entries);
        evlist->nr_groups += data.nr_groups;
        return 0;
    }

    /*
     * There are 2 users - builtin-record and builtin-test objects.
     * Both call perf_evlist__delete in case of error, so we dont
     * need to bother.
     */
    return ret;
}

struct introduction

tools/perf/util/target.h

struct target {
    const char   *pid;
    const char   *tid;
    const char   *cpu_list;
    const char   *uid_str;
    uid_t        uid;
    bool         system_wide;
    bool         uses_mmap;
    bool         default_per_cpu;
    bool         per_thread;
};
===

tools/perf/util/data.h

struct perf_data_file {
    const char      *path;
    int          fd;
    bool             is_pipe;
    bool             force;
    unsigned long        size;
    enum perf_data_mode  mode;
};

=== 

tools/perf/util/session.h

struct perf_session {
    struct perf_header  header;
    struct machines     machines;
    struct perf_evlist  *evlist;
    struct trace_event  tevent;
    bool            repipe;
    bool            one_mmap;
    void            *one_mmap_addr;
    u64         one_mmap_offset;
    struct ordered_events   ordered_events;
    struct perf_data_file   *file;
    struct perf_tool    *tool;
};

===

tools/perf/util/evlist.h 

struct perf_evlist {
    struct list_head entries;
    struct hlist_head heads[PERF_EVLIST__HLIST_SIZE];
    int      nr_entries;
    int      nr_groups;
    int      nr_mmaps;
    size_t       mmap_len;
    int      id_pos;
    int      is_pos;
    u64      combined_sample_type;
    struct {
        int cork_fd;
        pid_t   pid;
    } workload;
    bool         overwrite;
    struct fdarray   pollfd;
    struct perf_mmap *mmap;
    struct thread_map *threads; // threads
    struct cpu_map    *cpus;   // cpus
    struct perf_evsel *selected;
    struct events_stats stats;
};

=== 

/** struct perf_evsel - event selector **/

Each event passed from user mapping one perf_evsel struct. 

struct perf_evsel {
    struct list_head    node;
    struct perf_event_attr  attr;
    char            *filter;
    struct xyarray      *fd;
    struct xyarray      *sample_id;
    u64         *id;
    struct perf_counts  *counts;
    struct perf_counts  *prev_raw_counts;
    int         idx;
    u32         ids;
    char            *name;
    double          scale;
    const char      *unit;
    bool            snapshot;
    struct event_format *tp_format;
    ...
    ...
    struct perf_evsel   *leader;
}

=== 

tools/perf/builtin-record.c

struct record {
    struct perf_tool    tool;
    struct record_opts  opts;
    u64         bytes_written;
    struct perf_data_file   file;
    struct perf_evlist  *evlist;
    struct perf_session *session;
    const char      *progname;
    int         realtime_prio;
    bool            no_buildid;
    bool            no_buildid_cache;
    long            samples;
};

===
Here is important, perf_stat is an array include three "struct stats" in "perf_stat",
and will init perf_stat:
    for (i = 0; i < 3; i++)
        init_stats(&ps->res_stats[i]);

struct perf_stat {
    struct stats      res_stats[3];
};

tools/perf/util/stat.h

struct stats
{
    double n, mean, M2;
    u64 max, min;
};

====
tools/perf/util/evsel.h

struct perf_counts_values {
    union {
        struct {
            u64 val;
            u64 ena;
            u64 run;
        };
        u64 values[3];
    };
};

struct perf_counts {
    s8            scaled;
    struct perf_counts_values aggr;
    struct perf_counts_values cpu[];
};

perf stat's CALL CHAIN

CALL CHAIN:
commands // tools/perf/perf.c
	cmd_stat // tools/perf/builtin-stat.c
		parse_events_option // If perf stat -e xxx, specified event name, will check this event name
			parse_events
 				parse_events__scanner // check events
 					parse_events_lex_init_extra
 					parse_events__scan_string
 					parse_events_parse
 					parse_events__flush_buffer
 					parse_events__delete_buffer
 					parse_events_lex_destroy
				perf_pmu__parse_cleanup:
		perf_evlist__new();
			perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus, struct thread_map *threads) // evlist->cpus, evlist->threads
				perf_evlist__set_maps ///
		parse_options
		parse_options_usage
		add_default_attributes()
		target__validate(&target);
		perf_evlist__create_maps(evsel_list, &target) // fill out evlist->threads(thread_map)
			evlist->threads = thread_map__new_str(target->pid, target->tid,target->uid); // evlist->threads
			evlist->threads(thread_map) = [tid,tid,tid,tid,...]
			target__uses_dummy_map(target)
				evlist->cpus = cpu_map__dummy_new() // evlist->cpus
				evlist->cpus = cpu_map__new(target->cpu_list)
		perf_evlist__alloc_stats(evsel_list, interval)  // Traverse all evsel
			evlist__for_each(evlist, evsel) {
				perf_evsel__alloc_stat_priv(evsel) // Alloc memory for each evsel->priv = zalloc(sizeof(struct perf_stat));
					perf_evsel__reset_stat_priv(evsel)
						init_stats // Fill out "struct perf_stat", perf_stat include 3 elements of "struct stats{}"
				perf_evsel__alloc_counts(evsel, perf_evsel__nr_cpus(evsel)) //  Alloc evsel->counts
				alloc_raw && perf_evsel__alloc_prev_raw_counts(evsel) // Alloc evsel->prev_raw_counts =  addr;
			}
		perf_stat_init_aggr_mode()
			cpu_map__build_socket_map
				cpu_map__build_map(cpus, sockp, cpu_map__get_socket);
				cpu_map__get_socket
			cpu_map__build_core_map
				cpu_map__build_map(cpus, corep, cpu_map__get_core);
				cpu_map__get_core
					cpu_map__get_socket

		run_perf_stat(argc, argv);
			__run_perf_stat(argc, argv);
				perf_evlist__prepare_workload(evsel_list, &target, argv, false, workload_exec_failed_signal)
				perf_evlist__set_leader(evsel_list); // evlist->nr_groups  = 1 or 0 ? decide by evlist->nr_entries > 1 or not
					__perf_evlist__set_leader(&evlist->entries);
					evlist__for_each(evsel_list, evsel) {  // Traverse all evsel
						create_perf_stat_counter(evsel)
							struct perf_event_attr *attr = &evsel->attr;
							attr->xxx  = xxx
							perf_evsel__open_per_cpu(evsel, perf_evsel__cpus(evsel)
							perf_evsel__is_group_leader(evsel)
							perf_evsel__open_per_thread(evsel, evsel_list->threads)
								// important: __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus, struct thread_map *threads)
								__perf_evsel__open(evsel, &empty_cpu_map.map, threads)
									// perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads), if system_wide: nthreads = 1
									perf_evsel__alloc_fd(evsel, cpus->nr, nthreads)
										evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
									for (cpu = 0; cpu < cpus->nr; cpu++) {
										 for (thread = 0; thread < nthreads; thread++) {
										 	group_fd = get_group_fd(evsel, cpu, thread);
										 	sys_perf_event_open(&evsel->attr, pid, cpus->map[cpu], group_fd, flags);
										 }
									}
					}
					perf_evlist__apply_filters(evsel_list, &counter)
					evlist__for_each(evlist, evsel) {
						perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
					}
					t0 = rdclock();
					clock_gettime(CLOCK_MONOTONIC, &ref_time);
					if (forks) {
						perf_evlist__start_workload(evsel_list);
						handle_initial_delay();
						if (interval) {
							print_interval();
						}
					} else {
						handle_initial_delay();
						print_interval();
					}
					t1 = rdclock();

					update_stats(&walltime_nsecs_stats, t1 - t0);

					// 开始为每个evsel读
					if (aggr_mode == AGGR_GLOBAL) {
						evlist__for_each(evsel_list, counter) {
							// 读到struct: "struct perf_counts_values", 保存在evsel的 &counter->counts->aggr , （这里evsel 就是counter）
							// 还有“struct perf_stat” ， counter->priv
							read_counter_aggr(counter);
								aggr->val = aggr->ena = aggr->run = 0; // 这里， 把 perf_counts_values aggr 全部初始化为0
								read_counter(counter)  // 如何读此event？遍历每个thread和cpu
									int nthreads = thread_map__nr(evsel_list->threads);
									int ncpus = perf_evsel__nr_cpus(counter);
									int cpu, thread;
									for (thread = 0; thread < nthreads; thread++) {
										for (cpu = 0; cpu < ncpus; cpu++) {
											// pocess + cpu 二维数组方式读, 读到 "struct  perf_counts_values count"
											process_per_cpu(struct perf_evsel *evsel, int cpu, int thread))
												perf_evsel__read_cb(evsel, cpu, thread, &count)
													memset(count, 0, sizeof(*count));
													FD(evsel, cpu, thread)
													readn(FD(evsel, cpu, thread), count, sizeof(*count))
														ion(true, fd, buf, n);
															read(fd, buf, left)

												read_cb(evsel, cpu, thread, tmp);
													switch (aggr_mode) {
														case AGGR_CORE:
														case AGGR_SOCKET:
														case AGGR_NONE:
														perf_evsel__compute_deltas(evsel, cpu, count);
														perf_counts_values__scale(count, scale, NULL);
														update_shadow_stats(evsel, count->values, cpu);

													}
										}
									}
							perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), thread_map__nr(evsel_list->threads));
						}
					} else {
						evlist__for_each(evsel_list, counter) {
							read_counter(counter);
							perf_evsel__close_fd(counter, perf_evsel__nr_cpus(counter), 1);
						}
					}

		print_stat
			print_aggr // AGGR_CORE AGGR_SOCKET
			print_counter_aggr(evsel, NULL); // AGGR_GLOBAL
			print_counter(evsel, NULL) // AGGR_NONE

tools/perf/util/evsel.h

struct perf_evsel {

}