// perf_json.c -- see perf_json.h. The builders that were debug_server.c's,

// moved so the RRDC control port answers with the same fields.

#include "perf_json.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "glue.h"            // MHZ, warp_mode

#include "vera_bandwidth.h"

#include "sprite_trace.h"

cJSON *perf_json_stat(const perf_stat_t *s) {

    cJSON *o = cJSON_CreateObject();

    cJSON_AddNumberToObject(o, "min", s->min);

    cJSON_AddNumberToObject(o, "mean", s->mean);

    cJSON_AddNumberToObject(o, "p50", s->p50);

    cJSON_AddNumberToObject(o, "p95", s->p95);

    cJSON_AddNumberToObject(o, "p99", s->p99);

    cJSON_AddNumberToObject(o, "max", s->max);

    return o;

}

void perf_json_window_name(float seconds, char *out, size_t outsz) {

    if (seconds <= 0.0f) snprintf(out, outsz, "session");

    else                 snprintf(out, outsz, "%gs", (double)seconds);

}

// Accepts either a number of seconds or a name ("30s", "session"), so a client

// can send back the same window labels it was given.

float perf_json_window_seconds(const cJSON *item) {

    if (cJSON_IsNumber(item)) return (float)item->valuedouble;

    if (cJSON_IsString(item) && item->valuestring) {

        if (!strcmp(item->valuestring, "session")) return 0.0f;

        return (float)atof(item->valuestring); // "30s" -> 30

    }

    return 0.0f;

}

cJSON *perf_json_budget(void) {

    cJSON *b = cJSON_CreateObject();

    cJSON_AddBoolToObject(b, "enabled", perf_budget_is_enabled());

    cJSON_AddNumberToObject(b, "targetFps", perf_budget_get_target_fps());

    cJSON_AddNumberToObject(b, "vsyncHz", perf_budget_vsync_hz());

    cJSON_AddNumberToObject(b, "machineKhz", (double)MHZ * 1000.0);

    cJSON_AddNumberToObject(b, "cyclesPerFrame", perf_budget_cycles_per_frame());

    cJSON_AddNumberToObject(b, "cyclesPerScanline", perf_budget_cycles_per_scanline());

    cJSON_AddNumberToObject(b, "scanlinesPerFrame",

                            perf_budget_cycles_per_scanline()

                                ? perf_budget_cycles_per_frame() / perf_budget_cycles_per_scanline() : 0);

    cJSON_AddNumberToObject(b, "budgetCycles", perf_budget_budget_cycles());

    cJSON_AddNumberToObject(b, "framesPerBudget", perf_budget_frames_per_budget());

    cJSON_AddNumberToObject(b, "historyFrames", perf_budget_capacity());

    cJSON_AddNumberToObject(b, "totalFrames", perf_budget_total_frames());

    const char *mode = "auto";

    switch (perf_budget_get_idle_mode()) {

        case PERF_IDLE_MARKERS: mode = "markers"; break;

        case PERF_IDLE_NONE:    mode = "none";    break;

        default:                mode = "auto";    break;

    }

    cJSON_AddStringToObject(b, "idleMode", mode);

    cJSON_AddBoolToObject(b, "warpMode", warp_mode);

    return b;

}

cJSON *perf_json_frame(const perf_frame_t *f) {

    cJSON *o = cJSON_CreateObject();

    const uint32_t budget = perf_budget_budget_cycles();

    cJSON_AddNumberToObject(o, "frame", f->frame);

    cJSON_AddNumberToObject(o, "totalCycles", f->total);

    cJSON_AddNumberToObject(o, "workCycles", perf_frame_work(f));

    cJSON_AddNumberToObject(o, "idleCycles", f->idle);

    cJSON_AddNumberToObject(o, "irqCycles", f->irq);

    cJSON_AddNumberToObject(o, "mainCycles",

                            perf_frame_work(f) > f->irq ? perf_frame_work(f) - f->irq : 0);

    cJSON_AddNumberToObject(o, "budgetWorkCycles", f->period_work);

    cJSON_AddNumberToObject(o, "instructions", f->instructions);

    cJSON_AddNumberToObject(o, "hostUs", f->host_us);

    cJSON_AddNumberToObject(o, "utilizationPct",

                            budget ? 100.0 * (double)f->period_work / (double)budget : 0.0);

    cJSON_AddBoolToObject(o, "overBudget", budget && f->period_work > budget);

    return o;

}

