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 #include "gpu/command_buffer/service/buffer_manager.h" 6 #include "gpu/command_buffer/service/error_state_mock.h" 7 #include "gpu/command_buffer/service/feature_info.h" 8 #include "gpu/command_buffer/service/mocks.h" 9 #include "gpu/command_buffer/service/test_helper.h" 10 #include "testing/gtest/include/gtest/gtest.h" 11 #include "ui/gl/gl_mock.h" 12 13 using ::testing::_; 14 using ::testing::Return; 15 using ::testing::StrictMock; 16 17 namespace gpu { 18 namespace gles2 { 19 20 class BufferManagerTestBase : public testing::Test { 21 protected: 22 void SetUpBase( 23 MemoryTracker* memory_tracker, 24 FeatureInfo* feature_info, 25 const char* extensions) { 26 gl_.reset(new ::testing::StrictMock< ::gfx::MockGLInterface>()); 27 ::gfx::GLInterface::SetGLInterface(gl_.get()); 28 if (feature_info) { 29 TestHelper::SetupFeatureInfoInitExpectations(gl_.get(), extensions); 30 feature_info->Initialize(); 31 } 32 error_state_.reset(new MockErrorState()); 33 manager_.reset(new BufferManager(memory_tracker, feature_info)); 34 } 35 36 virtual void TearDown() { 37 manager_->Destroy(false); 38 manager_.reset(); 39 ::gfx::GLInterface::SetGLInterface(NULL); 40 error_state_.reset(); 41 gl_.reset(); 42 } 43 44 GLenum GetTarget(const Buffer* buffer) const { 45 return buffer->target(); 46 } 47 48 void DoBufferData( 49 Buffer* buffer, GLsizeiptr size, GLenum usage, const GLvoid* data, 50 GLenum error) { 51 TestHelper::DoBufferData( 52 gl_.get(), error_state_.get(), manager_.get(), 53 buffer, size, usage, data, error); 54 } 55 56 bool DoBufferSubData( 57 Buffer* buffer, GLintptr offset, GLsizeiptr size, 58 const GLvoid* data) { 59 bool success = true; 60 if (!buffer->CheckRange(offset, size)) { 61 EXPECT_CALL(*error_state_, SetGLError(_, _, GL_INVALID_VALUE, _, _)) 62 .Times(1) 63 .RetiresOnSaturation(); 64 success = false; 65 } else if (!buffer->IsClientSideArray()) { 66 EXPECT_CALL(*gl_, BufferSubData( 67 buffer->target(), offset, size, _)) 68 .Times(1) 69 .RetiresOnSaturation(); 70 } 71 manager_->DoBufferSubData( 72 error_state_.get(), buffer, offset, size, data); 73 return success; 74 } 75 76 // Use StrictMock to make 100% sure we know how GL will be called. 77 scoped_ptr< ::testing::StrictMock< ::gfx::MockGLInterface> > gl_; 78 scoped_ptr<BufferManager> manager_; 79 scoped_ptr<MockErrorState> error_state_; 80 }; 81 82 class BufferManagerTest : public BufferManagerTestBase { 83 protected: 84 virtual void SetUp() { 85 SetUpBase(NULL, NULL, ""); 86 } 87 }; 88 89 class BufferManagerMemoryTrackerTest : public BufferManagerTestBase { 90 protected: 91 virtual void SetUp() { 92 mock_memory_tracker_ = new StrictMock<MockMemoryTracker>(); 93 SetUpBase(mock_memory_tracker_.get(), NULL, ""); 94 } 95 96 scoped_refptr<MockMemoryTracker> mock_memory_tracker_; 97 }; 98 99 class BufferManagerClientSideArraysTest : public BufferManagerTestBase { 100 protected: 101 virtual void SetUp() { 102 feature_info_ = new FeatureInfo(); 103 feature_info_->workarounds_.use_client_side_arrays_for_stream_buffers = 104 true; 105 SetUpBase(NULL, feature_info_.get(), ""); 106 } 107 108 scoped_refptr<FeatureInfo> feature_info_; 109 }; 110 111 #define EXPECT_MEMORY_ALLOCATION_CHANGE(old_size, new_size, pool) \ 112 EXPECT_CALL(*mock_memory_tracker_.get(), \ 113 TrackMemoryAllocatedChange(old_size, new_size, pool)) \ 114 .Times(1).RetiresOnSaturation() 115 116 TEST_F(BufferManagerTest, Basic) { 117 const GLuint kClientBuffer1Id = 1; 118 const GLuint kServiceBuffer1Id = 11; 119 const GLsizeiptr kBuffer1Size = 123; 120 const GLuint kClientBuffer2Id = 2; 121 // Check we can create buffer. 122 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); 123 // Check buffer got created. 124 Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); 125 ASSERT_TRUE(buffer1 != NULL); 126 EXPECT_EQ(0u, GetTarget(buffer1)); 127 EXPECT_EQ(0, buffer1->size()); 128 EXPECT_EQ(static_cast<GLenum>(GL_STATIC_DRAW), buffer1->usage()); 129 EXPECT_FALSE(buffer1->IsDeleted()); 130 EXPECT_FALSE(buffer1->IsClientSideArray()); 131 EXPECT_EQ(kServiceBuffer1Id, buffer1->service_id()); 132 GLuint client_id = 0; 133 EXPECT_TRUE(manager_->GetClientId(buffer1->service_id(), &client_id)); 134 EXPECT_EQ(kClientBuffer1Id, client_id); 135 manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); 136 EXPECT_EQ(static_cast<GLenum>(GL_ELEMENT_ARRAY_BUFFER), GetTarget(buffer1)); 137 // Check we and set its size. 138 DoBufferData(buffer1, kBuffer1Size, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); 139 EXPECT_EQ(kBuffer1Size, buffer1->size()); 140 EXPECT_EQ(static_cast<GLenum>(GL_DYNAMIC_DRAW), buffer1->usage()); 141 // Check we get nothing for a non-existent buffer. 142 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer2Id) == NULL); 143 // Check trying to a remove non-existent buffers does not crash. 144 manager_->RemoveBuffer(kClientBuffer2Id); 145 // Check that it gets deleted when the last reference is released. 146 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBuffer1Id))) 147 .Times(1) 148 .RetiresOnSaturation(); 149 // Check we can't get the buffer after we remove it. 150 manager_->RemoveBuffer(kClientBuffer1Id); 151 EXPECT_TRUE(manager_->GetBuffer(kClientBuffer1Id) == NULL); 152 } 153 154 TEST_F(BufferManagerMemoryTrackerTest, Basic) { 155 const GLuint kClientBuffer1Id = 1; 156 const GLuint kServiceBuffer1Id = 11; 157 const GLsizeiptr kBuffer1Size1 = 123; 158 const GLsizeiptr kBuffer1Size2 = 456; 159 // Check we can create buffer. 160 EXPECT_MEMORY_ALLOCATION_CHANGE(0, 0, MemoryTracker::kManaged); 161 manager_->CreateBuffer(kClientBuffer1Id, kServiceBuffer1Id); 162 // Check buffer got created. 163 Buffer* buffer1 = manager_->GetBuffer(kClientBuffer1Id); 164 ASSERT_TRUE(buffer1 != NULL); 165 manager_->SetTarget(buffer1, GL_ELEMENT_ARRAY_BUFFER); 166 // Check we and set its size. 167 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size1, MemoryTracker::kManaged); 168 DoBufferData(buffer1, kBuffer1Size1, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); 169 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size1, 0, MemoryTracker::kManaged); 170 EXPECT_MEMORY_ALLOCATION_CHANGE(0, kBuffer1Size2, MemoryTracker::kManaged); 171 DoBufferData(buffer1, kBuffer1Size2, GL_DYNAMIC_DRAW, NULL, GL_NO_ERROR); 172 // On delete it will get freed. 173 EXPECT_MEMORY_ALLOCATION_CHANGE(kBuffer1Size2, 0, MemoryTracker::kManaged); 174 } 175 176 TEST_F(BufferManagerTest, Destroy) { 177 const GLuint kClient1Id = 1; 178 const GLuint kService1Id = 11; 179 // Check we can create buffer. 180 manager_->CreateBuffer(kClient1Id, kService1Id); 181 // Check buffer got created. 182 Buffer* buffer1 = manager_->GetBuffer(kClient1Id); 183 ASSERT_TRUE(buffer1 != NULL); 184 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kService1Id))) 185 .Times(1) 186 .RetiresOnSaturation(); 187 manager_->Destroy(true); 188 // Check the resources were released. 189 buffer1 = manager_->GetBuffer(kClient1Id); 190 ASSERT_TRUE(buffer1 == NULL); 191 } 192 193 TEST_F(BufferManagerTest, DoBufferSubData) { 194 const GLuint kClientBufferId = 1; 195 const GLuint kServiceBufferId = 11; 196 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 197 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 198 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 199 ASSERT_TRUE(buffer != NULL); 200 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 201 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 202 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); 203 EXPECT_TRUE(DoBufferSubData(buffer, sizeof(data), 0, data)); 204 EXPECT_FALSE(DoBufferSubData(buffer, sizeof(data), 1, data)); 205 EXPECT_FALSE(DoBufferSubData(buffer, 0, sizeof(data) + 1, data)); 206 EXPECT_FALSE(DoBufferSubData(buffer, -1, sizeof(data), data)); 207 EXPECT_FALSE(DoBufferSubData(buffer, 0, -1, data)); 208 DoBufferData(buffer, 1, GL_STATIC_DRAW, NULL, GL_NO_ERROR); 209 const int size = 0x20000; 210 scoped_ptr<uint8[]> temp(new uint8[size]); 211 EXPECT_FALSE(DoBufferSubData(buffer, 0 - size, size, temp.get())); 212 EXPECT_FALSE(DoBufferSubData(buffer, 1, size / 2, temp.get())); 213 } 214 215 TEST_F(BufferManagerTest, GetRange) { 216 const GLuint kClientBufferId = 1; 217 const GLuint kServiceBufferId = 11; 218 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 219 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 220 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 221 ASSERT_TRUE(buffer != NULL); 222 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 223 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 224 const char* buf = 225 static_cast<const char*>(buffer->GetRange(0, sizeof(data))); 226 ASSERT_TRUE(buf != NULL); 227 const char* buf1 = 228 static_cast<const char*>(buffer->GetRange(1, sizeof(data) - 1)); 229 EXPECT_EQ(buf + 1, buf1); 230 EXPECT_TRUE(buffer->GetRange(sizeof(data), 1) == NULL); 231 EXPECT_TRUE(buffer->GetRange(0, sizeof(data) + 1) == NULL); 232 EXPECT_TRUE(buffer->GetRange(-1, sizeof(data)) == NULL); 233 EXPECT_TRUE(buffer->GetRange(-0, -1) == NULL); 234 const int size = 0x20000; 235 DoBufferData(buffer, size / 2, GL_STATIC_DRAW, NULL, GL_NO_ERROR); 236 EXPECT_TRUE(buffer->GetRange(0 - size, size) == NULL); 237 EXPECT_TRUE(buffer->GetRange(1, size / 2) == NULL); 238 } 239 240 TEST_F(BufferManagerTest, GetMaxValueForRangeUint8) { 241 const GLuint kClientBufferId = 1; 242 const GLuint kServiceBufferId = 11; 243 const uint8 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 244 const uint8 new_data[] = {100, 120, 110}; 245 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 246 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 247 ASSERT_TRUE(buffer != NULL); 248 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 249 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 250 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); 251 GLuint max_value; 252 // Check entire range succeeds. 253 EXPECT_TRUE(buffer->GetMaxValueForRange( 254 0, 10, GL_UNSIGNED_BYTE, &max_value)); 255 EXPECT_EQ(10u, max_value); 256 // Check sub range succeeds. 257 EXPECT_TRUE(buffer->GetMaxValueForRange( 258 4, 3, GL_UNSIGNED_BYTE, &max_value)); 259 EXPECT_EQ(6u, max_value); 260 // Check changing sub range succeeds. 261 EXPECT_TRUE(DoBufferSubData(buffer, 4, sizeof(new_data), new_data)); 262 EXPECT_TRUE(buffer->GetMaxValueForRange( 263 4, 3, GL_UNSIGNED_BYTE, &max_value)); 264 EXPECT_EQ(120u, max_value); 265 max_value = 0; 266 EXPECT_TRUE(buffer->GetMaxValueForRange( 267 0, 10, GL_UNSIGNED_BYTE, &max_value)); 268 EXPECT_EQ(120u, max_value); 269 // Check out of range fails. 270 EXPECT_FALSE(buffer->GetMaxValueForRange( 271 0, 11, GL_UNSIGNED_BYTE, &max_value)); 272 EXPECT_FALSE(buffer->GetMaxValueForRange( 273 10, 1, GL_UNSIGNED_BYTE, &max_value)); 274 } 275 276 TEST_F(BufferManagerTest, GetMaxValueForRangeUint16) { 277 const GLuint kClientBufferId = 1; 278 const GLuint kServiceBufferId = 11; 279 const uint16 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 280 const uint16 new_data[] = {100, 120, 110}; 281 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 282 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 283 ASSERT_TRUE(buffer != NULL); 284 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 285 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 286 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); 287 GLuint max_value; 288 // Check entire range succeeds. 289 EXPECT_TRUE(buffer->GetMaxValueForRange( 290 0, 10, GL_UNSIGNED_SHORT, &max_value)); 291 EXPECT_EQ(10u, max_value); 292 // Check odd offset fails for GL_UNSIGNED_SHORT. 293 EXPECT_FALSE(buffer->GetMaxValueForRange( 294 1, 10, GL_UNSIGNED_SHORT, &max_value)); 295 // Check sub range succeeds. 296 EXPECT_TRUE(buffer->GetMaxValueForRange( 297 8, 3, GL_UNSIGNED_SHORT, &max_value)); 298 EXPECT_EQ(6u, max_value); 299 // Check changing sub range succeeds. 300 EXPECT_TRUE(DoBufferSubData(buffer, 8, sizeof(new_data), new_data)); 301 EXPECT_TRUE(buffer->GetMaxValueForRange( 302 8, 3, GL_UNSIGNED_SHORT, &max_value)); 303 EXPECT_EQ(120u, max_value); 304 max_value = 0; 305 EXPECT_TRUE(buffer->GetMaxValueForRange( 306 0, 10, GL_UNSIGNED_SHORT, &max_value)); 307 EXPECT_EQ(120u, max_value); 308 // Check out of range fails. 309 EXPECT_FALSE(buffer->GetMaxValueForRange( 310 0, 11, GL_UNSIGNED_SHORT, &max_value)); 311 EXPECT_FALSE(buffer->GetMaxValueForRange( 312 20, 1, GL_UNSIGNED_SHORT, &max_value)); 313 } 314 315 TEST_F(BufferManagerTest, GetMaxValueForRangeUint32) { 316 const GLuint kClientBufferId = 1; 317 const GLuint kServiceBufferId = 11; 318 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 319 const uint32 new_data[] = {100, 120, 110}; 320 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 321 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 322 ASSERT_TRUE(buffer != NULL); 323 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 324 DoBufferData(buffer, sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 325 EXPECT_TRUE(DoBufferSubData(buffer, 0, sizeof(data), data)); 326 GLuint max_value; 327 // Check entire range succeeds. 328 EXPECT_TRUE( 329 buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); 330 EXPECT_EQ(10u, max_value); 331 // Check non aligned offsets fails for GL_UNSIGNED_INT. 332 EXPECT_FALSE( 333 buffer->GetMaxValueForRange(1, 10, GL_UNSIGNED_INT, &max_value)); 334 EXPECT_FALSE( 335 buffer->GetMaxValueForRange(2, 10, GL_UNSIGNED_INT, &max_value)); 336 EXPECT_FALSE( 337 buffer->GetMaxValueForRange(3, 10, GL_UNSIGNED_INT, &max_value)); 338 // Check sub range succeeds. 339 EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); 340 EXPECT_EQ(6u, max_value); 341 // Check changing sub range succeeds. 342 EXPECT_TRUE(DoBufferSubData(buffer, 16, sizeof(new_data), new_data)); 343 EXPECT_TRUE(buffer->GetMaxValueForRange(16, 3, GL_UNSIGNED_INT, &max_value)); 344 EXPECT_EQ(120u, max_value); 345 max_value = 0; 346 EXPECT_TRUE(buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); 347 EXPECT_EQ(120u, max_value); 348 // Check out of range fails. 349 EXPECT_FALSE( 350 buffer->GetMaxValueForRange(0, 11, GL_UNSIGNED_INT, &max_value)); 351 EXPECT_FALSE( 352 buffer->GetMaxValueForRange(40, 1, GL_UNSIGNED_INT, &max_value)); 353 } 354 355 TEST_F(BufferManagerTest, UseDeletedBuffer) { 356 const GLuint kClientBufferId = 1; 357 const GLuint kServiceBufferId = 11; 358 const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 359 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 360 scoped_refptr<Buffer> buffer = manager_->GetBuffer(kClientBufferId); 361 ASSERT_TRUE(buffer.get() != NULL); 362 manager_->SetTarget(buffer.get(), GL_ARRAY_BUFFER); 363 // Remove buffer 364 manager_->RemoveBuffer(kClientBufferId); 365 // Use it after removing 366 DoBufferData(buffer.get(), sizeof(data), GL_STATIC_DRAW, NULL, GL_NO_ERROR); 367 // Check that it gets deleted when the last reference is released. 368 EXPECT_CALL(*gl_, DeleteBuffersARB(1, ::testing::Pointee(kServiceBufferId))) 369 .Times(1) 370 .RetiresOnSaturation(); 371 buffer = NULL; 372 } 373 374 // Test buffers get shadowed when they are supposed to be. 375 TEST_F(BufferManagerClientSideArraysTest, StreamBuffersAreShadowed) { 376 const GLuint kClientBufferId = 1; 377 const GLuint kServiceBufferId = 11; 378 static const uint32 data[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 379 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 380 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 381 ASSERT_TRUE(buffer != NULL); 382 manager_->SetTarget(buffer, GL_ARRAY_BUFFER); 383 DoBufferData(buffer, sizeof(data), GL_STREAM_DRAW, data, GL_NO_ERROR); 384 EXPECT_TRUE(buffer->IsClientSideArray()); 385 EXPECT_EQ(0, memcmp(data, buffer->GetRange(0, sizeof(data)), sizeof(data))); 386 DoBufferData(buffer, sizeof(data), GL_DYNAMIC_DRAW, data, GL_NO_ERROR); 387 EXPECT_FALSE(buffer->IsClientSideArray()); 388 } 389 390 TEST_F(BufferManagerTest, MaxValueCacheClearedCorrectly) { 391 const GLuint kClientBufferId = 1; 392 const GLuint kServiceBufferId = 11; 393 const uint32 data1[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 394 const uint32 data2[] = {11, 12, 13, 14, 15, 16, 17, 18, 19, 20}; 395 const uint32 data3[] = {30, 29, 28}; 396 manager_->CreateBuffer(kClientBufferId, kServiceBufferId); 397 Buffer* buffer = manager_->GetBuffer(kClientBufferId); 398 ASSERT_TRUE(buffer != NULL); 399 manager_->SetTarget(buffer, GL_ELEMENT_ARRAY_BUFFER); 400 GLuint max_value; 401 // Load the buffer with some initial data, and then get the maximum value for 402 // a range, which has the side effect of caching it. 403 DoBufferData(buffer, sizeof(data1), GL_STATIC_DRAW, data1, GL_NO_ERROR); 404 EXPECT_TRUE( 405 buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); 406 EXPECT_EQ(10u, max_value); 407 // Check that any cached values are invalidated if the buffer is reloaded 408 // with the same amount of data (but different content) 409 ASSERT_EQ(sizeof(data2), sizeof(data1)); 410 DoBufferData(buffer, sizeof(data2), GL_STATIC_DRAW, data2, GL_NO_ERROR); 411 EXPECT_TRUE( 412 buffer->GetMaxValueForRange(0, 10, GL_UNSIGNED_INT, &max_value)); 413 EXPECT_EQ(20u, max_value); 414 // Check that any cached values are invalidated if the buffer is reloaded 415 // with entirely different content. 416 ASSERT_NE(sizeof(data3), sizeof(data1)); 417 DoBufferData(buffer, sizeof(data3), GL_STATIC_DRAW, data3, GL_NO_ERROR); 418 EXPECT_TRUE( 419 buffer->GetMaxValueForRange(0, 3, GL_UNSIGNED_INT, &max_value)); 420 EXPECT_EQ(30u, max_value); 421 } 422 423 } // namespace gles2 424 } // namespace gpu 425 426 427
