Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
fceef8e0
Commit
fceef8e0
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
fe596d67
Changes
143
Show whitespace changes
Inline
Side-by-side
deps/jemalloc/test/unit/tsd.c
0 → 100644
View file @
fceef8e0
#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 @
fceef8e0
#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 @
fceef8e0
#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