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( 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 49 TEST_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(0u, 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 66 TEST_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 75 class 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 111 TEST_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 129 TEST_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(0u, 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(1u, 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(1u, 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 174 TEST_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
