// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <climits>
-
-#include "src/v8.h"
#include "src/heap/gc-idle-time-handler.h"
const double GCIdleTimeHandler::kConservativeTimeRatio = 0.9;
-intptr_t GCIdleTimeHandler::EstimateMarkingStepSize(
- int idle_time_in_ms, intptr_t marking_speed_in_bytes_per_ms) {
+size_t GCIdleTimeHandler::EstimateMarkingStepSize(
+ size_t idle_time_in_ms, size_t marking_speed_in_bytes_per_ms) {
DCHECK(idle_time_in_ms > 0);
if (marking_speed_in_bytes_per_ms == 0) {
GCIdleTimeHandler::kInitialConservativeMarkingSpeed;
}
- intptr_t marking_step_size = marking_speed_in_bytes_per_ms * idle_time_in_ms;
- if (static_cast<intptr_t>(marking_step_size / idle_time_in_ms) !=
- marking_speed_in_bytes_per_ms) {
+ size_t marking_step_size = marking_speed_in_bytes_per_ms * idle_time_in_ms;
+ if (marking_step_size / marking_speed_in_bytes_per_ms != idle_time_in_ms) {
// In the case of an overflow we return maximum marking step size.
- return INT_MAX;
+ return GCIdleTimeHandler::kMaximumMarkingStepSize;
}
- return Min(static_cast<intptr_t>(marking_step_size *
- GCIdleTimeHandler::kConservativeTimeRatio),
- static_cast<intptr_t>(INT_MAX));
+ if (marking_step_size > kMaximumMarkingStepSize)
+ return kMaximumMarkingStepSize;
+
+ return static_cast<size_t>(marking_step_size *
+ GCIdleTimeHandler::kConservativeTimeRatio);
}
}
}
// operations are executing during IdleNotification.
class GCIdleTimeHandler {
public:
- static intptr_t EstimateMarkingStepSize(
- int idle_time_in_ms, intptr_t marking_speed_in_bytes_per_ms);
+ static size_t EstimateMarkingStepSize(size_t idle_time_in_ms,
+ size_t marking_speed_in_bytes_per_ms);
// If we haven't recorded any incremental marking events yet, we carefully
// mark with a conservative lower bound for the marking speed.
- static const intptr_t kInitialConservativeMarkingSpeed = 100 * KB;
+ static const size_t kInitialConservativeMarkingSpeed = 100 * KB;
+
+ // Maximum marking step size returned by EstimateMarkingStepSize.
+ static const size_t kMaximumMarkingStepSize = 700 * MB;
// We have to make sure that we finish the IdleNotification before
// idle_time_in_ms. Hence, we conservatively prune our workload estimate.
void Heap::AdvanceIdleIncrementalMarking(int idle_time_in_ms) {
- intptr_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
- idle_time_in_ms, tracer_.IncrementalMarkingSpeedInBytesPerMillisecond());
+ intptr_t step_size =
+ static_cast<size_t>(GCIdleTimeHandler::EstimateMarkingStepSize(
+ idle_time_in_ms,
+ tracer_.IncrementalMarkingSpeedInBytesPerMillisecond()));
incremental_marking()->Step(step_size,
IncrementalMarking::NO_GC_VIA_STACK_GUARD, true);
Capacity(), Waste(), Available(), pct);
if (!swept_precisely_) return;
+ if (heap()->mark_compact_collector()->sweeping_in_progress()) {
+ heap()->mark_compact_collector()->EnsureSweepingCompleted();
+ }
ClearHistograms(heap()->isolate());
HeapObjectIterator obj_it(this);
for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next())
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-#include <climits>
+#include <limits>
#include "src/heap/gc-idle-time-handler.h"
namespace internal {
TEST(EstimateMarkingStepSizeTest, EstimateMarkingStepSizeInitial) {
- intptr_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(1, 0);
- EXPECT_EQ(static_cast<intptr_t>(
- GCIdleTimeHandler::kInitialConservativeMarkingSpeed *
- GCIdleTimeHandler::kConservativeTimeRatio),
- step_size);
+ size_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(1, 0);
+ EXPECT_EQ(
+ static_cast<size_t>(GCIdleTimeHandler::kInitialConservativeMarkingSpeed *
+ GCIdleTimeHandler::kConservativeTimeRatio),
+ step_size);
}
TEST(EstimateMarkingStepSizeTest, EstimateMarkingStepSizeNonZero) {
- intptr_t marking_speed_in_bytes_per_millisecond = 100;
- intptr_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
+ size_t marking_speed_in_bytes_per_millisecond = 100;
+ size_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
1, marking_speed_in_bytes_per_millisecond);
- EXPECT_EQ(static_cast<intptr_t>(marking_speed_in_bytes_per_millisecond *
- GCIdleTimeHandler::kConservativeTimeRatio),
+ EXPECT_EQ(static_cast<size_t>(marking_speed_in_bytes_per_millisecond *
+ GCIdleTimeHandler::kConservativeTimeRatio),
step_size);
}
TEST(EstimateMarkingStepSizeTest, EstimateMarkingStepSizeOverflow1) {
- intptr_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(10, INT_MAX);
- EXPECT_EQ(INT_MAX, step_size);
+ size_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
+ 10, std::numeric_limits<size_t>::max());
+ EXPECT_EQ(static_cast<size_t>(GCIdleTimeHandler::kMaximumMarkingStepSize),
+ step_size);
}
TEST(EstimateMarkingStepSizeTest, EstimateMarkingStepSizeOverflow2) {
- intptr_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(INT_MAX, 10);
- EXPECT_EQ(INT_MAX, step_size);
+ size_t step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
+ std::numeric_limits<size_t>::max(), 10);
+ EXPECT_EQ(static_cast<size_t>(GCIdleTimeHandler::kMaximumMarkingStepSize),
+ step_size);
}
} // namespace internal