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 18 namespace gpu { 19 namespace gles2 { 20 21 class 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 48 TEST_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 65 TEST_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 74 class 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 109 TEST_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 127 TEST_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 172 TEST_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
