Lines Matching refs:bucket
65 // This works out reasonably for the current bucket sizes of the generic
130 static void partitionBucketInitBase(PartitionBucket* bucket, PartitionRootBase* root)
132 bucket->activePagesHead = &PartitionRootGeneric::gSeedPage;
133 bucket->freePagesHead = 0;
134 bucket->numFullPages = 0;
135 bucket->numSystemPagesPerSlotSpan = partitionBucketNumSystemPages(bucket->slotSize);
146 PartitionBucket* bucket = &root->buckets()[i];
148 bucket->slotSize = kAllocationGranularity;
150 bucket->slotSize = i << kBucketShift;
151 partitionBucketInitBase(bucket, root);
188 // We avoid them in the bucket lookup map, but we tolerate them to keep the
193 PartitionBucket* bucket = &root->buckets[0];
196 bucket->slotSize = currentSize;
197 partitionBucketInitBase(bucket, root);
200 bucket->activePagesHead = 0;
202 ++bucket;
207 ASSERT(bucket == &root->buckets[0] + (kGenericNumBucketedOrders * kGenericNumBucketsPerOrder));
209 // Then set up the fast size -> bucket lookup table.
210 bucket = &root->buckets[0];
215 // Use the bucket of finest granularity for malloc(0) etc.
220 PartitionBucket* validBucket = bucket;
225 bucket++;
229 ASSERT(bucket == &root->buckets[0] + (kGenericNumBucketedOrders * kGenericNumBucketsPerOrder));
231 // And there's one last bucket lookup that will be hit for e.g. malloc(-1),
236 static bool partitionAllocShutdownBucket(PartitionBucket* bucket)
239 bool noLeaks = !bucket->numFullPages;
240 PartitionPage* page = bucket->activePagesHead;
280 PartitionBucket* bucket = &root->buckets()[i];
281 if (!partitionAllocShutdownBucket(bucket))
294 PartitionBucket* bucket = &root->buckets[i];
295 if (!partitionAllocShutdownBucket(bucket))
402 ASSERT(page->bucket->numSystemPagesPerSlotSpan);
404 partitionDecommitSystemPages(root, addr, page->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
407 static ALWAYS_INLINE size_t partitionBucketSlots(const PartitionBucket* bucket)
409 return (bucket->numSystemPagesPerSlotSpan * kSystemPageSize) / bucket->slotSize;
412 static ALWAYS_INLINE size_t partitionBucketPartitionPages(const PartitionBucket* bucket)
414 return (bucket->numSystemPagesPerSlotSpan + (kNumSystemPagesPerPartitionPage - 1)) / kNumSystemPagesPerPartitionPage;
417 static ALWAYS_INLINE void partitionPageReset(PartitionPage* page, PartitionBucket* bucket)
421 page->numUnprovisionedSlots = partitionBucketSlots(bucket);
423 page->bucket = bucket;
429 size_t numPartitionPages = partitionBucketPartitionPages(bucket);
444 PartitionBucket* bucket = page->bucket;
447 ASSERT(numSlots + page->numAllocatedSlots == partitionBucketSlots(bucket));
452 size_t size = bucket->slotSize;
478 // We do not neccessarily create any new freelist entries, because we cross sub page boundaries frequently for large bucket sizes.
517 PartitionBucket* bucket = page->bucket;
521 ASSERT(page->bucket == bucket);
522 ASSERT(page != bucket->freePagesHead);
523 ASSERT(!bucket->freePagesHead || page != bucket->freePagesHead->nextPage);
528 bucket->activePagesHead = page;
536 page->nextPage = bucket->freePagesHead;
537 bucket->freePagesHead = page;
542 ASSERT(page->numAllocatedSlots == static_cast<int>(partitionBucketSlots(bucket)));
544 ++bucket->numFullPages;
547 RELEASE_ASSERT(bucket->numFullPages);
553 bucket->activePagesHead = 0;
563 ASSERT(partitionBucketIsDirectMapped(page->bucket));
609 PartitionBucket* bucket = reinterpret_cast<PartitionBucket*>(reinterpret_cast<char*>(page) + kPageMetadataSize);
612 page->bucket = bucket;
618 bucket->activePagesHead = 0;
619 bucket->freePagesHead = 0;
620 bucket->slotSize = size;
621 bucket->numSystemPagesPerSlotSpan = 0;
622 bucket->numFullPages = 0;
648 void* partitionAllocSlowPath(PartitionRootBase* root, int flags, size_t size, PartitionBucket* bucket)
651 ASSERT(!bucket->activePagesHead->freelistHead);
658 if (UNLIKELY(partitionBucketIsDirectMapped(bucket))) {
660 ASSERT(bucket == &PartitionRootBase::gPagedBucket);
671 if (LIKELY(partitionSetNewActivePage(bucket->activePagesHead))) {
672 PartitionPage* newPage = bucket->activePagesHead;
684 PartitionPage* newPage = bucket->freePagesHead;
691 bucket->freePagesHead = newPage->nextPage;
693 partitionRecommitSystemPages(root, addr, newPage->bucket->numSystemPagesPerSlotSpan * kSystemPageSize);
696 size_t numPartitionPages = partitionBucketPartitionPages(bucket);
702 // Skip the alignment check because it depends on page->bucket, which is not yet set.
706 partitionPageReset(newPage, bucket);
707 bucket->activePagesHead = newPage;
767 PartitionBucket* bucket = page->bucket;
769 ASSERT(bucket->activePagesHead != &PartitionRootGeneric::gSeedPage);
772 if (UNLIKELY(partitionBucketIsDirectMapped(bucket))) {
778 if (LIKELY(page == bucket->activePagesHead) && page->nextPage) {
780 ASSERT(bucket->activePagesHead != page);
785 PartitionPage* currentPage = bucket->activePagesHead;
789 bucket->activePagesHead = page;
802 ASSERT(page->numAllocatedSlots == static_cast<int>(partitionBucketSlots(bucket) - 1));
807 page->nextPage = bucket->activePagesHead;
808 bucket->activePagesHead = page;
809 --bucket->numFullPages;
819 ASSERT(partitionBucketIsDirectMapped(page->bucket));
829 // bucket->slotSize is the current size of the allocation.
830 size_t currentSize = page->bucket->slotSize;
869 page->bucket->slotSize = newSize;
891 if (UNLIKELY(partitionBucketIsDirectMapped(page->bucket))) {
933 const PartitionBucket& bucket = root.buckets()[i];
934 if (bucket.activePagesHead == &PartitionRootGeneric::gSeedPage && !bucket.freePagesHead && !bucket.numFullPages) {
935 // Empty bucket with no freelist or full pages. Skip reporting it.
939 PartitionPage* freePages = bucket.freePagesHead;
944 size_t bucketSlotSize = bucket.slotSize;
945 size_t bucketNumSlots = partitionBucketSlots(&bucket);
947 size_t bucketPageSize = bucket.numSystemPagesPerSlotSpan * kSystemPageSize;
949 size_t numActiveBytes = bucket.numFullPages * bucketUsefulStorage;
950 size_t numResidentBytes = bucket.numFullPages * bucketPageSize;
953 const PartitionPage* page = bucket.activePagesHead;
974 printf("bucket size %zu (pageSize %zu waste %zu): %zu alloc/%zu commit/%zu freeable bytes, %zu/%zu/%zu full/active/free pages\n", bucketSlotSize, bucketPageSize, bucketWaste, numActiveBytes, numResidentBytes, numFreeableBytes, static_cast<size_t>(bucket.numFullPages), numActivePages, numFreePages);
