ae/Renderive
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
712c26a4f9269fce2b1b0de5824e1d3c75559221
Renderive/tests/Memory_Data_Path_Stress.cpp
T

273 lines
14 KiB
C++
Raw Blame History

#include <QApplication>
#include <QElapsedTimer>
#include <QEventLoop>
#include <QThread>
#include <QTime>
#include <gtest/gtest.h>
#include <cmath>
#include <unordered_map>
#include "../Renderive/Axis/Axis.h"
#include "../Renderive/Axis/Frequency_Axis.h"
#include "../Renderive/Axis/Time_Axis.h"
#include "../Renderive/plot/Latency_Eager_Plot.h"
#include "../Renderive/architecture/Timeline_Stream.h"
#include "../Renderive/base/Memory.h"
#include "../Renderive/plottable/Audio_Frequency.h"
#include "../Renderive/plottable/Planisphere.h"
#include "../Renderive/plottable/Waterfall.h"
#include "internal/Renderive_Private_Access.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_ready(const std::shared_ptr<renderive::Waterfall>& waterfall, 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() && time_axis->ok())
return true;
QThread::msleep(1);
}
return false;
}
bool wait_idle(renderive::Latency_Eager_Plot& plot) {
QElapsedTimer timer;
timer.start();
while (timer.elapsed() < 3000) {
QApplication::processEvents(QEventLoop::AllEvents, 10);
if (!plot.is_rendering() && !renderive::Abs_Plot_Private_Access::active_render_tasks(plot))
return true;
QThread::msleep(1);
}
return false;
}
void stress_data_paths() {
renderive::Latency_Eager_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).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);
ASSERT_TRUE(wait_ready(waterfall, time_axis, audio, planisphere));
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->timeline_stream()->push_time(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();
ASSERT_TRUE(wait_idle(plot));
auto* waterfall_data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(waterfall_data->ring_buffer.col_count, frequency_sizes[stage]);
ASSERT_EQ(waterfall_data->ring_buffer.row_count, time_sizes[stage]);
ASSERT_EQ(waterfall_data->image.width(), frequency_sizes[stage]);
ASSERT_EQ(waterfall_data->image.height(), time_sizes[stage]);
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);
ASSERT_NE(expected, expected_frequency.end());
EXPECT_NEAR(waterfall_data->ring_buffer.frequency_data(row, 0, 0)[0], expected->second, 0.000001);
if (row)
EXPECT_GT(tick, previous_tick);
previous_tick = tick;
}
auto* time_data = time_axis->d();
ASSERT_TRUE(time_data->timeline_snapshot);
ASSERT_EQ(time_data->timeline_snapshot->time_point_size, time_sizes[stage]);
ASSERT_EQ(time_data->timeline_snapshot->times.size(), static_cast<std::size_t>(time_sizes[stage]));
ASSERT_FALSE(time_data->timeline_snapshot->times.empty());
EXPECT_EQ(time_data->timeline_snapshot->times.back(), expected_time);
int lower = qMin(time_data->timeline_snapshot->lower, time_data->timeline_snapshot->upper());
int upper = qMax(time_data->timeline_snapshot->lower, time_data->timeline_snapshot->upper());
ASSERT_EQ(time_data->ticks.size(), time_data->timeline_snapshot->ticks.size());
for (const renderive::Timeline_Tick& tick : time_data->timeline_snapshot->ticks) {
EXPECT_GE(tick.tick, lower);
EXPECT_LE(tick.tick, upper);
}
auto* audio_data = renderive::Audio_Frequency_Private_Access::data(audio.get());
ASSERT_EQ(audio_data->point_count, time_sizes[stage]);
ASSERT_EQ(audio_data->power_snapshot.size(), static_cast<std::size_t>(time_sizes[stage]));
ASSERT_NE(audio_data->data_count, 0);
EXPECT_NEAR(audio_data->power_snapshot[audio_data->data_count - 1], expected_power, 0.000001);
auto* planisphere_data = renderive::Planisphere_Private_Access::data(planisphere.get());
ASSERT_FALSE(planisphere_data->data_list.empty());
QPointF actual_position = planisphere_data->data_list.back().pos;
EXPECT_NEAR(actual_position.x(), expected_position.x(), 0.000001);
EXPECT_NEAR(actual_position.y(), expected_position.y(), 0.000001);
plot.start_render(240);
}
for (int frame = 0; frame < 180; ++frame) {
planisphere->set_continue_millisecond(500 + (frame & 1));
process_events(8);
}
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
EXPECT_TRUE(renderive::Planisphere_Private_Access::data(planisphere.get())->data_list.empty());
renderive::Memory_Stats stats = renderive::memory_stats();
EXPECT_GT(stats.upstream_allocation_count, 0);
EXPECT_GT(stats.upstream_peak_bytes, 0);
}
}
TEST(Memory_Data_Path_Stress, KeepsRingAndRenderableDataConsistentAcrossResizes) {
stress_data_paths();
}
TEST(Memory_Data_Path_Stress, WaterfallWritesNewestTimelineRowAtBottom) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(1, 4);
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(1).set_coord_range({0.0, 1.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(4).build();
renderive::Color_Map color_map({qRgb(10, 0, 0), qRgb(20, 0, 0), qRgb(30, 0, 0), qRgb(40, 0, 0)});
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 1.0}).set_power_range({0.0, 4.0}).set_frequency_point_size(1).set_color_map(color_map).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
for (int frame = 0; frame < 4; ++frame) {
std::pmr::vector<double> row(renderive::memory_resource(renderive::Memory_Domain::Waterfall));
row.resize(1);
row[0] = static_cast<double>(frame);
waterfall->give_data(QTime::fromMSecsSinceStartOfDay(frame), std::move(row));
}
process_events(100);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(data->image.width(), 1);
ASSERT_EQ(data->image.height(), 4);
EXPECT_EQ(qRed(data->image.image().pixel(0, 0)), 10);
EXPECT_EQ(qRed(data->image.image().pixel(0, 3)), 40);
}
TEST(Memory_Data_Path_Stress, WaterfallWritesNewestTimelineRowAtTopWhenTimeAxisPushesToStart) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(1, 4);
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(1).set_coord_range({0.0, 1.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(4).set_start_coord_to_end_coord(true).build();
renderive::Color_Map color_map({qRgb(10, 0, 0), qRgb(20, 0, 0), qRgb(30, 0, 0), qRgb(40, 0, 0)});
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 1.0}).set_power_range({0.0, 4.0}).set_frequency_point_size(1).set_color_map(color_map).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
for (int frame = 0; frame < 4; ++frame) {
std::pmr::vector<double> row(renderive::memory_resource(renderive::Memory_Domain::Waterfall));
row.resize(1);
row[0] = static_cast<double>(frame);
waterfall->give_data(QTime::fromMSecsSinceStartOfDay(frame), std::move(row));
}
process_events(100);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
auto* data = renderive::Waterfall_Private_Access::data(waterfall.get());
ASSERT_EQ(data->image.width(), 1);
ASSERT_EQ(data->image.height(), 4);
EXPECT_EQ(qRed(data->image.image().pixel(0, 0)), 40);
EXPECT_EQ(qRed(data->image.image().pixel(0, 3)), 10);
}
TEST(Memory_Data_Path_Stress, DirtyLocalPixelCacheRebuildsAfterInput) {
renderive::Latency_Eager_Plot plot;
plot.init();
plot.resize(1, 4);
auto cache_node = plot.create_renderable_node(plot.get_root_renderable(), "Stream_Cache");
auto data_node = plot.create_renderable_node(cache_node, "Data_Renderable");
auto axis_node = plot.create_renderable_node(plot.get_root_renderable(), "Axis_Renderable");
cache_node->set_cache_mode(renderive::Renderable_Cache_Mode::Local_Pixel);
auto frequency_axis = renderive::Frequency_Axis::Builder(axis_node, Qt::Horizontal).set_pixel_size(1).set_coord_range({0.0, 1.0}).build();
auto time_axis = renderive::Time_Axis::Builder(axis_node, Qt::Vertical).set_pixel_size(4).set_time_point_size(4).build();
renderive::Color_Map color_map({qRgb(10, 0, 0), qRgb(20, 0, 0), qRgb(30, 0, 0), qRgb(40, 0, 0)});
auto waterfall = renderive::Waterfall::Builder(data_node, frequency_axis, time_axis).set_frequency_range({0.0, 1.0}).set_power_range({0.0, 4.0}).set_frequency_point_size(1).set_color_map(color_map).build();
plot.show();
plot.start_render(240);
ASSERT_TRUE(wait_ready(waterfall, time_axis));
process_events(80);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
ASSERT_FALSE(cache_node->cache_image.isNull());
plot.start_render(240);
for (int frame = 0; frame < 4; ++frame) {
std::pmr::vector<double> row(renderive::memory_resource(renderive::Memory_Domain::Waterfall));
row.resize(1);
row[0] = static_cast<double>(frame);
waterfall->give_data(QTime::fromMSecsSinceStartOfDay(frame), std::move(row));
}
process_events(100);
plot.pause_render();
ASSERT_TRUE(wait_idle(plot));
ASSERT_EQ(cache_node->cache_image.width(), 1);
ASSERT_EQ(cache_node->cache_image.height(), 4);
EXPECT_EQ(qRed(cache_node->cache_image.image().pixel(0, 3)), 40);
}
int main(int argc, char** argv) {
qputenv("QT_QPA_PLATFORM", "offscreen");
QApplication app(argc, argv);
testing::InitGoogleTest(&argc, argv);
renderive::start_render_scheduler();
return RUN_ALL_TESTS();
}
Reference in New Issue View Git Blame Copy Permalink