23 General utilities library [utilities]

• (1.1)
  A call to deallocate has no effect, thus the amount of memory consumed increases monotonically until the resource is destroyed.
• (1.2)
  The program can supply an initial buffer, which the allocator uses to satisfy memory requests.
• (1.3)
  When the initial buffer (if any) is exhausted, it obtains additional buffers from an upstream memory resource supplied at construction.
  Each additional buffer is larger than the previous one, following a geometric progression.
• (1.4)
  It is intended for access from one thread of control at a time.
  Specifically, calls to allocate and deallocate do not synchronize with one another.
• (1.5)
  It frees the allocated memory on destruction, even if deallocate has not been called for some of the allocated blocks.

class monotonic_buffer_resource : public memory_resource {
  memory_resource *upstream_rsrc; // exposition only
  void *current_buffer;           // exposition only
  size_t next_buffer_size;        // exposition only

public:
  explicit monotonic_buffer_resource(memory_resource *upstream);
  monotonic_buffer_resource(size_t initial_size, memory_resource *upstream);
  monotonic_buffer_resource(void *buffer, size_t buffer_size,
                            memory_resource *upstream);

  monotonic_buffer_resource()
      : monotonic_buffer_resource(get_default_resource()) {}
  explicit monotonic_buffer_resource(size_t initial_size)
      : monotonic_buffer_resource(initial_size, get_default_resource()) {}
  monotonic_buffer_resource(void *buffer, size_t buffer_size)
      : monotonic_buffer_resource(buffer, buffer_size, get_default_resource()) {}

  monotonic_buffer_resource(const monotonic_buffer_resource&) = delete;

  virtual ~monotonic_buffer_resource();

  monotonic_buffer_resource
    operator=(const monotonic_buffer_resource&) = delete;

  void release();
  memory_resource* upstream_resource() const;

protected:
  void* do_allocate(size_t bytes, size_t alignment) override;
  void do_deallocate(void* p, size_t bytes, size_t alignment) override;

  bool do_is_equal(const memory_resource& other) const noexcept override;
};