Rename freelist2->freelist

Author: mysterymath

libc/src/__support/CMakeLists.txt

@@ -17,7 +17,7 @@ add_header_library(
 add_header_library(
   freelist
   HDRS
-    freelist2.h
+    freelist.h
   DEPENDS
     libc.src.__support.fixedvector
     libc.src.__support.CPP.array

libc/src/__support/freelist2.h renamed to libc/src/__support/freelist.h

@@ -6,22 +6,22 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_LIBC_SRC___SUPPORT_FREELIST2_H
-#define LLVM_LIBC_SRC___SUPPORT_FREELIST2_H
+#ifndef LLVM_LIBC_SRC___SUPPORT_FREELIST_H
+#define LLVM_LIBC_SRC___SUPPORT_FREELIST_H
 
 #include "block.h"
 
 namespace LIBC_NAMESPACE_DECL {
 
 /// A circularly-linked FIFO list node storing a free Block. A list is a
-/// FreeList2*; nullptr is an empty list. All Blocks on a list are the same
+/// FreeList*; nullptr is an empty list. All Blocks on a list are the same
 /// size.
 ///
 /// Accessing free blocks in FIFO order maximizes the amount of time before a
 /// free block is reused. This in turn maximizes the number of opportunities for
 /// it to be coalesced with an adjacent block, which tends to reduce heap
 /// fragmentation.
-class FreeList2 {
+class FreeList {
 public:
   Block<> *block() const {
     return const_cast<Block<> *>(Block<>::from_usable_space(this));
@@ -30,30 +30,30 @@ class FreeList2 {
   /// @returns Size for all blocks on the list.
   size_t size() const { return block()->inner_size(); }
 
-  /// Push to the back. The Block must be able to contain a FreeList2.
-  static void push(FreeList2 *&list, Block<> *block);
+  /// Push to the back. The Block must be able to contain a FreeList.
+  static void push(FreeList *&list, Block<> *block);
 
   /// Pop the front.
-  static void pop(FreeList2 *&list);
+  static void pop(FreeList *&list);
 
 protected:
   /// Push an already-constructed node to the back.
-  static void push(FreeList2 *&list, FreeList2 *node);
+  static void push(FreeList *&list, FreeList *node);
 
 private:
   // Circularly linked pointers to adjacent nodes.
-  FreeList2 *prev;
-  FreeList2 *next;
+  FreeList *prev;
+  FreeList *next;
 };
 
-LIBC_INLINE void FreeList2::push(FreeList2 *&list, Block<> *block) {
+LIBC_INLINE void FreeList::push(FreeList *&list, Block<> *block) {
   LIBC_ASSERT(!block->used() && "only free blocks can be placed on free lists");
-  LIBC_ASSERT(block->inner_size_free() >= sizeof(FreeList2) &&
+  LIBC_ASSERT(block->inner_size_free() >= sizeof(FreeList) &&
               "block too small to accomodate free list node");
-  push(list, new (block->usable_space()) FreeList2);
+  push(list, new (block->usable_space()) FreeList);
 }
 
-LIBC_INLINE void FreeList2::pop(FreeList2 *&list) {
+LIBC_INLINE void FreeList::pop(FreeList *&list) {
   LIBC_ASSERT(list != nullptr && "cannot pop from empty list");
   if (list->next == list) {
     list = nullptr;
@@ -64,7 +64,7 @@ LIBC_INLINE void FreeList2::pop(FreeList2 *&list) {
   }
 }
 
-LIBC_INLINE void FreeList2::push(FreeList2 *&list, FreeList2 *node) {
+LIBC_INLINE void FreeList::push(FreeList *&list, FreeList *node) {
   if (list) {
     LIBC_ASSERT(Block<>::from_usable_space(node)->outer_size() ==
                     list->block()->outer_size() &&
@@ -80,4 +80,4 @@ LIBC_INLINE void FreeList2::push(FreeList2 *&list, FreeList2 *node) {
 
 } // namespace LIBC_NAMESPACE_DECL
 
-#endif // LLVM_LIBC_SRC___SUPPORT_FREELIST2_H
+#endif // LLVM_LIBC_SRC___SUPPORT_FREELIST_H

libc/src/__support/freestore.h

@@ -26,18 +26,18 @@ class FreeStore {
   Block<> *remove_best_fit(size_t size);
 
 private:
-  static constexpr size_t MIN_SIZE = sizeof(FreeList2);
+  static constexpr size_t MIN_SIZE = sizeof(FreeList);
   static constexpr size_t MIN_LARGE_SIZE = sizeof(FreeTrie);
   static constexpr size_t NUM_SMALL_SIZES =
       (align_up(MIN_LARGE_SIZE) - align_up(MIN_SIZE)) / alignof(max_align_t);
 
   static bool is_small(Block<> *block);
   static bool is_small(size_t size);
 
-  FreeList2 *&small_list(Block<> *block);
-  FreeList2 **best_small_fit(size_t size);
+  FreeList *&small_list(Block<> *block);
+  FreeList **best_small_fit(size_t size);
 
-  cpp::array<FreeList2 *, NUM_SMALL_SIZES> small_lists = {nullptr};
+  cpp::array<FreeList *, NUM_SMALL_SIZES> small_lists = {nullptr};
   FreeTrie *large_trie = nullptr;
   FreeTrie::SizeRange range = {0, 0};
 };
@@ -51,7 +51,7 @@ inline void FreeStore::insert(Block<> *block) {
   if (block->inner_size_free() < MIN_SIZE)
     return;
   if (is_small(block))
-    FreeList2::push(small_list(block), block);
+    FreeList::push(small_list(block), block);
   else
     FreeTrie::push(FreeTrie::find(large_trie, block->inner_size(), range),
                    block);
@@ -61,13 +61,13 @@ inline void FreeStore::remove(Block<> *block) {
   LIBC_ASSERT(block->inner_size_free() >= MIN_SIZE &&
               "block too small to have been present");
   if (is_small(block)) {
-    FreeList2 *block_list =
-        reinterpret_cast<FreeList2 *>(block->usable_space());
-    FreeList2 *&list = small_list(block);
+    FreeList *block_list =
+        reinterpret_cast<FreeList *>(block->usable_space());
+    FreeList *&list = small_list(block);
     if (block_list == list)
-      FreeList2::pop(list);
+      FreeList::pop(list);
     else
-      FreeList2::pop(block_list);
+      FreeList::pop(block_list);
   } else {
     auto *trie = reinterpret_cast<FreeTrie *>(block->usable_space());
     if (trie == large_trie) {
@@ -80,11 +80,11 @@ inline void FreeStore::remove(Block<> *block) {
 
 inline Block<> *FreeStore::remove_best_fit(size_t size) {
   if (is_small(size)) {
-    FreeList2 **list = best_small_fit(size);
+    FreeList **list = best_small_fit(size);
     if (!list)
       return nullptr;
     Block<> *block = (*list)->block();
-    FreeList2::pop(*list);
+    FreeList::pop(*list);
     return block;
   }
 
@@ -106,14 +106,14 @@ inline bool FreeStore::is_small(size_t size) {
   return size - sizeof(Block<>::offset_type) < MIN_LARGE_SIZE;
 }
 
-inline FreeList2 *&FreeStore::small_list(Block<> *block) {
+inline FreeList *&FreeStore::small_list(Block<> *block) {
   LIBC_ASSERT(is_small(block) && "only legal for small blocks");
   return small_lists[(block->inner_size_free() - MIN_SIZE) /
                      alignof(max_align_t)];
 }
 
-inline FreeList2 **FreeStore::best_small_fit(size_t size) {
-  for (FreeList2 *&list : small_lists)
+inline FreeList **FreeStore::best_small_fit(size_t size) {
+  for (FreeList *&list : small_lists)
     if (list && list->size() >= size)
       return &list;
   return nullptr;

libc/src/__support/freetrie.h

@@ -10,14 +10,14 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_FREETRIE_H
 #define LLVM_LIBC_SRC___SUPPORT_FREETRIE_H
 
-#include "freelist2.h"
+#include "freelist.h"
 
 namespace LIBC_NAMESPACE_DECL {
 
 /// A trie node containing a free list. The subtrie contains a contiguous
 /// SizeRange of freelists.There is no relationship between the size of this
 /// free list and the size ranges of the subtries.
-class FreeTrie : public FreeList2 {
+class FreeTrie : public FreeList {
 public:
   // Power-of-two range of sizes covered by a subtrie.
   struct SizeRange {
@@ -112,14 +112,14 @@ LIBC_INLINE void FreeTrie::push(InsertPos pos, Block<> *block) {
     node->lower = node->upper = nullptr;
     node->parent = pos.parent;
   }
-  FreeList2 *list = *pos.trie;
-  FreeList2::push(list, node);
+  FreeList *list = *pos.trie;
+  FreeList::push(list, node);
   *pos.trie = static_cast<FreeTrie *>(list);
 }
 
 LIBC_INLINE void FreeTrie::pop(FreeTrie *&trie) {
-  FreeList2 *list = trie;
-  FreeList2::pop(list);
+  FreeList *list = trie;
+  FreeList::pop(list);
   FreeTrie *new_trie = static_cast<FreeTrie *>(list);
   if (new_trie) {
     // The freelist is non-empty, so copy the trie links to the new head.

libc/test/src/__support/CMakeLists.txt

@@ -20,7 +20,7 @@ if(NOT LIBC_TARGET_ARCHITECTURE_IS_NVPTX)
     SUITE
       libc-support-tests
     SRCS
-      freelist2_test.cpp
+      freelist_test.cpp
       #freetrie_test.cpp
     DEPENDS
       libc.src.__support.CPP.array

libc/test/src/__support/freelist2_test.cpp renamed to libc/test/src/__support/freelist_test.cpp

@@ -8,12 +8,12 @@
 
 #include <stddef.h>
 
-#include "src/__support/freelist2.h"
+#include "src/__support/freelist.h"
 #include "test/UnitTest/Test.h"
 
 namespace LIBC_NAMESPACE_DECL {
 
-TEST(LlvmLibcFreeList2, PushPop) {
+TEST(LlvmLibcFreeList, PushPop) {
   cpp::byte mem1[1024];
   optional<Block<> *> maybeBlock = Block<>::init(mem1);
   ASSERT_TRUE(maybeBlock.has_value());
@@ -24,20 +24,20 @@ TEST(LlvmLibcFreeList2, PushPop) {
   ASSERT_TRUE(maybeBlock.has_value());
   Block<> *block2 = *maybeBlock;
 
-  FreeList2 *list = nullptr;
-  FreeList2::push(list, block1);
-  ASSERT_NE(list, static_cast<FreeList2*>(nullptr));
+  FreeList *list = nullptr;
+  FreeList::push(list, block1);
+  ASSERT_NE(list, static_cast<FreeList *>(nullptr));
   EXPECT_EQ(list->block(), block1);
 
-  FreeList2::push(list, block2);
+  FreeList::push(list, block2);
   EXPECT_EQ(list->block(), block1);
 
-  FreeList2::pop(list);
-  ASSERT_NE(list, static_cast<FreeList2*>(nullptr));
+  FreeList::pop(list);
+  ASSERT_NE(list, static_cast<FreeList *>(nullptr));
   EXPECT_EQ(list->block(), block2);
 
-  FreeList2::pop(list);
-  ASSERT_EQ(list, static_cast<FreeList2*>(nullptr));
+  FreeList::pop(list);
+  ASSERT_EQ(list, static_cast<FreeList *>(nullptr));
 }
 
 } // namespace LIBC_NAMESPACE_DECL