Web 图形与 3D / 系统课时

分析绘制调用与帧耗时

分析绘制调用与帧耗时

WebGL 2 场景掉帧可能来自重复 Draw Call、频繁切换材质或像素填充过多。本课先用 Chrome 性能面板找到长帧,再运行 100 个三角形的实验,区分 CPU 提交、帧间隔与 GPU 耗时,并验证实例化和降分辨率是否有效。

学习目标

  • 在 Chrome Performance 录制中定位长帧,区分主线程耗时与 GPU 工作时间。
  • 统计每帧 Draw Call 和已创建资源数量,运行逐个绘制与实例化的对照实验。
  • 按固定变量比较状态切换、实例化与渲染分辨率,解释 GPU 计时查询的限制。

在浏览器中建立可复现的基线

以桌面版 Chrome DevTools 为例,先关闭其他占用 GPU 的标签页,让动画稳定运行 3 秒,再执行以下操作:

  1. 按 F12,进入 Performance,点击 Record 录制约 8 秒,期间保持相同的场景和镜头操作,随后停止。
  2. 查看 Frames 或 FPS 相关轨道,找到明显超过刷新周期的长帧;展开 Main 轨道检查脚本调用与渲染任务,并用 Bottom-up 查看累计耗时。
  3. 在相同窗口尺寸、设备像素比和浏览器缩放下重复录制 3 次;对照中位数与长帧,而不是挑选最好的一次。

60 Hz 显示器的单帧预算约 16.7 ms,120 Hz 约 8.3 ms。Main 中脚本任务偏长提示 CPU 压力,但浏览器的 Paint 并不等于 WebGL 的 GPU 绘制耗时;没有 GPU 计时数据时,不能仅凭主线程短就断言 GPU 空闲。

Chrome 性能录制中定位帧轨道与主线程任务

运行 Draw Call 与资源计数实验

将下面代码保存为 webgl-profile.html,用支持 WebGL 2 的桌面浏览器打开;直接查看画布下方每 120 帧更新一次的统计,同时可用 DevTools 录制性能。按 I 切换逐个绘制与实例化,按 R 切换渲染分辨率。两种模式绘制相同的 100 个三角形。

html
<!doctype html>
<html lang="zh-CN">
<meta charset="utf-8">
<title>WebGL 2 Draw Call 对照</title>
<p>按 I 切换绘制方式;按 R 切换分辨率</p>
<canvas id="view" style="width:600px;height:360px"></canvas>
<pre id="stats"></pre>
<script>
const canvas = document.querySelector("#view");
const gl = canvas.getContext("webgl2", { antialias: false });
if (!gl) throw new Error("需要 WebGL 2");
function compile(type, source) {
  const shader = gl.createShader(type);
  gl.shaderSource(shader, source);
  gl.compileShader(shader);
  if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
    throw new Error(gl.getShaderInfoLog(shader));
  return shader;
}
const vs = compile(gl.VERTEX_SHADER, `#version 300 es
layout(location=0) in vec2 aPosition;
layout(location=1) in vec2 aOffset;
uniform vec2 uOffset;
uniform bool uInstanced;
void main() {
  vec2 p = aPosition * 0.08 + (uInstanced ? aOffset : uOffset);
  gl_Position = vec4(p, 0.0, 1.0);
}`);
const fs = compile(gl.FRAGMENT_SHADER, `#version 300 es
precision mediump float;
out vec4 fragColor;
void main() { fragColor = vec4(0.2, 0.5, 0.8, 1.0); }`);
const program = gl.createProgram();
gl.attachShader(program, vs);
gl.attachShader(program, fs);
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS))
  throw new Error(gl.getProgramInfoLog(program));
