Merge branch 'perf/test' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux-2.6 into perf/core

24 files changed, 1013 insertions, 519 deletions

diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index ac6692cf5508..1b9b13ee2a72 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -396,6 +396,7 @@ LIB_H += util/build-id.h
 LIB_H += util/debug.h
 LIB_H += util/debugfs.h
 LIB_H += util/event.h
+LIB_H += util/evsel.h
 LIB_H += util/exec_cmd.h
 LIB_H += util/types.h
 LIB_H += util/levenshtein.h
@@ -404,6 +405,7 @@ LIB_H += util/parse-options.h
 LIB_H += util/parse-events.h
 LIB_H += util/quote.h
 LIB_H += util/util.h
+LIB_H += util/xyarray.h
 LIB_H += util/header.h
 LIB_H += util/help.h
 LIB_H += util/session.h
@@ -433,6 +435,7 @@ LIB_OBJS += $(OUTPUT)util/ctype.o
 LIB_OBJS += $(OUTPUT)util/debugfs.o
 LIB_OBJS += $(OUTPUT)util/environment.o
 LIB_OBJS += $(OUTPUT)util/event.o
+LIB_OBJS += $(OUTPUT)util/evsel.o
 LIB_OBJS += $(OUTPUT)util/exec_cmd.o
 LIB_OBJS += $(OUTPUT)util/help.o
 LIB_OBJS += $(OUTPUT)util/levenshtein.o
@@ -470,6 +473,7 @@ LIB_OBJS += $(OUTPUT)util/sort.o
 LIB_OBJS += $(OUTPUT)util/hist.o
 LIB_OBJS += $(OUTPUT)util/probe-event.o
 LIB_OBJS += $(OUTPUT)util/util.o
+LIB_OBJS += $(OUTPUT)util/xyarray.o
 LIB_OBJS += $(OUTPUT)util/cpumap.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index 50efbd509b8f..7bc049035484 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -18,6 +18,7 @@
 
 #include "util/header.h"
 #include "util/event.h"
+#include "util/evsel.h"
 #include "util/debug.h"
 #include "util/session.h"
 #include "util/symbol.h"
@@ -27,18 +28,18 @@
 #include <sched.h>
 #include <sys/mman.h>
 
+#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
+
 enum write_mode_t {
         WRITE_FORCE,
         WRITE_APPEND
 };
 
-static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
-
 static u64                      user_interval                   = ULLONG_MAX;
 static u64                      default_interval                =      0;
 static u64                      sample_type;
 
-static int                      nr_cpus                         =      0;
+static struct cpu_map           *cpus;
 static unsigned int             page_size;
 static unsigned int             mmap_pages                      =    128;
 static unsigned int             user_freq                       = UINT_MAX;
@@ -53,8 +54,7 @@ static bool			sample_id_all_avail		=   true;
 static bool                     system_wide                     =  false;
 static pid_t                    target_pid                      =     -1;
 static pid_t                    target_tid                      =     -1;
-static pid_t                    *all_tids                       =      NULL;
-static int                      thread_num                      =      0;
+static struct thread_map        *threads;
 static pid_t                    child_pid                       =     -1;
 static bool                     no_inherit                      =  false;
 static enum write_mode_t        write_mode                      = WRITE_FORCE;
@@ -81,7 +81,6 @@ static struct perf_session	*session;
 static const char               *cpu_list;
 
 struct mmap_data {
-        int                     counter;
         void                    *base;
         unsigned int            mask;
         unsigned int            prev;
@@ -229,12 +228,12 @@ static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int n
         return h_attr;
 }
 
