| /src/external/bsd/jemalloc.old/dist/include/jemalloc/internal/ |
| jemalloc_internal_inlines_b.h | 18 /* Set new arena/tcache associations. */
20 tcache_t *tcache = tcache_get(tsd); local
21 if (tcache != NULL) {
24 tcache, newarena); local
50 tcache_t *tcache = tsd_tcachep_get(tsd); local
57 tcache_slow, tcache, ret); local
61 tcache_slow, tcache, ret); local
|
| tcache_structs.h | 11 * The tcache state is split into the slow and hot path data. Each has a
14 * tcache, and as part of a dynamic allocation for manual allocations. Keeping
16 * splitting up the tcache [de]allocation code into those paths called with the
17 * TSD tcache and those called with a manual tcache.
26 * tcache definition. This enables arenas to aggregate stats across
27 * tcaches without having a tcache dependency.
31 /* The arena this tcache is associated with. */
52 tcache_t *tcache; member in struct:tcache_slow_s
60 /* Linkage for list of available (previously used) explicit tcache IDs. *
63 tcache_t *tcache; member in union:tcaches_s::__anon23
[all...] |
| arena_inlines_b.h | 146 tcache_t *tcache, bool slow_path) {
147 assert(!tsdn_null(tsdn) || tcache == NULL);
149 if (likely(tcache != NULL)) {
152 tcache, size, ind, zero, slow_path);
156 tcache, size, ind, zero, slow_path);
281 arena_dalloc_large(tsdn_t *tsdn, void *ptr, tcache_t *tcache, szind_t szind,
285 arena_dalloc_promoted(tsdn, ptr, tcache, slow_path);
287 tcache_dalloc_large(tsdn_tsd(tsdn), tcache, ptr, szind, local
302 arena_dalloc(tsdn_t *tsdn, void *ptr, tcache_t *tcache,
304 assert(!tsdn_null(tsdn) || tcache == NULL)
331 tcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr, local
418 tcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr, local
[all...] |
| /src/external/bsd/jemalloc.old/include/jemalloc/internal/ |
| jemalloc_internal_inlines_b.h | 18 /* Set new arena/tcache associations. */
20 tcache_t *tcache = tcache_get(tsd); local
21 if (tcache != NULL) {
24 tcache, newarena); local
50 tcache_t *tcache = tsd_tcachep_get(tsd); local
57 tcache_slow, tcache, ret); local
61 tcache_slow, tcache, ret); local
|
| tcache_structs.h | 11 * The tcache state is split into the slow and hot path data. Each has a
14 * tcache, and as part of a dynamic allocation for manual allocations. Keeping
16 * splitting up the tcache [de]allocation code into those paths called with the
17 * TSD tcache and those called with a manual tcache.
26 * tcache definition. This enables arenas to aggregate stats across
27 * tcaches without having a tcache dependency.
31 /* The arena this tcache is associated with. */
52 tcache_t *tcache; member in struct:tcache_slow_s
60 /* Linkage for list of available (previously used) explicit tcache IDs. *
63 tcache_t *tcache; member in union:tcaches_s::__anon91
[all...] |
| arena_inlines_b.h | 146 tcache_t *tcache, bool slow_path) {
147 assert(!tsdn_null(tsdn) || tcache == NULL);
149 if (likely(tcache != NULL)) {
152 tcache, size, ind, zero, slow_path);
156 tcache, size, ind, zero, slow_path);
281 arena_dalloc_large(tsdn_t *tsdn, void *ptr, tcache_t *tcache, szind_t szind,
285 arena_dalloc_promoted(tsdn, ptr, tcache, slow_path);
287 tcache_dalloc_large(tsdn_tsd(tsdn), tcache, ptr, szind, local
302 arena_dalloc(tsdn_t *tsdn, void *ptr, tcache_t *tcache,
304 assert(!tsdn_null(tsdn) || tcache == NULL)
331 tcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr, local
418 tcache_dalloc_small(tsdn_tsd(tsdn), tcache, ptr, local
[all...] |
| /src/external/bsd/jemalloc/dist/include/jemalloc/internal/ |
| jemalloc_internal_inlines_b.h | 21 /* Set new arena/tcache associations. */
23 tcache_t *tcache = tcache_get(tsd); local
24 if (tcache != NULL) {
28 tsd_tsdn(tsd), tcache_slow, tcache, newarena); local
53 tcache_t *tcache = tsd_tcachep_get(tsd); local
60 tcache_slow, tcache, ret); local
64 tsd_tsdn(tsd), tcache_slow, tcache, ret); local
|
| tcache_structs.h | 12 * The tcache state is split into the slow and hot path data. Each has a
15 * tcache, and as part of a dynamic allocation for manual allocations. Keeping
17 * splitting up the tcache [de]allocation code into those paths called with the
18 * TSD tcache and those called with a manual tcache.
27 * tcache definition. This enables arenas to aggregate stats across
28 * tcaches without having a tcache dependency.
32 /* The arena this tcache is associated with. */
34 /* The number of bins activated in the tcache. */
59 tcache_t *tcache; member in struct:tcache_slow_s
70 tcache_t *tcache; member in union:tcaches_s::__anon39
[all...] |
| arena_inlines_b.h | 198 bool slab, tcache_t *tcache, bool slow_path) {
199 assert(!tsdn_null(tsdn) || tcache == NULL);
201 if (likely(tcache != NULL)) {
204 return tcache_alloc_small(tsdn_tsd(tsdn), arena, tcache,
206 } else if (likely(ind < tcache_nbins_get(tcache->tcache_slow)
207 && !tcache_bin_disabled(ind, &tcache->bins[ind],
208 tcache->tcache_slow))) {
209 return tcache_alloc_large(tsdn_tsd(tsdn), arena, tcache,
315 arena_dalloc_large(tsdn_t *tsdn, void *ptr, tcache_t *tcache, szind_t szind,
317 assert(!tsdn_null(tsdn) && tcache != NULL)
326 tsdn_tsd(tsdn), tcache, ptr, szind, slow_path); local
[all...] |
| /src/external/bsd/jemalloc/include/jemalloc/internal/ |
| jemalloc_internal_inlines_b.h | 21 /* Set new arena/tcache associations. */
23 tcache_t *tcache = tcache_get(tsd); local
24 if (tcache != NULL) {
28 tsd_tsdn(tsd), tcache_slow, tcache, newarena); local
53 tcache_t *tcache = tsd_tcachep_get(tsd); local
60 tcache_slow, tcache, ret); local
64 tsd_tsdn(tsd), tcache_slow, tcache, ret); local
|
| tcache_structs.h | 12 * The tcache state is split into the slow and hot path data. Each has a
15 * tcache, and as part of a dynamic allocation for manual allocations. Keeping
17 * splitting up the tcache [de]allocation code into those paths called with the
18 * TSD tcache and those called with a manual tcache.
27 * tcache definition. This enables arenas to aggregate stats across
28 * tcaches without having a tcache dependency.
32 /* The arena this tcache is associated with. */
34 /* The number of bins activated in the tcache. */
59 tcache_t *tcache; member in struct:tcache_slow_s
70 tcache_t *tcache; member in union:tcaches_s::__anon141
[all...] |
| arena_inlines_b.h | 198 bool slab, tcache_t *tcache, bool slow_path) {
199 assert(!tsdn_null(tsdn) || tcache == NULL);
201 if (likely(tcache != NULL)) {
204 return tcache_alloc_small(tsdn_tsd(tsdn), arena, tcache,
206 } else if (likely(ind < tcache_nbins_get(tcache->tcache_slow)
207 && !tcache_bin_disabled(ind, &tcache->bins[ind],
208 tcache->tcache_slow))) {
209 return tcache_alloc_large(tsdn_tsd(tsdn), arena, tcache,
315 arena_dalloc_large(tsdn_t *tsdn, void *ptr, tcache_t *tcache, szind_t szind,
317 assert(!tsdn_null(tsdn) && tcache != NULL)
326 tsdn_tsd(tsdn), tcache, ptr, szind, slow_path); local
[all...] |
| /src/external/bsd/jemalloc/dist/test/unit/ |
| ncached_max.c | 15 const char *get_name = "thread.tcache.ncached_max.read_sizeclass";
46 tcache_t *tcache = tsd_tcachep_get(tsd); local
47 assert(tcache != NULL);
48 tcache_slow_t *tcache_slow = tcache->tcache_slow;
86 const char *set_name = "thread.tcache.ncached_max.write";
90 /* Test the ncached_max set with tcache on. */
116 * Close the tcache and set ncached_max of some bins. It will be
117 * set properly but thread.tcache.ncached_max.read still returns 0
118 * since the bin is not available yet. After enabling the tcache,
124 expect_d_eq(mallctl("thread.tcache.enabled", (void *)&e1, &bool_sz
[all...] |
| tcache_max.c | 74 tcache_t *tcache = tcache_get(tsd); local
75 for (szind_t i = 0; i < tcache_nbins_get(tcache->tcache_slow); i++) {
76 cache_bin_t *cache_bin = &tcache->bins[i];
77 if (tcache_bin_disabled(i, cache_bin, tcache->tcache_slow)) {
89 expect_zu_eq(tcache_bytes, *prev + diff, "tcache bytes not expected");
96 expect_d_eq(mallctl("thread.tcache.flush", NULL, NULL, NULL, 0), 0,
97 "Unexpected tcache flush failure");
149 assert_d_eq(mallctl("thread.tcache.max", (void *)&tcache_max,
220 expect_d_eq(mallctl("thread.tcache.max", NULL, NULL, (void *)&large,
223 expect_d_eq(mallctl("thread.tcache.flush", NULL, NULL, NULL, 0), 0
228 tcache_t *tcache = tcache_get(tsd); local
287 tcache_t *tcache = tsd_tcachep_get(tsd); local
[all...] |
| /src/external/bsd/jemalloc.old/dist/src/ |
| tcache.c | 24 * We attempt to make the number of slots in a tcache bin for a given size class
26 * the multiplier is 2 (i.e. we set the maximum number of objects in the tcache
34 * Number of allocation bytes between tcache incremental GCs. Again, this
62 /* Total stack size required (per tcache). Include the padding above. */
123 tcache_gc_small(tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache,
128 cache_bin_t *cache_bin = &tcache->bins[szind];
148 tcache_bin_flush_small(tsd, tcache, cache_bin, szind,
162 tcache_gc_large(tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache,
166 cache_bin_t *cache_bin = &tcache->bins[szind];
171 tcache_bin_flush_large(tsd, tcache, cache_bin, szind
177 tcache_t *tcache = tcache_get(tsd); local
711 tcache_t *tcache = tsd_tcachep_get_unsafe(tsd); local
737 tcache_arena_associate(tsd_tsdn(tsd), tcache_slow, tcache, local
744 tcache, arena); local
771 tcache_t *tcache = (void *)((uintptr_t)mem + tcache_bin_alloc_size); local
776 tcache_arena_associate(tsd_tsdn(tsd), tcache_slow, tcache, local
811 tcache_arena_dissociate(tsd_tsdn(tsd), tcache_slow, tcache); local
843 tcache_t *tcache = tsd_tcachep_get(tsd); local
920 tcache_t *tcache = tcache_create_explicit(tsd); local
953 tcache_t *tcache = elm->tcache; local
969 tcache_t *tcache = tcaches_elm_remove(tsd, &tcaches[ind], true); local
981 tcache_t *tcache = tcaches_elm_remove(tsd, elm, false); local
[all...] |
| arena.c | 151 /* Currently cached bytes and sanitizer-stashed bytes in tcache. */
1210 bool zero, tcache_t *tcache) {
1225 zero, tcache, true);
1270 arena_dalloc_promoted(tsdn_t *tsdn, void *ptr, tcache_t *tcache,
1286 if (bumped_usize <= tcache_maxclass && tcache != NULL) {
1287 tcache_dalloc_large(tsdn_tsd(tsdn), tcache, ptr, local
1444 size_t alignment, bool zero, tcache_t *tcache) {
1447 zero, tcache, true);
1453 return ipalloct(tsdn, usize, alignment, zero, tcache, arena);
1458 size_t size, size_t alignment, bool zero, tcache_t *tcache,
1870 tcache_t *tcache = tcache_slow->tcache; local
[all...] |
| jemalloc.c | 672 * individual threads do not lock when recording tcache stats
686 tcache_slow->tcache, arena);
1400 CONF_HANDLE_BOOL(opt_tcache, "tcache")
2359 tcache_t *tcache; local
2362 /* Getting tcache ptr unconditionally. */
2363 tcache = tsd_tcachep_get(tsd);
2364 assert(tcache == tcache_get(tsd));
2367 tcache = tcache_get(tsd);
2369 tcache = NULL;
2373 * Should not specify tcache on deallocation path when bein
2411 tcache_t *tcache = tcache_get_from_ind(tsd, dopts->tcache_ind, local
2914 idalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false, local
2920 idalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false, local
3009 isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx, local
3015 isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx, local
3038 tcache_t *tcache = tcache_get_from_ind(tsd, local
3043 tcache_t *tcache = tcache_get_from_ind(tsd, local
3164 tcache_t *tcache = tcache_get_from_ind(tsd, TCACHE_IND_AUTOMATIC, local
3542 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, local
3626 tcache_t *tcache = tcache_get_from_ind(tsd, local
3907 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast, local
3945 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast, local
4236 tcache_t *tcache = tcache_get_from_ind(tsd, local
[all...] |
| /src/external/bsd/jemalloc/dist/src/ |
| tcache.c | 25 * We attempt to make the number of slots in a tcache bin for a given size class
27 * the multiplier is 2 (i.e. we set the maximum number of objects in the tcache
35 * Number of allocation bytes between tcache incremental GCs. Again, this
63 * is only used to initialize tcache_nbins in the per-thread tcache.
69 * to initialize tcache_max in the per-thread tcache. Directly modifying it
364 tsd_t *tsd, tcache_slow_t *tcache_slow, tcache_t *tcache, szind_t szind) {
371 cache_bin_t *cache_bin = &tcache->bins[szind];
372 assert(!tcache_bin_disabled(szind, cache_bin, tcache->tcache_slow));
396 * When the new tcache gc is not enabled, keep the flush delay logic,
470 tsd, tcache, cache_bin, szind, (unsigned)(ncached - nflush))
514 tcache_t *tcache = tcache_get(tsd); local
732 tcache_t *tcache = tsd_tcachep_get(tsd); local
961 tcache_t *tcache = tsd_tcachep_get_unsafe(tsd); local
988 tsd_tsdn(tsd), tcache_slow, tcache, arena); local
996 tsd_tsdn(tsd), tcache_slow, tcache, arena); local
1048 tcache_t *tcache = (void *)((byte_t *)mem + tcache_size); local
1056 tsd_tsdn(tsd), tcache_slow, tcache, arena_ichoose(tsd, NULL)); local
1102 tcache_t *tcache = tsd_tcachep_get(tsd); local
1181 tcache_t *tcache = tsd_tcachep_get(tsd); local
1228 tcache_arena_dissociate(tsd_tsdn(tsd), tcache_slow, tcache); local
1264 tcache_t *tcache = tsd_tcachep_get(tsd); local
1339 tcache_t *tcache = tcache_create_explicit(tsd); local
1372 tcache_t *tcache = elm->tcache; local
1388 tcache_t *tcache = tcaches_elm_remove(tsd, &tcaches[ind], true); local
1400 tcache_t *tcache = tcaches_elm_remove(tsd, elm, false); local
[all...] |
| arena.c | 164 /* Currently cached bytes and sanitizer-stashed bytes in tcache. */
631 tsdn_t *tsdn, void *ptr, tcache_t *tcache, bool slow_path, edata_t *edata) {
645 if (bumped_usize >= SC_LARGE_MINCLASS && tcache != NULL
648 bumped_ind, &tcache->bins[bumped_ind], tcache->tcache_slow)) {
650 tsdn_tsd(tsdn), tcache, ptr, bumped_ind, slow_path); local
658 tsdn_t *tsdn, void *ptr, tcache_t *tcache, bool slow_path) {
660 arena_dalloc_promoted_impl(tsdn, ptr, tcache, slow_path, edata);
703 /* tcache */ NULL, /* slow_path */ true, edata);
1142 bool zero, bool slab, tcache_t *tcache) {
2081 tcache_t *tcache = tcache_slow->tcache; local
[all...] |
| ctl.c | 442 {NAME("tcache"), CHILD(named, thread_tcache)},
510 {NAME("tcache"), CTL(opt_tcache)},
923 {NAME("tcache"), CHILD(named, tcache)},
2307 /* Set new arena/tcache associations. */
2423 /* pointer to tcache_t always exists even with tcache disabled. */
2424 tcache_t *tcache = tsd_tcachep_get(tsd); local
2425 assert(tcache != NULL);
2426 oldval = tcache_max_get(tcache->tcache_slow);
3914 /* tcache bin mutex *
[all...] |
| jemalloc.c | 705 * individual threads do not lock when recording tcache stats
719 tsdn, tcache_slow->tcache, arena);
1459 * allocation out of the tcache.
1475 /* Fill in the tcache. */
1476 tcache_t *tcache = tcache_get_from_ind( local
1487 dopts->alignment, dopts->zero, slab, tcache, arena);
1491 slab, tcache, false, arena, sopts->slow);
1957 ifree(tsd_t *tsd, void *ptr, tcache_t *tcache, bool slow_path) {
1980 idalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false, false); local
1985 idalloctm(tsd_tsdn(tsd), ptr, tcache, &alloc_ctx, false, true) local
2056 isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx, false); local
2061 isdalloct(tsd_tsdn(tsd), ptr, usize, tcache, &alloc_ctx, true); local
2083 tcache_t *tcache = tcache_get_from_ind(tsd, local
2088 tcache_t *tcache = tcache_get_from_ind(tsd, local
2527 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, local
2613 tcache_t *tcache = tcache_get_from_ind(tsd, local
2903 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast, local
2941 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, !fast, local
3215 tcache_t *tcache = tcache_get_from_ind(tsd, tcache_ind, local
[all...] |
| /src/sys/compat/linux/arch/aarch64/ |
| linux_syscallargs.h | 775 syscallarg(struct linux_getcpu_cache *) tcache; member in struct:linux_sys_getcpu_args
|
| /src/sys/compat/linux/arch/alpha/ |
| linux_syscallargs.h | 1246 syscallarg(struct linux_getcpu_cache *) tcache; member in struct:linux_sys_getcpu_args
|
| /src/sys/compat/linux/arch/amd64/ |
| linux_syscallargs.h | 1271 syscallarg(struct linux_getcpu_cache *) tcache; member in struct:linux_sys_getcpu_args
|
| /src/sys/compat/linux/arch/arm/ |
| linux_syscallargs.h | 1210 syscallarg(struct linux_getcpu_cache *) tcache; member in struct:linux_sys_getcpu_args
|
