HarmonyOS 6 HiTrace 实测:20 段计算,怎样找出最长一次界面反馈间隔
配套工程源码、测试材料与运行说明
前言
两颗按钮最后算出的校验值都是 −456971984。奇怪的是,连续执行的面板隔了 17,714 ms 才反馈一次,分段执行那组的最长间隔只有 1,017 ms,整轮却用了 18,247 ms。为了弄清这些数字在讲什么,我先把二十段计算逐一标进 trace,再读面板。读者可以沿着同一份校验值和段数去找两条时间轴,把工作总量、完成耗时和反馈机会分别核对。
卡住的时候,计算到底有没有少做
两条路都计算二十段,每段八百五十万次整数运算,从相同的输入出发。下一段用前一段的校验值继续算,最后页面显示同一结果。这个条件防止误把跳过一部分任务算作速度提升。两段间的等待只在分段路径启用。即使给方法加 async,如果里面没有真正交回事件循环的等待,密集的同步循环仍可以一段接一段跑到底。
hiTraceMeter.startTrace(chunk, i);
try {
checksum = sweep(checksum);
} finally {
hiTraceMeter.finishTrace(chunk, i);
}
this.done = i + 1;
if (split && i + 1 < SECTIONS) await yieldTurn();
if (id !== this.runId) return;
这个小片段值得按执行顺序看。先打开一段 trace,标签配上循环序号。同步计算成功或失败,都用 finally 关闭同一段。之后才推进画面上的完成计数。分段开关在相邻块之间等待定时任务,UI 在这段空档有机会更新。每一段内部的计算仍会占用线程。把等待放在进度更新之前甚至末轮也等一次,会让面板显示及测量范围变化,改动时要先决定末段完成算在哪一刻。

整轮、子块与计时器的职责最好拆开读。整轮标记在点击后打开,完成时关闭,覆盖进入以后所有计算和让出时段。子块只圈住当次 sweep,段号用于对应同一组 start 和 finish。界面计时器只定期尝试写一个点,程序忙时不会按原计划完成,下一次有机会执行时才观察到较大的间隔。这三个观察如果共用一个名字,打开轨迹会看见许多重叠块,很难把工作时间和没有反馈的时间分开。源码里把事件名称显式区分,还保留任务编号,方便以后做多轮分析。
从一份 trace 找到二十段
设备侧开始采集后,再点「连续执行」和「分段让出」,两轮都结束才收尾。命令中的 DEVICE 换成 hdc list targets 查到的模拟器目标。应用用 @kit.PerformanceAnalysisKit 的 hiTraceMeter.startTrace 和 finishTrace 留下范围。拉回的记录应该同时出现 JITTER_WHOLE_INLINE 与 JITTER_WHOLE_SLICED。缺一组时先检查采集起止、缓冲区和操作次序,确认记录完整再做 SQL 统计。
hdc -t DEVICE shell hitrace --trace_begin -b 32768 app ace
hdc -t DEVICE shell hitrace --trace_finish -o /data/local/tmp/jitter.trace
hdc -t DEVICE file recv /data/local/tmp/jitter.trace jitter.trace
trace_streamer.exe jitter.trace -e jitter.sqlite
SELECT name, COUNT(*) AS slices, ROUND(MAX(dur) / 1e6, 3) AS longest_ms
FROM callstack
WHERE name LIKE 'H:JITTER_%' AND dur > 0
GROUP BY name
ORDER BY name;
这条查询按名称归类。COUNT 说明读到多少个块,MAX 取这组里最长的一块。假如连续组的每一块看起来都不算很长,整轮仍然可能让界面等很久,因为前一块刚结束,下一块马上开始。要判断让出了多久,下一条查询把当前开始时间减去上一段的结束时间。窗口函数按同一名称分组并按时间排序,第一段没有上一段,要把它单独看。
WITH chunks AS (
SELECT name, ts,
LAG(ts + dur) OVER (PARTITION BY name ORDER BY ts) AS previous_end
FROM callstack
WHERE name IN ('H:JITTER_CHUNK_INLINE', 'H:JITTER_CHUNK_SLICED')
AND dur > 0
)
SELECT name, ROUND((ts - previous_end) / 1e6, 3) AS gap_ms
FROM chunks
WHERE previous_end IS NOT NULL
ORDER BY name, ts;
实际复跑先查设备目标,再让模拟器开到节拍故障台。工具执行 trace_begin 时使用 app 和 ace 类别,缓冲设为 32768;两次计算完成后用 trace_finish 输出文件。把同一个文件取回,再交给 DevEco Studio 安装目录 tools/profiler/dic_server 下的 trace_streamer,通过 -e 输出 SQLite。记好每轮文件名,以免第二次打开了上一轮导出的库。数据库里 dur 的数值按纳秒理解,代码里的 MAX 除以一百万转成毫秒。漏改单位时一段可能像是几亿毫秒,先量纲检查比猜设备非常慢更靠谱。这一流程用 MateBook Pro API 24 模拟器完成,运行版本 6.1.0.125(SP12DEVC00E47R1P3)。
本轮的原始记录里,连续路径最长一个计算块约 1336.583 毫秒,分段路径最长一个约 990.684 毫秒,二者均有二十段。整轮 trace 分别约 17.714 秒和 18.247 秒。这些值对应事件区间,和面板报告的回调间隔不一定相等。前者可以指向哪个计算块重,后者显示用户隔多久收到一次下一步反馈。若应用中还有读磁盘、同步日志或数据展开,可以给它们各留标签,按实际开始与结束判断它们是否延长了 UI 的等待。
用 Profiler 看时可做类似的事。找到应用主线程和带标记的区间,再对输入和画面更新所在的位置。图中的空档也可能来自没有采对线程、标记遗漏或另外的工作。别把时间线上没看到颜色的那一块直接写成空闲。本文处理更新和校验时使用系统 HiTrace 与解析结果;下方原有区间图来自另一轮,用于讲标记怎么读。

