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