/* * idea/realtime/idea_canvas_bench.cpp * Idea System(TM) realtime canvas -- physics-core demo + benchmark. * * Idea System(TM) / Idea(TM). From Author; distributive. * * Exercises the graphics-independent physics core: builds a grid, excites a * few cells, advances many 120 Hz steps under OpenMP, and reports throughput * and a small ASCII intensity map (so the result is legible headless). This * is the part that is BUILT AND VERIFIED in the Idea System environment. */ #include "idea_canvas.h" #include #include #include #if defined(_OPENMP) # include #endif int main(int argc, char **argv) { int cols = argc > 1 ? atoi(argv[1]) : 256; int rows = argc > 2 ? atoi(argv[2]) : 256; int steps = argc > 3 ? atoi(argv[3]) : 1200; /* 10 s at 120 Hz */ idea_canvas *c = idea_canvas_create(cols, rows); if (!c) { std::fprintf(stderr, "create failed\n"); return 1; } idea_sim_params p = idea_sim_defaults(); #if defined(_OPENMP) std::printf("OpenMP: %d threads\n", omp_get_max_threads()); #else std::printf("OpenMP: not enabled (serial)\n"); #endif std::printf("grid: %dx%d (%zu vertices) steps: %d @ %.0f Hz\n", cols, rows, idea_canvas_count(c), steps, IDEA_CANVAS_SIM_HZ); /* excite a few "importance" points */ idea_canvas_excite(c, cols / 2, rows / 2, 1.0f); idea_canvas_excite(c, cols / 4, rows / 4, 0.8f); idea_canvas_excite(c, 3 * cols / 4, 3 * rows / 4, 0.8f); const float dt = (float)idea_canvas_timestep(); auto t0 = std::chrono::steady_clock::now(); for (int i = 0; i < steps; ++i) { if (i % 240 == 0) idea_canvas_excite(c, cols / 2, rows / 2, 0.6f); idea_canvas_step(c, &p, dt); } auto t1 = std::chrono::steady_clock::now(); double secs = std::chrono::duration(t1 - t0).count(); double vps = (double)idea_canvas_count(c) * steps / secs; std::printf("ran %d steps in %.3f s -> %.1f steps/s (%.2f M vertex-updates/s)\n", steps, secs, steps / secs, vps / 1e6); std::printf("headroom vs 120 Hz: %.1fx\n", (steps / secs) / IDEA_CANVAS_SIM_HZ); /* peak / mean intensity so the field is checkable beyond the ASCII ramp */ { const idea_vertex *VV = idea_canvas_vertices_const(c); float peak = 0.0f; double sum = 0.0; for (size_t i = 0; i < idea_canvas_count(c); ++i) { if (VV[i].intensity > peak) peak = VV[i].intensity; sum += VV[i].intensity; } std::printf("field: peak=%.4f mean=%.5f\n", peak, sum / idea_canvas_count(c)); } /* tiny ASCII intensity map (downsampled) */ const char *ramp = " .:-=+*#%@"; const idea_vertex *V = idea_canvas_vertices_const(c); int sw = 40, sh = 16; /* normalise to the current peak so a decayed-but-alive field is legible, * and downsample by MAX over each block so bright cells are not missed. */ float peakv = 1e-6f; for (size_t i = 0; i < idea_canvas_count(c); ++i) if (V[i].intensity > peakv) peakv = V[i].intensity; std::printf("intensity field (normalised to peak=%.3f):\n", peakv); for (int sy = 0; sy < sh; ++sy) { for (int sx = 0; sx < sw; ++sx) { int c0 = (int)((double)sx / sw * cols), c1 = (int)((double)(sx + 1) / sw * cols); int r0 = (int)((double)sy / sh * rows), r1 = (int)((double)(sy + 1) / sh * rows); if (c1 <= c0) c1 = c0 + 1; if (r1 <= r0) r1 = r0 + 1; float m = 0.0f; for (int row = r0; row < r1 && row < rows; ++row) for (int col = c0; col < c1 && col < cols; ++col) { float v = V[(size_t)row * cols + col].intensity; if (v > m) m = v; } int idx = (int)((m / peakv) * 9.0f + 0.5f); if (idx > 9) idx = 9; if (idx < 0) idx = 0; std::putchar(ramp[idx]); } std::putchar('\n'); } idea_canvas_destroy(c); return 0; }