From Jason Turner

[mem.res.pool.overview]

C++17 → C++20 3.1 KB 21 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game
C++ Weekly: Ep 248

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpuykoknth/{from.md → to.md} +6 -8
tmp/tmpuykoknth/{from.md → to.md} RENAMED
@@ -30,19 +30,19 @@ without external synchronization and may have thread-specific pools to
30
  reduce synchronization costs. An `unsynchronized_pool_resource` class
31
  may not be accessed from multiple threads simultaneously and thus avoids
32
  the cost of synchronization entirely in single-threaded applications.
33
 
34
  ``` cpp
 
35
  struct pool_options {
36
  size_t max_blocks_per_chunk = 0;
37
  size_t largest_required_pool_block = 0;
38
  };
39
 
40
  class synchronized_pool_resource : public memory_resource {
41
  public:
42
- synchronized_pool_resource(const pool_options& opts,
43
- memory_resource* upstream);
44
 
45
  synchronized_pool_resource()
46
  : synchronized_pool_resource(pool_options(), get_default_resource()) {}
47
  explicit synchronized_pool_resource(memory_resource* upstream)
48
  : synchronized_pool_resource(pool_options(), upstream) {}
@@ -50,12 +50,11 @@ public:
50
  : synchronized_pool_resource(opts, get_default_resource()) {}
51
 
52
  synchronized_pool_resource(const synchronized_pool_resource&) = delete;
53
  virtual ~synchronized_pool_resource();
54
 
55
- synchronized_pool_resource&
56
- operator=(const synchronized_pool_resource&) = delete;
57
 
58
  void release();
59
  memory_resource* upstream_resource() const;
60
  pool_options options() const;
61
 
@@ -66,12 +65,11 @@ protected:
66
  bool do_is_equal(const memory_resource& other) const noexcept override;
67
  };
68
 
69
  class unsynchronized_pool_resource : public memory_resource {
70
  public:
71
- unsynchronized_pool_resource(const pool_options& opts,
72
- memory_resource* upstream);
73
 
74
  unsynchronized_pool_resource()
75
  : unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
76
  explicit unsynchronized_pool_resource(memory_resource* upstream)
77
  : unsynchronized_pool_resource(pool_options(), upstream) {}
@@ -79,12 +77,11 @@ public:
79
  : unsynchronized_pool_resource(opts, get_default_resource()) {}
80
 
81
  unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
82
  virtual ~unsynchronized_pool_resource();
83
 
84
- unsynchronized_pool_resource&
85
- operator=(const unsynchronized_pool_resource&) = delete;
86
 
87
  void release();
88
  memory_resource* upstream_resource() const;
89
  pool_options options() const;
90
 
@@ -92,7 +89,8 @@ protected:
92
  void* do_allocate(size_t bytes, size_t alignment) override;
93
  void do_deallocate(void* p, size_t bytes, size_t alignment) override;
94
 
95
  bool do_is_equal(const memory_resource& other) const noexcept override;
96
  };
 
97
  ```
98
 
 
30
  reduce synchronization costs. An `unsynchronized_pool_resource` class
31
  may not be accessed from multiple threads simultaneously and thus avoids
32
  the cost of synchronization entirely in single-threaded applications.
33
 
34
  ``` cpp
35
+ namespace std::pmr {
36
  struct pool_options {
37
  size_t max_blocks_per_chunk = 0;
38
  size_t largest_required_pool_block = 0;
39
  };
40
 
41
  class synchronized_pool_resource : public memory_resource {
42
  public:
43
+ synchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
 
44
 
45
  synchronized_pool_resource()
46
  : synchronized_pool_resource(pool_options(), get_default_resource()) {}
47
  explicit synchronized_pool_resource(memory_resource* upstream)
48
  : synchronized_pool_resource(pool_options(), upstream) {}
 
50
  : synchronized_pool_resource(opts, get_default_resource()) {}
51
 
52
  synchronized_pool_resource(const synchronized_pool_resource&) = delete;
53
  virtual ~synchronized_pool_resource();
54
 
55
+ synchronized_pool_resource& operator=(const synchronized_pool_resource&) = delete;
 
56
 
57
  void release();
58
  memory_resource* upstream_resource() const;
59
  pool_options options() const;
60
 
 
65
  bool do_is_equal(const memory_resource& other) const noexcept override;
66
  };
67
 
68
  class unsynchronized_pool_resource : public memory_resource {
69
  public:
70
+ unsynchronized_pool_resource(const pool_options& opts, memory_resource* upstream);
 
71
 
72
  unsynchronized_pool_resource()
73
  : unsynchronized_pool_resource(pool_options(), get_default_resource()) {}
74
  explicit unsynchronized_pool_resource(memory_resource* upstream)
75
  : unsynchronized_pool_resource(pool_options(), upstream) {}
 
77
  : unsynchronized_pool_resource(opts, get_default_resource()) {}
78
 
79
  unsynchronized_pool_resource(const unsynchronized_pool_resource&) = delete;
80
  virtual ~unsynchronized_pool_resource();
81
 
82
+ unsynchronized_pool_resource& operator=(const unsynchronized_pool_resource&) = delete;
 
83
 
84
  void release();
85
  memory_resource* upstream_resource() const;
86
  pool_options options() const;
87
 
 
89
  void* do_allocate(size_t bytes, size_t alignment) override;
90
  void do_deallocate(void* p, size_t bytes, size_t alignment) override;
91
 
92
  bool do_is_equal(const memory_resource& other) const noexcept override;
93
  };
94
+ }
95
  ```
96