121 lines
3.1 KiB
TypeScript
121 lines
3.1 KiB
TypeScript
import type { PerformanceTrack, SetPageVisibility } from '../messages';
|
|
|
|
import ListWalker from '../../common/ListWalker';
|
|
|
|
export type PerformanceChartPoint = {
|
|
time: number,
|
|
usedHeap: number,
|
|
totalHeap: number,
|
|
fps: number | null,
|
|
cpu: number | null,
|
|
nodesCount: number,
|
|
}
|
|
|
|
export default class PerformanceTrackManager extends ListWalker<PerformanceTrack> {
|
|
private chart: Array<PerformanceChartPoint> = [];
|
|
private isHidden: boolean = false;
|
|
private timeCorrection: number = 0;
|
|
private heapAvailable: boolean = false;
|
|
private fpsAvailable: boolean = false;
|
|
private cpuAvailable: boolean = false;
|
|
private prevTime: number | null = null;
|
|
private prevNodesCount: number = 0;
|
|
|
|
|
|
append(msg: PerformanceTrack):void {
|
|
let fps: number | null = null;
|
|
let cpu: number | null = null;
|
|
if (!this.isHidden && this.prevTime != null) {
|
|
let timePassed = msg.time - this.prevTime + this.timeCorrection;
|
|
|
|
if (timePassed > 0 && msg.frames >= 0) {
|
|
if (msg.frames > 0) { this.fpsAvailable = true; }
|
|
fps = msg.frames*1e3/timePassed; // Multiply by 1e3 as time in ms;
|
|
fps = Math.min(fps,60); // What if 120? TODO: alert if more than 60
|
|
if (this.chart.length === 1) {
|
|
this.chart[0].fps = fps;
|
|
}
|
|
}
|
|
|
|
if (timePassed > 0 && msg.ticks >= 0) {
|
|
this.cpuAvailable = true;
|
|
let tickRate = msg.ticks * 30 / timePassed;
|
|
if (tickRate > 1) {
|
|
tickRate = 1;
|
|
}
|
|
cpu = Math.round(100 - tickRate*100);
|
|
if (this.chart.length === 1) {
|
|
this.chart[0].cpu = cpu;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.prevTime = msg.time;
|
|
this.timeCorrection = 0
|
|
|
|
this.heapAvailable = this.heapAvailable || msg.usedJSHeapSize > 0;
|
|
this.chart.push({
|
|
usedHeap: msg.usedJSHeapSize,
|
|
totalHeap: msg.totalJSHeapSize,
|
|
fps,
|
|
cpu,
|
|
time: msg.time,
|
|
nodesCount: this.prevNodesCount,
|
|
});
|
|
super.append(msg);
|
|
}
|
|
|
|
|
|
// TODO: refactor me
|
|
private prevNCTime = 0
|
|
addNodeCountPointIfNeed(time: number) {
|
|
if ((this.prevTime && time - this.prevTime < 200) || (time - this.prevNCTime < 200)) {
|
|
return
|
|
}
|
|
const lastPoint = this.chart[this.chart.length - 1]
|
|
if (lastPoint && lastPoint.nodesCount === this.prevNodesCount) {
|
|
return
|
|
}
|
|
const newPoint = Object.assign({
|
|
usedHeap:0,
|
|
totalHeap: 0,
|
|
fps: null,
|
|
cpu: null,
|
|
}, lastPoint)
|
|
newPoint.time = time
|
|
newPoint.nodesCount = this.prevNodesCount
|
|
this.chart.push(newPoint)
|
|
this.prevNCTime = time
|
|
}
|
|
|
|
setCurrentNodesCount(count: number) {
|
|
this.prevNodesCount = count;
|
|
// if (this.chart.length > 0) {
|
|
// this.chart[ this.chart.length - 1 ].nodesCount = count;
|
|
// }
|
|
}
|
|
|
|
handleVisibility(msg: SetPageVisibility):void {
|
|
if (!this.isHidden && msg.hidden && this.prevTime != null) {
|
|
this.timeCorrection = msg.time - this.prevTime;
|
|
}
|
|
if (this.isHidden && !msg.hidden) {
|
|
this.prevTime = msg.time;
|
|
}
|
|
this.isHidden = msg.hidden;
|
|
}
|
|
|
|
get chartData(): Array<PerformanceChartPoint> {
|
|
return this.chart;
|
|
}
|
|
|
|
get availability(): { cpu: boolean, fps: boolean, heap: boolean, nodes: boolean } {
|
|
return {
|
|
cpu: this.cpuAvailable,
|
|
fps: this.fpsAvailable,
|
|
heap: this.heapAvailable,
|
|
nodes: true,
|
|
}
|
|
}
|
|
|
|
}
|