// VERA's side of the same question. Deliberately a sub-object of perfStats

// rather than a request of its own: a developer asking "what is eating my

// frame?" should get the CPU answer and the bus answer in one round trip,

// because the interesting cases are the ones where the two disagree.

//

// The headline is peakLineClocks against lineClocks (800), NOT a percentage of

// VERA's total bandwidth. A frame uses maybe a fifth of the chip's 100 MB/s and

// reporting that would be true and useless -- the scanline is the window that

// actually runs out. See src/vera_bandwidth.h.

cJSON *perf_json_bandwidth(void) {

    cJSON *o = cJSON_CreateObject();

    cJSON_AddBoolToObject(o, "enabled", vera_bandwidth_is_enabled());

    cJSON_AddNumberToObject(o, "lineClocks", VERA_BW_LINE_CLOCKS);

    cJSON_AddNumberToObject(o, "bytesPerAccess", VERA_BW_BYTES_PER_ACCESS);

    cJSON_AddNumberToObject(o, "accessClocks", VERA_BW_ACCESS_CLOCKS);

    cJSON_AddNumberToObject(o, "scanlinesPerFrame", vera_bandwidth_scanlines_per_frame());

    vera_bw_frame_t f;

    if (!vera_bandwidth_last_frame(&f)) {

        return o;

    }

    cJSON_AddNumberToObject(o, "frame", f.frame);

    cJSON_AddNumberToObject(o, "linesActive", f.lines_active);

    cJSON *layers = cJSON_CreateArray();

    for (int i = 0; i < 2; i++) {

        cJSON *l = cJSON_CreateObject();

        cJSON_AddNumberToObject(l, "fetches", f.layer_fetches[i]);

        cJSON_AddNumberToObject(l, "bytes", f.layer_bytes[i]);

        cJSON_AddNumberToObject(l, "peakLine", f.layer_peak_line[i]);

        cJSON_AddNumberToObject(l, "peakFetches", f.layer_peak_fetches[i]);

        cJSON_AddItemToArray(layers, l);

    }

    cJSON_AddItemToObject(o, "layers", layers);

    // Per-scanline pressure: the headline.

    cJSON_AddNumberToObject(o, "peakLine", f.peak_line);

    cJSON_AddNumberToObject(o, "peakLineClocks", f.peak_clocks);

    cJSON_AddNumberToObject(o, "p95LineClocks", f.p95_clocks);

    cJSON_AddNumberToObject(o, "meanLineClocks", f.mean_clocks);

    cJSON_AddNumberToObject(o, "linesOverBudget", f.lines_over);

    cJSON_AddNumberToObject(o, "peakLinePct",

                            100.0 * (double)f.peak_clocks / (double)VERA_BW_LINE_CLOCKS);

    cJSON_AddNumberToObject(o, "totalFetches", f.total_fetches);

    cJSON_AddNumberToObject(o, "totalClocks", f.total_clocks);

    // How much of each scanline was still free when the layers and the CPU had

    // taken their share. Sprites are last on the bus (vram_if.v:142-157), so

    // this is what they were really competing for.

    //

    // Named "bus" deliberately. Every clock figure in this object is BUS

    // OCCUPANCY, which is not the clock the sprite views report: sprite render

    // time is wall clock and runs about five times higher, so a client that

    // subtracted one from the other would conclude a comfortable line was

    // oversubscribed. Convert sprite width and colour depth to fetches first.

    cJSON_AddNumberToObject(o, "spriteBusHeadroomClocksAtPeak",

                            f.peak_clocks < VERA_BW_LINE_CLOCKS

                                ? VERA_BW_LINE_CLOCKS - f.peak_clocks : 0);

    cJSON_AddStringToObject(o, "clockUnits", "bus");

    cJSON *port = cJSON_CreateObject();

    cJSON_AddNumberToObject(port, "readBytes", f.port_reads);

    cJSON_AddNumberToObject(port, "writeBytes", f.port_writes);

    cJSON_AddNumberToObject(port, "accesses", f.port_accesses);

    cJSON_AddNumberToObject(port, "vramBytes", f.port_vram_bytes);

    cJSON_AddNumberToObject(port, "fxCacheWrites", f.fx_cache_writes);

    cJSON_AddNumberToObject(port, "fxAffineFetches", f.fx_affine_fetches);

    // Bytes that reached VRAM per byte the CPU pushed. Above 1.0 means FX is

    // doing work the CPU did not pay for, which is the point of using it.

    const uint32_t stores = f.port_reads + f.port_writes;

    cJSON_AddNumberToObject(port, "amplification",

                            stores ? (double)f.port_vram_bytes / (double)stores : 0.0);

    cJSON_AddItemToObject(o, "port", port);

    return o;

}

