补充提交

2026-07-30 08:07:43 +08:00
parent e7a62b3c02
commit ceb29b1ce2
12 changed files with 800 additions and 0 deletions
@@ -0,0 +1,173 @@
+#include <QApplication>
+#include <QElapsedTimer>
+#include <QEventLoop>
+#include <QThread>
+#include <QTime>
+#include <cmath>
+#include <unordered_map>
+#include "../Renderive/Axis/Axis.h"
+#include "../Renderive/Axis/Frequency_Axis.h"
+#include "../Renderive/Axis/Time_Axis.h"
+#include "../Renderive/Axis/Time_Axis_p.h"
+#include "../Renderive/architecture/Plot.h"
+#include "../Renderive/architecture/Plot_p.h"
+#include "../Renderive/base/Memory.h"
+#include "../Renderive/plottable/Audio_Frequency.h"
+#include "../Renderive/plottable/Audio_Frequency_p.h"
+#include "../Renderive/plottable/Planisphere.h"
+#include "../Renderive/plottable/Planisphere_p.h"
+#include "../Renderive/plottable/Waterfall.h"
+#include "../Renderive/plottable/Waterfall_p.h"
+namespace {
+void process_events(int milliseconds) {
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < milliseconds) {
+        QApplication::processEvents(QEventLoop::AllEvents, 10);
+        QThread::msleep(1);
+    }
+}
+std::vector<double> make_frequency_data(int size, int frame) {
+    std::vector<double> data(size);
+    for (int i = 0; i < size; ++i)
+        data[i] = -90.0 + 30.0 * std::sin(static_cast<double>(i + frame) * 0.017);
+    return data;
+}
+bool wait_ready(const std::shared_ptr<renderive::Waterfall>& waterfall, const std::shared_ptr<renderive::Time_Axis>& time_axis, const std::shared_ptr<renderive::Audio_Frequency>& audio, const std::shared_ptr<renderive::Planisphere>& planisphere) {
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < 3000) {
+        QApplication::processEvents(QEventLoop::AllEvents, 10);
+        if (waterfall->ok() && time_axis->ok() && audio->ok() && planisphere->ok())
+            return true;
+        QThread::msleep(1);
+    }
+    return false;
+}
+bool wait_idle(renderive::Plot& plot) {
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < 3000) {
+        QApplication::processEvents(QEventLoop::AllEvents, 10);
+        if (!plot.is_rendering() && !plot.d->active_render_tasks.load(std::memory_order_acquire))
+            return true;
+        QThread::msleep(1);
+    }
+    return false;
+}
+int stress_data_paths() {
+    renderive::Plot plot;
+    plot.init();
+    plot.resize(720, 420);
+    auto data_node = plot.create_renderable_node(plot.get_root_renderable(), "Data_Renderable");
+    auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
+    auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(700).set_coord_range({0.0, 100.0}).build();
+    auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_time_point_size(32).build();
+    auto value_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_coord_range({-120.0, 0.0}).build();
+    auto i_axis = renderive::Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(700).set_coord_range({-2.0, 2.0}).build();
+    auto q_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(400).set_coord_range({-2.0, 2.0}).build();
+    auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 100.0}).set_power_range({-120.0, 0.0}).set_frequency_point_size(64).build();
+    auto audio = renderive::Audio_Frequency::Builder(data_node, time_axis, value_axis).set_time_point_size(32).set_key_range({-120.0, 0.0}).build();
+    auto planisphere = renderive::Planisphere::Builder(data_node, i_axis, q_axis).set_i_range({-2.0, 2.0}).set_q_range({-2.0, 2.0}).set_continue_millisecond(500).build();
+    plot.show();
+    plot.start_render(240);
+    if (!wait_ready(waterfall, time_axis, audio, planisphere))
+        return 1;
+    const int frequency_sizes[] = {64, 512, 8192, 8193, 128};
+    const int time_sizes[] = {32, 96, 48, 64, 24};
+    const renderive::Waterfall_Update_Mode update_modes[] = {
+        renderive::Waterfall_Update_Mode::Batch,
+        renderive::Waterfall_Update_Mode::Single_Line,
+        renderive::Waterfall_Update_Mode::Timed_Latest,
+        renderive::Waterfall_Update_Mode::Single_Line,
+        renderive::Waterfall_Update_Mode::Batch
+    };
+    for (int stage = 0; stage < 5; ++stage) {
+        waterfall->set_frequency_point_size(frequency_sizes[stage]);
+        waterfall->set_update_mode(update_modes[stage]);
+        waterfall->set_update_interval_ms(2);
+        time_axis->set_time_point_size(time_sizes[stage]);
+        audio->set_time_point_size(time_sizes[stage]);
+        process_events(100);
+        std::unordered_map<int, double> expected_frequency;
+        QTime expected_time;
+        double expected_power{};
+        QPointF expected_position;
+        for (int frame = 0; frame < time_sizes[stage] * 2; ++frame) {
+            std::vector<double> frequency_data = make_frequency_data(frequency_sizes[stage], frame);
+            expected_time = QTime::fromMSecsSinceStartOfDay((stage * 10000 + frame * 4) % 86400000);
+            int tick = time_axis->give_data(expected_time);
+            waterfall->give_data(tick, frequency_data);
+            expected_frequency[tick] = frequency_data.front();
+            expected_power = frequency_data[frame % frequency_data.size()];
+            audio->give_data(tick, expected_power);
+            double phase = static_cast<double>(frame) * 0.13;
+            expected_position = {1.5 * std::cos(phase), 1.5 * std::sin(phase)};
+            planisphere->give_data(expected_position);
+            if ((frame & 3) == 3)
+                process_events(8);
+        }
+        process_events(60);
+        plot.pause_render();
+        if (!wait_idle(plot))
+            return 2;
+        auto* waterfall_data = waterfall->d();
+        if (waterfall_data->ring_buffer.col_count != frequency_sizes[stage] || waterfall_data->ring_buffer.row_count != time_sizes[stage])
+            return 3;
+        if (waterfall_data->image.width() != frequency_sizes[stage] || waterfall_data->image.height() != time_sizes[stage])
+            return 4;
+        int row_count = waterfall_data->ring_buffer.snapshot();
+        int previous_tick{};
+        for (int row = 0; row < row_count; ++row) {
+            int tick = waterfall_data->ring_buffer.tick(row);
+            auto expected = expected_frequency.find(tick);
+            if (expected == expected_frequency.end())
+                return 5;
+            if (std::abs(waterfall_data->ring_buffer.frequency_data(row, 0, 0)[0] - expected->second) > 0.000001)
+                return 6;
+            if (row && tick >= previous_tick)
+                return 7;
+            previous_tick = tick;
+        }
+        auto* time_data = time_axis->d();
+        if (time_data->time_ticker.time_point_size != time_sizes[stage] || time_data->time_snapshot.size() != static_cast<std::size_t>(time_sizes[stage]))
+            return 8;
+        if (!time_data->time_data_count || time_data->time_snapshot[time_data->time_data_count - 1] != expected_time)
+            return 9;
+        int lower = qMin(time_data->time_ticker.lower, time_data->time_ticker.upper());
+        int upper = qMax(time_data->time_ticker.lower, time_data->time_ticker.upper());
+        for (const renderive::Time_Tick& tick : time_data->data) {
+            if (tick.tick < lower || tick.tick > upper)
+                return 10;
+        }
+        auto* audio_data = audio->d();
+        if (audio_data->point_count != time_sizes[stage] || audio_data->power_snapshot.size() != static_cast<std::size_t>(time_sizes[stage]))
+            return 11;
+        if (!audio_data->data_count || std::abs(audio_data->power_snapshot[audio_data->data_count - 1] - expected_power) > 0.000001)
+            return 12;
+        auto* planisphere_data = planisphere->d();
+        if (planisphere_data->data_list.empty())
+            return 13;
+        QPointF actual_position = planisphere_data->data_list.back().pos;
+        if (std::abs(actual_position.x() - expected_position.x()) > 0.000001 || std::abs(actual_position.y() - expected_position.y()) > 0.000001)
+            return 14;
+        plot.start_render(240);
+    }
+    for (int frame = 0; frame < 180; ++frame) {
+        planisphere->set_continue_millisecond(500 + (frame & 1));
+        process_events(8);
+    }
+    plot.pause_render();
+    if (!wait_idle(plot))
+        return 15;
+    if (!planisphere->d()->data_list.empty())
+        return 16;
+    renderive::Memory_Stats stats = renderive::memory_stats();
+    return stats.upstream_allocation_count && stats.upstream_peak_bytes ? 0 : 17;
+}
+}
+int main(int argc, char** argv) {
+    QApplication app(argc, argv);
+    renderive::start_render_scheduler();
+    return stress_data_paths();
+}