Lines Matching refs:alloc
34 static int udb_alloc_compact(void* base, udb_alloc* alloc);
200 udb->alloc = udb_alloc_create(udb, (udb_alloc_d*)( in udb_base_create_fd()
202 if(!udb->alloc) { in udb_base_create_fd()
209 udb_alloc_compact(udb, udb->alloc); in udb_base_create_fd()
320 if(udb->fd != -1 && udb->base && udb->alloc) { in udb_base_close()
321 uint64_t nsize = udb->alloc->disk->nextgrow; in udb_base_close()
345 udb_alloc_delete(udb->alloc); in udb_base_free()
359 udb_alloc_delete(udb->alloc); in udb_base_free_keep_mmap()
517 udb_base_remap(udb_base* udb, udb_alloc* alloc, uint64_t nsize) in udb_base_remap() argument
561 alloc->disk = (udb_alloc_d*)((char*)udb->glob_data in udb_base_remap()
567 (void)udb; (void)alloc; (void)nsize; in udb_base_remap()
576 udb_base_remap(udb, udb->alloc, udb->glob_data->fsize); in udb_base_remap_process()
609 return udb_base_remap(udb, udb->alloc, nsize);
670 fsck_fsize(udb_base* udb, udb_alloc* alloc) argument
680 if(!udb_base_remap(udb, alloc, (uint64_t)realsize))
772 regen_ptrlist(void* base, udb_base* udb, udb_alloc* alloc, argument
775 udb_void at = alloc->udb->glob_data->hsize;
777 while(at < alloc->disk->nextgrow) {
791 at = alloc->udb->glob_data->hsize;
792 while(at < alloc->disk->nextgrow) {
886 fsck_file(udb_base* udb, udb_alloc* alloc, int moved) argument
900 if(rb_old+rb_size <= alloc->disk->nextgrow
901 && rb_new+rb_size <= alloc->disk->nextgrow) {
921 regen.nextgrow = alloc->disk->nextgrow;
945 *alloc->disk = regen;
948 regen_ptrlist(base, udb, alloc, rb_old, rb_new);
963 udb_alloc* alloc = (udb_alloc*)xalloc_zero(sizeof(*alloc)); local
964 if(!alloc)
966 alloc->udb = udb;
967 alloc->disk = disk;
972 if(fsck_fsize(udb, alloc))
973 return alloc;
975 if(fsck_file(udb, alloc, 0))
976 return alloc;
978 if(fsck_file(udb, alloc, 1))
979 return alloc;
983 free(alloc);
986 return alloc;
989 void udb_alloc_delete(udb_alloc* alloc) argument
991 if(!alloc) return;
992 free(alloc);
997 udb_alloc_unlink_fl(void* base, udb_alloc* alloc, udb_void chunk, int exp) argument
1006 assert(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]);
1010 else alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = fp->next;
1017 udb_alloc_pop_fl(void* base, udb_alloc* alloc, int exp) argument
1019 udb_void f = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP];
1025 alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = fp->next;
1034 udb_alloc_push_fl(void* base, udb_alloc* alloc, udb_void f, int exp) argument
1042 fp->next = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP];
1046 alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = f;
1051 udb_alloc_push_fl_noinit(void* base, udb_alloc* alloc, udb_void f, int exp) argument
1059 fp->next = alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP];
1062 alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP] = f;
1067 grow_align(void* base, udb_alloc* alloc, uint64_t esz) argument
1069 while( (alloc->disk->nextgrow & (esz-1)) != 0) {
1072 int fexp = udb_exp_offset(alloc->disk->nextgrow);
1074 udb_void f = alloc->disk->nextgrow;
1075 udb_void fn = alloc->disk->nextgrow+fsz;
1076 assert(fn <= alloc->udb->base_size);
1077 alloc->disk->stat_free += fsz;
1078 udb_alloc_push_fl(base, alloc, f, fexp);
1080 alloc->disk->nextgrow = fn;
1086 grow_chunks(void* base, udb_alloc* alloc, size_t sz, int exp) argument
1090 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1091 grow_align(base, alloc, esz);
1093 ret = alloc->disk->nextgrow;
1102 alloc->disk->stat_alloc += esz;
1103 alloc->disk->stat_data += sz;
1105 alloc->disk->nextgrow += esz;
1106 assert(alloc->disk->nextgrow <= alloc->udb->base_size);
1107 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1113 grow_end_calc(udb_alloc* alloc, int exp) argument
1116 uint64_t ng = alloc->disk->nextgrow;
1132 grow_extra_check(udb_alloc* alloc, uint64_t ge) argument
1135 uint64_t bsz = alloc->udb->base_size;
1154 enough_free(udb_alloc* alloc) argument
1156 if(alloc->udb->base_size <= 2*1024*1024) {
1159 if(((size_t)alloc->disk->nextgrow)*3 <= alloc->udb->base_size)
1164 uint64_t space = alloc->udb->base_size - alloc->disk->nextgrow;
1165 if(space >= 1024*1024 && (space*4 >= alloc->udb->base_size
1166 || alloc->udb->base_size < 4*1024*1024))
1174 udb_alloc_grow_space(void* base, udb_alloc* alloc, size_t sz, int exp) argument
1183 uint64_t grow_end = grow_end_calc(alloc, exp);
1184 assert(alloc->udb->base_size >= alloc->disk->nextgrow);
1185 if(grow_end <= alloc->udb->base_size) {
1187 return grow_chunks(base, alloc, sz, exp);
1192 grow_end = grow_extra_check(alloc, grow_end);
1193 if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) {
1197 assert(grow_end <= alloc->udb->base_size);
1198 assert(alloc->udb->glob_data->fsize == alloc->udb->base_size);
1199 return grow_chunks(base, alloc, sz, exp);
1204 grow_xl(void* base, udb_alloc* alloc, uint64_t xlsz, uint64_t sz) argument
1208 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1211 grow_align(base, alloc, UDB_ALLOC_CHUNK_SIZE);
1214 ret = alloc->disk->nextgrow;
1227 alloc->disk->stat_data += sz;
1228 alloc->disk->stat_alloc += xlsz;
1230 alloc->disk->nextgrow += xlsz;
1231 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1237 udb_alloc_xl_space(void* base, udb_alloc* alloc, size_t sz) argument
1242 uint64_t grow_end = grow_end_calc(alloc, UDB_ALLOC_CHUNKS_MAX) + need;
1244 if(grow_end <= alloc->udb->base_size) {
1246 return grow_xl(base, alloc, need, sz);
1249 grow_end = grow_extra_check(alloc, grow_end);
1250 if(!(base=udb_base_grow_and_remap(alloc->udb, grow_end))) {
1254 assert(grow_end <= alloc->udb->base_size);
1255 assert(alloc->udb->glob_data->fsize == alloc->udb->base_size);
1256 return grow_xl(base, alloc, need, sz);
1261 udb_alloc_subdivide(void* base, udb_alloc* alloc, udb_void big, int e2, argument
1272 udb_alloc_push_fl(base, alloc, big+sz, e);
1294 udb_void udb_alloc_space(udb_alloc* alloc, size_t sz) argument
1296 void* base = alloc->udb->base;
1300 return udb_alloc_xl_space(base, alloc, sz);
1302 if(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP]) {
1305 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1306 ret = udb_alloc_pop_fl(base, alloc, exp);
1312 alloc->disk->stat_data += sz;
1313 alloc->disk->stat_alloc += (1<<exp);
1314 assert(alloc->disk->stat_free >= (1u<<exp));
1315 alloc->disk->stat_free -= (1<<exp);
1316 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1321 if(alloc->disk->free[e2-UDB_ALLOC_CHUNK_MINEXP]) {
1323 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1324 big = udb_alloc_pop_fl(base, alloc, e2);
1326 ret = udb_alloc_subdivide(base, alloc, big, e2, exp);
1337 alloc->disk->stat_data += sz;
1338 alloc->disk->stat_alloc += (1<<exp);
1339 assert(alloc->disk->stat_free >= (1u<<exp));
1340 alloc->disk->stat_free -= (1<<exp);
1341 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1345 return udb_alloc_grow_space(base, alloc, sz, exp);
1350 have_free_for(udb_alloc* alloc, int exp) argument
1353 if(alloc->disk->free[exp-UDB_ALLOC_CHUNK_MINEXP])
1356 if(alloc->disk->free[e2-UDB_ALLOC_CHUNK_MINEXP]) {
1400 move_chunk(void* base, udb_alloc* alloc, udb_void f, int exp, uint64_t esz, argument
1403 udb_void res = udb_alloc_pop_fl(base, alloc, e2);
1408 res = udb_alloc_subdivide(base, alloc, res, e2, exp);
1412 alloc->udb->glob_data->rb_old = f;
1413 alloc->udb->glob_data->rb_new = res;
1414 alloc->udb->glob_data->rb_size = esz;
1421 chunk_fix_ptrs(base, alloc->udb, rp, res+sizeof(udb_chunk_d),
1429 free_xl_space(void* base, udb_alloc* alloc, udb_void s, uint64_t m) argument
1437 udb_alloc_unlink_fl(base, alloc, q, UDB_ALLOC_CHUNKS_MAX);
1475 move_xl_list(void* base, udb_alloc* alloc, udb_void xl_start, uint64_t xl_sz, argument
1487 move_xl_segment(base, alloc->udb, xl, n, sz, 0);
1488 chunk_fix_ptrs(base, alloc->udb, UDB_CHUNK(n),
1493 alloc->disk->stat_free -= amount;
1494 alloc->disk->nextgrow -= amount;
1495 alloc->udb->glob_data->rb_old = 0;
1496 alloc->udb->glob_data->rb_new = 0;
1497 alloc->udb->glob_data->rb_size = 0;
1502 coagulate_possible(void* base, udb_alloc* alloc, udb_void f, int exp, argument
1508 if(other >= alloc->udb->base_size)
1510 if(other >= alloc->disk->nextgrow)
1512 if(other < alloc->udb->glob_data->hsize)
1540 coagulate_and_push(void* base, udb_alloc* alloc, udb_void last, int exp, argument
1545 while( (other=coagulate_possible(base, alloc, last, exp, esz)) ) {
1547 udb_alloc_unlink_fl(base, alloc, other, exp);
1555 udb_alloc_push_fl(base, alloc, last, exp);
1561 udb_alloc_compact(void* base, udb_alloc* alloc) argument
1566 uint64_t at = alloc->disk->nextgrow;
1569 if(alloc->udb->inhibit_compact)
1571 alloc->udb->useful_compact = 0;
1572 while(at > alloc->udb->glob_data->hsize) {
1595 alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1596 free_xl_space(base, alloc, xl+xlsz, m);
1597 move_xl_list(base, alloc, xl_start, xl_sz, m);
1598 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1616 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1617 udb_alloc_unlink_fl(base, alloc, last, exp);
1618 alloc->disk->stat_free -= esz;
1619 alloc->disk->nextgrow = last;
1620 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1624 } else if( (e2=have_free_for(alloc, exp)) ) {
1627 alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1628 move_chunk(base, alloc, last, exp, esz, e2);
1630 last = coagulate_and_push(base, alloc,
1634 alloc->disk->stat_free -= esz;
1635 alloc->disk->nextgrow = last;
1637 alloc->udb->glob_data->rb_old = 0;
1638 alloc->udb->glob_data->rb_new = 0;
1639 alloc->udb->glob_data->rb_size = 0;
1640 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1672 alloc->udb->glob_data->dirty_alloc = udb_dirty_compact;
1673 free_xl_space(base, alloc, at, m);
1674 move_xl_list(base, alloc, xl_start, xl_sz, m);
1675 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1680 if(enough_free(alloc)) {
1681 uint64_t nsize = alloc->disk->nextgrow;
1682 udb_base_shrink(alloc->udb, nsize);
1683 if(!udb_base_remap(alloc->udb, alloc, nsize))
1695 return udb_alloc_compact(udb->base, udb->alloc);
1716 udb_free_xl(void* base, udb_alloc* alloc, udb_void f, udb_xl_chunk_d* fp, argument
1728 (*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type,
1732 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1734 alloc->disk->stat_data -= sz;
1735 alloc->disk->stat_alloc -= xlsz;
1736 alloc->disk->stat_free += xlsz;
1743 udb_alloc_push_fl(base, alloc, c, UDB_ALLOC_CHUNKS_MAX);
1746 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1749 int udb_alloc_free(udb_alloc* alloc, udb_void r, size_t sz) argument
1763 base = alloc->udb->base;
1778 udb_free_xl(base, alloc, f, (udb_xl_chunk_d*)fp, sz);
1780 if(alloc->udb->inhibit_compact) {
1781 alloc->udb->useful_compact = 1;
1784 return udb_alloc_compact(base, alloc);
1794 (*alloc->udb->walkfunc)(base, alloc->udb->walkarg, fp->type,
1799 alloc->udb->glob_data->dirty_alloc = udb_dirty_fl;
1800 alloc->disk->stat_data -= sz;
1801 alloc->disk->stat_free += esz;
1802 alloc->disk->stat_alloc -= esz;
1805 while( (other=coagulate_possible(base, alloc, f, exp, esz)) ) {
1808 udb_alloc_unlink_fl(base, alloc, other, exp);
1817 udb_alloc_push_fl(base, alloc, f, exp);
1823 udb_alloc_push_fl_noinit(base, alloc, f, exp);
1825 alloc->udb->glob_data->dirty_alloc = udb_dirty_clean;
1827 if(alloc->udb->inhibit_compact) {
1828 alloc->udb->useful_compact = 1;
1831 return udb_alloc_compact(base, alloc);
1834 udb_void udb_alloc_init(udb_alloc* alloc, void* d, size_t sz) argument
1837 udb_void r = udb_alloc_space(alloc, sz);
1839 memcpy(UDB_REL(alloc->udb->base, r), d, sz);
1843 udb_void udb_alloc_realloc(udb_alloc* alloc, udb_void r, size_t osz, size_t sz) argument
1845 void* base = alloc->udb->base;
1852 return udb_alloc_space(alloc, sz);
1854 if(!udb_alloc_free(alloc, r, osz))
1870 newd = udb_alloc_space(alloc, sz);
1873 base = alloc->udb->base;
1880 chunk_fix_ptrs(base, alloc->udb, np, newd, osz, r);
1882 if(!udb_alloc_free(alloc, r, osz))
1887 int udb_alloc_grow(udb_alloc* alloc, size_t sz, size_t num) argument
1897 want = grow_end_calc(alloc, exp) + esz*(num-1);
1898 assert(want >= alloc->udb->base_size);
1899 if(!udb_base_grow_and_remap(alloc->udb, want)) {
1906 void udb_alloc_set_type(udb_alloc* alloc, udb_void r, udb_chunk_type tp) argument
1908 void* base = alloc->udb->base;
1923 (to+destsize) <= udb->alloc->disk->nextgrow);
2077 r = udb_alloc_space(udb->alloc, sz);
2079 udb_alloc_set_type(udb->alloc, r, type);
2090 udb_alloc_free(udb->alloc, d, sz);