Web 图形与 3D / 系统课时
分析绘制调用与帧耗时
分析绘制调用与帧耗时
WebGL 2 场景掉帧可能来自重复 Draw Call、频繁切换材质或像素填充过多。本课先用 Chrome 性能面板找到长帧,再运行 100 个三角形的实验,区分 CPU 提交、帧间隔与 GPU 耗时,并验证实例化和降分辨率是否有效。
学习目标
- 在 Chrome Performance 录制中定位长帧,区分主线程耗时与 GPU 工作时间。
- 统计每帧 Draw Call 和已创建资源数量,运行逐个绘制与实例化的对照实验。
- 按固定变量比较状态切换、实例化与渲染分辨率,解释 GPU 计时查询的限制。
在浏览器中建立可复现的基线
以桌面版 Chrome DevTools 为例,先关闭其他占用 GPU 的标签页,让动画稳定运行 3 秒,再执行以下操作:
- 按
F12,进入Performance,点击Record录制约 8 秒,期间保持相同的场景和镜头操作,随后停止。 - 查看
Frames或 FPS 相关轨道,找到明显超过刷新周期的长帧;展开Main轨道检查脚本调用与渲染任务,并用Bottom-up查看累计耗时。 - 在相同窗口尺寸、设备像素比和浏览器缩放下重复录制 3 次;对照中位数与长帧,而不是挑选最好的一次。
60 Hz 显示器的单帧预算约 16.7 ms,120 Hz 约 8.3 ms。Main 中脚本任务偏长提示 CPU 压力,但浏览器的 Paint 并不等于 WebGL 的 GPU 绘制耗时;没有 GPU 计时数据时,不能仅凭主线程短就断言 GPU 空闲。

运行 Draw Call 与资源计数实验
将下面代码保存为 webgl-profile.html,用支持 WebGL 2 的桌面浏览器打开;直接查看画布下方每 120 帧更新一次的统计,同时可用 DevTools 录制性能。按 I 切换逐个绘制与实例化,按 R 切换渲染分辨率。两种模式绘制相同的 100 个三角形。
<!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> 是随设备与负载变化的数值占位符:
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)。

分别比较三种优化
只改一个变量,观察相同场景下 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、分辨率、场景对象数及是否开启抗锯齿,才能让下次测量与本次结果可比。