perf: Rename the ros_ core_set code
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 13 Dec 2017 20:09:09 +0000 (15:09 -0500)
committerBarret Rhoden <brho@cs.berkeley.edu>
Thu, 14 Dec 2017 17:40:45 +0000 (12:40 -0500)
I'll move it to parlib shortly.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
tools/dev-util/perf/akaros.c
tools/dev-util/perf/akaros.h
tools/dev-util/perf/perf.c

index 6d05bbd..5ccbd81 100644 (file)
@@ -18,21 +18,21 @@ static const unsigned int llcores[] = {
        0
 };
 
-void ros_get_low_latency_core_set(struct core_set *cores)
+void parlib_get_ll_core_set(struct core_set *cores)
 {
-       ros_get_no_cores_set(cores);
+       parlib_get_none_core_set(cores);
        for (size_t i = 0; i < COUNT_OF(llcores); i++)
-               ros_set_bit(cores, llcores[i]);
+               parlib_set_core(cores, llcores[i]);
 }
 
-size_t ros_get_low_latency_core_count(void)
+size_t parlib_nr_ll_cores(void)
 {
        return COUNT_OF(llcores);
 }
 
 static int guess_nr_cores(void)
 {
-       return max_vcores() + ros_get_low_latency_core_count();
+       return max_vcores() + parlib_nr_ll_cores();
 }
 
 static int get_vars_nr_cores(void)
@@ -60,7 +60,7 @@ static void set_nr_cores(void *arg)
                nr_cores = guess_nr_cores();
 }
 
-size_t ros_total_cores(void)
+size_t parlib_nr_total_cores(void)
 {
        static parlib_once_t once = PARLIB_ONCE_INIT;
 
@@ -68,7 +68,7 @@ size_t ros_total_cores(void)
        return nr_cores;
 }
 
-void ros_parse_cores(const char *str, struct core_set *cores)
+void parlib_parse_cores(const char *str, struct core_set *cores)
 {
        unsigned int fcpu, ncpu;
        char *dstr = xstrdup(str);
@@ -84,11 +84,11 @@ void ros_parse_cores(const char *str, struct core_set *cores)
                                fprintf(stderr, "Invalid CPU range: %s\n", tok);
                                exit(1);
                        }
-                       if (fcpu >= ros_total_cores()) {
+                       if (fcpu >= parlib_nr_total_cores()) {
                                fprintf(stderr, "CPU number out of bound: %u\n", fcpu);
                                exit(1);
                        }
-                       if (ncpu >= ros_total_cores()) {
+                       if (ncpu >= parlib_nr_total_cores()) {
                                fprintf(stderr, "CPU number out of bound: %u\n", ncpu);
                                exit(1);
                        }
@@ -97,37 +97,37 @@ void ros_parse_cores(const char *str, struct core_set *cores)
                                exit(1);
                        }
                        for (; fcpu <= ncpu; fcpu++)
-                               ros_set_bit(cores->core_set, fcpu);
+                               parlib_set_core(cores, fcpu);
                } else {
                        fcpu = atoi(tok);
-                       if (fcpu >= ros_total_cores()) {
+                       if (fcpu >= parlib_nr_total_cores()) {
                                fprintf(stderr, "CPU number out of bound: %u\n",
                                                fcpu);
                                exit(1);
                        }
-                       ros_set_bit(cores->core_set, fcpu);
+                       parlib_set_core(cores, fcpu);
                }
        }
        free(dstr);
 }
 
-void ros_get_all_cores_set(struct core_set *cores)
+void parlib_get_all_core_set(struct core_set *cores)
 {
-       size_t max_cores = ros_total_cores();
+       size_t max_cores = parlib_nr_total_cores();
 
        memset(cores->core_set, 0xff, DIV_ROUND_UP(max_cores, CHAR_BIT));
 }
 
-void ros_get_no_cores_set(struct core_set *cores)
+void parlib_get_none_core_set(struct core_set *cores)
 {
-       size_t max_cores = ros_total_cores();
+       size_t max_cores = parlib_nr_total_cores();
 
        memset(cores->core_set, 0, DIV_ROUND_UP(max_cores, CHAR_BIT));
 }
 
-void ros_not_core_set(struct core_set *dcs)
+void parlib_not_core_set(struct core_set *dcs)
 {
-       size_t max_cores = ros_total_cores();
+       size_t max_cores = parlib_nr_total_cores();
 
        for (size_t i = 0; (max_cores > 0) && (i < sizeof(dcs->core_set)); i++) {
                size_t nb = (max_cores >= CHAR_BIT) ? CHAR_BIT : max_cores;
@@ -137,13 +137,13 @@ void ros_not_core_set(struct core_set *dcs)
        }
 }
 
-void ros_and_core_sets(struct core_set *dcs, const struct core_set *scs)
+void parlib_and_core_sets(struct core_set *dcs, const struct core_set *scs)
 {
        for (size_t i = 0; i < sizeof(dcs->core_set); i++)
                dcs->core_set[i] &= scs->core_set[i];
 }
 
