Revision: 23248
Author: [email protected]
Date: Wed Aug 20 15:37:43 2014 UTC
Log: Use size_t in GCIdleTimeHandler to fix undefined behaviour.
BUG=
[email protected]
Review URL: https://codereview.chromium.org/490943002
http://code.google.com/p/v8/source/detail?r=23248
Modified:
/branches/bleeding_edge/src/heap/gc-idle-time-handler.cc
/branches/bleeding_edge/src/heap/gc-idle-time-handler.h
/branches/bleeding_edge/src/heap/heap.cc
/branches/bleeding_edge/src/heap/spaces.cc
/branches/bleeding_edge/test/heap-unittests/heap-unittest.cc
=======================================
--- /branches/bleeding_edge/src/heap/gc-idle-time-handler.cc Wed Aug 20
14:20:59 2014 UTC
+++ /branches/bleeding_edge/src/heap/gc-idle-time-handler.cc Wed Aug 20
15:37:43 2014 UTC
@@ -1,9 +1,6 @@
// 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"
@@ -14,8 +11,8 @@
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) {
@@ -23,16 +20,17 @@
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);
}
}
}
=======================================
--- /branches/bleeding_edge/src/heap/gc-idle-time-handler.h Wed Aug 20
10:33:03 2014 UTC
+++ /branches/bleeding_edge/src/heap/gc-idle-time-handler.h Wed Aug 20
15:37:43 2014 UTC
@@ -14,12 +14,15 @@
// 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.
=======================================
--- /branches/bleeding_edge/src/heap/heap.cc Wed Aug 20 10:33:03 2014 UTC
+++ /branches/bleeding_edge/src/heap/heap.cc Wed Aug 20 15:37:43 2014 UTC
@@ -4265,8 +4265,10 @@
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);
=======================================
--- /branches/bleeding_edge/src/heap/spaces.cc Wed Aug 20 15:04:22 2014 UTC
+++ /branches/bleeding_edge/src/heap/spaces.cc Wed Aug 20 15:37:43 2014 UTC
@@ -2738,6 +2738,9 @@
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())
=======================================
--- /branches/bleeding_edge/test/heap-unittests/heap-unittest.cc Wed Aug 20
10:33:03 2014 UTC
+++ /branches/bleeding_edge/test/heap-unittests/heap-unittest.cc Wed Aug 20
15:37:43 2014 UTC
@@ -2,7 +2,7 @@
// 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"
@@ -12,33 +12,37 @@
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
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
