project-base/server-skynet-source-3rd-jemalloc
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
41e0b857be
server-skynet-source-3rd-je.../include/jemalloc/internal/edata_cache.h

51 lines
1.6 KiB
C
Raw Normal View History

Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
#ifndef JEMALLOC_INTERNAL_EDATA_CACHE_H
#define JEMALLOC_INTERNAL_EDATA_CACHE_H
Make headers self-contained by fixing `#include`s Header files are now self-contained, which makes the relationships between the files clearer, and crucially allows LSP tools like `clangd` to function correctly in all of our header files. I have verified that the headers are self-contained (aside from the various Windows shims) by compiling them as if they were C files – in a follow-up commit I plan to add this to CI to ensure we don't regress on this front.
2023-06-10 08:37:47 +08:00
#include "jemalloc/internal/jemalloc_preamble.h"
Base: Pull into a single header.
2020-02-18 04:00:57 +08:00
#include "jemalloc/internal/base.h"
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
/* For tests only. */
#define EDATA_CACHE_FAST_FILL 4
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
/*
* A cache of edata_t structures allocated via base_alloc_edata (as opposed to
* the underlying extents they describe). The contents of returned edata_t
* objects are garbage and cannot be relied upon.
*/
typedef struct edata_cache_s edata_cache_t;
struct edata_cache_s {
Rename edata_tree_t -> edata_avail_t. This isn't a tree any more, and it mildly irritates me any time I see it.
2020-11-05 08:00:52 +08:00
edata_avail_t avail;
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
atomic_zu_t count;
malloc_mutex_t mtx;
edata_cache: Remember the associated base_t. This will save us some trouble down the line when we stop passing arena pointers everywhere; we won't have to pass around a base_t pointer either.
2019-12-13 10:28:37 +08:00
base_t *base;
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
};
edata_cache: Remember the associated base_t. This will save us some trouble down the line when we stop passing arena pointers everywhere; we won't have to pass around a base_t pointer either.
2019-12-13 10:28:37 +08:00
bool edata_cache_init(edata_cache_t *edata_cache, base_t *base);
edata_t *edata_cache_get(tsdn_t *tsdn, edata_cache_t *edata_cache);
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
void edata_cache_put(tsdn_t *tsdn, edata_cache_t *edata_cache, edata_t *edata);
edata_cache: Remember the associated base_t. This will save us some trouble down the line when we stop passing arena pointers everywhere; we won't have to pass around a base_t pointer either.
2019-12-13 10:28:37 +08:00
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
void edata_cache_prefork(tsdn_t *tsdn, edata_cache_t *edata_cache);
void edata_cache_postfork_parent(tsdn_t *tsdn, edata_cache_t *edata_cache);
void edata_cache_postfork_child(tsdn_t *tsdn, edata_cache_t *edata_cache);
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
/*
* An edata_cache_small is like an edata_cache, but it relies on external
* synchronization and avoids first-fit strategies.
*/
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
typedef struct edata_cache_fast_s edata_cache_fast_t;
struct edata_cache_fast_s {
Edata: split up different list linkage uses.
2020-06-12 06:15:51 +08:00
edata_list_inactive_t list;
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
edata_cache_t *fallback;
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
bool disabled;
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
};
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
void edata_cache_fast_init(edata_cache_fast_t *ecs, edata_cache_t *fallback);
edata_t *edata_cache_fast_get(tsdn_t *tsdn, edata_cache_fast_t *ecs);
void edata_cache_fast_put(tsdn_t *tsdn, edata_cache_fast_t *ecs,
Edata cache small: rewrite. In previous designs, this was intended to be a sort of cache that couldn't fail. In the current design, we want to use it just as a contention reduction mechanism. Rewrite it with those goals in mind.
2020-10-29 20:11:16 +08:00
edata_t *edata);
edata_cache: Allow unbounded fast caching. The edata_cache_small had a fill/flush heuristic. In retrospect, this was a premature optimization; more testing indicates that an unbounded cache is effectively fine here, and moreover we spend a nontrivial amount of time doing unnecessary filling/flushing. As the HPA takes on a larger and larger fraction of all allocations, any theoretical differences in allocation patterns should shrink. The HPA is more efficient with its metadata in general, so it still comes out ahead on metadata usage anyways.
2021-07-24 06:29:43 +08:00
void edata_cache_fast_disable(tsdn_t *tsdn, edata_cache_fast_t *ecs);
Edata cache: add edata_cache_small_t. This can be used to amortize the synchronization costs of edata_cache accesses.
2020-02-19 09:21:40 +08:00
Pull out edata_t caching into its own module.
2019-12-12 03:17:19 +08:00
#endif /* JEMALLOC_INTERNAL_EDATA_CACHE_H */
Reference in New Issue Copy Permalink