342 lines
13 KiB
C++
342 lines
13 KiB
C++
// AsyncRegionBuilder(C3) headless 测试（真线程，无需 GPU）：
|
||
// 后台 worker 调公共重组核 reorganizeRegion 从分块 store 重组 RegionTarget→单张
|
||
// VTK_SHORT image；主线程非阻塞 takeLatest 取最新就绪。
|
||
//
|
||
// 验：就绪内容 == 同步重组逐体素一致 / supersede 收敛最新 / 析构忙时干净 join /
|
||
// 并发数百次不崩不死锁 / takeLatest 非阻塞。
|
||
|
||
#include "render/source/AsyncRegionBuilder.hpp"
|
||
#include "render/source/RegionReorganizer.hpp"
|
||
|
||
#include "core/algo/GprVolumeBuilder.hpp"
|
||
#include "data/store/ChunkedVolumeStore.hpp"
|
||
|
||
#include <vtkImageData.h>
|
||
#include <vtkPointData.h>
|
||
#include <vtkShortArray.h>
|
||
|
||
#include <chrono>
|
||
#include <filesystem>
|
||
#include <thread>
|
||
|
||
#include <gtest/gtest.h>
|
||
|
||
using namespace geopro;
|
||
using geopro::render::AsyncRegionBuilder;
|
||
using geopro::render::RegionTarget;
|
||
using geopro::render::reorganizeRegion;
|
||
|
||
namespace {
|
||
|
||
// 造一个含金字塔的 store：值 = 全局 (i+j+k)%1000（便于校验块定位），非 64 整除
|
||
// 维度以含边缘块。返回 store 目录。与 C2 测试同口径。
|
||
std::string makePyramidStore(const std::string& dir, int nx, int ny, int nz,
|
||
int brick, int levels) {
|
||
std::filesystem::remove_all(dir);
|
||
core::BuiltI16 b;
|
||
b.vol = core::ScalarVolumeI16(nx, ny, nz);
|
||
for (int k = 0; k < nz; ++k)
|
||
for (int j = 0; j < ny; ++j)
|
||
for (int i = 0; i < nx; ++i)
|
||
b.vol.at(i, j, k) = static_cast<short>((i + j + k) % 1000);
|
||
b.quant = {1.0, 0.0};
|
||
b.origin = {{1, 2, 3}};
|
||
b.spacing = {{0.5, 0.5, 0.2}};
|
||
b.vminPhys = 0;
|
||
b.vmaxPhys = 1000;
|
||
data::ChunkedVolumeStore::write(dir, b, brick);
|
||
{
|
||
data::ChunkedVolumeStore s(dir);
|
||
s.buildPyramid(levels);
|
||
}
|
||
return dir;
|
||
}
|
||
|
||
void sleepMs(int ms) {
|
||
std::this_thread::sleep_for(std::chrono::milliseconds(ms));
|
||
}
|
||
|
||
// 轮询等就绪（有超时上限，避免卡死）。
|
||
vtkSmartPointer<vtkImageData> waitReady(AsyncRegionBuilder& b, int maxTries = 500,
|
||
int stepMs = 5) {
|
||
vtkSmartPointer<vtkImageData> img;
|
||
for (int i = 0; i < maxTries && img == nullptr; ++i) {
|
||
img = b.takeLatest();
|
||
if (img == nullptr) sleepMs(stepMs);
|
||
}
|
||
return img;
|
||
}
|
||
|
||
// 两图逐体素相等（dims/类型/标量）。
|
||
bool imagesEqual(vtkImageData* a, vtkImageData* b) {
|
||
if (a == nullptr || b == nullptr) return false;
|
||
int da[3], db[3];
|
||
a->GetDimensions(da);
|
||
b->GetDimensions(db);
|
||
if (da[0] != db[0] || da[1] != db[1] || da[2] != db[2]) return false;
|
||
auto* aa = vtkShortArray::SafeDownCast(a->GetPointData()->GetScalars());
|
||
auto* ba = vtkShortArray::SafeDownCast(b->GetPointData()->GetScalars());
|
||
if (aa == nullptr || ba == nullptr) return false;
|
||
const vtkIdType n = aa->GetNumberOfTuples();
|
||
if (n != ba->GetNumberOfTuples()) return false;
|
||
for (vtkIdType i = 0; i < n; ++i)
|
||
if (aa->GetValue(i) != ba->GetValue(i)) return false;
|
||
return true;
|
||
}
|
||
|
||
RegionTarget makeTarget(int level, int bx0, int bx1, int by0, int by1, int bz0,
|
||
int bz1, double exagg = 1.0) {
|
||
RegionTarget t{};
|
||
t.level = level;
|
||
t.bx0 = bx0;
|
||
t.bx1 = bx1;
|
||
t.by0 = by0;
|
||
t.by1 = by1;
|
||
t.bz0 = bz0;
|
||
t.bz1 = bz1;
|
||
t.exagg = exagg;
|
||
return t;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
// ── 就绪内容 == 同步重组逐体素一致 ─────────────────────────────────────────
|
||
TEST(AsyncRegionBuilder, ReconstructsRequestedTargetMatchesSync) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_match").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
const RegionTarget t = makeTarget(1, 0, 2, 0, 1, 0, 1, 1.0);
|
||
|
||
// 同步参考：同一重组核对同一 target。
|
||
data::ChunkedVolumeStore refStore(dir);
|
||
vtkSmartPointer<vtkImageData> sync = reorganizeRegion(refStore, t, 16384);
|
||
ASSERT_NE(sync.Get(), nullptr);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
b.requestTarget(t);
|
||
vtkSmartPointer<vtkImageData> async = waitReady(b);
|
||
ASSERT_NE(async.Get(), nullptr);
|
||
|
||
EXPECT_EQ(async->GetScalarType(), VTK_SHORT);
|
||
EXPECT_TRUE(imagesEqual(async.Get(), sync.Get()));
|
||
}
|
||
|
||
// ── supersede：连发多个不同 target，最终收敛到最后一个，不崩不死锁 ────────────
|
||
TEST(AsyncRegionBuilder, SupersedesStaleRequests) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_super").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
|
||
// 连发若干不同 target，最后一个为期望最终态。
|
||
std::vector<RegionTarget> seq = {
|
||
makeTarget(2, 0, 1, 0, 1, 0, 1),
|
||
makeTarget(1, 0, 2, 0, 1, 0, 1),
|
||
makeTarget(0, 0, 1, 0, 1, 0, 1),
|
||
makeTarget(1, 1, 3, 0, 2, 0, 1), // 最终态
|
||
};
|
||
const RegionTarget last = seq.back();
|
||
for (const auto& t : seq) b.requestTarget(t);
|
||
|
||
// 同步参考 = 最后一个 target。
|
||
data::ChunkedVolumeStore refStore(dir);
|
||
vtkSmartPointer<vtkImageData> sync = reorganizeRegion(refStore, last, 16384);
|
||
ASSERT_NE(sync.Get(), nullptr);
|
||
|
||
// 轮询直到 pending 清空且取到与最终态一致的结果（收敛）。
|
||
vtkSmartPointer<vtkImageData> latest;
|
||
for (int i = 0; i < 800; ++i) {
|
||
auto img = b.takeLatest();
|
||
if (img != nullptr) latest = img;
|
||
if (latest != nullptr && !b.hasPending()) break;
|
||
sleepMs(5);
|
||
}
|
||
ASSERT_NE(latest.Get(), nullptr);
|
||
EXPECT_FALSE(b.hasPending());
|
||
EXPECT_TRUE(imagesEqual(latest.Get(), sync.Get()))
|
||
<< "最终就绪结果应收敛到最后一个 target";
|
||
}
|
||
|
||
// ── 析构忙时干净 join：建后立即析构（worker 在忙）应不崩不死锁不泄漏 ──────────
|
||
TEST(AsyncRegionBuilder, DestructorJoinsCleanly) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_dtor").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
for (int rep = 0; rep < 20; ++rep) {
|
||
AsyncRegionBuilder b(dir);
|
||
// 立刻发请求让 worker 忙起来，随即析构。
|
||
b.requestTarget(makeTarget(0, 0, 3, 0, 2, 0, 1));
|
||
b.requestTarget(makeTarget(1, 0, 2, 0, 1, 0, 1));
|
||
// 不等待，直接离开作用域析构（必须干净 join）。
|
||
}
|
||
SUCCEED(); // 到这里没死锁/崩溃即通过。
|
||
}
|
||
|
||
// ── 并发压力：主线程循环 requestTarget + takeLatest 数百次，worker 并发，不崩 ──
|
||
TEST(AsyncRegionBuilder, ConcurrentStress) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_stress").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
int gotCount = 0;
|
||
for (int i = 0; i < 400; ++i) {
|
||
const int lvl = i % 3;
|
||
const int bx1 = 1 + (i % 2);
|
||
b.requestTarget(makeTarget(lvl, 0, bx1, 0, 1, 0, 1));
|
||
auto img = b.takeLatest(); // 非阻塞
|
||
if (img != nullptr) ++gotCount;
|
||
}
|
||
// 排空：等到最后一批就绪。
|
||
auto fin = waitReady(b);
|
||
EXPECT_NE(fin.Get(), nullptr);
|
||
// 过程中至少取到过若干结果（功能层证明 worker 在产出）。
|
||
EXPECT_GE(gotCount, 0); // 不强求次数，关键是不崩不死锁
|
||
SUCCEED();
|
||
}
|
||
|
||
// ── takeLatest 非阻塞：无结果时立即返回 nullptr，不等待 worker ───────────────
|
||
TEST(AsyncRegionBuilder, TakeLatestNonBlockingWhenEmpty) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_nb").string();
|
||
makePyramidStore(dir, 128, 64, 48, 64, 2);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
// 未发任何请求 → 立即 nullptr（计时应极短）。
|
||
const auto t0 = std::chrono::steady_clock::now();
|
||
auto img = b.takeLatest();
|
||
const auto dtMs = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||
std::chrono::steady_clock::now() - t0)
|
||
.count();
|
||
EXPECT_EQ(img.Get(), nullptr);
|
||
EXPECT_LT(dtMs, 100); // 远小于任一次重组耗时，证明未阻塞等 worker
|
||
}
|
||
|
||
// ── C3-3：轮询某 target 的 getReady 直到非空（带超时）──────────────────────
|
||
vtkSmartPointer<vtkImageData> waitGetReady(AsyncRegionBuilder& b,
|
||
const RegionTarget& t,
|
||
int maxTries = 800, int stepMs = 5) {
|
||
vtkSmartPointer<vtkImageData> img;
|
||
int lv = -1;
|
||
for (int i = 0; i < maxTries && img == nullptr; ++i) {
|
||
img = b.getReady(t, lv);
|
||
if (img == nullptr) sleepMs(stepMs);
|
||
}
|
||
return img;
|
||
}
|
||
|
||
// ── C3-3：预取的目标建好后即刻命中（无需再等）─────────────────────────────
|
||
TEST(AsyncRegionBuilder, PrefetchedTargetReadyImmediately) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_prefetch").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
const RegionTarget cur = makeTarget(1, 0, 2, 0, 1, 0, 1);
|
||
const RegionTarget nxt = makeTarget(1, 1, 3, 0, 2, 0, 1);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
b.requestTarget(cur);
|
||
b.prefetch({nxt});
|
||
|
||
// 等两者都进缓存就绪。
|
||
ASSERT_NE(waitGetReady(b, cur).Get(), nullptr);
|
||
ASSERT_NE(waitGetReady(b, nxt).Get(), nullptr);
|
||
|
||
// 此后 getReady(nxt) 即刻命中（无需再等；计时极短）。
|
||
const auto t0 = std::chrono::steady_clock::now();
|
||
int lv = -1;
|
||
auto hit = b.getReady(nxt, lv);
|
||
const auto dtMs = std::chrono::duration_cast<std::chrono::milliseconds>(
|
||
std::chrono::steady_clock::now() - t0)
|
||
.count();
|
||
ASSERT_NE(hit.Get(), nullptr);
|
||
EXPECT_EQ(lv, nxt.level);
|
||
EXPECT_LT(dtMs, 50);
|
||
|
||
// 内容 == 同步重组（缓存不改内容）。
|
||
data::ChunkedVolumeStore refStore(dir);
|
||
auto sync = reorganizeRegion(refStore, nxt, 16384);
|
||
ASSERT_NE(sync.Get(), nullptr);
|
||
EXPECT_TRUE(imagesEqual(hit.Get(), sync.Get()));
|
||
}
|
||
|
||
// ── C3-3：缓存有界 LRU——请求/预取 > 容量个不同 target → size ≤ N ────────────
|
||
TEST(AsyncRegionBuilder, CacheIsBoundedLru) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_lru").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
const std::size_t cap = 3;
|
||
AsyncRegionBuilder b(dir, cap);
|
||
|
||
// 提交 6 个不同 target（> 容量），逐个等就绪。
|
||
std::vector<RegionTarget> ts = {
|
||
makeTarget(0, 0, 1, 0, 1, 0, 1), makeTarget(0, 1, 2, 0, 1, 0, 1),
|
||
makeTarget(0, 2, 3, 0, 1, 0, 1), makeTarget(1, 0, 1, 0, 1, 0, 1),
|
||
makeTarget(1, 1, 2, 0, 1, 0, 1), makeTarget(2, 0, 1, 0, 1, 0, 1),
|
||
};
|
||
for (const auto& t : ts) {
|
||
b.requestTarget(t);
|
||
ASSERT_NE(waitGetReady(b, t).Get(), nullptr) << "target 未就绪";
|
||
}
|
||
|
||
// 缓存有界：size ≤ 容量。
|
||
EXPECT_LE(b.cacheSize(), cap);
|
||
|
||
// 最久未用的（第一个）应被淘汰：getReady 即刻 nullptr（不重建——非阻塞）。
|
||
int lv = -1;
|
||
EXPECT_EQ(b.getReady(ts.front(), lv).Get(), nullptr)
|
||
<< "最久未用项应已被 LRU 淘汰";
|
||
// 最近的几个仍命中。
|
||
EXPECT_NE(b.getReady(ts.back(), lv).Get(), nullptr);
|
||
}
|
||
|
||
// ── C3-3：相同请求短路——同一 target 连请求多次不重复建（建一次后命中缓存）────
|
||
TEST(AsyncRegionBuilder, IdenticalRequestShortCircuits) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_short").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
AsyncRegionBuilder b(dir);
|
||
const RegionTarget t = makeTarget(1, 0, 2, 0, 1, 0, 1);
|
||
|
||
b.requestTarget(t);
|
||
ASSERT_NE(waitGetReady(b, t).Get(), nullptr);
|
||
|
||
// 已就绪后再连发同一 target：短路（不应再有 pending/在建），缓存仍 1 条。
|
||
for (int i = 0; i < 10; ++i) b.requestTarget(t);
|
||
// 给 worker 一点时间（若误重建会出现 pending/building）。
|
||
sleepMs(50);
|
||
EXPECT_FALSE(b.hasPending()) << "同一已就绪 target 不应触发重建";
|
||
EXPECT_EQ(b.cacheSize(), 1u) << "同一 target 不应在缓存里重复占位";
|
||
|
||
// 短路时主目标仍可经 takeLatest 取到（兼容 C3-1/C3-2）。
|
||
int lv = -1;
|
||
EXPECT_NE(b.getReady(t, lv).Get(), nullptr);
|
||
}
|
||
|
||
// ── C3-3：预取不饿死主目标——大量 prefetch + 一个主 requestTarget → 主先就绪 ──
|
||
TEST(AsyncRegionBuilder, PrefetchDoesNotStarveMainTarget) {
|
||
const auto dir =
|
||
(std::filesystem::temp_directory_path() / "gpr_arb_starve").string();
|
||
makePyramidStore(dir, 200, 80, 60, 64, 3);
|
||
|
||
AsyncRegionBuilder b(dir, /*cap*/ 6);
|
||
|
||
// 先灌大量预取（不同 target），再设主目标。
|
||
std::vector<RegionTarget> many;
|
||
for (int i = 0; i < 12; ++i)
|
||
many.push_back(makeTarget(0, i % 3, (i % 3) + 1, 0, 1, 0, 1, 1.0 + i));
|
||
b.prefetch(many);
|
||
|
||
const RegionTarget main = makeTarget(2, 0, 1, 0, 1, 0, 1);
|
||
b.requestTarget(main);
|
||
|
||
// 主目标应优先就绪（轮询 getReady(main) 命中）。
|
||
ASSERT_NE(waitGetReady(b, main, 800, 2).Get(), nullptr)
|
||
<< "预取饿死了主目标";
|
||
}
|