diff options
author | Myles Borins <mylesborins@google.com> | 2019-09-24 11:56:38 -0400 |
---|---|---|
committer | Myles Borins <myles.borins@gmail.com> | 2019-10-07 03:19:23 -0400 |
commit | f7f6c928c1c9c136b7926f892b8a2fda11d8b4b2 (patch) | |
tree | f5edbccb3ffda2573d70a6e291e7157f290e0ae0 /deps/v8/test/unittests/heap/spaces-unittest.cc | |
parent | ffd22e81983056d09c064c59343a0e488236272d (diff) | |
download | android-node-v8-f7f6c928c1c9c136b7926f892b8a2fda11d8b4b2.tar.gz android-node-v8-f7f6c928c1c9c136b7926f892b8a2fda11d8b4b2.tar.bz2 android-node-v8-f7f6c928c1c9c136b7926f892b8a2fda11d8b4b2.zip |
deps: update V8 to 7.8.279.9
PR-URL: https://github.com/nodejs/node/pull/29694
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: Jiawen Geng <technicalcute@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Ujjwal Sharma <usharma1998@gmail.com>
Diffstat (limited to 'deps/v8/test/unittests/heap/spaces-unittest.cc')
-rw-r--r-- | deps/v8/test/unittests/heap/spaces-unittest.cc | 141 |
1 files changed, 141 insertions, 0 deletions
diff --git a/deps/v8/test/unittests/heap/spaces-unittest.cc b/deps/v8/test/unittests/heap/spaces-unittest.cc index 140d3d45b3..c5acc6c43e 100644 --- a/deps/v8/test/unittests/heap/spaces-unittest.cc +++ b/deps/v8/test/unittests/heap/spaces-unittest.cc @@ -143,5 +143,146 @@ TEST_F(SpacesTest, CodeRangeAddressReuse) { EXPECT_EQ(code_range6, code_range3); } +// Tests that FreeListMany::SelectFreeListCategoryType returns what it should. +TEST_F(SpacesTest, FreeListManySelectFreeListCategoryType) { + FreeListMany free_list; + + // Testing that all sizes below 256 bytes get assigned the correct category + for (size_t size = 0; size <= FreeListMany::kPreciseCategoryMaxSize; size++) { + FreeListCategoryType cat = free_list.SelectFreeListCategoryType(size); + if (cat == 0) { + // If cat == 0, then we make sure that |size| doesn't fit in the 2nd + // category. + EXPECT_LT(size, free_list.categories_min[1]); + } else { + // Otherwise, size should fit in |cat|, but not in |cat+1|. + EXPECT_LE(free_list.categories_min[cat], size); + EXPECT_LT(size, free_list.categories_min[cat + 1]); + } + } + + // Testing every size above 256 would take long time, so test only some + // "interesting cases": picking some number in the middle of the categories, + // as well as at the categories' bounds. + for (int cat = kFirstCategory + 1; cat <= free_list.last_category_; cat++) { + std::vector<size_t> sizes; + // Adding size less than this category's minimum + sizes.push_back(free_list.categories_min[cat] - 8); + // Adding size equal to this category's minimum + sizes.push_back(free_list.categories_min[cat]); + // Adding size greater than this category's minimum + sizes.push_back(free_list.categories_min[cat] + 8); + // Adding size between this category's minimum and the next category + if (cat != free_list.last_category_) { + sizes.push_back( + (free_list.categories_min[cat] + free_list.categories_min[cat + 1]) / + 2); + } + + for (size_t size : sizes) { + FreeListCategoryType cat = free_list.SelectFreeListCategoryType(size); + if (cat == free_list.last_category_) { + // If cat == last_category, then we make sure that |size| indeeds fits + // in the last category. + EXPECT_LE(free_list.categories_min[cat], size); + } else { + // Otherwise, size should fit in |cat|, but not in |cat+1|. + EXPECT_LE(free_list.categories_min[cat], size); + EXPECT_LT(size, free_list.categories_min[cat + 1]); + } + } + } +} + +// Tests that FreeListMany::GuaranteedAllocatable returns what it should. +TEST_F(SpacesTest, FreeListManyGuaranteedAllocatable) { + FreeListMany free_list; + + for (int cat = kFirstCategory; cat < free_list.last_category_; cat++) { + std::vector<size_t> sizes; + // Adding size less than this category's minimum + sizes.push_back(free_list.categories_min[cat] - 8); + // Adding size equal to this category's minimum + sizes.push_back(free_list.categories_min[cat]); + // Adding size greater than this category's minimum + sizes.push_back(free_list.categories_min[cat] + 8); + if (cat != free_list.last_category_) { + // Adding size between this category's minimum and the next category + sizes.push_back( + (free_list.categories_min[cat] + free_list.categories_min[cat + 1]) / + 2); + } + + for (size_t size : sizes) { + FreeListCategoryType cat_free = + free_list.SelectFreeListCategoryType(size); + size_t guaranteed_allocatable = free_list.GuaranteedAllocatable(size); + if (cat_free == free_list.last_category_) { + // If |cat_free| == last_category, then guaranteed_allocatable must + // return the last category, because when allocating, the last category + // is searched entirely. + EXPECT_EQ(free_list.SelectFreeListCategoryType(guaranteed_allocatable), + free_list.last_category_); + } else if (size < free_list.categories_min[0]) { + // If size < free_list.categories_min[0], then the bytes are wasted, and + // guaranteed_allocatable should return 0. + EXPECT_EQ(guaranteed_allocatable, 0ul); + } else { + // Otherwise, |guaranteed_allocatable| is equal to the minimum of + // |size|'s category (|cat_free|); + EXPECT_EQ(free_list.categories_min[cat_free], guaranteed_allocatable); + } + } + } +} + +// Tests that +// FreeListManyCachedFastPath::SelectFastAllocationFreeListCategoryType returns +// what it should. +TEST_F(SpacesTest, + FreeListManyCachedFastPathSelectFastAllocationFreeListCategoryType) { + FreeListManyCachedFastPath free_list; + + for (int cat = kFirstCategory; cat <= free_list.last_category_; cat++) { + std::vector<size_t> sizes; + // Adding size less than this category's minimum + sizes.push_back(free_list.categories_min[cat] - 8); + // Adding size equal to this category's minimum + sizes.push_back(free_list.categories_min[cat]); + // Adding size greater than this category's minimum + sizes.push_back(free_list.categories_min[cat] + 8); + // Adding size between this category's minimum and the next category + if (cat != free_list.last_category_) { + sizes.push_back( + (free_list.categories_min[cat] + free_list.categories_min[cat + 1]) / + 2); + } + + for (size_t size : sizes) { + FreeListCategoryType cat = + free_list.SelectFastAllocationFreeListCategoryType(size); + if (size <= FreeListManyCachedFastPath::kTinyObjectMaxSize) { + // For tiny objects, the first category of the fast path should be + // chosen. + EXPECT_TRUE(cat == FreeListManyCachedFastPath::kFastPathFirstCategory); + } else if (size >= free_list.categories_min[free_list.last_category_] - + FreeListManyCachedFastPath::kFastPathOffset) { + // For objects close to the minimum of the last category, the last + // category is chosen. + EXPECT_EQ(cat, free_list.last_category_); + } else { + // For other objects, the chosen category must satisfy that its minimum + // is at least |size|+1.85k. + EXPECT_GE(free_list.categories_min[cat], + size + FreeListManyCachedFastPath::kFastPathOffset); + // And the smaller categoriy's minimum is less than |size|+1.85k + // (otherwise it would have been chosen instead). + EXPECT_LT(free_list.categories_min[cat - 1], + size + FreeListManyCachedFastPath::kFastPathOffset); + } + } + } +} + } // namespace internal } // namespace v8 |