LCOV - code coverage report
Current view: top level - test/unittests/compiler - node-cache-unittest.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 79 79 100.0 %
Date: 2019-04-19 Functions: 16 23 69.6 %

          Line data    Source code
       1             : // Copyright 2014 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #include "src/compiler/node-cache.h"
       6             : #include "test/unittests/compiler/graph-unittest.h"
       7             : #include "test/unittests/test-utils.h"
       8             : #include "testing/gmock-support.h"
       9             : 
      10             : using testing::Contains;
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : namespace compiler {
      15             : namespace node_cache_unittest {
      16             : 
      17             : typedef GraphTest NodeCacheTest;
      18             : 
      19       15418 : TEST_F(NodeCacheTest, Int32Constant_back_to_back) {
      20             :   Int32NodeCache cache;
      21             : 
      22        2415 :   for (int i = -2000000000; i < 2000000000; i += 3315177) {
      23        1207 :     Node** pos = cache.Find(zone(), i);
      24        2414 :     ASSERT_TRUE(pos != nullptr);
      25        8449 :     for (int j = 0; j < 3; j++) {
      26        3621 :       Node** npos = cache.Find(zone(), i);
      27        3621 :       EXPECT_EQ(pos, npos);
      28             :     }
      29             :   }
      30             : }
      31             : 
      32             : 
      33       15418 : TEST_F(NodeCacheTest, Int32Constant_five) {
      34             :   Int32NodeCache cache;
      35           1 :   int32_t constants[] = {static_cast<int32_t>(0x80000000), -77, 0, 1, -1};
      36             :   Node* nodes[arraysize(constants)];
      37             : 
      38          11 :   for (size_t i = 0; i < arraysize(constants); i++) {
      39           5 :     int32_t k = constants[i];
      40           5 :     Node* node = graph()->NewNode(common()->Int32Constant(k));
      41           5 :     *cache.Find(zone(), k) = nodes[i] = node;
      42             :   }
      43             : 
      44          11 :   for (size_t i = 0; i < arraysize(constants); i++) {
      45           5 :     int32_t k = constants[i];
      46          10 :     EXPECT_EQ(nodes[i], *cache.Find(zone(), k));
      47             :   }
      48           1 : }
      49             : 
      50             : 
      51       15418 : TEST_F(NodeCacheTest, Int32Constant_hits) {
      52             :   Int32NodeCache cache;
      53             :   const int32_t kSize = 1500;
      54             :   Node** nodes = zone()->NewArray<Node*>(kSize);
      55             : 
      56        3001 :   for (int i = 0; i < kSize; i++) {
      57        1500 :     int32_t v = i * -55;
      58        4500 :     nodes[i] = graph()->NewNode(common()->Int32Constant(v));
      59        1500 :     *cache.Find(zone(), v) = nodes[i];
      60             :   }
      61             : 
      62           1 :   int hits = 0;
      63        3001 :   for (int i = 0; i < kSize; i++) {
      64        1500 :     int32_t v = i * -55;
      65        1500 :     Node** pos = cache.Find(zone(), v);
      66        1500 :     if (*pos != nullptr) {
      67         350 :       EXPECT_EQ(nodes[i], *pos);
      68         175 :       hits++;
      69             :     }
      70             :   }
      71           1 :   EXPECT_LT(4, hits);
      72           1 : }
      73             : 
      74             : 
      75       15418 : TEST_F(NodeCacheTest, Int64Constant_back_to_back) {
      76             :   Int64NodeCache cache;
      77             : 
      78        2415 :   for (int64_t i = -2000000000; i < 2000000000; i += 3315177) {
      79        1207 :     Node** pos = cache.Find(zone(), i);
      80        2414 :     ASSERT_TRUE(pos != nullptr);
      81        8449 :     for (int j = 0; j < 3; j++) {
      82        3621 :       Node** npos = cache.Find(zone(), i);
      83        3621 :       EXPECT_EQ(pos, npos);
      84             :     }
      85             :   }
      86             : }
      87             : 
      88             : 
      89       15418 : TEST_F(NodeCacheTest, Int64Constant_hits) {
      90             :   Int64NodeCache cache;
      91             :   const int32_t kSize = 1500;
      92             :   Node** nodes = zone()->NewArray<Node*>(kSize);
      93             : 
      94        3001 :   for (int i = 0; i < kSize; i++) {
      95        1500 :     int64_t v = static_cast<int64_t>(i) * static_cast<int64_t>(5003001);
      96        4500 :     nodes[i] = graph()->NewNode(common()->Int32Constant(i));
      97        1500 :     *cache.Find(zone(), v) = nodes[i];
      98             :   }
      99             : 
     100           1 :   int hits = 0;
     101        3001 :   for (int i = 0; i < kSize; i++) {
     102        1500 :     int64_t v = static_cast<int64_t>(i) * static_cast<int64_t>(5003001);
     103        1500 :     Node** pos = cache.Find(zone(), v);
     104        1500 :     if (*pos != nullptr) {
     105         340 :       EXPECT_EQ(nodes[i], *pos);
     106         170 :       hits++;
     107             :     }
     108             :   }
     109           1 :   EXPECT_LT(4, hits);
     110           1 : }
     111             : 
     112             : 
     113       15418 : TEST_F(NodeCacheTest, GetCachedNodes_int32) {
     114             :   Int32NodeCache cache;
     115             :   int32_t constants[] = {0, 311, 12,  13,  14,  555, -555, -44, -33, -22, -11,
     116           1 :                          0, 311, 311, 412, 412, 11,  11,   -33, -33, -22, -11};
     117             : 
     118          45 :   for (size_t i = 0; i < arraysize(constants); i++) {
     119          22 :     int32_t k = constants[i];
     120          22 :     Node** pos = cache.Find(zone(), k);
     121          22 :     if (*pos != nullptr) {
     122             :       ZoneVector<Node*> nodes(zone());
     123           9 :       cache.GetCachedNodes(&nodes);
     124           9 :       EXPECT_THAT(nodes, Contains(*pos));
     125             :     } else {
     126             :       ZoneVector<Node*> nodes(zone());
     127          13 :       Node* n = graph()->NewNode(common()->Int32Constant(k));
     128          13 :       *pos = n;
     129          13 :       cache.GetCachedNodes(&nodes);
     130          13 :       EXPECT_THAT(nodes, Contains(n));
     131             :     }
     132             :   }
     133           1 : }
     134             : 
     135             : 
     136       15418 : TEST_F(NodeCacheTest, GetCachedNodes_int64) {
     137             :   Int64NodeCache cache;
     138             :   int64_t constants[] = {0, 311, 12,  13,  14,  555, -555, -44, -33, -22, -11,
     139           1 :                          0, 311, 311, 412, 412, 11,  11,   -33, -33, -22, -11};
     140             : 
     141          45 :   for (size_t i = 0; i < arraysize(constants); i++) {
     142          22 :     int64_t k = constants[i];
     143          22 :     Node** pos = cache.Find(zone(), k);
     144          22 :     if (*pos != nullptr) {
     145             :       ZoneVector<Node*> nodes(zone());
     146           9 :       cache.GetCachedNodes(&nodes);
     147           9 :       EXPECT_THAT(nodes, Contains(*pos));
     148             :     } else {
     149             :       ZoneVector<Node*> nodes(zone());
     150          13 :       Node* n = graph()->NewNode(common()->Int64Constant(k));
     151          13 :       *pos = n;
     152          13 :       cache.GetCachedNodes(&nodes);
     153          13 :       EXPECT_THAT(nodes, Contains(n));
     154             :     }
     155             :   }
     156           1 : }
     157             : 
     158             : }  // namespace node_cache_unittest
     159             : }  // namespace compiler
     160             : }  // namespace internal
     161        9249 : }  // namespace v8

Generated by: LCOV version 1.10