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 14namespace gpu { 15 16class CommandBufferHelper; 17 18// Manages a shared memory segment. 19class 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 who's 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 chuck is in use. 94 bool InUse() { 95 return allocator_.InUse(); 96 } 97 98 private: 99 int32 shm_id_; 100 gpu::Buffer shm_; 101 FencedAllocatorWrapper allocator_; 102 103 DISALLOW_COPY_AND_ASSIGN(MemoryChunk); 104}; 105 106// Manages MemoryChucks. 107class GPU_EXPORT MappedMemoryManager { 108 public: 109 explicit MappedMemoryManager(CommandBufferHelper* helper); 110 111 ~MappedMemoryManager(); 112 113 unsigned int chunk_size_multiple() const { 114 return chunk_size_multiple_; 115 } 116 117 void set_chunk_size_multiple(unsigned int multiple) { 118 chunk_size_multiple_ = multiple; 119 } 120 121 // Allocates a block of memory 122 // Parameters: 123 // size: size of memory to allocate. 124 // shm_id: pointer to variable to receive the shared memory id. 125 // shm_offset: pointer to variable to receive the shared memory offset. 126 // Returns: 127 // pointer to allocated block of memory. NULL if failure. 128 void* Alloc( 129 unsigned int size, int32* shm_id, unsigned int* shm_offset); 130 131 // Frees a block of memory. 132 // 133 // Parameters: 134 // pointer: the pointer to the memory block to free. 135 void Free(void* pointer); 136 137 // Frees a block of memory, pending the passage of a token. That memory won't 138 // be re-allocated until the token has passed through the command stream. 139 // 140 // Parameters: 141 // pointer: the pointer to the memory block to free. 142 // token: the token value to wait for before re-using the memory. 143 void FreePendingToken(void* pointer, int32 token); 144 145 // Free Any Shared memory that is not in use. 146 void FreeUnused(); 147 148 // Used for testing 149 size_t num_chunks() { 150 return chunks_.size(); 151 } 152 153 private: 154 typedef ScopedVector<MemoryChunk> MemoryChunkVector; 155 156 // size a chunk is rounded up to. 157 unsigned int chunk_size_multiple_; 158 CommandBufferHelper* helper_; 159 MemoryChunkVector chunks_; 160 161 DISALLOW_COPY_AND_ASSIGN(MappedMemoryManager); 162}; 163 164} // namespace gpu 165 166#endif // GPU_COMMAND_BUFFER_CLIENT_MAPPED_MEMORY_H_ 167 168