| /src/external/bsd/jemalloc.old/dist/include/jemalloc/internal/ |
| peak_event.h | 6 * contains the allocator tie-ins (and knows about tsd, the event module, etc.).
9 /* Update the peak with current tsd state. */
10 void peak_event_update(tsd_t *tsd);
12 void peak_event_zero(tsd_t *tsd);
13 uint64_t peak_event_max(tsd_t *tsd);
17 uint64_t peak_alloc_new_event_wait(tsd_t *tsd);
18 uint64_t peak_alloc_postponed_event_wait(tsd_t *tsd);
19 void peak_alloc_event_handler(tsd_t *tsd, uint64_t elapsed);
20 uint64_t peak_dalloc_new_event_wait(tsd_t *tsd);
21 uint64_t peak_dalloc_postponed_event_wait(tsd_t *tsd);
[all...] |
| jemalloc_internal_inlines_b.h | 7 percpu_arena_update(tsd_t *tsd, unsigned cpu) {
9 arena_t *oldarena = tsd_arena_get(tsd);
15 arena_t *newarena = arena_get(tsd_tsdn(tsd), newind, true);
19 arena_migrate(tsd, oldarena, newarena);
20 tcache_t *tcache = tcache_get(tsd);
22 tcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);
23 tcache_arena_reassociate(tsd_tsdn(tsd), tcache_slow,
32 arena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal) {
40 if (unlikely(tsd_reentrancy_level_get(tsd) > 0)) {
41 return arena_get(tsd_tsdn(tsd), 0, true)
[all...] |
| prof_externs.h | 59 prof_tdata_t *prof_tdata_init(tsd_t *tsd);
60 prof_tdata_t *prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata);
62 void prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx);
63 void prof_malloc_sample_object(tsd_t *tsd, const void *ptr, size_t size,
65 void prof_free_sampled_object(tsd_t *tsd, size_t usize, prof_info_t *prof_info);
66 prof_tctx_t *prof_tctx_create(tsd_t *tsd);
68 bool prof_mdump(tsd_t *tsd, const char *filename);
71 void prof_tdata_cleanup(tsd_t *tsd);
74 const char *prof_thread_name_get(tsd_t *tsd);
75 int prof_thread_name_set(tsd_t *tsd, const char *thread_name)
[all...] |
| /src/external/bsd/jemalloc.old/include/jemalloc/internal/ |
| peak_event.h | 6 * contains the allocator tie-ins (and knows about tsd, the event module, etc.).
9 /* Update the peak with current tsd state. */
10 void peak_event_update(tsd_t *tsd);
12 void peak_event_zero(tsd_t *tsd);
13 uint64_t peak_event_max(tsd_t *tsd);
17 uint64_t peak_alloc_new_event_wait(tsd_t *tsd);
18 uint64_t peak_alloc_postponed_event_wait(tsd_t *tsd);
19 void peak_alloc_event_handler(tsd_t *tsd, uint64_t elapsed);
20 uint64_t peak_dalloc_new_event_wait(tsd_t *tsd);
21 uint64_t peak_dalloc_postponed_event_wait(tsd_t *tsd);
[all...] |
| jemalloc_internal_inlines_b.h | 7 percpu_arena_update(tsd_t *tsd, unsigned cpu) {
9 arena_t *oldarena = tsd_arena_get(tsd);
15 arena_t *newarena = arena_get(tsd_tsdn(tsd), newind, true);
19 arena_migrate(tsd, oldarena, newarena);
20 tcache_t *tcache = tcache_get(tsd);
22 tcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);
23 tcache_arena_reassociate(tsd_tsdn(tsd), tcache_slow,
32 arena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal) {
40 if (unlikely(tsd_reentrancy_level_get(tsd) > 0)) {
41 return arena_get(tsd_tsdn(tsd), 0, true)
[all...] |
| /src/external/bsd/jemalloc.old/dist/src/ |
| peak_event.c | 17 /* Update the peak with current tsd state. */
19 peak_event_update(tsd_t *tsd) {
20 uint64_t alloc = tsd_thread_allocated_get(tsd);
21 uint64_t dalloc = tsd_thread_deallocated_get(tsd);
22 peak_t *peak = tsd_peakp_get(tsd);
27 peak_event_activity_callback(tsd_t *tsd) {
29 tsd);
30 uint64_t alloc = tsd_thread_allocated_get(tsd);
31 uint64_t dalloc = tsd_thread_deallocated_get(tsd);
39 peak_event_zero(tsd_t *tsd) {
[all...] |
| tsd.c | 32 * have a dependency on tsd. So we define the struct here, and only refer to it
69 tsd_in_nominal_list(tsd_t *tsd) {
73 * We don't know that tsd is nominal; it might not be safe to get data
78 if (tsd == tsd_list) {
88 tsd_add_nominal(tsd_t *tsd) {
89 assert(!tsd_in_nominal_list(tsd));
90 assert(tsd_state_get(tsd) <= tsd_state_nominal_max);
91 ql_elm_new(tsd, TSD_MANGLE(tsd_link));
92 malloc_mutex_lock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);
93 ql_tail_insert(&tsd_nominal_tsds, tsd, TSD_MANGLE(tsd_link))
396 tsd_t *tsd = (tsd_t *)arg; local
441 tsd_t *tsd; local
460 tsd_t *tsd = tsd_fetch(); local
[all...] |
| prof_stats.c | 12 prof_stats_enter(tsd_t *tsd, szind_t ind) {
15 malloc_mutex_lock(tsd_tsdn(tsd), &prof_stats_mtx);
19 prof_stats_leave(tsd_t *tsd) {
20 malloc_mutex_unlock(tsd_tsdn(tsd), &prof_stats_mtx);
24 prof_stats_inc(tsd_t *tsd, szind_t ind, size_t size) {
26 prof_stats_enter(tsd, ind);
31 prof_stats_leave(tsd);
35 prof_stats_dec(tsd_t *tsd, szind_t ind, size_t size) {
37 prof_stats_enter(tsd, ind);
40 prof_stats_leave(tsd);
[all...] |
| thread_event.c | 14 * if an event should be triggered but needs to be postponed, e.g. when the TSD
22 uint64_t event##_new_event_wait(tsd_t *tsd); \
23 uint64_t event##_postponed_event_wait(tsd_t *tsd); \
24 void event##_event_handler(tsd_t *tsd, uint64_t elapsed);
31 static uint64_t event##_fetch_elapsed(tsd_t *tsd);
37 tcache_gc_fetch_elapsed(tsd_t *tsd) {
42 tcache_gc_dalloc_fetch_elapsed(tsd_t *tsd) {
47 prof_sample_fetch_elapsed(tsd_t *tsd) {
48 uint64_t last_event = thread_allocated_last_event_get(tsd);
49 uint64_t last_sample_event = prof_sample_last_event_get(tsd);
[all...] |
| /src/external/bsd/jemalloc/dist/src/ |
| peak_event.c | 9 /* Update the peak with current tsd state. */
11 peak_event_update(tsd_t *tsd) {
12 uint64_t alloc = tsd_thread_allocated_get(tsd);
13 uint64_t dalloc = tsd_thread_deallocated_get(tsd);
14 peak_t *peak = tsd_peakp_get(tsd);
20 peak_event_zero(tsd_t *tsd) {
21 uint64_t alloc = tsd_thread_allocated_get(tsd);
22 uint64_t dalloc = tsd_thread_deallocated_get(tsd);
23 peak_t *peak = tsd_peakp_get(tsd);
28 peak_event_max(tsd_t *tsd) {
[all...] |
| tsd.c | 41 * have a dependency on tsd. So we define the struct here, and only refer to it
70 tsd_in_nominal_list(tsd_t *tsd) {
74 * We don't know that tsd is nominal; it might not be safe to get data
79 if (tsd == tsd_list) {
89 tsd_add_nominal(tsd_t *tsd) {
90 assert(!tsd_in_nominal_list(tsd));
91 assert(tsd_state_get(tsd) <= tsd_state_nominal_max);
92 ql_elm_new(tsd, TSD_MANGLE(tsd_link));
93 malloc_mutex_lock(tsd_tsdn(tsd), &tsd_nominal_tsds_lock);
94 ql_tail_insert(&tsd_nominal_tsds, tsd, TSD_MANGLE(tsd_link))
411 tsd_t *tsd = (tsd_t *)arg; local
456 tsd_t *tsd; local
475 tsd_t *tsd = tsd_fetch(); local
[all...] |
| prof_stats.c | 12 prof_stats_enter(tsd_t *tsd, szind_t ind) {
15 malloc_mutex_lock(tsd_tsdn(tsd), &prof_stats_mtx);
19 prof_stats_leave(tsd_t *tsd) {
20 malloc_mutex_unlock(tsd_tsdn(tsd), &prof_stats_mtx);
24 prof_stats_inc(tsd_t *tsd, szind_t ind, size_t size) {
26 prof_stats_enter(tsd, ind);
31 prof_stats_leave(tsd);
35 prof_stats_dec(tsd_t *tsd, szind_t ind, size_t size) {
37 prof_stats_enter(tsd, ind);
40 prof_stats_leave(tsd);
[all...] |
| /src/external/bsd/jemalloc/dist/include/jemalloc/internal/ |
| peak_event.h | 17 * contains the allocator tie-ins (and knows about tsd, the event module, etc.).
20 /* Update the peak with current tsd state. */
21 void peak_event_update(tsd_t *tsd);
23 void peak_event_zero(tsd_t *tsd);
24 uint64_t peak_event_max(tsd_t *tsd);
|
| tsd.h | 21 * tsd_foop_get_unsafe(tsd) returns a pointer to the thread-local instance of
22 * foo. This omits some safety checks, and so can be used during tsd
26 JEMALLOC_ALWAYS_INLINE t *tsd_##n##p_get_unsafe(tsd_t *tsd) { \
27 return &tsd->TSD_MANGLE(n); \
35 /* tsd_foop_get(tsd) returns a pointer to the thread-local instance of foo. */
38 tsd_##n##p_get(tsd_t *tsd) { \
43 uint8_t state = tsd_state_get(tsd); \
49 return tsd_##n##p_get_unsafe(tsd); \
66 tsd_t *tsd = tsdn_tsd(tsdn); \
67 return (nt *)tsd_##n##p_get(tsd); \
119 tsd_t *tsd = tsd_get(init); local
144 tsd_t *tsd = tsd_fetch_min(); local
[all...] |
| thread_event.h | 5 #include "jemalloc/internal/tsd.h"
47 void te_assert_invariants_debug(tsd_t *tsd);
48 void te_event_trigger(tsd_t *tsd, te_ctx_t *ctx);
49 void te_recompute_fast_threshold(tsd_t *tsd);
50 void tsd_te_init(tsd_t *tsd);
51 void te_adjust_thresholds_helper(tsd_t *tsd, te_ctx_t *ctx, uint64_t wait);
60 /* Getters directly wrap TSD getters. */
62 JEMALLOC_ALWAYS_INLINE uint64_t counter##_get(tsd_t *tsd) { \
63 return tsd_##counter##_get(tsd); \
70 * Setters call the TSD pointer getters rather than the TSD setters, so tha
[all...] |
| jemalloc_internal_inlines_b.h | 10 percpu_arena_update(tsd_t *tsd, unsigned cpu) {
12 arena_t *oldarena = tsd_arena_get(tsd);
18 arena_t *newarena = arena_get(tsd_tsdn(tsd), newind, true);
22 arena_migrate(tsd, oldarena, newarena);
23 tcache_t *tcache = tcache_get(tsd);
25 tcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);
28 tsd_tsdn(tsd), tcache_slow, tcache, newarena);
35 arena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal) {
43 if (unlikely(tsd_reentrancy_level_get(tsd) > 0)) {
44 return arena_get(tsd_tsdn(tsd), 0, true)
[all...] |
| prof_externs.h | 72 prof_tdata_t *prof_tdata_init(tsd_t *tsd);
73 prof_tdata_t *prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata);
75 void prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx);
77 tsd_t *tsd, const void *ptr, size_t size, size_t usize, prof_tctx_t *tctx);
79 tsd_t *tsd, const void *ptr, size_t usize, prof_info_t *prof_info);
80 prof_tctx_t *prof_tctx_create(tsd_t *tsd);
82 bool prof_mdump(tsd_t *tsd, const char *filename);
85 void prof_tdata_cleanup(tsd_t *tsd);
88 const char *prof_thread_name_get(tsd_t *tsd);
89 int prof_thread_name_set(tsd_t *tsd, const char *thread_name)
[all...] |
| prof_data.h | 20 bool prof_data_init(tsd_t *tsd);
21 prof_tctx_t *prof_lookup(tsd_t *tsd, prof_bt_t *bt);
22 int prof_thread_name_set_impl(tsd_t *tsd, const char *thread_name);
24 void prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,
26 prof_tdata_t *prof_tdata_init_impl(tsd_t *tsd, uint64_t thr_uid,
28 void prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata);
29 void prof_reset(tsd_t *tsd, size_t lg_sample);
30 void prof_tctx_try_destroy(tsd_t *tsd, prof_tctx_t *tctx);
|
| /src/external/bsd/jemalloc/include/jemalloc/internal/ |
| peak_event.h | 17 * contains the allocator tie-ins (and knows about tsd, the event module, etc.).
20 /* Update the peak with current tsd state. */
21 void peak_event_update(tsd_t *tsd);
23 void peak_event_zero(tsd_t *tsd);
24 uint64_t peak_event_max(tsd_t *tsd);
|
| tsd.h | 21 * tsd_foop_get_unsafe(tsd) returns a pointer to the thread-local instance of
22 * foo. This omits some safety checks, and so can be used during tsd
26 JEMALLOC_ALWAYS_INLINE t *tsd_##n##p_get_unsafe(tsd_t *tsd) { \
27 return &tsd->TSD_MANGLE(n); \
35 /* tsd_foop_get(tsd) returns a pointer to the thread-local instance of foo. */
38 tsd_##n##p_get(tsd_t *tsd) { \
43 uint8_t state = tsd_state_get(tsd); \
49 return tsd_##n##p_get_unsafe(tsd); \
66 tsd_t *tsd = tsdn_tsd(tsdn); \
67 return (nt *)tsd_##n##p_get(tsd); \
119 tsd_t *tsd = tsd_get(init); local
144 tsd_t *tsd = tsd_fetch_min(); local
[all...] |
| thread_event.h | 5 #include "jemalloc/internal/tsd.h"
47 void te_assert_invariants_debug(tsd_t *tsd);
48 void te_event_trigger(tsd_t *tsd, te_ctx_t *ctx);
49 void te_recompute_fast_threshold(tsd_t *tsd);
50 void tsd_te_init(tsd_t *tsd);
51 void te_adjust_thresholds_helper(tsd_t *tsd, te_ctx_t *ctx, uint64_t wait);
60 /* Getters directly wrap TSD getters. */
62 JEMALLOC_ALWAYS_INLINE uint64_t counter##_get(tsd_t *tsd) { \
63 return tsd_##counter##_get(tsd); \
70 * Setters call the TSD pointer getters rather than the TSD setters, so tha
[all...] |
| jemalloc_internal_inlines_b.h | 10 percpu_arena_update(tsd_t *tsd, unsigned cpu) {
12 arena_t *oldarena = tsd_arena_get(tsd);
18 arena_t *newarena = arena_get(tsd_tsdn(tsd), newind, true);
22 arena_migrate(tsd, oldarena, newarena);
23 tcache_t *tcache = tcache_get(tsd);
25 tcache_slow_t *tcache_slow = tsd_tcache_slowp_get(tsd);
28 tsd_tsdn(tsd), tcache_slow, tcache, newarena);
35 arena_choose_impl(tsd_t *tsd, arena_t *arena, bool internal) {
43 if (unlikely(tsd_reentrancy_level_get(tsd) > 0)) {
44 return arena_get(tsd_tsdn(tsd), 0, true)
[all...] |
| prof_externs.h | 72 prof_tdata_t *prof_tdata_init(tsd_t *tsd);
73 prof_tdata_t *prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata);
75 void prof_alloc_rollback(tsd_t *tsd, prof_tctx_t *tctx);
77 tsd_t *tsd, const void *ptr, size_t size, size_t usize, prof_tctx_t *tctx);
79 tsd_t *tsd, const void *ptr, size_t usize, prof_info_t *prof_info);
80 prof_tctx_t *prof_tctx_create(tsd_t *tsd);
82 bool prof_mdump(tsd_t *tsd, const char *filename);
85 void prof_tdata_cleanup(tsd_t *tsd);
88 const char *prof_thread_name_get(tsd_t *tsd);
89 int prof_thread_name_set(tsd_t *tsd, const char *thread_name)
[all...] |
| prof_data.h | 20 bool prof_data_init(tsd_t *tsd);
21 prof_tctx_t *prof_lookup(tsd_t *tsd, prof_bt_t *bt);
22 int prof_thread_name_set_impl(tsd_t *tsd, const char *thread_name);
24 void prof_dump_impl(tsd_t *tsd, write_cb_t *prof_dump_write, void *cbopaque,
26 prof_tdata_t *prof_tdata_init_impl(tsd_t *tsd, uint64_t thr_uid,
28 void prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata);
29 void prof_reset(tsd_t *tsd, size_t lg_sample);
30 void prof_tctx_try_destroy(tsd_t *tsd, prof_tctx_t *tctx);
|
| /src/sys/external/bsd/compiler_rt/dist/lib/asan/ |
| asan_posix.cc | 41 // ---------------------- TSD ---------------- {{{1
45 // Reuse the Asan TSD API for compatibility with existing code
48 static void (*tsd_destructor)(void *tsd) = nullptr;
62 void AsanTSDInit(void (*destructor)(void *tsd)) {
72 void AsanTSDSet(void *tsd) {
74 CHECK(tsd);
76 key.key = tsd;
79 void PlatformTSDDtor(void *tsd) {
81 CHECK_EQ(key.key, tsd);
85 AsanThread::TSDDtor(tsd);
[all...] |
