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
89a9e5a9
Commit
89a9e5a9
authored
May 09, 2017
by
Guy Benoish
Browse files
Merge branch 'unstable' of
https://github.com/antirez/redis
into unstable
parents
71a8df6a
a4c7f34d
Changes
178
Expand all
Show whitespace changes
Inline
Side-by-side
deps/jemalloc/include/jemalloc/internal/assert.h
deleted
100644 → 0
View file @
71a8df6a
/*
* Define a custom assert() in order to reduce the chances of deadlock during
* assertion failure.
*/
#ifndef assert
#define assert(e) do { \
if (unlikely(config_debug && !(e))) { \
malloc_printf( \
"<jemalloc>: %s:%d: Failed assertion: \"%s\"\n", \
__FILE__, __LINE__, #e); \
abort(); \
} \
} while (0)
#endif
#ifndef not_reached
#define not_reached() do { \
if (config_debug) { \
malloc_printf( \
"<jemalloc>: %s:%d: Unreachable code reached\n", \
__FILE__, __LINE__); \
abort(); \
} \
unreachable(); \
} while (0)
#endif
#ifndef not_implemented
#define not_implemented() do { \
if (config_debug) { \
malloc_printf("<jemalloc>: %s:%d: Not implemented\n", \
__FILE__, __LINE__); \
abort(); \
} \
} while (0)
#endif
#ifndef assert_not_implemented
#define assert_not_implemented(e) do { \
if (unlikely(config_debug && !(e))) \
not_implemented(); \
} while (0)
#endif
deps/jemalloc/include/jemalloc/internal/atomic.h
View file @
89a9e5a9
...
@@ -28,8 +28,8 @@
...
@@ -28,8 +28,8 @@
* callers.
* callers.
*
*
* <t> atomic_read_<t>(<t> *p) { return (*p); }
* <t> atomic_read_<t>(<t> *p) { return (*p); }
* <t> atomic_add_<t>(<t> *p, <t> x) { return (*p +
=
x); }
* <t> atomic_add_<t>(<t> *p, <t> x) { return (*p + x); }
* <t> atomic_sub_<t>(<t> *p, <t> x) { return (*p -
=
x); }
* <t> atomic_sub_<t>(<t> *p, <t> x) { return (*p - x); }
* bool atomic_cas_<t>(<t> *p, <t> c, <t> s)
* bool atomic_cas_<t>(<t> *p, <t> c, <t> s)
* {
* {
* if (*p != c)
* if (*p != c)
...
...
deps/jemalloc/include/jemalloc/internal/base.h
View file @
89a9e5a9
...
@@ -9,13 +9,12 @@
...
@@ -9,13 +9,12 @@
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
void
*
base_alloc
(
tsdn_t
*
tsdn
,
size_t
size
);
void
*
base_alloc
(
size_t
size
);
void
base_stats_get
(
tsdn_t
*
tsdn
,
size_t
*
allocated
,
size_t
*
resident
,
void
base_stats_get
(
size_t
*
allocated
,
size_t
*
resident
,
size_t
*
mapped
);
size_t
*
mapped
);
bool
base_boot
(
void
);
bool
base_boot
(
void
);
void
base_prefork
(
tsdn_t
*
tsdn
);
void
base_prefork
(
void
);
void
base_postfork_parent
(
tsdn_t
*
tsdn
);
void
base_postfork_parent
(
void
);
void
base_postfork_child
(
tsdn_t
*
tsdn
);
void
base_postfork_child
(
void
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
...
deps/jemalloc/include/jemalloc/internal/bitmap.h
View file @
89a9e5a9
...
@@ -15,15 +15,6 @@ typedef unsigned long bitmap_t;
...
@@ -15,15 +15,6 @@ typedef unsigned long bitmap_t;
#define BITMAP_GROUP_NBITS (ZU(1) << LG_BITMAP_GROUP_NBITS)
#define BITMAP_GROUP_NBITS (ZU(1) << LG_BITMAP_GROUP_NBITS)
#define BITMAP_GROUP_NBITS_MASK (BITMAP_GROUP_NBITS-1)
#define BITMAP_GROUP_NBITS_MASK (BITMAP_GROUP_NBITS-1)
/*
* Do some analysis on how big the bitmap is before we use a tree. For a brute
* force linear search, if we would have to call ffs_lu() more than 2^3 times,
* use a tree instead.
*/
#if LG_BITMAP_MAXBITS - LG_BITMAP_GROUP_NBITS > 3
# define USE_TREE
#endif
/* Number of groups required to store a given number of bits. */
/* Number of groups required to store a given number of bits. */
#define BITMAP_BITS2GROUPS(nbits) \
#define BITMAP_BITS2GROUPS(nbits) \
((nbits + BITMAP_GROUP_NBITS_MASK) >> LG_BITMAP_GROUP_NBITS)
((nbits + BITMAP_GROUP_NBITS_MASK) >> LG_BITMAP_GROUP_NBITS)
...
@@ -57,8 +48,6 @@ typedef unsigned long bitmap_t;
...
@@ -57,8 +48,6 @@ typedef unsigned long bitmap_t;
/*
/*
* Maximum number of groups required to support LG_BITMAP_MAXBITS.
* Maximum number of groups required to support LG_BITMAP_MAXBITS.
*/
*/
#ifdef USE_TREE
#if LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS
#if LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS
# define BITMAP_GROUPS_MAX BITMAP_GROUPS_1_LEVEL(BITMAP_MAXBITS)
# define BITMAP_GROUPS_MAX BITMAP_GROUPS_1_LEVEL(BITMAP_MAXBITS)
#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 2
#elif LG_BITMAP_MAXBITS <= LG_BITMAP_GROUP_NBITS * 2
...
@@ -76,12 +65,6 @@ typedef unsigned long bitmap_t;
...
@@ -76,12 +65,6 @@ typedef unsigned long bitmap_t;
(LG_BITMAP_MAXBITS / LG_SIZEOF_BITMAP) \
(LG_BITMAP_MAXBITS / LG_SIZEOF_BITMAP) \
+ !!(LG_BITMAP_MAXBITS % LG_SIZEOF_BITMAP)
+ !!(LG_BITMAP_MAXBITS % LG_SIZEOF_BITMAP)
#else
/* USE_TREE */
#define BITMAP_GROUPS_MAX BITMAP_BITS2GROUPS(BITMAP_MAXBITS)
#endif
/* USE_TREE */
#endif
/* JEMALLOC_H_TYPES */
#endif
/* JEMALLOC_H_TYPES */
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_STRUCTS
#ifdef JEMALLOC_H_STRUCTS
...
@@ -95,7 +78,6 @@ struct bitmap_info_s {
...
@@ -95,7 +78,6 @@ struct bitmap_info_s {
/* Logical number of bits in bitmap (stored at bottom level). */
/* Logical number of bits in bitmap (stored at bottom level). */
size_t
nbits
;
size_t
nbits
;
#ifdef USE_TREE
/* Number of levels necessary for nbits. */
/* Number of levels necessary for nbits. */
unsigned
nlevels
;
unsigned
nlevels
;
...
@@ -104,10 +86,6 @@ struct bitmap_info_s {
...
@@ -104,10 +86,6 @@ struct bitmap_info_s {
* bottom to top (e.g. the bottom level is stored in levels[0]).
* bottom to top (e.g. the bottom level is stored in levels[0]).
*/
*/
bitmap_level_t
levels
[
BITMAP_MAX_LEVELS
+
1
];
bitmap_level_t
levels
[
BITMAP_MAX_LEVELS
+
1
];
#else
/* USE_TREE */
/* Number of groups necessary for nbits. */
size_t
ngroups
;
#endif
/* USE_TREE */
};
};
#endif
/* JEMALLOC_H_STRUCTS */
#endif
/* JEMALLOC_H_STRUCTS */
...
@@ -115,8 +93,9 @@ struct bitmap_info_s {
...
@@ -115,8 +93,9 @@ struct bitmap_info_s {
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
void
bitmap_info_init
(
bitmap_info_t
*
binfo
,
size_t
nbits
);
void
bitmap_info_init
(
bitmap_info_t
*
binfo
,
size_t
nbits
);
size_t
bitmap_info_ngroups
(
const
bitmap_info_t
*
binfo
);
size_t
bitmap_size
(
size_t
nbits
);
void
bitmap_init
(
bitmap_t
*
bitmap
,
const
bitmap_info_t
*
binfo
);
void
bitmap_init
(
bitmap_t
*
bitmap
,
const
bitmap_info_t
*
binfo
);
size_t
bitmap_size
(
const
bitmap_info_t
*
binfo
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
@@ -134,20 +113,10 @@ void bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit);
...
@@ -134,20 +113,10 @@ void bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit);
JEMALLOC_INLINE
bool
JEMALLOC_INLINE
bool
bitmap_full
(
bitmap_t
*
bitmap
,
const
bitmap_info_t
*
binfo
)
bitmap_full
(
bitmap_t
*
bitmap
,
const
bitmap_info_t
*
binfo
)
{
{
#ifdef USE_TREE
unsigned
rgoff
=
binfo
->
levels
[
binfo
->
nlevels
].
group_offset
-
1
;
size_t
rgoff
=
binfo
->
levels
[
binfo
->
nlevels
].
group_offset
-
1
;
bitmap_t
rg
=
bitmap
[
rgoff
];
bitmap_t
rg
=
bitmap
[
rgoff
];
/* The bitmap is full iff the root group is 0. */
/* The bitmap is full iff the root group is 0. */
return
(
rg
==
0
);
return
(
rg
==
0
);
#else
size_t
i
;
for
(
i
=
0
;
i
<
binfo
->
ngroups
;
i
++
)
{
if
(
bitmap
[
i
]
!=
0
)
return
(
false
);
}
return
(
true
);
#endif
}
}
JEMALLOC_INLINE
bool
JEMALLOC_INLINE
bool
...
@@ -159,7 +128,7 @@ bitmap_get(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -159,7 +128,7 @@ bitmap_get(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
assert
(
bit
<
binfo
->
nbits
);
assert
(
bit
<
binfo
->
nbits
);
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
g
=
bitmap
[
goff
];
g
=
bitmap
[
goff
];
return
(
!
(
g
&
(
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
))));
return
(
!
(
g
&
(
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
))));
}
}
JEMALLOC_INLINE
void
JEMALLOC_INLINE
void
...
@@ -174,11 +143,10 @@ bitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -174,11 +143,10 @@ bitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
gp
=
&
bitmap
[
goff
];
gp
=
&
bitmap
[
goff
];
g
=
*
gp
;
g
=
*
gp
;
assert
(
g
&
(
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)));
assert
(
g
&
(
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)));
g
^=
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
g
^=
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
*
gp
=
g
;
*
gp
=
g
;
assert
(
bitmap_get
(
bitmap
,
binfo
,
bit
));
assert
(
bitmap_get
(
bitmap
,
binfo
,
bit
));
#ifdef USE_TREE
/* Propagate group state transitions up the tree. */
/* Propagate group state transitions up the tree. */
if
(
g
==
0
)
{
if
(
g
==
0
)
{
unsigned
i
;
unsigned
i
;
...
@@ -187,14 +155,13 @@ bitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -187,14 +155,13 @@ bitmap_set(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
goff
=
bit
>>
LG_BITMAP_GROUP_NBITS
;
gp
=
&
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
goff
];
gp
=
&
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
goff
];
g
=
*
gp
;
g
=
*
gp
;
assert
(
g
&
(
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)));
assert
(
g
&
(
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)));
g
^=
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
g
^=
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
*
gp
=
g
;
*
gp
=
g
;
if
(
g
!=
0
)
if
(
g
!=
0
)
break
;
break
;
}
}
}
}
#endif
}
}
/* sfu: set first unset. */
/* sfu: set first unset. */
...
@@ -207,24 +174,15 @@ bitmap_sfu(bitmap_t *bitmap, const bitmap_info_t *binfo)
...
@@ -207,24 +174,15 @@ bitmap_sfu(bitmap_t *bitmap, const bitmap_info_t *binfo)
assert
(
!
bitmap_full
(
bitmap
,
binfo
));
assert
(
!
bitmap_full
(
bitmap
,
binfo
));
#ifdef USE_TREE
i
=
binfo
->
nlevels
-
1
;
i
=
binfo
->
nlevels
-
1
;
g
=
bitmap
[
binfo
->
levels
[
i
].
group_offset
];
g
=
bitmap
[
binfo
->
levels
[
i
].
group_offset
];
bit
=
ffs_lu
(
g
)
-
1
;
bit
=
jemalloc_ffsl
(
g
)
-
1
;
while
(
i
>
0
)
{
while
(
i
>
0
)
{
i
--
;
i
--
;
g
=
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
bit
];
g
=
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
bit
];
bit
=
(
bit
<<
LG_BITMAP_GROUP_NBITS
)
+
(
ffs_lu
(
g
)
-
1
);
bit
=
(
bit
<<
LG_BITMAP_GROUP_NBITS
)
+
(
jemalloc_ffsl
(
g
)
-
1
);
}
}
#else
i
=
0
;
g
=
bitmap
[
0
];
while
((
bit
=
ffs_lu
(
g
))
==
0
)
{
i
++
;
g
=
bitmap
[
i
];
}
bit
=
(
i
<<
LG_BITMAP_GROUP_NBITS
)
+
(
bit
-
1
);
#endif
bitmap_set
(
bitmap
,
binfo
,
bit
);
bitmap_set
(
bitmap
,
binfo
,
bit
);
return
(
bit
);
return
(
bit
);
}
}
...
@@ -235,7 +193,7 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -235,7 +193,7 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
size_t
goff
;
size_t
goff
;
bitmap_t
*
gp
;
bitmap_t
*
gp
;
bitmap_t
g
;
bitmap_t
g
;
UNUSED
bool
propagate
;
bool
propagate
;
assert
(
bit
<
binfo
->
nbits
);
assert
(
bit
<
binfo
->
nbits
);
assert
(
bitmap_get
(
bitmap
,
binfo
,
bit
));
assert
(
bitmap_get
(
bitmap
,
binfo
,
bit
));
...
@@ -243,11 +201,10 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -243,11 +201,10 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
gp
=
&
bitmap
[
goff
];
gp
=
&
bitmap
[
goff
];
g
=
*
gp
;
g
=
*
gp
;
propagate
=
(
g
==
0
);
propagate
=
(
g
==
0
);
assert
((
g
&
(
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)))
==
0
);
assert
((
g
&
(
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)))
==
0
);
g
^=
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
g
^=
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
*
gp
=
g
;
*
gp
=
g
;
assert
(
!
bitmap_get
(
bitmap
,
binfo
,
bit
));
assert
(
!
bitmap_get
(
bitmap
,
binfo
,
bit
));
#ifdef USE_TREE
/* Propagate group state transitions up the tree. */
/* Propagate group state transitions up the tree. */
if
(
propagate
)
{
if
(
propagate
)
{
unsigned
i
;
unsigned
i
;
...
@@ -257,15 +214,14 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
...
@@ -257,15 +214,14 @@ bitmap_unset(bitmap_t *bitmap, const bitmap_info_t *binfo, size_t bit)
gp
=
&
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
goff
];
gp
=
&
bitmap
[
binfo
->
levels
[
i
].
group_offset
+
goff
];
g
=
*
gp
;
g
=
*
gp
;
propagate
=
(
g
==
0
);
propagate
=
(
g
==
0
);
assert
((
g
&
(
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)))
assert
((
g
&
(
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
)))
==
0
);
==
0
);
g
^=
ZU
(
1
)
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
g
^=
1LU
<<
(
bit
&
BITMAP_GROUP_NBITS_MASK
);
*
gp
=
g
;
*
gp
=
g
;
if
(
!
propagate
)
if
(
!
propagate
)
break
;
break
;
}
}
}
}
#endif
/* USE_TREE */
}
}
#endif
#endif
...
...
deps/jemalloc/include/jemalloc/internal/chunk.h
View file @
89a9e5a9
...
@@ -48,30 +48,32 @@ extern size_t chunk_npages;
...
@@ -48,30 +48,32 @@ extern size_t chunk_npages;
extern
const
chunk_hooks_t
chunk_hooks_default
;
extern
const
chunk_hooks_t
chunk_hooks_default
;
chunk_hooks_t
chunk_hooks_get
(
tsdn_t
*
tsdn
,
arena_t
*
arena
);
chunk_hooks_t
chunk_hooks_get
(
arena_t
*
arena
);
chunk_hooks_t
chunk_hooks_set
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
chunk_hooks_t
chunk_hooks_set
(
arena_t
*
arena
,
const
chunk_hooks_t
*
chunk_hooks
);
const
chunk_hooks_t
*
chunk_hooks
);
bool
chunk_register
(
tsdn_t
*
tsdn
,
const
void
*
chunk
,
bool
chunk_register
(
const
void
*
chunk
,
const
extent_node_t
*
node
);
const
extent_node_t
*
node
);
void
chunk_deregister
(
const
void
*
chunk
,
const
extent_node_t
*
node
);
void
chunk_deregister
(
const
void
*
chunk
,
const
extent_node_t
*
node
);
void
*
chunk_alloc_base
(
size_t
size
);
void
*
chunk_alloc_base
(
size_t
size
);
void
*
chunk_alloc_cache
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
void
*
chunk_alloc_cache
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
chunk_hooks_t
*
chunk_hooks
,
void
*
new_addr
,
size_t
size
,
size_t
alignment
,
void
*
new_addr
,
size_t
size
,
size_t
alignment
,
bool
*
zero
,
size_t
*
sn
,
bool
*
zero
,
bool
*
commit
,
bool
dalloc_node
);
bool
dalloc_node
);
void
*
chunk_alloc_wrapper
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
void
*
chunk_alloc_wrapper
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
chunk_hooks_t
*
chunk_hooks
,
void
*
new_addr
,
size_t
size
,
size_t
alignment
,
void
*
new_addr
,
size_t
size
,
size_t
alignment
,
bool
*
zero
,
bool
*
commit
);
size_t
*
sn
,
bool
*
zero
,
bool
*
commit
);
void
chunk_dalloc_cache
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
void
chunk_dalloc_cache
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
void
*
chunk
,
size_t
size
,
bool
committed
);
chunk_hooks_t
*
chunk_hooks
,
void
*
chunk
,
size_t
size
,
size_t
sn
,
void
chunk_dalloc_arena
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
bool
committed
);
void
*
chunk
,
size_t
size
,
bool
zeroed
,
bool
committed
);
void
chunk_dalloc_wrapper
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
void
chunk_dalloc_wrapper
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
chunk_hooks_t
*
chunk_hooks
,
void
*
chunk
,
size_t
size
,
size_t
sn
,
void
*
chunk
,
size_t
size
,
bool
committed
);
bool
zeroed
,
bool
committed
);
bool
chunk_purge_arena
(
arena_t
*
arena
,
void
*
chunk
,
size_t
offset
,
bool
chunk_purge_wrapper
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
void
*
chunk
,
size_t
size
,
size_t
offset
,
size_t
length
);
size_t
length
);
bool
chunk_purge_wrapper
(
arena_t
*
arena
,
chunk_hooks_t
*
chunk_hooks
,
void
*
chunk
,
size_t
size
,
size_t
offset
,
size_t
length
);
bool
chunk_boot
(
void
);
bool
chunk_boot
(
void
);
void
chunk_prefork
(
void
);
void
chunk_postfork_parent
(
void
);
void
chunk_postfork_child
(
void
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
...
deps/jemalloc/include/jemalloc/internal/chunk_dss.h
View file @
89a9e5a9
...
@@ -23,11 +23,13 @@ extern const char *dss_prec_names[];
...
@@ -23,11 +23,13 @@ extern const char *dss_prec_names[];
dss_prec_t
chunk_dss_prec_get
(
void
);
dss_prec_t
chunk_dss_prec_get
(
void
);
bool
chunk_dss_prec_set
(
dss_prec_t
dss_prec
);
bool
chunk_dss_prec_set
(
dss_prec_t
dss_prec
);
void
*
chunk_alloc_dss
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
void
*
new_addr
,
void
*
chunk_alloc_dss
(
arena_t
*
arena
,
void
*
new_addr
,
size_t
size
,
size_t
size
,
size_t
alignment
,
bool
*
zero
,
bool
*
commit
);
size_t
alignment
,
bool
*
zero
,
bool
*
commit
);
bool
chunk_in_dss
(
void
*
chunk
);
bool
chunk_in_dss
(
void
*
chunk
);
bool
chunk_dss_mergeable
(
void
*
chunk_a
,
void
*
chunk_b
);
bool
chunk_dss_boot
(
void
);
void
chunk_dss_boot
(
void
);
void
chunk_dss_prefork
(
void
);
void
chunk_dss_postfork_parent
(
void
);
void
chunk_dss_postfork_child
(
void
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
...
deps/jemalloc/include/jemalloc/internal/chunk_mmap.h
View file @
89a9e5a9
...
@@ -9,8 +9,8 @@
...
@@ -9,8 +9,8 @@
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
void
*
chunk_alloc_mmap
(
void
*
new_addr
,
size_t
size
,
size_t
alignment
,
void
*
chunk_alloc_mmap
(
size_t
size
,
size_t
alignment
,
bool
*
zero
,
bool
*
zero
,
bool
*
commit
);
bool
*
commit
);
bool
chunk_dalloc_mmap
(
void
*
chunk
,
size_t
size
);
bool
chunk_dalloc_mmap
(
void
*
chunk
,
size_t
size
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
...
...
deps/jemalloc/include/jemalloc/internal/ckh.h
View file @
89a9e5a9
...
@@ -40,7 +40,9 @@ struct ckh_s {
...
@@ -40,7 +40,9 @@ struct ckh_s {
#endif
#endif
/* Used for pseudo-random number generation. */
/* Used for pseudo-random number generation. */
uint64_t
prng_state
;
#define CKH_A 1103515241
#define CKH_C 12347
uint32_t
prng_state
;
/* Total number of items. */
/* Total number of items. */
size_t
count
;
size_t
count
;
...
@@ -72,7 +74,7 @@ bool ckh_iter(ckh_t *ckh, size_t *tabind, void **key, void **data);
...
@@ -72,7 +74,7 @@ bool ckh_iter(ckh_t *ckh, size_t *tabind, void **key, void **data);
bool
ckh_insert
(
tsd_t
*
tsd
,
ckh_t
*
ckh
,
const
void
*
key
,
const
void
*
data
);
bool
ckh_insert
(
tsd_t
*
tsd
,
ckh_t
*
ckh
,
const
void
*
key
,
const
void
*
data
);
bool
ckh_remove
(
tsd_t
*
tsd
,
ckh_t
*
ckh
,
const
void
*
searchkey
,
void
**
key
,
bool
ckh_remove
(
tsd_t
*
tsd
,
ckh_t
*
ckh
,
const
void
*
searchkey
,
void
**
key
,
void
**
data
);
void
**
data
);
bool
ckh_search
(
ckh_t
*
ckh
,
const
void
*
sea
r
chkey
,
void
**
key
,
void
**
data
);
bool
ckh_search
(
ckh_t
*
ckh
,
const
void
*
seachkey
,
void
**
key
,
void
**
data
);
void
ckh_string_hash
(
const
void
*
key
,
size_t
r_hash
[
2
]);
void
ckh_string_hash
(
const
void
*
key
,
size_t
r_hash
[
2
]);
bool
ckh_string_keycomp
(
const
void
*
k1
,
const
void
*
k2
);
bool
ckh_string_keycomp
(
const
void
*
k1
,
const
void
*
k2
);
void
ckh_pointer_hash
(
const
void
*
key
,
size_t
r_hash
[
2
]);
void
ckh_pointer_hash
(
const
void
*
key
,
size_t
r_hash
[
2
]);
...
...
deps/jemalloc/include/jemalloc/internal/ctl.h
View file @
89a9e5a9
...
@@ -21,14 +21,13 @@ struct ctl_named_node_s {
...
@@ -21,14 +21,13 @@ struct ctl_named_node_s {
/* If (nchildren == 0), this is a terminal node. */
/* If (nchildren == 0), this is a terminal node. */
unsigned
nchildren
;
unsigned
nchildren
;
const
ctl_node_t
*
children
;
const
ctl_node_t
*
children
;
int
(
*
ctl
)(
tsd_t
*
,
const
size_t
*
,
size_t
,
void
*
,
int
(
*
ctl
)(
const
size_t
*
,
size_t
,
void
*
,
size_t
*
,
size_t
*
,
void
*
,
size_t
);
void
*
,
size_t
);
};
};
struct
ctl_indexed_node_s
{
struct
ctl_indexed_node_s
{
struct
ctl_node_s
node
;
struct
ctl_node_s
node
;
const
ctl_named_node_t
*
(
*
index
)(
tsdn_t
*
,
const
size_t
*
,
size_t
,
const
ctl_named_node_t
*
(
*
index
)(
const
size_t
*
,
size_t
,
size_t
);
size_t
);
};
};
struct
ctl_arena_stats_s
{
struct
ctl_arena_stats_s
{
...
@@ -36,12 +35,8 @@ struct ctl_arena_stats_s {
...
@@ -36,12 +35,8 @@ struct ctl_arena_stats_s {
unsigned
nthreads
;
unsigned
nthreads
;
const
char
*
dss
;
const
char
*
dss
;
ssize_t
lg_dirty_mult
;
ssize_t
lg_dirty_mult
;
ssize_t
decay_time
;
size_t
pactive
;
size_t
pactive
;
size_t
pdirty
;
size_t
pdirty
;
/* The remainder are only populated if config_stats is true. */
arena_stats_t
astats
;
arena_stats_t
astats
;
/* Aggregate stats for small size classes, based on bin stats. */
/* Aggregate stats for small size classes, based on bin stats. */
...
@@ -61,7 +56,6 @@ struct ctl_stats_s {
...
@@ -61,7 +56,6 @@ struct ctl_stats_s {
size_t
metadata
;
size_t
metadata
;
size_t
resident
;
size_t
resident
;
size_t
mapped
;
size_t
mapped
;
size_t
retained
;
unsigned
narenas
;
unsigned
narenas
;
ctl_arena_stats_t
*
arenas
;
/* (narenas + 1) elements. */
ctl_arena_stats_t
*
arenas
;
/* (narenas + 1) elements. */
};
};
...
@@ -70,17 +64,16 @@ struct ctl_stats_s {
...
@@ -70,17 +64,16 @@ struct ctl_stats_s {
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
int
ctl_byname
(
tsd_t
*
tsd
,
const
char
*
name
,
void
*
oldp
,
size_t
*
oldlenp
,
int
ctl_byname
(
const
char
*
name
,
void
*
oldp
,
size_t
*
oldlenp
,
void
*
newp
,
void
*
newp
,
size_t
newlen
);
size_t
newlen
);
int
ctl_nametomib
(
tsdn_t
*
tsdn
,
const
char
*
name
,
size_t
*
mibp
,
int
ctl_nametomib
(
const
char
*
name
,
size_t
*
mibp
,
size_t
*
miblenp
);
size_t
*
miblenp
);
int
ctl_bymib
(
tsd_t
*
tsd
,
const
size_t
*
mib
,
size_t
miblen
,
void
*
oldp
,
int
ctl_bymib
(
const
size_t
*
mib
,
size_t
miblen
,
void
*
oldp
,
size_t
*
oldlenp
,
size_t
*
oldlenp
,
void
*
newp
,
size_t
newlen
);
void
*
newp
,
size_t
newlen
);
bool
ctl_boot
(
void
);
bool
ctl_boot
(
void
);
void
ctl_prefork
(
tsdn_t
*
tsdn
);
void
ctl_prefork
(
void
);
void
ctl_postfork_parent
(
tsdn_t
*
tsdn
);
void
ctl_postfork_parent
(
void
);
void
ctl_postfork_child
(
tsdn_t
*
tsdn
);
void
ctl_postfork_child
(
void
);
#define xmallctl(name, oldp, oldlenp, newp, newlen) do { \
#define xmallctl(name, oldp, oldlenp, newp, newlen) do { \
if (je_mallctl(name, oldp, oldlenp, newp, newlen) \
if (je_mallctl(name, oldp, oldlenp, newp, newlen) \
...
...
deps/jemalloc/include/jemalloc/internal/extent.h
View file @
89a9e5a9
...
@@ -18,20 +18,6 @@ struct extent_node_s {
...
@@ -18,20 +18,6 @@ struct extent_node_s {
/* Total region size. */
/* Total region size. */
size_t
en_size
;
size_t
en_size
;
/*
* Serial number (potentially non-unique).
*
* In principle serial numbers can wrap around on 32-bit systems if
* JEMALLOC_MUNMAP is defined, but as long as comparison functions fall
* back on address comparison for equal serial numbers, stable (if
* imperfect) ordering is maintained.
*
* Serial numbers may not be unique even in the absence of wrap-around,
* e.g. when splitting an extent and assigning the same serial number to
* both resulting adjacent extents.
*/
size_t
en_sn
;
/*
/*
* The zeroed flag is used by chunk recycling code to track whether
* The zeroed flag is used by chunk recycling code to track whether
* memory is zero-filled.
* memory is zero-filled.
...
@@ -59,10 +45,10 @@ struct extent_node_s {
...
@@ -59,10 +45,10 @@ struct extent_node_s {
qr
(
extent_node_t
)
cc_link
;
qr
(
extent_node_t
)
cc_link
;
union
{
union
{
/* Linkage for the size/
sn/
address-ordered tree. */
/* Linkage for the size/address-ordered tree. */
rb_node
(
extent_node_t
)
sz
sn
ad_link
;
rb_node
(
extent_node_t
)
szad_link
;
/* Linkage for arena's
achunks,
huge
,
and node_cache lists. */
/* Linkage for arena's huge and node_cache lists. */
ql_elm
(
extent_node_t
)
ql_link
;
ql_elm
(
extent_node_t
)
ql_link
;
};
};
...
@@ -75,7 +61,7 @@ typedef rb_tree(extent_node_t) extent_tree_t;
...
@@ -75,7 +61,7 @@ typedef rb_tree(extent_node_t) extent_tree_t;
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
rb_proto
(,
extent_tree_sz
sn
ad_
,
extent_tree_t
,
extent_node_t
)
rb_proto
(,
extent_tree_szad_
,
extent_tree_t
,
extent_node_t
)
rb_proto
(,
extent_tree_ad_
,
extent_tree_t
,
extent_node_t
)
rb_proto
(,
extent_tree_ad_
,
extent_tree_t
,
extent_node_t
)
...
@@ -87,7 +73,6 @@ rb_proto(, extent_tree_ad_, extent_tree_t, extent_node_t)
...
@@ -87,7 +73,6 @@ rb_proto(, extent_tree_ad_, extent_tree_t, extent_node_t)
arena_t
*
extent_node_arena_get
(
const
extent_node_t
*
node
);
arena_t
*
extent_node_arena_get
(
const
extent_node_t
*
node
);
void
*
extent_node_addr_get
(
const
extent_node_t
*
node
);
void
*
extent_node_addr_get
(
const
extent_node_t
*
node
);
size_t
extent_node_size_get
(
const
extent_node_t
*
node
);
size_t
extent_node_size_get
(
const
extent_node_t
*
node
);
size_t
extent_node_sn_get
(
const
extent_node_t
*
node
);
bool
extent_node_zeroed_get
(
const
extent_node_t
*
node
);
bool
extent_node_zeroed_get
(
const
extent_node_t
*
node
);
bool
extent_node_committed_get
(
const
extent_node_t
*
node
);
bool
extent_node_committed_get
(
const
extent_node_t
*
node
);
bool
extent_node_achunk_get
(
const
extent_node_t
*
node
);
bool
extent_node_achunk_get
(
const
extent_node_t
*
node
);
...
@@ -95,13 +80,12 @@ prof_tctx_t *extent_node_prof_tctx_get(const extent_node_t *node);
...
@@ -95,13 +80,12 @@ prof_tctx_t *extent_node_prof_tctx_get(const extent_node_t *node);
void
extent_node_arena_set
(
extent_node_t
*
node
,
arena_t
*
arena
);
void
extent_node_arena_set
(
extent_node_t
*
node
,
arena_t
*
arena
);
void
extent_node_addr_set
(
extent_node_t
*
node
,
void
*
addr
);
void
extent_node_addr_set
(
extent_node_t
*
node
,
void
*
addr
);
void
extent_node_size_set
(
extent_node_t
*
node
,
size_t
size
);
void
extent_node_size_set
(
extent_node_t
*
node
,
size_t
size
);
void
extent_node_sn_set
(
extent_node_t
*
node
,
size_t
sn
);
void
extent_node_zeroed_set
(
extent_node_t
*
node
,
bool
zeroed
);
void
extent_node_zeroed_set
(
extent_node_t
*
node
,
bool
zeroed
);
void
extent_node_committed_set
(
extent_node_t
*
node
,
bool
committed
);
void
extent_node_committed_set
(
extent_node_t
*
node
,
bool
committed
);
void
extent_node_achunk_set
(
extent_node_t
*
node
,
bool
achunk
);
void
extent_node_achunk_set
(
extent_node_t
*
node
,
bool
achunk
);
void
extent_node_prof_tctx_set
(
extent_node_t
*
node
,
prof_tctx_t
*
tctx
);
void
extent_node_prof_tctx_set
(
extent_node_t
*
node
,
prof_tctx_t
*
tctx
);
void
extent_node_init
(
extent_node_t
*
node
,
arena_t
*
arena
,
void
*
addr
,
void
extent_node_init
(
extent_node_t
*
node
,
arena_t
*
arena
,
void
*
addr
,
size_t
size
,
size_t
sn
,
bool
zeroed
,
bool
committed
);
size_t
size
,
bool
zeroed
,
bool
committed
);
void
extent_node_dirty_linkage_init
(
extent_node_t
*
node
);
void
extent_node_dirty_linkage_init
(
extent_node_t
*
node
);
void
extent_node_dirty_insert
(
extent_node_t
*
node
,
void
extent_node_dirty_insert
(
extent_node_t
*
node
,
arena_runs_dirty_link_t
*
runs_dirty
,
extent_node_t
*
chunks_dirty
);
arena_runs_dirty_link_t
*
runs_dirty
,
extent_node_t
*
chunks_dirty
);
...
@@ -130,13 +114,6 @@ extent_node_size_get(const extent_node_t *node)
...
@@ -130,13 +114,6 @@ extent_node_size_get(const extent_node_t *node)
return
(
node
->
en_size
);
return
(
node
->
en_size
);
}
}
JEMALLOC_INLINE
size_t
extent_node_sn_get
(
const
extent_node_t
*
node
)
{
return
(
node
->
en_sn
);
}
JEMALLOC_INLINE
bool
JEMALLOC_INLINE
bool
extent_node_zeroed_get
(
const
extent_node_t
*
node
)
extent_node_zeroed_get
(
const
extent_node_t
*
node
)
{
{
...
@@ -187,13 +164,6 @@ extent_node_size_set(extent_node_t *node, size_t size)
...
@@ -187,13 +164,6 @@ extent_node_size_set(extent_node_t *node, size_t size)
node
->
en_size
=
size
;
node
->
en_size
=
size
;
}
}
JEMALLOC_INLINE
void
extent_node_sn_set
(
extent_node_t
*
node
,
size_t
sn
)
{
node
->
en_sn
=
sn
;
}
JEMALLOC_INLINE
void
JEMALLOC_INLINE
void
extent_node_zeroed_set
(
extent_node_t
*
node
,
bool
zeroed
)
extent_node_zeroed_set
(
extent_node_t
*
node
,
bool
zeroed
)
{
{
...
@@ -224,13 +194,12 @@ extent_node_prof_tctx_set(extent_node_t *node, prof_tctx_t *tctx)
...
@@ -224,13 +194,12 @@ extent_node_prof_tctx_set(extent_node_t *node, prof_tctx_t *tctx)
JEMALLOC_INLINE
void
JEMALLOC_INLINE
void
extent_node_init
(
extent_node_t
*
node
,
arena_t
*
arena
,
void
*
addr
,
size_t
size
,
extent_node_init
(
extent_node_t
*
node
,
arena_t
*
arena
,
void
*
addr
,
size_t
size
,
size_t
sn
,
bool
zeroed
,
bool
committed
)
bool
zeroed
,
bool
committed
)
{
{
extent_node_arena_set
(
node
,
arena
);
extent_node_arena_set
(
node
,
arena
);
extent_node_addr_set
(
node
,
addr
);
extent_node_addr_set
(
node
,
addr
);
extent_node_size_set
(
node
,
size
);
extent_node_size_set
(
node
,
size
);
extent_node_sn_set
(
node
,
sn
);
extent_node_zeroed_set
(
node
,
zeroed
);
extent_node_zeroed_set
(
node
,
zeroed
);
extent_node_committed_set
(
node
,
committed
);
extent_node_committed_set
(
node
,
committed
);
extent_node_achunk_set
(
node
,
false
);
extent_node_achunk_set
(
node
,
false
);
...
...
deps/jemalloc/include/jemalloc/internal/hash.h
View file @
89a9e5a9
/*
/*
* The following hash function is based on MurmurHash3, placed into the public
* The following hash function is based on MurmurHash3, placed into the public
* domain by Austin Appleby. See http
s
://
github.com/aappleby
/smhasher for
* domain by Austin Appleby. See http://
code.google.com/p
/smhasher
/
for
* details.
* details.
*/
*/
/******************************************************************************/
/******************************************************************************/
...
@@ -49,14 +49,6 @@ JEMALLOC_INLINE uint32_t
...
@@ -49,14 +49,6 @@ JEMALLOC_INLINE uint32_t
hash_get_block_32
(
const
uint32_t
*
p
,
int
i
)
hash_get_block_32
(
const
uint32_t
*
p
,
int
i
)
{
{
/* Handle unaligned read. */
if
(
unlikely
((
uintptr_t
)
p
&
(
sizeof
(
uint32_t
)
-
1
))
!=
0
)
{
uint32_t
ret
;
memcpy
(
&
ret
,
(
uint8_t
*
)(
p
+
i
),
sizeof
(
uint32_t
));
return
(
ret
);
}
return
(
p
[
i
]);
return
(
p
[
i
]);
}
}
...
@@ -64,14 +56,6 @@ JEMALLOC_INLINE uint64_t
...
@@ -64,14 +56,6 @@ JEMALLOC_INLINE uint64_t
hash_get_block_64
(
const
uint64_t
*
p
,
int
i
)
hash_get_block_64
(
const
uint64_t
*
p
,
int
i
)
{
{
/* Handle unaligned read. */
if
(
unlikely
((
uintptr_t
)
p
&
(
sizeof
(
uint64_t
)
-
1
))
!=
0
)
{
uint64_t
ret
;
memcpy
(
&
ret
,
(
uint8_t
*
)(
p
+
i
),
sizeof
(
uint64_t
));
return
(
ret
);
}
return
(
p
[
i
]);
return
(
p
[
i
]);
}
}
...
@@ -337,18 +321,13 @@ hash_x64_128(const void *key, const int len, const uint32_t seed,
...
@@ -337,18 +321,13 @@ hash_x64_128(const void *key, const int len, const uint32_t seed,
JEMALLOC_INLINE
void
JEMALLOC_INLINE
void
hash
(
const
void
*
key
,
size_t
len
,
const
uint32_t
seed
,
size_t
r_hash
[
2
])
hash
(
const
void
*
key
,
size_t
len
,
const
uint32_t
seed
,
size_t
r_hash
[
2
])
{
{
assert
(
len
<=
INT_MAX
);
/* Unfortunate implementation limitation. */
#if (LG_SIZEOF_PTR == 3 && !defined(JEMALLOC_BIG_ENDIAN))
#if (LG_SIZEOF_PTR == 3 && !defined(JEMALLOC_BIG_ENDIAN))
hash_x64_128
(
key
,
(
int
)
len
,
seed
,
(
uint64_t
*
)
r_hash
);
hash_x64_128
(
key
,
len
,
seed
,
(
uint64_t
*
)
r_hash
);
#else
#else
{
uint64_t
hashes
[
2
];
uint64_t
hashes
[
2
];
hash_x86_128
(
key
,
(
int
)
len
,
seed
,
hashes
);
hash_x86_128
(
key
,
len
,
seed
,
hashes
);
r_hash
[
0
]
=
(
size_t
)
hashes
[
0
];
r_hash
[
0
]
=
(
size_t
)
hashes
[
0
];
r_hash
[
1
]
=
(
size_t
)
hashes
[
1
];
r_hash
[
1
]
=
(
size_t
)
hashes
[
1
];
}
#endif
#endif
}
}
#endif
#endif
...
...
deps/jemalloc/include/jemalloc/internal/huge.h
View file @
89a9e5a9
...
@@ -9,23 +9,24 @@
...
@@ -9,23 +9,24 @@
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
void
*
huge_malloc
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
size_t
usize
,
bool
zero
);
void
*
huge_malloc
(
tsd_t
*
tsd
,
arena_t
*
arena
,
size_t
size
,
bool
zero
,
void
*
huge_palloc
(
tsdn_t
*
tsdn
,
arena_t
*
arena
,
size_t
usize
,
tcache_t
*
tcache
);
size_t
alignment
,
bool
zero
);
void
*
huge_palloc
(
tsd_t
*
tsd
,
arena_t
*
arena
,
size_t
size
,
size_t
alignment
,
bool
huge_ralloc_no_move
(
tsdn_t
*
tsdn
,
void
*
ptr
,
size_t
oldsize
,
bool
zero
,
tcache_t
*
tcache
);
size_t
usize_min
,
size_t
usize_max
,
bool
zero
);
bool
huge_ralloc_no_move
(
void
*
ptr
,
size_t
oldsize
,
size_t
usize_min
,
size_t
usize_max
,
bool
zero
);
void
*
huge_ralloc
(
tsd_t
*
tsd
,
arena_t
*
arena
,
void
*
ptr
,
size_t
oldsize
,
void
*
huge_ralloc
(
tsd_t
*
tsd
,
arena_t
*
arena
,
void
*
ptr
,
size_t
oldsize
,
size_t
usize
,
size_t
alignment
,
bool
zero
,
tcache_t
*
tcache
);
size_t
usize
,
size_t
alignment
,
bool
zero
,
tcache_t
*
tcache
);
#ifdef JEMALLOC_JET
#ifdef JEMALLOC_JET
typedef
void
(
huge_dalloc_junk_t
)(
void
*
,
size_t
);
typedef
void
(
huge_dalloc_junk_t
)(
void
*
,
size_t
);
extern
huge_dalloc_junk_t
*
huge_dalloc_junk
;
extern
huge_dalloc_junk_t
*
huge_dalloc_junk
;
#endif
#endif
void
huge_dalloc
(
tsd
n
_t
*
tsd
n
,
void
*
ptr
);
void
huge_dalloc
(
tsd_t
*
tsd
,
void
*
ptr
,
tcache_t
*
tcache
);
arena_t
*
huge_aalloc
(
const
void
*
ptr
);
arena_t
*
huge_aalloc
(
const
void
*
ptr
);
size_t
huge_salloc
(
tsdn_t
*
tsdn
,
const
void
*
ptr
);
size_t
huge_salloc
(
const
void
*
ptr
);
prof_tctx_t
*
huge_prof_tctx_get
(
tsdn_t
*
tsdn
,
const
void
*
ptr
);
prof_tctx_t
*
huge_prof_tctx_get
(
const
void
*
ptr
);
void
huge_prof_tctx_set
(
tsdn_t
*
tsdn
,
const
void
*
ptr
,
prof_tctx_t
*
tctx
);
void
huge_prof_tctx_set
(
const
void
*
ptr
,
prof_tctx_t
*
tctx
);
void
huge_prof_tctx_reset
(
tsdn_t
*
tsdn
,
const
void
*
ptr
);
void
huge_prof_tctx_reset
(
const
void
*
ptr
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
...
deps/jemalloc/include/jemalloc/internal/jemalloc_internal.h.in
View file @
89a9e5a9
This diff is collapsed.
Click to expand it.
deps/jemalloc/include/jemalloc/internal/jemalloc_internal_decls.h
View file @
89a9e5a9
...
@@ -17,18 +17,7 @@
...
@@ -17,18 +17,7 @@
# include <sys/uio.h>
# include <sys/uio.h>
# endif
# endif
# include <pthread.h>
# include <pthread.h>
# ifdef JEMALLOC_OS_UNFAIR_LOCK
# include <os/lock.h>
# endif
# ifdef JEMALLOC_GLIBC_MALLOC_HOOK
# include <sched.h>
# endif
# include <errno.h>
# include <errno.h>
# include <sys/time.h>
# include <time.h>
# ifdef JEMALLOC_HAVE_MACH_ABSOLUTE_TIME
# include <mach/mach_time.h>
# endif
#endif
#endif
#include <sys/types.h>
#include <sys/types.h>
...
...
deps/jemalloc/include/jemalloc/internal/jemalloc_internal_defs.h.in
View file @
89a9e5a9
...
@@ -56,9 +56,9 @@
...
@@ -56,9 +56,9 @@
#undef JEMALLOC_HAVE_BUILTIN_CLZ
#undef JEMALLOC_HAVE_BUILTIN_CLZ
/*
/*
* Defined if
os_unfair_lock_*() functions are available, as provided by Darwin
.
* Defined if
madvise(2) is available
.
*/
*/
#undef JEMALLOC_
OS_UNFAIR_LOCK
#undef JEMALLOC_
HAVE_MADVISE
/*
/*
* Defined if OSSpin*() functions are available, as provided by Darwin, and
* Defined if OSSpin*() functions are available, as provided by Darwin, and
...
@@ -66,9 +66,6 @@
...
@@ -66,9 +66,6 @@
*/
*/
#undef JEMALLOC_OSSPIN
#undef JEMALLOC_OSSPIN
/* Defined if syscall(2) is usable. */
#undef JEMALLOC_USE_SYSCALL
/*
/*
* Defined if secure_getenv(3) is available.
* Defined if secure_getenv(3) is available.
*/
*/
...
@@ -79,24 +76,6 @@
...
@@ -79,24 +76,6 @@
*/
*/
#undef JEMALLOC_HAVE_ISSETUGID
#undef JEMALLOC_HAVE_ISSETUGID
/* Defined if pthread_atfork(3) is available. */
#undef JEMALLOC_HAVE_PTHREAD_ATFORK
/*
* Defined if clock_gettime(CLOCK_MONOTONIC_COARSE, ...) is available.
*/
#undef JEMALLOC_HAVE_CLOCK_MONOTONIC_COARSE
/*
* Defined if clock_gettime(CLOCK_MONOTONIC, ...) is available.
*/
#undef JEMALLOC_HAVE_CLOCK_MONOTONIC
/*
* Defined if mach_absolute_time() is available.
*/
#undef JEMALLOC_HAVE_MACH_ABSOLUTE_TIME
/*
/*
* Defined if _malloc_thread_cleanup() exists. At least in the case of
* Defined if _malloc_thread_cleanup() exists. At least in the case of
* FreeBSD, pthread_key_create() allocates, which if used during malloc
* FreeBSD, pthread_key_create() allocates, which if used during malloc
...
@@ -210,16 +189,9 @@
...
@@ -210,16 +189,9 @@
#undef JEMALLOC_TLS
#undef JEMALLOC_TLS
/*
/*
*
Used to mark unreachable code to quiet "end of non-void" compiler warnings.
*
ffs()/ffsl() functions to use for bitmapping. Don't use these directly;
*
Don't use this directly;
instead use
unreachable
() from util.h
* instead
,
use
jemalloc_ffs() or jemalloc_ffsl
() from util.h
.
*/
*/
#undef JEMALLOC_INTERNAL_UNREACHABLE
/*
* ffs*() functions to use for bitmapping. Don't use these directly; instead,
* use ffs_*() from util.h.
*/
#undef JEMALLOC_INTERNAL_FFSLL
#undef JEMALLOC_INTERNAL_FFSL
#undef JEMALLOC_INTERNAL_FFSL
#undef JEMALLOC_INTERNAL_FFS
#undef JEMALLOC_INTERNAL_FFS
...
@@ -241,35 +213,18 @@
...
@@ -241,35 +213,18 @@
#undef JEMALLOC_ZONE
#undef JEMALLOC_ZONE
#undef JEMALLOC_ZONE_VERSION
#undef JEMALLOC_ZONE_VERSION
/*
* Methods for determining whether the OS overcommits.
* JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY: Linux's
* /proc/sys/vm.overcommit_memory file.
* JEMALLOC_SYSCTL_VM_OVERCOMMIT: FreeBSD's vm.overcommit sysctl.
*/
#undef JEMALLOC_SYSCTL_VM_OVERCOMMIT
#undef JEMALLOC_PROC_SYS_VM_OVERCOMMIT_MEMORY
/* Defined if madvise(2) is available. */
#undef JEMALLOC_HAVE_MADVISE
/*
/*
* Methods for purging unused pages differ between operating systems.
* Methods for purging unused pages differ between operating systems.
*
*
* madvise(..., MADV_FREE) : This marks pages as being unused, such that they
* madvise(..., MADV_DONTNEED) : On Linux, this immediately discards pages,
* will be discarded rather than swapped out.
* such that new pages will be demand-zeroed if
* madvise(..., MADV_DONTNEED) : This immediately discards pages, such that
* the address region is later touched.
* new pages will be demand-zeroed if the
* madvise(..., MADV_FREE) : On FreeBSD and Darwin, this marks pages as being
* address region is later touched.
* unused, such that they will be discarded rather
* than swapped out.
*/
*/
#undef JEMALLOC_PURGE_MADVISE_FREE
#undef JEMALLOC_PURGE_MADVISE_DONTNEED
#undef JEMALLOC_PURGE_MADVISE_DONTNEED
#undef JEMALLOC_PURGE_MADVISE_FREE
/*
* Defined if transparent huge pages are supported via the MADV_[NO]HUGEPAGE
* arguments to madvise(2).
*/
#undef JEMALLOC_THP
/* Define if operating system has alloca.h header. */
/* Define if operating system has alloca.h header. */
#undef JEMALLOC_HAS_ALLOCA_H
#undef JEMALLOC_HAS_ALLOCA_H
...
@@ -286,9 +241,6 @@
...
@@ -286,9 +241,6 @@
/* sizeof(long) == 2^LG_SIZEOF_LONG. */
/* sizeof(long) == 2^LG_SIZEOF_LONG. */
#undef LG_SIZEOF_LONG
#undef LG_SIZEOF_LONG
/* sizeof(long long) == 2^LG_SIZEOF_LONG_LONG. */
#undef LG_SIZEOF_LONG_LONG
/* sizeof(intmax_t) == 2^LG_SIZEOF_INTMAX_T. */
/* sizeof(intmax_t) == 2^LG_SIZEOF_INTMAX_T. */
#undef LG_SIZEOF_INTMAX_T
#undef LG_SIZEOF_INTMAX_T
...
@@ -307,7 +259,4 @@
...
@@ -307,7 +259,4 @@
*/
*/
#undef JEMALLOC_EXPORT
#undef JEMALLOC_EXPORT
/* config.malloc_conf options string. */
#undef JEMALLOC_CONFIG_MALLOC_CONF
#endif /* JEMALLOC_INTERNAL_DEFS_H_ */
#endif /* JEMALLOC_INTERNAL_DEFS_H_ */
deps/jemalloc/include/jemalloc/internal/mb.h
View file @
89a9e5a9
...
@@ -42,7 +42,7 @@ mb_write(void)
...
@@ -42,7 +42,7 @@ mb_write(void)
:
/* Inputs. */
:
/* Inputs. */
:
"memory"
/* Clobbers. */
:
"memory"
/* Clobbers. */
);
);
#
else
#else
/*
/*
* This is hopefully enough to keep the compiler from reordering
* This is hopefully enough to keep the compiler from reordering
* instructions around this one.
* instructions around this one.
...
@@ -52,7 +52,7 @@ mb_write(void)
...
@@ -52,7 +52,7 @@ mb_write(void)
:
/* Inputs. */
:
/* Inputs. */
:
"memory"
/* Clobbers. */
:
"memory"
/* Clobbers. */
);
);
#
endif
#endif
}
}
#elif (defined(__amd64__) || defined(__x86_64__))
#elif (defined(__amd64__) || defined(__x86_64__))
JEMALLOC_INLINE
void
JEMALLOC_INLINE
void
...
@@ -104,9 +104,9 @@ mb_write(void)
...
@@ -104,9 +104,9 @@ mb_write(void)
{
{
malloc_mutex_t
mtx
;
malloc_mutex_t
mtx
;
malloc_mutex_init
(
&
mtx
,
"mb"
,
WITNESS_RANK_OMIT
);
malloc_mutex_init
(
&
mtx
);
malloc_mutex_lock
(
TSDN_NULL
,
&
mtx
);
malloc_mutex_lock
(
&
mtx
);
malloc_mutex_unlock
(
TSDN_NULL
,
&
mtx
);
malloc_mutex_unlock
(
&
mtx
);
}
}
#endif
#endif
#endif
#endif
...
...
deps/jemalloc/include/jemalloc/internal/mutex.h
View file @
89a9e5a9
This diff is collapsed.
Click to expand it.
deps/jemalloc/include/jemalloc/internal/nstime.h
deleted
100644 → 0
View file @
71a8df6a
/******************************************************************************/
#ifdef JEMALLOC_H_TYPES
typedef
struct
nstime_s
nstime_t
;
/* Maximum supported number of seconds (~584 years). */
#define NSTIME_SEC_MAX KQU(18446744072)
#endif
/* JEMALLOC_H_TYPES */
/******************************************************************************/
#ifdef JEMALLOC_H_STRUCTS
struct
nstime_s
{
uint64_t
ns
;
};
#endif
/* JEMALLOC_H_STRUCTS */
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
void
nstime_init
(
nstime_t
*
time
,
uint64_t
ns
);
void
nstime_init2
(
nstime_t
*
time
,
uint64_t
sec
,
uint64_t
nsec
);
uint64_t
nstime_ns
(
const
nstime_t
*
time
);
uint64_t
nstime_sec
(
const
nstime_t
*
time
);
uint64_t
nstime_nsec
(
const
nstime_t
*
time
);
void
nstime_copy
(
nstime_t
*
time
,
const
nstime_t
*
source
);
int
nstime_compare
(
const
nstime_t
*
a
,
const
nstime_t
*
b
);
void
nstime_add
(
nstime_t
*
time
,
const
nstime_t
*
addend
);
void
nstime_subtract
(
nstime_t
*
time
,
const
nstime_t
*
subtrahend
);
void
nstime_imultiply
(
nstime_t
*
time
,
uint64_t
multiplier
);
void
nstime_idivide
(
nstime_t
*
time
,
uint64_t
divisor
);
uint64_t
nstime_divide
(
const
nstime_t
*
time
,
const
nstime_t
*
divisor
);
#ifdef JEMALLOC_JET
typedef
bool
(
nstime_monotonic_t
)(
void
);
extern
nstime_monotonic_t
*
nstime_monotonic
;
typedef
bool
(
nstime_update_t
)(
nstime_t
*
);
extern
nstime_update_t
*
nstime_update
;
#else
bool
nstime_monotonic
(
void
);
bool
nstime_update
(
nstime_t
*
time
);
#endif
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
#ifdef JEMALLOC_H_INLINES
#endif
/* JEMALLOC_H_INLINES */
/******************************************************************************/
deps/jemalloc/include/jemalloc/internal/pages.h
View file @
89a9e5a9
...
@@ -9,16 +9,13 @@
...
@@ -9,16 +9,13 @@
/******************************************************************************/
/******************************************************************************/
#ifdef JEMALLOC_H_EXTERNS
#ifdef JEMALLOC_H_EXTERNS
void
*
pages_map
(
void
*
addr
,
size_t
size
,
bool
*
commit
);
void
*
pages_map
(
void
*
addr
,
size_t
size
);
void
pages_unmap
(
void
*
addr
,
size_t
size
);
void
pages_unmap
(
void
*
addr
,
size_t
size
);
void
*
pages_trim
(
void
*
addr
,
size_t
alloc_size
,
size_t
leadsize
,
void
*
pages_trim
(
void
*
addr
,
size_t
alloc_size
,
size_t
leadsize
,
size_t
size
,
bool
*
commit
);
size_t
size
);
bool
pages_commit
(
void
*
addr
,
size_t
size
);
bool
pages_commit
(
void
*
addr
,
size_t
size
);
bool
pages_decommit
(
void
*
addr
,
size_t
size
);
bool
pages_decommit
(
void
*
addr
,
size_t
size
);
bool
pages_purge
(
void
*
addr
,
size_t
size
);
bool
pages_purge
(
void
*
addr
,
size_t
size
);
bool
pages_huge
(
void
*
addr
,
size_t
size
);
bool
pages_nohuge
(
void
*
addr
,
size_t
size
);
void
pages_boot
(
void
);
#endif
/* JEMALLOC_H_EXTERNS */
#endif
/* JEMALLOC_H_EXTERNS */
/******************************************************************************/
/******************************************************************************/
...
...
deps/jemalloc/include/jemalloc/internal/ph.h
deleted
100644 → 0
View file @
71a8df6a
This diff is collapsed.
Click to expand it.
Prev
1
2
3
4
5
6
…
9
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