Line data    Source code

       1             : // Copyright (c) 2011 The LevelDB 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. See the AUTHORS file for names of contributors.
       4             : 
       5             : #ifndef STORAGE_LEVELDB_UTIL_ARENA_H_
       6             : #define STORAGE_LEVELDB_UTIL_ARENA_H_
       7             : 
       8             : #include <vector>
       9             : #include <assert.h>
      10             : #include <stddef.h>
      11             : #include <stdint.h>
      12             : 
      13             : namespace leveldb {
      14             : 
      15             : class Arena {
      16             :  public:
      17             :   Arena();
      18             :   ~Arena();
      19             : 
      20             :   // Return a pointer to a newly allocated memory block of "bytes" bytes.
      21             :   char* Allocate(size_t bytes);
      22             : 
      23             :   // Allocate memory with the normal alignment guarantees provided by malloc
      24             :   char* AllocateAligned(size_t bytes);
      25             : 
      26             :   // Returns an estimate of the total memory usage of data allocated
      27             :   // by the arena (including space allocated but not yet used for user
      28             :   // allocations).
      29             :   size_t MemoryUsage() const {
      30        1668 :     return blocks_memory_ + blocks_.capacity() * sizeof(char*);
      31             :   }
      32             : 
      33             :  private:
      34             :   char* AllocateFallback(size_t bytes);
      35             :   char* AllocateNewBlock(size_t block_bytes);
      36             : 
      37             :   // Allocation state
      38             :   char* alloc_ptr_;
      39             :   size_t alloc_bytes_remaining_;
      40             : 
      41             :   // Array of new[] allocated memory blocks
      42             :   std::vector<char*> blocks_;
      43             : 
      44             :   // Bytes of memory in blocks allocated so far
      45             :   size_t blocks_memory_;
      46             : 
      47             :   // No copying allowed
      48             :   Arena(const Arena&);
      49             :   void operator=(const Arena&);
      50             : };
      51             : 
      52       28549 : inline char* Arena::Allocate(size_t bytes) {
      53             :   // The semantics of what to return are a bit messy if we allow
      54             :   // 0-byte allocations, so we disallow them here (we don't need
      55             :   // them for our internal use).
      56       28549 :   assert(bytes > 0);
      57       28549 :   if (bytes <= alloc_bytes_remaining_) {
      58       27797 :     char* result = alloc_ptr_;
      59       27797 :     alloc_ptr_ += bytes;
      60       27797 :     alloc_bytes_remaining_ -= bytes;
      61       27797 :     return result;
      62             :   }
      63         752 :   return AllocateFallback(bytes);
      64             : }
      65             : 
      66             : }  // namespace leveldb
      67             : 
      68             : #endif  // STORAGE_LEVELDB_UTIL_ARENA_H_