From fcbe4fa27707d3b8a31add65e41b6263b3dc8b48 Mon Sep 17 00:00:00 2001 From: Joel Maher Date: Fri, 2 Jun 2017 13:27:20 -0400 Subject: [PATCH] Bug 1323238 - disable MOZ_GTEST_BENCH tests as we are not looking at the data. r=wlach MozReview-Commit-ID: xYRHpWVaa7 --- gfx/tests/gtest/TestCompositor.cpp | 78 +- gfx/tests/gtest/TestRegion.cpp | 67 -- gfx/tests/gtest/TestTextureCompatibility.cpp | 1 - gfx/tests/gtest/TestTreeTraversal.cpp | 763 ------------------- 4 files changed, 35 insertions(+), 874 deletions(-) diff --git a/gfx/tests/gtest/TestCompositor.cpp b/gfx/tests/gtest/TestCompositor.cpp index 0a8498bb6988..e85803714a76 100644 --- a/gfx/tests/gtest/TestCompositor.cpp +++ b/gfx/tests/gtest/TestCompositor.cpp @@ -6,7 +6,6 @@ #include "gfxPrefs.h" #include "gfxUtils.h" #include "gtest/gtest.h" -#include "gtest/MozGTestBench.h" #include "TestLayers.h" #include "mozilla/gfx/2D.h" #include "mozilla/RefPtr.h" @@ -167,51 +166,44 @@ TEST(Gfx, CompositorConstruct) auto layerManagers = GetLayerManagers(GetPlatformBackends()); } -static void CompositorSimpleTree() { - const int benchmarkRepeatCount = 30; - - RefPtr refDT = CreateDT(); - refDT->FillRect(Rect(0, 0, gCompWidth, gCompHeight), ColorPattern(Color(1.f, 0.f, 1.f, 1.f))); - refDT->FillRect(Rect(0, 0, 100, 100), ColorPattern(Color(1.f, 0.f, 0.f, 1.f))); - refDT->FillRect(Rect(0, 50, 100, 100), ColorPattern(Color(0.f, 0.f, 1.f, 1.f))); - +TEST(Gfx, CompositorSimpleTree) +{ auto layerManagers = GetLayerManagers(GetPlatformBackends()); for (size_t i = 0; i < layerManagers.size(); i++) { - // Benchmark n composites - for (size_t n = 0; n < benchmarkRepeatCount; n++) { - RefPtr layerManager = layerManagers[i].mLayerManager; - RefPtr lmBase = layerManager.get(); - nsTArray> layers; - nsIntRegion layerVisibleRegion[] = { - nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)), - nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)), - nsIntRegion(IntRect(0, 0, 100, 100)), - nsIntRegion(IntRect(0, 50, 100, 100)), - }; - RefPtr root = CreateLayerTree("c(ooo)", layerVisibleRegion, nullptr, lmBase, layers); + RefPtr layerManager = layerManagers[i].mLayerManager; + RefPtr lmBase = layerManager.get(); + nsTArray> layers; + nsIntRegion layerVisibleRegion[] = { + nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)), + nsIntRegion(IntRect(0, 0, gCompWidth, gCompHeight)), + nsIntRegion(IntRect(0, 0, 100, 100)), + nsIntRegion(IntRect(0, 50, 100, 100)), + }; + RefPtr root = CreateLayerTree("c(ooo)", layerVisibleRegion, nullptr, lmBase, layers); - { // background - ColorLayer* colorLayer = layers[1]->AsColorLayer(); - colorLayer->SetColor(Color(1.f, 0.f, 1.f, 1.f)); - colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); - } - - { - ColorLayer* colorLayer = layers[2]->AsColorLayer(); - colorLayer->SetColor(Color(1.f, 0.f, 0.f, 1.f)); - colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); - } - - { - ColorLayer* colorLayer = layers[3]->AsColorLayer(); - colorLayer->SetColor(Color(0.f, 0.f, 1.f, 1.f)); - colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); - } - - EXPECT_TRUE(CompositeAndCompare(layerManager, refDT)); + { // background + ColorLayer* colorLayer = layers[1]->AsColorLayer(); + colorLayer->SetColor(Color(1.f, 0.f, 1.f, 1.f)); + colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); } + + { + ColorLayer* colorLayer = layers[2]->AsColorLayer(); + colorLayer->SetColor(Color(1.f, 0.f, 0.f, 1.f)); + colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); + } + + { + ColorLayer* colorLayer = layers[3]->AsColorLayer(); + colorLayer->SetColor(Color(0.f, 0.f, 1.f, 1.f)); + colorLayer->SetBounds(colorLayer->GetVisibleRegion().ToUnknownRegion().GetBounds()); + } + + RefPtr refDT = CreateDT(); + refDT->FillRect(Rect(0, 0, gCompWidth, gCompHeight), ColorPattern(Color(1.f, 0.f, 1.f, 1.f))); + refDT->FillRect(Rect(0, 0, 100, 100), ColorPattern(Color(1.f, 0.f, 0.f, 1.f))); + refDT->FillRect(Rect(0, 50, 100, 100), ColorPattern(Color(0.f, 0.f, 1.f, 1.f))); + EXPECT_TRUE(CompositeAndCompare(layerManager, refDT)); } -}; - -MOZ_GTEST_BENCH(GfxBench, CompositorSimpleTree, &CompositorSimpleTree); +} diff --git a/gfx/tests/gtest/TestRegion.cpp b/gfx/tests/gtest/TestRegion.cpp index ea8e323f91c3..cabbfd68d2f6 100644 --- a/gfx/tests/gtest/TestRegion.cpp +++ b/gfx/tests/gtest/TestRegion.cpp @@ -7,8 +7,6 @@ #include "PingPongRegion.h" #include "gtest/gtest.h" -#include "gtest/MozGTestBench.h" -#include "nsRect.h" #include "nsRegion.h" #include "RegionBuilder.h" #include "mozilla/gfx/TiledRegion.h" @@ -770,68 +768,3 @@ TEST(Gfx, TiledRegionNegativeRect) { EXPECT_TRUE(tiledRegion.Contains(nsIntRect(0, 0, -1, -1))); EXPECT_TRUE(tiledRegion.Contains(nsIntRect(100, 100, -1, -1))); } - -MOZ_GTEST_BENCH(GfxBench, RegionOr, []{ - const int size = 5000; - - nsRegion r; - for (int i = 0; i < size; i++) { - r = r.Or(r, nsRect(i, i, i + 10, i + 10)); - } - - nsIntRegion rInt; - for (int i = 0; i < size; i++) { - rInt = rInt.Or(rInt, nsIntRect(i, i, i + 10, i + 10)); - } -}); - -MOZ_GTEST_BENCH(GfxBench, RegionAnd, []{ - const int size = 5000; - nsRegion r(nsRect(0, 0, size, size)); - for (int i = 0; i < size; i++) { - nsRegion rMissingPixel(nsRect(0, 0, size, size)); - rMissingPixel = rMissingPixel.Sub(rMissingPixel, nsRect(i, i, 1, 1)); - r = r.And(r, rMissingPixel); - } -}); - -void BenchRegionBuilderOr() { - const int size = 5000; - - RegionBuilder r; - for (int i = 0; i < size; i++) { - r.OrWith(nsRect(i, i, i + 10, i + 10)); - } - r.ToRegion(); - - RegionBuilder rInt; - for (int i = 0; i < size; i++) { - rInt.OrWith(nsIntRect(i, i, i + 10, i + 10)); - } - rInt.ToRegion(); -} - -MOZ_GTEST_BENCH(GfxBench, RegionBuilderOr, []{ - BenchRegionBuilderOr(); -}); - -void BenchPingPongRegionOr() { - const int size = 5000; - - PingPongRegion r; - for (int i = 0; i < size; i++) { - r.OrWith(nsRect(i, i, i + 10, i + 10)); - } - r.Region(); - - PingPongRegion rInt; - for (int i = 0; i < size; i++) { - rInt.OrWith(nsIntRect(i, i, i + 10, i + 10)); - } - rInt.Region(); -} - -MOZ_GTEST_BENCH(GfxBench, PingPongRegionOr, []{ - BenchPingPongRegionOr(); -}); - diff --git a/gfx/tests/gtest/TestTextureCompatibility.cpp b/gfx/tests/gtest/TestTextureCompatibility.cpp index 297f83344744..d2fd37b0d162 100644 --- a/gfx/tests/gtest/TestTextureCompatibility.cpp +++ b/gfx/tests/gtest/TestTextureCompatibility.cpp @@ -7,7 +7,6 @@ #include "gfxConfig.h" #include "gfxPlatform.h" #include "gtest/gtest.h" -#include "gtest/MozGTestBench.h" #include "MockWidget.h" #include "mozilla/layers/BasicCompositor.h" #include "mozilla/layers/Compositor.h" diff --git a/gfx/tests/gtest/TestTreeTraversal.cpp b/gfx/tests/gtest/TestTreeTraversal.cpp index 043e28fd5671..fe5b6c555a2d 100644 --- a/gfx/tests/gtest/TestTreeTraversal.cpp +++ b/gfx/tests/gtest/TestTreeTraversal.cpp @@ -1,7 +1,6 @@ #include #include "mozilla/RefPtr.h" #include "gtest/gtest.h" -#include "gtest/MozGTestBench.h" #include "nsRegion.h" #include "nsRect.h" #include "TreeTraversal.h" @@ -270,27 +269,6 @@ typedef TestNodeReverse ForEachTestNodeReverse; typedef TestNodeForward SearchTestNodeForward; typedef TestNodeForward ForEachTestNodeForward; -template -void CreateBenchmarkTreeRecursive(RefPtr aNode, int aDepth, int aChildrenCount, Action aAction) -{ - if (aDepth > 0) { - for (int i = 0; i < aChildrenCount; i++) { - RefPtr newNode = new Node(); - aNode->AddChild(newNode); - CreateBenchmarkTreeRecursive(newNode, aDepth-1, aChildrenCount, aAction); - } - } - aAction(aNode); -} - -template -RefPtr CreateBenchmarkTree(int aDepth, int aChildrenCount, Action aAction) -{ - RefPtr rootNode = new Node(); - CreateBenchmarkTreeRecursive(rootNode, aDepth, aChildrenCount, aAction); - return rootNode; -} - TEST(TreeTraversal, DepthFirstSearchNull) { RefPtr nullNode; @@ -1343,37 +1321,6 @@ static RefPtr DepthFirstSearchForwardRecursive(RefPtr aNode) return nullptr; } -static void Plain_ForwardDepthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = - DepthFirstSearchForwardRecursive(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchPerformance, &Plain_ForwardDepthFirstSearchPerformance); - -static void TreeTraversal_ForwardDepthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = DepthFirstSearch(root.get(), &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchPerformance, &TreeTraversal_ForwardDepthFirstSearchPerformance); - template static RefPtr DepthFirstSearchCaptureVariablesForwardRecursive(RefPtr aNode, int a, int b, int c, int d, int e, int f, @@ -1398,61 +1345,6 @@ static RefPtr DepthFirstSearchCaptureVariablesForwardRecursive(RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeValuesAllFalseValuesForward{hayTotal, needleNode}); - needleNode->SetValue(needleTotal); - RefPtr foundNode = - DepthFirstSearchCaptureVariablesForwardRecursive(root.get(), - a, b, c, d, e, f, g, h, i, j, k, l, m, - n, o, p, q, r, s, t, u, v, w, x, y, z); - ASSERT_EQ(foundNode->GetValue(), needleTotal); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchCaptureVariablesPerformance, &Plain_ForwardDepthFirstSearchCaptureVariablesPerformance); - -static void TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1; - int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1; - int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1; - int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1; - int y = 1; int z = 1; - int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m + - n + o + p + q + r + s + t + u + v + w + x + y + z; - int hayTotal = 0; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeValuesAllFalseValuesForward{hayTotal, needleNode}); - needleNode->SetValue(needleTotal); - RefPtr foundNode = DepthFirstSearch(root.get(), - [a, b, c, d, e, f, g, h, i, j, k, l, m, - &n, &o, &p, &q, &r, &s, &t, &u, &v, &w, &x, &y, &z] - (SearchTestNodeForward* aNode) { - return aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l + m + - n + o + p + q + r + s + t + u + v + w + x + y + z; - }); - ASSERT_EQ(foundNode->GetValue(), needleTotal); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance, &TreeTraversal_ForwardDepthFirstSearchCaptureVariablesPerformance); - template static RefPtr DepthFirstSearchPostOrderForwardRecursive(RefPtr aNode) { @@ -1469,35 +1361,6 @@ static RefPtr DepthFirstSearchPostOrderForwardRecursive(RefPtr aNode return nullptr; } -static void Plain_ForwardDepthFirstSearchPostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesAllHay{}); - root->SetType(SearchNodeType::Needle); - RefPtr foundNode = - DepthFirstSearchPostOrderForwardRecursive(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(root, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardDepthFirstSearchPostOrderPerformance, &Plain_ForwardDepthFirstSearchPostOrderPerformance); - -static void TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesAllHay{}); - root->SetType(SearchNodeType::Needle); - RefPtr foundNode = DepthFirstSearchPostOrder(root.get(), &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(root, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance, &TreeTraversal_ForwardDepthFirstSearchPostOrderPerformance); - template static RefPtr BreadthFirstSearchForwardQueue(RefPtr aNode) { @@ -1518,264 +1381,6 @@ static RefPtr BreadthFirstSearchForwardQueue(RefPtr aNode) return nullptr; } -static void Plain_ForwardBreadthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = - BreadthFirstSearchForwardQueue(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardBreadthFirstSearchPerformance, &Plain_ForwardBreadthFirstSearchPerformance); - -static void TreeTraversal_ForwardBreadthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithLastLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = BreadthFirstSearch(root.get(), &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardBreadthFirstSearchPerformance, &TreeTraversal_ForwardBreadthFirstSearchPerformance); - -// This test ((Plain|TreeTraversal)_ForwardForEachNodePostOrderPerformance) -// uses the following benchmark: -// -// Starting with a tree whose leaves only are augmented with region data -// (arranged as a series of 1x1 blocks stacked in rows of 100000), calculate -// each ancestor's region as the union of its child regions. -template -static void ForEachNodePostOrderForwardRecursive(RefPtr aNode) -{ - if (!aNode->IsLeaf()) { - nsRegion newRegion; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - ForEachNodePostOrderForwardRecursive(node); - nsRegion childRegion = node->GetRegion(); - newRegion.OrWith(childRegion); - } - aNode->SetRegion(newRegion); - } -} - -static void Plain_ForwardForEachNodePostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int squareCount = 0; - int xWrap = PERFORMANCE_REGION_XWRAP; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AllocateUnitRegionsToLeavesOnly{xWrap, squareCount}); - ForEachNodePostOrderForwardRecursive(root); - ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP))); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodePostOrderPerformance, &Plain_ForwardForEachNodePostOrderPerformance); - -static void TreeTraversal_ForwardForEachNodePostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int squareCount = 0; - int xWrap = PERFORMANCE_REGION_XWRAP; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AllocateUnitRegionsToLeavesOnly{xWrap, squareCount}); - ForEachNodePostOrder(root.get(), - [](ForEachTestNodeForward* aNode) { - if (!aNode->IsLeaf()) { - nsRegion newRegion; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - nsRegion childRegion = node->GetRegion(); - newRegion.OrWith(childRegion); - } - aNode->SetRegion(newRegion); - } - }); - ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP))); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodePostOrderPerformance, &TreeTraversal_ForwardForEachNodePostOrderPerformance); - -// This test ((Plain|TreeTraversal)_ForwardForEachNodePerformance) uses the -// following benchmark: -// -// Starting with a tree whose root has a rectangular region of size -// PERFORMANCE_TREE_LEAF_COUNT x 1, for each node, split the region into -// PERFORMANCE_TREE_CHILD_COUNT separate regions of equal width and assign to -// each child left-to-right. In the end, every node's region should equal the -// sum of its childrens' regions, and each level of depth's regions should sum -// to the root's region. -template -static void ForEachNodeForwardRecursive(RefPtr aNode) -{ - if (!aNode->IsLeaf()) { - int nChildren = 0; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - nChildren++; - } - nsRect bounds = aNode->GetRegion().GetBounds(); - int childWidth = bounds.width / nChildren; - int x = bounds.x; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1))); - ForEachNodeForwardRecursive(node); - x += childWidth; - } - } -} - -static void Plain_ForwardForEachNodePerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNodeForwardRecursive(root); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodePerformance, &Plain_ForwardForEachNodePerformance); - -static void TreeTraversal_ForwardForEachNodePerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNode(root.get(), - [](ForEachTestNodeForward* aNode) { - if (!aNode->IsLeaf()) { - int nChildren = 0; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - nChildren++; - } - nsRect bounds = aNode->GetRegion().GetBounds(); - int childWidth = bounds.width / nChildren; - int x = bounds.x; - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1))); - x += childWidth; - } - } - }); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodePerformance, &TreeTraversal_ForwardForEachNodePerformance); - -// This test ((Plain|TreeTraversal)_ForwardForEachNodeStackPerformance) uses -// the following benchmark: -// -// Starting with an unattached region equal to PERFORMANCE_TREE_LEAF_COUNT x 1, -// a starting width of PERFORMANCE_TREE_LEAF_COUNT, and an empty tree, create a -// tree with the same conditions as -// ((Plain|TreeTraversal)_ForwardForEachNodePerformance) by assigning regions -// of the current width, starting from the min x and min y coordinates. For -// each level of depth, decrease the current width by a factor of -// PERFORMANCE_TREE_CHILD_COUNT, and maintain a stack of ancestor regions. -// Use the stack to track the portion of each region still available to assign -// to children, which determines the aforementioned min x and min y coordinates. -// Compare this to using the program stack. -template -static void ForEachNodeForwardStackRecursive(RefPtr aNode, int& aRectangleWidth, nsRegion aRegion, int aChildrenCount) -{ - nsRect parentRect = aRegion.GetBounds(); - nsRect newRectangle(parentRect.x, parentRect.y, aRectangleWidth, 1); - nsRegion newRegion(newRectangle); - aNode->SetRegion(nsRegion(newRegion)); - - aRectangleWidth /= aChildrenCount; - - for (RefPtr node = aNode->GetFirstChild(); - node != nullptr; - node = node->GetNextSibling()) { - ForEachNodeForwardStackRecursive(node, aRectangleWidth, newRegion, aChildrenCount); - newRegion.SubOut(node->GetRegion()); - } - - // Handle case where rectangle width is truncated if power falls below 0, - // so we dont lose the regions in future iterations - if (aRectangleWidth == 0) { - aRectangleWidth = 1; - } - else { - aRectangleWidth *= aChildrenCount; - } -} - -static void Plain_ForwardForEachNodeStackPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - nsRegion startRegion(nsRect(0, 0, rectangleWidth, 1)); - ForEachNodeForwardStackRecursive(root, rectangleWidth, startRegion, childrenCount); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ForwardForEachNodeStackPerformance, &Plain_ForwardForEachNodeStackPerformance); - -static void TreeTraversal_ForwardForEachNodeStackPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - stack regionStack; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - regionStack.push(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNode(root.get(), - [®ionStack, &rectangleWidth, childrenCount](ForEachTestNodeForward* aNode) { - nsRegion parentRegion = regionStack.top(); - nsRect parentRect = parentRegion.GetBounds(); - nsRect newRect(parentRect.x, parentRect.y, rectangleWidth, 1); - nsRegion newRegion(newRect); - aNode->SetRegion(newRegion); - regionStack.top().SubOut(newRegion); - regionStack.push(newRegion); - rectangleWidth /= childrenCount; - }, - [®ionStack, &rectangleWidth, childrenCount](ForEachTestNodeForward* aNode) { - regionStack.pop(); - // Handle case where rectangle width is truncated if power falls below 0, - // so we dont lose the regions in future iterations - if (rectangleWidth == 0) { - rectangleWidth = 1; - } - else { - rectangleWidth *= childrenCount; - } - }); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ForwardForEachNodeStackPerformance, &TreeTraversal_ForwardForEachNodeStackPerformance); - template static RefPtr DepthFirstSearchReverseRecursive(RefPtr aNode) { @@ -1792,37 +1397,6 @@ static RefPtr DepthFirstSearchReverseRecursive(RefPtr aNode) return nullptr; } -static void Plain_ReverseDepthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = - DepthFirstSearchReverseRecursive(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchPerformance, &Plain_ReverseDepthFirstSearchPerformance); - -static void TreeTraversal_ReverseDepthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = DepthFirstSearch(root.get(), - &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchPerformance, &TreeTraversal_ReverseDepthFirstSearchPerformance); template static RefPtr DepthFirstSearchCaptureVariablesReverseRecursive(RefPtr aNode, @@ -1848,59 +1422,6 @@ static RefPtr DepthFirstSearchCaptureVariablesReverseRecursive(RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeValuesAllFalseValuesReverse{hayTotal, needleNode}); - needleNode->SetValue(needleTotal); - RefPtr foundNode = - DepthFirstSearchCaptureVariablesReverseRecursive(root.get(), - a, b, c, d, e, f, g, h, i, j, k, l, m, - n, o, p, q, r, s, t, u, v, w, x, y, z); - ASSERT_EQ(foundNode->GetValue(), needleTotal); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchCaptureVariablesPerformance, &Plain_ReverseDepthFirstSearchCaptureVariablesPerformance); - -static void TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int a = 1; int b = 1; int c = 1; int d = 1; int e = 1; int f = 1; - int g = 1; int h = 1; int i = 1; int j = 1; int k = 1; int l = 1; - int m = 1; int n = 1; int o = 1; int p = 1; int q = 1; int r = 1; - int s = 1; int t = 1; int u = 1; int v = 1; int w = 1; int x = 1; - int y = 1; int z = 1; - int needleTotal = a + b + c + d + e + f + g + h + i + j + k + l + m + - n + o + p + q + r + s + t + u + v + w + x + y + z; - int hayTotal = 0; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeValuesAllFalseValuesReverse{hayTotal, needleNode}); - needleNode->SetValue(needleTotal); - RefPtr foundNode = DepthFirstSearch(root.get(), - [a, b, c, d, e, f, g, h, i, j, k, l, m, - &n, &o, &p, &q, &r, &s, &t, &u, &v, &w, &x, &y, &z] (SearchTestNodeReverse* aNode) { - return aNode->GetValue() == a + b + c + d + e + f + g + h + i + j + k + l + - m + n + o + p + q + r + s + t + u + v + w + x + y + z; - }); - ASSERT_EQ(foundNode->GetValue(), needleTotal); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance, &TreeTraversal_ReverseDepthFirstSearchCaptureVariablesPerformance); template static RefPtr DepthFirstSearchPostOrderReverseRecursive(RefPtr aNode) @@ -1918,34 +1439,6 @@ static RefPtr DepthFirstSearchPostOrderReverseRecursive(RefPtr aNode return nullptr; } -static void Plain_ReverseDepthFirstSearchPostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesAllHay{}); - root->SetType(SearchNodeType::Needle); - RefPtr foundNode = - DepthFirstSearchPostOrderReverseRecursive(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(root, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseDepthFirstSearchPostOrderPerformance, &Plain_ReverseDepthFirstSearchPostOrderPerformance); - -static void TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesAllHay{}); - root->SetType(SearchNodeType::Needle); - RefPtr foundNode = DepthFirstSearchPostOrder(root.get(), &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(root, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance, &TreeTraversal_ReverseDepthFirstSearchPostOrderPerformance); template static RefPtr BreadthFirstSearchReverseQueue(RefPtr aNode) @@ -1967,259 +1460,3 @@ static RefPtr BreadthFirstSearchReverseQueue(RefPtr aNode) return nullptr; } -static void Plain_ReverseBreadthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = - BreadthFirstSearchReverseQueue(root.get()); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseBreadthFirstSearchPerformance, &Plain_ReverseBreadthFirstSearchPerformance); - -static void TreeTraversal_ReverseBreadthFirstSearchPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - RefPtr needleNode; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AssignSearchNodeTypesWithFirstLeafAsNeedle{needleNode}); - needleNode->SetType(SearchNodeType::Needle); - RefPtr foundNode = BreadthFirstSearch(root.get(), &FindNeedle); - ASSERT_EQ(foundNode->GetType(), SearchNodeType::Needle); - ASSERT_EQ(needleNode, foundNode); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseBreadthFirstSearchPerformance, &TreeTraversal_ReverseBreadthFirstSearchPerformance); - -// This test ((Plain|TreeTraversal)_ReverseForEachNodePostOrderPerformance) -// uses the following benchmark: -// -// Starting with a tree whose leaves only are augmented with region data -// (arranged as a series of 1x1 blocks stacked in rows of 100000), calculate -// each ancestor's region as the union of its child regions. -template -static void ForEachNodePostOrderReverseRecursive(RefPtr aNode) -{ - if (!aNode->IsLeaf()) { - nsRegion newRegion; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - ForEachNodePostOrderReverseRecursive(node); - nsRegion childRegion = node->GetRegion(); - newRegion.OrWith(childRegion); - } - aNode->SetRegion(newRegion); - } -} - -static void Plain_ReverseForEachNodePostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int squareCount = 0; - int xWrap = PERFORMANCE_REGION_XWRAP; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AllocateUnitRegionsToLeavesOnly{xWrap, squareCount}); - ForEachNodePostOrderReverseRecursive(root); - ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP))); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodePostOrderPerformance, &Plain_ReverseForEachNodePostOrderPerformance); - -static void TreeTraversal_ReverseForEachNodePostOrderPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int squareCount = 0; - int xWrap = PERFORMANCE_REGION_XWRAP; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - AllocateUnitRegionsToLeavesOnly{xWrap, squareCount}); - ForEachNodePostOrder(root.get(), - [](ForEachTestNodeReverse* aNode) { - if (!aNode->IsLeaf()) { - nsRegion newRegion; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - nsRegion childRegion = node->GetRegion(); - newRegion.OrWith(childRegion); - } - aNode->SetRegion(newRegion); - } - }); - ASSERT_EQ(root->GetRegion(), nsRegion(nsRect(0, 0, PERFORMANCE_REGION_XWRAP, PERFORMANCE_REGION_XWRAP))); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodePostOrderPerformance, &TreeTraversal_ReverseForEachNodePostOrderPerformance); - -// This test ((Plain|TreeTraversal)_ReverseForEachNodePerformance) uses the -// following benchmark: -// -// Starting with a tree whose root has a rectangular region of size -// PERFORMANCE_TREE_LEAF_COUNT x 1, for each node, split the region into -// PERFORMANCE_TREE_CHILD_COUNT separate regions of equal width and assign to -// each child left-to-right. In the end, every node's region should equal the -// sum of its childrens' regions, and each level of depth's regions should sum -// to the root's region. -template -static void ForEachNodeReverseRecursive(RefPtr aNode) -{ - if (!aNode->IsLeaf()) { - int nChildren = 0; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - nChildren++; - } - nsRect bounds = aNode->GetRegion().GetBounds(); - int childWidth = bounds.width / nChildren; - int x = bounds.x; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1))); - ForEachNodeReverseRecursive(node); - x += childWidth; - } - } -} - -static void Plain_ReverseForEachNodePerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNodeReverseRecursive(root); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodePerformance, &Plain_ReverseForEachNodePerformance); - -static void TreeTraversal_ReverseForEachNodePerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - root->SetRegion(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNode(root.get(), - [](ForEachTestNodeReverse* aNode) { - if (!aNode->IsLeaf()) { - int nChildren = 0; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - nChildren++; - } - nsRect bounds = aNode->GetRegion().GetBounds(); - int childWidth = bounds.width / nChildren; - int x = bounds.x; - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - node->SetRegion(nsRegion(nsRect(x, 0, childWidth, 1))); - x += childWidth; - } - } - }); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodePerformance, &TreeTraversal_ReverseForEachNodePerformance); - -// This test ((Plain|TreeTraversal)_ReverseForEachNodeStackPerformance) uses -// the following benchmark: -// -// Starting with an unattached region equal to PERFORMANCE_TREE_LEAF_COUNT x 1, -// a starting width of PERFORMANCE_TREE_LEAF_COUNT, and an empty tree, create a -// tree with the same conditions as -// ((Plain|TreeTraversal)_ReverseForEachNodePerformance) by assigning regions -// of the current width, starting from the min x and min y coordinates. For -// each level of depth, decrease the current width by a factor of -// PERFORMANCE_TREE_CHILD_COUNT, and maintain a stack of ancestor regions. -// Use the stack to track the portion of each region still available to assign -// to children, which determines the aforementioned min x and min y coordinates. -// Compare this to using the program stack. -template -static void ForEachNodeReverseStackRecursive(RefPtr aNode, int& aRectangleWidth, nsRegion aRegion, int aChildrenCount) -{ - nsRect parentRect = aRegion.GetBounds(); - nsRect newRectangle(parentRect.x, parentRect.y, aRectangleWidth, 1); - nsRegion newRegion(newRectangle); - aNode->SetRegion(nsRegion(newRegion)); - - aRectangleWidth /= aChildrenCount; - - for (RefPtr node = aNode->GetLastChild(); - node != nullptr; - node = node->GetPrevSibling()) { - ForEachNodeReverseStackRecursive(node, aRectangleWidth, newRegion, aChildrenCount); - newRegion.SubOut(node->GetRegion()); - } - // Handle case where rectangle width is truncated if power falls below 0, - // so we dont lose the regions in future iterations - if (aRectangleWidth == 0) { - aRectangleWidth = 1; - } - else { - aRectangleWidth *= aChildrenCount; - } -} - -static void Plain_ReverseForEachNodeStackPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - nsRegion startRegion(nsRect(0, 0, rectangleWidth, 1)); - ForEachNodeReverseStackRecursive(root, rectangleWidth, startRegion, childrenCount); -} - -MOZ_GTEST_BENCH(TreeTraversal, Plain_ReverseForEachNodeStackPerformance, &Plain_ReverseForEachNodeStackPerformance); - -static void TreeTraversal_ReverseForEachNodeStackPerformance() -{ - int depth = PERFORMANCE_TREE_DEPTH; - int childrenCount = PERFORMANCE_TREE_CHILD_COUNT; - int rectangleWidth = PERFORMANCE_TREE_LEAF_COUNT; - stack regionStack; - RefPtr root = CreateBenchmarkTree(depth, childrenCount, - &ForEachNodeDoNothing); - regionStack.push(nsRegion(nsRect(0, 0, rectangleWidth, 1))); - ForEachNode(root.get(), - [®ionStack, &rectangleWidth, childrenCount](ForEachTestNodeReverse* aNode) { - nsRegion parentRegion = regionStack.top(); - nsRect parentRect = parentRegion.GetBounds(); - nsRect newRect(parentRect.x, parentRect.y, rectangleWidth, 1); - nsRegion newRegion(newRect); - aNode->SetRegion(newRegion); - regionStack.top().SubOut(newRegion); - regionStack.push(newRegion); - rectangleWidth /= childrenCount; - }, - [®ionStack, &rectangleWidth, childrenCount](ForEachTestNodeReverse* aNode) { - regionStack.pop(); - // Handle case where rectangle width is truncated if power falls below 0, - // so we dont lose the regions in future iterations - if (rectangleWidth == 0) { - rectangleWidth = 1; - } - else { - rectangleWidth *= childrenCount; - } - }); -} - -MOZ_GTEST_BENCH(TreeTraversal, TreeTraversal_ReverseForEachNodeStackPerformance, &TreeTraversal_ReverseForEachNodeStackPerformance);