Header refactoring: ctl - unify and remove from catchall.

In order to do this, we introduce the mutex_prof module, which breaks a circular
dependency between ctl and prof.

3 files changed, 41 insertions, 37 deletions

diff --git a/src/ctl.c b/src/ctl.c
index 8c2e7bc..3591f89 100644
--- a/src/ctl.c
+++ b/src/ctl.c
@@ -3,6 +3,7 @@
 #include "jemalloc/internal/jemalloc_internal_includes.h"
 
 #include "jemalloc/internal/assert.h"
+#include "jemalloc/internal/ctl.h"
 #include "jemalloc/internal/nstime.h"
 #include "jemalloc/internal/size_classes.h"
 #include "jemalloc/internal/util.h"
@@ -193,12 +194,12 @@ CTL_PROTO(stats_##n##_max_num_thds)
 
 /* Global mutexes. */
 #define OP(mtx) MUTEX_STATS_CTL_PROTO_GEN(mutexes_##mtx)
-GLOBAL_PROF_MUTEXES
+MUTEX_PROF_GLOBAL_MUTEXES
 #undef OP
 
 /* Per arena mutexes. */
 #define OP(mtx) MUTEX_STATS_CTL_PROTO_GEN(arenas_i_mutexes_##mtx)
-ARENA_PROF_MUTEXES
+MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 
 /* Arena bin mutexes. */
@@ -429,12 +430,12 @@ static const ctl_indexed_node_t stats_arenas_i_lextents_node[] = {
 };
 
 #define OP(mtx)  MUTEX_PROF_DATA_NODE(arenas_i_mutexes_##mtx)
-ARENA_PROF_MUTEXES
+MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 
 static const ctl_named_node_t stats_arenas_i_mutexes_node[] = {
 #define OP(mtx) {NAME(#mtx), CHILD(named, stats_arenas_i_mutexes_##mtx)},
-ARENA_PROF_MUTEXES
+MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 };
 
@@ -473,12 +474,12 @@ static const ctl_indexed_node_t stats_arenas_node[] = {
 };
 
 #define OP(mtx) MUTEX_PROF_DATA_NODE(mutexes_##mtx)
-GLOBAL_PROF_MUTEXES
+MUTEX_PROF_GLOBAL_MUTEXES
 #undef OP
 
 static const ctl_named_node_t stats_mutexes_node[] = {
 #define OP(mtx) {NAME(#mtx), CHILD(named, stats_mutexes_##mtx)},
-GLOBAL_PROF_MUTEXES
+MUTEX_PROF_GLOBAL_MUTEXES
 #undef OP
 	{NAME("reset"),		CTL(stats_mutexes_reset)}
 };
@@ -737,7 +738,7 @@ ctl_arena_stats_sdmerge(ctl_arena_t *ctl_sdarena, ctl_arena_t *ctl_arena,
 		        arena_prof_mutex_##mtx]),			\
 		    &(astats->astats.mutex_prof_data[			\
 		        arena_prof_mutex_##mtx]));
-ARENA_PROF_MUTEXES
+MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 		if (!destroyed) {
 			accum_atomic_zu(&sdstats->astats.base,
@@ -2401,13 +2402,13 @@ CTL_RO_CGEN(config_stats, stats_##n##_max_num_thds,			\
 #define OP(mtx)								\
     RO_MUTEX_CTL_GEN(mutexes_##mtx,					\
         ctl_stats->mutex_prof_data[global_prof_mutex_##mtx])
-GLOBAL_PROF_MUTEXES
+MUTEX_PROF_GLOBAL_MUTEXES
 #undef OP
 
 /* Per arena mutexes */
 #define OP(mtx) RO_MUTEX_CTL_GEN(arenas_i_mutexes_##mtx,		\
     arenas_i(mib[2])->astats->astats.mutex_prof_data[arena_prof_mutex_##mtx])
-ARENA_PROF_MUTEXES
+MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 
 /* tcache bin mutex */
diff --git a/src/jemalloc.c b/src/jemalloc.c
index 5e1f0a7..4214600 100644
--- a/src/jemalloc.c
+++ b/src/jemalloc.c
@@ -4,6 +4,7 @@
 
 #include "jemalloc/internal/assert.h"
 #include "jemalloc/internal/atomic.h"
+#include "jemalloc/internal/ctl.h"
 #include "jemalloc/internal/jemalloc_internal_types.h"
 #include "jemalloc/internal/malloc_io.h"
 #include "jemalloc/internal/size_classes.h"
diff --git a/src/stats.c b/src/stats.c
index ca9db89..5d51518 100644
--- a/src/stats.c
+++ b/src/stats.c
@@ -3,16 +3,18 @@
 #include "jemalloc/internal/jemalloc_internal_includes.h"
 
 #include "jemalloc/internal/assert.h"
+#include "jemalloc/internal/ctl.h"
+#include "jemalloc/internal/mutex_prof.h"
 
-const char *global_mutex_names[num_global_prof_mutexes] = {
+const char *global_mutex_names[mutex_prof_num_global_mutexes] = {
 #define OP(mtx) #mtx,
-	GLOBAL_PROF_MUTEXES
+	MUTEX_PROF_GLOBAL_MUTEXES
 #undef OP
 };
 
-const char *arena_mutex_names[num_arena_prof_mutexes] = {
+const char *arena_mutex_names[mutex_prof_num_arena_mutexes] = {
 #define OP(mtx) #mtx,
-	ARENA_PROF_MUTEXES
+	MUTEX_PROF_ARENA_MUTEXES
 #undef OP
 };
 
@@ -81,7 +83,7 @@ gen_mutex_ctl_str(char *str, size_t buf_len, const char *prefix,
 
 static void
 read_arena_bin_mutex_stats(unsigned arena_ind, unsigned bin_ind,
-    uint64_t results[num_mutex_prof_counters]) {
+    uint64_t results[mutex_prof_num_counters]) {
 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
 #define OP(c, t)							\
     gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,			\
@@ -94,7 +96,7 @@ MUTEX_PROF_COUNTERS
 
 static void
 mutex_stats_output_json(void (*write_cb)(void *, const char *), void *cbopaque,
-    const char *name, uint64_t stats[num_mutex_prof_counters],
+    const char *name, uint64_t stats[mutex_prof_num_counters],
     const char *json_indent, bool last) {
 	malloc_cprintf(write_cb, cbopaque, "%s\"%s\": {\n", json_indent, name);
 
@@ -105,7 +107,7 @@ mutex_stats_output_json(void (*write_cb)(void *, const char *), void *cbopaque,
 	malloc_cprintf(write_cb, cbopaque,				\
 	    fmt_str[sizeof(t) / sizeof(uint32_t) - 1], 			\
 	    json_indent, #c, (t)stats[mutex_counter_##c],		\
-	    (++k == num_mutex_prof_counters) ? "" : ",");
+	    (++k == mutex_prof_num_counters) ? "" : ",");
 MUTEX_PROF_COUNTERS
 #undef OP
 	malloc_cprintf(write_cb, cbopaque, "%s}%s\n", json_indent,
@@ -187,7 +189,7 @@ stats_arena_bins_print(void (*write_cb)(void *, const char *), void *cbopaque,
 			    nmalloc, ndalloc, curregs, nrequests, nfills,
 			    nflushes, nreslabs, curslabs, mutex ? "," : "");
 			if (mutex) {
-				uint64_t mutex_stats[num_mutex_prof_counters];
+				uint64_t mutex_stats[mutex_prof_num_counters];
 				read_arena_bin_mutex_stats(i, j, mutex_stats);
 				mutex_stats_output_json(write_cb, cbopaque,
 				    "mutex", mutex_stats, "\t\t\t\t\t\t", true);
@@ -226,7 +228,7 @@ stats_arena_bins_print(void (*write_cb)(void *, const char *), void *cbopaque,
 			    &max_wait, uint64_t);
 			CTL_M2_M4_GET("stats.arenas.0.bins.0.mutex.num_ops",
 			    i, j, &num_ops, uint64_t);
-			uint64_t mutex_stats[num_mutex_prof_counters];
+			uint64_t mutex_stats[mutex_prof_num_counters];
 			if (mutex) {
 				read_arena_bin_mutex_stats(i, j, mutex_stats);
 			}
@@ -336,11 +338,11 @@ stats_arena_lextents_print(void (*write_cb)(void *, const char *),
 
 static void
 read_arena_mutex_stats(unsigned arena_ind,
-    uint64_t results[num_arena_prof_mutexes][num_mutex_prof_counters]) {
+    uint64_t results[mutex_prof_num_arena_mutexes][mutex_prof_num_counters]) {
 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
 
-	arena_prof_mutex_ind_t i;
-	for (i = 0; i < num_arena_prof_mutexes; i++) {
+	mutex_prof_arena_ind_t i;
+	for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
 #define OP(c, t)							\
 		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,	\
 		    "arenas.0.mutexes",	arena_mutex_names[i], #c);	\
@@ -353,7 +355,7 @@ MUTEX_PROF_COUNTERS
 
 static void
 mutex_stats_output(void (*write_cb)(void *, const char *), void *cbopaque,
-    const char *name, uint64_t stats[num_mutex_prof_counters],
+    const char *name, uint64_t stats[mutex_prof_num_counters],
     bool first_mutex) {
 	if (first_mutex) {
 		/* Print title. */
@@ -380,15 +382,15 @@ MUTEX_PROF_COUNTERS
 static void
 stats_arena_mutexes_print(void (*write_cb)(void *, const char *),
     void *cbopaque, bool json, bool json_end, unsigned arena_ind) {
-	uint64_t mutex_stats[num_arena_prof_mutexes][num_mutex_prof_counters];
+	uint64_t mutex_stats[mutex_prof_num_arena_mutexes][mutex_prof_num_counters];
 	read_arena_mutex_stats(arena_ind, mutex_stats);
 
 	/* Output mutex stats. */
 	if (json) {
 		malloc_cprintf(write_cb, cbopaque, "\t\t\t\t\"mutexes\": {\n");
-		arena_prof_mutex_ind_t i, last_mutex;
-		last_mutex = num_arena_prof_mutexes - 1;
-		for (i = 0; i < num_arena_prof_mutexes; i++) {
+		mutex_prof_arena_ind_t i, last_mutex;
+		last_mutex = mutex_prof_num_arena_mutexes - 1;
+		for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
 			mutex_stats_output_json(write_cb, cbopaque,
 			    arena_mutex_names[i], mutex_stats[i],
 			    "\t\t\t\t\t", (i == last_mutex));
@@ -396,8 +398,8 @@ stats_arena_mutexes_print(void (*write_cb)(void *, const char *),
 		malloc_cprintf(write_cb, cbopaque, "\t\t\t\t}%s\n",
 		    json_end ? "" : ",");
 	} else {
-		arena_prof_mutex_ind_t i;
-		for (i = 0; i < num_arena_prof_mutexes; i++) {
+		mutex_prof_arena_ind_t i;
+		for (i = 0; i < mutex_prof_num_arena_mutexes; i++) {
 			mutex_stats_output(write_cb, cbopaque,
 			    arena_mutex_names[i], mutex_stats[i], i == 0);
 		}
@@ -993,11 +995,11 @@ stats_general_print(void (*write_cb)(void *, const char *), void *cbopaque,
 
 static void
 read_global_mutex_stats(
-    uint64_t results[num_global_prof_mutexes][num_mutex_prof_counters]) {
+    uint64_t results[mutex_prof_num_global_mutexes][mutex_prof_num_counters]) {
 	char cmd[MUTEX_CTL_STR_MAX_LENGTH];
 
-	global_prof_mutex_ind_t i;
-	for (i = 0; i < num_global_prof_mutexes; i++) {
+	mutex_prof_global_ind_t i;
+	for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
 #define OP(c, t)							\
 		gen_mutex_ctl_str(cmd, MUTEX_CTL_STR_MAX_LENGTH,	\
 		    "mutexes", global_mutex_names[i], #c);		\
@@ -1020,7 +1022,7 @@ stats_print_helper(void (*write_cb)(void *, const char *), void *cbopaque,
 	CTL_GET("stats.mapped", &mapped, size_t);
 	CTL_GET("stats.retained", &retained, size_t);
 
-	uint64_t mutex_stats[num_global_prof_mutexes][num_mutex_prof_counters];
+	uint64_t mutex_stats[mutex_prof_num_global_mutexes][mutex_prof_num_counters];
 	if (mutex) {
 		read_global_mutex_stats(mutex_stats);
 	}
@@ -1044,12 +1046,12 @@ stats_print_helper(void (*write_cb)(void *, const char *), void *cbopaque,
 		if (mutex) {
 			malloc_cprintf(write_cb, cbopaque,
 			    "\t\t\t\"mutexes\": {\n");
-			global_prof_mutex_ind_t i;
-			for (i = 0; i < num_global_prof_mutexes; i++) {
+			mutex_prof_global_ind_t i;
+			for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
 				mutex_stats_output_json(write_cb, cbopaque,
 				    global_mutex_names[i], mutex_stats[i],
 				    "\t\t\t\t",
-				    i == num_global_prof_mutexes - 1);
+				    i == mutex_prof_num_global_mutexes - 1);
 			}
 			malloc_cprintf(write_cb, cbopaque, "\t\t\t}\n");
 		}
@@ -1061,8 +1063,8 @@ stats_print_helper(void (*write_cb)(void *, const char *), void *cbopaque,
 		    " resident: %zu, mapped: %zu, retained: %zu\n",
 		    allocated, active, metadata, resident, mapped, retained);
 		if (mutex) {
-			global_prof_mutex_ind_t i;
-			for (i = 0; i < num_global_prof_mutexes; i++) {
+			mutex_prof_global_ind_t i;
+			for (i = 0; i < mutex_prof_num_global_mutexes; i++) {
 				mutex_stats_output(write_cb, cbopaque,
 				    global_mutex_names[i], mutex_stats[i],
 				    i == 0);