[heap] User size_t in GcTracer

src/heap/gc-tracer.cc

 // 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 "src/heap/gc-tracer.h"
 
 #include "src/counters.h"
 #include "src/heap/heap-inl.h"
 #include "src/isolate.h"
 
 namespace v8 {
 namespace internal {
 
-static intptr_t CountTotalHolesSize(Heap* heap) {
-  intptr_t holes_size = 0;
+static size_t CountTotalHolesSize(Heap* heap) {
+  size_t holes_size = 0;
   OldSpaces spaces(heap);
   for (OldSpace* space = spaces.next(); space != NULL; space = spaces.next()) {
-    holes_size += space->Waste() + space->Available();
+    DCHECK_GE(space->Waste(), 0);
+    DCHECK_GE(space->Available(), 0);

[Michael Lippautz, 2016/10/11 14:54:38]

nit: 
  DCHECK_GE(holes_size + space->Waste() + space->Available(), holes_size);

+    holes_size += static_cast<size_t>(space->Waste() + space->Available());
   }
   return holes_size;
 }
 
 
 GCTracer::Scope::Scope(GCTracer* tracer, ScopeId scope)
     : tracer_(tracer), scope_(scope) {
   // All accesses to incremental_marking_scope assume that incremental marking
   // scopes come first.
   STATIC_ASSERT(FIRST_INCREMENTAL_SCOPE == 0);
@@ skipping 152 matching lines @@
   current_.new_space_object_size =
       heap_->new_space()->top() - heap_->new_space()->bottom();
 
   current_.incremental_marking_bytes = 0;
   current_.incremental_marking_duration = 0;
 
   for (int i = 0; i < Scope::NUMBER_OF_SCOPES; i++) {
     current_.scopes[i] = 0;
   }
 
-  int committed_memory = static_cast<int>(heap_->CommittedMemory() / KB);
-  int used_memory = static_cast<int>(current_.start_object_size / KB);
+  size_t committed_memory = heap_->CommittedMemory() / KB;
+  size_t used_memory = current_.start_object_size / KB;
 
   Counters* counters = heap_->isolate()->counters();
 
   if (collector == SCAVENGER) {
     counters->scavenge_reason()->AddSample(static_cast<int>(gc_reason));
   } else {
     counters->mark_compact_reason()->AddSample(static_cast<int>(gc_reason));
   }
   counters->aggregated_memory_heap_committed()->AddSample(start_time,
                                                           committed_memory);
@@ skipping 31 matching lines @@
            current_.type == Event::INCREMENTAL_MARK_COMPACTOR)));
 
   current_.end_time = heap_->MonotonicallyIncreasingTimeInMs();
   current_.end_object_size = heap_->SizeOfObjects();
   current_.end_memory_size = heap_->memory_allocator()->Size();
   current_.end_holes_size = CountTotalHolesSize(heap_);
   current_.survived_new_space_object_size = heap_->SurvivedNewSpaceObjectSize();
 
   AddAllocation(current_.end_time);
 
-  int committed_memory = static_cast<int>(heap_->CommittedMemory() / KB);
-  int used_memory = static_cast<int>(current_.end_object_size / KB);
+  size_t committed_memory = heap_->CommittedMemory() / KB;
+  size_t used_memory = current_.end_object_size / KB;
   heap_->isolate()->counters()->aggregated_memory_heap_committed()->AddSample(
       current_.end_time, committed_memory);
   heap_->isolate()->counters()->aggregated_memory_heap_used()->AddSample(
       current_.end_time, used_memory);
 
   double duration = current_.end_time - current_.start_time;
 
   if (current_.type == Event::SCAVENGER) {
     recorded_scavenges_total_.Push(
         MakeBytesAndDuration(current_.new_space_object_size, duration));
@@ skipping 85 matching lines @@
   allocation_duration_since_gc_ = 0;
   new_space_allocation_in_bytes_since_gc_ = 0;
   old_generation_allocation_in_bytes_since_gc_ = 0;
 }
 
 
 void GCTracer::AddContextDisposalTime(double time) {
   recorded_context_disposal_times_.Push(time);
 }
 
-
 void GCTracer::AddCompactionEvent(double duration,
-                                  intptr_t live_bytes_compacted) {
+                                  size_t live_bytes_compacted) {
   recorded_compactions_.Push(
       MakeBytesAndDuration(live_bytes_compacted, duration));
 }
 
 
 void GCTracer::AddSurvivalRatio(double promotion_ratio) {
   recorded_survival_ratios_.Push(promotion_ratio);
 }
 
-
-void GCTracer::AddIncrementalMarkingStep(double duration, intptr_t bytes) {
+void GCTracer::AddIncrementalMarkingStep(double duration, size_t bytes) {
   if (bytes > 0) {
     incremental_marking_bytes_ += bytes;
     incremental_marking_duration_ += duration;
   }
 }
 
 void GCTracer::Output(const char* format, ...) const {
   if (FLAG_trace_gc) {
     va_list arguments;
     va_start(arguments, format);
@@ skipping 44 matching lines @@
       static_cast<double>(current_.end_memory_size) / MB, duration,
       TotalExternalTime(), incremental_buffer,
       Heap::GarbageCollectionReasonToString(current_.gc_reason),
       current_.collector_reason != nullptr ? current_.collector_reason : "");
 }
 
 
 void GCTracer::PrintNVP() const {
   double duration = current_.end_time - current_.start_time;
   double spent_in_mutator = current_.start_time - previous_.end_time;
-  intptr_t allocated_since_last_gc =
+  size_t allocated_since_last_gc =
       current_.start_object_size - previous_.end_object_size;
 
   double incremental_walltime_duration = 0;
 
   if (current_.type == Event::INCREMENTAL_MARK_COMPACTOR) {
     incremental_walltime_duration =
         current_.end_time - incremental_marking_start_time_;
   }
 
   switch (current_.type) {
@@ skipping 250 matching lines @@
   const int min_speed = 1;
   if (speed >= max_speed) return max_speed;
   if (speed <= min_speed) return min_speed;
   return speed;
 }
 
 double GCTracer::AverageSpeed(const RingBuffer<BytesAndDuration>& buffer) {
   return AverageSpeed(buffer, MakeBytesAndDuration(0, 0), 0);
 }
 
-void GCTracer::RecordIncrementalMarkingSpeed(intptr_t bytes, double duration) {
+void GCTracer::RecordIncrementalMarkingSpeed(size_t bytes, double duration) {
   if (duration == 0 || bytes == 0) return;
   double current_speed = bytes / duration;
   if (recorded_incremental_marking_speed_ == 0) {
     recorded_incremental_marking_speed_ = current_speed;
   } else {
     recorded_incremental_marking_speed_ =
         (recorded_incremental_marking_speed_ + current_speed) / 2;
   }
 }
 
@@ skipping 102 matching lines @@
 }
 
 void GCTracer::ResetSurvivalEvents() { recorded_survival_ratios_.Reset(); }
 
 void GCTracer::NotifyIncrementalMarkingStart() {
   incremental_marking_start_time_ = heap_->MonotonicallyIncreasingTimeInMs();
 }
 
 }  // namespace internal
 }  // namespace v8