query_tracker_unittest.cc revision eb525c5499e34cc9c4b825d6d9e75bb07cc06ace 
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// Tests for the QueryTracker.
6
7#include "gpu/command_buffer/client/query_tracker.h"
8
9#include <GLES2/gl2ext.h>
10#include "base/memory/scoped_ptr.h"
11#include "gpu/command_buffer/client/client_test_helper.h"
12#include "gpu/command_buffer/client/gles2_cmd_helper.h"
13#include "gpu/command_buffer/client/mapped_memory.h"
14#include "gpu/command_buffer/common/command_buffer.h"
15#include "testing/gtest/include/gtest/gtest.h"
16#include "testing/gmock/include/gmock/gmock.h"
17
18namespace gpu {
19namespace gles2 {
20
21class QuerySyncManagerTest : public testing::Test {
22 protected:
23  static const int32 kNumCommandEntries = 400;
24  static const int32 kCommandBufferSizeBytes =
25      kNumCommandEntries * sizeof(CommandBufferEntry);
26
27  virtual void SetUp() {
28    command_buffer_.reset(new MockClientCommandBuffer());
29    helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
30    helper_->Initialize(kCommandBufferSizeBytes);
31    mapped_memory_.reset(new MappedMemoryManager(helper_.get()));
32    sync_manager_.reset(new QuerySyncManager(mapped_memory_.get()));
33  }
34
35  virtual void TearDown() {
36    sync_manager_.reset();
37    mapped_memory_.reset();
38    helper_.reset();
39    command_buffer_.reset();
40  }
41
42  scoped_ptr<CommandBuffer> command_buffer_;
43  scoped_ptr<GLES2CmdHelper> helper_;
44  scoped_ptr<MappedMemoryManager> mapped_memory_;
45  scoped_ptr<QuerySyncManager> sync_manager_;
46};
47
48TEST_F(QuerySyncManagerTest, Basic) {
49  QuerySyncManager::QueryInfo infos[4];
50  memset(&infos, 0xBD, sizeof(infos));
51
52  for (size_t ii = 0; ii < arraysize(infos); ++ii) {
53    EXPECT_TRUE(sync_manager_->Alloc(&infos[ii]));
54    EXPECT_NE(0, infos[ii].shm_id);
55    ASSERT_TRUE(infos[ii].sync != NULL);
56    EXPECT_EQ(0u, infos[ii].sync->process_count);
57    EXPECT_EQ(0u, infos[ii].sync->result);
58  }
59
60  for (size_t ii = 0; ii < arraysize(infos); ++ii) {
61    sync_manager_->Free(infos[ii]);
62  }
63}
64
65TEST_F(QuerySyncManagerTest, DontFree) {
66  QuerySyncManager::QueryInfo infos[4];
67  memset(&infos, 0xBD, sizeof(infos));
68
69  for (size_t ii = 0; ii < arraysize(infos); ++ii) {
70    EXPECT_TRUE(sync_manager_->Alloc(&infos[ii]));
71  }
72}
73
74class QueryTrackerTest : public testing::Test {
75 protected:
76  static const int32 kNumCommandEntries = 400;
77  static const int32 kCommandBufferSizeBytes =
78      kNumCommandEntries * sizeof(CommandBufferEntry);
79
80  virtual void SetUp() {
81    command_buffer_.reset(new MockClientCommandBuffer());
82    helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
83    helper_->Initialize(kCommandBufferSizeBytes);
84    mapped_memory_.reset(new MappedMemoryManager(helper_.get()));
85    query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
86  }
87
88  virtual void TearDown() {
89    query_tracker_.reset();
90    mapped_memory_.reset();
91    helper_.reset();
92    command_buffer_.reset();
93  }
94
95  QuerySync* GetSync(QueryTracker::Query* query) {
96    return query->info_.sync;
97  }
98
99  QuerySyncManager::Bucket* GetBucket(QueryTracker::Query* query) {
100    return query->info_.bucket;
101  }
102
103  scoped_ptr<CommandBuffer> command_buffer_;
104  scoped_ptr<GLES2CmdHelper> helper_;
105  scoped_ptr<MappedMemoryManager> mapped_memory_;
106  scoped_ptr<QueryTracker> query_tracker_;
107};
108
109TEST_F(QueryTrackerTest, Basic) {
110  const GLuint kId1 = 123;
111  const GLuint kId2 = 124;
112
113  // Check we can create a Query.
114  QueryTracker::Query* query = query_tracker_->CreateQuery(
115      kId1, GL_ANY_SAMPLES_PASSED_EXT);
116  ASSERT_TRUE(query != NULL);
117  // Check we can get the same Query.
118  EXPECT_EQ(query, query_tracker_->GetQuery(kId1));
119  // Check we get nothing for a non-existent query.
120  EXPECT_TRUE(query_tracker_->GetQuery(kId2) == NULL);
121  // Check we can delete the query.
122  query_tracker_->RemoveQuery(kId1);
123  // Check we get nothing for a non-existent query.
124  EXPECT_TRUE(query_tracker_->GetQuery(kId1) == NULL);
125}
126
127TEST_F(QueryTrackerTest, Query) {
128  const GLuint kId1 = 123;
129  const int32 kToken = 46;
130  const uint32 kResult = 456;
131
132  // Create a Query.
133  QueryTracker::Query* query = query_tracker_->CreateQuery(
134      kId1, GL_ANY_SAMPLES_PASSED_EXT);
135  ASSERT_TRUE(query != NULL);
136  EXPECT_TRUE(query->NeverUsed());
137  EXPECT_FALSE(query->Pending());
138  EXPECT_EQ(0, query->token());
139  EXPECT_EQ(0u, query->submit_count());
140
141  // Check MarkAsActive.
142  query->MarkAsActive();
143  EXPECT_FALSE(query->NeverUsed());
144  EXPECT_FALSE(query->Pending());
145  EXPECT_EQ(0, query->token());
146  EXPECT_EQ(1u, query->submit_count());
147
148  // Check MarkAsPending.
149  query->MarkAsPending(kToken);
150  EXPECT_FALSE(query->NeverUsed());
151  EXPECT_TRUE(query->Pending());
152  EXPECT_EQ(kToken, query->token());
153  EXPECT_EQ(1u, query->submit_count());
154
155  // Check CheckResultsAvailable.
156  EXPECT_FALSE(query->CheckResultsAvailable(helper_.get()));
157  EXPECT_FALSE(query->NeverUsed());
158  EXPECT_TRUE(query->Pending());
159
160  // Simulate GPU process marking it as available.
161  QuerySync* sync = GetSync(query);
162  sync->process_count = query->submit_count();
163  sync->result = kResult;
164
165  // Check CheckResultsAvailable.
166  EXPECT_TRUE(query->CheckResultsAvailable(helper_.get()));
167  EXPECT_EQ(kResult, query->GetResult());
168  EXPECT_FALSE(query->NeverUsed());
169  EXPECT_FALSE(query->Pending());
170}
171
172TEST_F(QueryTrackerTest, Remove) {
173  const GLuint kId1 = 123;
174  const int32 kToken = 46;
175  const uint32 kResult = 456;
176
177  // Create a Query.
178  QueryTracker::Query* query = query_tracker_->CreateQuery(
179      kId1, GL_ANY_SAMPLES_PASSED_EXT);
180  ASSERT_TRUE(query != NULL);
181
182  QuerySyncManager::Bucket* bucket = GetBucket(query);
183  EXPECT_EQ(1u, bucket->used_query_count);
184
185  query->MarkAsActive();
186  query->MarkAsPending(kToken);
187
188  query_tracker_->RemoveQuery(kId1);
189  // Check we get nothing for a non-existent query.
190  EXPECT_TRUE(query_tracker_->GetQuery(kId1) == NULL);
191
192  // Check that memory was not freed.
193  EXPECT_EQ(1u, bucket->used_query_count);
194
195  // Simulate GPU process marking it as available.
196  QuerySync* sync = GetSync(query);
197  sync->process_count = query->submit_count();
198  sync->result = kResult;
199
200  // Check FreeCompletedQueries.
201  query_tracker_->FreeCompletedQueries();
202  EXPECT_EQ(0u, bucket->used_query_count);
203}
204
205}  // namespace gles2
206}  // namespace gpu
207
208
209