lin
2025-07-30 fcd736bf35fd93b563e9bbf594f2aa7b62028cc9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
// 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.
 
#ifndef V8_COMPILER_ZONE_STATS_H_
#define V8_COMPILER_ZONE_STATS_H_
 
#include <map>
#include <set>
#include <vector>
 
#include "src/globals.h"
#include "src/zone/zone.h"
 
namespace v8 {
namespace internal {
namespace compiler {
 
class V8_EXPORT_PRIVATE ZoneStats final {
 public:
  class Scope final {
   public:
    explicit Scope(ZoneStats* zone_stats, const char* zone_name)
        : zone_name_(zone_name), zone_stats_(zone_stats), zone_(nullptr) {}
    ~Scope() { Destroy(); }
 
    Zone* zone() {
      if (zone_ == nullptr) zone_ = zone_stats_->NewEmptyZone(zone_name_);
      return zone_;
    }
    void Destroy() {
      if (zone_ != nullptr) zone_stats_->ReturnZone(zone_);
      zone_ = nullptr;
    }
 
   private:
    const char* zone_name_;
    ZoneStats* const zone_stats_;
    Zone* zone_;
    DISALLOW_COPY_AND_ASSIGN(Scope);
  };
 
  class V8_EXPORT_PRIVATE StatsScope final {
   public:
    explicit StatsScope(ZoneStats* zone_stats);
    ~StatsScope();
 
    size_t GetMaxAllocatedBytes();
    size_t GetCurrentAllocatedBytes();
    size_t GetTotalAllocatedBytes();
 
   private:
    friend class ZoneStats;
    void ZoneReturned(Zone* zone);
 
    typedef std::map<Zone*, size_t> InitialValues;
 
    ZoneStats* const zone_stats_;
    InitialValues initial_values_;
    size_t total_allocated_bytes_at_start_;
    size_t max_allocated_bytes_;
 
    DISALLOW_COPY_AND_ASSIGN(StatsScope);
  };
 
  explicit ZoneStats(AccountingAllocator* allocator);
  ~ZoneStats();
 
  size_t GetMaxAllocatedBytes() const;
  size_t GetTotalAllocatedBytes() const;
  size_t GetCurrentAllocatedBytes() const;
 
 private:
  Zone* NewEmptyZone(const char* zone_name);
  void ReturnZone(Zone* zone);
 
  static const size_t kMaxUnusedSize = 3;
  typedef std::vector<Zone*> Zones;
  typedef std::vector<StatsScope*> Stats;
 
  Zones zones_;
  Stats stats_;
  size_t max_allocated_bytes_;
  size_t total_deleted_bytes_;
  AccountingAllocator* allocator_;
 
  DISALLOW_COPY_AND_ASSIGN(ZoneStats);
};
 
}  // namespace compiler
}  // namespace internal
}  // namespace v8
 
#endif  // V8_COMPILER_ZONE_STATS_H_