-static void create_counter(int counter, int cpu)
+static void create_counter(struct perf_evsel *evsel, int cpu)
 {
-        char *filter = filters[counter];
-        struct perf_event_attr *attr = attrs + counter;
+        char *filter = evsel->filter;
+        struct perf_event_attr *attr = &evsel->attr;
         struct perf_header_attr *h_attr;
-        int track = !counter; /* only the first counter needs these */
+        int track = !evsel->idx; /* only the first counter needs these */
         int thread_index;
         int ret;
         struct {
@@ -318,12 +317,11 @@ static void create_counter(int counter, int cpu)
 retry_sample_id:
         attr->sample_id_all = sample_id_all_avail ? 1 : 0;
 
-        for (thread_index = 0; thread_index < thread_num; thread_index++) {
+        for (thread_index = 0; thread_index < threads->nr; thread_index++) {
 try_again:
-                fd[nr_cpu][counter][thread_index] = sys_perf_event_open(attr,
-                                all_tids[thread_index], cpu, group_fd, 0);
+                FD(evsel, nr_cpu, thread_index) = sys_perf_event_open(attr, threads->map[thread_index], cpu, group_fd, 0);
 
-                if (fd[nr_cpu][counter][thread_index] < 0) {
+                if (FD(evsel, nr_cpu, thread_index) < 0) {
                         int err = errno;
 
                         if (err == EPERM || err == EACCES)
@@ -360,7 +358,7 @@ try_again:
                         }
                         printf("\n");
                         error("sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information.\n",
-                                        fd[nr_cpu][counter][thread_index], strerror(err));
+                              FD(evsel, nr_cpu, thread_index), strerror(err));
 
 #if defined(__i386__) || defined(__x86_64__)
                         if (attr->type == PERF_TYPE_HARDWARE && err == EOPNOTSUPP)
@@ -374,7 +372,7 @@ try_again:
                         exit(-1);
                 }
 
-                h_attr = get_header_attr(attr, counter);
+                h_attr = get_header_attr(attr, evsel->idx);
                 if (h_attr == NULL)
                         die("nomem\n");
 
@@ -385,7 +383,7 @@ try_again:
                         }
                 }
 
-                if (read(fd[nr_cpu][counter][thread_index], &read_data, sizeof(read_data)) == -1) {
+                if (read(FD(evsel, nr_cpu, thread_index), &read_data, sizeof(read_data)) == -1) {
                         perror("Unable to read perf file descriptor");
                         exit(-1);
                 }
@@ -395,43 +393,44 @@ try_again:
                         exit(-1);
                 }
 
-                assert(fd[nr_cpu][counter][thread_index] >= 0);
-                fcntl(fd[nr_cpu][counter][thread_index], F_SETFL, O_NONBLOCK);
+                assert(FD(evsel, nr_cpu, thread_index) >= 0);
+                fcntl(FD(evsel, nr_cpu, thread_index), F_SETFL, O_NONBLOCK);
 
                 /*
                  * First counter acts as the group leader:
                  */
                 if (group && group_fd == -1)
-                        group_fd = fd[nr_cpu][counter][thread_index];
-
-                if (counter || thread_index) {
-                        ret = ioctl(fd[nr_cpu][counter][thread_index],
-                                        PERF_EVENT_IOC_SET_OUTPUT,
-                                        fd[nr_cpu][0][0]);
+                        group_fd = FD(evsel, nr_cpu, thread_index);
+
+                if (evsel->idx || thread_index) {
+                        struct perf_evsel *first;
+                        first = list_entry(evsel_list.next, struct perf_evsel, node);
+                        ret = ioctl(FD(evsel, nr_cpu, thread_index),
+                                    PERF_EVENT_IOC_SET_OUTPUT,
+                                    FD(first, nr_cpu, 0));
                         if (ret) {
                                 error("failed to set output: %d (%s)\n", errno,
                                                 strerror(errno));
                                 exit(-1);
                         }
                 } else {
-                        mmap_array[nr_cpu].counter = counter;
                         mmap_array[nr_cpu].prev = 0;
                         mmap_array[nr_cpu].mask = mmap_pages*page_size - 1;
                         mmap_array[nr_cpu].base = mmap(NULL, (mmap_pages+1)*page_size,
-                                PROT_READ|PROT_WRITE, MAP_SHARED, fd[nr_cpu][counter][thread_index], 0);
+                                PROT_READ | PROT_WRITE, MAP_SHARED, FD(evsel, nr_cpu, thread_index), 0);
                         if (mmap_array[nr_cpu].base == MAP_FAILED) {
                                 error("failed to mmap with %d (%s)\n", errno, strerror(errno));
                                 exit(-1);
                         }
 
-                        event_array[nr_poll].fd = fd[nr_cpu][counter][thread_index];
+                        event_array[nr_poll].fd = FD(evsel, nr_cpu, thread_index);
                         event_array[nr_poll].events = POLLIN;
                         nr_poll++;
                 }
 
                 if (filter != NULL) {
-                        ret = ioctl(fd[nr_cpu][counter][thread_index],
-                                        PERF_EVENT_IOC_SET_FILTER, filter);
+                        ret = ioctl(FD(evsel, nr_cpu, thread_index),
+                                    PERF_EVENT_IOC_SET_FILTER, filter);
                         if (ret) {
                                 error("failed to set filter with %d (%s)\n", errno,
                                                 strerror(errno));
@@ -446,11 +445,12 @@ try_again:
 
 static void open_counters(int cpu)
 {
-        int counter;
+        struct perf_evsel *pos;
 
         group_fd = -1;
-        for (counter = 0; counter < nr_counters; counter++)
-                create_counter(counter, cpu);
+
+        list_for_each_entry(pos, &evsel_list, node)
+                create_counter(pos, cpu);
 
         nr_cpu++;
 }
@@ -537,7 +537,7 @@ static void mmap_read_all(void)
 
 static int __cmd_record(int argc, const char **argv)
 {
-        int i, counter;
+        int i;
         struct stat st;
         int flags;
         int err;
@@ -604,7 +604,7 @@ static int __cmd_record(int argc, const char **argv)
                         goto out_delete_session;
         }
 
-        if (have_tracepoints(attrs, nr_counters))
+        if (have_tracepoints(&evsel_list))
                 perf_header__set_feat(&session->header, HEADER_TRACE_INFO);
 
         /*
@@ -652,7 +652,7 @@ static int __cmd_record(int argc, const char **argv)
                 }
 
                 if (!system_wide && target_tid == -1 && target_pid == -1)
-                        all_tids[0] = child_pid;
+                        threads->map[0] = child_pid;
 
                 close(child_ready_pipe[1]);
                 close(go_pipe[0]);
@@ -666,17 +666,11 @@ static int __cmd_record(int argc, const char **argv)
                 close(child_ready_pipe[0]);
         }
 
-        nr_cpus = read_cpu_map(cpu_list);
-        if (nr_cpus < 1) {
-                perror("failed to collect number of CPUs");
-                return -1;
-        }
-
         if (!system_wide && no_inherit && !cpu_list) {
                 open_counters(-1);
         } else {
-                for (i = 0; i < nr_cpus; i++)
-                        open_counters(cpumap[i]);
+                for (i = 0; i < cpus->nr; i++)
+                        open_counters(cpus->map[i]);
         }
 
         perf_session__set_sample_type(session, sample_type);
@@ -711,7 +705,7 @@ static int __cmd_record(int argc, const char **argv)
                         return err;
                 }
 
-                if (have_tracepoints(attrs, nr_counters)) {
+                if (have_tracepoints(&evsel_list)) {
                         /*
                          * FIXME err <= 0 here actually means that
                          * there were no tracepoints so its not really
@@ -720,8 +714,7 @@ static int __cmd_record(int argc, const char **argv)
                          * return this more properly and also
                          * propagate errors that now are calling die()
                          */
-                        err = event__synthesize_tracing_data(output, attrs,
-                                                             nr_counters,
+                        err = event__synthesize_tracing_data(output, &evsel_list,
                                                              process_synthesized_event,
                                                              session);
                         if (err <= 0) {
@@ -795,13 +788,13 @@ static int __cmd_record(int argc, const char **argv)
 
                 if (done) {
                         for (i = 0; i < nr_cpu; i++) {
-                                for (counter = 0;
-                                        counter < nr_counters;
-                                        counter++) {
+                                struct perf_evsel *pos;
+
+                                list_for_each_entry(pos, &evsel_list, node) {
                                         for (thread = 0;
-                                                thread < thread_num;
+                                                thread < threads->nr;
                                                 thread++)
-                                                ioctl(fd[i][counter][thread],
+                                                ioctl(FD(pos, i, thread),
                                                         PERF_EVENT_IOC_DISABLE);
                                 }
                         }
@@ -887,7 +880,8 @@ const struct option record_options[] = {
 
 int cmd_record(int argc, const char **argv, const char *prefix __used)
 {
-        int i, j, err = -ENOMEM;
+        int err = -ENOMEM;
+        struct perf_evsel *pos;
 
         argc = parse_options(argc, argv, record_options, record_usage,
                             PARSE_OPT_STOP_AT_NON_OPTION);
@@ -910,38 +904,32 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
         if (no_buildid_cache || no_buildid)
                 disable_buildid_cache();
 
-        if (!nr_counters) {
-                nr_counters     = 1;
-                attrs[0].type   = PERF_TYPE_HARDWARE;
-                attrs[0].config = PERF_COUNT_HW_CPU_CYCLES;
+        if (list_empty(&evsel_list) && perf_evsel_list__create_default() < 0) {
+                pr_err("Not enough memory for event selector list\n");
+                goto out_symbol_exit;
         }
 
-        if (target_pid != -1) {
+        if (target_pid != -1)
                 target_tid = target_pid;
-                thread_num = find_all_tid(target_pid, &all_tids);
-                if (thread_num <= 0) {
-                        fprintf(stderr, "Can't find all threads of pid %d\n",
-                                        target_pid);
-                        usage_with_options(record_usage, record_options);
-                }
-        } else {
-                all_tids=malloc(sizeof(pid_t));
-                if (!all_tids)
-                        goto out_symbol_exit;
 
-                all_tids[0] = target_tid;
-                thread_num = 1;
+        threads = thread_map__new(target_pid, target_tid);
+        if (threads == NULL) {
+                pr_err("Problems finding threads of monitor\n");
+                usage_with_options(record_usage, record_options);
         }
 
-        for (i = 0; i < MAX_NR_CPUS; i++) {
-                for (j = 0; j < MAX_COUNTERS; j++) {
-                        fd[i][j] = malloc(sizeof(int)*thread_num);
-                        if (!fd[i][j])
-                                goto out_free_fd;
-                }
+        cpus = cpu_map__new(cpu_list);
+        if (cpus == NULL) {
+                perror("failed to parse CPUs map");
+                return -1;
+        }
+
+        list_for_each_entry(pos, &evsel_list, node) {
+                if (perf_evsel__alloc_fd(pos, cpus->nr, threads->nr) < 0)
+                        goto out_free_fd;
         }
-        event_array = malloc(
-                sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num);
+        event_array = malloc((sizeof(struct pollfd) * MAX_NR_CPUS *
+                              MAX_COUNTERS * threads->nr));
         if (!event_array)
                 goto out_free_fd;
 
@@ -968,12 +956,8 @@ int cmd_record(int argc, const char **argv, const char *prefix __used)
 out_free_event_array:
         free(event_array);
 out_free_fd:
-        for (i = 0; i < MAX_NR_CPUS; i++) {
-                for (j = 0; j < MAX_COUNTERS; j++)
-                        free(fd[i][j]);
-        }
-        free(all_tids);
-        all_tids = NULL;
+        thread_map__delete(threads);
+        threads = NULL;
 out_symbol_exit:
         symbol__exit();
         return err;
diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 7ff746da7e6c..02b2d8013a61 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -43,6 +43,7 @@
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/event.h"
+#include "util/evsel.h"
 #include "util/debug.h"
 #include "util/header.h"
 #include "util/cpumap.h"
@@ -71,7 +72,7 @@ static struct perf_event_attr default_attrs[] = {
 };
 
 static bool                     system_wide                     =  false;
-static int                      nr_cpus                         =  0;
+static struct cpu_map           *cpus;
 static int                      run_idx                         =  0;
 
 static int                      run_count                       =  1;
@@ -80,8 +81,7 @@ static bool			scale				=  true;
 static bool                     no_aggr                         = false;
 static pid_t                    target_pid                      = -1;
 static pid_t                    target_tid                      = -1;
-static pid_t                    *all_tids                       =  NULL;
-static int                      thread_num                      =  0;
+static struct thread_map        *threads;
 static pid_t                    child_pid                       = -1;
 static bool                     null_run                        =  false;
 static bool                     big_num                         =  true;
@@ -90,17 +90,6 @@ static const char		*cpu_list;
 static const char               *csv_sep                        = NULL;
 static bool                     csv_output                      = false;
 
-
-static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
-
-static int                      event_scaled[MAX_COUNTERS];
-
-static struct {
-        u64 val;
-        u64 ena;
-        u64 run;
-} cpu_counts[MAX_NR_CPUS][MAX_COUNTERS];
-
 static volatile int done = 0;
 
 struct stats
@@ -108,6 +97,22 @@ struct stats
         double n, mean, M2;
 };
 
+struct perf_stat {
+        struct stats      res_stats[3];
+};
+
+static int perf_evsel__alloc_stat_priv(struct perf_evsel *evsel)
+{
+        evsel->priv = zalloc(sizeof(struct perf_stat));
+        return evsel->priv == NULL ? -ENOMEM : 0;
+}
+
+static void perf_evsel__free_stat_priv(struct perf_evsel *evsel)
+{
+        free(evsel->priv);
+        evsel->priv = NULL;
+}
+
 static void update_stats(struct stats *stats, u64 val)
 {
         double delta;
@@ -147,75 +152,38 @@ static double stddev_stats(struct stats *stats)
         return sqrt(variance_mean);
 }
 
-struct stats                    event_res_stats[MAX_COUNTERS][3];
 struct stats                    runtime_nsecs_stats[MAX_NR_CPUS];
 struct stats                    runtime_cycles_stats[MAX_NR_CPUS];
 struct stats                    runtime_branches_stats[MAX_NR_CPUS];
 struct stats                    walltime_nsecs_stats;
 
-#define MATCH_EVENT(t, c, counter)                      \
-        (attrs[counter].type == PERF_TYPE_##t &&        \
-         attrs[counter].config == PERF_COUNT_##c)
-
-#define ERR_PERF_OPEN \
-"counter %d, sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information."
-
-static int create_perf_stat_counter(int counter, bool *perm_err)
+static int create_perf_stat_counter(struct perf_evsel *evsel)
 {
-        struct perf_event_attr *attr = attrs + counter;
-        int thread;
-        int ncreated = 0;
+        struct perf_event_attr *attr = &evsel->attr;
 
         if (scale)
                 attr->read_format = PERF_FORMAT_TOTAL_TIME_ENABLED |
                                     PERF_FORMAT_TOTAL_TIME_RUNNING;
 
-        if (system_wide) {
-                int cpu;
-
-                for (cpu = 0; cpu < nr_cpus; cpu++) {
-                        fd[cpu][counter][0] = sys_perf_event_open(attr,
-                                        -1, cpumap[cpu], -1, 0);
-                        if (fd[cpu][counter][0] < 0) {
-                                if (errno == EPERM || errno == EACCES)
-                                        *perm_err = true;
-                                error(ERR_PERF_OPEN, counter,
-                                         fd[cpu][counter][0], strerror(errno));
-                        } else {
-                                ++ncreated;
-                        }
-                }
-        } else {
-                attr->inherit = !no_inherit;
-                if (target_pid == -1 && target_tid == -1) {
-                        attr->disabled = 1;
-                        attr->enable_on_exec = 1;
-                }
-                for (thread = 0; thread < thread_num; thread++) {
-                        fd[0][counter][thread] = sys_perf_event_open(attr,
-                                all_tids[thread], -1, -1, 0);
-                        if (fd[0][counter][thread] < 0) {
-                                if (errno == EPERM || errno == EACCES)
-                                        *perm_err = true;
-                                error(ERR_PERF_OPEN, counter,
-                                         fd[0][counter][thread],
-                                         strerror(errno));
-                        } else {
-                                ++ncreated;
-                        }
-                }
+        if (system_wide)
+                return perf_evsel__open_per_cpu(evsel, cpus);
+
+        attr->inherit = !no_inherit;
+        if (target_pid == -1 && target_tid == -1) {
+                attr->disabled = 1;
+                attr->enable_on_exec = 1;
         }
 
-        return ncreated;
+        return perf_evsel__open_per_thread(evsel, threads);
 }
 
 /*
  * Does the counter have nsecs as a unit?
  */
-static inline int nsec_counter(int counter)
+static inline int nsec_counter(struct perf_evsel *evsel)
 {
-        if (MATCH_EVENT(SOFTWARE, SW_CPU_CLOCK, counter) ||
-            MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
+        if (perf_evsel__match(evsel, SOFTWARE, SW_CPU_CLOCK) ||
+            perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
                 return 1;
 
         return 0;
@@ -225,54 +193,17 @@ static inline int nsec_counter(int counter)
  * Read out the results of a single counter:
  * aggregate counts across CPUs in system-wide mode
  */
-static void read_counter_aggr(int counter)
+static int read_counter_aggr(struct perf_evsel *counter)
 {
-        u64 count[3], single_count[3];
-        int cpu;
-        size_t res, nv;
-        int scaled;
-        int i, thread;
+        struct perf_stat *ps = counter->priv;
+        u64 *count = counter->counts->aggr.values;
+        int i;
 
-        count[0] = count[1] = count[2] = 0;
-
-        nv = scale ? 3 : 1;
-        for (cpu = 0; cpu < nr_cpus; cpu++) {
-                for (thread = 0; thread < thread_num; thread++) {
-                        if (fd[cpu][counter][thread] < 0)
-                                continue;
-
-                        res = read(fd[cpu][counter][thread],
-                                        single_count, nv * sizeof(u64));
-                        assert(res == nv * sizeof(u64));
-
-                        close(fd[cpu][counter][thread]);
-                        fd[cpu][counter][thread] = -1;
-
-                        count[0] += single_count[0];
-                        if (scale) {
-                                count[1] += single_count[1];
-                                count[2] += single_count[2];
-                        }
-                }
-        }
-
-        scaled = 0;
-        if (scale) {
-                if (count[2] == 0) {
-                        event_scaled[counter] = -1;
-                        count[0] = 0;
-                        return;
-                }
-
-                if (count[2] < count[1]) {
-                        event_scaled[counter] = 1;
-                        count[0] = (unsigned long long)
-                                ((double)count[0] * count[1] / count[2] + 0.5);
-                }
-        }
+        if (__perf_evsel__read(counter, cpus->nr, threads->nr, scale) < 0)
+                return -1;
 
         for (i = 0; i < 3; i++)
-                update_stats(&event_res_stats[counter][i], count[i]);
+                update_stats(&ps->res_stats[i], count[i]);
 
         if (verbose) {
                 fprintf(stderr, "%s: %Ld %Ld %Ld\n", event_name(counter),
@@ -282,74 +213,51 @@ static void read_counter_aggr(int counter)
         /*
          * Save the full runtime - to allow normalization during printout:
          */
-        if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
+        if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
                 update_stats(&runtime_nsecs_stats[0], count[0]);
-        if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
+        if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
                 update_stats(&runtime_cycles_stats[0], count[0]);
-        if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
+        if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
                 update_stats(&runtime_branches_stats[0], count[0]);
+
+        return 0;
 }
 
 /*
  * Read out the results of a single counter:
  * do not aggregate counts across CPUs in system-wide mode
  */
-static void read_counter(int counter)
+static int read_counter(struct perf_evsel *counter)
 {
-        u64 count[3];
+        u64 *count;
         int cpu;
-        size_t res, nv;
-
-        count[0] = count[1] = count[2] = 0;
-
-        nv = scale ? 3 : 1;
-
-        for (cpu = 0; cpu < nr_cpus; cpu++) {
-
-                if (fd[cpu][counter][0] < 0)
-                        continue;
-
-                res = read(fd[cpu][counter][0], count, nv * sizeof(u64));
-
-                assert(res == nv * sizeof(u64));
 
-                close(fd[cpu][counter][0]);
-                fd[cpu][counter][0] = -1;
+        for (cpu = 0; cpu < cpus->nr; cpu++) {
+                if (__perf_evsel__read_on_cpu(counter, cpu, 0, scale) < 0)
+                        return -1;
 
-                if (scale) {
-                        if (count[2] == 0) {
-                                count[0] = 0;
-                        } else if (count[2] < count[1]) {
-                                count[0] = (unsigned long long)
-                                ((double)count[0] * count[1] / count[2] + 0.5);
-                        }
-                }
-                cpu_counts[cpu][counter].val = count[0]; /* scaled count */
-                cpu_counts[cpu][counter].ena = count[1];
-                cpu_counts[cpu][counter].run = count[2];
+                count = counter->counts->cpu[cpu].values;
 
-                if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter))
+                if (perf_evsel__match(counter, SOFTWARE, SW_TASK_CLOCK))
                         update_stats(&runtime_nsecs_stats[cpu], count[0]);
-                if (MATCH_EVENT(HARDWARE, HW_CPU_CYCLES, counter))
+                if (perf_evsel__match(counter, HARDWARE, HW_CPU_CYCLES))
                         update_stats(&runtime_cycles_stats[cpu], count[0]);
-                if (MATCH_EVENT(HARDWARE, HW_BRANCH_INSTRUCTIONS, counter))
+                if (perf_evsel__match(counter, HARDWARE, HW_BRANCH_INSTRUCTIONS))
                         update_stats(&runtime_branches_stats[cpu], count[0]);
         }
+
+        return 0;
 }
 
 static int run_perf_stat(int argc __used, const char **argv)
 {
         unsigned long long t0, t1;
+        struct perf_evsel *counter;
         int status = 0;
-        int counter, ncreated = 0;
         int child_ready_pipe[2], go_pipe[2];
-        bool perm_err = false;
         const bool forks = (argc > 0);
         char buf;
 
-        if (!system_wide)
-                nr_cpus = 1;
-
         if (forks && (pipe(child_ready_pipe) < 0 || pipe(go_pipe) < 0)) {
                 perror("failed to create pipes");
                 exit(1);
@@ -389,7 +297,7 @@ static int run_perf_stat(int argc __used, const char **argv)
                 }
 
                 if (target_tid == -1 && target_pid == -1 && !system_wide)
-                        all_tids[0] = child_pid;
+                        threads->map[0] = child_pid;
 
                 /*
                  * Wait for the child to be ready to exec.
@@ -401,19 +309,23 @@ static int run_perf_stat(int argc __used, const char **argv)
                 close(child_ready_pipe[0]);
         }
 
-        for (counter = 0; counter < nr_counters; counter++)
-                ncreated += create_perf_stat_counter(counter, &perm_err);
-
-        if (ncreated < nr_counters) {
-                if (perm_err)
-                        error("You may not have permission to collect %sstats.\n"
-                              "\t Consider tweaking"
-                              " /proc/sys/kernel/perf_event_paranoid or running as root.",
-                              system_wide ? "system-wide " : "");
-                die("Not all events could be opened.\n");
-                if (child_pid != -1)
-                        kill(child_pid, SIGTERM);
-                return -1;
+        list_for_each_entry(counter, &evsel_list, node) {
+                if (create_perf_stat_counter(counter) < 0) {
+                        if (errno == -EPERM || errno == -EACCES) {
+                                error("You may not have permission to collect %sstats.\n"
+                                      "\t Consider tweaking"
+                                      " /proc/sys/kernel/perf_event_paranoid or running as root.",
+                                      system_wide ? "system-wide " : "");
+                        } else {
+                                error("open_counter returned with %d (%s). "
+                                      "/bin/dmesg may provide additional information.\n",
+                                       errno, strerror(errno));
+                        }
+                        if (child_pid != -1)
+                                kill(child_pid, SIGTERM);
+                        die("Not all events could be opened.\n");
+                        return -1;
+                }
         }
 
         /*
@@ -433,25 +345,33 @@ static int run_perf_stat(int argc __used, const char **argv)
         update_stats(&walltime_nsecs_stats, t1 - t0);
 
         if (no_aggr) {
-                for (counter = 0; counter < nr_counters; counter++)
+                list_for_each_entry(counter, &evsel_list, node) {
                         read_counter(counter);
+                        perf_evsel__close_fd(counter, cpus->nr, 1);
+                }
         } else {
-                for (counter = 0; counter < nr_counters; counter++)
+                list_for_each_entry(counter, &evsel_list, node) {
                         read_counter_aggr(counter);
+                        perf_evsel__close_fd(counter, cpus->nr, threads->nr);
+                }
         }
+
         return WEXITSTATUS(status);
 }
 
-static void print_noise(int counter, double avg)
+static void print_noise(struct perf_evsel *evsel, double avg)
 {
+        struct perf_stat *ps;
+
         if (run_count == 1)
                 return;
 
+        ps = evsel->priv;
         fprintf(stderr, "   ( +- %7.3f%% )",
-                        100 * stddev_stats(&event_res_stats[counter][0]) / avg);
+                        100 * stddev_stats(&ps->res_stats[0]) / avg);
 }
 
-static void nsec_printout(int cpu, int counter, double avg)
+static void nsec_printout(int cpu, struct perf_evsel *evsel, double avg)
 {
         double msecs = avg / 1e6;
         char cpustr[16] = { '\0', };
@@ -460,20 +380,19 @@ static void nsec_printout(int cpu, int counter, double avg)
         if (no_aggr)
                 sprintf(cpustr, "CPU%*d%s",
                         csv_output ? 0 : -4,
-                        cpumap[cpu], csv_sep);
+                        cpus->map[cpu], csv_sep);
 
-        fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(counter));
+        fprintf(stderr, fmt, cpustr, msecs, csv_sep, event_name(evsel));
 
         if (csv_output)
                 return;
 
-        if (MATCH_EVENT(SOFTWARE, SW_TASK_CLOCK, counter)) {
+        if (perf_evsel__match(evsel, SOFTWARE, SW_TASK_CLOCK))
                 fprintf(stderr, " # %10.3f CPUs ",
                                 avg / avg_stats(&walltime_nsecs_stats));
-        }
 }
 
-static void abs_printout(int cpu, int counter, double avg)
+static void abs_printout(int cpu, struct perf_evsel *evsel, double avg)
 {
         double total, ratio = 0.0;
         char cpustr[16] = { '\0', };
@@ -489,23 +408,23 @@ static void abs_printout(int cpu, int counter, double avg)
         if (no_aggr)
                 sprintf(cpustr, "CPU%*d%s",
                         csv_output ? 0 : -4,
-                        cpumap[cpu], csv_sep);
+                        cpus->map[cpu], csv_sep);
         else
                 cpu = 0;
 
-        fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(counter));
+        fprintf(stderr, fmt, cpustr, avg, csv_sep, event_name(evsel));
 
         if (csv_output)
                 return;
 
-        if (MATCH_EVENT(HARDWARE, HW_INSTRUCTIONS, counter)) {
+        if (perf_evsel__match(evsel, HARDWARE, HW_INSTRUCTIONS)) {
                 total = avg_stats(&runtime_cycles_stats[cpu]);
 
                 if (total)
                         ratio = avg / total;
 
                 fprintf(stderr, " # %10.3f IPC  ", ratio);
-        } else if (MATCH_EVENT(HARDWARE, HW_BRANCH_MISSES, counter) &&
+        } else if (perf_evsel__match(evsel, HARDWARE, HW_BRANCH_MISSES) &&
                         runtime_branches_stats[cpu].n != 0) {
                 total = avg_stats(&runtime_branches_stats[cpu]);
 
@@ -528,10 +447,11 @@ static void abs_printout(int cpu, int counter, double avg)
  * Print out the results of a single counter:
  * aggregated counts in system-wide mode
  */
-static void print_counter_aggr(int counter)
+static void print_counter_aggr(struct perf_evsel *counter)
 {
-        double avg = avg_stats(&event_res_stats[counter][0]);
-        int scaled = event_scaled[counter];
+        struct perf_stat *ps = counter->priv;
+        double avg = avg_stats(&ps->res_stats[0]);
+        int scaled = counter->counts->scaled;
 
         if (scaled == -1) {
                 fprintf(stderr, "%*s%s%-24s\n",
@@ -555,8 +475,8 @@ static void print_counter_aggr(int counter)
         if (scaled) {
                 double avg_enabled, avg_running;
 
-                avg_enabled = avg_stats(&event_res_stats[counter][1]);
-                avg_running = avg_stats(&event_res_stats[counter][2]);
+                avg_enabled = avg_stats(&ps->res_stats[1]);
+                avg_running = avg_stats(&ps->res_stats[2]);
 
                 fprintf(stderr, "  (scaled from %.2f%%)",
                                 100 * avg_running / avg_enabled);
@@ -569,19 +489,19 @@ static void print_counter_aggr(int counter)
  * Print out the results of a single counter:
  * does not use aggregated count in system-wide
  */
-static void print_counter(int counter)
+static void print_counter(struct perf_evsel *counter)
 {
         u64 ena, run, val;
         int cpu;
 
-        for (cpu = 0; cpu < nr_cpus; cpu++) {
-                val = cpu_counts[cpu][counter].val;
-                ena = cpu_counts[cpu][counter].ena;
-                run = cpu_counts[cpu][counter].run;
+        for (cpu = 0; cpu < cpus->nr; cpu++) {
+                val = counter->counts->cpu[cpu].val;
+                ena = counter->counts->cpu[cpu].ena;
+                run = counter->counts->cpu[cpu].run;
                 if (run == 0 || ena == 0) {
                         fprintf(stderr, "CPU%*d%s%*s%s%-24s",
                                 csv_output ? 0 : -4,
-                                cpumap[cpu], csv_sep,
+                                cpus->map[cpu], csv_sep,
                                 csv_output ? 0 : 18,
                                 "<not counted>", csv_sep,
                                 event_name(counter));
@@ -609,7 +529,8 @@ static void print_counter(int counter)
 
 static void print_stat(int argc, const char **argv)
 {
-        int i, counter;
+        struct perf_evsel *counter;
+        int i;
 
         fflush(stdout);
 
@@ -632,10 +553,10 @@ static void print_stat(int argc, const char **argv)
         }
 
         if (no_aggr) {
-                for (counter = 0; counter < nr_counters; counter++)
+                list_for_each_entry(counter, &evsel_list, node)
                         print_counter(counter);
         } else {
-                for (counter = 0; counter < nr_counters; counter++)
+                list_for_each_entry(counter, &evsel_list, node)
                         print_counter_aggr(counter);
         }
 
@@ -720,8 +641,8 @@ static const struct option options[] = {
 
 int cmd_stat(int argc, const char **argv, const char *prefix __used)
 {
-        int status;
-        int i,j;
+        struct perf_evsel *pos;
+        int status = -ENOMEM;
 
         setlocale(LC_ALL, "");
 
@@ -757,41 +678,45 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
 
         /* Set attrs and nr_counters if no event is selected and !null_run */
         if (!null_run && !nr_counters) {
-                memcpy(attrs, default_attrs, sizeof(default_attrs));
+                size_t c;
+
                 nr_counters = ARRAY_SIZE(default_attrs);
+
+                for (c = 0; c < ARRAY_SIZE(default_attrs); ++c) {
+                        pos = perf_evsel__new(default_attrs[c].type,
+                                              default_attrs[c].config,
+                                              nr_counters);
+                        if (pos == NULL)
+                                goto out;
+                        list_add(&pos->node, &evsel_list);
+                }
         }
 
-        if (system_wide)
-                nr_cpus = read_cpu_map(cpu_list);
-        else
-                nr_cpus = 1;
+        if (target_pid != -1)
+                target_tid = target_pid;
 
-        if (nr_cpus < 1)
+        threads = thread_map__new(target_pid, target_tid);
+        if (threads == NULL) {
+                pr_err("Problems finding threads of monitor\n");
                 usage_with_options(stat_usage, options);
+        }
 
-        if (target_pid != -1) {
-                target_tid = target_pid;
-                thread_num = find_all_tid(target_pid, &all_tids);
-                if (thread_num <= 0) {
-                        fprintf(stderr, "Can't find all threads of pid %d\n",
-                                        target_pid);
-                        usage_with_options(stat_usage, options);
-                }
-        } else {
-                all_tids=malloc(sizeof(pid_t));
-                if (!all_tids)
-                        return -ENOMEM;
+        if (system_wide)
+                cpus = cpu_map__new(cpu_list);
+        else
+                cpus = cpu_map__dummy_new();
 
-                all_tids[0] = target_tid;
-                thread_num = 1;
+        if (cpus == NULL) {
+                perror("failed to parse CPUs map");
+                usage_with_options(stat_usage, options);
+                return -1;
         }
 
-        for (i = 0; i < MAX_NR_CPUS; i++) {
-                for (j = 0; j < MAX_COUNTERS; j++) {
-                        fd[i][j] = malloc(sizeof(int)*thread_num);
-                        if (!fd[i][j])
-                                return -ENOMEM;
-                }
+        list_for_each_entry(pos, &evsel_list, node) {
+                if (perf_evsel__alloc_stat_priv(pos) < 0 ||
+                    perf_evsel__alloc_counts(pos, cpus->nr) < 0 ||
+                    perf_evsel__alloc_fd(pos, cpus->nr, threads->nr) < 0)
+                        goto out_free_fd;
         }
 
         /*
@@ -814,6 +739,11 @@ int cmd_stat(int argc, const char **argv, const char *prefix __used)
 
         if (status != -1)
                 print_stat(argc, argv);
-
+out_free_fd:
+        list_for_each_entry(pos, &evsel_list, node)
+                perf_evsel__free_stat_priv(pos);
+out:
+        thread_map__delete(threads);
+        threads = NULL;
         return status;
 }
diff --git a/tools/perf/builtin-test.c b/tools/perf/builtin-test.c
index e0c3f471f22d..6c991529f62b 100644
--- a/tools/perf/builtin-test.c
+++ b/tools/perf/builtin-test.c
@@ -234,6 +234,85 @@ out:
         return err;
 }
 
+#include "util/evsel.h"
+#include <sys/types.h>
+
+static int trace_event__id(const char *event_name)
+{
+        char *filename;
+        int err = -1, fd;
+
+        if (asprintf(&filename,
+                     "/sys/kernel/debug/tracing/events/syscalls/%s/id",
+                     event_name) < 0)
+                return -1;
+
+        fd = open(filename, O_RDONLY);
+        if (fd >= 0) {
+                char id[16];
+                if (read(fd, id, sizeof(id)) > 0)
+                        err = atoi(id);
+                close(fd);
+        }
+
+        free(filename);
+        return err;
+}
+
+static int test__open_syscall_event(void)
+{
+        int err = -1, fd;
+        struct thread_map *threads;
+        struct perf_evsel *evsel;
+        unsigned int nr_open_calls = 111, i;
+        int id = trace_event__id("sys_enter_open");
+
+        if (id < 0) {
+                pr_debug("trace_event__id(\"sys_enter_open\") ");
+                return -1;
+        }
+
+        threads = thread_map__new(-1, getpid());
+        if (threads == NULL) {
+                pr_debug("thread_map__new ");
+                return -1;
+        }
+
+        evsel = perf_evsel__new(PERF_TYPE_TRACEPOINT, id, 0);
+        if (evsel == NULL) {
+                pr_debug("perf_evsel__new ");
+                goto out_thread_map_delete;
+        }
+
+        if (perf_evsel__open_per_thread(evsel, threads) < 0) {
+                pr_debug("perf_evsel__open_per_thread ");
+                goto out_evsel_delete;
+        }
+
+        for (i = 0; i < nr_open_calls; ++i) {
+                fd = open("/etc/passwd", O_RDONLY);
+                close(fd);
+        }
+
+        if (perf_evsel__read_on_cpu(evsel, 0, 0) < 0) {
+                pr_debug("perf_evsel__open_read_on_cpu ");
+                goto out_close_fd;
+        }
+
+        if (evsel->counts->cpu[0].val != nr_open_calls)
+                pr_debug("perf_evsel__read_on_cpu: expected to intercept %d calls, got %Ld ",
+                         nr_open_calls, evsel->counts->cpu[0].val);
+        
+        err = 0;
+out_close_fd:
+        perf_evsel__close_fd(evsel, 1, threads->nr);
+out_evsel_delete:
+        perf_evsel__delete(evsel);
+out_thread_map_delete:
+        thread_map__delete(threads);
+        return err;
+}
+
 static struct test {
         const char *desc;
         int (*func)(void);
@@ -243,6 +322,10 @@ static struct test {
                 .func = test__vmlinux_matches_kallsyms,
         },
         {
+                .desc = "detect open syscall event",
+                .func = test__open_syscall_event,
+        },
+        {
                 .func = NULL,
         },
 };
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index ae15f046c405..1e67ab9c7ebc 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -21,6 +21,7 @@
 #include "perf.h"
 
 #include "util/color.h"
+#include "util/evsel.h"
 #include "util/session.h"
 #include "util/symbol.h"
 #include "util/thread.h"
@@ -29,6 +30,7 @@
 #include "util/parse-options.h"
 #include "util/parse-events.h"
 #include "util/cpumap.h"
+#include "util/xyarray.h"
 
 #include "util/debug.h"
 
@@ -55,7 +57,7 @@
 #include <linux/unistd.h>
 #include <linux/types.h>
 
-static int                      *fd[MAX_NR_CPUS][MAX_COUNTERS];
+#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
 
 static bool                     system_wide                     =  false;
 
@@ -66,10 +68,9 @@ static int			print_entries;
 
 static int                      target_pid                      =     -1;
 static int                      target_tid                      =     -1;
-static pid_t                    *all_tids                       =      NULL;
-static int                      thread_num                      =      0;
+static struct thread_map        *threads;
 static bool                     inherit                         =  false;
-static int                      nr_cpus                         =      0;
+static struct cpu_map           *cpus;
 static int                      realtime_prio                   =      0;
 static bool                     group                           =  false;
 static unsigned int             page_size;
@@ -100,6 +101,7 @@ struct sym_entry		*sym_filter_entry		=   NULL;
 struct sym_entry                *sym_filter_entry_sched         =   NULL;
 static int                      sym_pcnt_filter                 =      5;
 static int                      sym_counter                     =      0;
+static struct perf_evsel        *sym_evsel                      =   NULL;
 static int                      display_weighted                =     -1;
 static const char               *cpu_list;
 
@@ -353,7 +355,7 @@ static void show_details(struct sym_entry *syme)
                 return;
 
         symbol = sym_entry__symbol(syme);
-        printf("Showing %s for %s\n", event_name(sym_counter), symbol->name);
+        printf("Showing %s for %s\n", event_name(sym_evsel), symbol->name);
         printf("  Events  Pcnt (>=%d%%)\n", sym_pcnt_filter);
 
         pthread_mutex_lock(&syme->src->lock);
@@ -460,7 +462,8 @@ static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
 static void print_sym_table(void)
 {
         int printed = 0, j;
-        int counter, snap = !display_weighted ? sym_counter : 0;
+        struct perf_evsel *counter;
+        int snap = !display_weighted ? sym_counter : 0;
         float samples_per_sec = samples/delay_secs;
         float ksamples_per_sec = kernel_samples/delay_secs;
         float us_samples_per_sec = (us_samples)/delay_secs;
@@ -532,7 +535,9 @@ static void print_sym_table(void)
         }
 
         if (nr_counters == 1 || !display_weighted) {
-                printf("%Ld", (u64)attrs[0].sample_period);
+                struct perf_evsel *first;
+                first = list_entry(evsel_list.next, struct perf_evsel, node);
+                printf("%Ld", first->attr.sample_period);
                 if (freq)
                         printf("Hz ");
                 else
@@ -540,9 +545,9 @@ static void print_sym_table(void)
         }
 
         if (!display_weighted)
-                printf("%s", event_name(sym_counter));
-        else for (counter = 0; counter < nr_counters; counter++) {
-                if (counter)
+                printf("%s", event_name(sym_evsel));
+        else list_for_each_entry(counter, &evsel_list, node) {
+                if (counter->idx)
                         printf("/");
 
                 printf("%s", event_name(counter));
@@ -558,12 +563,12 @@ static void print_sym_table(void)
                 printf(" (all");
 
         if (cpu_list)
-                printf(", CPU%s: %s)\n", nr_cpus > 1 ? "s" : "", cpu_list);
+                printf(", CPU%s: %s)\n", cpus->nr > 1 ? "s" : "", cpu_list);
         else {
                 if (target_tid != -1)
                         printf(")\n");
                 else
-                        printf(", %d CPU%s)\n", nr_cpus, nr_cpus > 1 ? "s" : "");
+                        printf(", %d CPU%s)\n", cpus->nr, cpus->nr > 1 ? "s" : "");
         }
 
         printf("%-*.*s\n", win_width, win_width, graph_dotted_line);
@@ -739,7 +744,7 @@ static void print_mapped_keys(void)
         fprintf(stdout, "\t[e]     display entries (lines).           \t(%d)\n", print_entries);
 
         if (nr_counters > 1)
-                fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", event_name(sym_counter));
+                fprintf(stdout, "\t[E]     active event counter.              \t(%s)\n", event_name(sym_evsel));
 
         fprintf(stdout, "\t[f]     profile display filter (count).    \t(%d)\n", count_filter);
 
@@ -826,19 +831,23 @@ static void handle_keypress(struct perf_session *session, int c)
                         break;
                 case 'E':
                         if (nr_counters > 1) {
-                                int i;
-
                                 fprintf(stderr, "\nAvailable events:");
-                                for (i = 0; i < nr_counters; i++)
-                                        fprintf(stderr, "\n\t%d %s", i, event_name(i));
+
+                                list_for_each_entry(sym_evsel, &evsel_list, node)
+                                        fprintf(stderr, "\n\t%d %s", sym_evsel->idx, event_name(sym_evsel));
 
                                 prompt_integer(&sym_counter, "Enter details event counter");
 
                                 if (sym_counter >= nr_counters) {
-                                        fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(0));
+                                        sym_evsel = list_entry(evsel_list.next, struct perf_evsel, node);
                                         sym_counter = 0;
+                                        fprintf(stderr, "Sorry, no such event, using %s.\n", event_name(sym_evsel));
                                         sleep(1);
+                                        break;
                                 }
+                                list_for_each_entry(sym_evsel, &evsel_list, node)
+                                        if (sym_evsel->idx == sym_counter)
+                                                break;
                         } else sym_counter = 0;
                         break;
                 case 'f':
@@ -978,7 +987,8 @@ static int symbol_filter(struct map *map, struct symbol *sym)
 
 static void event__process_sample(const event_t *self,
                                   struct sample_data *sample,
-                                  struct perf_session *session, int counter)
+                                  struct perf_session *session,
+                                  struct perf_evsel *evsel)
 {
         u64 ip = self->ip.ip;
         struct sym_entry *syme;
@@ -1071,9 +1081,9 @@ static void event__process_sample(const event_t *self,
 
         syme = symbol__priv(al.sym);
         if (!syme->skip) {
-                syme->count[counter]++;
+                syme->count[evsel->idx]++;
                 syme->origin = origin;
-                record_precise_ip(syme, counter, ip);
+                record_precise_ip(syme, evsel->idx, ip);
                 pthread_mutex_lock(&active_symbols_lock);
                 if (list_empty(&syme->node) || !syme->node.next)
                         __list_insert_active_sym(syme);
@@ -1082,12 +1092,24 @@ static void event__process_sample(const event_t *self,
 }
 
 struct mmap_data {
-        int                     counter;
         void                    *base;
         int                     mask;
         unsigned int            prev;
 };
 
+static int perf_evsel__alloc_mmap_per_thread(struct perf_evsel *evsel,
+                                             int ncpus, int nthreads)
+{
+        evsel->priv = xyarray__new(ncpus, nthreads, sizeof(struct mmap_data));
+        return evsel->priv != NULL ? 0 : -ENOMEM;
+}
+
+static void perf_evsel__free_mmap(struct perf_evsel *evsel)
+{
+        xyarray__delete(evsel->priv);
+        evsel->priv = NULL;
+}
+
 static unsigned int mmap_read_head(struct mmap_data *md)
 {
         struct perf_event_mmap_page *pc = md->base;
@@ -1100,8 +1122,11 @@ static unsigned int mmap_read_head(struct mmap_data *md)
 }
 
 static void perf_session__mmap_read_counter(struct perf_session *self,
-                                            struct mmap_data *md)
+                                            struct perf_evsel *evsel,
+                                            int cpu, int thread_idx)
 {
+        struct xyarray *mmap_array = evsel->priv;
+        struct mmap_data *md = xyarray__entry(mmap_array, cpu, thread_idx);
         unsigned int head = mmap_read_head(md);
         unsigned int old = md->prev;
         unsigned char *data = md->base + page_size;
@@ -1155,7 +1180,7 @@ static void perf_session__mmap_read_counter(struct perf_session *self,
 
                 event__parse_sample(event, self, &sample);
                 if (event->header.type == PERF_RECORD_SAMPLE)
-                        event__process_sample(event, &sample, self, md->counter);
+                        event__process_sample(event, &sample, self, evsel);
                 else
                         event__process(event, &sample, self);
                 old += size;
@@ -1165,36 +1190,39 @@ static void perf_session__mmap_read_counter(struct perf_session *self,
 }
 
 static struct pollfd *event_array;
-static struct mmap_data *mmap_array[MAX_NR_CPUS][MAX_COUNTERS];
 
 static void perf_session__mmap_read(struct perf_session *self)
 {
-        int i, counter, thread_index;
+        struct perf_evsel *counter;
+        int i, thread_index;
 
-        for (i = 0; i < nr_cpus; i++) {
-                for (counter = 0; counter < nr_counters; counter++)
+        for (i = 0; i < cpus->nr; i++) {
+                list_for_each_entry(counter, &evsel_list, node) {
                         for (thread_index = 0;
-                                thread_index < thread_num;
+                                thread_index < threads->nr;
                                 thread_index++) {
                                 perf_session__mmap_read_counter(self,
-                                        &mmap_array[i][counter][thread_index]);
+                                        counter, i, thread_index);
                         }
+                }
         }
 }
 
 int nr_poll;
 int group_fd;
 
-static void start_counter(int i, int counter)
+static void start_counter(int i, struct perf_evsel *evsel)
 {
+        struct xyarray *mmap_array = evsel->priv;
+        struct mmap_data *mm;
         struct perf_event_attr *attr;
         int cpu = -1;
         int thread_index;
 
         if (target_tid == -1)
-                cpu = cpumap[i];
+                cpu = cpus->map[i];
 
-        attr = attrs + counter;
+        attr = &evsel->attr;
 
         attr->sample_type       = PERF_SAMPLE_IP | PERF_SAMPLE_TID;
 
@@ -1207,12 +1235,12 @@ static void start_counter(int i, int counter)
         attr->inherit           = (cpu < 0) && inherit;
         attr->mmap              = 1;
 
-        for (thread_index = 0; thread_index < thread_num; thread_index++) {
+        for (thread_index = 0; thread_index < threads->nr; thread_index++) {
 try_again:
-                fd[i][counter][thread_index] = sys_perf_event_open(attr,
-                                all_tids[thread_index], cpu, group_fd, 0);
+                FD(evsel, i, thread_index) = sys_perf_event_open(attr,
+                                threads->map[thread_index], cpu, group_fd, 0);
 
-                if (fd[i][counter][thread_index] < 0) {
+                if (FD(evsel, i, thread_index) < 0) {
                         int err = errno;
 
                         if (err == EPERM || err == EACCES)
@@ -1236,29 +1264,29 @@ try_again:
                         }
                         printf("\n");
                         error("sys_perf_event_open() syscall returned with %d (%s).  /bin/dmesg may provide additional information.\n",
-                                        fd[i][counter][thread_index], strerror(err));
+                                        FD(evsel, i, thread_index), strerror(err));
                         die("No CONFIG_PERF_EVENTS=y kernel support configured?\n");
                         exit(-1);
                 }
-                assert(fd[i][counter][thread_index] >= 0);
-                fcntl(fd[i][counter][thread_index], F_SETFL, O_NONBLOCK);
+                assert(FD(evsel, i, thread_index) >= 0);
+                fcntl(FD(evsel, i, thread_index), F_SETFL, O_NONBLOCK);
 
                 /*
                  * First counter acts as the group leader:
                  */
                 if (group && group_fd == -1)
-                        group_fd = fd[i][counter][thread_index];
+                        group_fd = FD(evsel, i, thread_index);
 
-                event_array[nr_poll].fd = fd[i][counter][thread_index];
+                event_array[nr_poll].fd = FD(evsel, i, thread_index);
                 event_array[nr_poll].events = POLLIN;
                 nr_poll++;
 
-                mmap_array[i][counter][thread_index].counter = counter;
-                mmap_array[i][counter][thread_index].prev = 0;
-                mmap_array[i][counter][thread_index].mask = mmap_pages*page_size - 1;
-                mmap_array[i][counter][thread_index].base = mmap(NULL, (mmap_pages+1)*page_size,
-                                PROT_READ, MAP_SHARED, fd[i][counter][thread_index], 0);
-                if (mmap_array[i][counter][thread_index].base == MAP_FAILED)
+                mm = xyarray__entry(mmap_array, i, thread_index);
+                mm->prev = 0;
+                mm->mask = mmap_pages*page_size - 1;
+                mm->base = mmap(NULL, (mmap_pages+1)*page_size,
+                                PROT_READ, MAP_SHARED, FD(evsel, i, thread_index), 0);
+                if (mm->base == MAP_FAILED)
                         die("failed to mmap with %d (%s)\n", errno, strerror(errno));
         }
 }
@@ -1266,8 +1294,8 @@ try_again:
 static int __cmd_top(void)
 {
         pthread_t thread;
-        int i, counter;
-        int ret;
+        struct perf_evsel *counter;
+        int i, ret;
         /*
          * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
          * mmap reading, etc is encapsulated in it. Use O_WRONLY for now.
@@ -1281,9 +1309,9 @@ static int __cmd_top(void)
         else
                 event__synthesize_threads(event__process, session);
 
-        for (i = 0; i < nr_cpus; i++) {
+        for (i = 0; i < cpus->nr; i++) {
                 group_fd = -1;
-                for (counter = 0; counter < nr_counters; counter++)
+                list_for_each_entry(counter, &evsel_list, node)
                         start_counter(i, counter);
         }
 
@@ -1372,8 +1400,8 @@ static const struct option options[] = {
 
 int cmd_top(int argc, const char **argv, const char *prefix __used)
 {
-        int counter;
-        int i,j;
+        struct perf_evsel *pos;
+        int status = -ENOMEM;
 
         page_size = sysconf(_SC_PAGE_SIZE);
 
@@ -1381,34 +1409,17 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
         if (argc)
                 usage_with_options(top_usage, options);
 
-        if (target_pid != -1) {
+        if (target_pid != -1)
                 target_tid = target_pid;
-                thread_num = find_all_tid(target_pid, &all_tids);
-                if (thread_num <= 0) {
-                        fprintf(stderr, "Can't find all threads of pid %d\n",
-                                target_pid);
-                        usage_with_options(top_usage, options);
-                }
-        } else {
-                all_tids=malloc(sizeof(pid_t));
-                if (!all_tids)
-                        return -ENOMEM;
 
-                all_tids[0] = target_tid;
-                thread_num = 1;
+        threads = thread_map__new(target_pid, target_tid);
+        if (threads == NULL) {
+                pr_err("Problems finding threads of monitor\n");
+                usage_with_options(top_usage, options);
         }
 
-        for (i = 0; i < MAX_NR_CPUS; i++) {
-                for (j = 0; j < MAX_COUNTERS; j++) {
-                        fd[i][j] = malloc(sizeof(int)*thread_num);
-                        mmap_array[i][j] = zalloc(
-                                sizeof(struct mmap_data)*thread_num);
-                        if (!fd[i][j] || !mmap_array[i][j])
-                                return -ENOMEM;
-                }
-        }
-        event_array = malloc(
-                sizeof(struct pollfd)*MAX_NR_CPUS*MAX_COUNTERS*thread_num);
+        event_array = malloc((sizeof(struct pollfd) *
+                              MAX_NR_CPUS * MAX_COUNTERS * threads->nr));
         if (!event_array)
                 return -ENOMEM;
 
@@ -1419,15 +1430,10 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 cpu_list = NULL;
         }
 
-        if (!nr_counters)
-                nr_counters = 1;
-
-        symbol_conf.priv_size = (sizeof(struct sym_entry) +
-                                 (nr_counters + 1) * sizeof(unsigned long));
-
-        symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
-        if (symbol__init() < 0)
-                return -1;
+        if (!nr_counters && perf_evsel_list__create_default() < 0) {
+                pr_err("Not enough memory for event selector list\n");
+                return -ENOMEM;
+        }
 
         if (delay_secs < 1)
                 delay_secs = 1;
@@ -1444,23 +1450,33 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 exit(EXIT_FAILURE);
         }
 
-        /*
-         * Fill in the ones not specifically initialized via -c:
-         */
-        for (counter = 0; counter < nr_counters; counter++) {
-                if (attrs[counter].sample_period)
+        if (target_tid != -1)
+                cpus = cpu_map__dummy_new();
+        else
+                cpus = cpu_map__new(cpu_list);
+
+        if (cpus == NULL)
+                usage_with_options(top_usage, options);
+
+        list_for_each_entry(pos, &evsel_list, node) {
+                if (perf_evsel__alloc_mmap_per_thread(pos, cpus->nr, threads->nr) < 0 ||
+                    perf_evsel__alloc_fd(pos, cpus->nr, threads->nr) < 0)
+                        goto out_free_fd;
+                /*
+                 * Fill in the ones not specifically initialized via -c:
+                 */
+                if (pos->attr.sample_period)
                         continue;
 
-                attrs[counter].sample_period = default_interval;
+                pos->attr.sample_period = default_interval;
         }
 
-        if (target_tid != -1)
-                nr_cpus = 1;
-        else
-                nr_cpus = read_cpu_map(cpu_list);
+        symbol_conf.priv_size = (sizeof(struct sym_entry) +
+                                 (nr_counters + 1) * sizeof(unsigned long));
 
-        if (nr_cpus < 1)
-                usage_with_options(top_usage, options);
+        symbol_conf.try_vmlinux_path = (symbol_conf.vmlinux_name == NULL);
+        if (symbol__init() < 0)
+                return -1;
 
         get_term_dimensions(&winsize);
         if (print_entries == 0) {
@@ -1468,5 +1484,10 @@ int cmd_top(int argc, const char **argv, const char *prefix __used)
                 signal(SIGWINCH, sig_winch_handler);
         }
 
-        return __cmd_top();
+        status = __cmd_top();
+out_free_fd:
+        list_for_each_entry(pos, &evsel_list, node)
+                perf_evsel__free_mmap(pos);
+
+        return status;
 }
diff --git a/tools/perf/perf.c b/tools/perf/perf.c
index 595d0f4a7103..5b1ecd66bb36 100644
--- a/tools/perf/perf.c
+++ b/tools/perf/perf.c
@@ -286,6 +286,8 @@ static int run_builtin(struct cmd_struct *p, int argc, const char **argv)
         status = p->fn(argc, argv, prefix);
         exit_browser(status);
 
+        perf_evsel_list__delete();
+
         if (status)
                 return status & 0xff;
 
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 0f9b8d7a7d7e..3ccaa1043383 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -4,32 +4,53 @@
 #include <assert.h>
 #include <stdio.h>
 
-int cpumap[MAX_NR_CPUS];
-
-static int default_cpu_map(void)
+static struct cpu_map *cpu_map__default_new(void)
 {
-        int nr_cpus, i;
+        struct cpu_map *cpus;
+        int nr_cpus;
 
         nr_cpus = sysconf(_SC_NPROCESSORS_ONLN);
-        assert(nr_cpus <= MAX_NR_CPUS);
-        assert((int)nr_cpus >= 0);
+        if (nr_cpus < 0)
+                return NULL;
+
+        cpus = malloc(sizeof(*cpus) + nr_cpus * sizeof(int));
+        if (cpus != NULL) {
+                int i;
+                for (i = 0; i < nr_cpus; ++i)
+                        cpus->map[i] = i;
 
-        for (i = 0; i < nr_cpus; ++i)
-                cpumap[i] = i;
+                cpus->nr = nr_cpus;
+        }
 
-        return nr_cpus;
+        return cpus;
 }
 
-static int read_all_cpu_map(void)
+static struct cpu_map *cpu_map__trim_new(int nr_cpus, int *tmp_cpus)
 {
+        size_t payload_size = nr_cpus * sizeof(int);
+        struct cpu_map *cpus = malloc(sizeof(*cpus) + payload_size);
+
+        if (cpus != NULL) {
+                cpus->nr = nr_cpus;
+                memcpy(cpus->map, tmp_cpus, payload_size);
+        }
+
+        return cpus;
+}
+
+static struct cpu_map *cpu_map__read_all_cpu_map(void)
+{
+        struct cpu_map *cpus = NULL;
         FILE *onlnf;
         int nr_cpus = 0;
+        int *tmp_cpus = NULL, *tmp;
+        int max_entries = 0;
         int n, cpu, prev;
         char sep;
 
         onlnf = fopen("/sys/devices/system/cpu/online", "r");
         if (!onlnf)
-                return default_cpu_map();
+                return cpu_map__default_new();
 
         sep = 0;
         prev = -1;
@@ -38,12 +59,28 @@ static int read_all_cpu_map(void)
                 if (n <= 0)
                         break;
                 if (prev >= 0) {
-                        assert(nr_cpus + cpu - prev - 1 < MAX_NR_CPUS);
+                        int new_max = nr_cpus + cpu - prev - 1;
+
+                        if (new_max >= max_entries) {
+                                max_entries = new_max + MAX_NR_CPUS / 2;
+                                tmp = realloc(tmp_cpus, max_entries * sizeof(int));
+                                if (tmp == NULL)
+                                        goto out_free_tmp;
+                                tmp_cpus = tmp;
+                        }
+
                         while (++prev < cpu)
-                                cpumap[nr_cpus++] = prev;
+                                tmp_cpus[nr_cpus++] = prev;
+                }
+                if (nr_cpus == max_entries) {
+                        max_entries += MAX_NR_CPUS;
+                        tmp = realloc(tmp_cpus, max_entries * sizeof(int));
+                        if (tmp == NULL)
+                                goto out_free_tmp;
+                        tmp_cpus = tmp;
                 }
-                assert (nr_cpus < MAX_NR_CPUS);
-                cpumap[nr_cpus++] = cpu;
+
+                tmp_cpus[nr_cpus++] = cpu;
                 if (n == 2 && sep == '-')
                         prev = cpu;
                 else
@@ -51,24 +88,31 @@ static int read_all_cpu_map(void)
                 if (n == 1 || sep == '\n')
                         break;
         }
-        fclose(onlnf);
-        if (nr_cpus > 0)
-                return nr_cpus;
 
-        return default_cpu_map();
+        if (nr_cpus > 0)
+                cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
+        else
+                cpus = cpu_map__default_new();
+out_free_tmp:
+        free(tmp_cpus);
+        fclose(onlnf);
+        return cpus;
 }
 
-int read_cpu_map(const char *cpu_list)
+struct cpu_map *cpu_map__new(const char *cpu_list)
 {
+        struct cpu_map *cpus = NULL;
         unsigned long start_cpu, end_cpu = 0;
         char *p = NULL;
         int i, nr_cpus = 0;
+        int *tmp_cpus = NULL, *tmp;
+        int max_entries = 0;
 
         if (!cpu_list)
-                return read_all_cpu_map();
+                return cpu_map__read_all_cpu_map();
 
         if (!isdigit(*cpu_list))
-                goto invalid;
+                goto out;
 
         while (isdigit(*cpu_list)) {
                 p = NULL;
@@ -94,21 +138,42 @@ int read_cpu_map(const char *cpu_list)
                 for (; start_cpu <= end_cpu; start_cpu++) {
                         /* check for duplicates */
                         for (i = 0; i < nr_cpus; i++)
-                                if (cpumap[i] == (int)start_cpu)
+                                if (tmp_cpus[i] == (int)start_cpu)
                                         goto invalid;
 
-                        assert(nr_cpus < MAX_NR_CPUS);
-                        cpumap[nr_cpus++] = (int)start_cpu;
+                        if (nr_cpus == max_entries) {
+                                max_entries += MAX_NR_CPUS;
+                                tmp = realloc(tmp_cpus, max_entries * sizeof(int));
+                                if (tmp == NULL)
+                                        goto invalid;
+                                tmp_cpus = tmp;
+                        }
+                        tmp_cpus[nr_cpus++] = (int)start_cpu;
                 }
                 if (*p)
                         ++p;
 
                 cpu_list = p;
         }
-        if (nr_cpus > 0)
-                return nr_cpus;
 
-        return default_cpu_map();
+        if (nr_cpus > 0)
+                cpus = cpu_map__trim_new(nr_cpus, tmp_cpus);
+        else
+                cpus = cpu_map__default_new();
 invalid:
-        return -1;
+        free(tmp_cpus);
+out:
+        return cpus;
+}
+
+struct cpu_map *cpu_map__dummy_new(void)
+{
+        struct cpu_map *cpus = malloc(sizeof(*cpus) + sizeof(int));
+
+        if (cpus != NULL) {
+                cpus->nr = 1;
+                cpus->map[0] = -1;
+        }
+
+        return cpus;
 }
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 3e60f56e490e..f7a4f42f6307 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -1,7 +1,13 @@
 #ifndef __PERF_CPUMAP_H
 #define __PERF_CPUMAP_H
 
-extern int read_cpu_map(const char *cpu_list);
-extern int cpumap[];
+struct cpu_map {
+        int nr;
+        int map[];
+};
+
+struct cpu_map *cpu_map__new(const char *cpu_list);
+struct cpu_map *cpu_map__dummy_new(void);
+void *cpu_map__delete(struct cpu_map *map);
 
 #endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
new file mode 100644
index 000000000000..c95267e63c5b
--- /dev/null
+++ b/tools/perf/util/evsel.c
@@ -0,0 +1,186 @@
+#include "evsel.h"
+#include "../perf.h"
+#include "util.h"
+#include "cpumap.h"
+#include "thread.h"
+
+#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
+
+struct perf_evsel *perf_evsel__new(u32 type, u64 config, int idx)
+{
+        struct perf_evsel *evsel = zalloc(sizeof(*evsel));
+
+        if (evsel != NULL) {
+                evsel->idx         = idx;
+                evsel->attr.type   = type;
+                evsel->attr.config = config;
+                INIT_LIST_HEAD(&evsel->node);
+        }
+
+        return evsel;
+}
+
+int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
+{
+        evsel->fd = xyarray__new(ncpus, nthreads, sizeof(int));
+        return evsel->fd != NULL ? 0 : -ENOMEM;
+}
+
+int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
+{
+        evsel->counts = zalloc((sizeof(*evsel->counts) +
+                                (ncpus * sizeof(struct perf_counts_values))));
+        return evsel->counts != NULL ? 0 : -ENOMEM;
+}
+
+void perf_evsel__free_fd(struct perf_evsel *evsel)
+{
+        xyarray__delete(evsel->fd);
+        evsel->fd = NULL;
+}
+
+void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
+{
+        int cpu, thread;
+
+        for (cpu = 0; cpu < ncpus; cpu++)
+                for (thread = 0; thread < nthreads; ++thread) {
+                        close(FD(evsel, cpu, thread));
+                        FD(evsel, cpu, thread) = -1;
+                }
+}
+
+void perf_evsel__delete(struct perf_evsel *evsel)
+{
+        assert(list_empty(&evsel->node));
+        xyarray__delete(evsel->fd);
+        free(evsel);
+}
+
+int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
+                              int cpu, int thread, bool scale)
+{
+        struct perf_counts_values count;
+        size_t nv = scale ? 3 : 1;
+
+        if (FD(evsel, cpu, thread) < 0)
+                return -EINVAL;
+
+        if (evsel->counts == NULL && perf_evsel__alloc_counts(evsel, cpu + 1) < 0)
+                return -ENOMEM;
+
+        if (readn(FD(evsel, cpu, thread), &count, nv * sizeof(u64)) < 0)
+                return -errno;
+
+        if (scale) {
+                if (count.run == 0)
+                        count.val = 0;
+                else if (count.run < count.ena)
+                        count.val = (u64)((double)count.val * count.ena / count.run + 0.5);
+        } else
+                count.ena = count.run = 0;
+
+        evsel->counts->cpu[cpu] = count;
+        return 0;
+}
+
+int __perf_evsel__read(struct perf_evsel *evsel,
+                       int ncpus, int nthreads, bool scale)
+{
+        size_t nv = scale ? 3 : 1;
+        int cpu, thread;
+        struct perf_counts_values *aggr = &evsel->counts->aggr, count;
+
+        aggr->val = 0;
+
+        for (cpu = 0; cpu < ncpus; cpu++) {
+                for (thread = 0; thread < nthreads; thread++) {
+                        if (FD(evsel, cpu, thread) < 0)
+                                continue;
+
+                        if (readn(FD(evsel, cpu, thread),
+                                  &count, nv * sizeof(u64)) < 0)
+                                return -errno;
+
+                        aggr->val += count.val;
+                        if (scale) {
+                                aggr->ena += count.ena;
+                                aggr->run += count.run;
+                        }
+                }
+        }
+
+        evsel->counts->scaled = 0;
+        if (scale) {
+                if (aggr->run == 0) {
+                        evsel->counts->scaled = -1;
+                        aggr->val = 0;
+                        return 0;
+                }
+
+                if (aggr->run < aggr->ena) {
+                        evsel->counts->scaled = 1;
+                        aggr->val = (u64)((double)aggr->val * aggr->ena / aggr->run + 0.5);
+                }
+        } else
+                aggr->ena = aggr->run = 0;
+
+        return 0;
+}
+
+int perf_evsel__open_per_cpu(struct perf_evsel *evsel, struct cpu_map *cpus)
+{
+        int cpu;
+
+        if (evsel->fd == NULL && perf_evsel__alloc_fd(evsel, cpus->nr, 1) < 0)
+                return -1;
+
+        for (cpu = 0; cpu < cpus->nr; cpu++) {
+                FD(evsel, cpu, 0) = sys_perf_event_open(&evsel->attr, -1,
+                                                        cpus->map[cpu], -1, 0);
+                if (FD(evsel, cpu, 0) < 0)
+                        goto out_close;
+        }
+
+        return 0;
+
+out_close:
+        while (--cpu >= 0) {
+                close(FD(evsel, cpu, 0));
+                FD(evsel, cpu, 0) = -1;
+        }
+        return -1;
+}
+
+int perf_evsel__open_per_thread(struct perf_evsel *evsel, struct thread_map *threads)
+{
+        int thread;
+
+        if (evsel->fd == NULL && perf_evsel__alloc_fd(evsel, 1, threads->nr))
+                return -1;
+
+        for (thread = 0; thread < threads->nr; thread++) {
+                FD(evsel, 0, thread) = sys_perf_event_open(&evsel->attr,
+                                                           threads->map[thread], -1, -1, 0);
+                if (FD(evsel, 0, thread) < 0)
+                        goto out_close;
+        }
+
+        return 0;
+
+out_close:
+        while (--thread >= 0) {
+                close(FD(evsel, 0, thread));
+                FD(evsel, 0, thread) = -1;
+        }
+        return -1;
+}
+
+int perf_evsel__open(struct perf_evsel *evsel, 
+                     struct cpu_map *cpus, struct thread_map *threads)
+{
+        if (threads == NULL)
+                return perf_evsel__open_per_cpu(evsel, cpus);
+
+        return perf_evsel__open_per_thread(evsel, threads);
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
new file mode 100644
index 000000000000..863d78d5ef1a
--- /dev/null
+++ b/tools/perf/util/evsel.h
@@ -0,0 +1,115 @@
+#ifndef __PERF_EVSEL_H
+#define __PERF_EVSEL_H 1
+
+#include <linux/list.h>
+#include <stdbool.h>
+#include <linux/perf_event.h>
+#include "types.h"
+#include "xyarray.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[];
+};
+
+struct perf_evsel {
+        struct list_head        node;
+        struct perf_event_attr  attr;
+        char                    *filter;
+        struct xyarray          *fd;
+        struct perf_counts      *counts;
+        int                     idx;
+        void                    *priv;
+};
+
+struct cpu_map;
+struct thread_map;
+
+struct perf_evsel *perf_evsel__new(u32 type, u64 config, int idx);
+void perf_evsel__delete(struct perf_evsel *evsel);
+
+int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
+int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus);
+void perf_evsel__free_fd(struct perf_evsel *evsel);
+void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
+
+int perf_evsel__open_per_cpu(struct perf_evsel *evsel, struct cpu_map *cpus);
+int perf_evsel__open_per_thread(struct perf_evsel *evsel, struct thread_map *threads);
+int perf_evsel__open(struct perf_evsel *evsel, 
+                     struct cpu_map *cpus, struct thread_map *threads);
+
+#define perf_evsel__match(evsel, t, c)          \
+        (evsel->attr.type == PERF_TYPE_##t &&   \
+         evsel->attr.config == PERF_COUNT_##c)
+
+int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
+                              int cpu, int thread, bool scale);
+
+/**
+ * perf_evsel__read_on_cpu - Read out the results on a CPU and thread
+ *
+ * @evsel - event selector to read value
+ * @cpu - CPU of interest
+ * @thread - thread of interest
+ */
+static inline int perf_evsel__read_on_cpu(struct perf_evsel *evsel,
+                                          int cpu, int thread)
+{
+        return __perf_evsel__read_on_cpu(evsel, cpu, thread, false);
+}
+
+/**
+ * perf_evsel__read_on_cpu_scaled - Read out the results on a CPU and thread, scaled
+ *
+ * @evsel - event selector to read value
+ * @cpu - CPU of interest
+ * @thread - thread of interest
+ */
+static inline int perf_evsel__read_on_cpu_scaled(struct perf_evsel *evsel,
+                                                 int cpu, int thread)
+{
+        return __perf_evsel__read_on_cpu(evsel, cpu, thread, true);
+}
+
+int __perf_evsel__read(struct perf_evsel *evsel, int ncpus, int nthreads,
+                       bool scale);
+
+/**
+ * perf_evsel__read - Read the aggregate results on all CPUs
+ *
+ * @evsel - event selector to read value
+ * @ncpus - Number of cpus affected, from zero
+ * @nthreads - Number of threads affected, from zero
+ */
+static inline int perf_evsel__read(struct perf_evsel *evsel,
+                                    int ncpus, int nthreads)
+{
+        return __perf_evsel__read(evsel, ncpus, nthreads, false);
+}
+
+/**
+ * perf_evsel__read_scaled - Read the aggregate results on all CPUs, scaled
+ *
+ * @evsel - event selector to read value
+ * @ncpus - Number of cpus affected, from zero
+ * @nthreads - Number of threads affected, from zero
+ */
+static inline int perf_evsel__read_scaled(struct perf_evsel *evsel,
+                                          int ncpus, int nthreads)
+{
+        return __perf_evsel__read(evsel, ncpus, nthreads, true);
+}
+
+#endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 4b8c8397a947..989fa2dee2fd 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -463,7 +463,7 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
 
                 /* Write trace info */
                 trace_sec->offset = lseek(fd, 0, SEEK_CUR);
-                read_tracing_data(fd, attrs, nr_counters);
+                read_tracing_data(fd, &evsel_list);
                 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
         }
 
@@ -606,7 +606,7 @@ int perf_header__write(struct perf_header *self, int fd, bool at_exit)
 static int perf_header__getbuffer64(struct perf_header *self,
                                     int fd, void *buf, size_t size)
 {
-        if (do_read(fd, buf, size) <= 0)
+        if (readn(fd, buf, size) <= 0)
                 return -1;
 
         if (self->needs_swap)
@@ -662,7 +662,7 @@ int perf_file_header__read(struct perf_file_header *self,
 {
         lseek(fd, 0, SEEK_SET);
 
-        if (do_read(fd, self, sizeof(*self)) <= 0 ||
+        if (readn(fd, self, sizeof(*self)) <= 0 ||
             memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
                 return -1;
 
@@ -823,7 +823,7 @@ static int perf_file_header__read_pipe(struct perf_pipe_file_header *self,
                                        struct perf_header *ph, int fd,
                                        bool repipe)
 {
-        if (do_read(fd, self, sizeof(*self)) <= 0 ||
+        if (readn(fd, self, sizeof(*self)) <= 0 ||
             memcmp(&self->magic, __perf_magic, sizeof(self->magic)))
                 return -1;
 
@@ -1133,8 +1133,7 @@ int event__process_event_type(event_t *self,
         return 0;
 }
 
-int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
-                                   int nb_events,
+int event__synthesize_tracing_data(int fd, struct list_head *pattrs,
                                    event__handler_t process,
                                    struct perf_session *session __unused)
 {
@@ -1145,7 +1144,7 @@ int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
         memset(&ev, 0, sizeof(ev));
 
         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
-        size = read_tracing_data_size(fd, pattrs, nb_events);
+        size = read_tracing_data_size(fd, pattrs);
         if (size <= 0)
                 return size;
         aligned_size = ALIGN(size, sizeof(u64));
@@ -1155,7 +1154,7 @@ int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
 
         process(&ev, NULL, session);
 
-        err = read_tracing_data(fd, pattrs, nb_events);
+        err = read_tracing_data(fd, pattrs);
         write_padded(fd, NULL, 0, padding);
 
         return aligned_size;
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 6335965e1f93..33f16be7b72f 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -113,8 +113,7 @@ int event__synthesize_event_types(event__handler_t process,
 int event__process_event_type(event_t *self,
                               struct perf_session *session);
 
-int event__synthesize_tracing_data(int fd, struct perf_event_attr *pattrs,
-                                   int nb_events,
+int event__synthesize_tracing_data(int fd, struct list_head *pattrs,
                                    event__handler_t process,
                                    struct perf_session *session);
 int event__process_tracing_data(event_t *self,
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index c305305a3884..3a142e90d609 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -1,6 +1,7 @@
 #include "../../../include/linux/hw_breakpoint.h"
 #include "util.h"
 #include "../perf.h"
+#include "evsel.h"
 #include "parse-options.h"
 #include "parse-events.h"
 #include "exec_cmd.h"
@@ -12,8 +13,7 @@
 
 int                             nr_counters;
 
-struct perf_event_attr          attrs[MAX_COUNTERS];
-char                            *filters[MAX_COUNTERS];
+LIST_HEAD(evsel_list);
 
 struct event_symbol {
         u8              type;
@@ -266,10 +266,10 @@ static char *event_cache_name(u8 cache_type, u8 cache_op, u8 cache_result)
         return name;
 }
 
-const char *event_name(int counter)
+const char *event_name(struct perf_evsel *evsel)
 {
-        u64 config = attrs[counter].config;
-        int type = attrs[counter].type;
+        u64 config = evsel->attr.config;
+        int type = evsel->attr.type;
 
         return __event_name(type, config);
 }
@@ -814,9 +814,6 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
                         return -1;
 
         for (;;) {
-                if (nr_counters == MAX_COUNTERS)
-                        return -1;
-
                 memset(&attr, 0, sizeof(attr));
                 ret = parse_event_symbols(&str, &attr);
                 if (ret == EVT_FAILED)
@@ -826,8 +823,13 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
                         return -1;
 
                 if (ret != EVT_HANDLED_ALL) {
-                        attrs[nr_counters] = attr;
-                        nr_counters++;
+                        struct perf_evsel *evsel;
+                        evsel = perf_evsel__new(attr.type, attr.config,
+                                                nr_counters);
+                        if (evsel == NULL)
+                                return -1;
+                        list_add_tail(&evsel->node, &evsel_list);
+                        ++nr_counters;
                 }
 
                 if (*str == 0)
@@ -844,21 +846,22 @@ int parse_events(const struct option *opt __used, const char *str, int unset __u
 int parse_filter(const struct option *opt __used, const char *str,
                  int unset __used)
 {
-        int i = nr_counters - 1;
-        int len = strlen(str);
+        struct perf_evsel *last = NULL;
 
-        if (i < 0 || attrs[i].type != PERF_TYPE_TRACEPOINT) {
+        if (!list_empty(&evsel_list))
+                last = list_entry(evsel_list.prev, struct perf_evsel, node);
+
+        if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
                 fprintf(stderr,
                         "-F option should follow a -e tracepoint option\n");
                 return -1;
         }
 
-        filters[i] = malloc(len + 1);
-        if (!filters[i]) {
+        last->filter = strdup(str);
+        if (last->filter == NULL) {
                 fprintf(stderr, "not enough memory to hold filter string\n");
                 return -1;
         }
-        strcpy(filters[i], str);
 
         return 0;
 }
@@ -967,3 +970,26 @@ void print_events(void)
 
         exit(129);
 }
+
+int perf_evsel_list__create_default(void)
+{
+        struct perf_evsel *evsel = perf_evsel__new(PERF_TYPE_HARDWARE,
+                                                   PERF_COUNT_HW_CPU_CYCLES, 0);
+        if (evsel == NULL)
+                return -ENOMEM;
+
+        list_add(&evsel->node, &evsel_list);
+        ++nr_counters;
+        return 0;
+}
+
+void perf_evsel_list__delete(void)
+{
+        struct perf_evsel *pos, *n;
+
+        list_for_each_entry_safe(pos, n, &evsel_list, node) {
+                list_del_init(&pos->node);
+                perf_evsel__delete(pos);
+        }
+        nr_counters = 0;
+}
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index fc4ab3fe877a..0a0abc1d10eb 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -4,6 +4,16 @@
  * Parse symbolic events/counts passed in as options:
  */
 
+#include <linux/perf_event.h>
+
+struct list_head;
+struct perf_evsel;
+
+extern struct list_head evsel_list;
+
+int perf_evsel_list__create_default(void);
+void perf_evsel_list__delete(void);
+
 struct option;
 
 struct tracepoint_path {
@@ -13,14 +23,11 @@ struct tracepoint_path {
 };
 
 extern struct tracepoint_path *tracepoint_id_to_path(u64 config);
-extern bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events);
+extern bool have_tracepoints(struct list_head *evsel_list);
 
 extern int                      nr_counters;
 
-extern struct perf_event_attr attrs[MAX_COUNTERS];
-extern char *filters[MAX_COUNTERS];
-
-extern const char *event_name(int ctr);
+const char *event_name(struct perf_evsel *event);
 extern const char *__event_name(int type, u64 config);
 
 extern int parse_events(const struct option *opt, const char *str, int unset);
@@ -33,5 +40,4 @@ extern void print_events(void);
 extern char debugfs_path[];
 extern int valid_debugfs_mount(const char *debugfs);
 
-
 #endif /* __PERF_PARSE_EVENTS_H */
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 0f7e544544f5..b163dfd6cbc5 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -838,23 +838,6 @@ static struct thread *perf_session__register_idle_thread(struct perf_session *se
         return thread;
 }
 
-int do_read(int fd, void *buf, size_t size)
-{
-        void *buf_start = buf;
-
-        while (size) {
-                int ret = read(fd, buf, size);
-
-                if (ret <= 0)
-                        return ret;
-
-                size -= ret;
-                buf += ret;
-        }
-
-        return buf - buf_start;
-}
-
 #define session_done()  (*(volatile int *)(&session_done))
 volatile int session_done;
 
@@ -872,7 +855,7 @@ static int __perf_session__process_pipe_events(struct perf_session *self,
 
         head = 0;
 more:
-        err = do_read(self->fd, &event, sizeof(struct perf_event_header));
+        err = readn(self->fd, &event, sizeof(struct perf_event_header));
         if (err <= 0) {
                 if (err == 0)
                         goto done;
@@ -892,8 +875,7 @@ more:
         p += sizeof(struct perf_event_header);
 
         if (size - sizeof(struct perf_event_header)) {
-                err = do_read(self->fd, p,
-                              size - sizeof(struct perf_event_header));
+                err = readn(self->fd, p, size - sizeof(struct perf_event_header));
                 if (err <= 0) {
                         if (err == 0) {
                                 pr_err("unexpected end of event stream\n");
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index ffe4b98db8f0..decd83f274fd 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -109,7 +109,6 @@ void mem_bswap_64(void *src, int byte_size);
 
 int perf_session__create_kernel_maps(struct perf_session *self);
 
-int do_read(int fd, void *buf, size_t size);
 void perf_session__update_sample_type(struct perf_session *self);
 void perf_session__set_sample_id_all(struct perf_session *session, bool value);
 void perf_session__set_sample_type(struct perf_session *session, u64 type);
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 8c72d888e449..00f4eade2e3e 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -16,35 +16,50 @@ static int filter(const struct dirent *dir)
                 return 1;
 }
 
-int find_all_tid(int pid, pid_t ** all_tid)
+struct thread_map *thread_map__new_by_pid(pid_t pid)
 {
+        struct thread_map *threads;
         char name[256];
         int items;
         struct dirent **namelist = NULL;
-        int ret = 0;
         int i;
 
         sprintf(name, "/proc/%d/task", pid);
         items = scandir(name, &namelist, filter, NULL);
         if (items <= 0)
-                return -ENOENT;
-        *all_tid = malloc(sizeof(pid_t) * items);
-        if (!*all_tid) {
-                ret = -ENOMEM;
-                goto failure;
-        }
-
-        for (i = 0; i < items; i++)
-                (*all_tid)[i] = atoi(namelist[i]->d_name);
+                return NULL;
 
-        ret = items;
+        threads = malloc(sizeof(*threads) + sizeof(pid_t) * items);
+        if (threads != NULL) {
+                for (i = 0; i < items; i++)
+                        threads->map[i] = atoi(namelist[i]->d_name);
+                threads->nr = items;
+        }
 
-failure:
         for (i=0; i<items; i++)
                 free(namelist[i]);
         free(namelist);
 
-        return ret;
+        return threads;
+}
+
+struct thread_map *thread_map__new_by_tid(pid_t tid)
+{
+        struct thread_map *threads = malloc(sizeof(*threads) + sizeof(pid_t));
+
+        if (threads != NULL) {
+                threads->map[0] = tid;
+                threads->nr     = 1;
+        }
+
+        return threads;
+}
+
+struct thread_map *thread_map__new(pid_t pid, pid_t tid)
+{
+        if (pid != -1)
+                return thread_map__new_by_pid(pid);
+        return thread_map__new_by_tid(tid);
 }
 
 static struct thread *thread__new(pid_t pid)
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 688500ff826f..d7574101054a 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -18,11 +18,24 @@ struct thread {
         int                     comm_len;
 };
 
+struct thread_map {
+        int nr;
+        int map[];
+};
+
 struct perf_session;
 
 void thread__delete(struct thread *self);
 
-int find_all_tid(int pid, pid_t ** all_tid);
+struct thread_map *thread_map__new_by_pid(pid_t pid);
+struct thread_map *thread_map__new_by_tid(pid_t tid);
+struct thread_map *thread_map__new(pid_t pid, pid_t tid);
+
+static inline void thread_map__delete(struct thread_map *threads)
+{
+        free(threads);
+}
+
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
 struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
diff --git a/tools/perf/util/trace-event-info.c b/tools/perf/util/trace-event-info.c
index b1572601286c..35729f4c40cb 100644
--- a/tools/perf/util/trace-event-info.c
+++ b/tools/perf/util/trace-event-info.c
@@ -34,11 +34,13 @@
 #include <ctype.h>
 #include <errno.h>
 #include <stdbool.h>
+#include <linux/list.h>
 #include <linux/kernel.h>
 
 #include "../perf.h"
 #include "trace-event.h"
 #include "debugfs.h"
+#include "evsel.h"
 
 #define VERSION "0.5"
 
@@ -469,16 +471,17 @@ out:
 }
 
 static struct tracepoint_path *
-get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
+get_tracepoints_path(struct list_head *pattrs)
 {
         struct tracepoint_path path, *ppath = &path;
-        int i, nr_tracepoints = 0;
+        struct perf_evsel *pos;
+        int nr_tracepoints = 0;
 
-        for (i = 0; i < nb_events; i++) {
-                if (pattrs[i].type != PERF_TYPE_TRACEPOINT)
+        list_for_each_entry(pos, pattrs, node) {
+                if (pos->attr.type != PERF_TYPE_TRACEPOINT)
                         continue;
                 ++nr_tracepoints;
-                ppath->next = tracepoint_id_to_path(pattrs[i].config);
+                ppath->next = tracepoint_id_to_path(pos->attr.config);
                 if (!ppath->next)
                         die("%s\n", "No memory to alloc tracepoints list");
                 ppath = ppath->next;
@@ -487,21 +490,21 @@ get_tracepoints_path(struct perf_event_attr *pattrs, int nb_events)
         return nr_tracepoints > 0 ? path.next : NULL;
 }
 
-bool have_tracepoints(struct perf_event_attr *pattrs, int nb_events)
+bool have_tracepoints(struct list_head *pattrs)
 {
-        int i;
+        struct perf_evsel *pos;
 
-        for (i = 0; i < nb_events; i++)
-                if (pattrs[i].type == PERF_TYPE_TRACEPOINT)
+        list_for_each_entry(pos, pattrs, node)
+                if (pos->attr.type == PERF_TYPE_TRACEPOINT)
                         return true;
 
         return false;
 }
 
-int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
+int read_tracing_data(int fd, struct list_head *pattrs)
 {
         char buf[BUFSIZ];
-        struct tracepoint_path *tps = get_tracepoints_path(pattrs, nb_events);
+        struct tracepoint_path *tps = get_tracepoints_path(pattrs);
 
         /*
          * What? No tracepoints? No sense writing anything here, bail out.
@@ -545,14 +548,13 @@ int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events)
         return 0;
 }
 
-ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
-                               int nb_events)
+ssize_t read_tracing_data_size(int fd, struct list_head *pattrs)
 {
         ssize_t size;
         int err = 0;
 
         calc_data_size = 1;
-        err = read_tracing_data(fd, pattrs, nb_events);
+        err = read_tracing_data(fd, pattrs);
         size = calc_data_size - 1;
         calc_data_size = 0;
 
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index b3e86b1e4444..b5f12ca24d99 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -262,9 +262,8 @@ raw_field_value(struct event *event, const char *name, void *data);
 void *raw_field_ptr(struct event *event, const char *name, void *data);
 unsigned long long eval_flag(const char *flag);
 
-int read_tracing_data(int fd, struct perf_event_attr *pattrs, int nb_events);
-ssize_t read_tracing_data_size(int fd, struct perf_event_attr *pattrs,
-                               int nb_events);
+int read_tracing_data(int fd, struct list_head *pattrs);
+ssize_t read_tracing_data_size(int fd, struct list_head *pattrs);
 
 /* taken from kernel/trace/trace.h */
 enum trace_flag_type {
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index 214265674ddd..5b3ea49aa63e 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -114,3 +114,20 @@ unsigned long convert_unit(unsigned long value, char *unit)
 
         return value;
 }
+
+int readn(int fd, void *buf, size_t n)
+{
+        void *buf_start = buf;
+
+        while (n) {
+                int ret = read(fd, buf, n);
+
+                if (ret <= 0)
+                        return ret;
+
+                n -= ret;
+                buf += ret;
+        }
+
+        return buf - buf_start;
+}
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 7562707ddd1c..e833f26f3bfc 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -265,6 +265,7 @@ void argv_free(char **argv);
 bool strglobmatch(const char *str, const char *pat);
 bool strlazymatch(const char *str, const char *pat);
 unsigned long convert_unit(unsigned long value, char *unit);
+int readn(int fd, void *buf, size_t size);
 
 #define _STR(x) #x
 #define STR(x) _STR(x)
diff --git a/tools/perf/util/xyarray.c b/tools/perf/util/xyarray.c
new file mode 100644
index 000000000000..22afbf6c536a
--- /dev/null
+++ b/tools/perf/util/xyarray.c
@@ -0,0 +1,20 @@
+#include "xyarray.h"
+#include "util.h"
+
+struct xyarray *xyarray__new(int xlen, int ylen, size_t entry_size)
+{
+        size_t row_size = ylen * entry_size;
+        struct xyarray *xy = zalloc(sizeof(*xy) + xlen * row_size);
+
+        if (xy != NULL) {
+                xy->entry_size = entry_size;
+                xy->row_size   = row_size;
+        }
+
+        return xy;
+}
+
+void xyarray__delete(struct xyarray *xy)
+{
+        free(xy);
+}
diff --git a/tools/perf/util/xyarray.h b/tools/perf/util/xyarray.h
new file mode 100644
index 000000000000..c488a07275dd
--- /dev/null
+++ b/tools/perf/util/xyarray.h
@@ -0,0 +1,20 @@
+#ifndef _PERF_XYARRAY_H_
+#define _PERF_XYARRAY_H_ 1
+
+#include <sys/types.h>
+
+struct xyarray {
+        size_t row_size;
+        size_t entry_size;
+        char contents[];
+};
+
+struct xyarray *xyarray__new(int xlen, int ylen, size_t entry_size);
+void xyarray__delete(struct xyarray *xy);
+
+static inline void *xyarray__entry(struct xyarray *xy, int x, int y)
+{
+        return &xy->contents[x * xy->row_size + y * xy->entry_size];
+}
+
+#endif /* _PERF_XYARRAY_H_ */