Lines Matching defs:tdata
69 * Table of mutexes that are shared among tdata's. No operations require
70 * holding multiple tdata locks, so there is no problem with using them for more
71 * than one tdata at the same time, even though a gctx lock may be acquired
72 * while holding a tdata lock.
126 static bool prof_tdata_should_destroy(tsdn_t *tsdn, prof_tdata_t *tdata,
128 static void prof_tdata_destroy(tsd_t *tsd, prof_tdata_t *tdata,
199 prof_tdata_t *tdata;
210 tdata = prof_tdata_get(tsd, true);
211 if (tdata != NULL)
212 prof_sample_threshold_update(tdata);
216 malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);
221 malloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock);
232 malloc_mutex_lock(tsdn, tctx->tdata->lock);
240 malloc_mutex_unlock(tsdn, tctx->tdata->lock);
247 malloc_mutex_lock(tsd_tsdn(tsd), tctx->tdata->lock);
256 malloc_mutex_unlock(tsd_tsdn(tsd), tctx->tdata->lock);
270 prof_enter(tsd_t *tsd, prof_tdata_t *tdata)
274 assert(tdata == prof_tdata_get(tsd, false));
276 if (tdata != NULL) {
277 assert(!tdata->enq);
278 tdata->enq = true;
285 prof_leave(tsd_t *tsd, prof_tdata_t *tdata)
289 assert(tdata == prof_tdata_get(tsd, false));
293 if (tdata != NULL) {
296 assert(tdata->enq);
297 tdata->enq = false;
298 idump = tdata->enq_idump;
299 tdata->enq_idump = false;
300 gdump = tdata->enq_gdump;
301 tdata->enq_gdump = false;
577 prof_tdata_t *tdata)
615 malloc_mutex_assert_owner(tsdn, tctx->tdata->lock);
642 prof_tdata_t *tdata = tctx->tdata;
646 malloc_mutex_assert_owner(tsd_tsdn(tsd), tctx->tdata->lock);
654 ckh_remove(tsd, &tdata->bt2tctx, &gctx->bt, NULL, NULL);
655 destroy_tdata = prof_tdata_should_destroy(tsd_tsdn(tsd), tdata, false);
656 malloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);
701 tdata);
704 malloc_mutex_assert_not_owner(tsd_tsdn(tsd), tctx->tdata->lock);
707 prof_tdata_destroy(tsd, tdata, false);
714 prof_lookup_global(tsd_t *tsd, prof_bt_t *bt, prof_tdata_t *tdata,
727 prof_enter(tsd, tdata);
732 prof_leave(tsd, tdata);
738 prof_leave(tsd, tdata);
753 prof_leave(tsd, tdata);
768 prof_tdata_t *tdata;
773 tdata = prof_tdata_get(tsd, false);
774 if (tdata == NULL)
777 malloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);
778 not_found = ckh_search(&tdata->bt2tctx, bt, NULL, &ret.v);
781 malloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);
791 if (prof_lookup_global(tsd, bt, tdata, &btkey, &gctx,
801 prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
804 ret.p->tdata = tdata;
805 ret.p->thr_uid = tdata->thr_uid;
806 ret.p->thr_discrim = tdata->thr_discrim;
809 ret.p->tctx_uid = tdata->tctx_uid_next++;
812 malloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);
813 error = ckh_insert(tsd, &tdata->bt2tctx, btkey, ret.v);
814 malloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);
817 prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
845 prof_sample_threshold_update(prof_tdata_t *tdata)
855 tdata->bytes_until_sample = 0;
865 * tdata->bytes_until_sample = | -------- |, where p = ---------------
877 r = prng_lg_range_u64(&tdata->prng_state, 53);
879 tdata->bytes_until_sample = (uint64_t)(log(u) /
887 prof_tdata_count_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
918 prof_tdata_t *tdata;
921 tdata = prof_tdata_get(tsd, false);
922 if (tdata == NULL)
1041 prof_tctx_merge_tdata(tsdn_t *tsdn, prof_tctx_t *tctx, prof_tdata_t *tdata)
1044 malloc_mutex_assert_owner(tsdn, tctx->tdata->lock);
1058 tdata->cnt_summed.curobjs += tctx->dump_cnts.curobjs;
1059 tdata->cnt_summed.curbytes += tctx->dump_cnts.curbytes;
1061 tdata->cnt_summed.accumobjs +=
1063 tdata->cnt_summed.accumbytes +=
1214 prof_tdata_t *tdata = prof_tdata_get(tsd, false);
1250 prof_gctx_try_destroy(tsd, tdata, gctx, tdata);
1262 prof_tdata_merge_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata,
1268 malloc_mutex_lock(arg->tsdn, tdata->lock);
1269 if (!tdata->expired) {
1276 tdata->dumping = true;
1277 memset(&tdata->cnt_summed, 0, sizeof(prof_cnt_t));
1278 for (tabind = 0; !ckh_iter(&tdata->bt2tctx, &tabind, NULL,
1280 prof_tctx_merge_tdata(arg->tsdn, tctx.p, tdata);
1282 arg->cnt_all.curobjs += tdata->cnt_summed.curobjs;
1283 arg->cnt_all.curbytes += tdata->cnt_summed.curbytes;
1285 arg->cnt_all.accumobjs += tdata->cnt_summed.accumobjs;
1286 arg->cnt_all.accumbytes += tdata->cnt_summed.accumbytes;
1289 tdata->dumping = false;
1290 malloc_mutex_unlock(arg->tsdn, tdata->lock);
1296 prof_tdata_dump_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
1300 if (!tdata->dumping)
1305 tdata->thr_uid, tdata->cnt_summed.curobjs,
1306 tdata->cnt_summed.curbytes, tdata->cnt_summed.accumobjs,
1307 tdata->cnt_summed.accumbytes,
1308 (tdata->thread_name != NULL) ? " " : "",
1309 (tdata->thread_name != NULL) ? tdata->thread_name : ""))
1310 return (tdata);
1547 prof_tdata_t *tdata;
1560 tdata = prof_tdata_get(tsd, true);
1561 if (tdata == NULL)
1565 prof_enter(tsd, tdata);
1592 prof_leave(tsd, tdata);
1679 prof_tdata_t *tdata;
1686 tdata = prof_tdata_get(tsd, false);
1687 if (tdata == NULL)
1689 if (tdata->enq) {
1690 tdata->enq_idump = true;
1731 prof_tdata_t *tdata;
1738 tdata = prof_tdata_get(tsd, false);
1739 if (tdata == NULL)
1741 if (tdata->enq) {
1742 tdata->enq_gdump = true;
1796 prof_tdata_t *tdata;
1801 tdata = (prof_tdata_t *)iallocztm(tsd_tsdn(tsd), sizeof(prof_tdata_t),
1804 if (tdata == NULL)
1807 tdata->lock = prof_tdata_mutex_choose(thr_uid);
1808 tdata->thr_uid = thr_uid;
1809 tdata->thr_discrim = thr_discrim;
1810 tdata->thread_name = thread_name;
1811 tdata->attached = true;
1812 tdata->expired = false;
1813 tdata->tctx_uid_next = 0;
1815 if (ckh_new(tsd, &tdata->bt2tctx, PROF_CKH_MINITEMS, prof_bt_hash,
1817 idalloctm(tsd_tsdn(tsd), tdata, NULL, true, true);
1821 tdata->prng_state = (uint64_t)(uintptr_t)tdata;
1822 prof_sample_threshold_update(tdata);
1824 tdata->enq = false;
1825 tdata->enq_idump = false;
1826 tdata->enq_gdump = false;
1828 tdata->dumping = false;
1829 tdata->active = active;
1832 tdata_tree_insert(&tdatas, tdata);
1835 return (tdata);
1847 prof_tdata_should_destroy_unlocked(prof_tdata_t *tdata, bool even_if_attached)
1850 if (tdata->attached && !even_if_attached)
1852 if (ckh_count(&tdata->bt2tctx) != 0)
1858 prof_tdata_should_destroy(tsdn_t *tsdn, prof_tdata_t *tdata,
1862 malloc_mutex_assert_owner(tsdn, tdata->lock);
1864 return (prof_tdata_should_destroy_unlocked(tdata, even_if_attached));
1868 prof_tdata_destroy_locked(tsd_t *tsd, prof_tdata_t *tdata,
1874 tdata_tree_remove(&tdatas, tdata);
1876 assert(prof_tdata_should_destroy_unlocked(tdata, even_if_attached));
1878 if (tdata->thread_name != NULL)
1879 idalloctm(tsd_tsdn(tsd), tdata->thread_name, NULL, true, true);
1880 ckh_delete(tsd, &tdata->bt2tctx);
1881 idalloctm(tsd_tsdn(tsd), tdata, NULL, true, true);
1885 prof_tdata_destroy(tsd_t *tsd, prof_tdata_t *tdata, bool even_if_attached)
1889 prof_tdata_destroy_locked(tsd, tdata, even_if_attached);
1894 prof_tdata_detach(tsd_t *tsd, prof_tdata_t *tdata)
1898 malloc_mutex_lock(tsd_tsdn(tsd), tdata->lock);
1899 if (tdata->attached) {
1900 destroy_tdata = prof_tdata_should_destroy(tsd_tsdn(tsd), tdata,
1904 * another thread to win the race to destroy tdata.
1907 tdata->attached = false;
1911 malloc_mutex_unlock(tsd_tsdn(tsd), tdata->lock);
1913 prof_tdata_destroy(tsd, tdata, true);
1917 prof_tdata_reinit(tsd_t *tsd, prof_tdata_t *tdata)
1919 uint64_t thr_uid = tdata->thr_uid;
1920 uint64_t thr_discrim = tdata->thr_discrim + 1;
1921 char *thread_name = (tdata->thread_name != NULL) ?
1922 prof_thread_name_alloc(tsd_tsdn(tsd), tdata->thread_name) : NULL;
1923 bool active = tdata->active;
1925 prof_tdata_detach(tsd, tdata);
1931 prof_tdata_expire(tsdn_t *tsdn, prof_tdata_t *tdata)
1935 malloc_mutex_lock(tsdn, tdata->lock);
1936 if (!tdata->expired) {
1937 tdata->expired = true;
1938 destroy_tdata = tdata->attached ? false :
1939 prof_tdata_should_destroy(tsdn, tdata, false);
1942 malloc_mutex_unlock(tsdn, tdata->lock);
1948 prof_tdata_reset_iter(prof_tdata_tree_t *tdatas, prof_tdata_t *tdata, void *arg)
1952 return (prof_tdata_expire(tsdn, tdata) ? tdata : NULL);
1985 prof_tdata_t *tdata;
1990 tdata = tsd_prof_tdata_get(tsd);
1991 if (tdata != NULL)
1992 prof_tdata_detach(tsd, tdata);
2021 prof_tdata_t *tdata;
2023 tdata = prof_tdata_get(tsd, true);
2024 if (tdata == NULL)
2026 return (tdata->thread_name != NULL ? tdata->thread_name : "");
2053 prof_tdata_t *tdata;
2057 tdata = prof_tdata_get(tsd, true);
2058 if (tdata == NULL)
2074 if (tdata->thread_name != NULL) {
2075 idalloctm(tsd_tsdn(tsd), tdata->thread_name, NULL, true, true);
2076 tdata->thread_name = NULL;
2079 tdata->thread_name = s;
2086 prof_tdata_t *tdata;
2088 tdata = prof_tdata_get(tsd, true);
2089 if (tdata == NULL)
2091 return (tdata->active);
2097 prof_tdata_t *tdata;
2099 tdata = prof_tdata_get(tsd, true);
2100 if (tdata == NULL)
2102 tdata->active = active;