92 lines
3.5 KiB
C++
92 lines
3.5 KiB
C++
#include "render_3D/detail/Render_Domain.h"
|
|
#include <gtest/gtest.h>
|
|
#include <atomic>
|
|
#include <chrono>
|
|
#include <future>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
namespace renderive::render_3d::detail {
|
|
namespace {
|
|
TEST(RenderDomain, SharesDomainPerGpuIndex) {
|
|
auto first = Render_Domain::acquire(0x7ffffffcU);
|
|
auto second = Render_Domain::acquire(0x7ffffffcU);
|
|
auto other = Render_Domain::acquire(0x7ffffffbU);
|
|
EXPECT_EQ(first, second);
|
|
EXPECT_NE(first, other);
|
|
}
|
|
TEST(RenderDomain, PreparedTaskRunsAfterNoThrowHandoff) {
|
|
auto domain = Render_Domain::acquire(0x7ffffffaU);
|
|
std::atomic<bool> executed{};
|
|
auto prepared = domain->prepare([&] {
|
|
executed.store(true, std::memory_order_release);
|
|
}, [](std::exception_ptr) {});
|
|
ASSERT_TRUE(prepared);
|
|
EXPECT_EQ(domain->post(std::move(prepared.task)), Render_Domain::Admission_Result::none);
|
|
EXPECT_TRUE(domain->invoke([] {}));
|
|
EXPECT_TRUE(executed.load(std::memory_order_acquire));
|
|
}
|
|
TEST(RenderDomain, AbandonedPreparedTasksReleaseReservedCapacity) {
|
|
auto domain = Render_Domain::acquire(0x7ffffff9U);
|
|
for (std::size_t index = 0; index < 128; ++index) {
|
|
auto prepared = domain->prepare([] {}, [](std::exception_ptr) {});
|
|
ASSERT_TRUE(prepared);
|
|
}
|
|
EXPECT_TRUE(domain->invoke([] {}));
|
|
}
|
|
TEST(RenderDomain, NestedInvokeExecutesInlineOnTheAffinityThread) {
|
|
auto domain = Render_Domain::acquire(0x7ffffff8U);
|
|
const auto value = domain->invoke([domain] {
|
|
const auto nested = domain->invoke([] {
|
|
return 42;
|
|
});
|
|
if (!nested) throw std::logic_error("nested render-domain invoke unexpectedly stopped");
|
|
return *nested.value;
|
|
});
|
|
ASSERT_TRUE(value);
|
|
EXPECT_EQ(*value.value, 42);
|
|
}
|
|
TEST(RenderDomain, ReportsBoundedAdmissionStatistics) {
|
|
auto domain = Render_Domain::acquire(0x7ffffff7U);
|
|
const auto statistics = domain->statistics();
|
|
EXPECT_EQ(statistics.capacity, 64U);
|
|
EXPECT_TRUE(statistics.admitted <= statistics.capacity);
|
|
EXPECT_TRUE(statistics.queued <= statistics.capacity);
|
|
}
|
|
TEST(RenderDomain, DeliversFireAndForgetExceptionsAndKeepsRunning) {
|
|
auto domain = Render_Domain::acquire(0x7ffffff6U);
|
|
std::promise<std::exception_ptr> delivered;
|
|
auto exception = delivered.get_future();
|
|
EXPECT_EQ(domain->post(
|
|
[] { throw std::runtime_error("unexpected render-domain failure"); },
|
|
[&delivered](std::exception_ptr value) {
|
|
delivered.set_value(std::move(value));
|
|
}),
|
|
Render_Domain::Admission_Result::none);
|
|
ASSERT_EQ(exception.wait_for(std::chrono::seconds(1)),
|
|
std::future_status::ready);
|
|
EXPECT_THROW(std::rethrow_exception(exception.get()), std::runtime_error);
|
|
EXPECT_TRUE(domain->invoke([] {}));
|
|
const auto value = domain->invoke([] {
|
|
return 17;
|
|
});
|
|
ASSERT_TRUE(value);
|
|
EXPECT_EQ(*value.value, 17);
|
|
}
|
|
TEST(RenderDomain, FinalOwnerMayBeReleasedOnAffinityThread) {
|
|
auto domain = Render_Domain::acquire(0x7ffffff5U);
|
|
std::weak_ptr<Render_Domain> weak = domain;
|
|
std::promise<void> released;
|
|
auto finished = released.get_future();
|
|
EXPECT_EQ(domain->post([owned = domain, &released]() mutable {
|
|
owned.reset();
|
|
released.set_value();
|
|
}, [](std::exception_ptr) {}), Render_Domain::Admission_Result::none);
|
|
domain.reset();
|
|
EXPECT_EQ(finished.wait_for(std::chrono::seconds(1)),
|
|
std::future_status::ready);
|
|
EXPECT_TRUE(weak.expired());
|
|
}
|
|
}
|
|
}
|