Replaced different means of zone pooling/reusing by one zone segment pool

BUG=v8:5409

Review-Url: https://codereview.chromium.org/2348303002
Cr-Commit-Position: refs/heads/master@{#39633}

BUILD.gn

@@ -1174,8 +1174,8 @@ v8_source_set("v8_base") {
     "src/compiler/wasm-compiler.cc",
     "src/compiler/wasm-compiler.h",
     "src/compiler/wasm-linkage.cc",
-    "src/compiler/zone-pool.cc",
-    "src/compiler/zone-pool.h",
+    "src/compiler/zone-stats.cc",
+    "src/compiler/zone-stats.h",
     "src/context-measure.cc",
     "src/context-measure.h",
     "src/contexts-inl.h",

src/compiler/move-optimizer.cc

@@ -317,7 +317,7 @@ void MoveOptimizer::OptimizeMerge(InstructionBlock* block) {
       if (!op->IsConstant() && !op->IsImmediate()) return;
     }
   }
-  // TODO(dcarney): pass a ZonePool down for this?
+  // TODO(dcarney): pass a ZoneStats down for this?
   MoveMap move_map(local_zone());
   size_t correct_counts = 0;
   // Accumulate set of shared moves.

src/compiler/pipeline-statistics.cc

@@ -6,7 +6,7 @@
 
 #include "src/compilation-info.h"
 #include "src/compiler/pipeline-statistics.h"
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 #include "src/isolate.h"
 
 namespace v8 {
@@ -16,13 +16,13 @@ namespace compiler {
 void PipelineStatistics::CommonStats::Begin(
     PipelineStatistics* pipeline_stats) {
   DCHECK(!scope_);
-  scope_.reset(new ZonePool::StatsScope(pipeline_stats->zone_pool_));
+  scope_.reset(new ZoneStats::StatsScope(pipeline_stats->zone_stats_));
   timer_.Start();
   outer_zone_initial_size_ = pipeline_stats->OuterZoneSize();
   allocated_bytes_at_start_ =
       outer_zone_initial_size_ -
       pipeline_stats->total_stats_.outer_zone_initial_size_ +
-      pipeline_stats->zone_pool_->GetCurrentAllocatedBytes();
+      pipeline_stats->zone_stats_->GetCurrentAllocatedBytes();
 }
 
 
@@ -43,12 +43,11 @@ void PipelineStatistics::CommonStats::End(
   timer_.Stop();
 }
 
-
 PipelineStatistics::PipelineStatistics(CompilationInfo* info,
-                                       ZonePool* zone_pool)
+                                       ZoneStats* zone_stats)
     : isolate_(info->isolate()),
       outer_zone_(info->zone()),
-      zone_pool_(zone_pool),
+      zone_stats_(zone_stats),
       compilation_stats_(isolate_->GetTurboStatistics()),
       source_size_(0),
       phase_kind_name_(nullptr),

src/compiler/pipeline-statistics.h

@@ -10,7 +10,7 @@
 
 #include "src/base/platform/elapsed-timer.h"
 #include "src/compilation-statistics.h"
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 
 namespace v8 {
 namespace internal {
@@ -20,7 +20,7 @@ class PhaseScope;
 
 class PipelineStatistics : public Malloced {
  public:
-  PipelineStatistics(CompilationInfo* info, ZonePool* zone_pool);
+  PipelineStatistics(CompilationInfo* info, ZoneStats* zone_stats);
   ~PipelineStatistics();
 
   void BeginPhaseKind(const char* phase_kind_name);
@@ -39,7 +39,7 @@ class PipelineStatistics : public Malloced {
     void End(PipelineStatistics* pipeline_stats,
              CompilationStatistics::BasicStats* diff);
 
-    std::unique_ptr<ZonePool::StatsScope> scope_;
+    std::unique_ptr<ZoneStats::StatsScope> scope_;
     base::ElapsedTimer timer_;
     size_t outer_zone_initial_size_;
     size_t allocated_bytes_at_start_;
@@ -57,7 +57,7 @@ class PipelineStatistics : public Malloced {
 
   Isolate* isolate_;
   Zone* outer_zone_;
-  ZonePool* zone_pool_;
+  ZoneStats* zone_stats_;
   CompilationStatistics* compilation_stats_;
   std::string function_name_;
 

src/compiler/pipeline.cc

@@ -69,7 +69,7 @@
 #include "src/compiler/typer.h"
 #include "src/compiler/value-numbering-reducer.h"
 #include "src/compiler/verifier.h"
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 #include "src/isolate-inl.h"
 #include "src/ostreams.h"
 #include "src/parsing/parse-info.h"
@@ -84,19 +84,19 @@ namespace compiler {
 class PipelineData {
  public:
   // For main entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info,
+  PipelineData(ZoneStats* zone_stats, CompilationInfo* info,
                PipelineStatistics* pipeline_statistics)
       : isolate_(info->isolate()),
         info_(info),
         debug_name_(info_->GetDebugName()),
         outer_zone_(info_->zone()),
-        zone_pool_(zone_pool),
+        zone_stats_(zone_stats),
         pipeline_statistics_(pipeline_statistics),
-        graph_zone_scope_(zone_pool_),
+        graph_zone_scope_(zone_stats_),
         graph_zone_(graph_zone_scope_.zone()),
-        instruction_zone_scope_(zone_pool_),
+        instruction_zone_scope_(zone_stats_),
         instruction_zone_(instruction_zone_scope_.zone()),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(zone_stats_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()) {
     PhaseScope scope(pipeline_statistics, "init pipeline data");
     graph_ = new (graph_zone_) Graph(graph_zone_);
@@ -113,48 +113,48 @@ class PipelineData {
   }
 
   // For WASM compile entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info, Graph* graph,
+  PipelineData(ZoneStats* zone_stats, CompilationInfo* info, Graph* graph,
                SourcePositionTable* source_positions)
       : isolate_(info->isolate()),
         info_(info),
         debug_name_(info_->GetDebugName()),
-        zone_pool_(zone_pool),
-        graph_zone_scope_(zone_pool_),
+        zone_stats_(zone_stats),
+        graph_zone_scope_(zone_stats_),
         graph_(graph),
         source_positions_(source_positions),
-        instruction_zone_scope_(zone_pool_),
+        instruction_zone_scope_(zone_stats_),
         instruction_zone_(instruction_zone_scope_.zone()),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(zone_stats_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()) {}
 
   // For machine graph testing entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info, Graph* graph,
+  PipelineData(ZoneStats* zone_stats, CompilationInfo* info, Graph* graph,
                Schedule* schedule)
       : isolate_(info->isolate()),
         info_(info),
         debug_name_(info_->GetDebugName()),
-        zone_pool_(zone_pool),
-        graph_zone_scope_(zone_pool_),
+        zone_stats_(zone_stats),
+        graph_zone_scope_(zone_stats_),
         graph_(graph),
         source_positions_(new (info->zone()) SourcePositionTable(graph_)),
         schedule_(schedule),
-        instruction_zone_scope_(zone_pool_),
+        instruction_zone_scope_(zone_stats_),
         instruction_zone_(instruction_zone_scope_.zone()),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(zone_stats_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()) {}
 
   // For register allocation testing entry point.
-  PipelineData(ZonePool* zone_pool, CompilationInfo* info,
+  PipelineData(ZoneStats* zone_stats, CompilationInfo* info,
                InstructionSequence* sequence)
       : isolate_(info->isolate()),
         info_(info),
         debug_name_(info_->GetDebugName()),
-        zone_pool_(zone_pool),
-        graph_zone_scope_(zone_pool_),
-        instruction_zone_scope_(zone_pool_),
+        zone_stats_(zone_stats),
+        graph_zone_scope_(zone_stats_),
+        instruction_zone_scope_(zone_stats_),
         instruction_zone_(sequence->zone()),
         sequence_(sequence),
-        register_allocation_zone_scope_(zone_pool_),
+        register_allocation_zone_scope_(zone_stats_),
         register_allocation_zone_(register_allocation_zone_scope_.zone()) {}
 
   ~PipelineData() {
@@ -165,7 +165,7 @@ class PipelineData {
 
   Isolate* isolate() const { return isolate_; }
   CompilationInfo* info() const { return info_; }
-  ZonePool* zone_pool() const { return zone_pool_; }
+  ZoneStats* zone_stats() const { return zone_stats_; }
   PipelineStatistics* pipeline_statistics() { return pipeline_statistics_; }
   bool compilation_failed() const { return compilation_failed_; }
   void set_compilation_failed() { compilation_failed_ = true; }
@@ -312,14 +312,14 @@ class PipelineData {
   CompilationInfo* const info_;
   std::unique_ptr<char[]> debug_name_;
   Zone* outer_zone_ = nullptr;
-  ZonePool* const zone_pool_;
+  ZoneStats* const zone_stats_;
   PipelineStatistics* pipeline_statistics_ = nullptr;
   bool compilation_failed_ = false;
   Handle<Code> code_ = Handle<Code>::null();
 
   // All objects in the following group of fields are allocated in graph_zone_.
   // They are all set to nullptr when the graph_zone_ is destroyed.
-  ZonePool::Scope graph_zone_scope_;
+  ZoneStats::Scope graph_zone_scope_;
   Zone* graph_zone_ = nullptr;
   Graph* graph_ = nullptr;
   SourcePositionTable* source_positions_ = nullptr;
@@ -336,7 +336,7 @@ class PipelineData {
   // instruction_zone_.  They are all set to nullptr when the instruction_zone_
   // is
   // destroyed.
-  ZonePool::Scope instruction_zone_scope_;
+  ZoneStats::Scope instruction_zone_scope_;
   Zone* instruction_zone_;
   InstructionSequence* sequence_ = nullptr;
   Frame* frame_ = nullptr;
@@ -344,7 +344,7 @@ class PipelineData {
   // All objects in the following group of fields are allocated in
   // register_allocation_zone_.  They are all set to nullptr when the zone is
   // destroyed.
-  ZonePool::Scope register_allocation_zone_scope_;
+  ZoneStats::Scope register_allocation_zone_scope_;
   Zone* register_allocation_zone_;
   RegisterAllocationData* register_allocation_data_ = nullptr;
 
@@ -517,21 +517,21 @@ class PipelineRunScope {
       : phase_scope_(
             phase_name == nullptr ? nullptr : data->pipeline_statistics(),
             phase_name),
-        zone_scope_(data->zone_pool()) {}
+        zone_scope_(data->zone_stats()) {}
 
   Zone* zone() { return zone_scope_.zone(); }
 
  private:
   PhaseScope phase_scope_;
-  ZonePool::Scope zone_scope_;
+  ZoneStats::Scope zone_scope_;
 };
 
 PipelineStatistics* CreatePipelineStatistics(CompilationInfo* info,
-                                             ZonePool* zone_pool) {
+                                             ZoneStats* zone_stats) {
   PipelineStatistics* pipeline_statistics = nullptr;
 
   if (FLAG_turbo_stats || FLAG_turbo_stats_nvp) {
-    pipeline_statistics = new PipelineStatistics(info, zone_pool);
+    pipeline_statistics = new PipelineStatistics(info, zone_stats);
     pipeline_statistics->BeginPhaseKind("initializing");
   }
 
@@ -568,11 +568,11 @@ class PipelineCompilationJob final : public CompilationJob {
       // to the CompilationJob constructor, but it is not dereferenced there.
       : CompilationJob(isolate, &info_, "TurboFan"),
         zone_(isolate->allocator()),
-        zone_pool_(isolate->allocator()),
+        zone_stats_(isolate->allocator()),
         parse_info_(&zone_, function),
         info_(&parse_info_, function),
-        pipeline_statistics_(CreatePipelineStatistics(info(), &zone_pool_)),
-        data_(&zone_pool_, info(), pipeline_statistics_.get()),
+        pipeline_statistics_(CreatePipelineStatistics(info(), &zone_stats_)),
+        data_(&zone_stats_, info(), pipeline_statistics_.get()),
         pipeline_(&data_),
         linkage_(nullptr) {}
 
@@ -583,7 +583,7 @@ class PipelineCompilationJob final : public CompilationJob {
 
  private:
   Zone zone_;
-  ZonePool zone_pool_;
+  ZoneStats zone_stats_;
   ParseInfo parse_info_;
   CompilationInfo info_;
   std::unique_ptr<PipelineStatistics> pipeline_statistics_;
@@ -669,8 +669,8 @@ class PipelineWasmCompilationJob final : public CompilationJob {
                                       SourcePositionTable* source_positions)
       : CompilationJob(info->isolate(), info, "TurboFan",
                        State::kReadyToExecute),
-        zone_pool_(info->isolate()->allocator()),
-        data_(&zone_pool_, info, graph, source_positions),
+        zone_stats_(info->isolate()->allocator()),
+        data_(&zone_stats_, info, graph, source_positions),
         pipeline_(&data_),
         linkage_(descriptor) {}
 
@@ -680,7 +680,7 @@ class PipelineWasmCompilationJob final : public CompilationJob {
   Status FinalizeJobImpl() final;
 
  private:
-  ZonePool zone_pool_;
+  ZoneStats zone_stats_;
   PipelineData data_;
   PipelineImpl pipeline_;
   Linkage linkage_;
@@ -1642,11 +1642,11 @@ Handle<Code> Pipeline::GenerateCodeForCodeStub(Isolate* isolate,
   CompilationInfo info(CStrVector(debug_name), isolate, graph->zone(), flags);
 
   // Construct a pipeline for scheduling and code generation.
-  ZonePool zone_pool(isolate->allocator());
-  PipelineData data(&zone_pool, &info, graph, schedule);
+  ZoneStats zone_stats(isolate->allocator());
+  PipelineData data(&zone_stats, &info, graph, schedule);
   std::unique_ptr<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats || FLAG_turbo_stats_nvp) {
-    pipeline_statistics.reset(new PipelineStatistics(&info, &zone_pool));
+    pipeline_statistics.reset(new PipelineStatistics(&info, &zone_stats));
     pipeline_statistics->BeginPhaseKind("stub codegen");
   }
 
@@ -1668,10 +1668,10 @@ Handle<Code> Pipeline::GenerateCodeForCodeStub(Isolate* isolate,
 
 // static
 Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info) {
-  ZonePool zone_pool(info->isolate()->allocator());
+  ZoneStats zone_stats(info->isolate()->allocator());
   std::unique_ptr<PipelineStatistics> pipeline_statistics(
-      CreatePipelineStatistics(info, &zone_pool));
-  PipelineData data(&zone_pool, info, pipeline_statistics.get());
+      CreatePipelineStatistics(info, &zone_stats));
+  PipelineData data(&zone_stats, info, pipeline_statistics.get());
   PipelineImpl pipeline(&data);
 
   Linkage linkage(Linkage::ComputeIncoming(data.instruction_zone(), info));
@@ -1696,11 +1696,11 @@ Handle<Code> Pipeline::GenerateCodeForTesting(CompilationInfo* info,
                                               Graph* graph,
                                               Schedule* schedule) {
   // Construct a pipeline for scheduling and code generation.
-  ZonePool zone_pool(info->isolate()->allocator());
-  PipelineData data(&zone_pool, info, graph, schedule);
+  ZoneStats zone_stats(info->isolate()->allocator());
+  PipelineData data(&zone_stats, info, graph, schedule);
   std::unique_ptr<PipelineStatistics> pipeline_statistics;
   if (FLAG_turbo_stats || FLAG_turbo_stats_nvp) {
-    pipeline_statistics.reset(new PipelineStatistics(info, &zone_pool));
+    pipeline_statistics.reset(new PipelineStatistics(info, &zone_stats));
     pipeline_statistics->BeginPhaseKind("test codegen");
   }
 
@@ -1735,8 +1735,8 @@ bool Pipeline::AllocateRegistersForTesting(const RegisterConfiguration* config,
                                            bool run_verifier) {
   CompilationInfo info(ArrayVector("testing"), sequence->isolate(),
                        sequence->zone(), Code::ComputeFlags(Code::STUB));
-  ZonePool zone_pool(sequence->isolate()->allocator());
-  PipelineData data(&zone_pool, &info, sequence);
+  ZoneStats zone_stats(sequence->isolate()->allocator());
+  PipelineData data(&zone_stats, &info, sequence);
   PipelineImpl pipeline(&data);
   pipeline.data_->InitializeFrameData(nullptr);
   pipeline.AllocateRegisters(config, nullptr, run_verifier);

src/compiler/scheduler.h

@@ -9,7 +9,7 @@
 #include "src/compiler/node.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/schedule.h"
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 #include "src/zone/zone-containers.h"
 
 namespace v8 {

src/compiler/wasm-compiler.cc

@@ -25,7 +25,7 @@
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/source-position.h"
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 
 #include "src/code-factory.h"
 #include "src/code-stubs.h"

src/compiler/zone-pool.cc → src/compiler/zone-stats.cc

@@ -2,18 +2,18 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "src/compiler/zone-pool.h"
+#include "src/compiler/zone-stats.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-ZonePool::StatsScope::StatsScope(ZonePool* zone_pool)
-    : zone_pool_(zone_pool),
-      total_allocated_bytes_at_start_(zone_pool->GetTotalAllocatedBytes()),
+ZoneStats::StatsScope::StatsScope(ZoneStats* zone_stats)
+    : zone_stats_(zone_stats),
+      total_allocated_bytes_at_start_(zone_stats->GetTotalAllocatedBytes()),
       max_allocated_bytes_(0) {
-  zone_pool_->stats_.push_back(this);
-  for (Zone* zone : zone_pool_->used_) {
+  zone_stats_->stats_.push_back(this);
+  for (Zone* zone : zone_stats_->zones_) {
     size_t size = static_cast<size_t>(zone->allocation_size());
     std::pair<InitialValues::iterator, bool> res =
         initial_values_.insert(std::make_pair(zone, size));
@@ -22,21 +22,18 @@ ZonePool::StatsScope::StatsScope(ZonePool* zone_pool)
   }
 }
 
-
-ZonePool::StatsScope::~StatsScope() {
-  DCHECK_EQ(zone_pool_->stats_.back(), this);
-  zone_pool_->stats_.pop_back();
+ZoneStats::StatsScope::~StatsScope() {
+  DCHECK_EQ(zone_stats_->stats_.back(), this);
+  zone_stats_->stats_.pop_back();
 }
 
-
-size_t ZonePool::StatsScope::GetMaxAllocatedBytes() {
+size_t ZoneStats::StatsScope::GetMaxAllocatedBytes() {
   return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
 }
 
-
-size_t ZonePool::StatsScope::GetCurrentAllocatedBytes() {
+size_t ZoneStats::StatsScope::GetCurrentAllocatedBytes() {
   size_t total = 0;
-  for (Zone* zone : zone_pool_->used_) {
+  for (Zone* zone : zone_stats_->zones_) {
     total += static_cast<size_t>(zone->allocation_size());
     // Adjust for initial values.
     InitialValues::iterator it = initial_values_.find(zone);
@@ -47,13 +44,12 @@ size_t ZonePool::StatsScope::GetCurrentAllocatedBytes() {
   return total;
 }
 
-
-size_t ZonePool::StatsScope::GetTotalAllocatedBytes() {
-  return zone_pool_->GetTotalAllocatedBytes() - total_allocated_bytes_at_start_;
+size_t ZoneStats::StatsScope::GetTotalAllocatedBytes() {
+  return zone_stats_->GetTotalAllocatedBytes() -
+         total_allocated_bytes_at_start_;
 }
 
-
-void ZonePool::StatsScope::ZoneReturned(Zone* zone) {
+void ZoneStats::StatsScope::ZoneReturned(Zone* zone) {
   size_t current_total = GetCurrentAllocatedBytes();
   // Update max.
   max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
@@ -64,53 +60,37 @@ void ZonePool::StatsScope::ZoneReturned(Zone* zone) {
   }
 }
 
-ZonePool::ZonePool(AccountingAllocator* allocator)
+ZoneStats::ZoneStats(AccountingAllocator* allocator)
     : max_allocated_bytes_(0), total_deleted_bytes_(0), allocator_(allocator) {}
 
-ZonePool::~ZonePool() {
-  DCHECK(used_.empty());
+ZoneStats::~ZoneStats() {
+  DCHECK(zones_.empty());
   DCHECK(stats_.empty());
-  for (Zone* zone : unused_) {
-    delete zone;
-  }
 }
 
-
-size_t ZonePool::GetMaxAllocatedBytes() {
+size_t ZoneStats::GetMaxAllocatedBytes() {
   return std::max(max_allocated_bytes_, GetCurrentAllocatedBytes());
 }
 
-
-size_t ZonePool::GetCurrentAllocatedBytes() {
+size_t ZoneStats::GetCurrentAllocatedBytes() {
   size_t total = 0;
-  for (Zone* zone : used_) {
+  for (Zone* zone : zones_) {
     total += static_cast<size_t>(zone->allocation_size());
   }
   return total;
 }
 
-
-size_t ZonePool::GetTotalAllocatedBytes() {
+size_t ZoneStats::GetTotalAllocatedBytes() {
   return total_deleted_bytes_ + GetCurrentAllocatedBytes();
 }
 
-
-Zone* ZonePool::NewEmptyZone() {
-  Zone* zone;
-  // Grab a zone from pool if possible.
-  if (!unused_.empty()) {
-    zone = unused_.back();
-    unused_.pop_back();
-  } else {
-    zone = new Zone(allocator_);
-  }
-  used_.push_back(zone);
-  DCHECK_EQ(0u, zone->allocation_size());
+Zone* ZoneStats::NewEmptyZone() {
+  Zone* zone = new Zone(allocator_);
+  zones_.push_back(zone);
   return zone;
 }
 
-
-void ZonePool::ReturnZone(Zone* zone) {
+void ZoneStats::ReturnZone(Zone* zone) {
   size_t current_total = GetCurrentAllocatedBytes();
   // Update max.
   max_allocated_bytes_ = std::max(max_allocated_bytes_, current_total);
@@ -119,18 +99,11 @@ void ZonePool::ReturnZone(Zone* zone) {
     stat_scope->ZoneReturned(zone);
   }
   // Remove from used.
-  Used::iterator it = std::find(used_.begin(), used_.end(), zone);
-  DCHECK(it != used_.end());
-  used_.erase(it);
+  Zones::iterator it = std::find(zones_.begin(), zones_.end(), zone);
+  DCHECK(it != zones_.end());
+  zones_.erase(it);
   total_deleted_bytes_ += static_cast<size_t>(zone->allocation_size());
-  // Delete zone or clear and stash on unused_.
-  if (unused_.size() >= kMaxUnusedSize) {
   delete zone;
-  } else {
-    zone->DeleteAll();
-    DCHECK_EQ(0u, zone->allocation_size());
-    unused_.push_back(zone);
-  }
 }
 
 }  // namespace compiler

src/compiler/zone-pool.h → src/compiler/zone-stats.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef V8_COMPILER_ZONE_POOL_H_
-#define V8_COMPILER_ZONE_POOL_H_
+#ifndef V8_COMPILER_ZONE_STATS_H_
+#define V8_COMPILER_ZONE_STATS_H_
 
 #include <map>
 #include <set>
@@ -15,32 +15,32 @@ namespace v8 {
 namespace internal {
 namespace compiler {
 
-class ZonePool final {
+class ZoneStats final {
  public:
   class Scope final {
    public:
-    explicit Scope(ZonePool* zone_pool)
-        : zone_pool_(zone_pool), zone_(nullptr) {}
+    explicit Scope(ZoneStats* zone_stats)
+        : zone_stats_(zone_stats), zone_(nullptr) {}
     ~Scope() { Destroy(); }
 
     Zone* zone() {
-      if (zone_ == nullptr) zone_ = zone_pool_->NewEmptyZone();
+      if (zone_ == nullptr) zone_ = zone_stats_->NewEmptyZone();
       return zone_;
     }
     void Destroy() {
-      if (zone_ != nullptr) zone_pool_->ReturnZone(zone_);
+      if (zone_ != nullptr) zone_stats_->ReturnZone(zone_);
       zone_ = nullptr;
     }
 
    private:
-    ZonePool* const zone_pool_;
+    ZoneStats* const zone_stats_;
     Zone* zone_;
     DISALLOW_COPY_AND_ASSIGN(Scope);
   };
 
   class StatsScope final {
    public:
-    explicit StatsScope(ZonePool* zone_pool);
+    explicit StatsScope(ZoneStats* zone_stats);
     ~StatsScope();
 
     size_t GetMaxAllocatedBytes();
@@ -48,12 +48,12 @@ class ZonePool final {
     size_t GetTotalAllocatedBytes();
 
    private:
-    friend class ZonePool;
+    friend class ZoneStats;
     void ZoneReturned(Zone* zone);
 
     typedef std::map<Zone*, size_t> InitialValues;
 
-    ZonePool* const zone_pool_;
+    ZoneStats* const zone_stats_;
     InitialValues initial_values_;
     size_t total_allocated_bytes_at_start_;
     size_t max_allocated_bytes_;
@@ -61,8 +61,8 @@ class ZonePool final {
     DISALLOW_COPY_AND_ASSIGN(StatsScope);
   };
 
-  explicit ZonePool(AccountingAllocator* allocator);
-  ~ZonePool();
+  explicit ZoneStats(AccountingAllocator* allocator);
+  ~ZoneStats();
 
   size_t GetMaxAllocatedBytes();
   size_t GetTotalAllocatedBytes();
@@ -73,22 +73,20 @@ class ZonePool final {
   void ReturnZone(Zone* zone);
 
   static const size_t kMaxUnusedSize = 3;
-  typedef std::vector<Zone*> Unused;
-  typedef std::vector<Zone*> Used;
+  typedef std::vector<Zone*> Zones;
   typedef std::vector<StatsScope*> Stats;
 
-  Unused unused_;
-  Used used_;
+  Zones zones_;
   Stats stats_;
   size_t max_allocated_bytes_;
   size_t total_deleted_bytes_;
   AccountingAllocator* allocator_;
 
-  DISALLOW_COPY_AND_ASSIGN(ZonePool);
+  DISALLOW_COPY_AND_ASSIGN(ZoneStats);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
-#endif
+#endif  // V8_COMPILER_ZONE_STATS_H_

src/isolate.cc

@@ -1972,7 +1972,6 @@ Isolate::Isolate(bool enable_serializer)
       allocator_(FLAG_trace_gc_object_stats
                      ? new VerboseAccountingAllocator(&heap_, 256 * KB)
                      : new AccountingAllocator()),
-      runtime_zone_(new Zone(allocator_)),
       inner_pointer_to_code_cache_(NULL),
       global_handles_(NULL),
       eternal_handles_(NULL),
@@ -2245,9 +2244,6 @@ Isolate::~Isolate() {
   delete cancelable_task_manager_;
   cancelable_task_manager_ = nullptr;
 
-  delete runtime_zone_;
-  runtime_zone_ = nullptr;
-
   delete allocator_;
   allocator_ = nullptr;
 

src/isolate.h

@@ -885,7 +885,6 @@ class Isolate {
     DCHECK(handle_scope_implementer_);
     return handle_scope_implementer_;
   }
-  Zone* runtime_zone() { return runtime_zone_; }
 
   UnicodeCache* unicode_cache() {
     return unicode_cache_;
@@ -1331,7 +1330,6 @@ class Isolate {
   HandleScopeImplementer* handle_scope_implementer_;
   UnicodeCache* unicode_cache_;
   AccountingAllocator* allocator_;
-  Zone* runtime_zone_;
   InnerPointerToCodeCache* inner_pointer_to_code_cache_;
   GlobalHandles* global_handles_;
   EternalHandles* eternal_handles_;

src/runtime/runtime-regexp.cc

@@ -393,8 +393,8 @@ MUST_USE_RESULT static Object* StringReplaceGlobalAtomRegExpWithString(
   DCHECK(subject->IsFlat());
   DCHECK(replacement->IsFlat());
 
-  ZoneScope zone_scope(isolate->runtime_zone());
-  ZoneList<int> indices(8, zone_scope.zone());
+  Zone zone(isolate->allocator());
+  ZoneList<int> indices(8, &zone);
   DCHECK_EQ(JSRegExp::ATOM, pattern_regexp->TypeTag());
   String* pattern =
       String::cast(pattern_regexp->DataAt(JSRegExp::kAtomPatternIndex));
@@ -403,7 +403,7 @@ MUST_USE_RESULT static Object* StringReplaceGlobalAtomRegExpWithString(
   int replacement_len = replacement->length();
 
   FindStringIndicesDispatch(isolate, *subject, pattern, &indices, 0xffffffff,
-                            zone_scope.zone());
+                            &zone);
 
   int matches = indices.length();
   if (matches == 0) return *subject;
@@ -474,8 +474,8 @@ MUST_USE_RESULT static Object* StringReplaceGlobalRegExpWithString(
   int subject_length = subject->length();
 
   // CompiledReplacement uses zone allocation.
-  ZoneScope zone_scope(isolate->runtime_zone());
-  CompiledReplacement compiled_replacement(zone_scope.zone());
+  Zone zone(isolate->allocator());
+  CompiledReplacement compiled_replacement(&zone);
   bool simple_replace =
       compiled_replacement.Compile(replacement, capture_count, subject_length);
 
@@ -711,17 +711,17 @@ RUNTIME_FUNCTION(Runtime_StringSplit) {
 
   static const int kMaxInitialListCapacity = 16;
 
-  ZoneScope zone_scope(isolate->runtime_zone());
+  Zone zone(isolate->allocator());
 
   // Find (up to limit) indices of separator and end-of-string in subject
   int initial_capacity = Min<uint32_t>(kMaxInitialListCapacity, limit);
-  ZoneList<int> indices(initial_capacity, zone_scope.zone());
+  ZoneList<int> indices(initial_capacity, &zone);
 
   FindStringIndicesDispatch(isolate, *subject, *pattern, &indices, limit,
-                            zone_scope.zone());
+                            &zone);
 
   if (static_cast<uint32_t>(indices.length()) < limit) {
-    indices.Add(subject_length, zone_scope.zone());
+    indices.Add(subject_length, &zone);
   }
 
   // The list indices now contains the end of each part to create.

src/runtime/runtime-strings.cc

@@ -181,14 +181,14 @@ RUNTIME_FUNCTION(Runtime_StringMatch) {
 
   int capture_count = regexp->CaptureCount();
 
-  ZoneScope zone_scope(isolate->runtime_zone());
-  ZoneList<int> offsets(8, zone_scope.zone());
+  Zone zone(isolate->allocator());
+  ZoneList<int> offsets(8, &zone);
 
   while (true) {
     int32_t* match = global_cache.FetchNext();
     if (match == NULL) break;
-    offsets.Add(match[0], zone_scope.zone());  // start
-    offsets.Add(match[1], zone_scope.zone());  // end
+    offsets.Add(match[0], &zone);  // start
+    offsets.Add(match[1], &zone);  // end
   }
 
   if (global_cache.HasException()) return isolate->heap()->exception();

src/v8.gyp

@@ -738,8 +738,8 @@
         'compiler/wasm-compiler.cc',
         'compiler/wasm-compiler.h',
         'compiler/wasm-linkage.cc',
-        'compiler/zone-pool.cc',
-        'compiler/zone-pool.h',
+        'compiler/zone-stats.cc',
+        'compiler/zone-stats.h',
         'compiler-dispatcher/compiler-dispatcher-job.cc',
         'compiler-dispatcher/compiler-dispatcher-job.h',
         'compiler-dispatcher/optimizing-compile-dispatcher.cc',

src/zone/zone.cc

@@ -105,9 +105,7 @@ void Zone::DeleteAll() {
   }
 
   position_ = limit_ = 0;
-
   allocation_size_ = 0;
-  // Update the head segment to be the kept segment (if any).
   segment_head_ = nullptr;
 }
 

src/zone/zone.h

@@ -44,9 +44,6 @@ class Zone final {
     return static_cast<T*>(New(length * sizeof(T)));
   }
 
-  // Deletes all objects and free all memory allocated in the Zone.
-  void DeleteAll();
-
   // Returns true if more memory has been allocated in zones than
   // the limit allows.
   bool excess_allocation() const {
@@ -77,6 +74,9 @@ class Zone final {
   // Report zone excess when allocation exceeds this limit.
   static const size_t kExcessLimit = 256 * MB;
 
+  // Deletes all objects and free all memory allocated in the Zone.
+  void DeleteAll();
+
   // The number of bytes allocated in this zone so far.
   size_t allocation_size_;
 
@@ -125,19 +125,6 @@ class ZoneObject {
   void operator delete(void* pointer, Zone* zone) { UNREACHABLE(); }
 };
 
-// The ZoneScope is used to automatically call DeleteAll() on a
-// Zone when the ZoneScope is destroyed (i.e. goes out of scope)
-class ZoneScope final {
- public:
-  explicit ZoneScope(Zone* zone) : zone_(zone) {}
-  ~ZoneScope() { zone_->DeleteAll(); }
-
-  Zone* zone() const { return zone_; }
-
- private:
-  Zone* zone_;
-};
-
 // The ZoneAllocationPolicy is used to specialize generic data
 // structures to allocate themselves and their elements in the Zone.
 class ZoneAllocationPolicy final {

test/cctest/wasm/wasm-run-utils.h

@@ -8,7 +8,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
-
 #include <memory>
 
 #include "src/base/utils/random-number-generator.h"
@@ -20,8 +19,7 @@
 #include "src/compiler/node.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/wasm-compiler.h"
-#include "src/compiler/zone-pool.h"
-
+#include "src/compiler/zone-stats.h"
 #include "src/wasm/ast-decoder.h"
 #include "src/wasm/wasm-interpreter.h"
 #include "src/wasm/wasm-js.h"

test/unittests/BUILD.gn

@@ -82,7 +82,7 @@ v8_executable("unittests") {
     "compiler/typed-optimization-unittest.cc",
     "compiler/typer-unittest.cc",
     "compiler/value-numbering-reducer-unittest.cc",
-    "compiler/zone-pool-unittest.cc",
+    "compiler/zone-stats-unittest.cc",
     "counters-unittest.cc",
     "eh-frame-iterator-unittest.cc",
     "eh-frame-writer-unittest.cc",

test/unittests/compiler/zone-pool-unittest.cc → test/unittests/compiler/zone-stats-unittest.cc

@@ -2,28 +2,28 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/compiler/zone-stats.h"
 #include "src/base/utils/random-number-generator.h"
-#include "src/compiler/zone-pool.h"
 #include "test/unittests/test-utils.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-class ZonePoolTest : public TestWithIsolate {
+class ZoneStatsTest : public TestWithIsolate {
  public:
-  ZonePoolTest() : zone_pool_(&allocator_) {}
+  ZoneStatsTest() : zone_stats_(&allocator_) {}
 
  protected:
-  ZonePool* zone_pool() { return &zone_pool_; }
+  ZoneStats* zone_stats() { return &zone_stats_; }
 
   void ExpectForPool(size_t current, size_t max, size_t total) {
-    ASSERT_EQ(current, zone_pool()->GetCurrentAllocatedBytes());
-    ASSERT_EQ(max, zone_pool()->GetMaxAllocatedBytes());
-    ASSERT_EQ(total, zone_pool()->GetTotalAllocatedBytes());
+    ASSERT_EQ(current, zone_stats()->GetCurrentAllocatedBytes());
+    ASSERT_EQ(max, zone_stats()->GetMaxAllocatedBytes());
+    ASSERT_EQ(total, zone_stats()->GetTotalAllocatedBytes());
   }
 
-  void Expect(ZonePool::StatsScope* stats, size_t current, size_t max,
+  void Expect(ZoneStats::StatsScope* stats, size_t current, size_t max,
               size_t total) {
     ASSERT_EQ(current, stats->GetCurrentAllocatedBytes());
     ASSERT_EQ(max, stats->GetMaxAllocatedBytes());
@@ -39,41 +39,39 @@ class ZonePoolTest : public TestWithIsolate {
 
  private:
   v8::internal::AccountingAllocator allocator_;
-  ZonePool zone_pool_;
+  ZoneStats zone_stats_;
   base::RandomNumberGenerator rng;
 };
 
-
-TEST_F(ZonePoolTest, Empty) {
+TEST_F(ZoneStatsTest, Empty) {
   ExpectForPool(0, 0, 0);
   {
-    ZonePool::StatsScope stats(zone_pool());
+    ZoneStats::StatsScope stats(zone_stats());
     Expect(&stats, 0, 0, 0);
   }
   ExpectForPool(0, 0, 0);
   {
-    ZonePool::Scope scope(zone_pool());
+    ZoneStats::Scope scope(zone_stats());
     scope.zone();
   }
   ExpectForPool(0, 0, 0);
 }
 
-
-TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
+TEST_F(ZoneStatsTest, MultipleZonesWithDeletion) {
   static const size_t kArraySize = 10;
 
-  ZonePool::Scope* scopes[kArraySize];
+  ZoneStats::Scope* scopes[kArraySize];
 
   // Initialize.
   size_t before_stats = 0;
   for (size_t i = 0; i < kArraySize; ++i) {
-    scopes[i] = new ZonePool::Scope(zone_pool());
+    scopes[i] = new ZoneStats::Scope(zone_stats());
     before_stats += Allocate(scopes[i]->zone());  // Add some stuff.
   }
 
   ExpectForPool(before_stats, before_stats, before_stats);
 
-  ZonePool::StatsScope stats(zone_pool());
+  ZoneStats::StatsScope stats(zone_stats());
 
   size_t before_deletion = 0;
   for (size_t i = 0; i < kArraySize; ++i) {
@@ -87,7 +85,7 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
   // Delete the scopes and create new ones.
   for (size_t i = 0; i < kArraySize; ++i) {
     delete scopes[i];
-    scopes[i] = new ZonePool::Scope(zone_pool());
+    scopes[i] = new ZoneStats::Scope(zone_stats());
   }
 
   Expect(&stats, 0, before_deletion, before_deletion);
@@ -116,14 +114,13 @@ TEST_F(ZonePoolTest, MultipleZonesWithDeletion) {
                 before_stats + before_deletion + after_deletion);
 }
 
-
-TEST_F(ZonePoolTest, SimpleAllocationLoop) {
+TEST_F(ZoneStatsTest, SimpleAllocationLoop) {
   int runs = 20;
   size_t total_allocated = 0;
   size_t max_loop_allocation = 0;
-  ZonePool::StatsScope outer_stats(zone_pool());
+  ZoneStats::StatsScope outer_stats(zone_stats());
   {
-    ZonePool::Scope outer_scope(zone_pool());
+    ZoneStats::Scope outer_scope(zone_stats());
     size_t outer_allocated = 0;
     for (int i = 0; i < runs; ++i) {
       {
@@ -131,10 +128,10 @@ TEST_F(ZonePoolTest, SimpleAllocationLoop) {
         outer_allocated += bytes;
         total_allocated += bytes;
       }
-      ZonePool::StatsScope inner_stats(zone_pool());
+      ZoneStats::StatsScope inner_stats(zone_stats());
       size_t allocated = 0;
       {
-        ZonePool::Scope inner_scope(zone_pool());
+        ZoneStats::Scope inner_scope(zone_stats());
         for (int j = 0; j < 20; ++j) {
           size_t bytes = Allocate(inner_scope.zone());
           allocated += bytes;

test/unittests/unittests.gyp

@@ -79,7 +79,7 @@
       'compiler/typed-optimization-unittest.cc',
       'compiler/typer-unittest.cc',
       'compiler/value-numbering-reducer-unittest.cc',
-      'compiler/zone-pool-unittest.cc',
+      'compiler/zone-stats-unittest.cc',
       'compiler-dispatcher/compiler-dispatcher-job-unittest.cc',
       'counters-unittest.cc',
       'eh-frame-iterator-unittest.cc',