| // Copyright 2017 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <limits> |
| |
| #include "mock/mock_bus_mapper.h" |
| #include "gtest/gtest.h" |
| |
| #include "address_manager.h" |
| #include "gpu_mapping.h" |
| #include "msd_arm_buffer.h" |
| #include "msd_arm_connection.h" |
| |
| namespace { |
| |
| class TestAddressSpaceObserver : public AddressSpaceObserver { |
| public: |
| void FlushAddressMappingRange(AddressSpace*, uint64_t start, uint64_t length, |
| bool synchronous) override |
| { |
| } |
| void UnlockAddressSpace(AddressSpace* address_space) override |
| { |
| unlocked_address_spaces_.push_back(address_space); |
| } |
| void ReleaseSpaceMappings(const AddressSpace* address_space) override {} |
| |
| const std::vector<AddressSpace*>& unlocked_address_spaces() const |
| { |
| return unlocked_address_spaces_; |
| } |
| |
| private: |
| std::vector<AddressSpace*> unlocked_address_spaces_; |
| }; |
| |
| class FakeConnectionOwner : public MsdArmConnection::Owner { |
| public: |
| FakeConnectionOwner() {} |
| |
| void ScheduleAtom(std::shared_ptr<MsdArmAtom> atom) override { atoms_list_.push_back(atom); } |
| void CancelAtoms(std::shared_ptr<MsdArmConnection> connection) override |
| { |
| cancel_atoms_list_.push_back(connection.get()); |
| } |
| AddressSpaceObserver* GetAddressSpaceObserver() override { return &observer_; } |
| TestAddressSpaceObserver* GetTestAddressSpaceObserver() { return &observer_; } |
| magma::PlatformBusMapper* GetBusMapper() override { return &bus_mapper_; } |
| ArmMaliCacheCoherencyStatus cache_coherency_status() override |
| { |
| return kArmMaliCacheCoherencyAce; |
| } |
| |
| const std::vector<MsdArmConnection*>& cancel_atoms_list() { return cancel_atoms_list_; } |
| const std::vector<std::shared_ptr<MsdArmAtom>>& atoms_list() { return atoms_list_; } |
| |
| private: |
| TestAddressSpaceObserver observer_; |
| MockConsistentBusMapper bus_mapper_; |
| std::vector<MsdArmConnection*> cancel_atoms_list_; |
| std::vector<std::shared_ptr<MsdArmAtom>> atoms_list_; |
| }; |
| |
| class DeregisterConnectionOwner : public FakeConnectionOwner { |
| public: |
| void set_connection(std::weak_ptr<MsdArmConnection> connection) { connection_ = connection; } |
| void DeregisterConnection() override { EXPECT_TRUE(connection_.expired()); } |
| |
| private: |
| std::weak_ptr<MsdArmConnection> connection_; |
| }; |
| |
| void* g_test_token; |
| uint32_t g_test_data_size; |
| magma_arm_mali_status g_status; |
| |
| void TestCallback(void* token, msd_notification_t* notification) |
| { |
| g_test_token = token; |
| if (notification->type == MSD_CONNECTION_NOTIFICATION_CHANNEL_SEND) { |
| g_test_data_size = notification->u.channel_send.size; |
| memcpy(&g_status, notification->u.channel_send.data, g_test_data_size); |
| } |
| } |
| } // namespace |
| |
| class TestConnection { |
| public: |
| void MapUnmap() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| |
| // GPU VA not page aligned |
| EXPECT_FALSE(connection->AddMapping( |
| std::make_unique<GpuMapping>(1, 0, 1, 0, connection.get(), buffer))); |
| |
| // Empty GPU VA. |
| EXPECT_FALSE(connection->AddMapping( |
| std::make_unique<GpuMapping>(PAGE_SIZE, 0, 0, 0, connection.get(), buffer))); |
| |
| // size would overflow. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 0, std::numeric_limits<uint64_t>::max() - PAGE_SIZE * 100 + 1, 0, |
| connection.get(), buffer))); |
| |
| // GPU VA would be larger than 48 bits wide. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 0, (1ul << 48) - 999 * PAGE_SIZE, 0, connection.get(), buffer))); |
| |
| // Map is too large for buffer. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 0, PAGE_SIZE * 101, 0, connection.get(), buffer))); |
| |
| // Map is past end of buffer due to offset. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 1, PAGE_SIZE * 100, 0, connection.get(), buffer))); |
| |
| // Page offset would overflow. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, std::numeric_limits<uint64_t>::max() / PAGE_SIZE, PAGE_SIZE * 100, 0, |
| connection.get(), buffer))); |
| |
| // Invalid flags. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 0, PAGE_SIZE * 100, (1 << 14), connection.get(), buffer))); |
| |
| EXPECT_TRUE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1000 * PAGE_SIZE, 0, PAGE_SIZE * 100, 0, connection.get(), buffer))); |
| |
| // Mapping would overlap previous mapping. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1001 * PAGE_SIZE, 0, PAGE_SIZE * 99, 0, connection.get(), buffer))); |
| |
| // Mapping would overlap next mapping. |
| EXPECT_FALSE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 999 * PAGE_SIZE, 0, PAGE_SIZE * 100, 0, connection.get(), buffer))); |
| |
| EXPECT_TRUE(connection->AddMapping(std::make_unique<GpuMapping>( |
| 1100 * PAGE_SIZE, 0, PAGE_SIZE * 100, 0, connection.get(), buffer))); |
| |
| EXPECT_FALSE(connection->RemoveMapping(1001 * PAGE_SIZE)); |
| |
| EXPECT_TRUE(connection->RemoveMapping(1000 * PAGE_SIZE)); |
| |
| buffer.reset(); |
| |
| // Mapping should already have been removed by buffer deletion. |
| EXPECT_FALSE(connection->RemoveMapping(1100 * PAGE_SIZE)); |
| } |
| |
| void CommitMemory() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| AddressSpace* address_space = connection->address_space_for_testing(); |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| |
| constexpr uint64_t kGpuOffset[] = {1000, 1100}; |
| |
| auto mapping0 = std::make_unique<GpuMapping>(kGpuOffset[0] * PAGE_SIZE, 1, PAGE_SIZE * 99, |
| 0, connection.get(), buffer); |
| GpuMapping* mapping0_ptr = mapping0.get(); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping0))); |
| |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 1)); |
| mali_pte_t pte; |
| constexpr uint64_t kInvalidPte = 2u; |
| // Only the first page should be committed. |
| EXPECT_TRUE(address_space->ReadPteForTesting(kGpuOffset[0] * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 1) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| |
| // Should be legal to map with pages already committed. |
| EXPECT_TRUE(connection->AddMapping(std::make_unique<GpuMapping>( |
| kGpuOffset[1] * PAGE_SIZE, 1, PAGE_SIZE * 2, 0, connection.get(), buffer))); |
| |
| EXPECT_TRUE(address_space->ReadPteForTesting(kGpuOffset[1] * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 5)); |
| |
| ASSERT_EQ(2u, mapping0_ptr->bus_mappings_.size()); |
| EXPECT_EQ(1u, mapping0_ptr->bus_mappings_[0]->page_count()); |
| EXPECT_EQ(2u, mapping0_ptr->bus_mappings_[1]->page_offset()); |
| EXPECT_EQ(4u, mapping0_ptr->bus_mappings_[1]->page_count()); |
| |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[1] + 1) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| // The mapping should be truncated because it's only for 2 pages. |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[1] + 2) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 4) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| |
| EXPECT_TRUE(connection->RemoveMapping(kGpuOffset[1] * PAGE_SIZE)); |
| |
| // Should unmap the last page. |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 4)); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 4) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| ASSERT_EQ(1u, mapping0_ptr->bus_mappings_.size()); |
| EXPECT_EQ(1u, mapping0_ptr->bus_mappings_[0]->page_offset()); |
| EXPECT_EQ(4u, mapping0_ptr->bus_mappings_[0]->page_count()); |
| EXPECT_EQ(4u, mapping0_ptr->pinned_page_count()); |
| |
| // Should be ignored because offset isn't supported. |
| EXPECT_FALSE(connection->CommitMemoryForBuffer(buffer.get(), 0, 6)); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 4) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| |
| // Can decommit entire buffer. |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 0)); |
| EXPECT_FALSE(address_space->ReadPteForTesting(kGpuOffset[0] * PAGE_SIZE, &pte)); |
| } |
| |
| void CommitLargeBuffer() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = 1ul << 35; // 32 GB |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| MsdArmAbiBuffer abi_buffer(buffer); |
| |
| constexpr uint64_t kGpuOffset[] = {1000, 1100}; |
| |
| EXPECT_TRUE(connection->AddMapping(std::make_unique<GpuMapping>( |
| kGpuOffset[0] * PAGE_SIZE, 0, PAGE_SIZE * 100, 0, connection.get(), buffer))); |
| |
| // Committing 1 page should be fine. |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 0, 1)); |
| |
| // MockBusMapper will fail committing the entire region. |
| EXPECT_TRUE(connection->AddMapping(std::make_unique<GpuMapping>( |
| kGpuOffset[1] * PAGE_SIZE, 0, kBufferSize, 0, connection.get(), buffer))); |
| |
| EXPECT_FALSE(connection->CommitMemoryForBuffer(buffer.get(), 0, kBufferSize / PAGE_SIZE)); |
| } |
| |
| void GrowableMemory() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| AddressSpace* address_space = connection->address_space_for_testing(); |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| |
| constexpr uint64_t kGpuOffset[] = {1000, 1100}; |
| |
| EXPECT_TRUE(connection->AddMapping( |
| std::make_unique<GpuMapping>(kGpuOffset[0] * PAGE_SIZE, 1, PAGE_SIZE * 95, |
| MAGMA_GPU_MAP_FLAG_GROWABLE, connection.get(), buffer))); |
| EXPECT_TRUE(connection->AddMapping( |
| std::make_unique<GpuMapping>(kGpuOffset[1] * PAGE_SIZE, 1, PAGE_SIZE * 95, |
| MAGMA_GPU_MAP_FLAG_GROWABLE, connection.get(), buffer))); |
| |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 1)); |
| mali_pte_t pte; |
| constexpr uint64_t kInvalidPte = 2u; |
| // Only the first page should be committed. |
| EXPECT_TRUE(address_space->ReadPteForTesting(kGpuOffset[0] * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 1) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| |
| EXPECT_FALSE(connection->PageInMemory((kGpuOffset[0] + 95) * PAGE_SIZE)); |
| |
| // Should grow to a 64-page boundary. |
| EXPECT_TRUE(connection->PageInMemory((kGpuOffset[0] + 1) * PAGE_SIZE)); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 1) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 63) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 64) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| |
| // Second mapping should also be grown. |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[1] + 1) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| |
| // Should be growable up to last page of mapping. |
| EXPECT_TRUE(connection->PageInMemory((kGpuOffset[0] + 94) * PAGE_SIZE)); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 94) * PAGE_SIZE, &pte)); |
| EXPECT_NE(kInvalidPte, pte); |
| EXPECT_TRUE(address_space->ReadPteForTesting((kGpuOffset[0] + 95) * PAGE_SIZE, &pte)); |
| EXPECT_EQ(kInvalidPte, pte); |
| |
| // Address space size didn't change, so it should be unlocked. |
| EXPECT_EQ(0u, owner.GetTestAddressSpaceObserver()->unlocked_address_spaces().size()); |
| EXPECT_TRUE(connection->PageInMemory((kGpuOffset[0] + 94) * PAGE_SIZE)); |
| EXPECT_LE(1u, owner.GetTestAddressSpaceObserver()->unlocked_address_spaces().size()); |
| } |
| |
| void Notification() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| MsdArmAtom atom(connection, 0, 1, 5, magma_arm_mali_user_data{7, 8}, 0); |
| |
| // Shouldn't do anything. |
| connection->SendNotificationData(&atom, static_cast<ArmMaliResultCode>(10)); |
| |
| uint32_t token; |
| connection->SetNotificationCallback(&TestCallback, &token); |
| connection->SendNotificationData(&atom, static_cast<ArmMaliResultCode>(20)); |
| EXPECT_EQ(sizeof(g_status), g_test_data_size); |
| EXPECT_EQ(&token, g_test_token); |
| |
| EXPECT_EQ(7u, g_status.data.data[0]); |
| EXPECT_EQ(8u, g_status.data.data[1]); |
| EXPECT_EQ(20u, g_status.result_code); |
| EXPECT_EQ(5u, g_status.atom_number); |
| |
| connection->SetNotificationCallback(nullptr, nullptr); |
| connection->SendNotificationData(&atom, static_cast<ArmMaliResultCode>(20)); |
| |
| EXPECT_EQ(20u, g_status.result_code); |
| } |
| |
| void DestructionNotification() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| |
| uint32_t token; |
| connection->SetNotificationCallback(&TestCallback, &token); |
| connection->MarkDestroyed(); |
| |
| EXPECT_EQ(sizeof(g_status), g_test_data_size); |
| EXPECT_EQ(&token, g_test_token); |
| |
| EXPECT_EQ(0u, g_status.data.data[0]); |
| EXPECT_EQ(0u, g_status.data.data[1]); |
| EXPECT_EQ(0u, g_status.atom_number); |
| EXPECT_EQ(kArmMaliResultTerminated, g_status.result_code); |
| |
| // Shouldn't do anything. |
| MsdArmAtom atom(connection, 0, 1, 5, magma_arm_mali_user_data{7, 8}, 0); |
| connection->SendNotificationData(&atom, static_cast<ArmMaliResultCode>(10)); |
| EXPECT_EQ(kArmMaliResultTerminated, g_status.result_code); |
| |
| connection->SetNotificationCallback(nullptr, 0); |
| |
| EXPECT_EQ(1u, owner.cancel_atoms_list().size()); |
| EXPECT_EQ(connection.get(), owner.cancel_atoms_list()[0]); |
| } |
| |
| void SoftwareAtom() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| |
| magma_arm_mali_atom client_atom = {}; |
| client_atom.flags = kAtomFlagSemaphoreWait; |
| std::deque<std::shared_ptr<magma::PlatformSemaphore>> semaphores; |
| EXPECT_FALSE(connection->ExecuteAtom(&client_atom, &semaphores)); |
| |
| std::shared_ptr<magma::PlatformSemaphore> semaphore(magma::PlatformSemaphore::Create()); |
| semaphores.push_back(semaphore); |
| EXPECT_TRUE(connection->ExecuteAtom(&client_atom, &semaphores)); |
| |
| EXPECT_EQ(1u, owner.atoms_list().size()); |
| std::shared_ptr<MsdArmAtom> atom = owner.atoms_list()[0]; |
| std::shared_ptr<MsdArmSoftAtom> soft_atom = MsdArmSoftAtom::cast(atom); |
| EXPECT_TRUE(!!soft_atom); |
| EXPECT_EQ(kAtomFlagSemaphoreWait, soft_atom->soft_flags()); |
| EXPECT_EQ(semaphore, soft_atom->platform_semaphore()); |
| } |
| |
| void FlushRegion() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| |
| constexpr uint64_t kGpuOffset[] = {1000, 1100, 1200}; |
| |
| auto mapping0 = std::make_unique<GpuMapping>(kGpuOffset[0] * PAGE_SIZE, 1, PAGE_SIZE * 5, 0, |
| connection.get(), buffer); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping0))); |
| |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 99)); |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE), buffer->flushed_region_start_bytes_); |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE * 6), buffer->flushed_region_end_bytes_); |
| |
| auto mapping1 = std::make_unique<GpuMapping>(kGpuOffset[1] * PAGE_SIZE, 1, PAGE_SIZE * 6, 0, |
| connection.get(), buffer); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping1))); |
| |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE), buffer->flushed_region_start_bytes_); |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE * 7), buffer->flushed_region_end_bytes_); |
| |
| // Outer cache-coherent mappings shouldn't flush pages. |
| auto mapping2 = std::make_unique<GpuMapping>(kGpuOffset[2] * PAGE_SIZE, 1, PAGE_SIZE * 99, |
| kMagmaArmMaliGpuMapFlagBothShareable, |
| connection.get(), buffer); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping2))); |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE), buffer->flushed_region_start_bytes_); |
| EXPECT_EQ(static_cast<uint32_t>(PAGE_SIZE * 7), buffer->flushed_region_end_bytes_); |
| } |
| |
| void FlushUncachedRegion() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| EXPECT_TRUE(buffer->platform_buffer()->SetCachePolicy(MAGMA_CACHE_POLICY_UNCACHED)); |
| |
| constexpr uint64_t kGpuOffset = 1000; |
| auto mapping = std::make_unique<GpuMapping>(kGpuOffset * PAGE_SIZE, 1, PAGE_SIZE * 99, 0, |
| connection.get(), buffer); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping))); |
| |
| // Mappings of uncached buffers shouldn't flush pages. |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), 1, 1)); |
| EXPECT_EQ(0u, buffer->flushed_region_start_bytes_); |
| EXPECT_EQ(0u, buffer->flushed_region_end_bytes_); |
| } |
| |
| void PhysicalToVirtual() |
| { |
| FakeConnectionOwner owner; |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| constexpr uint64_t kBufferSize = PAGE_SIZE * 100; |
| |
| std::shared_ptr<MsdArmBuffer> buffer( |
| MsdArmBuffer::Create(kBufferSize, "test-buffer").release()); |
| EXPECT_TRUE(buffer); |
| |
| constexpr uint64_t kGpuOffset = 1100; |
| constexpr uint32_t kMappingOffsetInPages = 1; |
| |
| auto mapping = std::make_unique<GpuMapping>(kGpuOffset * PAGE_SIZE, kMappingOffsetInPages, |
| PAGE_SIZE * 5, 0, connection.get(), buffer); |
| EXPECT_TRUE(connection->AddMapping(std::move(mapping))); |
| EXPECT_TRUE(connection->CommitMemoryForBuffer(buffer.get(), kMappingOffsetInPages, 2)); |
| |
| auto bus_mapping = owner.GetBusMapper()->MapPageRangeBus(buffer->platform_buffer(), 0, 100); |
| constexpr uint32_t kPageOffsetIntoBuffer = 2; |
| uint64_t physical = bus_mapping->Get()[kPageOffsetIntoBuffer] + 300; |
| uint64_t virtual_address; |
| EXPECT_TRUE(connection->GetVirtualAddressFromPhysical(physical, &virtual_address)); |
| EXPECT_EQ((kGpuOffset + kPageOffsetIntoBuffer - kMappingOffsetInPages) * PAGE_SIZE + 300, |
| virtual_address); |
| |
| // Don't check uncommitted pages inside mapping. |
| physical = bus_mapping->Get()[4] + 300; |
| EXPECT_FALSE(connection->GetVirtualAddressFromPhysical(physical, &virtual_address)); |
| |
| // Don't check pages after mapping. |
| physical = bus_mapping->Get()[6] + 300; |
| EXPECT_FALSE(connection->GetVirtualAddressFromPhysical(physical, &virtual_address)); |
| |
| // Don't check pages before mapping. |
| physical = bus_mapping->Get()[0] + 300; |
| EXPECT_FALSE(connection->GetVirtualAddressFromPhysical(physical, &virtual_address)); |
| } |
| |
| void DeregisterConnection() |
| { |
| DeregisterConnectionOwner owner; |
| { |
| auto connection = MsdArmConnection::Create(0, &owner); |
| EXPECT_TRUE(connection); |
| owner.set_connection(connection); |
| } |
| } |
| }; |
| |
| TEST(TestConnection, MapUnmap) |
| { |
| TestConnection test; |
| test.MapUnmap(); |
| } |
| |
| TEST(TestConnection, CommitMemory) |
| { |
| TestConnection test; |
| test.CommitMemory(); |
| } |
| |
| TEST(TestConnection, CommitLargeBuffer) |
| { |
| TestConnection test; |
| test.CommitLargeBuffer(); |
| } |
| |
| TEST(TestConnection, Notification) |
| { |
| TestConnection test; |
| test.Notification(); |
| } |
| |
| TEST(TestConnection, DestructionNotification) |
| { |
| TestConnection test; |
| test.DestructionNotification(); |
| } |
| |
| TEST(TestConnection, SoftwareAtom) |
| { |
| TestConnection test; |
| test.SoftwareAtom(); |
| } |
| |
| TEST(TestConnection, GrowableMemory) |
| { |
| TestConnection test; |
| test.GrowableMemory(); |
| } |
| |
| TEST(TestConnection, FlushRegion) |
| { |
| TestConnection test; |
| test.FlushRegion(); |
| } |
| |
| TEST(TestConnection, FlushUncachedRegion) |
| { |
| TestConnection test; |
| test.FlushUncachedRegion(); |
| } |
| |
| TEST(TestConnection, PhysicalToVirtual) |
| { |
| TestConnection test; |
| test.PhysicalToVirtual(); |
| } |
| |
| TEST(TestConnection, DeregisterConnection) |
| { |
| TestConnection test; |
| test.DeregisterConnection(); |
| } |
