OLD | NEW |
1 // Copyright 2014 the V8 project authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <cmath> | 5 #include <cmath> |
6 #include <limits> | 6 #include <limits> |
7 | 7 |
8 #include "src/globals.h" | 8 #include "src/globals.h" |
9 #include "src/heap/gc-tracer.h" | 9 #include "src/heap/gc-tracer.h" |
10 #include "src/isolate.h" | 10 #include "src/isolate.h" |
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
184 EXPECT_DOUBLE_EQ( | 184 EXPECT_DOUBLE_EQ( |
185 200.0, tracer->current_.scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE]); | 185 200.0, tracer->current_.scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE]); |
186 } | 186 } |
187 | 187 |
188 TEST_F(GCTracerTest, IncrementalMarkingDetails) { | 188 TEST_F(GCTracerTest, IncrementalMarkingDetails) { |
189 GCTracer* tracer = i_isolate()->heap()->tracer(); | 189 GCTracer* tracer = i_isolate()->heap()->tracer(); |
190 tracer->ResetForTesting(); | 190 tracer->ResetForTesting(); |
191 | 191 |
192 // Round 1. | 192 // Round 1. |
193 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 50); | 193 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 50); |
| 194 // Scavenger has no impact on incremental marking details. |
| 195 tracer->Start(SCAVENGER, GarbageCollectionReason::kTesting, |
| 196 "collector unittest"); |
| 197 tracer->Stop(SCAVENGER); |
194 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, | 198 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, |
195 "collector unittest"); | 199 "collector unittest"); |
196 // Switch to incremental MC to enable writing back incremental scopes. | 200 // Switch to incremental MC to enable writing back incremental scopes. |
197 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; | 201 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; |
198 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 100); | 202 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 100); |
199 tracer->Stop(MARK_COMPACTOR); | 203 tracer->Stop(MARK_COMPACTOR); |
200 EXPECT_DOUBLE_EQ( | 204 EXPECT_DOUBLE_EQ( |
201 100, | 205 100, |
202 tracer->current_ | 206 tracer->current_ |
203 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 207 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
204 .longest_step); | 208 .longest_step); |
205 EXPECT_EQ( | 209 EXPECT_EQ( |
206 2, | 210 2, |
207 tracer->current_ | 211 tracer->current_ |
208 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 212 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
209 .steps); | 213 .steps); |
210 EXPECT_DOUBLE_EQ( | 214 EXPECT_DOUBLE_EQ( |
211 150, | 215 150, |
212 tracer->current_ | 216 tracer->current_ |
213 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 217 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
214 .cumulative_duration); | 218 .duration); |
215 | 219 |
216 // Round 2. Cumulative numbers should add up, others should be reset. | 220 // Round 2. Numbers should be reset. |
217 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 13); | 221 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 13); |
218 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 15); | 222 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 15); |
219 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, | 223 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, |
220 "collector unittest"); | 224 "collector unittest"); |
221 // Switch to incremental MC to enable writing back incremental scopes. | 225 // Switch to incremental MC to enable writing back incremental scopes. |
222 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; | 226 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; |
223 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 122); | 227 tracer->AddScopeSample(GCTracer::Scope::MC_INCREMENTAL_FINALIZE, 122); |
224 tracer->Stop(MARK_COMPACTOR); | 228 tracer->Stop(MARK_COMPACTOR); |
225 EXPECT_DOUBLE_EQ( | 229 EXPECT_DOUBLE_EQ( |
226 122, | 230 122, |
227 tracer->current_ | 231 tracer->current_ |
228 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 232 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
229 .longest_step); | 233 .longest_step); |
230 EXPECT_EQ( | 234 EXPECT_EQ( |
231 3, | 235 3, |
232 tracer->current_ | 236 tracer->current_ |
233 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 237 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
234 .steps); | 238 .steps); |
235 EXPECT_DOUBLE_EQ( | 239 EXPECT_DOUBLE_EQ( |
236 300, | 240 150, |
237 tracer->current_ | 241 tracer->current_ |
238 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] | 242 .incremental_marking_scopes[GCTracer::Scope::MC_INCREMENTAL_FINALIZE] |
239 .cumulative_duration); | 243 .duration); |
| 244 } |
| 245 |
| 246 TEST_F(GCTracerTest, IncrementalMarkingSpeed) { |
| 247 GCTracer* tracer = i_isolate()->heap()->tracer(); |
| 248 tracer->ResetForTesting(); |
| 249 |
| 250 // Round 1. |
| 251 // 1000000 bytes in 100ms. |
| 252 tracer->AddIncrementalMarkingStep(100, 1000000); |
| 253 EXPECT_EQ(1000000 / 100, |
| 254 tracer->IncrementalMarkingSpeedInBytesPerMillisecond()); |
| 255 // 1000000 bytes in 100ms. |
| 256 tracer->AddIncrementalMarkingStep(100, 1000000); |
| 257 EXPECT_EQ(1000000 / 100, |
| 258 tracer->IncrementalMarkingSpeedInBytesPerMillisecond()); |
| 259 // Scavenger has no impact on incremental marking details. |
| 260 tracer->Start(SCAVENGER, GarbageCollectionReason::kTesting, |
| 261 "collector unittest"); |
| 262 tracer->Stop(SCAVENGER); |
| 263 // 1000000 bytes in 100ms. |
| 264 tracer->AddIncrementalMarkingStep(100, 1000000); |
| 265 EXPECT_EQ(300, tracer->incremental_marking_duration_); |
| 266 EXPECT_EQ(3000000, tracer->incremental_marking_bytes_); |
| 267 EXPECT_EQ(1000000 / 100, |
| 268 tracer->IncrementalMarkingSpeedInBytesPerMillisecond()); |
| 269 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, |
| 270 "collector unittest"); |
| 271 // Switch to incremental MC. |
| 272 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; |
| 273 // 1000000 bytes in 100ms. |
| 274 tracer->AddIncrementalMarkingStep(100, 1000000); |
| 275 EXPECT_EQ(400, tracer->incremental_marking_duration_); |
| 276 EXPECT_EQ(4000000, tracer->incremental_marking_bytes_); |
| 277 tracer->Stop(MARK_COMPACTOR); |
| 278 EXPECT_EQ(400, tracer->current_.incremental_marking_duration); |
| 279 EXPECT_EQ(4000000, tracer->current_.incremental_marking_bytes); |
| 280 EXPECT_EQ(0, tracer->incremental_marking_duration_); |
| 281 EXPECT_EQ(0, tracer->incremental_marking_bytes_); |
| 282 EXPECT_EQ(1000000 / 100, |
| 283 tracer->IncrementalMarkingSpeedInBytesPerMillisecond()); |
| 284 |
| 285 // Round 2. |
| 286 tracer->AddIncrementalMarkingStep(2000, 1000); |
| 287 tracer->Start(MARK_COMPACTOR, GarbageCollectionReason::kTesting, |
| 288 "collector unittest"); |
| 289 // Switch to incremental MC. |
| 290 tracer->current_.type = GCTracer::Event::INCREMENTAL_MARK_COMPACTOR; |
| 291 tracer->Stop(MARK_COMPACTOR); |
| 292 EXPECT_DOUBLE_EQ((4000000.0 / 400 + 1000.0 / 2000) / 2, |
| 293 static_cast<double>( |
| 294 tracer->IncrementalMarkingSpeedInBytesPerMillisecond())); |
240 } | 295 } |
241 | 296 |
242 } // namespace internal | 297 } // namespace internal |
243 } // namespace v8 | 298 } // namespace v8 |
OLD | NEW |