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    // Tracing id which identifies the GPU client for whom memory is being
  34    // allocated.
  35    virtual uint64_t ClientTracingId() const = 0;
  36
  37    // Raw ID identifying the GPU client for whom memory is being allocated.
  38    virtual int ClientId() const = 0;
  39
  40  protected:
  41   friend class base::RefCounted<MemoryTracker>;
  42   MemoryTracker() {}
  43   virtual ~MemoryTracker() {};
  44
  45  private:
  46   DISALLOW_COPY_AND_ASSIGN(MemoryTracker);
  47 };
  48
  49 // A MemoryTypeTracker tracks the use of a particular type of memory (buffer,
  50 // texture, or renderbuffer) and forward the result to a specified
  51 // MemoryTracker.
  52 class MemoryTypeTracker {
  53  public:
  54   MemoryTypeTracker(MemoryTracker* memory_tracker, MemoryTracker::Pool pool)
  55     : memory_tracker_(memory_tracker),
  56       pool_(pool),
  57       has_done_update_(false),
  58       mem_represented_(0),
  59       mem_represented_at_last_update_(0) {
  60     UpdateMemRepresented();
  61   }
  62
  63   ~MemoryTypeTracker() {
  64     UpdateMemRepresented();
  65   }
  66
  67   void TrackMemAlloc(size_t bytes) {
  68     mem_represented_ += bytes;
  69     UpdateMemRepresented();
  70   }
  71
  72   void TrackMemFree(size_t bytes) {
  73     DCHECK(bytes <= mem_represented_);
  74     mem_represented_ -= bytes;
  75     UpdateMemRepresented();
  76   }
  77
  78   size_t GetMemRepresented() const {
  79     return mem_represented_at_last_update_;
  80   }
  81
  82   // Ensure a certain amount of GPU memory is free. Returns true on success.
  83   bool EnsureGPUMemoryAvailable(size_t size_needed) {
  84     if (memory_tracker_) {
  85       return memory_tracker_->EnsureGPUMemoryAvailable(size_needed);
  86     }
  87     return true;
  88   }
  89
  90  private:
  91   void UpdateMemRepresented() {
  92     // Skip redundant updates only if we have already done an update.
  93     if (!has_done_update_ &&
  94         mem_represented_ == mem_represented_at_last_update_) {
  95       return;
  96     }
  97     if (memory_tracker_) {
  98       memory_tracker_->TrackMemoryAllocatedChange(
  99         mem_represented_at_last_update_,
 100         mem_represented_,
 101         pool_);
 102     }
 103     has_done_update_ = true;
 104     mem_represented_at_last_update_ = mem_represented_;
 105   }
 106
 107   MemoryTracker* memory_tracker_;
 108   MemoryTracker::Pool pool_;
 109   bool has_done_update_;
 110   size_t mem_represented_;
 111   size_t mem_represented_at_last_update_;
 112
 113   DISALLOW_COPY_AND_ASSIGN(MemoryTypeTracker);
 114 };
 115
 116 }  // namespace gles2
 117 }  // namespace gpu
 118
 119 #endif  // GPU_COMMAND_BUFFER_SERVICE_MEMORY_TRACKING_H_