u64 val;
 
        if (!evsel->stats)
-               perf_evlist__alloc_stats(script->session->evlist, false);
+               evlist__alloc_stats(script->session->evlist, false);
        if (evsel_script(evsel->leader)->gnum++ == 0)
                perf_stat__reset_shadow_stats();
        val = sample->period * evsel->scale;
 
        perf_evlist__set_maps(&evlist->core, script->cpus, script->threads);
 
-       if (perf_evlist__alloc_stats(evlist, true))
+       if (evlist__alloc_stats(evlist, true))
                return -ENOMEM;
 
        script->allocated = true;
                zfree(&script.ptime_range);
        }
 
-       perf_evlist__free_stats(session->evlist);
+       evlist__free_stats(session->evlist);
        perf_session__delete(session);
 
        if (script_started)
 
 {
        int i;
 
-       perf_evlist__reset_stats(evsel_list);
+       evlist__reset_stats(evsel_list);
        perf_stat__reset_shadow_stats();
 
        for (i = 0; i < stat_config.stats_num; i++)
                update_stats(&walltime_nsecs_stats, t1 - t0);
 
                if (stat_config.aggr_mode == AGGR_GLOBAL)
-                       perf_evlist__save_aggr_prev_raw_counts(evsel_list);
+                       evlist__save_aggr_prev_raw_counts(evsel_list);
 
-               perf_evlist__copy_prev_raw_counts(evsel_list);
-               perf_evlist__reset_prev_raw_counts(evsel_list);
+               evlist__copy_prev_raw_counts(evsel_list);
+               evlist__reset_prev_raw_counts(evsel_list);
                runtime_stat_reset(&stat_config);
                perf_stat__reset_shadow_per_stat(&rt_stat);
        } else
 
        perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads);
 
-       if (perf_evlist__alloc_stats(evsel_list, true))
+       if (evlist__alloc_stats(evsel_list, true))
                return -ENOMEM;
 
        st->maps_allocated = true;
                goto out;
        }
 
-       if (perf_evlist__alloc_stats(evsel_list, interval))
+       if (evlist__alloc_stats(evsel_list, interval))
                goto out;
 
        if (perf_stat_init_aggr_mode())
                                run_idx + 1);
 
                if (run_idx != 0)
-                       perf_evlist__reset_prev_raw_counts(evsel_list);
+                       evlist__reset_prev_raw_counts(evsel_list);
 
                status = run_perf_stat(argc, argv, run_idx);
                if (forever && status != -1 && !interval) {
        }
 
        perf_stat__exit_aggr_mode();
-       perf_evlist__free_stats(evsel_list);
+       evlist__free_stats(evsel_list);
 out:
        zfree(&stat_config.walltime_run);
 
 
        if (err)
                goto out;
 
-       err = perf_evlist__alloc_stats(evlist, false);
+       err = evlist__alloc_stats(evlist, false);
        if (err)
                goto out;
 
        /* ... clenup. */
        metricgroup__rblist_exit(&metric_events);
        runtime_stat__exit(&st);
-       perf_evlist__free_stats(evlist);
+       evlist__free_stats(evlist);
        perf_cpu_map__put(cpus);
        evlist__delete(evlist);
        return err;
 
        return 0;
 }
 
-int perf_evlist__alloc_stats(struct evlist *evlist, bool alloc_raw)
+int evlist__alloc_stats(struct evlist *evlist, bool alloc_raw)
 {
        struct evsel *evsel;
 
        return 0;
 
 out_free:
-       perf_evlist__free_stats(evlist);
+       evlist__free_stats(evlist);
        return -1;
 }
 
-void perf_evlist__free_stats(struct evlist *evlist)
+void evlist__free_stats(struct evlist *evlist)
 {
        struct evsel *evsel;
 
        }
 }
 
-void perf_evlist__reset_stats(struct evlist *evlist)
+void evlist__reset_stats(struct evlist *evlist)
 {
        struct evsel *evsel;
 
        }
 }
 
-void perf_evlist__reset_prev_raw_counts(struct evlist *evlist)
+void evlist__reset_prev_raw_counts(struct evlist *evlist)
 {
        struct evsel *evsel;
 
        evsel->counts->aggr = evsel->prev_raw_counts->aggr;
 }
 
-void perf_evlist__copy_prev_raw_counts(struct evlist *evlist)
+void evlist__copy_prev_raw_counts(struct evlist *evlist)
 {
        struct evsel *evsel;
 
                evsel__copy_prev_raw_counts(evsel);
 }
 
-void perf_evlist__save_aggr_prev_raw_counts(struct evlist *evlist)
+void evlist__save_aggr_prev_raw_counts(struct evlist *evlist)
 {
        struct evsel *evsel;
 
 
                                   struct runtime_stat *st);
 void perf_stat__collect_metric_expr(struct evlist *);
 
-int perf_evlist__alloc_stats(struct evlist *evlist, bool alloc_raw);
-void perf_evlist__free_stats(struct evlist *evlist);
-void perf_evlist__reset_stats(struct evlist *evlist);
-void perf_evlist__reset_prev_raw_counts(struct evlist *evlist);
-void perf_evlist__copy_prev_raw_counts(struct evlist *evlist);
-void perf_evlist__save_aggr_prev_raw_counts(struct evlist *evlist);
+int evlist__alloc_stats(struct evlist *evlist, bool alloc_raw);
+void evlist__free_stats(struct evlist *evlist);
+void evlist__reset_stats(struct evlist *evlist);
+void evlist__reset_prev_raw_counts(struct evlist *evlist);
+void evlist__copy_prev_raw_counts(struct evlist *evlist);
+void evlist__save_aggr_prev_raw_counts(struct evlist *evlist);
 
 int perf_stat_process_counter(struct perf_stat_config *config,
                              struct evsel *counter);