reflow comments in wtf/allocator

third_party/WebKit/Source/wtf/allocator/PartitionAlloc.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 82 matching lines @@
     bestPages = static_cast<uint16_t>(size / kSystemPageSize);
     RELEASE_ASSERT(bestPages < (1 << 8));
     return static_cast<uint8_t>(bestPages);
   }
   ASSERT(size <= kMaxSystemPagesPerSlotSpan * kSystemPageSize);
   for (uint16_t i = kNumSystemPagesPerPartitionPage - 1;
        i <= kMaxSystemPagesPerSlotSpan; ++i) {
     size_t pageSize = kSystemPageSize * i;
     size_t numSlots = pageSize / size;
     size_t waste = pageSize - (numSlots * size);
-    // Leaving a page unfaulted is not free; the page will occupy an empty page table entry.
-    // Make a simple attempt to account for that.
+    // Leaving a page unfaulted is not free; the page will occupy an empty page
+    // table entry.  Make a simple attempt to account for that.
     size_t numRemainderPages = i & (kNumSystemPagesPerPartitionPage - 1);
     size_t numUnfaultedPages =
         numRemainderPages
             ? (kNumSystemPagesPerPartitionPage - numRemainderPages)
             : 0;
     waste += sizeof(void*) * numUnfaultedPages;
     double wasteRatio = (double)waste / (double)pageSize;
     if (wasteRatio < bestWasteRatio) {
       bestWasteRatio = wasteRatio;
       bestPages = i;
@@ skipping 70 matching lines @@
 
 void partitionAllocGenericInit(PartitionRootGeneric* root) {
   SpinLock::Guard guard(root->lock);
 
   partitionAllocBaseInit(root);
 
   // Precalculate some shift and mask constants used in the hot path.
   // Example: malloc(41) == 101001 binary.
   // Order is 6 (1 << 6-1)==32 is highest bit set.
   // orderIndex is the next three MSB == 010 == 2.
-  // subOrderIndexMask is a mask for the remaining bits == 11 (masking to 01 for the subOrderIndex).
+  // subOrderIndexMask is a mask for the remaining bits == 11 (masking to 01 for
+  // the subOrderIndex).
   size_t order;
   for (order = 0; order <= kBitsPerSizet; ++order) {
     size_t orderIndexShift;
     if (order < kGenericNumBucketsPerOrderBits + 1)
       orderIndexShift = 0;
     else
       orderIndexShift = order - (kGenericNumBucketsPerOrderBits + 1);
     root->orderIndexShifts[order] = orderIndexShift;
     size_t subOrderIndexMask;
     if (order == kBitsPerSizet) {
@@ skipping 231 matching lines @@
     // In this case, we can still hand out pages from the current super page
     // allocation.
     char* ret = root->nextPartitionPage;
     root->nextPartitionPage += totalSize;
     partitionIncreaseCommittedPages(root, totalSize);
     return ret;
   }
 
   // Need a new super page. We want to allocate super pages in a continguous
   // address region as much as possible. This is important for not causing
-  // page table bloat and not fragmenting address spaces in 32 bit architectures.
+  // page table bloat and not fragmenting address spaces in 32 bit
+  // architectures.
   char* requestedAddress = root->nextSuperPage;
   char* superPage = reinterpret_cast<char*>(allocPages(
       requestedAddress, kSuperPageSize, kSuperPageSize, PageAccessible));
   if (UNLIKELY(!superPage))
     return 0;
 
   root->totalSizeOfSuperPages += kSuperPageSize;
   partitionIncreaseCommittedPages(root, totalSize);
 
   root->nextSuperPage = superPage + kSuperPageSize;
@@ skipping 42 matching lines @@
       ASSERT(!root->firstExtent);
       root->firstExtent = latestExtent;
     } else {
       ASSERT(currentExtent->superPageBase);
       currentExtent->next = latestExtent;
     }
     root->currentExtent = latestExtent;
     latestExtent->superPageBase = superPage;
     latestExtent->superPagesEnd = superPage + kSuperPageSize;
   } else {
-    // We allocated next to an existing extent so just nudge the size up a little.
+    // We allocated next to an existing extent so just nudge the size up a
+    // little.
     ASSERT(currentExtent->superPagesEnd);
     currentExtent->superPagesEnd += kSuperPageSize;
     ASSERT(ret >= currentExtent->superPageBase &&
            ret < currentExtent->superPagesEnd);
   }
   return ret;
 }
 
 static ALWAYS_INLINE uint16_t
 partitionBucketPartitionPages(const PartitionBucket* bucket) {
@@ skipping 35 matching lines @@
   }
 }
 
 static ALWAYS_INLINE char* partitionPageAllocAndFillFreelist(
     PartitionPage* page) {
   ASSERT(page != &PartitionRootGeneric::gSeedPage);
   uint16_t numSlots = page->numUnprovisionedSlots;
   ASSERT(numSlots);
   PartitionBucket* bucket = page->bucket;
   // We should only get here when _every_ slot is either used or unprovisioned.
-  // (The third state is "on the freelist". If we have a non-empty freelist, we should not get here.)
+  // (The third state is "on the freelist". If we have a non-empty freelist, we
+  // should not get here.)
   ASSERT(numSlots + page->numAllocatedSlots == partitionBucketSlots(bucket));
   // Similarly, make explicitly sure that the freelist is empty.
   ASSERT(!page->freelistHead);
   ASSERT(page->numAllocatedSlots >= 0);
 
   size_t size = bucket->slotSize;
   char* base = reinterpret_cast<char*>(partitionPageToPointer(page));
   char* returnObject = base + (size * page->numAllocatedSlots);
   char* firstFreelistPointer = returnObject + size;
   char* firstFreelistPointerExtent =
@@ skipping 14 matching lines @@
     // space, we may get an off-by-one when a freelist pointer fits in the
     // wasted space, but a slot does not.
     // We know we can fit at least one freelist pointer.
     numNewFreelistEntries = 1;
     // Any further entries require space for the whole slot span.
     numNewFreelistEntries += static_cast<uint16_t>(
         (freelistLimit - firstFreelistPointerExtent) / size);
   }
 
   // We always return an object slot -- that's the +1 below.
-  // We do not neccessarily create any new freelist entries, because we cross sub page boundaries frequently for large bucket sizes.
+  // We do not neccessarily create any new freelist entries, because we cross
+  // sub page boundaries frequently for large bucket sizes.
   ASSERT(numNewFreelistEntries + 1 <= numSlots);
   numSlots -= (numNewFreelistEntries + 1);
   page->numUnprovisionedSlots = numSlots;
   page->numAllocatedSlots++;
 
   if (LIKELY(numNewFreelistEntries)) {
     char* freelistPointer = firstFreelistPointer;
     PartitionFreelistEntry* entry =
         reinterpret_cast<PartitionFreelistEntry*>(freelistPointer);
     page->freelistHead = entry;
@@ skipping 866 matching lines @@
       partitionStats.totalDiscardableBytes += memoryStats[i].discardableBytes;
       if (!isLightDump)
         partitionStatsDumper->partitionsDumpBucketStats(partitionName,
                                                         &memoryStats[i]);
     }
   }
   partitionStatsDumper->partitionDumpTotals(partitionName, &partitionStats);
 }
 
 }  // namespace WTF