gpu/command_buffer/service/memory_tracking.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_SERVICE_MEMORY_TRACKING_H_
   6 #define GPU_COMMAND_BUFFER_SERVICE_MEMORY_TRACKING_H_
   7
   8 #include <string>
   9 #include "base/basictypes.h"
  10 #include "base/logging.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/trace_event/trace_event.h"
  13
  14 namespace gpu {
  15 namespace gles2 {
  16
  17 // A MemoryTracker is used to propagate per-ContextGroup memory usage
  18 // statistics to the global GpuMemoryManager.
  19 class MemoryTracker : public base::RefCounted<MemoryTracker> {
  20  public:
  21    enum Pool {
  22      kUnmanaged,
  23      kManaged
  24    };
  25
  26    virtual void TrackMemoryAllocatedChange(size_t old_size,
  27                                            size_t new_size,
  28                                            Pool pool) = 0;
  29
  30    // Ensure a certain amount of GPU memory is free. Returns true on success.
  31    virtual bool EnsureGPUMemoryAvailable(size_t size_needed) = 0;
  32
  33  protected:
  34   friend class base::RefCounted<MemoryTracker>;
  35   MemoryTracker() {}
  36   virtual ~MemoryTracker() {};
  37
  38  private:
  39   DISALLOW_COPY_AND_ASSIGN(MemoryTracker);
  40 };
  41
  42 // A MemoryTypeTracker tracks the use of a particular type of memory (buffer,
  43 // texture, or renderbuffer) and forward the result to a specified
  44 // MemoryTracker.
  45 class MemoryTypeTracker {
  46  public:
  47   MemoryTypeTracker(MemoryTracker* memory_tracker, MemoryTracker::Pool pool)
  48     : memory_tracker_(memory_tracker),
  49       pool_(pool),
  50       has_done_update_(false),
  51       mem_represented_(0),
  52       mem_represented_at_last_update_(0) {
  53     UpdateMemRepresented();
  54   }
  55
  56   ~MemoryTypeTracker() {
  57     UpdateMemRepresented();
  58   }
  59
  60   void TrackMemAlloc(size_t bytes) {
  61     mem_represented_ += bytes;
  62     UpdateMemRepresented();
  63   }
  64
  65   void TrackMemFree(size_t bytes) {
  66     DCHECK(bytes <= mem_represented_);
  67     mem_represented_ -= bytes;
  68     UpdateMemRepresented();
  69   }
  70
  71   size_t GetMemRepresented() const {
  72     return mem_represented_at_last_update_;
  73   }
  74
  75   // Ensure a certain amount of GPU memory is free. Returns true on success.
  76   bool EnsureGPUMemoryAvailable(size_t size_needed) {
  77     if (memory_tracker_) {
  78       return memory_tracker_->EnsureGPUMemoryAvailable(size_needed);
  79     }
  80     return true;
  81   }
  82
  83  private:
  84   void UpdateMemRepresented() {
  85     // Skip redundant updates only if we have already done an update.
  86     if (!has_done_update_ &&
  87         mem_represented_ == mem_represented_at_last_update_) {
  88       return;
  89     }
  90     if (memory_tracker_) {
  91       memory_tracker_->TrackMemoryAllocatedChange(
  92         mem_represented_at_last_update_,
  93         mem_represented_,
  94         pool_);
  95     }
  96     has_done_update_ = true;
  97     mem_represented_at_last_update_ = mem_represented_;
  98   }
  99
 100   MemoryTracker* memory_tracker_;
 101   MemoryTracker::Pool pool_;
 102   bool has_done_update_;
 103   size_t mem_represented_;
 104   size_t mem_represented_at_last_update_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(MemoryTypeTracker);
 107 };
 108
 109 }  // namespace gles2
 110 }  // namespace gpu
 111
 112 #endif  // GPU_COMMAND_BUFFER_SERVICE_MEMORY_TRACKING_H_