负反馈模型测试成功

2026-07-30 11:21:30 +08:00
parent ceb29b1ce2
commit 9271599723
31 changed files with 3649 additions and 1981 deletions
@@ -0,0 +1,111 @@
+#include <QApplication>
+#include <QElapsedTimer>
+#include <QEventLoop>
+#include <QThread>
+#include <QTime>
+#include <atomic>
+#include <cmath>
+#include <thread>
+#include <vector>
+#include "../Renderive/Axis/Axis.h"
+#include "../Renderive/Axis/Frequency_Axis.h"
+#include "../Renderive/Axis/Time_Axis.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/Spectrum.h"
+#include "../Renderive/plottable/Waterfall.h"
+namespace {
+std::pmr::vector<double> make_data(int size, int seed, renderive::Memory_Domain domain) {
+    std::pmr::vector<double> data(renderive::memory_resource(domain));
+    data.resize(size);
+    for (int i = 0; i < size; ++i)
+        data[i] = -90.0 + 30.0 * std::sin(static_cast<double>(i + seed) * 0.017);
+    return data;
+}
+void process_events(int milliseconds) {
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < milliseconds) {
+        QApplication::processEvents(QEventLoop::AllEvents, 10);
+        QThread::msleep(1);
+    }
+}
+bool wait_ready(const std::shared_ptr<renderive::Waterfall>& waterfall, const std::shared_ptr<renderive::Spectrum>& spectrum, const std::shared_ptr<renderive::Audio_Frequency>& audio, const std::shared_ptr<renderive::Time_Axis>& time_axis) {
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < 3000) {
+        QApplication::processEvents(QEventLoop::AllEvents, 10);
+        if (waterfall->ok() && spectrum->ok() && audio->ok() && time_axis->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 run_stress() {
+    renderive::Plot plot;
+    plot.init();
+    plot.resize(640, 360);
+    plot.set_max_render_fps(1000);
+    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(640).set_coord_range({0.0, 100.0}).build();
+    auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(360).set_time_point_size(128).build();
+    auto power_axis = renderive::Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(360).set_coord_range({0.0, -120.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(256).build();
+    auto spectrum = renderive::Spectrum::Builder(data_node, frequency_axis, power_axis).set_frequency_range({0.0, 100.0}).set_frequency_point_size(256).build();
+    auto audio = renderive::Audio_Frequency::Builder(data_node, time_axis, power_axis).set_time_point_size(128).set_key_range({-120.0, 0.0}).build();
+    plot.show();
+    plot.start_render(1000);
+    if (!wait_ready(waterfall, spectrum, audio, time_axis))
+        return 1;
+    std::atomic_bool running{true};
+    std::atomic<int> pushes{0};
+    std::vector<std::thread> workers;
+    for (int thread_index = 0; thread_index < 4; ++thread_index) {
+        workers.emplace_back([&, thread_index]() {
+            for (int frame = 0; running.load(std::memory_order_acquire) && frame < 2500; ++frame) {
+                int seed = frame + thread_index * 10000;
+                QTime time = QTime::fromMSecsSinceStartOfDay(seed % 86400000);
+                int tick = time_axis->give_data(time);
+                waterfall->give_data(tick, make_data(256, seed, renderive::Memory_Domain::Waterfall));
+                spectrum->give_data(make_data(256, seed, renderive::Memory_Domain::Spectrum));
+                audio->give_data(tick, -90.0 + static_cast<double>((seed % 120)));
+                pushes.fetch_add(1, std::memory_order_relaxed);
+                if ((frame & 15) == 15)
+                    std::this_thread::yield();
+            }
+        });
+    }
+    QElapsedTimer timer;
+    timer.start();
+    while (timer.elapsed() < 8000 && pushes.load(std::memory_order_relaxed) < 10000)
+        process_events(5);
+    running.store(false, std::memory_order_release);
+    for (auto& worker : workers)
+        worker.join();
+    process_events(300);
+    plot.pause_render();
+    if (!wait_idle(plot))
+        return 2;
+    return pushes.load(std::memory_order_relaxed) > 1000 ? 0 : 3;
+}
+}
+int main(int argc, char** argv) {
+    qputenv("QT_QPA_PLATFORM", "offscreen");
+    QApplication app(argc, argv);
+    renderive::start_render_scheduler();
+    return run_stress();
+}