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 <limits>
       6             : 
       7             : #include "src/globals.h"
       8             : #include "src/heap/scavenge-job.h"
       9             : #include "src/utils.h"
      10             : #include "testing/gtest/include/gtest/gtest.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : const size_t kScavengeSpeedInBytesPerMs = 500 * KB;
      16             : const size_t kNewSpaceCapacity = 8 * MB;
      17             : 
      18             : 
      19       15443 : TEST(ScavengeJob, AllocationLimitEmptyNewSpace) {
      20           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(
      21           0 :       kScavengeSpeedInBytesPerMs, 0, kNewSpaceCapacity));
      22           1 : }
      23             : 
      24             : 
      25       15443 : TEST(ScavengeJob, AllocationLimitFullNewSpace) {
      26           2 :   EXPECT_TRUE(ScavengeJob::ReachedIdleAllocationLimit(
      27           0 :       kScavengeSpeedInBytesPerMs, kNewSpaceCapacity, kNewSpaceCapacity));
      28           1 : }
      29             : 
      30             : 
      31       15443 : TEST(ScavengeJob, AllocationLimitUnknownScavengeSpeed) {
      32             :   size_t expected_size = ScavengeJob::kInitialScavengeSpeedInBytesPerMs *
      33             :                              ScavengeJob::kAverageIdleTimeMs -
      34             :                          ScavengeJob::kBytesAllocatedBeforeNextIdleTask;
      35             :   expected_size = Max(expected_size, ScavengeJob::kMinAllocationLimit);
      36             : 
      37           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(0, expected_size - 1,
      38           0 :                                                        kNewSpaceCapacity));
      39           2 :   EXPECT_TRUE(ScavengeJob::ReachedIdleAllocationLimit(0, expected_size,
      40           0 :                                                       kNewSpaceCapacity));
      41           1 : }
      42             : 
      43             : 
      44       15443 : TEST(ScavengeJob, AllocationLimitLowScavengeSpeed) {
      45             :   size_t scavenge_speed = 1 * KB;
      46           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(
      47           0 :       scavenge_speed, ScavengeJob::kMinAllocationLimit - 1, kNewSpaceCapacity));
      48           2 :   EXPECT_TRUE(ScavengeJob::ReachedIdleAllocationLimit(
      49           0 :       scavenge_speed, ScavengeJob::kMinAllocationLimit, kNewSpaceCapacity));
      50           1 : }
      51             : 
      52             : 
      53       15443 : TEST(ScavengeJob, AllocationLimitAverageScavengeSpeed) {
      54             :   size_t expected_size =
      55             :       kScavengeSpeedInBytesPerMs * ScavengeJob::kAverageIdleTimeMs -
      56             :       ScavengeJob::kBytesAllocatedBeforeNextIdleTask;
      57           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(
      58             :       kScavengeSpeedInBytesPerMs, ScavengeJob::kMinAllocationLimit,
      59           0 :       kNewSpaceCapacity));
      60           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(
      61           0 :       kScavengeSpeedInBytesPerMs, expected_size - 1, kNewSpaceCapacity));
      62           2 :   EXPECT_TRUE(ScavengeJob::ReachedIdleAllocationLimit(
      63           0 :       kScavengeSpeedInBytesPerMs, expected_size, kNewSpaceCapacity));
      64           1 : }
      65             : 
      66             : 
      67       15443 : TEST(ScavengeJob, AllocationLimitHighScavengeSpeed) {
      68             :   size_t scavenge_speed = kNewSpaceCapacity;
      69             :   size_t expected_size =
      70             :       static_cast<size_t>(
      71           1 :           kNewSpaceCapacity *
      72           1 :           ScavengeJob::kMaxAllocationLimitAsFractionOfNewSpace) -
      73             :       ScavengeJob::kBytesAllocatedBeforeNextIdleTask;
      74           2 :   EXPECT_FALSE(ScavengeJob::ReachedIdleAllocationLimit(
      75           0 :       scavenge_speed, expected_size - 1, kNewSpaceCapacity));
      76           2 :   EXPECT_TRUE(ScavengeJob::ReachedIdleAllocationLimit(
      77           0 :       scavenge_speed, expected_size + 1, kNewSpaceCapacity));
      78           1 : }
      79             : 
      80             : 
      81       15443 : TEST(ScavengeJob, EnoughIdleTimeForScavengeUnknownScavengeSpeed) {
      82             :   size_t scavenge_speed = ScavengeJob::kInitialScavengeSpeedInBytesPerMs;
      83             :   size_t new_space_size = 1 * MB;
      84             :   size_t expected_time = (new_space_size + scavenge_speed - 1) / scavenge_speed;
      85           2 :   EXPECT_TRUE(
      86           0 :       ScavengeJob::EnoughIdleTimeForScavenge(expected_time, 0, new_space_size));
      87           2 :   EXPECT_FALSE(ScavengeJob::EnoughIdleTimeForScavenge(expected_time - 1, 0,
      88           0 :                                                       new_space_size));
      89           1 : }
      90             : 
      91             : 
      92       15443 : TEST(ScavengeJob, EnoughIdleTimeForScavengeLowScavengeSpeed) {
      93             :   size_t scavenge_speed = 1 * KB;
      94             :   size_t new_space_size = 1 * MB;
      95             :   size_t expected_time = (new_space_size + scavenge_speed - 1) / scavenge_speed;
      96           2 :   EXPECT_TRUE(ScavengeJob::EnoughIdleTimeForScavenge(
      97           0 :       expected_time, scavenge_speed, new_space_size));
      98           2 :   EXPECT_FALSE(ScavengeJob::EnoughIdleTimeForScavenge(
      99           0 :       expected_time - 1, scavenge_speed, new_space_size));
     100           1 : }
     101             : 
     102             : 
     103       15443 : TEST(ScavengeJob, EnoughIdleTimeForScavengeHighScavengeSpeed) {
     104             :   size_t scavenge_speed = kNewSpaceCapacity;
     105             :   size_t new_space_size = 1 * MB;
     106             :   size_t expected_time = (new_space_size + scavenge_speed - 1) / scavenge_speed;
     107           2 :   EXPECT_TRUE(ScavengeJob::EnoughIdleTimeForScavenge(
     108           0 :       expected_time, scavenge_speed, new_space_size));
     109           2 :   EXPECT_FALSE(ScavengeJob::EnoughIdleTimeForScavenge(
     110           0 :       expected_time - 1, scavenge_speed, new_space_size));
     111           1 : }
     112             : 
     113             : }  // namespace internal
     114        9264 : }  // namespace v8