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 <algorithm>
       6             : 
       7             : #include "src/compiler/zone-stats.h"
       8             : 
       9             : namespace v8 {
      10             : namespace internal {
      11             : namespace compiler {
      12             : 
      13          23 : ZoneStats::StatsScope::StatsScope(ZoneStats* zone_stats)
      14             :     : zone_stats_(zone_stats),
      15             :       total_allocated_bytes_at_start_(zone_stats->GetTotalAllocatedBytes()),
      16          46 :       max_allocated_bytes_(0) {
      17          46 :   zone_stats_->stats_.push_back(this);
      18          76 :   for (Zone* zone : zone_stats_->zones_) {
      19             :     size_t size = static_cast<size_t>(zone->allocation_size());
      20             :     std::pair<InitialValues::iterator, bool> res =
      21          60 :         initial_values_.insert(std::make_pair(zone, size));
      22             :     USE(res);
      23             :     DCHECK(res.second);
      24             :   }
      25          23 : }
      26             : 
      27          46 : ZoneStats::StatsScope::~StatsScope() {
      28             :   DCHECK_EQ(zone_stats_->stats_.back(), this);
      29          23 :   zone_stats_->stats_.pop_back();
      30          23 : }
      31             : 
      32         846 : size_t ZoneStats::StatsScope::GetMaxAllocatedBytes() {
      33        1692 :   return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
      34             : }
      35             : 
      36        1753 : size_t ZoneStats::StatsScope::GetCurrentAllocatedBytes() {
      37             :   size_t total = 0;
      38        7017 :   for (Zone* zone : zone_stats_->zones_) {
      39        3511 :     total += static_cast<size_t>(zone->allocation_size());
      40             :     // Adjust for initial values.
      41             :     InitialValues::iterator it = initial_values_.find(zone);
      42        3511 :     if (it != initial_values_.end()) {
      43         935 :       total -= it->second;
      44             :     }
      45             :   }
      46        1753 :   return total;
      47             : }
      48             : 
      49         846 : size_t ZoneStats::StatsScope::GetTotalAllocatedBytes() {
      50         846 :   return zone_stats_->GetTotalAllocatedBytes() -
      51         846 :          total_allocated_bytes_at_start_;
      52             : }
      53             : 
      54          61 : void ZoneStats::StatsScope::ZoneReturned(Zone* zone) {
      55          61 :   size_t current_total = GetCurrentAllocatedBytes();
      56             :   // Update max.
      57         122 :   max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
      58             :   // Drop zone from initial value map.
      59             :   InitialValues::iterator it = initial_values_.find(zone);
      60          61 :   if (it != initial_values_.end()) {
      61             :     initial_values_.erase(it);
      62             :   }
      63          61 : }
      64             : 
      65     2602473 : ZoneStats::ZoneStats(AccountingAllocator* allocator)
      66     2602473 :     : max_allocated_bytes_(0), total_deleted_bytes_(0), allocator_(allocator) {}
      67             : 
      68     5208811 : ZoneStats::~ZoneStats() {
      69             :   DCHECK(zones_.empty());
      70             :   DCHECK(stats_.empty());
      71     2605213 : }
      72             : 
      73         429 : size_t ZoneStats::GetMaxAllocatedBytes() const {
      74         858 :   return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
      75             : }
      76             : 
      77         429 : size_t ZoneStats::GetCurrentAllocatedBytes() const {
      78             :   size_t total = 0;
      79   383263334 :   for (Zone* zone : zones_) {
      80   306081134 :     total += static_cast<size_t>(zone->allocation_size());
      81             :   }
      82         429 :   return total;
      83             : }
      84             : 
      85         429 : size_t ZoneStats::GetTotalAllocatedBytes() const {
      86        2596 :   return total_deleted_bytes_ + GetCurrentAllocatedBytes();
      87             : }
      88             : 
      89    77175822 : Zone* ZoneStats::NewEmptyZone(const char* zone_name) {
      90    77175822 :   Zone* zone = new Zone(allocator_, zone_name);
      91    77201027 :   zones_.push_back(zone);
      92    77192064 :   return zone;
      93             : }
      94             : 
      95    77180044 : void ZoneStats::ReturnZone(Zone* zone) {
      96    77180044 :   size_t current_total = GetCurrentAllocatedBytes();
      97             :   // Update max.
      98   154360088 :   max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
      99             :   // Update stats.
     100    77180105 :   for (StatsScope* stat_scope : stats_) {
     101          61 :     stat_scope->ZoneReturned(zone);
     102             :   }
     103             :   // Remove from used.
     104    77180044 :   Zones::iterator it = std::find(zones_.begin(), zones_.end(), zone);
     105             :   DCHECK(it != zones_.end());
     106    77163200 :   zones_.erase(it);
     107   154322858 :   total_deleted_bytes_ += static_cast<size_t>(zone->allocation_size());
     108    77161429 :   delete zone;
     109    77234022 : }
     110             : 
     111             : }  // namespace compiler
     112             : }  // namespace internal
     113             : }  // namespace v8