Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
5c988b33
Commit
5c988b33
authored
Jun 20, 2014
by
antirez
Browse files
Jemalloc updated to 3.6.0.
Not a single bug in about 3 months, and our previous version was too old (3.2.0).
parent
f94d46ba
Changes
143
Hide whitespace changes
Inline
Side-by-side
deps/jemalloc/test/unit/tsd.c
0 → 100644
View file @
5c988b33
#include "test/jemalloc_test.h"
#define THREAD_DATA 0x72b65c10
typedef
unsigned
int
data_t
;
static
bool
data_cleanup_executed
;
void
data_cleanup
(
void
*
arg
)
{
data_t
*
data
=
(
data_t
*
)
arg
;
assert_x_eq
(
*
data
,
THREAD_DATA
,
"Argument passed into cleanup function should match tsd value"
);
data_cleanup_executed
=
true
;
}
malloc_tsd_protos
(,
data
,
data_t
)
malloc_tsd_externs
(
data
,
data_t
)
#define DATA_INIT 0x12345678
malloc_tsd_data
(,
data
,
data_t
,
DATA_INIT
)
malloc_tsd_funcs
(,
data
,
data_t
,
DATA_INIT
,
data_cleanup
)
static
void
*
thd_start
(
void
*
arg
)
{
data_t
d
=
(
data_t
)(
uintptr_t
)
arg
;
assert_x_eq
(
*
data_tsd_get
(),
DATA_INIT
,
"Initial tsd get should return initialization value"
);
data_tsd_set
(
&
d
);
assert_x_eq
(
*
data_tsd_get
(),
d
,
"After tsd set, tsd get should return value that was set"
);
d
=
0
;
assert_x_eq
(
*
data_tsd_get
(),
(
data_t
)(
uintptr_t
)
arg
,
"Resetting local data should have no effect on tsd"
);
return
(
NULL
);
}
TEST_BEGIN
(
test_tsd_main_thread
)
{
thd_start
((
void
*
)
0xa5f3e329
);
}
TEST_END
TEST_BEGIN
(
test_tsd_sub_thread
)
{
thd_t
thd
;
data_cleanup_executed
=
false
;
thd_create
(
&
thd
,
thd_start
,
(
void
*
)
THREAD_DATA
);
thd_join
(
thd
,
NULL
);
assert_true
(
data_cleanup_executed
,
"Cleanup function should have executed"
);
}
TEST_END
int
main
(
void
)
{
data_tsd_boot
();
return
(
test
(
test_tsd_main_thread
,
test_tsd_sub_thread
));
}
deps/jemalloc/test/unit/util.c
0 → 100644
View file @
5c988b33
#include "test/jemalloc_test.h"
TEST_BEGIN
(
test_pow2_ceil
)
{
unsigned
i
,
pow2
;
size_t
x
;
assert_zu_eq
(
pow2_ceil
(
0
),
0
,
"Unexpected result"
);
for
(
i
=
0
;
i
<
sizeof
(
size_t
)
*
8
;
i
++
)
{
assert_zu_eq
(
pow2_ceil
(
ZU
(
1
)
<<
i
),
ZU
(
1
)
<<
i
,
"Unexpected result"
);
}
for
(
i
=
2
;
i
<
sizeof
(
size_t
)
*
8
;
i
++
)
{
assert_zu_eq
(
pow2_ceil
((
ZU
(
1
)
<<
i
)
-
1
),
ZU
(
1
)
<<
i
,
"Unexpected result"
);
}
for
(
i
=
0
;
i
<
sizeof
(
size_t
)
*
8
-
1
;
i
++
)
{
assert_zu_eq
(
pow2_ceil
((
ZU
(
1
)
<<
i
)
+
1
),
ZU
(
1
)
<<
(
i
+
1
),
"Unexpected result"
);
}
for
(
pow2
=
1
;
pow2
<
25
;
pow2
++
)
{
for
(
x
=
(
ZU
(
1
)
<<
(
pow2
-
1
))
+
1
;
x
<=
ZU
(
1
)
<<
pow2
;
x
++
)
{
assert_zu_eq
(
pow2_ceil
(
x
),
ZU
(
1
)
<<
pow2
,
"Unexpected result, x=%zu"
,
x
);
}
}
}
TEST_END
TEST_BEGIN
(
test_malloc_strtoumax_no_endptr
)
{
int
err
;
set_errno
(
0
);
assert_ju_eq
(
malloc_strtoumax
(
"0"
,
NULL
,
0
),
0
,
"Unexpected result"
);
err
=
get_errno
();
assert_d_eq
(
err
,
0
,
"Unexpected failure"
);
}
TEST_END
TEST_BEGIN
(
test_malloc_strtoumax
)
{
struct
test_s
{
const
char
*
input
;
const
char
*
expected_remainder
;
int
base
;
int
expected_errno
;
const
char
*
expected_errno_name
;
uintmax_t
expected_x
;
};
#define ERR(e) e, #e
#define UMAX(x) ((uintmax_t)x##ULL)
struct
test_s
tests
[]
=
{
{
"0"
,
"0"
,
-
1
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"0"
,
"0"
,
1
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"0"
,
"0"
,
37
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
""
,
""
,
0
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"+"
,
"+"
,
0
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"++3"
,
"++3"
,
0
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"-"
,
"-"
,
0
,
ERR
(
EINVAL
),
UINTMAX_MAX
},
{
"42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
"+42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
"-42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
-
42
)},
{
"042"
,
""
,
0
,
ERR
(
0
),
UMAX
(
042
)},
{
"+042"
,
""
,
0
,
ERR
(
0
),
UMAX
(
042
)},
{
"-042"
,
""
,
0
,
ERR
(
0
),
UMAX
(
-
042
)},
{
"0x42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
0x42
)},
{
"+0x42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
0x42
)},
{
"-0x42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
-
0x42
)},
{
"0"
,
""
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"1"
,
""
,
0
,
ERR
(
0
),
UMAX
(
1
)},
{
"42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
" 42"
,
""
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
"42 "
,
" "
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
"0x"
,
"x"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"42x"
,
"x"
,
0
,
ERR
(
0
),
UMAX
(
42
)},
{
"07"
,
""
,
0
,
ERR
(
0
),
UMAX
(
7
)},
{
"010"
,
""
,
0
,
ERR
(
0
),
UMAX
(
8
)},
{
"08"
,
"8"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"0_"
,
"_"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"0x"
,
"x"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"0X"
,
"X"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"0xg"
,
"xg"
,
0
,
ERR
(
0
),
UMAX
(
0
)},
{
"0XA"
,
""
,
0
,
ERR
(
0
),
UMAX
(
10
)},
{
"010"
,
""
,
10
,
ERR
(
0
),
UMAX
(
10
)},
{
"0x3"
,
"x3"
,
10
,
ERR
(
0
),
UMAX
(
0
)},
{
"12"
,
"2"
,
2
,
ERR
(
0
),
UMAX
(
1
)},
{
"78"
,
"8"
,
8
,
ERR
(
0
),
UMAX
(
7
)},
{
"9a"
,
"a"
,
10
,
ERR
(
0
),
UMAX
(
9
)},
{
"9A"
,
"A"
,
10
,
ERR
(
0
),
UMAX
(
9
)},
{
"fg"
,
"g"
,
16
,
ERR
(
0
),
UMAX
(
15
)},
{
"FG"
,
"G"
,
16
,
ERR
(
0
),
UMAX
(
15
)},
{
"0xfg"
,
"g"
,
16
,
ERR
(
0
),
UMAX
(
15
)},
{
"0XFG"
,
"G"
,
16
,
ERR
(
0
),
UMAX
(
15
)},
{
"z_"
,
"_"
,
36
,
ERR
(
0
),
UMAX
(
35
)},
{
"Z_"
,
"_"
,
36
,
ERR
(
0
),
UMAX
(
35
)}
};
#undef ERR
#undef UMAX
unsigned
i
;
for
(
i
=
0
;
i
<
sizeof
(
tests
)
/
sizeof
(
struct
test_s
);
i
++
)
{
struct
test_s
*
test
=
&
tests
[
i
];
int
err
;
uintmax_t
result
;
char
*
remainder
;
set_errno
(
0
);
result
=
malloc_strtoumax
(
test
->
input
,
&
remainder
,
test
->
base
);
err
=
get_errno
();
assert_d_eq
(
err
,
test
->
expected_errno
,
"Expected errno %s for
\"
%s
\"
, base %d"
,
test
->
expected_errno_name
,
test
->
input
,
test
->
base
);
assert_str_eq
(
remainder
,
test
->
expected_remainder
,
"Unexpected remainder for
\"
%s
\"
, base %d"
,
test
->
input
,
test
->
base
);
if
(
err
==
0
)
{
assert_ju_eq
(
result
,
test
->
expected_x
,
"Unexpected result for
\"
%s
\"
, base %d"
,
test
->
input
,
test
->
base
);
}
}
}
TEST_END
TEST_BEGIN
(
test_malloc_snprintf_truncated
)
{
#define BUFLEN 15
char
buf
[
BUFLEN
];
int
result
;
size_t
len
;
#define TEST(expected_str_untruncated, fmt...) do { \
result = malloc_snprintf(buf, len, fmt); \
assert_d_eq(strncmp(buf, expected_str_untruncated, len-1), 0, \
"Unexpected string inequality (\"%s\" vs \"%s\")", \
buf, expected_str_untruncated); \
assert_d_eq(result, strlen(expected_str_untruncated), \
"Unexpected result"); \
} while (0)
for
(
len
=
1
;
len
<
BUFLEN
;
len
++
)
{
TEST
(
"012346789"
,
"012346789"
);
TEST
(
"a0123b"
,
"a%sb"
,
"0123"
);
TEST
(
"a01234567"
,
"a%s%s"
,
"0123"
,
"4567"
);
TEST
(
"a0123 "
,
"a%-6s"
,
"0123"
);
TEST
(
"a 0123"
,
"a%6s"
,
"0123"
);
TEST
(
"a 012"
,
"a%6.3s"
,
"0123"
);
TEST
(
"a 012"
,
"a%*.*s"
,
6
,
3
,
"0123"
);
TEST
(
"a 123b"
,
"a% db"
,
123
);
TEST
(
"a123b"
,
"a%-db"
,
123
);
TEST
(
"a-123b"
,
"a%-db"
,
-
123
);
TEST
(
"a+123b"
,
"a%+db"
,
123
);
}
#undef BUFLEN
#undef TEST
}
TEST_END
TEST_BEGIN
(
test_malloc_snprintf
)
{
#define BUFLEN 128
char
buf
[
BUFLEN
];
int
result
;
#define TEST(expected_str, fmt...) do { \
result = malloc_snprintf(buf, sizeof(buf), fmt); \
assert_str_eq(buf, expected_str, "Unexpected output"); \
assert_d_eq(result, strlen(expected_str), "Unexpected result"); \
} while (0)
TEST
(
"hello"
,
"hello"
);
TEST
(
"50%, 100%"
,
"50%%, %d%%"
,
100
);
TEST
(
"a0123b"
,
"a%sb"
,
"0123"
);
TEST
(
"a 0123b"
,
"a%5sb"
,
"0123"
);
TEST
(
"a 0123b"
,
"a%*sb"
,
5
,
"0123"
);
TEST
(
"a0123 b"
,
"a%-5sb"
,
"0123"
);
TEST
(
"a0123b"
,
"a%*sb"
,
-
1
,
"0123"
);
TEST
(
"a0123 b"
,
"a%*sb"
,
-
5
,
"0123"
);
TEST
(
"a0123 b"
,
"a%-*sb"
,
-
5
,
"0123"
);
TEST
(
"a012b"
,
"a%.3sb"
,
"0123"
);
TEST
(
"a012b"
,
"a%.*sb"
,
3
,
"0123"
);
TEST
(
"a0123b"
,
"a%.*sb"
,
-
3
,
"0123"
);
TEST
(
"a 012b"
,
"a%5.3sb"
,
"0123"
);
TEST
(
"a 012b"
,
"a%5.*sb"
,
3
,
"0123"
);
TEST
(
"a 012b"
,
"a%*.3sb"
,
5
,
"0123"
);
TEST
(
"a 012b"
,
"a%*.*sb"
,
5
,
3
,
"0123"
);
TEST
(
"a 0123b"
,
"a%*.*sb"
,
5
,
-
3
,
"0123"
);
TEST
(
"_abcd_"
,
"_%x_"
,
0xabcd
);
TEST
(
"_0xabcd_"
,
"_%#x_"
,
0xabcd
);
TEST
(
"_1234_"
,
"_%o_"
,
01234
);
TEST
(
"_01234_"
,
"_%#o_"
,
01234
);
TEST
(
"_1234_"
,
"_%u_"
,
1234
);
TEST
(
"_1234_"
,
"_%d_"
,
1234
);
TEST
(
"_ 1234_"
,
"_% d_"
,
1234
);
TEST
(
"_+1234_"
,
"_%+d_"
,
1234
);
TEST
(
"_-1234_"
,
"_%d_"
,
-
1234
);
TEST
(
"_-1234_"
,
"_% d_"
,
-
1234
);
TEST
(
"_-1234_"
,
"_%+d_"
,
-
1234
);
TEST
(
"_-1234_"
,
"_%d_"
,
-
1234
);
TEST
(
"_1234_"
,
"_%d_"
,
1234
);
TEST
(
"_-1234_"
,
"_%i_"
,
-
1234
);
TEST
(
"_1234_"
,
"_%i_"
,
1234
);
TEST
(
"_01234_"
,
"_%#o_"
,
01234
);
TEST
(
"_1234_"
,
"_%u_"
,
1234
);
TEST
(
"_0x1234abc_"
,
"_%#x_"
,
0x1234abc
);
TEST
(
"_0X1234ABC_"
,
"_%#X_"
,
0x1234abc
);
TEST
(
"_c_"
,
"_%c_"
,
'c'
);
TEST
(
"_string_"
,
"_%s_"
,
"string"
);
TEST
(
"_0x42_"
,
"_%p_"
,
((
void
*
)
0x42
));
TEST
(
"_-1234_"
,
"_%ld_"
,
((
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%ld_"
,
((
long
)
1234
));
TEST
(
"_-1234_"
,
"_%li_"
,
((
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%li_"
,
((
long
)
1234
));
TEST
(
"_01234_"
,
"_%#lo_"
,
((
long
)
01234
));
TEST
(
"_1234_"
,
"_%lu_"
,
((
long
)
1234
));
TEST
(
"_0x1234abc_"
,
"_%#lx_"
,
((
long
)
0x1234abc
));
TEST
(
"_0X1234ABC_"
,
"_%#lX_"
,
((
long
)
0x1234ABC
));
TEST
(
"_-1234_"
,
"_%lld_"
,
((
long
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%lld_"
,
((
long
long
)
1234
));
TEST
(
"_-1234_"
,
"_%lli_"
,
((
long
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%lli_"
,
((
long
long
)
1234
));
TEST
(
"_01234_"
,
"_%#llo_"
,
((
long
long
)
01234
));
TEST
(
"_1234_"
,
"_%llu_"
,
((
long
long
)
1234
));
TEST
(
"_0x1234abc_"
,
"_%#llx_"
,
((
long
long
)
0x1234abc
));
TEST
(
"_0X1234ABC_"
,
"_%#llX_"
,
((
long
long
)
0x1234ABC
));
TEST
(
"_-1234_"
,
"_%qd_"
,
((
long
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%qd_"
,
((
long
long
)
1234
));
TEST
(
"_-1234_"
,
"_%qi_"
,
((
long
long
)
-
1234
));
TEST
(
"_1234_"
,
"_%qi_"
,
((
long
long
)
1234
));
TEST
(
"_01234_"
,
"_%#qo_"
,
((
long
long
)
01234
));
TEST
(
"_1234_"
,
"_%qu_"
,
((
long
long
)
1234
));
TEST
(
"_0x1234abc_"
,
"_%#qx_"
,
((
long
long
)
0x1234abc
));
TEST
(
"_0X1234ABC_"
,
"_%#qX_"
,
((
long
long
)
0x1234ABC
));
TEST
(
"_-1234_"
,
"_%jd_"
,
((
intmax_t
)
-
1234
));
TEST
(
"_1234_"
,
"_%jd_"
,
((
intmax_t
)
1234
));
TEST
(
"_-1234_"
,
"_%ji_"
,
((
intmax_t
)
-
1234
));
TEST
(
"_1234_"
,
"_%ji_"
,
((
intmax_t
)
1234
));
TEST
(
"_01234_"
,
"_%#jo_"
,
((
intmax_t
)
01234
));
TEST
(
"_1234_"
,
"_%ju_"
,
((
intmax_t
)
1234
));
TEST
(
"_0x1234abc_"
,
"_%#jx_"
,
((
intmax_t
)
0x1234abc
));
TEST
(
"_0X1234ABC_"
,
"_%#jX_"
,
((
intmax_t
)
0x1234ABC
));
TEST
(
"_1234_"
,
"_%td_"
,
((
ptrdiff_t
)
1234
));
TEST
(
"_-1234_"
,
"_%td_"
,
((
ptrdiff_t
)
-
1234
));
TEST
(
"_1234_"
,
"_%ti_"
,
((
ptrdiff_t
)
1234
));
TEST
(
"_-1234_"
,
"_%ti_"
,
((
ptrdiff_t
)
-
1234
));
TEST
(
"_-1234_"
,
"_%zd_"
,
((
ssize_t
)
-
1234
));
TEST
(
"_1234_"
,
"_%zd_"
,
((
ssize_t
)
1234
));
TEST
(
"_-1234_"
,
"_%zi_"
,
((
ssize_t
)
-
1234
));
TEST
(
"_1234_"
,
"_%zi_"
,
((
ssize_t
)
1234
));
TEST
(
"_01234_"
,
"_%#zo_"
,
((
ssize_t
)
01234
));
TEST
(
"_1234_"
,
"_%zu_"
,
((
ssize_t
)
1234
));
TEST
(
"_0x1234abc_"
,
"_%#zx_"
,
((
ssize_t
)
0x1234abc
));
TEST
(
"_0X1234ABC_"
,
"_%#zX_"
,
((
ssize_t
)
0x1234ABC
));
#undef BUFLEN
}
TEST_END
int
main
(
void
)
{
return
(
test
(
test_pow2_ceil
,
test_malloc_strtoumax_no_endptr
,
test_malloc_strtoumax
,
test_malloc_snprintf_truncated
,
test_malloc_snprintf
));
}
deps/jemalloc/test/unit/zero.c
0 → 100644
View file @
5c988b33
#include "test/jemalloc_test.h"
#ifdef JEMALLOC_FILL
const
char
*
malloc_conf
=
"abort:false,junk:false,zero:true,redzone:false,quarantine:0"
;
#endif
static
void
test_zero
(
size_t
sz_min
,
size_t
sz_max
)
{
char
*
s
;
size_t
sz_prev
,
sz
,
i
;
sz_prev
=
0
;
s
=
(
char
*
)
mallocx
(
sz_min
,
0
);
assert_ptr_not_null
((
void
*
)
s
,
"Unexpected mallocx() failure"
);
for
(
sz
=
sallocx
(
s
,
0
);
sz
<=
sz_max
;
sz_prev
=
sz
,
sz
=
sallocx
(
s
,
0
))
{
if
(
sz_prev
>
0
)
{
assert_c_eq
(
s
[
0
],
'a'
,
"Previously allocated byte %zu/%zu is corrupted"
,
ZU
(
0
),
sz_prev
);
assert_c_eq
(
s
[
sz_prev
-
1
],
'a'
,
"Previously allocated byte %zu/%zu is corrupted"
,
sz_prev
-
1
,
sz_prev
);
}
for
(
i
=
sz_prev
;
i
<
sz
;
i
++
)
{
assert_c_eq
(
s
[
i
],
0x0
,
"Newly allocated byte %zu/%zu isn't zero-filled"
,
i
,
sz
);
s
[
i
]
=
'a'
;
}
if
(
xallocx
(
s
,
sz
+
1
,
0
,
0
)
==
sz
)
{
s
=
(
char
*
)
rallocx
(
s
,
sz
+
1
,
0
);
assert_ptr_not_null
((
void
*
)
s
,
"Unexpected rallocx() failure"
);
}
}
dallocx
(
s
,
0
);
}
TEST_BEGIN
(
test_zero_small
)
{
test_skip_if
(
!
config_fill
);
test_zero
(
1
,
SMALL_MAXCLASS
-
1
);
}
TEST_END
TEST_BEGIN
(
test_zero_large
)
{
test_skip_if
(
!
config_fill
);
test_zero
(
SMALL_MAXCLASS
+
1
,
arena_maxclass
);
}
TEST_END
TEST_BEGIN
(
test_zero_huge
)
{
test_skip_if
(
!
config_fill
);
test_zero
(
arena_maxclass
+
1
,
chunksize
*
2
);
}
TEST_END
int
main
(
void
)
{
return
(
test
(
test_zero_small
,
test_zero_large
,
test_zero_huge
));
}
Prev
1
…
4
5
6
7
8
Next
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment