content/common/gpu/sync_point_manager.cc

   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 #include "content/common/gpu/sync_point_manager.h"
   6
   7 #include <climits>
   8
   9 #include "base/logging.h"
  10 #include "base/rand_util.h"
  11
  12 namespace content {
  13
  14 static const int kMaxSyncBase = INT_MAX;
  15
  16 SyncPointManager::SyncPointManager()
  17     : next_sync_point_(base::RandInt(1, kMaxSyncBase)) {
  18   // To reduce the risk that a sync point created in a previous GPU process
  19   // will be in flight in the next GPU process, randomize the starting sync
  20   // point number. http://crbug.com/373452
  21 }
  22
  23 SyncPointManager::~SyncPointManager() {
  24 }
  25
  26 uint32 SyncPointManager::GenerateSyncPoint() {
  27   base::AutoLock lock(lock_);
  28   uint32 sync_point = next_sync_point_++;
  29   // When an integer overflow occurs, don't return 0.
  30   if (!sync_point)
  31     sync_point = next_sync_point_++;
  32
  33   // Note: wrapping would take days for a buggy/compromized renderer that would
  34   // insert sync points in a loop, but if that were to happen, better explicitly
  35   // crash the GPU process than risk worse.
  36   // For normal operation (at most a few per frame), it would take ~a year to
  37   // wrap.
  38   CHECK(sync_point_map_.find(sync_point) == sync_point_map_.end());
  39   sync_point_map_.insert(std::make_pair(sync_point, ClosureList()));
  40   return sync_point;
  41 }
  42
  43 void SyncPointManager::RetireSyncPoint(uint32 sync_point) {
  44   DCHECK(thread_checker_.CalledOnValidThread());
  45   ClosureList list;
  46   {
  47     base::AutoLock lock(lock_);
  48     SyncPointMap::iterator it = sync_point_map_.find(sync_point);
  49     if (it == sync_point_map_.end()) {
  50       LOG(ERROR) << "Attempted to retire sync point that"
  51                     " didn't exist or was already retired.";
  52       return;
  53     }
  54     list.swap(it->second);
  55     sync_point_map_.erase(it);
  56   }
  57   for (ClosureList::iterator i = list.begin(); i != list.end(); ++i)
  58     i->Run();
  59 }
  60
  61 void SyncPointManager::AddSyncPointCallback(uint32 sync_point,
  62                                             const base::Closure& callback) {
  63   DCHECK(thread_checker_.CalledOnValidThread());
  64   {
  65     base::AutoLock lock(lock_);
  66     SyncPointMap::iterator it = sync_point_map_.find(sync_point);
  67     if (it != sync_point_map_.end()) {
  68       it->second.push_back(callback);
  69       return;
  70     }
  71   }
  72   callback.Run();
  73 }
  74
  75 bool SyncPointManager::IsSyncPointRetired(uint32 sync_point) {
  76   DCHECK(thread_checker_.CalledOnValidThread());
  77   {
  78     base::AutoLock lock(lock_);
  79     SyncPointMap::iterator it = sync_point_map_.find(sync_point);
  80     return it == sync_point_map_.end();
  81   }
  82 }
  83
  84 }  // namespace content