cJSON *perf_json_window(float secs) {

    perf_window_t w;

    if (!perf_budget_window(secs, &w)) return NULL;

    char name[32];

    perf_json_window_name(secs, name, sizeof name);

    cJSON *o = cJSON_CreateObject();

    cJSON_AddStringToObject(o, "name", name);

    cJSON_AddNumberToObject(o, "seconds", secs);

    cJSON_AddNumberToObject(o, "frames", w.frames);

    cJSON_AddNumberToObject(o, "budgetCycles", w.budget_cycles);

    cJSON_AddItemToObject(o, "work", perf_json_stat(&w.work));

    cJSON_AddItemToObject(o, "budgetWork", perf_json_stat(&w.budget_work));

    cJSON_AddItemToObject(o, "total", perf_json_stat(&w.total));

    cJSON_AddItemToObject(o, "irq", perf_json_stat(&w.irq));

    cJSON_AddItemToObject(o, "hostUs", perf_json_stat(&w.host_us));

    cJSON_AddNumberToObject(o, "overruns", w.overruns);

    cJSON_AddNumberToObject(o, "overrunPct", w.overrun_pct);

    cJSON_AddNumberToObject(o, "worstOverrunCycles", w.worst_overrun);

    cJSON_AddNumberToObject(o, "worstFrame", w.worst_frame);

    cJSON_AddNumberToObject(o, "meanUtilizationPct", w.mean_utilization);

    cJSON_AddNumberToObject(o, "p95UtilizationPct", w.p95_utilization);

    cJSON_AddNumberToObject(o, "maxUtilizationPct", w.max_utilization);

    return o;

}

cJSON *perf_json_bandwidth_lines(void) {

    uint16_t n = 0;

    const vera_bw_line_t *lines = vera_bandwidth_last_lines(&n);

    cJSON *a = cJSON_CreateArray();

    for (uint16_t i = 0; lines && i < n; i++)

        cJSON_AddItemToArray(a, cJSON_CreateNumber(vera_bw_line_clocks(&lines[i])));

    return a;

}

// The sprite renderer is the other half of VERA's scanline: what it spent

// drawing sprites on each line against the 798 clocks it has (wall clock, not

// the bus clocks perf_json_bandwidth counts -- see vera_bandwidth.h).

cJSON *perf_json_sprites(bool lines) {

    cJSON *o = cJSON_CreateObject();

    const sprite_trace_frame_t *f = sprite_trace_active ? sprite_trace_last_frame() : NULL;

    cJSON_AddBoolToObject(o, "enabled", sprite_trace_active);

    cJSON_AddNumberToObject(o, "lineBudget", SPRITE_TRACE_LINE_BUDGET);

    if (!f) return o;

    const sprite_frame_summary_t *s = &f->summary;

    cJSON_AddNumberToObject(o, "frame", s->frame);

    cJSON_AddNumberToObject(o, "peakLine", s->peak_line);

    cJSON_AddNumberToObject(o, "peakBudget", s->peak_budget);

    cJSON_AddNumberToObject(o, "peakDemand", s->peak_demand);

    cJSON_AddNumberToObject(o, "linesExhausted", s->lines_exhausted);

    cJSON_AddNumberToObject(o, "spritesDropped", s->sprites_dropped);

    cJSON_AddNumberToObject(o, "budgetUsedTotal", s->budget_used_total);

    cJSON_AddNumberToObject(o, "slotsUsed", s->slots_used);

    cJSON_AddNumberToObject(o, "slotsMultiplexed", s->slots_multiplexed);

    cJSON_AddNumberToObject(o, "effectiveSprites", s->effective_sprites);

    cJSON_AddNumberToObject(o, "cpuCycles", s->cpu_cycles);

    cJSON_AddBoolToObject(o, "multiplexing", s->multiplexing);

    if (lines && f->lines) {

        cJSON *a = cJSON_CreateArray();

        for (int i = 0; i < SPRITE_TRACE_LINES; i++)

            cJSON_AddItemToArray(a, cJSON_CreateNumber(f->lines[i].budget_used));

        cJSON_AddItemToObject(o, "lines", a);

    }

    return o;

}