From b1f78f2cddbcf1e137acb13c31b46e06d3012c58 Mon Sep 17 00:00:00 2001 From: Paul Oliver Date: Sat, 11 Apr 2026 14:07:37 +0200 Subject: Adds heatmaps --- arch/dummy/arch_vars.py | 1 + arch/v1/arch.c | 40 ++++----- arch/v1/arch_vars.py | 10 ++- core.c | 94 ++++++++------------- data/compress.c | 56 +++++++++++++ data/render.c | 86 ++++++++++++++++++++ data/vue/App.vue | 212 +++++++++++++++++++++++++++++++++--------------- data/vue/Plot.vue | 104 +++++++++++++++--------- data/vue/Section.vue | 4 +- salis.py | 80 ++++++++++++++++-- 10 files changed, 490 insertions(+), 197 deletions(-) create mode 100644 data/compress.c create mode 100644 data/render.c diff --git a/arch/dummy/arch_vars.py b/arch/dummy/arch_vars.py index 6e37eca..c8d5e55 100644 --- a/arch/dummy/arch_vars.py +++ b/arch/dummy/arch_vars.py @@ -25,3 +25,4 @@ class ArchVars: ] self.plots = {} + self.heatmaps = {} diff --git a/arch/v1/arch.c b/arch/v1/arch.c index 152a97d..49d9db5 100644 --- a/arch/v1/arch.c +++ b/arch/v1/arch.c @@ -47,7 +47,7 @@ void arch_core_save(FILE *f, const struct Core *core) { fwrite(&core->wdea, sizeof(uint64_t), 1, f); #if defined(DATA_PUSH_PATH) - //fwrite(core->weva, sizeof(uint64_t), MVEC_SIZE, f); + fwrite(core->weva, sizeof(uint64_t), MVEC_SIZE, f); #endif } #endif @@ -64,7 +64,7 @@ void arch_core_load(FILE *f, struct Core *core) { fread(&core->wdea, sizeof(uint64_t), 1, f); #if defined(DATA_PUSH_PATH) - //fread(core->weva, sizeof(uint64_t), MVEC_SIZE, f); + fread(core->weva, sizeof(uint64_t), MVEC_SIZE, f); #endif } #endif @@ -626,19 +626,22 @@ void _write(struct Core *core, uint64_t pix) { if (_is_writeable_by(core, *regs[0], pix)) { // Store write event uint8_t inst = *regs[1] % INST_COUNT; + uint8_t inst_rep = *regs[1] % INST_CAP; + uint64_t addr = *regs[0]; ++core->iwrt[inst]; + ++core->weva[addr]; - if (mvec_is_in_mb0_of_proc(core, *regs[0], pix)) { + if (mvec_is_in_mb0_of_proc(core, addr, pix)) { ++core->wmb0; - } else if (mvec_is_in_mb1_of_proc(core, *regs[0], pix)) { + } else if (mvec_is_in_mb1_of_proc(core, addr, pix)) { ++core->wmb1; } else { ++core->wdea; } // Write instruction - mvec_set_inst(core, *regs[0], *regs[1] % INST_CAP); + mvec_set_inst(core, addr, inst_rep); } _increment_ip(core, pix); @@ -860,7 +863,7 @@ void arch_push_data_header() { } // Memory events - char *eprefs[] = { /* "wev" */ }; + char *eprefs[] = { "wev" }; int eprefs_cnt = sizeof(eprefs) / sizeof(eprefs[0]); for (int i = 0; i < CORES; ++i) { @@ -984,16 +987,16 @@ void arch_push_data_line() { } // TODO: insert write memory events - char *eprefs[] = { /* "wev" */ }; + char *eprefs[] = { "wev" }; int eprefs_cnt = sizeof(eprefs) / sizeof(eprefs[0]); for (int i = 0; i < CORES; ++i) { for (int j = 0; j < eprefs_cnt; ++j) { uint64_t *in = NULL; - //if (!strcmp("wev", eprefs[j])) { - // in = g_cores[i].weva; - //} + if (!strcmp("wev", eprefs[j])) { + in = g_cores[i].weva; + } // Compress event data size_t size = sizeof(uint64_t) * MVEC_SIZE; @@ -1001,18 +1004,7 @@ void arch_push_data_line() { assert(out); z_stream strm = { 0 }; - strm.zalloc = NULL; - strm.zfree = NULL; - strm.opaque = NULL; - - deflateInit(&strm, Z_DEFAULT_COMPRESSION); - - strm.avail_in = size; - strm.avail_out = size; - strm.next_in = (Bytef *)in; - strm.next_out = (Bytef *)out; - - deflate(&strm, Z_FINISH); + salis_deflate(&strm, size, (Bytef *)in, (Bytef *)out); // Insert blob const void *blob = out; @@ -1039,7 +1031,7 @@ void arch_push_data_line() { blob_size, g_steps ); - deflateEnd(&strm); + salis_deflate_end(&strm); free(out); } } @@ -1055,7 +1047,7 @@ void arch_push_data_line() { core->wmb1 = 0; core->wdea = 0; - //memset(core->weva, 0, sizeof(uint64_t) * MVEC_SIZE); + memset(core->weva, 0, sizeof(uint64_t) * MVEC_SIZE); } } #endif diff --git a/arch/v1/arch_vars.py b/arch/v1/arch_vars.py index 65c5e87..b9d4c4f 100644 --- a/arch/v1/arch_vars.py +++ b/arch/v1/arch_vars.py @@ -83,7 +83,7 @@ class ArchVars: ("uint64_t", "wmb1", ""), # writes within mb1 counter ("uint64_t", "wdea", ""), # writes within dead code counter - #("uint64_t", "weva", f"[{2 ** args.mvec_pow}]"), # write events array + ("uint64_t", "weva", f"[{2 ** args.mvec_pow}]"), # write events array ] self.data_is_compressed = True @@ -138,3 +138,11 @@ class ArchVars: } for i in range(args.cores) }, } + + self.heatmaps = { + "Events": { + f"wev_{i}": { + "table": f"wev_{i}", + } for i in range(args.cores) + } + } diff --git a/core.c b/core.c index 79fc6f2..b6b5609 100644 --- a/core.c +++ b/core.c @@ -14,6 +14,10 @@ #define MALL_FLAG 0x80 #define UINT64_HALF 0x8000000000000000ul +#if defined(COMPRESS) || defined(DATA_PUSH_PATH) +#include "data/compress.c" +#endif + struct Proc { #define PROC_FIELD(type, name) type name; PROC_FIELDS @@ -46,7 +50,7 @@ struct Core { uint64_t edea; // executions within dead code counter uint64_t aeva[MVEC_SIZE]; // allocation events array - //uint64_t eeva[MVEC_SIZE]; // execution events array + uint64_t eeva[MVEC_SIZE]; // execution events array #define CORE_DATA_FIELD(type, name, suff) type name suff; CORE_DATA_FIELDS @@ -418,7 +422,7 @@ void core_save(FILE *f, const struct Core *core) { fwrite(core->mvec, sizeof(uint8_t), MVEC_SIZE, f); #if defined(DATA_PUSH_PATH) fwrite(core->aeva, sizeof(uint64_t), MVEC_SIZE, f); - //fwrite(core->eeva, sizeof(uint64_t), MVEC_SIZE, f); + fwrite(core->eeva, sizeof(uint64_t), MVEC_SIZE, f); #endif arch_core_save(f, core); @@ -514,7 +518,7 @@ void core_load(FILE *f, struct Core *core) { fread(core->mvec, sizeof(uint8_t), MVEC_SIZE, f); #if defined(DATA_PUSH_PATH) fread(core->aeva, sizeof(uint64_t), MVEC_SIZE, f); - //fread(core->eeva, sizeof(uint64_t), MVEC_SIZE, f); + fread(core->eeva, sizeof(uint64_t), MVEC_SIZE, f); #endif arch_core_load(f, core); @@ -564,17 +568,25 @@ void core_step(struct Core *core) { // Save execution event locations in database assert(mvec_proc_is_live(core, core->pcur)); - struct Proc *proc = proc_fetch(core, core->pcur); + uint64_t pcur_ip = arch_proc_ip_addr(core, core->pcur); - if (mvec_is_in_mb0_of_proc(core, proc->ip, core->pcur)) { + if (mvec_is_in_mb0_of_proc(core, pcur_ip, core->pcur)) { ++core->emb0; - } else if (mvec_is_in_mb1_of_proc(core, proc->ip, core->pcur)) { + } else if (mvec_is_in_mb1_of_proc(core, pcur_ip, core->pcur)) { ++core->emb1; - } else if (mvec_is_alloc(core, proc->ip)) { + } else if (mvec_is_alloc(core, pcur_ip)) { ++core->eliv; } else { ++core->edea; } + +#if defined(MVEC_LOOP) + core->eeva[mvec_loop(pcur_ip)]++; +#else + if (pcur_ip < MVEC_SIZE) { + core->eeva[pcur_ip]++; + } +#endif #endif arch_proc_step(core, core->pcur); @@ -634,18 +646,7 @@ void salis_save(const char *path) { assert(out); z_stream strm = { 0 }; - strm.zalloc = NULL; - strm.zfree = NULL; - strm.opaque = NULL; - - deflateInit(&strm, Z_DEFAULT_COMPRESSION); - - strm.avail_in = size; - strm.avail_out = size; - strm.next_in = (Bytef *)in; - strm.next_out = (Bytef *)out; - - deflate(&strm, Z_FINISH); + salis_deflate(&strm, size, (Bytef *)in, (Bytef *)out); FILE *fx = fopen(path, "wb"); assert(fx); @@ -654,7 +655,7 @@ void salis_save(const char *path) { fwrite(out, sizeof(char), strm.total_out, fx); fclose(fx); - deflateEnd(&strm); + salis_deflate_end(&strm); free(in); free(out); @@ -762,7 +763,7 @@ void salis_push_data_header() { ); // Memory events - char *eprefs[] = { "aev" /*, "eev" */ }; + char *eprefs[] = { "aev", "eev" }; int eprefs_cnt = sizeof(eprefs) / sizeof(eprefs[0]); for (int i = 0; i < CORES; ++i) { @@ -798,10 +799,8 @@ void salis_push_data_line() { struct Core *core = &g_cores[i]; for (uint64_t j = core->pfst; j <= core->plst; ++j) { - const struct Proc *proc = proc_get(core, j); - - amb0[i] += (double)proc->mb0s; - amb1[i] += (double)proc->mb1s; + amb0[i] += (double)arch_proc_mb0_size(core, j); + amb1[i] += (double)arch_proc_mb1_size(core, j); } amb0[i] /= core->pnum; @@ -851,7 +850,7 @@ void salis_push_data_line() { ); // TODO: insert execute memory events - char *eprefs[] = { "aev" /*, "eev" */ }; + char *eprefs[] = { "aev", "eev" }; int eprefs_cnt = sizeof(eprefs) / sizeof(eprefs[0]); for (int i = 0; i < CORES; ++i) { @@ -860,9 +859,9 @@ void salis_push_data_line() { if (!strcmp("aev", eprefs[j])) { in = g_cores[i].aeva; - } // else if (!strcmp("eev", eprefs[j])) { - // in = g_cores[i].eeva; - // } + } else if (!strcmp("eev", eprefs[j])) { + in = g_cores[i].eeva; + } // Compress event data size_t size = sizeof(uint64_t) * MVEC_SIZE; @@ -870,18 +869,7 @@ void salis_push_data_line() { assert(out); z_stream strm = { 0 }; - strm.zalloc = NULL; - strm.zfree = NULL; - strm.opaque = NULL; - - deflateInit(&strm, Z_DEFAULT_COMPRESSION); - - strm.avail_in = size; - strm.avail_out = size; - strm.next_in = (Bytef *)in; - strm.next_out = (Bytef *)out; - - deflate(&strm, Z_FINISH); + salis_deflate(&strm, size, (Bytef *)in, (Bytef *)out); // Insert blob const void *blob = out; @@ -908,7 +896,7 @@ void salis_push_data_line() { blob_size, g_steps ); - deflateEnd(&strm); + salis_deflate_end(&strm); free(out); } } @@ -923,7 +911,7 @@ void salis_push_data_line() { core->edea = 0; memset(core->aeva, 0, sizeof(uint64_t) * MVEC_SIZE); - //memset(core->eeva, 0, sizeof(uint64_t) * MVEC_SIZE); + memset(core->eeva, 0, sizeof(uint64_t) * MVEC_SIZE); } // Push arch-specific data @@ -988,24 +976,8 @@ void salis_load() { assert(out); z_stream strm = { 0 }; - strm.next_in = (Bytef *)in; - strm.avail_in = x_size; - strm.zalloc = NULL; - strm.zfree = NULL; - strm.opaque = NULL; - - inflateInit(&strm); - - strm.avail_out = size; - strm.next_out = (Bytef *)out; - -#if defined(NDEBUG) - inflate(&strm, Z_FINISH); -#else - assert(inflate(&strm, Z_FINISH)); -#endif - - inflateEnd(&strm); + salis_inflate(&strm, x_size, size, (Bytef *)in, (Bytef *)out); + salis_inflate_end(&strm); FILE *f = fmemopen(out, size, "rb"); #else diff --git a/data/compress.c b/data/compress.c new file mode 100644 index 0000000..df61123 --- /dev/null +++ b/data/compress.c @@ -0,0 +1,56 @@ +void salis_deflate(z_stream *strm, size_t size, Bytef *in, Bytef *out) { + assert(strm); + assert(size); + assert(in); + assert(out); + + strm->zalloc = NULL; + strm->zfree = NULL; + strm->opaque = NULL; + + deflateInit(strm, Z_DEFAULT_COMPRESSION); + + strm->avail_in = size; + strm->avail_out = size; + strm->next_in = in; + strm->next_out = out; + + deflate(strm, Z_FINISH); +} + +void salis_deflate_end(z_stream *strm) { + assert(strm); + + deflateEnd(strm); +} + +void salis_inflate(z_stream *strm, size_t avail_in, size_t size, Bytef *in, Bytef *out) { + assert(strm); + assert(avail_in); + assert(size); + assert(in); + assert(out); + + strm->next_in = in; + strm->avail_in = avail_in; + strm->zalloc = NULL; + strm->zfree = NULL; + strm->opaque = NULL; + + inflateInit(strm); + + strm->avail_out = size; + strm->next_out = out; + +#if defined(NDEBUG) + inflate(strm, Z_FINISH); +#else + assert(inflate(strm, Z_FINISH)); +#endif +} + +void salis_inflate_end(z_stream *strm) { + assert(strm); + + inflateEnd(strm); +} diff --git a/data/render.c b/data/render.c new file mode 100644 index 0000000..f9da65d --- /dev/null +++ b/data/render.c @@ -0,0 +1,86 @@ +#include +SQLITE_EXTENSION_INIT1 + +#include +#include +#include +#include + +#include "compress.c" + +#define EVA_SIZE (sizeof(uint64_t) * MVEC_SIZE) + +void eva_render(sqlite3_context *context, int argc, sqlite3_value **argv) { + assert(context); + assert(argc == 4); + assert(argv); + + (void)argc; + + size_t left = (size_t)sqlite3_value_int(argv[0]); +#if defined(MVEC_LOOP) + left %= MVEC_SIZE; +#endif + + size_t px_count = (size_t)sqlite3_value_int(argv[1]); + size_t px_pow = (size_t)sqlite3_value_int(argv[2]); + size_t px_res = 1 << px_pow; +#if !defined(MVEC_LOOP) +#if !defined(NDEBUG) + size_t right = left + px_res * px_count; +#endif + assert(left < MVEC_SIZE); + assert(right <= MVEC_SIZE); +#endif + + const void *blob = sqlite3_value_blob(argv[3]); + size_t blob_size = (size_t)sqlite3_value_bytes(argv[3]); + + // Inflate blob + size_t out_size = sizeof(uint64_t) * px_count; + uint64_t *eva = sqlite3_malloc(EVA_SIZE); + uint64_t *out = sqlite3_malloc(out_size); + z_stream strm = { 0 }; + salis_inflate(&strm, blob_size, EVA_SIZE, (Bytef *)blob, (Bytef *)eva); + salis_inflate_end(&strm); + + // Render image + for (size_t i = 0; i < px_count; i++) { + out[i] = 0; + + for (size_t j = 0; j < px_res; j++) { + size_t in_coord = left + i * px_res + j; +#if defined(MVEC_LOOP) + in_coord %= MVEC_SIZE; +#endif + out[i] += eva[in_coord]; + } + } + + sqlite3_free(eva); + + // Transform rendered image into textual representation + // A comma-separated list of hexadecimal integers + char *csv = sqlite3_malloc(px_count * 17 + 1); + char *ptr = csv; + + for (size_t i = 0; i < px_count; i++) { + ptr += sprintf(ptr, "%lx ", out[i]); + } + + *(--ptr) = '\0'; + sqlite3_free(out); + + sqlite3_result_text(context, csv, -1, sqlite3_free); +} + +int sqlite3_render_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) { + assert(db); + assert(pzErrMsg); + assert(pApi); + + (void)pzErrMsg; + + SQLITE_EXTENSION_INIT2(pApi); + return sqlite3_create_function(db, "eva_render", 4, SQLITE_DETERMINISTIC | SQLITE_INNOCUOUS | SQLITE_UTF8, NULL, eva_render, NULL, NULL); +} diff --git a/data/vue/App.vue b/data/vue/App.vue index e672911..73923dd 100644 --- a/data/vue/App.vue +++ b/data/vue/App.vue @@ -9,11 +9,15 @@
- Entries (max): - nth: - X-axis: + Entries: + nth: + X-axis: X-low: - X-high: + X-high: + Left: + Px-count: + Px-pow: + ↻
@@ -29,6 +33,9 @@
+
+ +
@@ -41,7 +48,7 @@ import Section from './Section.vue' const root = window.location.href const id = v => v const hex = v => v !== undefined ? `0x${v.toString(16)}` : '' -const hex_pow = v => v !== undefined ? `0x${Math.pow(2, v).toString(16)}` : '' +const hex_pow = v => v !== undefined ? `0x${(2 ** v).toString(16)}` : '' const disabled = v => v ? 'disabled' : 'enabled' const opt_fmts = [ @@ -58,88 +65,120 @@ const opt_fmts = [ ['Seed', 'seed', hex], ] -let visible_tables = [] +let visible_plot_tables = [] +let visible_heatmap_tables = [] let query_timeout = null -let plot_x_low = 0n +let plot_x_low = 0 let plot_redraw = false +let mvec_size = 0 + +const uint32_max = (2 ** 32) - 1 +const hm_max_pixels = 2 ** 11 + +const entries_def = 2000 +const nth_def = 1 +const x_axis_def = 'rowid' +const x_low_def = hex(0) +const x_high_def = hex(uint32_max) +const hm_left_def = hex(0) +const hm_px_count_def = hex(2 ** 10) + +const entries = ref(entries_def) +const nth = ref(nth_def) +const x_axes = ref(['rowid', 'step']) +const x_axis = ref(x_axis_def) +const x_low = ref(x_low_def) +const x_high = ref(x_high_def) +const hm_left = ref(hm_left_def) +const hm_px_count = ref(hm_px_count_def) +const hm_px_pow = ref(hex(0)) const opts = ref({}) const plots = ref({}) +const heatmaps = ref({}) const loaded = ref(false) -const entries = ref(2000) -const nth = ref(BigInt(1)) -const x_axes = ref(['rowid', 'step']) -const x_axis = ref(x_axes.value[0]) -const x_low = ref(hex(BigInt(0))) -const x_high = ref(hex(BigInt(Math.pow(2, 64)))) - const query_in_progress = ref(false) const data = ref([]) const top_pad = useTemplateRef('top_pad') const top_bar = useTemplateRef('top_bar') const plot_sections = useTemplateRef('plot_sections') +const heatmap_sections = useTemplateRef('heatmap_sections') const update_visible_tables = () => { - const section_visibility = plot_sections.value.map(section => section.visible) - visible_tables = Object.entries(plots.value).filter((_, i) => section_visibility[i]).map((section, _) => [...new Set(Object.entries(section[1]).map(plot => plot[1].table))]).flat() + const plot_section_visibility = plot_sections.value.map(section => section.visible) + const heatmap_section_visibility = heatmap_sections.value.map(section => section.visible) + visible_plot_tables = Object.entries(plots.value).filter((_, i) => plot_section_visibility[i]).map((section, _) => [...new Set(Object.entries(section[1]).map(plot => plot[1].table))]).flat() + visible_heatmap_tables = Object.entries(heatmaps.value).filter((_, i) => heatmap_section_visibility[i]).map((section, _) => [...new Set(Object.entries(section[1]).map(plot => plot[1].table))]).flat() } const sanitize = (input, min, max, def, fmt) => { - if (isNaN(Number(input.value)) || input.value === '' || input.value < min || input.value > max) { + if (isNaN(Number(input.value)) || input.value === '' || input.value < min || input.value >= max) { input.value = fmt(def) } } +const max_hm_px_pow = () => Math.floor(Math.log2((mvec_size - Number(hm_left.value)) / Number(hm_px_count.value))) + const trigger_reload = () => { update_visible_tables() - sanitize(entries, 1n, BigInt(Math.pow(2, 64)), 2000n, id) - sanitize(nth, 1n, BigInt(Math.pow(2, 64)), 1n, id) - sanitize(x_low, 0n, BigInt(Math.pow(2, 64)), 0n, hex) - sanitize(x_high, 1n, BigInt(Math.pow(2, 64)), BigInt(Math.pow(2, 64)), hex) + sanitize(entries, 1, uint32_max, 2000, id) + sanitize(nth, 1, uint32_max, 1, id) + sanitize(x_low, 0, uint32_max, 0, hex) + sanitize(x_high, 1, uint32_max, uint32_max, hex) + + if (opts.value.mvec_loop) { + sanitize(hm_left, 0, uint32_max, 0, hex) + sanitize(hm_px_count, 1, hm_max_pixels, hm_max_pixels, hex) + sanitize(hm_px_pow, 0, uint32_max, uint32_max, hex) + } else { + sanitize(hm_left, 0, mvec_size, 0, hex) + sanitize(hm_px_count, 1, hm_max_pixels, hm_max_pixels, hex) + sanitize(hm_px_pow, 0, max_hm_px_pow(), max_hm_px_pow(), hex) + } - plot_x_low = x_low.value + plot_x_low = Number(x_low.value) plot_redraw = true query() } -const pad_top_bar = () => { - top_pad.value.style.height = `${Math.round(top_bar.value.getBoundingClientRect().height)}px` -} - -const reviver = (_, val, { source }) => { - if (Number.isInteger(val) && !Number.isSafeInteger(val)) { - try { return BigInt(source) } catch {} - } - - return val +const reset_inputs = () => { + entries.value = entries_def + nth.value = nth_def + x_axis.value = x_axis_def + x_low.value = x_low_def + x_high.value = x_high_def + hm_left.value = hm_left_def + hm_px_count.value = hm_px_count_def + hm_px_pow.value = max_hm_px_pow() + + trigger_reload() } -const query_table = async table => { +const query_table = async (table, is_heatmap, x_high_now) => { const params = { table: table, entries: entries.value, nth: nth.value, x_axis: x_axis.value, - x_low: Number(plot_x_low), - x_high: Number(x_high.value), + x_low: plot_x_low, + x_high: x_high_now, + is_eva: is_heatmap, + ...is_heatmap ? { + hm_left: Number(hm_left.value), + hm_px_count: Number(hm_px_count.value), + hm_px_pow: Number(hm_px_pow.value), + } : {}, } const search_params = new URLSearchParams(params) const resp_table = await fetch(root + `data?${search_params}`, { method: 'GET' }) - const resp_json = JSON.parse(await resp_table.text(), reviver) + const text_table = await resp_table.text() - // Keep track of the highest x-axis value fetched so far. - // Future queries will set this as the minimum, which prevents re-fetching already stored data. - if (resp_json.length) { - const x_last = BigInt(resp_json.slice(-1)[0][x_axis.value] + 1) - plot_x_low = plot_x_low > x_last ? plot_x_low : x_last - } - - return resp_json + return JSON.parse(text_table) } const query = async () => { @@ -148,27 +187,51 @@ const query = async () => { clearTimeout(query_timeout) query_in_progress.value = true - const query_results = await Promise.all(visible_tables.map(query_table)) - const query_values = Object.fromEntries(visible_tables.map((key, i) => [key, query_results[i]])) + const high_params = new URLSearchParams({ x_axis: x_axis.value }) + const resp_x_high = await fetch(root + `x_high?${high_params}`, { method: 'GET' }) + const text_x_high = await resp_x_high.text() + const json_x_high = JSON.parse(text_x_high) + const x_high_max = json_x_high.x_high + 1 + const x_high_val = Number(x_high.value) + const x_high_now = x_high_max < x_high_val ? x_high_max : x_high_val; + + const plot_query_results = await Promise.all(visible_plot_tables.map(table => query_table(table, false, x_high_now))) + const heatmap_query_results = await Promise.all(visible_heatmap_tables.map(table => query_table(table, true, x_high_now))) + const plot_query_values = Object.fromEntries(visible_plot_tables.map((table, i) => [table, plot_query_results[i]])) + const heatmap_query_values = Object.fromEntries(visible_heatmap_tables.map((table, i) => [table, heatmap_query_results[i]])) - data.value = { redraw: plot_redraw, values: query_values } + // Keep track of the highest x-axis value fetched so far. + // Future queries will set this as the minimum, which prevents re-fetching already stored data. + plot_x_low = x_high_now + + data.value = { redraw: plot_redraw, plot_values: plot_query_values, heatmap_values: heatmap_query_values } plot_redraw = false query_in_progress.value = false query_timeout = setTimeout(query, 10000) } -onMounted(async () => { - window.onresize = _ => pad_top_bar() - pad_top_bar() +const with_big_ints = (_, val, { source }) => { + if (Number.isInteger(val) && !Number.isSafeInteger(val)) { + try { return BigInt(source) } catch {} + } + return val +} + +onMounted(async () => { const resp_opts = await fetch(root + 'opts', { method: 'GET' }) const resp_plots = await fetch(root + 'plots', { method: 'GET' }) + const resp_heatmaps = await fetch(root + 'heatmaps', { method: 'GET' }) - opts.value = JSON.parse(await resp_opts.text(), reviver) - plots.value = JSON.parse(await resp_plots.text(), reviver) + opts.value = JSON.parse(await resp_opts.text(), with_big_ints) + plots.value = JSON.parse(await resp_plots.text()) + heatmaps.value = JSON.parse(await resp_heatmaps.text()) loaded.value = true + mvec_size = 2 ** opts.value.mvec_pow + hm_px_pow.value = hex(max_hm_px_pow()) + // All tables should include one cycle column for each core. // This allows normalizing the plots against each core's cycle count // (i.e. making `cycl_#` the plots' x-axis). @@ -176,37 +239,45 @@ onMounted(async () => { }) watch(loaded, _ => { + top_pad.value.style.height = `${Math.round(top_bar.value.getBoundingClientRect().height)}px` + update_visible_tables() query() }, { flush: 'post' }) provide('plots', plots) +provide('heatmaps', heatmaps) provide('entries', entries) provide('x_axis', x_axis) +provide('hm_left', hm_left) +provide('hm_px_count', hm_px_count) +provide('hm_px_pow', hm_px_pow) provide('data', data) provide('trigger_reload', trigger_reload) diff --git a/data/vue/Plot.vue b/data/vue/Plot.vue index 3c08d73..5bbc89a 100644 --- a/data/vue/Plot.vue +++ b/data/vue/Plot.vue @@ -11,7 +11,7 @@