gpu/command_buffer/client/ring_buffer.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 // This file contains the definition of the RingBuffer class.
   6
   7 #ifndef GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
   8 #define GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_
   9
  10 #include <deque>
  11
  12 #include "base/logging.h"
  13 #include "base/macros.h"
  14 #include "gpu/gpu_export.h"
  15
  16 namespace gpu {
  17 class CommandBufferHelper;
  18
  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 {
  23  public:
  24   typedef unsigned int Offset;
  25
  26   // Creates a RingBuffer.
  27   // Parameters:
  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);
  35
  36   ~RingBuffer();
  37
  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.
  41   //
  42   // Parameters:
  43   //   size: the size of the memory block to allocate.
  44   //
  45   // Returns:
  46   //   the pointer to the allocated memory block.
  47   void* Alloc(unsigned int size);
  48
  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.
  51   //
  52   // Parameters:
  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);
  56
  57   // Discards a block within the ring buffer.
  58   //
  59   // Parameters:
  60   //   pointer: the pointer to the memory block to free.
  61   void DiscardBlock(void* pointer);
  62
  63   // Gets the size of the largest free block that is available without waiting.
  64   unsigned int GetLargestFreeSizeNoWaiting();
  65
  66   // Gets the total size of all free blocks that are available without waiting.
  67   unsigned int GetTotalFreeSizeNoWaiting();
  68
  69   // Gets the size of the largest free block that can be allocated if the
  70   // caller can wait. Allocating a block of this size will succeed, but may
  71   // block.
  72   unsigned int GetLargestFreeOrPendingSize() {
  73     return size_;
  74   }
  75
  76   // Gets a pointer to a memory block given the base memory and the offset.
  77   void* GetPointer(RingBuffer::Offset offset) const {
  78     return static_cast<int8*>(base_) + offset;
  79   }
  80
  81   // Gets the offset to a memory block given the base memory and the address.
  82   RingBuffer::Offset GetOffset(void* pointer) const {
  83     return static_cast<int8*>(pointer) - static_cast<int8*>(base_);
  84   }
  85
  86   // Rounds the given size to the alignment in use.
  87   unsigned int RoundToAlignment(unsigned int size) {
  88     return (size + alignment_ - 1) & ~(alignment_ - 1);
  89   }
  90
  91
  92  private:
  93   enum State {
  94     IN_USE,
  95     PADDING,
  96     FREE_PENDING_TOKEN
  97   };
  98   // Book-keeping sturcture that describes a block of memory.
  99   struct Block {
 100     Block(Offset _offset, unsigned int _size, State _state)
 101         : offset(_offset),
 102           size(_size),
 103           token(0),
 104           state(_state) {
 105     }
 106     Offset offset;
 107     unsigned int size;
 108     unsigned int token;  // token to wait for.
 109     State state;
 110   };
 111
 112   typedef std::deque<Block> Container;
 113   typedef unsigned int BlockIndex;
 114
 115   void FreeOldestBlock();
 116
 117   CommandBufferHelper* helper_;
 118
 119   // Used blocks are added to the end, blocks are freed from the beginning.
 120   Container blocks_;
 121
 122   // The base offset of the ring buffer.
 123   Offset base_offset_;
 124
 125   // The size of the ring buffer.
 126   Offset size_;
 127
 128   // Offset of first free byte.
 129   Offset free_offset_;
 130
 131   // Offset of first used byte.
 132   // Range between in_use_mark and free_mark is in use.
 133   Offset in_use_offset_;
 134
 135   // Alignment for allocations.
 136   unsigned int alignment_;
 137
 138   // The physical address that corresponds to base_offset.
 139   void* base_;
 140
 141   DISALLOW_IMPLICIT_CONSTRUCTORS(RingBuffer);
 142 };
 143
 144 }  // namespace gpu
 145
 146 #endif  // GPU_COMMAND_BUFFER_CLIENT_RING_BUFFER_H_