读图时,先找最长一次反馈间隔
| API 24 MateBook Pro 模拟器 | 连续执行 | 分段执行 |
| 面板最长打点间隔 | 17,714 ms | 1,017 ms |
| 面板整轮耗时 | 17,714 ms | 18,247 ms |
| 校验结果 | −456971984 | −456971984 |
| 解析到的计算子段 | 20 | 20 |


看动图时停留在按钮刚开始和场景切换之间。连续路径出现计算迟迟不刷新随后显示完成,分段路径可见进度逐步补上。要确认这不是少算,回到图和表同时对 20 / 20 与 −456971984。最长间隔下降约 16.7 秒,分段整轮用时却多约半秒,这两项恰好回答不同的问题。下一步只有在确认同一段应用占用与前台停顿重合之后,才去改 sweep 的调度;若进度回调按时出现而屏幕未动,则继续查布局与呈现。
表里的最长间隔来自应用打点。代码安排固定周期请求更新,计算期间直到能再执行才记录下一次。它衡量相邻两次回调隔了多久,不等于落了多少帧。连续侧长时间都没更新,整个任务完了才接着响应。分段侧给画面留了多次机会,但一次计算块内部仍有停顿。两轮里分段的整轮完成时间一会儿稍短、一会儿稍长,不能拿其中一轮称整体吞吐提升,因为调度和环境会影响读数。
如果用户正在等搜索结果,可能要求可取消、能看到状态又希望总时长缩短。需要分别设目标。能在别的线程做的计算可保持 UI 路径短,再观察最终校验值是否仍一样。必须更新界面的工作让它分批进行,也要看每批最长花多久。如果随窗口变化同时重新计算布局,从应用 trace 的一次停顿出发,还应该查那时有没有窗口渲染或其他重任务,不能把都归给当前按钮。
上手看轨迹时不妨从最后一根柱子往左找。它前面若正好是一连串紧挨着的计算标记,就继续确认这些标记属于负责更新页面的线程。若只是看见渲染侧没有收到新工作,别急着认为是渲染出错,做决定的是它上游有没有提交。真实项目还会碰到反过来的情况:应用线程按时交出状态,但是下游忙着画一次重布局。这时应用日志显示更新,也不等于用户真的已经看到了新帧,要跟系统帧记录交叉检查。
完整入口和复跑条件
完整工程已经放在文首,打开后用 API 24 SDK 运行 entry。先在开发机启动采集,然后分别完成一次连续执行与分段执行,再结束 trace。两轮都以二十段、每段八百五十万次为基准,先在界面核对校验值和完成标记,随后在导出的 trace 中核对每组段数。想试更小的分段,可以另留一份同总量的样本,比较最长反馈间隔和整轮耗时,各自说明变化的原因。
先用应用进程过滤 trace,避免把别的应用事件算进去。单段最长耗时来自 trace 的起止,面板最长间隔来自应用打点,两组数分别记录。只要其中一边的计算段还没收全,就回到设备上重录完整过程。
import { hiTraceMeter } from '@kit.PerformanceAnalysisKit';
import { systemDateTime } from '@kit.BasicServicesKit';
const SECTIONS = 20;
const OPERATIONS = 8500000;
const INTERVAL = 65;
function sweep(seed: number): number {
let value = seed;
for (let i = 0; i < OPERATIONS; i++) {
value = (Math.imul(value, 1664525) + 1013904223) | 0;
value ^= value >>> 11;
}
return value;
}
function now(): number {
return systemDateTime.getUptime(systemDateTime.TimeType.STARTUP);
}
function yieldTurn(): Promise<void> {
return new Promise<void>(resolve => { setTimeout(resolve, 18); });
}
@Entry
@Component
struct Index {
@State private samples: number[] = [];
@State private phase: string = '等待试验';
@State private busy: boolean = false;
@State private done: number = 0;
@State private continuous: string = '—';
@State private staggered: string = '—';
private timer: number = -1;
private previous: number = 0;
private runId: number = 0;
private tick(): void {
const time = now();
this.samples = [...this.samples, time - this.previous];
this.previous = time;
}
private async run(split: boolean): Promise<void> {
if (this.busy) return;
this.busy = true;
this.done = 0;
this.samples = [];
this.phase = split ? '分段执行中' : '连续执行中';
const id = ++this.runId;
let checksum: number = 78;
await yieldTurn();
if (id !== this.runId) return;
this.previous = now();
this.timer = setInterval(() => this.tick(), INTERVAL);
const label = split ? 'JITTER_WHOLE_SLICED' : 'JITTER_WHOLE_INLINE';
const started = now();
hiTraceMeter.startTrace(label, id);
try {
for (let i = 0; i < SECTIONS; i++) {
const chunk = split ? 'JITTER_CHUNK_SLICED' : 'JITTER_CHUNK_INLINE';
hiTraceMeter.startTrace(chunk, i);
try {
checksum = sweep(checksum);
} finally {
hiTraceMeter.finishTrace(chunk, i);
}
this.done = i + 1;
if (split && i + 1 < SECTIONS) await yieldTurn();
if (id !== this.runId) return;
}
// 记录尾段的时间差;连续路径的定时器在循环中无法运行。
this.tick();
const maxGap = this.samples.reduce((a: number, b: number) => Math.max(a, b), 0);
const text = `${maxGap} ms · 总 ${now() - started} ms · ${checksum}`;
if (split) this.staggered = text;
else this.continuous = text;
this.phase = split ? '分段执行完成' : '连续执行完成';
} finally {
hiTraceMeter.finishTrace(label, id);
if (id === this.runId) {
clearInterval(this.timer);
this.busy = false;
}
}
}
aboutToDisappear(): void {
this.runId++;
clearInterval(this.timer);
this.busy = false;
}
@Builder
private Signal() {
Column({ space: 7 }) {
Text('主线程打点').fontSize(15).fontWeight(FontWeight.Bold).fontColor('#D6E2DA')
Row({ space: 5 }) {
ForEach(this.samples.slice(-22), (sample: number, index: number) => {
Column() {
Rect().height(Math.min(98, 8 + sample * 0.42)).width('100%')
.fill(sample > 110 ? '#FB8756' : '#BFFF43')
}.height(108).layoutWeight(1).justifyContent(FlexAlign.End)
}, (sample: number, index: number) => `${index}:${sample}`)
if (this.samples.length === 0) {
Text('等待第一条采样').fontSize(12).fontColor('#C3D2C7')
}
}.height(116).width('100%').alignItems(VerticalAlign.Bottom)
.padding(7).border({ width: 1, color: '#405448' })
Text('单根柱对应一次间隔 · 量程上限见正文').fontSize(11).fontColor('#B8C7BC')
}.width('100%').alignItems(HorizontalAlign.Start)
}
build() {
Scroll() {
Column({ space: 17 }) {
Row({ space: 12 }) {
Text('节拍故障台').fontSize(31).fontWeight(FontWeight.Bold).fontColor('#EDFFF2').layoutWeight(1)
Text('TRACE / 20 段').fontSize(12).fontFamily('monospace').fontColor('#BFFF43')
}.width('100%')
GridRow({ columns: 12, gutter: 16 }) {
GridCol({ span: { xs: 12, sm: 7 } }) {
this.Signal()
}
GridCol({ span: { xs: 12, sm: 5 } }) {
Column({ space: 10 }) {
Text(this.phase).id('phase').fontSize(17).fontColor('#F3FFF4').fontWeight(FontWeight.Bold)
Text(`${this.done} / 20`).id('done').fontSize(30).fontFamily('monospace').fontColor('#BFFF43')
Row({ space: 7 }) {
Button('连续执行', { type: ButtonType.Normal }).id('inline').enabled(!this.busy).height(35)
.fontSize(12).fontColor('#FFF4E9').backgroundColor('#503528').borderRadius(3)
.onClick(() => { void this.run(false); })
Button('分段让出', { type: ButtonType.Normal }).id('sliced').enabled(!this.busy).height(35)
.fontSize(12).fontColor('#172317').backgroundColor('#BFFF43').borderRadius(3)
.onClick(() => { void this.run(true); })
}.width('100%')
}.width('100%').alignItems(HorizontalAlign.Start).padding(12).backgroundColor('#263B30')
}
}.width('100%')
Divider().color('#405448')
Text('最长打点间隔 / 总耗时 / 校验值').fontSize(12).fontColor('#CBDAD0')
Row({ space: 10 }) {
Text('连续').width(52).fontSize(13).fontColor('#FBAD89')
Text(this.continuous).id('inline-data').fontSize(14).fontFamily('monospace').fontColor('#F3FFF4')
}.width('100%')
Row({ space: 10 }) {
Text('分段').width(52).fontSize(13).fontColor('#BFFF43')
Text(this.staggered).id('sliced-data').fontSize(14).fontFamily('monospace').fontColor('#F3FFF4')
}.width('100%')
}.width('100%').constraintSize({ maxWidth: 905 }).padding(26).alignItems(HorizontalAlign.Start)
}.width('100%').height('100%').align(Alignment.Top).backgroundColor('#15271F')
}
}
原例如果想验证块越小是否越平滑,一次只改总工作切成多少份,其余输入、起始种子、窗口与进度刷新节奏保持一致。若继续逐段喂入种子,要检查改分段定义后还在比较同一种结果。也可以保持二十次同样的业务工作,在每份中插入更细的让出机会,另查校验结果与外层区间。真实应用还有个退出条件,用户离页时不应再收到这轮结果。让取消或标记失效成为一条独立用例,再谈性能。界面看起来快一点不能掩盖旧任务回写。
FAQ|命令能生成文件,SQL 却查不到区间
实际文件先找样例标签,再确认解析后的名称表示是什么。空结果可能是从其他进程采的,也可能是采集过早结束,使用的类别没有包含应用事件。把测试缩到一次按钮操作,等完以后再关采集。等能在原始记录对到这一轮,再扩展到两种模式。别先去改 SQL 的时间单位,单位错误不会让一个缺失的名称出现。
FAQ|分段已经让出,为什么进度还有一秒没动
定时任务只在块之间有机会执行。每块如果接近一秒,画面仍要等这一块结束。代码里的定时等待是两段之间的安排,不能缩短块里的同步循环。决定改哪一种,要看任务是否能拆到后台、是否需要逐步更新,以及用户希望等待的尺度。换成更小的块也要计总开销,不能只看一条变绿的等待记录。
FAQ|返回后又进来,旧任务会不会写到新界面
在完整文件里能看到 runId 和离开时的清理。可以在分段时退出,再回来确认前一轮计时器和完成提示不会串到新页。这个场景适合给接入团队再做一次回归,因为未来如果把分段改成后台线程,加法虽然一样,取消与回写的责任已经换了。
还建议给诊断样本留一份不带界面采样的对照。把进度栏设成很复杂的组件,更新自身也会带来工作;如果每个处理块都写大量日志,日志又会挤进同一时段。可以先用简单状态重放计算,然后逐步加入真实进度页与数据。比较时把同一设备、相同输入和相同采集类别写进记录,标出哪组用来验证机制,哪组作为真实性能参考。不然跑得最漂亮的那张图可能只是移除了被测应用本来要做的事。
给团队留结果时,可以同时写一张「能解释到哪里」的记录。若标记数是二十、结果一致、最长打点间隔变短,这些证据支持优先拆开连续阻塞。若还有一段空白不能解释,就回到原始文件核对同一进程中的应用线程与系统刷新,而不是把所有剩余时间都写成 UI 开销。一次系统或依赖升级也可能改变追踪解析后的名称和线程分组,先用同样的操作取得能对照的区间。需要交给另一位开发者复现时,留下应用版本、模拟器 API、触发动作、选用的采集类别和查询。只交一张柱状图,他无法在下一轮追到同一段代码。
总结
用相同任务和结果锁住工作量,再看二十个区间之间的空档。这个实验支持「分段时有更多机会更新界面」,给出的是定位主线程占用的方法。想进一步给用户可见的首帧、掉帧和吞吐下结论,就用系统事件和各自独立的测量补齐。
下一次回归可以用任务校验值、组成区间数和最长回调间隔作为三个检查点。只要有一个不对,再回来查沿途的线程记录。
更多推荐
所有评论(0)