// Copyright (C) 2019 The Android Open Source Project // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. import {searchEq, searchRange, searchSegment} from '../../base/binary_search'; import {assertTrue} from '../../base/logging'; import {Actions} from '../../common/actions'; import {colorForThread} from '../../common/colorizer'; import {checkerboardExcept} from '../../frontend/checkerboard'; import {globals} from '../../frontend/globals'; import {NewTrackArgs, Track} from '../../frontend/track'; import {trackRegistry} from '../../frontend/track_registry'; import { Config, Data, PROCESS_SCHEDULING_TRACK_KIND, } from './common'; const MARGIN_TOP = 5; const RECT_HEIGHT = 30; const TRACK_HEIGHT = MARGIN_TOP * 2 + RECT_HEIGHT; class ProcessSchedulingTrack extends Track { static readonly kind = PROCESS_SCHEDULING_TRACK_KIND; static create(args: NewTrackArgs): ProcessSchedulingTrack { return new ProcessSchedulingTrack(args); } private mousePos?: {x: number, y: number}; private utidHoveredInThisTrack = -1; constructor(args: NewTrackArgs) { super(args); } getHeight(): number { return TRACK_HEIGHT; } renderCanvas(ctx: CanvasRenderingContext2D): void { // TODO: fonts and colors should come from the CSS and not hardcoded here. const {timeScale, visibleWindowTime} = globals.frontendLocalState; const data = this.data(); if (data === undefined) return; // Can't possibly draw anything. // If the cached trace slices don't fully cover the visible time range, // show a gray rectangle with a "Loading..." label. checkerboardExcept( ctx, this.getHeight(), timeScale.timeToPx(visibleWindowTime.start), timeScale.timeToPx(visibleWindowTime.end), timeScale.timeToPx(data.start), timeScale.timeToPx(data.end)); assertTrue(data.starts.length === data.ends.length); assertTrue(data.starts.length === data.utids.length); const rawStartIdx = data.ends.findIndex(end => end >= visibleWindowTime.start); const startIdx = rawStartIdx === -1 ? data.starts.length : rawStartIdx; const [, rawEndIdx] = searchSegment(data.starts, visibleWindowTime.end); const endIdx = rawEndIdx === -1 ? data.starts.length : rawEndIdx; const cpuTrackHeight = Math.floor(RECT_HEIGHT / data.maxCpu); for (let i = startIdx; i < endIdx; i++) { const tStart = data.starts[i]; const tEnd = data.ends[i]; const utid = data.utids[i]; const cpu = data.cpus[i]; const rectStart = timeScale.timeToPx(tStart); const rectEnd = timeScale.timeToPx(tEnd); const rectWidth = rectEnd - rectStart; if (rectWidth < 0.3) continue; const threadInfo = globals.threads.get(utid); const pid = (threadInfo ? threadInfo.pid : -1) || -1; const isHovering = globals.state.hoveredUtid !== -1; const isThreadHovered = globals.state.hoveredUtid === utid; const isProcessHovered = globals.state.hoveredPid === pid; const color = colorForThread(threadInfo); if (isHovering && !isThreadHovered) { if (!isProcessHovered) { color.l = 90; color.s = 0; } else { color.l = Math.min(color.l + 30, 80); color.s -= 20; } } else { color.l = Math.min(color.l + 10, 60); color.s -= 20; } ctx.fillStyle = `hsl(${color.h}, ${color.s}%, ${color.l}%)`; const y = MARGIN_TOP + cpuTrackHeight * cpu + cpu; ctx.fillRect(rectStart, y, rectEnd - rectStart, cpuTrackHeight); } const hoveredThread = globals.threads.get(this.utidHoveredInThisTrack); if (hoveredThread !== undefined && this.mousePos !== undefined) { const tidText = `T: ${hoveredThread.threadName} [${hoveredThread.tid}]`; if (hoveredThread.pid) { const pidText = `P: ${hoveredThread.procName} [${hoveredThread.pid}]`; this.drawTrackHoverTooltip(ctx, this.mousePos, pidText, tidText); } else { this.drawTrackHoverTooltip(ctx, this.mousePos, tidText); } } } onMouseMove(pos: {x: number, y: number}) { const data = this.data(); this.mousePos = pos; if (data === undefined) return; if (pos.y < MARGIN_TOP || pos.y > MARGIN_TOP + RECT_HEIGHT) { this.utidHoveredInThisTrack = -1; globals.dispatch(Actions.setHoveredUtidAndPid({utid: -1, pid: -1})); return; } const cpuTrackHeight = Math.floor(RECT_HEIGHT / data.maxCpu); const cpu = Math.floor((pos.y - MARGIN_TOP) / (cpuTrackHeight + 1)); const {timeScale} = globals.frontendLocalState; const t = timeScale.pxToTime(pos.x); const [i, j] = searchRange(data.starts, t, searchEq(data.cpus, cpu)); if (i === j || i >= data.starts.length || t > data.ends[i]) { this.utidHoveredInThisTrack = -1; globals.dispatch(Actions.setHoveredUtidAndPid({utid: -1, pid: -1})); return; } const utid = data.utids[i]; this.utidHoveredInThisTrack = utid; const threadInfo = globals.threads.get(utid); const pid = threadInfo ? (threadInfo.pid ? threadInfo.pid : -1) : -1; globals.dispatch(Actions.setHoveredUtidAndPid({utid, pid})); } onMouseOut() { this.utidHoveredInThisTrack = -1; globals.dispatch(Actions.setHoveredUtidAndPid({utid: -1, pid: -1})); this.mousePos = undefined; } } trackRegistry.register(ProcessSchedulingTrack);