gl.deleteShader(vs);
gl.deleteShader(fs);
const offsets = new Float32Array(200);
for (let i = 0; i < 100; i++) {
  offsets[2 * i] = (i % 10 - 4.5) * 0.19;
  offsets[2 * i + 1] = (Math.floor(i / 10) - 4.5) * 0.19;
}
function makeBuffer(data) {
  const buffer = gl.createBuffer();
  gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
  gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
  return buffer;
}
const vertices = makeBuffer(new Float32Array([0, 1, -1, -1, 1, -1]));
const instances = makeBuffer(offsets);
function makeVao(useOffsets) {
  const vao = gl.createVertexArray();
  gl.bindVertexArray(vao);
  gl.bindBuffer(gl.ARRAY_BUFFER, vertices);
  gl.enableVertexAttribArray(0);
  gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
  if (useOffsets) {
    gl.bindBuffer(gl.ARRAY_BUFFER, instances);
    gl.enableVertexAttribArray(1);
    gl.vertexAttribPointer(1, 2, gl.FLOAT, false, 0, 0);
    gl.vertexAttribDivisor(1, 1); // 每个实例读取一次偏移
  }
  gl.bindVertexArray(null);
  return vao;
}
const plainVao = makeVao(false);
const instancedVao = makeVao(true);
const uOffset = gl.getUniformLocation(program, "uOffset");
const uInstanced = gl.getUniformLocation(program, "uInstanced");
let instanced = false, scale = 1;
let frames = 0, totalSubmitMs = 0, windowStart = performance.now();
function resetWindow() {
  frames = 0;
  totalSubmitMs = 0;
  windowStart = performance.now();
}
function resize() {
  canvas.width = Math.round(600 * devicePixelRatio * scale);
  canvas.height = Math.round(360 * devicePixelRatio * scale);
  gl.viewport(0, 0, canvas.width, canvas.height);
}
document.addEventListener("keydown", (event) => {
  if (event.key.toLowerCase() === "i") {
    instanced = !instanced;
    resetWindow();
  }
  if (event.key.toLowerCase() === "r") {
    scale = scale === 1 ? 0.7 : 1;
    resize();
    resetWindow();
  }
});
function frame() {
  const begin = performance.now();
  gl.clearColor(1, 1, 1, 1);
  gl.clear(gl.COLOR_BUFFER_BIT);
  gl.useProgram(program);
  gl.uniform1i(uInstanced, instanced ? 1 : 0);
  let drawCalls = 0;
  if (instanced) {
    gl.bindVertexArray(instancedVao);
    gl.drawArraysInstanced(gl.TRIANGLES, 0, 3, 100);
    drawCalls = 1;
  } else {
    gl.bindVertexArray(plainVao);
    for (let i = 0; i < 100; i++) {
      gl.uniform2f(uOffset, offsets[2 * i], offsets[2 * i + 1]);
      gl.drawArrays(gl.TRIANGLES, 0, 3);
      drawCalls++;
    }
  }
  // 此处测得的是JS调用与命令提交耗时,不是GPU执行耗时。
  totalSubmitMs += performance.now() - begin;
  frames++;
  if (frames === 120) {
    const fps = frames * 1000 / (performance.now() - windowStart);
    document.querySelector("#stats").textContent =
      `mode=${instanced ? "instanced" : "loop"} drawCalls=${drawCalls} ` +
      `buffers=2 vaos=2 programs=1 ` +
      `avgSubmitMs=${(totalSubmitMs / frames).toFixed(2)} ` +
      `fps=${fps.toFixed(1)} scale=${scale}`;
    resetWindow();
  }
  requestAnimationFrame(frame);
}
resize();
requestAnimationFrame(frame);
</script>
</html>

预期结果:画布呈现 10×10 阵列。逐个绘制时 drawCalls=100,实例化时 drawCalls=1;两种方式均创建 2 个 Buffer、2 个 VAO、1 个 Program。统计区域会显示以下形式,<TIME> 和 <FPS> 是随设备与负载变化的数值占位符:

text
mode=loop drawCalls=100 buffers=2 vaos=2 programs=1 avgSubmitMs=<TIME> fps=<FPS> scale=1
mode=instanced drawCalls=1 buffers=2 vaos=2 programs=1 avgSubmitMs=<TIME> fps=<FPS> scale=1

这里的资源数是本示例实际创建的对象数,而非显存用量。真实引擎应在 createBuffer、createTexture、createProgram 等资源创建和对应删除的位置分别累加与扣减存活数量,在 drawArrays、drawElements 与实例化绘制调用点统计 Draw Call;不要把三角形数误记为 Draw Call。

为什么 CPU 耗时不能充当 GPU 耗时

performance.now() 包围 gl.drawArrays() 测到的是 JavaScript 调用及命令提交阶段的墙钟时间。GPU 往往异步处理队列中的命令,因此这段时间短不代表 GPU 在同一时间内完成了绘制。

WebGL 2 可以尝试 gl.getExtension("EXT_disjoint_timer_query_webgl2")。扩展可用时,用 gl.createQuery() 创建查询,以 gl.beginQuery(ext.TIME_ELAPSED_EXT, query) 和 gl.endQuery(ext.TIME_ELAPSED_EXT) 包住待测绘制批次;在后续帧用 gl.getQueryParameter(query, gl.QUERY_RESULT_AVAILABLE) 检查是否完成,确认 gl.getParameter(ext.GPU_DISJOINT_EXT) 为 false 后读取 gl.QUERY_RESULT,除以 1,000,000 得到毫秒,最后 gl.deleteQuery(query)。

主线程提交、GPU执行与屏幕呈现的异步时间线

分别比较三种优化

只改一个变量,观察相同场景下 3 轮录制的中位数和最长帧。以下是可预先计算的计数变化,不是预设的性能加速百分比:

实验 变更前 变更后 应关注的指标
相同网格实例化 100 次 drawArrays 1 次 drawArraysInstanced,仍绘制 100 个实例 Draw Call、主线程提交耗时
不透明物体按材质排序 200 个物体、A/B 材质交替,最多 200 次 Program 切换 A 组先绘、B 组后绘,约 2 次切换 Program/纹理绑定次数、主线程耗时
绘制缓冲区缩放 scale=1,像素数为基准 scale=0.7,像素数约为 49% GPU 时间、帧率、画面清晰度

对不透明物体可按 Program、材质和纹理分组;透明物体通常还需保持适当的由远及近绘制顺序,不能仅为减少状态切换而打乱混合顺序。分辨率实验改的是 canvas.width 与 canvas.height,不改变 CSS 显示尺寸;在高 DPI 屏上实际像素数还要乘设备像素比的平方。

若实例化明显降低 CPU 提交时间但帧率不变,应继续检查 GPU 填充、着色器复杂度与同步等待;若缩小绘制缓冲区后 GPU 时间降低,则更可能受到像素填充或片元着色影响。记录浏览器版本、设备、DPR、分辨率、场景对象数及是否开启抗锯齿,才能让下次测量与本次结果可比。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

分析绘制调用与帧耗时

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通