memapi-jemalloc-sys 0.1.2+5.3.0-298-g70d4102f48dce2d5755e9139a15eeec606f97bff

FFI bindings to Jemalloc made for memapi.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

#include "test/jemalloc_test.h"

static void
mallctl_thread_name_get_impl(const char *thread_name_expected, const char *func,
    int line) {
	const char *thread_name_old;
	size_t sz;

	sz = sizeof(thread_name_old);
	expect_d_eq(mallctl("thread.prof.name", (void *)&thread_name_old, &sz,
	    NULL, 0), 0,
	    "%s():%d: Unexpected mallctl failure reading thread.prof.name",
	    func, line);
	expect_str_eq(thread_name_old, thread_name_expected,
	    "%s():%d: Unexpected thread.prof.name value", func, line);
}

static void
mallctl_thread_name_set_impl(const char *thread_name, const char *func,
    int line) {
	expect_d_eq(mallctl("thread.prof.name", NULL, NULL,
	    (void *)&thread_name, sizeof(thread_name)), 0,
	    "%s():%d: Unexpected mallctl failure writing thread.prof.name",
	    func, line);
	mallctl_thread_name_get_impl(thread_name, func, line);
}

#define mallctl_thread_name_get(a)					\
	mallctl_thread_name_get_impl(a, __func__, __LINE__)

#define mallctl_thread_name_set(a)					\
	mallctl_thread_name_set_impl(a, __func__, __LINE__)

TEST_BEGIN(test_prof_thread_name_validation) {
	test_skip_if(!config_prof);
	test_skip_if(opt_prof_sys_thread_name);

	mallctl_thread_name_get("");

	const char *test_name1 = "test case1";
	mallctl_thread_name_set(test_name1);

	/* Test name longer than the max len. */
	char long_name[] =
	    "test case longer than expected; test case longer than expected";
	expect_zu_gt(strlen(long_name), PROF_THREAD_NAME_MAX_LEN,
	   "Long test name not long enough");
	const char *test_name_long = long_name;
	expect_d_eq(mallctl("thread.prof.name", NULL, NULL,
	    (void *)&test_name_long, sizeof(test_name_long)), 0,
	    "Unexpected mallctl failure from thread.prof.name");
	/* Long name cut to match. */
	long_name[PROF_THREAD_NAME_MAX_LEN - 1] = '\0';
	mallctl_thread_name_get(test_name_long);

	/* NULL input shouldn't be allowed. */
	const char *test_name2 = NULL;
	expect_d_eq(mallctl("thread.prof.name", NULL, NULL,
	    (void *)&test_name2, sizeof(test_name2)), EINVAL,
	    "Unexpected mallctl result writing to thread.prof.name");

	/* '\n' shouldn't be allowed. */
	const char *test_name3 = "test\ncase";
	expect_d_eq(mallctl("thread.prof.name", NULL, NULL,
	    (void *)&test_name3, sizeof(test_name3)), EINVAL,
	    "Unexpected mallctl result writing \"%s\" to thread.prof.name",
	    test_name3);

	/* Simultaneous read/write shouldn't be allowed. */
	const char *thread_name_old;
	size_t sz = sizeof(thread_name_old);
	expect_d_eq(mallctl("thread.prof.name", (void *)&thread_name_old, &sz,
	    (void *)&test_name1, sizeof(test_name1)), EPERM,
	    "Unexpected mallctl result from thread.prof.name");

	mallctl_thread_name_set("");
}
TEST_END

static void *
thd_start(void *varg) {
	unsigned thd_ind = *(unsigned *)varg;
	char thread_name[16] = "";
	unsigned i;

	malloc_snprintf(thread_name, sizeof(thread_name), "thread %u", thd_ind);

	mallctl_thread_name_get("");
	mallctl_thread_name_set(thread_name);

#define NRESET 25
	for (i = 0; i < NRESET; i++) {
		expect_d_eq(mallctl("prof.reset", NULL, NULL, NULL, 0), 0,
		    "Unexpected error while resetting heap profile data");
		mallctl_thread_name_get(thread_name);
	}

	mallctl_thread_name_set(thread_name);
	mallctl_thread_name_set("");

	return NULL;
#undef NRESET
}

TEST_BEGIN(test_prof_thread_name_threaded) {
	test_skip_if(!config_prof);
	test_skip_if(opt_prof_sys_thread_name);

#define NTHREADS 4
	thd_t thds[NTHREADS];
	unsigned thd_args[NTHREADS];
	unsigned i;

	for (i = 0; i < NTHREADS; i++) {
		thd_args[i] = i;
		thd_create(&thds[i], thd_start, (void *)&thd_args[i]);
	}
	for (i = 0; i < NTHREADS; i++) {
		thd_join(thds[i], NULL);
	}
#undef NTHREADS
}
TEST_END

int
main(void) {
	return test(
	    test_prof_thread_name_validation,
	    test_prof_thread_name_threaded);
}