Lines Matching defs:bin
66 bin_t *bin);
577 arena_bin_slabs_nonfull_insert(bin_t *bin, edata_t *slab) {
579 edata_heap_insert(&bin->slabs_nonfull, slab);
581 bin->stats.nonfull_slabs++;
586 arena_bin_slabs_nonfull_remove(bin_t *bin, edata_t *slab) {
587 edata_heap_remove(&bin->slabs_nonfull, slab);
589 bin->stats.nonfull_slabs--;
594 arena_bin_slabs_nonfull_tryget(bin_t *bin) {
595 edata_t *slab = edata_heap_remove_first(&bin->slabs_nonfull);
600 bin->stats.reslabs++;
601 bin->stats.nonfull_slabs--;
607 arena_bin_slabs_full_insert(arena_t *arena, bin_t *bin, edata_t *slab) {
617 edata_list_active_append(&bin->slabs_full, slab);
621 arena_bin_slabs_full_remove(arena_t *arena, bin_t *bin, edata_t *slab) {
625 edata_list_active_remove(&bin->slabs_full, slab);
629 arena_bin_reset(tsd_t *tsd, arena_t *arena, bin_t *bin) {
632 malloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);
633 if (bin->slabcur != NULL) {
634 slab = bin->slabcur;
635 bin->slabcur = NULL;
636 malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);
638 malloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);
640 while ((slab = edata_heap_remove_first(&bin->slabs_nonfull)) != NULL) {
641 malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);
643 malloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);
645 for (slab = edata_list_active_first(&bin->slabs_full); slab != NULL;
646 slab = edata_list_active_first(&bin->slabs_full)) {
647 arena_bin_slabs_full_remove(arena, bin, slab);
648 malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);
650 malloc_mutex_lock(tsd_tsdn(tsd), &bin->lock);
653 bin->stats.curregs = 0;
654 bin->stats.curslabs = 0;
656 malloc_mutex_unlock(tsd_tsdn(tsd), &bin->lock);
866 bin_t *bin, szind_t binind, edata_t *fresh_slab) {
867 malloc_mutex_assert_owner(tsdn, &bin->lock);
869 assert(bin->slabcur == NULL);
870 assert(edata_heap_first(&bin->slabs_nonfull) == NULL);
876 bin->stats.nslabs++;
877 bin->stats.curslabs++;
879 bin->slabcur = fresh_slab;
884 arena_bin_malloc_with_fresh_slab(tsdn_t *tsdn, arena_t *arena, bin_t *bin,
886 malloc_mutex_assert_owner(tsdn, &bin->lock);
887 arena_bin_refill_slabcur_with_fresh_slab(tsdn, arena, bin, binind,
890 return arena_slab_reg_alloc(bin->slabcur, &bin_infos[binind]);
895 bin_t *bin) {
896 malloc_mutex_assert_owner(tsdn, &bin->lock);
898 assert(bin->slabcur == NULL || edata_nfree_get(bin->slabcur) == 0);
900 if (bin->slabcur != NULL) {
901 arena_bin_slabs_full_insert(arena, bin, bin->slabcur);
905 bin->slabcur = arena_bin_slabs_nonfull_tryget(bin);
906 assert(bin->slabcur == NULL || edata_nfree_get(bin->slabcur) > 0);
908 return (bin->slabcur == NULL);
939 * Bin-local resources are used first: 1) bin->slabcur, and 2) nonfull
950 * gets one chance of slab_alloc, and a retry of bin local resources
952 * the bin lock is dropped during the slab allocation).
960 * with filled < nfill) after going through the three steps: a) bin
962 * and bin local fails again.
969 bin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);
972 malloc_mutex_lock(tsdn, &bin->lock);
976 edata_t *slabcur = bin->slabcur;
989 if (!arena_bin_refill_slabcur_no_fresh_slab(tsdn, arena, bin)) {
990 assert(bin->slabcur != NULL);
997 bin, binind, fresh_slab);
998 assert(bin->slabcur != NULL);
1005 assert(bin->slabcur == NULL);
1020 bin->stats.nmalloc += filled;
1021 bin->stats.nrequests += cache_bin->tstats.nrequests;
1022 bin->stats.curregs += filled;
1023 bin->stats.nfills++;
1027 malloc_mutex_unlock(tsdn, &bin->lock);
1066 bin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);
1098 malloc_mutex_lock(tsdn, &bin->lock);
1104 arena_bin_lower_slab(tsdn, arena, slab, bin);
1107 edata_list_active_concat(&bin->slabs_full, &fulls);
1111 bin->stats.nslabs += nslab;
1112 bin->stats.curslabs += nslab;
1113 bin->stats.nmalloc += filled;
1114 bin->stats.nrequests += filled;
1115 bin->stats.curregs += filled;
1117 malloc_mutex_unlock(tsdn, &bin->lock);
1125 * bin->slabcur if necessary.
1128 arena_bin_malloc_no_fresh_slab(tsdn_t *tsdn, arena_t *arena, bin_t *bin,
1130 malloc_mutex_assert_owner(tsdn, &bin->lock);
1131 if (bin->slabcur == NULL || edata_nfree_get(bin->slabcur) == 0) {
1132 if (arena_bin_refill_slabcur_no_fresh_slab(tsdn, arena, bin)) {
1137 assert(bin->slabcur != NULL && edata_nfree_get(bin->slabcur) > 0);
1138 return arena_slab_reg_alloc(bin->slabcur, &bin_infos[binind]);
1147 bin_t *bin = arena_bin_choose(tsdn, arena, binind, &binshard);
1149 malloc_mutex_lock(tsdn, &bin->lock);
1151 void *ret = arena_bin_malloc_no_fresh_slab(tsdn, arena, bin, binind);
1153 malloc_mutex_unlock(tsdn, &bin->lock);
1158 malloc_mutex_lock(tsdn, &bin->lock);
1160 ret = arena_bin_malloc_no_fresh_slab(tsdn, arena, bin, binind);
1164 malloc_mutex_unlock(tsdn, &bin->lock);
1167 ret = arena_bin_malloc_with_fresh_slab(tsdn, arena, bin,
1173 bin->stats.nmalloc++;
1174 bin->stats.nrequests++;
1175 bin->stats.curregs++;
1177 malloc_mutex_unlock(tsdn, &bin->lock);
1295 arena_dissociate_bin_slab(arena_t *arena, edata_t *slab, bin_t *bin) {
1296 /* Dissociate slab from bin. */
1297 if (slab == bin->slabcur) {
1298 bin->slabcur = NULL;
1309 arena_bin_slabs_full_remove(arena, bin, slab);
1311 arena_bin_slabs_nonfull_remove(bin, slab);
1318 bin_t *bin) {
1322 * Make sure that if bin->slabcur is non-NULL, it refers to the
1327 if (bin->slabcur != NULL && edata_snad_comp(bin->slabcur, slab) > 0) {
1329 if (edata_nfree_get(bin->slabcur) > 0) {
1330 arena_bin_slabs_nonfull_insert(bin, bin->slabcur);
1332 arena_bin_slabs_full_insert(arena, bin, bin->slabcur);
1334 bin->slabcur = slab;
1336 bin->stats.reslabs++;
1339 arena_bin_slabs_nonfull_insert(bin, slab);
1344 arena_dalloc_bin_slab_prepare(tsdn_t *tsdn, edata_t *slab, bin_t *bin) {
1345 malloc_mutex_assert_owner(tsdn, &bin->lock);
1347 assert(slab != bin->slabcur);
1349 bin->stats.curslabs--;
1355 edata_t *slab, bin_t *bin) {
1356 arena_dissociate_bin_slab(arena, slab, bin);
1357 arena_dalloc_bin_slab_prepare(tsdn, slab, bin);
1362 edata_t *slab, bin_t *bin) {
1363 arena_bin_slabs_full_remove(arena, bin, slab);
1364 arena_bin_lower_slab(tsdn, arena, slab, bin);
1371 bin_t *bin = arena_get_bin(arena, binind, binshard);
1373 malloc_mutex_lock(tsdn, &bin->lock);
1376 bool ret = arena_dalloc_bin_locked_step(tsdn, arena, bin,
1378 arena_dalloc_bin_locked_finish(tsdn, arena, bin, &info);
1379 malloc_mutex_unlock(tsdn, &bin->lock);