gpu/command_buffer/client/mapped_memory.h

   1 // Copyright (c) 2012 The Chromium 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.
   4
   5 #ifndef GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
   6 #define GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
   7
   8 #include "base/memory/scoped_vector.h"
   9 #include "gpu/command_buffer/client/fenced_allocator.h"
  10 #include "gpu/command_buffer/common/buffer.h"
  11 #include "gpu/command_buffer/common/types.h"
  12 #include "gpu/gpu_export.h"
  13
  14 namespace gpu {
  15
  16 class CommandBufferHelper;
  17
  18 // Manages a shared memory segment.
  19 class GPU_EXPORT MemoryChunk {
  20  public:
  21   MemoryChunk(int32 shm_id, gpu::Buffer shm, CommandBufferHelper* helper);
  22
  23   // Gets the size of the largest free block that is available without waiting.
  24   unsigned int GetLargestFreeSizeWithoutWaiting() {
  25     return allocator_.GetLargestFreeSize();
  26   }
  27
  28   // Gets the size of the largest free block that can be allocated if the
  29   // caller can wait.
  30   unsigned int GetLargestFreeSizeWithWaiting() {
  31     return allocator_.GetLargestFreeOrPendingSize();
  32   }
  33
  34   // Gets the size of the chunk.
  35   unsigned int GetSize() const {
  36     return shm_.size;
  37   }
  38
  39   // The shared memory id for this chunk.
  40   int32 shm_id() const {
  41     return shm_id_;
  42   }
  43
  44   // Allocates a block of memory. If the buffer is out of directly available
  45   // memory, this function may wait until memory that was freed "pending a
  46   // token" can be re-used.
  47   //
  48   // Parameters:
  49   //   size: the size of the memory block to allocate.
  50   //
  51   // Returns:
  52   //   the pointer to the allocated memory block, or NULL if out of
  53   //   memory.
  54   void* Alloc(unsigned int size) {
  55     return allocator_.Alloc(size);
  56   }
  57
  58   // Gets the offset to a memory block given the base memory and the address.
  59   // It translates NULL to FencedAllocator::kInvalidOffset.
  60   unsigned int GetOffset(void* pointer) {
  61     return allocator_.GetOffset(pointer);
  62   }
  63
  64   // Frees a block of memory.
  65   //
  66   // Parameters:
  67   //   pointer: the pointer to the memory block to free.
  68   void Free(void* pointer) {
  69     allocator_.Free(pointer);
  70   }
  71
  72   // Frees a block of memory, pending the passage of a token. That memory won't
  73   // be re-allocated until the token has passed through the command stream.
  74   //
  75   // Parameters:
  76   //   pointer: the pointer to the memory block to free.
  77   //   token: the token value to wait for before re-using the memory.
  78   void FreePendingToken(void* pointer, unsigned int token) {
  79     allocator_.FreePendingToken(pointer, token);
  80   }
  81
  82   // Frees any blocks whose tokens have passed.
  83   void FreeUnused() {
  84     allocator_.FreeUnused();
  85   }
  86
  87   // Returns true if pointer is in the range of this block.
  88   bool IsInChunk(void* pointer) const {
  89     return pointer >= shm_.ptr &&
  90            pointer < reinterpret_cast<const int8*>(shm_.ptr) + shm_.size;
  91   }
  92
  93   // Returns true of any memory in this chunk is in use.
  94   bool InUse() {
  95     return allocator_.InUse();
  96   }
  97
  98   size_t bytes_in_use() const {
  99     return allocator_.bytes_in_use();
 100   }
 101
 102  private:
 103   int32 shm_id_;
 104   gpu::Buffer shm_;
 105   FencedAllocatorWrapper allocator_;
 106
 107   DISALLOW_COPY_AND_ASSIGN(MemoryChunk);
 108 };
 109
 110 // Manages MemoryChunks.
 111 class GPU_EXPORT MappedMemoryManager {
 112  public:
 113   enum MemoryLimit {
 114     kNoLimit = 0,
 115   };
 116
 117   // |unused_memory_reclaim_limit|: When exceeded this causes pending memory
 118   // to be reclaimed before allocating more memory.
 119   MappedMemoryManager(CommandBufferHelper* helper,
 120                       size_t unused_memory_reclaim_limit);
 121
 122   ~MappedMemoryManager();
 123
 124   unsigned int chunk_size_multiple() const {
 125     return chunk_size_multiple_;
 126   }
 127
 128   void set_chunk_size_multiple(unsigned int multiple) {
 129     chunk_size_multiple_ = multiple;
 130   }
 131
 132   // Allocates a block of memory
 133   // Parameters:
 134   //   size: size of memory to allocate.
 135   //   shm_id: pointer to variable to receive the shared memory id.
 136   //   shm_offset: pointer to variable to receive the shared memory offset.
 137   // Returns:
 138   //   pointer to allocated block of memory. NULL if failure.
 139   void* Alloc(
 140       unsigned int size, int32* shm_id, unsigned int* shm_offset);
 141
 142   // Frees a block of memory.
 143   //
 144   // Parameters:
 145   //   pointer: the pointer to the memory block to free.
 146   void Free(void* pointer);
 147
 148   // Frees a block of memory, pending the passage of a token. That memory won't
 149   // be re-allocated until the token has passed through the command stream.
 150   //
 151   // Parameters:
 152   //   pointer: the pointer to the memory block to free.
 153   //   token: the token value to wait for before re-using the memory.
 154   void FreePendingToken(void* pointer, int32 token);
 155
 156   // Free Any Shared memory that is not in use.
 157   void FreeUnused();
 158
 159   // Used for testing
 160   size_t num_chunks() const {
 161     return chunks_.size();
 162   }
 163
 164   // Used for testing
 165   size_t allocated_memory() const {
 166     return allocated_memory_;
 167   }
 168
 169  private:
 170   typedef ScopedVector<MemoryChunk> MemoryChunkVector;
 171
 172   // size a chunk is rounded up to.
 173   unsigned int chunk_size_multiple_;
 174   CommandBufferHelper* helper_;
 175   MemoryChunkVector chunks_;
 176   size_t allocated_memory_;
 177   size_t max_free_bytes_;
 178
 179   DISALLOW_COPY_AND_ASSIGN(MappedMemoryManager);
 180 };
 181
 182 }  // namespace gpu
 183
 184 #endif  // GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_
 185