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.
5 // This file contains the definition of the RingBuffer class.
7 #ifndef GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
8 #define GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
12 #include "base/logging.h"
13 #include "base/macros.h"
14 #include "gpu/gpu_export.h"
17 class CommandBufferHelper;
19 // RingBuffer manages a piece of memory as a ring buffer. Memory is allocated
20 // with Alloc and then a is freed pending a token with FreePendingToken. Old
21 // allocations must not be kept past new allocations.
22 class GPU_EXPORT RingBuffer {
24 typedef unsigned int Offset;
26 // Creates a RingBuffer.
28 // alignment: Alignment for allocations.
29 // base_offset: The offset of the start of the buffer.
30 // size: The size of the buffer in bytes.
31 // helper: A CommandBufferHelper for dealing with tokens.
32 // base: The physical address that corresponds to base_offset.
33 RingBuffer(unsigned int alignment, Offset base_offset,
34 unsigned int size, CommandBufferHelper* helper, void* base);
38 // Allocates a block of memory. If the buffer is out of directly available
39 // memory, this function may wait until memory that was freed "pending a
40 // token" can be re-used.
43 // size: the size of the memory block to allocate.
46 // the pointer to the allocated memory block.
47 void* Alloc(unsigned int size);
49 // Frees a block of memory, pending the passage of a token. That memory won't
50 // be re-allocated until the token has passed through the command stream.
53 // pointer: the pointer to the memory block to free.
54 // token: the token value to wait for before re-using the memory.
55 void FreePendingToken(void* pointer, unsigned int token);
57 // Gets the size of the largest free block that is available without waiting.
58 unsigned int GetLargestFreeSizeNoWaiting();
60 // Gets the size of the largest free block that can be allocated if the
61 // caller can wait. Allocating a block of this size will succeed, but may
63 unsigned int GetLargestFreeOrPendingSize() {
67 // Gets a pointer to a memory block given the base memory and the offset.
68 void* GetPointer(RingBuffer::Offset offset) const {
69 return static_cast<int8*>(base_) + offset;
72 // Gets the offset to a memory block given the base memory and the address.
73 RingBuffer::Offset GetOffset(void* pointer) const {
74 return static_cast<int8*>(pointer) - static_cast<int8*>(base_);
77 // Rounds the given size to the alignment in use.
78 unsigned int RoundToAlignment(unsigned int size) {
79 return (size + alignment_ - 1) & ~(alignment_ - 1);
89 // Book-keeping sturcture that describes a block of memory.
91 Block(Offset _offset, unsigned int _size, State _state)
99 unsigned int token; // token to wait for.
103 typedef std::deque<Block> Container;
104 typedef unsigned int BlockIndex;
106 void FreeOldestBlock();
108 CommandBufferHelper* helper_;
110 // Used blocks are added to the end, blocks are freed from the beginning.
113 // The base offset of the ring buffer.
116 // The size of the ring buffer.
119 // Offset of first free byte.
122 // Offset of first used byte.
123 // Range between in_use_mark and free_mark is in use.
124 Offset in_use_offset_;
126 // Alignment for allocations.
127 unsigned int alignment_;
129 // The physical address that corresponds to base_offset.
132 DISALLOW_IMPLICIT_CONSTRUCTORS(RingBuffer);
137 #endif // GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_