OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "gpu/command_buffer/client/query_tracker.h" | 5 #include "gpu/command_buffer/client/query_tracker.h" |
6 | 6 |
7 #include <GLES2/gl2.h> | 7 #include <GLES2/gl2.h> |
8 #include <GLES2/gl2ext.h> | 8 #include <GLES2/gl2ext.h> |
9 #include <GLES2/gl2extchromium.h> | 9 #include <GLES2/gl2extchromium.h> |
10 | 10 |
11 #include <limits.h> | 11 #include <limits.h> |
12 | 12 |
13 #include "base/atomicops.h" | 13 #include "base/atomicops.h" |
14 #include "base/numerics/safe_conversions.h" | 14 #include "base/numerics/safe_conversions.h" |
15 #include "gpu/command_buffer/client/gles2_cmd_helper.h" | 15 #include "gpu/command_buffer/client/gles2_cmd_helper.h" |
16 #include "gpu/command_buffer/client/gles2_implementation.h" | 16 #include "gpu/command_buffer/client/gles2_implementation.h" |
17 #include "gpu/command_buffer/client/mapped_memory.h" | 17 #include "gpu/command_buffer/client/mapped_memory.h" |
18 #include "gpu/command_buffer/common/time.h" | 18 #include "gpu/command_buffer/common/time.h" |
19 | 19 |
20 namespace gpu { | 20 namespace gpu { |
21 namespace gles2 { | 21 namespace gles2 { |
22 | 22 |
23 QuerySyncManager::Bucket::Bucket(QuerySync* sync_mem, | 23 QuerySyncManager::Bucket::Bucket(QuerySync* sync_mem, |
24 int32 shm_id, | 24 int32 shm_id, |
25 unsigned int shm_offset) | 25 unsigned int shm_offset) |
26 : syncs(sync_mem), | 26 : syncs(sync_mem), |
27 shm_id(shm_id), | 27 shm_id(shm_id), |
28 base_shm_offset(shm_offset), | 28 base_shm_offset(shm_offset) { |
29 free_queries(kSyncsPerBucket) { | |
30 static_assert(kSyncsPerBucket <= USHRT_MAX, | |
31 "Can't fit kSyncsPerBucket in unsigned short"); | |
32 for (size_t ii = 0; ii < kSyncsPerBucket; ++ii) | |
33 free_queries[ii] = ii; | |
34 } | 29 } |
35 | 30 |
36 QuerySyncManager::Bucket::~Bucket() = default; | 31 QuerySyncManager::Bucket::~Bucket() = default; |
37 | 32 |
38 QuerySyncManager::QuerySyncManager(MappedMemoryManager* manager) | 33 QuerySyncManager::QuerySyncManager(MappedMemoryManager* manager) |
39 : mapped_memory_(manager) { | 34 : mapped_memory_(manager) { |
40 DCHECK(manager); | 35 DCHECK(manager); |
41 } | 36 } |
42 | 37 |
43 QuerySyncManager::~QuerySyncManager() { | 38 QuerySyncManager::~QuerySyncManager() { |
44 while (!buckets_.empty()) { | 39 while (!buckets_.empty()) { |
45 mapped_memory_->Free(buckets_.front()->syncs); | 40 mapped_memory_->Free(buckets_.front()->syncs); |
46 delete buckets_.front(); | 41 delete buckets_.front(); |
47 buckets_.pop_front(); | 42 buckets_.pop_front(); |
48 } | 43 } |
49 } | 44 } |
50 | 45 |
51 bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) { | 46 bool QuerySyncManager::Alloc(QuerySyncManager::QueryInfo* info) { |
52 DCHECK(info); | 47 DCHECK(info); |
53 Bucket* bucket = nullptr; | 48 Bucket* bucket = nullptr; |
54 for (Bucket* bucket_candidate : buckets_) { | 49 for (Bucket* bucket_candidate : buckets_) { |
55 if (!bucket_candidate->free_queries.empty()) { | 50 // In C++11 STL this could be replaced with |
| 51 // if (!bucket_candidate->in_use_queries.all()) { ... } |
| 52 if (bucket_candidate->in_use_queries.count() != kSyncsPerBucket) { |
56 bucket = bucket_candidate; | 53 bucket = bucket_candidate; |
57 break; | 54 break; |
58 } | 55 } |
59 } | 56 } |
60 if (!bucket) { | 57 if (!bucket) { |
61 int32 shm_id; | 58 int32 shm_id; |
62 unsigned int shm_offset; | 59 unsigned int shm_offset; |
63 void* mem = mapped_memory_->Alloc( | 60 void* mem = mapped_memory_->Alloc( |
64 kSyncsPerBucket * sizeof(QuerySync), &shm_id, &shm_offset); | 61 kSyncsPerBucket * sizeof(QuerySync), &shm_id, &shm_offset); |
65 if (!mem) { | 62 if (!mem) { |
66 return false; | 63 return false; |
67 } | 64 } |
68 QuerySync* syncs = static_cast<QuerySync*>(mem); | 65 QuerySync* syncs = static_cast<QuerySync*>(mem); |
69 bucket = new Bucket(syncs, shm_id, shm_offset); | 66 bucket = new Bucket(syncs, shm_id, shm_offset); |
70 buckets_.push_back(bucket); | 67 buckets_.push_back(bucket); |
71 } | 68 } |
72 | 69 |
73 unsigned short index_in_bucket = bucket->free_queries.back(); | 70 unsigned short index_in_bucket = 0; |
| 71 for (size_t i = 0; i < kSyncsPerBucket; i++) { |
| 72 if (!bucket->in_use_queries[i]) { |
| 73 index_in_bucket = i; |
| 74 break; |
| 75 } |
| 76 } |
| 77 |
74 uint32 shm_offset = | 78 uint32 shm_offset = |
75 bucket->base_shm_offset + index_in_bucket * sizeof(QuerySync); | 79 bucket->base_shm_offset + index_in_bucket * sizeof(QuerySync); |
76 QuerySync* sync = bucket->syncs + index_in_bucket; | 80 QuerySync* sync = bucket->syncs + index_in_bucket; |
77 *info = QueryInfo(bucket, bucket->shm_id, shm_offset, sync); | 81 *info = QueryInfo(bucket, bucket->shm_id, shm_offset, sync); |
78 info->sync->Reset(); | 82 info->sync->Reset(); |
79 bucket->free_queries.pop_back(); | 83 bucket->in_use_queries[index_in_bucket] = true; |
80 return true; | 84 return true; |
81 } | 85 } |
82 | 86 |
83 void QuerySyncManager::Free(const QuerySyncManager::QueryInfo& info) { | 87 void QuerySyncManager::Free(const QuerySyncManager::QueryInfo& info) { |
84 DCHECK(info.bucket->free_queries.size() < kSyncsPerBucket); | 88 DCHECK_NE(info.bucket->in_use_queries.count(), 0u); |
85 unsigned short index_in_bucket = info.sync - info.bucket->syncs; | 89 unsigned short index_in_bucket = info.sync - info.bucket->syncs; |
86 info.bucket->free_queries.push_back(index_in_bucket); | 90 DCHECK(info.bucket->in_use_queries[index_in_bucket]); |
| 91 info.bucket->in_use_queries[index_in_bucket] = false; |
87 } | 92 } |
88 | 93 |
89 void QuerySyncManager::Shrink() { | 94 void QuerySyncManager::Shrink() { |
90 std::deque<Bucket*> new_buckets; | 95 std::deque<Bucket*> new_buckets; |
91 while (!buckets_.empty()) { | 96 while (!buckets_.empty()) { |
92 Bucket* bucket = buckets_.front(); | 97 Bucket* bucket = buckets_.front(); |
93 if (bucket->free_queries.size() < kSyncsPerBucket) { | 98 if (bucket->in_use_queries.any()) { |
94 new_buckets.push_back(bucket); | 99 new_buckets.push_back(bucket); |
95 } else { | 100 } else { |
96 mapped_memory_->Free(bucket->syncs); | 101 mapped_memory_->Free(bucket->syncs); |
97 delete bucket; | 102 delete bucket; |
98 } | 103 } |
99 buckets_.pop_front(); | 104 buckets_.pop_front(); |
100 } | 105 } |
101 buckets_.swap(new_buckets); | 106 buckets_.swap(new_buckets); |
102 } | 107 } |
103 | 108 |
(...skipping 163 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
267 } | 272 } |
268 | 273 |
269 query_sync_manager_.Free(query->info_); | 274 query_sync_manager_.Free(query->info_); |
270 it = removed_queries_.erase(it); | 275 it = removed_queries_.erase(it); |
271 delete query; | 276 delete query; |
272 } | 277 } |
273 } | 278 } |
274 | 279 |
275 } // namespace gles2 | 280 } // namespace gles2 |
276 } // namespace gpu | 281 } // namespace gpu |
OLD | NEW |