-void ros_or_core_sets(struct core_set *dcs, const struct core_set *scs)
+void parlib_or_core_sets(struct core_set *dcs, const struct core_set *scs)
 {
        for (size_t i = 0; i < sizeof(dcs->core_set); i++)
                dcs->core_set[i] |= scs->core_set[i];
index d421a7a..d47deb8 100644 (file)
 #include <parlib/parlib.h>
 #include <parlib/bitmask.h>
 
+__BEGIN_DECLS
+
 #define CORE_SET_SIZE BYTES_FOR_BITMASK(MAX_NUM_CORES)
 
-/* Not using sched.h CPU set because that file has definitions for a large
- * number of APIs Akaros does not support.
- * Making Akaros core_set.h visible in userslace might be a cleaner approach.
- */
 struct core_set {
        DECL_BITMASK(core_set, MAX_NUM_CORES);
 };
 
-void ros_get_low_latency_core_set(struct core_set *cores);
-size_t ros_get_low_latency_core_count(void);
-size_t ros_total_cores(void);
-void ros_parse_cores(const char *str, struct core_set *cores);
-void ros_get_all_cores_set(struct core_set *cores);
-void ros_get_no_cores_set(struct core_set *cores);
-void ros_not_core_set(struct core_set *dcs);
-void ros_and_core_sets(struct core_set *dcs, const struct core_set *scs);
-void ros_or_core_sets(struct core_set *dcs, const struct core_set *scs);
-
-static inline void ros_set_bit(void *addr, size_t nbit)
+void parlib_get_ll_core_set(struct core_set *cores);
+size_t parlib_nr_ll_cores(void);
+size_t parlib_nr_total_cores(void);
+void parlib_parse_cores(const char *str, struct core_set *cores);
+void parlib_get_all_core_set(struct core_set *cores);
+void parlib_get_none_core_set(struct core_set *cores);
+void parlib_not_core_set(struct core_set *dcs);
+void parlib_and_core_sets(struct core_set *dcs, const struct core_set *scs);
+void parlib_or_core_sets(struct core_set *dcs, const struct core_set *scs);
+
+static inline void parlib_set_core(struct core_set *cores, size_t coreid)
 {
-       SET_BITMASK_BIT(addr, nbit);
+       SET_BITMASK_BIT(cores->core_set, coreid);
 }
 
-static inline void ros_clear_bit(void *addr, size_t nbit)
+static inline void parlib_clear_core(struct core_set *cores, size_t coreid)
 {
-       CLR_BITMASK_BIT(addr, nbit);
+       CLR_BITMASK_BIT(cores->core_set, coreid);
 }
 
-static inline bool ros_get_bit(const void *addr, size_t nbit)
+static inline bool parlib_get_core(const struct core_set *cores, size_t coreid)
 {
-       return GET_BITMASK_BIT(addr, nbit);
+       return GET_BITMASK_BIT(cores->core_set, coreid);
 }
+
+__END_DECLS
index b99205f..e7227bb 100644 (file)
@@ -186,7 +186,7 @@ static error_t parse_collect_opt(int key, char *arg, struct argp_state *state)
                 * processes yet. */
                break;
        case 'C':
-               ros_parse_cores(arg, &p_opts->cores);
+               parlib_parse_cores(arg, &p_opts->cores);
                p_opts->got_cores = TRUE;
                break;
        case 'e':
@@ -209,7 +209,7 @@ static error_t parse_collect_opt(int key, char *arg, struct argp_state *state)
                        argp_usage(state);
                /* By default, we set all cores (different than linux) */
                if (!p_opts->got_cores)
-                       ros_get_all_cores_set(&p_opts->cores);
+                       parlib_get_all_core_set(&p_opts->cores);
                break;
        default:
                return ARGP_ERR_UNKNOWN;
@@ -534,7 +534,7 @@ static void run_process_and_wait(int argc, char *argv[],
                                                                 const struct core_set *cores)
 {
        int pid, status;
-       size_t max_cores = ros_total_cores();
+       size_t max_cores = parlib_nr_total_cores();
        struct core_set pvcores;
 
        pid = create_child_with_stdfds(argv[0], argc, argv, environ);
@@ -544,11 +544,11 @@ static void run_process_and_wait(int argc, char *argv[],
                exit(1);
        }
        if (cores) {
-               ros_get_low_latency_core_set(&pvcores);
-               ros_not_core_set(&pvcores);
-               ros_and_core_sets(&pvcores, cores);
+               parlib_get_ll_core_set(&pvcores);
+               parlib_not_core_set(&pvcores);
+               parlib_and_core_sets(&pvcores, cores);
                for (size_t i = 0; i < max_cores; i++) {
-                       if (ros_get_bit(&pvcores, i)) {
+                       if (parlib_get_core(&pvcores, i)) {
                                if (sys_provision(pid, RES_CORES, i)) {
                                        fprintf(stderr,
                                                        "Unable to provision CPU %lu to PID %d: cmd='%s'\n",