10 files changed, 138 insertions, 124 deletions

diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index b2f729fdb317..60cac6f92e8b 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -759,8 +759,8 @@ static int __cmd_record(int argc, const char **argv)
                 perf_session__process_machines(session, event__synthesize_guest_os);
 
         if (!system_wide)
-                event__synthesize_thread(target_tid, process_synthesized_event,
-                                         session);
+                event__synthesize_thread_map(threads, process_synthesized_event,
+                                             session);
         else
                 event__synthesize_threads(process_synthesized_event, session);
 
diff --git a/tools/perf/builtin-timechart.c b/tools/perf/builtin-timechart.c
index 746cf03cb05d..0ace786e83e0 100644
--- a/tools/perf/builtin-timechart.c
+++ b/tools/perf/builtin-timechart.c
@@ -264,9 +264,6 @@ pid_put_sample(int pid, int type, unsigned int cpu, u64 start, u64 end)
                 c->start_time = start;
         if (p->start_time == 0 || p->start_time > start)
                 p->start_time = start;
-
-        if (cpu > numcpus)
-                numcpus = cpu;
 }
 
 #define MAX_CPUS 4096
@@ -511,6 +508,9 @@ static int process_sample_event(event_t *event __used,
                 if (!event_str)
                         return 0;
 
+                if (sample->cpu > numcpus)
+                        numcpus = sample->cpu;
+
                 if (strcmp(event_str, "power:cpu_idle") == 0) {
                         struct power_processor_entry *ppe = (void *)te;
                         if (ppe->state == (u32)PWR_EVENT_EXIT)
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index b6998e055767..5a29d9cd9486 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -1306,7 +1306,7 @@ static int __cmd_top(void)
                 return -ENOMEM;
 
         if (target_tid != -1)
-                event__synthesize_thread(target_tid, event__process, session);
+                event__synthesize_thread_map(threads, event__process, session);
         else
                 event__synthesize_threads(event__process, session);
 
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 1478ab4ee222..50d0a931497a 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -263,11 +263,12 @@ static int __event__synthesize_thread(event_t *comm_event, event_t *mmap_event,
                                              process, session);
 }
 
-int event__synthesize_thread(pid_t pid, event__handler_t process,
-                             struct perf_session *session)
+int event__synthesize_thread_map(struct thread_map *threads,
+                                 event__handler_t process,
+                                 struct perf_session *session)
 {
         event_t *comm_event, *mmap_event;
-        int err = -1;
+        int err = -1, thread;
 
         comm_event = malloc(sizeof(comm_event->comm) + session->id_hdr_size);
         if (comm_event == NULL)
@@ -277,8 +278,15 @@ int event__synthesize_thread(pid_t pid, event__handler_t process,
         if (mmap_event == NULL)
                 goto out_free_comm;
 
-        err = __event__synthesize_thread(comm_event, mmap_event, pid,
-                                         process, session);
+        err = 0;
+        for (thread = 0; thread < threads->nr; ++thread) {
+                if (__event__synthesize_thread(comm_event, mmap_event,
+                                               threads->map[thread],
+                                               process, session)) {
+                        err = -1;
+                        break;
+                }
+        }
         free(mmap_event);
 out_free_comm:
         free(comm_event);
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 2b7e91902f10..cc7b52f9b492 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -135,14 +135,16 @@ typedef union event_union {
 void event__print_totals(void);
 
 struct perf_session;
+struct thread_map;
 
 typedef int (*event__handler_synth_t)(event_t *event, 
                                       struct perf_session *session);
 typedef int (*event__handler_t)(event_t *event, struct sample_data *sample,
                                 struct perf_session *session);
 
-int event__synthesize_thread(pid_t pid, event__handler_t process,
-                             struct perf_session *session);
+int event__synthesize_thread_map(struct thread_map *threads,
+                                 event__handler_t process,
+                                 struct perf_session *session);
 int event__synthesize_threads(event__handler_t process,
                               struct perf_session *session);
 int event__synthesize_kernel_mmap(event__handler_t process,
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index f6a929e74981..0866bcdb5e8e 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -270,11 +270,15 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                           const char *name, bool is_kallsyms)
 {
         const size_t size = PATH_MAX;
-        char *realname = realpath(name, NULL),
-             *filename = malloc(size),
+        char *realname, *filename = malloc(size),
              *linkname = malloc(size), *targetname;
         int len, err = -1;
 
+        if (is_kallsyms)
+                realname = (char *)name;
+        else
+                realname = realpath(name, NULL);
+
         if (realname == NULL || filename == NULL || linkname == NULL)
                 goto out_free;
 
@@ -306,7 +310,8 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
         if (symlink(targetname, linkname) == 0)
                 err = 0;
 out_free:
-        free(realname);
+        if (!is_kallsyms)
+                free(realname);
         free(filename);
         free(linkname);
         return err;
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 32f4f1f2f6e4..df51560f16f7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -585,6 +585,7 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
 {
         struct sort_entry *se;
         u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
+        u64 nr_events;
         const char *sep = symbol_conf.field_sep;
         int ret;
 
@@ -593,6 +594,7 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
 
         if (pair_hists) {
                 period = self->pair ? self->pair->period : 0;
+                nr_events = self->pair ? self->pair->nr_events : 0;
                 total = pair_hists->stats.total_period;
                 period_sys = self->pair ? self->pair->period_sys : 0;
                 period_us = self->pair ? self->pair->period_us : 0;
@@ -600,6 +602,7 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
                 period_guest_us = self->pair ? self->pair->period_guest_us : 0;
         } else {
                 period = self->period;
+                nr_events = self->nr_events;
                 total = session_total;
                 period_sys = self->period_sys;
                 period_us = self->period_us;
@@ -640,9 +643,9 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
 
         if (symbol_conf.show_nr_samples) {
                 if (sep)
-                        ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
+                        ret += snprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
                 else
-                        ret += snprintf(s + ret, size - ret, "%11" PRIu64, period);
+                        ret += snprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
         }
 
         if (pair_hists) {
diff --git a/tools/perf/util/svghelper.c b/tools/perf/util/svghelper.c
index fb737fe9be91..96c866045d60 100644
--- a/tools/perf/util/svghelper.c
+++ b/tools/perf/util/svghelper.c
@@ -456,9 +456,9 @@ void svg_legenda(void)
                 return;
 
         svg_legenda_box(0,      "Running", "sample");
-        svg_legenda_box(100,    "Idle","rect.c1");
-        svg_legenda_box(200,    "Deeper Idle", "rect.c3");
-        svg_legenda_box(350,    "Deepest Idle", "rect.c6");
+        svg_legenda_box(100,    "Idle","c1");
+        svg_legenda_box(200,    "Deeper Idle", "c3");
+        svg_legenda_box(350,    "Deepest Idle", "c6");
         svg_legenda_box(550,    "Sleeping", "process2");
         svg_legenda_box(650,    "Waiting for cpu", "waiting");
         svg_legenda_box(800,    "Blocked on IO", "blocked");
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 7821d0e6866f..b1bf490aff88 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -1836,7 +1836,7 @@ int dso__load_vmlinux(struct dso *self, struct map *map,
         int err = -1, fd;
         char symfs_vmlinux[PATH_MAX];
 
-        snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s/%s",
+        snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
                  symbol_conf.symfs, vmlinux);
         fd = open(symfs_vmlinux, O_RDONLY);
         if (fd < 0)
diff --git a/tools/power/x86/turbostat/turbostat.c b/tools/power/x86/turbostat/turbostat.c
index 4c6983de6fd9..362a0cb448db 100644
--- a/tools/power/x86/turbostat/turbostat.c
+++ b/tools/power/x86/turbostat/turbostat.c
@@ -72,7 +72,7 @@ int need_reinitialize;
 
 int num_cpus;
 
-typedef struct per_cpu_counters {
+struct counters {
         unsigned long long tsc;         /* per thread */
         unsigned long long aperf;       /* per thread */
         unsigned long long mperf;       /* per thread */
@@ -88,13 +88,13 @@ typedef struct per_cpu_counters {
         int pkg;
         int core;
         int cpu;
-        struct per_cpu_counters *next;
-} PCC;
+        struct counters *next;
+};
 
-PCC *pcc_even;
-PCC *pcc_odd;
-PCC *pcc_delta;
-PCC *pcc_average;
+struct counters *cnt_even;
+struct counters *cnt_odd;
+struct counters *cnt_delta;
+struct counters *cnt_average;
 struct timeval tv_even;
 struct timeval tv_odd;
 struct timeval tv_delta;
@@ -125,7 +125,7 @@ unsigned long long get_msr(int cpu, off_t offset)
         return msr;
 }
 
-void print_header()
+void print_header(void)
 {
         if (show_pkg)
                 fprintf(stderr, "pkg ");
@@ -160,39 +160,39 @@ void print_header()
         putc('\n', stderr);
 }
 
-void dump_pcc(PCC *pcc)
+void dump_cnt(struct counters *cnt)
 {
-        fprintf(stderr, "package: %d ", pcc->pkg);
-        fprintf(stderr, "core:: %d ", pcc->core);
-        fprintf(stderr, "CPU: %d ", pcc->cpu);
-        fprintf(stderr, "TSC: %016llX\n", pcc->tsc);
-        fprintf(stderr, "c3: %016llX\n", pcc->c3);
-        fprintf(stderr, "c6: %016llX\n", pcc->c6);
-        fprintf(stderr, "c7: %016llX\n", pcc->c7);
-        fprintf(stderr, "aperf: %016llX\n", pcc->aperf);
-        fprintf(stderr, "pc2: %016llX\n", pcc->pc2);
-        fprintf(stderr, "pc3: %016llX\n", pcc->pc3);
-        fprintf(stderr, "pc6: %016llX\n", pcc->pc6);
-        fprintf(stderr, "pc7: %016llX\n", pcc->pc7);
-        fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, pcc->extra_msr);
+        fprintf(stderr, "package: %d ", cnt->pkg);
+        fprintf(stderr, "core:: %d ", cnt->core);
+        fprintf(stderr, "CPU: %d ", cnt->cpu);
+        fprintf(stderr, "TSC: %016llX\n", cnt->tsc);
+        fprintf(stderr, "c3: %016llX\n", cnt->c3);
+        fprintf(stderr, "c6: %016llX\n", cnt->c6);
+        fprintf(stderr, "c7: %016llX\n", cnt->c7);
+        fprintf(stderr, "aperf: %016llX\n", cnt->aperf);
+        fprintf(stderr, "pc2: %016llX\n", cnt->pc2);
+        fprintf(stderr, "pc3: %016llX\n", cnt->pc3);
+        fprintf(stderr, "pc6: %016llX\n", cnt->pc6);
+        fprintf(stderr, "pc7: %016llX\n", cnt->pc7);
+        fprintf(stderr, "msr0x%x: %016llX\n", extra_msr_offset, cnt->extra_msr);
 }
 
-void dump_list(PCC *pcc)
+void dump_list(struct counters *cnt)
 {
-        printf("dump_list 0x%p\n", pcc);
+        printf("dump_list 0x%p\n", cnt);
 
-        for (; pcc; pcc = pcc->next)
-                dump_pcc(pcc);
+        for (; cnt; cnt = cnt->next)
+                dump_cnt(cnt);
 }
 
-void print_pcc(PCC *p)
+void print_cnt(struct counters *p)
 {
         double interval_float;
 
         interval_float = tv_delta.tv_sec + tv_delta.tv_usec/1000000.0;
 
         /* topology columns, print blanks on 1st (average) line */
-        if (p == pcc_average) {
+        if (p == cnt_average) {
                 if (show_pkg)
                         fprintf(stderr, "    ");
                 if (show_core)
@@ -262,24 +262,24 @@ void print_pcc(PCC *p)
         putc('\n', stderr);
 }
 
-void print_counters(PCC *cnt)
+void print_counters(struct counters *counters)
 {
-        PCC *pcc;
+        struct counters *cnt;
 
         print_header();
 
         if (num_cpus > 1)
-                print_pcc(pcc_average);
+                print_cnt(cnt_average);
 
-        for (pcc = cnt; pcc != NULL; pcc = pcc->next)
-                print_pcc(pcc);
+        for (cnt = counters; cnt != NULL; cnt = cnt->next)
+                print_cnt(cnt);
 
 }
 
 #define SUBTRACT_COUNTER(after, before, delta) (delta = (after - before), (before > after))
 
-
-int compute_delta(PCC *after, PCC *before, PCC *delta)
+int compute_delta(struct counters *after,
+        struct counters *before, struct counters *delta)
 {
         int errors = 0;
         int perf_err = 0;
@@ -391,20 +391,20 @@ int compute_delta(PCC *after, PCC *before, PCC *delta)
                 delta->extra_msr = after->extra_msr;
                 if (errors) {
                         fprintf(stderr, "ERROR cpu%d before:\n", before->cpu);
-                        dump_pcc(before);
+                        dump_cnt(before);
                         fprintf(stderr, "ERROR cpu%d after:\n", before->cpu);
-                        dump_pcc(after);
+                        dump_cnt(after);
                         errors = 0;
                 }
         }
         return 0;
 }
 
-void compute_average(PCC *delta, PCC *avg)
+void compute_average(struct counters *delta, struct counters *avg)
 {
-        PCC *sum;
+        struct counters *sum;
 
-        sum = calloc(1, sizeof(PCC));
+        sum = calloc(1, sizeof(struct counters));
         if (sum == NULL) {
                 perror("calloc sum");
                 exit(1);
@@ -438,35 +438,34 @@ void compute_average(PCC *delta, PCC *avg)
         free(sum);
 }
 
-void get_counters(PCC *pcc)
+void get_counters(struct counters *cnt)
 {
-        for ( ; pcc; pcc = pcc->next) {
-                pcc->tsc = get_msr(pcc->cpu, MSR_TSC);
+        for ( ; cnt; cnt = cnt->next) {
+                cnt->tsc = get_msr(cnt->cpu, MSR_TSC);
                 if (do_nhm_cstates)
-                        pcc->c3 = get_msr(pcc->cpu, MSR_CORE_C3_RESIDENCY);
+                        cnt->c3 = get_msr(cnt->cpu, MSR_CORE_C3_RESIDENCY);
                 if (do_nhm_cstates)
-                        pcc->c6 = get_msr(pcc->cpu, MSR_CORE_C6_RESIDENCY);
+                        cnt->c6 = get_msr(cnt->cpu, MSR_CORE_C6_RESIDENCY);
                 if (do_snb_cstates)
-                        pcc->c7 = get_msr(pcc->cpu, MSR_CORE_C7_RESIDENCY);
+                        cnt->c7 = get_msr(cnt->cpu, MSR_CORE_C7_RESIDENCY);
                 if (has_aperf)
-                        pcc->aperf = get_msr(pcc->cpu, MSR_APERF);
+                        cnt->aperf = get_msr(cnt->cpu, MSR_APERF);
                 if (has_aperf)
-                        pcc->mperf = get_msr(pcc->cpu, MSR_MPERF);
+                        cnt->mperf = get_msr(cnt->cpu, MSR_MPERF);
                 if (do_snb_cstates)
-                        pcc->pc2 = get_msr(pcc->cpu, MSR_PKG_C2_RESIDENCY);
+                        cnt->pc2 = get_msr(cnt->cpu, MSR_PKG_C2_RESIDENCY);
                 if (do_nhm_cstates)
-                        pcc->pc3 = get_msr(pcc->cpu, MSR_PKG_C3_RESIDENCY);
+                        cnt->pc3 = get_msr(cnt->cpu, MSR_PKG_C3_RESIDENCY);
                 if (do_nhm_cstates)
-                        pcc->pc6 = get_msr(pcc->cpu, MSR_PKG_C6_RESIDENCY);
+                        cnt->pc6 = get_msr(cnt->cpu, MSR_PKG_C6_RESIDENCY);
                 if (do_snb_cstates)
-                        pcc->pc7 = get_msr(pcc->cpu, MSR_PKG_C7_RESIDENCY);
+                        cnt->pc7 = get_msr(cnt->cpu, MSR_PKG_C7_RESIDENCY);
                 if (extra_msr_offset)
-                        pcc->extra_msr = get_msr(pcc->cpu, extra_msr_offset);
+                        cnt->extra_msr = get_msr(cnt->cpu, extra_msr_offset);
         }
 }
 
-
-void print_nehalem_info()
+void print_nehalem_info(void)
 {
         unsigned long long msr;
         unsigned int ratio;
@@ -514,38 +513,38 @@ void print_nehalem_info()
 
 }
 
-void free_counter_list(PCC *list)
+void free_counter_list(struct counters *list)
 {
-        PCC *p;
+        struct counters *p;
 
         for (p = list; p; ) {
-                PCC *free_me;
+                struct counters *free_me;
 
                 free_me = p;
                 p = p->next;
                 free(free_me);
         }
-        return;
 }
 
 void free_all_counters(void)
 {
-        free_counter_list(pcc_even);
-        pcc_even = NULL;
+        free_counter_list(cnt_even);
+        cnt_even = NULL;
 
-        free_counter_list(pcc_odd);
-        pcc_odd = NULL;
+        free_counter_list(cnt_odd);
+        cnt_odd = NULL;
 
-        free_counter_list(pcc_delta);
-        pcc_delta = NULL;
+        free_counter_list(cnt_delta);
+        cnt_delta = NULL;
 
-        free_counter_list(pcc_average);
-        pcc_average = NULL;
+        free_counter_list(cnt_average);
+        cnt_average = NULL;
 }
 
-void insert_cpu_counters(PCC **list, PCC *new)
+void insert_counters(struct counters **list,
+        struct counters *new)
 {
-        PCC *prev;
+        struct counters *prev;
 
         /*
          * list was empty
@@ -594,18 +593,16 @@ void insert_cpu_counters(PCC **list, PCC *new)
          */
         new->next = prev->next;
         prev->next = new;
-
-        return;
 }
 
-void alloc_new_cpu_counters(int pkg, int core, int cpu)
+void alloc_new_counters(int pkg, int core, int cpu)
 {
-        PCC *new;
+        struct counters *new;
 
         if (verbose > 1)
                 printf("pkg%d core%d, cpu%d\n", pkg, core, cpu);
 
-        new = (PCC *)calloc(1, sizeof(PCC));
+        new = (struct counters *)calloc(1, sizeof(struct counters));
         if (new == NULL) {
                 perror("calloc");
                 exit(1);
@@ -613,9 +610,10 @@ void alloc_new_cpu_counters(int pkg, int core, int cpu)
         new->pkg = pkg;
         new->core = core;
         new->cpu = cpu;
-        insert_cpu_counters(&pcc_odd, new);
+        insert_counters(&cnt_odd, new);
 
-        new = (PCC *)calloc(1, sizeof(PCC));
+        new = (struct counters *)calloc(1,
+                sizeof(struct counters));
         if (new == NULL) {
                 perror("calloc");
                 exit(1);
@@ -623,9 +621,9 @@ void alloc_new_cpu_counters(int pkg, int core, int cpu)
         new->pkg = pkg;
         new->core = core;
         new->cpu = cpu;
-        insert_cpu_counters(&pcc_even, new);
+        insert_counters(&cnt_even, new);
 
-        new = (PCC *)calloc(1, sizeof(PCC));
+        new = (struct counters *)calloc(1, sizeof(struct counters));
         if (new == NULL) {
                 perror("calloc");
                 exit(1);
@@ -633,9 +631,9 @@ void alloc_new_cpu_counters(int pkg, int core, int cpu)
         new->pkg = pkg;
         new->core = core;
         new->cpu = cpu;
-        insert_cpu_counters(&pcc_delta, new);
+        insert_counters(&cnt_delta, new);
 
-        new = (PCC *)calloc(1, sizeof(PCC));
+        new = (struct counters *)calloc(1, sizeof(struct counters));
         if (new == NULL) {
                 perror("calloc");
                 exit(1);
@@ -643,7 +641,7 @@ void alloc_new_cpu_counters(int pkg, int core, int cpu)
         new->pkg = pkg;
         new->core = core;
         new->cpu = cpu;
-        pcc_average = new;
+        cnt_average = new;
 }
 
 int get_physical_package_id(int cpu)
@@ -719,7 +717,7 @@ void re_initialize(void)
 {
         printf("turbostat: topology changed, re-initializing.\n");
         free_all_counters();
-        num_cpus = for_all_cpus(alloc_new_cpu_counters);
+        num_cpus = for_all_cpus(alloc_new_counters);
         need_reinitialize = 0;
         printf("num_cpus is now %d\n", num_cpus);
 }
@@ -728,7 +726,7 @@ void dummy(int pkg, int core, int cpu) { return; }
 /*
  * check to see if a cpu came on-line
  */
-void verify_num_cpus()
+void verify_num_cpus(void)
 {
         int new_num_cpus;
 
@@ -740,14 +738,12 @@ void verify_num_cpus()
                                 num_cpus, new_num_cpus);
                 need_reinitialize = 1;
         }
-
-        return;
 }
 
 void turbostat_loop()
 {
 restart:
-        get_counters(pcc_even);
+        get_counters(cnt_even);
         gettimeofday(&tv_even, (struct timezone *)NULL);
 
         while (1) {
@@ -757,24 +753,24 @@ restart:
                         goto restart;
                 }
                 sleep(interval_sec);
-                get_counters(pcc_odd);
+                get_counters(cnt_odd);
                 gettimeofday(&tv_odd, (struct timezone *)NULL);
 
-                compute_delta(pcc_odd, pcc_even, pcc_delta);
+                compute_delta(cnt_odd, cnt_even, cnt_delta);
                 timersub(&tv_odd, &tv_even, &tv_delta);
-                compute_average(pcc_delta, pcc_average);
-                print_counters(pcc_delta);
+                compute_average(cnt_delta, cnt_average);
+                print_counters(cnt_delta);
                 if (need_reinitialize) {
                         re_initialize();
                         goto restart;
                 }
                 sleep(interval_sec);
-                get_counters(pcc_even);
+                get_counters(cnt_even);
                 gettimeofday(&tv_even, (struct timezone *)NULL);
-                compute_delta(pcc_even, pcc_odd, pcc_delta);
+                compute_delta(cnt_even, cnt_odd, cnt_delta);
                 timersub(&tv_even, &tv_odd, &tv_delta);
-                compute_average(pcc_delta, pcc_average);
-                print_counters(pcc_delta);
+                compute_average(cnt_delta, cnt_average);
+                print_counters(cnt_delta);
         }
 }
 
@@ -892,7 +888,7 @@ void check_cpuid()
          * this check is valid for both Intel and AMD
          */
         asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x80000007));
-        has_invariant_tsc = edx && (1 << 8);
+        has_invariant_tsc = edx & (1 << 8);
 
         if (!has_invariant_tsc) {
                 fprintf(stderr, "No invariant TSC\n");
@@ -905,7 +901,7 @@ void check_cpuid()
          */
 
         asm("cpuid" : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) : "a" (0x6));
-        has_aperf = ecx && (1 << 0);
+        has_aperf = ecx & (1 << 0);
         if (!has_aperf) {
                 fprintf(stderr, "No APERF MSR\n");
                 exit(1);
@@ -952,7 +948,7 @@ void turbostat_init()
         check_dev_msr();
         check_super_user();
 
-        num_cpus = for_all_cpus(alloc_new_cpu_counters);
+        num_cpus = for_all_cpus(alloc_new_counters);
 
         if (verbose)
                 print_nehalem_info();
@@ -962,7 +958,7 @@ int fork_it(char **argv)
 {
         int retval;
         pid_t child_pid;
-        get_counters(pcc_even);
+        get_counters(cnt_even);
         gettimeofday(&tv_even, (struct timezone *)NULL);
 
         child_pid = fork();
@@ -985,14 +981,14 @@ int fork_it(char **argv)
                         exit(1);
                 }
         }
-        get_counters(pcc_odd);
+        get_counters(cnt_odd);
         gettimeofday(&tv_odd, (struct timezone *)NULL);
-        retval = compute_delta(pcc_odd, pcc_even, pcc_delta);
+        retval = compute_delta(cnt_odd, cnt_even, cnt_delta);
 
         timersub(&tv_odd, &tv_even, &tv_delta);
-        compute_average(pcc_delta, pcc_average);
+        compute_average(cnt_delta, cnt_average);
         if (!retval)
-                print_counters(pcc_delta);
+                print_counters(cnt_delta);
 
         fprintf(stderr, "%.6f sec\n", tv_delta.tv_sec + tv_delta.tv_usec/1000000.0);;