gpu/command_buffer/client/query_tracker_unittest.cc

   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
  11 #include <vector>
  12
  13 #include "base/memory/scoped_ptr.h"
  14 #include "gpu/command_buffer/client/client_test_helper.h"
  15 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
  16 #include "gpu/command_buffer/client/mapped_memory.h"
  17 #include "gpu/command_buffer/common/command_buffer.h"
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "testing/gmock/include/gmock/gmock.h"
  20
  21 namespace gpu {
  22 namespace gles2 {
  23
  24 class QuerySyncManagerTest : public testing::Test {
  25  protected:
  26   static const int32 kNumCommandEntries = 400;
  27   static const int32 kCommandBufferSizeBytes =
  28       kNumCommandEntries * sizeof(CommandBufferEntry);
  29
  30   void SetUp() override {
  31     command_buffer_.reset(new MockClientCommandBuffer());
  32     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
  33     helper_->Initialize(kCommandBufferSizeBytes);
  34     mapped_memory_.reset(
  35         new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
  36     sync_manager_.reset(new QuerySyncManager(mapped_memory_.get()));
  37   }
  38
  39   void TearDown() override {
  40     sync_manager_.reset();
  41     mapped_memory_.reset();
  42     helper_.reset();
  43     command_buffer_.reset();
  44   }
  45
  46   scoped_ptr<CommandBuffer> command_buffer_;
  47   scoped_ptr<GLES2CmdHelper> helper_;
  48   scoped_ptr<MappedMemoryManager> mapped_memory_;
  49   scoped_ptr<QuerySyncManager> sync_manager_;
  50 };
  51
  52 TEST_F(QuerySyncManagerTest, Basic) {
  53   QuerySyncManager::QueryInfo infos[4];
  54   memset(&infos, 0xBD, sizeof(infos));
  55
  56   for (size_t ii = 0; ii < arraysize(infos); ++ii) {
  57     EXPECT_TRUE(sync_manager_->Alloc(&infos[ii]));
  58     EXPECT_NE(0, infos[ii].shm_id);
  59     ASSERT_TRUE(infos[ii].sync != NULL);
  60     EXPECT_EQ(0, infos[ii].sync->process_count);
  61     EXPECT_EQ(0u, infos[ii].sync->result);
  62   }
  63
  64   for (size_t ii = 0; ii < arraysize(infos); ++ii) {
  65     sync_manager_->Free(infos[ii]);
  66   }
  67 }
  68
  69 TEST_F(QuerySyncManagerTest, DontFree) {
  70   QuerySyncManager::QueryInfo infos[4];
  71   memset(&infos, 0xBD, sizeof(infos));
  72
  73   for (size_t ii = 0; ii < arraysize(infos); ++ii) {
  74     EXPECT_TRUE(sync_manager_->Alloc(&infos[ii]));
  75   }
  76 }
  77
  78 class QueryTrackerTest : public testing::Test {
  79  protected:
  80   static const int32 kNumCommandEntries = 400;
  81   static const int32 kCommandBufferSizeBytes =
  82       kNumCommandEntries * sizeof(CommandBufferEntry);
  83
  84   void SetUp() override {
  85     command_buffer_.reset(new MockClientCommandBuffer());
  86     helper_.reset(new GLES2CmdHelper(command_buffer_.get()));
  87     helper_->Initialize(kCommandBufferSizeBytes);
  88     mapped_memory_.reset(
  89         new MappedMemoryManager(helper_.get(), MappedMemoryManager::kNoLimit));
  90     query_tracker_.reset(new QueryTracker(mapped_memory_.get()));
  91   }
  92
  93   void TearDown() override {
  94     query_tracker_.reset();
  95     mapped_memory_.reset();
  96     helper_.reset();
  97     command_buffer_.reset();
  98   }
  99
 100   QuerySync* GetSync(QueryTracker::Query* query) {
 101     return query->info_.sync;
 102   }
 103
 104   QuerySyncManager::Bucket* GetBucket(QueryTracker::Query* query) {
 105     return query->info_.bucket;
 106   }
 107
 108   uint32 GetBucketUsedCount(QuerySyncManager::Bucket* bucket) {
 109     return bucket->in_use_queries.count();
 110   }
 111
 112   uint32 GetFlushGeneration() { return helper_->flush_generation(); }
 113
 114   scoped_ptr<CommandBuffer> command_buffer_;
 115   scoped_ptr<GLES2CmdHelper> helper_;
 116   scoped_ptr<MappedMemoryManager> mapped_memory_;
 117   scoped_ptr<QueryTracker> query_tracker_;
 118 };
 119
 120 TEST_F(QueryTrackerTest, Basic) {
 121   const GLuint kId1 = 123;
 122   const GLuint kId2 = 124;
 123
 124   // Check we can create a Query.
 125   QueryTracker::Query* query = query_tracker_->CreateQuery(
 126       kId1, GL_ANY_SAMPLES_PASSED_EXT);
 127   ASSERT_TRUE(query != NULL);
 128   // Check we can get the same Query.
 129   EXPECT_EQ(query, query_tracker_->GetQuery(kId1));
 130   // Check we get nothing for a non-existent query.
 131   EXPECT_TRUE(query_tracker_->GetQuery(kId2) == NULL);
 132   // Check we can delete the query.
 133   query_tracker_->RemoveQuery(kId1);
 134   // Check we get nothing for a non-existent query.
 135   EXPECT_TRUE(query_tracker_->GetQuery(kId1) == NULL);
 136 }
 137
 138 TEST_F(QueryTrackerTest, Query) {
 139   const GLuint kId1 = 123;
 140   const int32 kToken = 46;
 141   const uint32 kResult = 456;
 142
 143   // Create a Query.
 144   QueryTracker::Query* query = query_tracker_->CreateQuery(
 145       kId1, GL_ANY_SAMPLES_PASSED_EXT);
 146   ASSERT_TRUE(query != NULL);
 147   EXPECT_TRUE(query->NeverUsed());
 148   EXPECT_FALSE(query->Pending());
 149   EXPECT_EQ(0, query->token());
 150   EXPECT_EQ(0, query->submit_count());
 151
 152   // Check MarkAsActive.
 153   query->MarkAsActive();
 154   EXPECT_FALSE(query->NeverUsed());
 155   EXPECT_FALSE(query->Pending());
 156   EXPECT_EQ(0, query->token());
 157   EXPECT_EQ(1, query->submit_count());
 158
 159   // Check MarkAsPending.
 160   query->MarkAsPending(kToken);
 161   EXPECT_FALSE(query->NeverUsed());
 162   EXPECT_TRUE(query->Pending());
 163   EXPECT_EQ(kToken, query->token());
 164   EXPECT_EQ(1, query->submit_count());
 165
 166   // Flush only once if no more flushes happened between a call to
 167   // EndQuery command and CheckResultsAvailable
 168   // Advance put_ so flush calls in CheckResultsAvailable go through
 169   // and updates flush_generation count
 170   helper_->Noop(1);
 171
 172   // Store FlushGeneration count after EndQuery is called
 173   uint32 gen1 = GetFlushGeneration();
 174
 175   // Check CheckResultsAvailable.
 176   EXPECT_FALSE(query->CheckResultsAvailable(helper_.get()));
 177   EXPECT_FALSE(query->NeverUsed());
 178   EXPECT_TRUE(query->Pending());
 179
 180   uint32 gen2 = GetFlushGeneration();
 181   EXPECT_NE(gen1, gen2);
 182
 183   // Repeated calls to CheckResultsAvailable should not flush unnecessarily
 184   EXPECT_FALSE(query->CheckResultsAvailable(helper_.get()));
 185   gen1 = GetFlushGeneration();
 186   EXPECT_EQ(gen1, gen2);
 187   EXPECT_FALSE(query->CheckResultsAvailable(helper_.get()));
 188   gen1 = GetFlushGeneration();
 189   EXPECT_EQ(gen1, gen2);
 190
 191   // Simulate GPU process marking it as available.
 192   QuerySync* sync = GetSync(query);
 193   sync->process_count = query->submit_count();
 194   sync->result = kResult;
 195
 196   // Check CheckResultsAvailable.
 197   EXPECT_TRUE(query->CheckResultsAvailable(helper_.get()));
 198   EXPECT_EQ(kResult, query->GetResult());
 199   EXPECT_FALSE(query->NeverUsed());
 200   EXPECT_FALSE(query->Pending());
 201 }
 202
 203 TEST_F(QueryTrackerTest, Remove) {
 204   const GLuint kId1 = 123;
 205   const int32 kToken = 46;
 206   const uint32 kResult = 456;
 207
 208   // Create a Query.
 209   QueryTracker::Query* query = query_tracker_->CreateQuery(
 210       kId1, GL_ANY_SAMPLES_PASSED_EXT);
 211   ASSERT_TRUE(query != NULL);
 212
 213   QuerySyncManager::Bucket* bucket = GetBucket(query);
 214   EXPECT_EQ(1u, GetBucketUsedCount(bucket));
 215
 216   query->MarkAsActive();
 217   query->MarkAsPending(kToken);
 218
 219   query_tracker_->RemoveQuery(kId1);
 220   // Check we get nothing for a non-existent query.
 221   EXPECT_TRUE(query_tracker_->GetQuery(kId1) == NULL);
 222
 223   // Check that memory was not freed.
 224   EXPECT_EQ(1u, GetBucketUsedCount(bucket));
 225
 226   // Simulate GPU process marking it as available.
 227   QuerySync* sync = GetSync(query);
 228   sync->process_count = query->submit_count();
 229   sync->result = kResult;
 230
 231   // Check FreeCompletedQueries.
 232   query_tracker_->FreeCompletedQueries();
 233   EXPECT_EQ(0u, GetBucketUsedCount(bucket));
 234 }
 235
 236 TEST_F(QueryTrackerTest, ManyQueries) {
 237   const GLuint kId1 = 123;
 238   const int32 kToken = 46;
 239   const uint32 kResult = 456;
 240
 241   const size_t kTestSize = 4000;
 242   static_assert(kTestSize > QuerySyncManager::kSyncsPerBucket,
 243                 "We want to use more than one bucket");
 244   // Create lots of queries.
 245   std::vector<QueryTracker::Query*> queries;
 246   for (size_t i = 0; i < kTestSize; i++) {
 247     QueryTracker::Query* query =
 248         query_tracker_->CreateQuery(kId1 + i, GL_ANY_SAMPLES_PASSED_EXT);
 249     ASSERT_TRUE(query != NULL);
 250     queries.push_back(query);
 251     QuerySyncManager::Bucket* bucket = GetBucket(query);
 252     EXPECT_LE(1u, GetBucketUsedCount(bucket));
 253   }
 254
 255   QuerySyncManager::Bucket* query_0_bucket = GetBucket(queries[0]);
 256   uint32 expected_use_count = QuerySyncManager::kSyncsPerBucket;
 257   EXPECT_EQ(expected_use_count, GetBucketUsedCount(query_0_bucket));
 258
 259   while (!queries.empty()) {
 260     QueryTracker::Query* query = queries.back();
 261     queries.pop_back();
 262     GLuint query_id = kId1 + queries.size();
 263     EXPECT_EQ(query_id, query->id());
 264     query->MarkAsActive();
 265     query->MarkAsPending(kToken);
 266
 267     QuerySyncManager::Bucket* bucket = GetBucket(query);
 268     uint32 use_count_before_remove = GetBucketUsedCount(bucket);
 269     query_tracker_->FreeCompletedQueries();
 270     EXPECT_EQ(use_count_before_remove, GetBucketUsedCount(bucket));
 271     query_tracker_->RemoveQuery(query_id);
 272     // Check we get nothing for a non-existent query.
 273     EXPECT_TRUE(query_tracker_->GetQuery(query_id) == NULL);
 274
 275     // Check that memory was not freed since it was not completed.
 276     EXPECT_EQ(use_count_before_remove, GetBucketUsedCount(bucket));
 277
 278     // Simulate GPU process marking it as available.
 279     QuerySync* sync = GetSync(query);
 280     sync->process_count = query->submit_count();
 281     sync->result = kResult;
 282
 283     // Check FreeCompletedQueries.
 284     query_tracker_->FreeCompletedQueries();
 285     EXPECT_EQ(use_count_before_remove - 1, GetBucketUsedCount(bucket));
 286   }
 287 }
 288
 289 }  // namespace gles2
 290 }  // namespace gpu
 291
 292