#!/bin/bash
|
# Round01 real Quick Switch main UI performance gate.
|
|
set -euo pipefail
|
|
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
OUTPUT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
|
# shellcheck source=build-output-paths.sh
|
source "$SCRIPT_DIR/build-output-paths.sh"
|
APP="$BUILD_CURRENT_APP"
|
BUILD_ROOT="$OUTPUT_ROOT/C2.builds"
|
INTERACTION_REPORT="$BUILD_REPORT_ROOT/round01-main-ui-performance-interaction-report.json"
|
LIFECYCLE_REPORT="$BUILD_REPORT_ROOT/round01-main-ui-performance-lifecycle-report.json"
|
INSTRUMENTS_REPORT="$BUILD_REPORT_ROOT/round01-main-ui-performance-instruments-report.json"
|
TRACE="$BUILD_REPORT_ROOT/round01-main-ui-performance-time-profile.trace"
|
POTENTIAL_HANGS_XML="$BUILD_REPORT_ROOT/round01-main-ui-performance-potential-hangs.xml"
|
HANG_RISKS_XML="$BUILD_REPORT_ROOT/round01-main-ui-performance-hang-risks.xml"
|
SUMMARY="$BUILD_REPORT_ROOT/round01-main-ui-performance-summary.json"
|
RUN_ID="$(date +%Y%m%d_%H%M%S)"
|
LOG_DIR="${ALIGNER_ROUND1_MAIN_UI_PERF_LOG_DIR:-/tmp/aligner-round01-main-ui-performance-$RUN_ID}"
|
APP_COUNT="${ALIGNER_ROUND1_MAIN_UI_PERF_APP_COUNT:-20}"
|
WINDOWS_PER_APP="${ALIGNER_ROUND1_MAIN_UI_PERF_WINDOWS_PER_APP:-10}"
|
LIFECYCLE_CYCLES="${ALIGNER_ROUND1_MAIN_UI_PERF_LIFECYCLE_CYCLES:-100}"
|
LIFECYCLE_INTERVAL="${ALIGNER_ROUND1_MAIN_UI_PERF_LIFECYCLE_INTERVAL:-0.02}"
|
LIFECYCLE_VISIBLE_DURATION="${ALIGNER_ROUND1_MAIN_UI_PERF_LIFECYCLE_VISIBLE_DURATION:-0.16}"
|
REPORT_WAIT="${ALIGNER_ROUND1_MAIN_UI_PERF_REPORT_WAIT:-8.0}"
|
INSTRUMENTS_TIME_LIMIT="${ALIGNER_ROUND1_MAIN_UI_PERF_INSTRUMENTS_TIME_LIMIT:-12s}"
|
|
fail() {
|
echo "Round01 main UI performance gate failed: $*" >&2
|
exit 1
|
}
|
|
run_logged() {
|
local name="$1"
|
shift
|
local log="$LOG_DIR/$name.log"
|
|
if "$@" >"$log" 2>&1; then
|
echo "PASS $name"
|
else
|
local code="$?"
|
echo "FAIL $name (log: $log)" >&2
|
tail -c 6000 "$log" >&2 || true
|
exit "$code"
|
fi
|
}
|
|
aligner_pids_for_current_app() {
|
ps -axo pid=,args= | while read -r pid command; do
|
case "$command" in
|
"$APP/Contents/MacOS/Aligner"*) echo "$pid" ;;
|
esac
|
done
|
}
|
|
stop_current_aligner() {
|
for pid in $(aligner_pids_for_current_app); do
|
kill "$pid" 2>/dev/null || true
|
done
|
|
for _ in {1..30}; do
|
[ -z "$(aligner_pids_for_current_app)" ] && return
|
sleep 0.1
|
done
|
|
fail "current Aligner app did not exit before performance gate"
|
}
|
|
wait_for_interaction_report() {
|
/usr/bin/python3 - "$INTERACTION_REPORT" "$REPORT_WAIT" "$APP_COUNT" "$WINDOWS_PER_APP" <<'PY'
|
import json
|
import os
|
import sys
|
import time
|
|
path = sys.argv[1]
|
timeout = float(sys.argv[2])
|
app_count = int(sys.argv[3])
|
windows_per_app = int(sys.argv[4])
|
deadline = time.monotonic() + timeout
|
expected_windows = app_count * windows_per_app
|
last_report = None
|
|
def stable_fingerprint(value):
|
hash_value = 0xCBF29CE484222325
|
for byte in (value or "").encode("utf-8"):
|
hash_value ^= byte
|
hash_value = (hash_value * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
|
return f"{hash_value:016x}"
|
|
while time.monotonic() < deadline:
|
try:
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
last_report = report
|
root = report.get("rootView", {})
|
if (
|
report.get("snapshotLoaded") is True
|
and report.get("quickSwitchVisible") is True
|
and report.get("appCount") == app_count
|
and report.get("windowCount") == expected_windows
|
and root.get("firstFrameLatencySampleCount", 0) >= 1
|
and root.get("keyboardResponseSampleCount", 0) >= 40
|
and root.get("hoverResponseSampleCount", 0) >= 40
|
):
|
sys.exit(0)
|
except FileNotFoundError:
|
pass
|
except json.JSONDecodeError:
|
pass
|
time.sleep(0.1)
|
|
if last_report is not None:
|
root = last_report.get("rootView", {})
|
print(json.dumps({
|
"reportBasename": os.path.basename(path),
|
"reportPathHash": stable_fingerprint(path),
|
"snapshotLoaded": last_report.get("snapshotLoaded"),
|
"quickSwitchVisible": last_report.get("quickSwitchVisible"),
|
"appCount": last_report.get("appCount"),
|
"windowCount": last_report.get("windowCount"),
|
"firstFrameLatencySampleCount": root.get("firstFrameLatencySampleCount"),
|
"keyboardResponseSampleCount": root.get("keyboardResponseSampleCount"),
|
"hoverResponseSampleCount": root.get("hoverResponseSampleCount"),
|
}, indent=2, ensure_ascii=False), file=sys.stderr)
|
print(f"interaction performance report did not become ready within {timeout:.1f}s", file=sys.stderr)
|
sys.exit(1)
|
PY
|
}
|
|
assert_interaction_report() {
|
local report_path="$1"
|
/usr/bin/python3 - "$report_path" "$APP_COUNT" "$WINDOWS_PER_APP" <<'PY'
|
import json
|
import os
|
import sys
|
|
path = sys.argv[1]
|
app_count = int(sys.argv[2])
|
windows_per_app = int(sys.argv[3])
|
expected_windows = app_count * windows_per_app
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
|
def stable_fingerprint(value):
|
hash_value = 0xCBF29CE484222325
|
for byte in (value or "").encode("utf-8"):
|
hash_value ^= byte
|
hash_value = (hash_value * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
|
return f"{hash_value:016x}"
|
|
def summary():
|
root = report.get("rootView", {})
|
return {
|
"reportBasename": os.path.basename(path),
|
"reportPathHash": stable_fingerprint(path),
|
"snapshotLoaded": report.get("snapshotLoaded"),
|
"quickSwitchVisible": report.get("quickSwitchVisible"),
|
"appCount": report.get("appCount"),
|
"windowCount": report.get("windowCount"),
|
"firstFrameLatencySampleCount": root.get("firstFrameLatencySampleCount"),
|
"firstFrameLatencyP95Milliseconds": root.get("firstFrameLatencyP95Milliseconds"),
|
"keyboardResponseSampleCount": root.get("keyboardResponseSampleCount"),
|
"keyboardResponseP95Milliseconds": root.get("keyboardResponseP95Milliseconds"),
|
"hoverResponseSampleCount": root.get("hoverResponseSampleCount"),
|
"hoverResponseP95Milliseconds": root.get("hoverResponseP95Milliseconds"),
|
"screenshotNotRequestedCount": root.get("screenshotNotRequestedCount"),
|
}
|
|
def require(condition, message):
|
if not condition:
|
print(message, file=sys.stderr)
|
print(json.dumps(summary(), indent=2, ensure_ascii=False), file=sys.stderr)
|
sys.exit(1)
|
|
root = report.get("rootView", {})
|
require(report.get("snapshotLoaded") is True, "snapshot must be loaded")
|
require(report.get("appCount") == app_count, "fixture app count must match")
|
require(report.get("windowCount") == expected_windows, "fixture window count must match")
|
require(root.get("firstFrameLatencySampleCount", 0) >= 1, "first frame sample is required")
|
require(root.get("firstFrameLatencyP95Milliseconds") < 150, "first frame P95 must be < 150ms")
|
require(root.get("keyboardResponseSampleCount", 0) >= 40, "keyboard sample count must be >= 40")
|
require(root.get("keyboardResponseP95Milliseconds") < 50, "keyboard P95 must be < 50ms")
|
require(root.get("hoverResponseSampleCount", 0) >= 40, "hover sample count must be >= 40")
|
require(root.get("hoverResponseP95Milliseconds") <= 32, "hover P95 must be <= 32ms")
|
require(root.get("interactionPerformanceGatePassed") is True, "interaction gate must pass")
|
require(root.get("screenshotNotRequestedCount") == expected_windows, "disabled screenshot run must mark all cards not requested")
|
|
print(json.dumps({
|
"firstFrameP95": root.get("firstFrameLatencyP95Milliseconds"),
|
"keyboardP95": root.get("keyboardResponseP95Milliseconds"),
|
"hoverP95": root.get("hoverResponseP95Milliseconds"),
|
"keyboardSamples": root.get("keyboardResponseSampleCount"),
|
"hoverSamples": root.get("hoverResponseSampleCount"),
|
"windowCount": report.get("windowCount")
|
}, indent=2, ensure_ascii=False))
|
PY
|
}
|
|
assert_lifecycle_report() {
|
/usr/bin/python3 - "$LIFECYCLE_REPORT" "$LIFECYCLE_CYCLES" "$APP_COUNT" "$WINDOWS_PER_APP" <<'PY'
|
import json
|
import os
|
import sys
|
|
path = sys.argv[1]
|
cycles = int(sys.argv[2])
|
app_count = int(sys.argv[3])
|
windows_per_app = int(sys.argv[4])
|
expected_windows = app_count * windows_per_app
|
with open(path, "r", encoding="utf-8") as file:
|
report = json.load(file)
|
|
def stable_fingerprint(value):
|
hash_value = 0xCBF29CE484222325
|
for byte in (value or "").encode("utf-8"):
|
hash_value ^= byte
|
hash_value = (hash_value * 0x100000001B3) & 0xFFFFFFFFFFFFFFFF
|
return f"{hash_value:016x}"
|
|
def summary():
|
root = report.get("rootView", {})
|
return {
|
"reportBasename": os.path.basename(path),
|
"reportPathHash": stable_fingerprint(path),
|
"quickSwitchVisible": report.get("quickSwitchVisible"),
|
"appCount": report.get("appCount"),
|
"windowCount": report.get("windowCount"),
|
"lifecycleTargetCycles": report.get("lifecycleTargetCycles"),
|
"lifecycleCompletedCycles": report.get("lifecycleCompletedCycles"),
|
"lifecycleGatePassed": report.get("lifecycleGatePassed"),
|
"lifecycleMaximumOverlayWindows": report.get("lifecycleMaximumOverlayWindows"),
|
"lifecycleMaximumVisibleOverlayWindows": report.get("lifecycleMaximumVisibleOverlayWindows"),
|
"lifecycleResidualOverlayWindows": report.get("lifecycleResidualOverlayWindows"),
|
"lifecycleResidualVisibleOverlayWindows": report.get("lifecycleResidualVisibleOverlayWindows"),
|
"firstFrameLatencySampleCount": root.get("firstFrameLatencySampleCount"),
|
"firstFrameLatencyP95Milliseconds": root.get("firstFrameLatencyP95Milliseconds"),
|
"screenshotNotRequestedCount": root.get("screenshotNotRequestedCount"),
|
}
|
|
def require(condition, message):
|
if not condition:
|
print(message, file=sys.stderr)
|
print(json.dumps(summary(), indent=2, ensure_ascii=False), file=sys.stderr)
|
sys.exit(1)
|
|
root = report.get("rootView", {})
|
require(report.get("lifecycleTargetCycles") == cycles, "lifecycle target cycles must match")
|
require(report.get("lifecycleCompletedCycles") == cycles, "lifecycle completed cycles must match")
|
require(report.get("lifecycleGatePassed") is True, "lifecycle gate must pass")
|
require(report.get("lifecycleMaximumOverlayWindows") <= 1, "maximum overlay windows must be <= 1")
|
require(report.get("lifecycleMaximumVisibleOverlayWindows") <= 1, "maximum visible overlay windows must be <= 1")
|
require(report.get("lifecycleResidualVisibleOverlayWindows") == 0, "visible overlay residual must be 0")
|
require(report.get("lifecycleResidualOverlayWindows") <= 1, "hidden reusable overlay residual must be <= 1")
|
require(report.get("quickSwitchVisible") is False, "Quick Switch must be hidden after lifecycle")
|
require(report.get("appCount") == app_count, "final lifecycle app count must match")
|
require(report.get("windowCount") == expected_windows, "final lifecycle window count must match")
|
require(root.get("firstFrameLatencySampleCount") == cycles, "first frame samples must match lifecycle cycles")
|
require(root.get("firstFrameLatencyP95Milliseconds") < 150, "lifecycle first frame P95 must be < 150ms")
|
require(root.get("screenshotNotRequestedCount") == expected_windows, "disabled screenshot lifecycle must mark all cards not requested")
|
|
print(json.dumps({
|
"cycles": report.get("lifecycleCompletedCycles"),
|
"firstFrameP95": root.get("firstFrameLatencyP95Milliseconds"),
|
"maximumOverlayWindows": report.get("lifecycleMaximumOverlayWindows"),
|
"residualVisibleOverlayWindows": report.get("lifecycleResidualVisibleOverlayWindows")
|
}, indent=2, ensure_ascii=False))
|
PY
|
}
|
|
count_trace_rows() {
|
local xml_path="$1"
|
local expected_schema="$2"
|
/usr/bin/python3 - "$xml_path" "$expected_schema" <<'PY'
|
import sys
|
import xml.etree.ElementTree as ET
|
|
xml_path, expected_schema = sys.argv[1:3]
|
root = ET.parse(xml_path).getroot()
|
schemas = root.findall(f".//schema[@name='{expected_schema}']")
|
if not schemas:
|
print(f"missing xctrace schema: {expected_schema} in {xml_path}", file=sys.stderr)
|
sys.exit(2)
|
print(len(root.findall(".//row")))
|
PY
|
}
|
|
KEY_SEQUENCE="$(/usr/bin/python3 - <<'PY'
|
commands = ["right", "down", "right", "up", "left", "down", "right", "up"] * 8
|
print(",".join(commands))
|
PY
|
)"
|
|
MOUSE_SEQUENCE="$(/usr/bin/python3 - "$APP_COUNT" "$WINDOWS_PER_APP" <<'PY'
|
import sys
|
|
app_count = int(sys.argv[1])
|
windows_per_app = int(sys.argv[2])
|
commands = []
|
for index in range(48):
|
app = index % app_count
|
window = (index * 3) % windows_per_app
|
commands.append(f"hover-card:{app}:{window}")
|
for index in range(16):
|
commands.append(f"hover-app:{index % app_count}")
|
print(",".join(commands))
|
PY
|
)"
|
|
cleanup() {
|
stop_current_aligner || true
|
}
|
trap cleanup EXIT
|
|
mkdir -p "$LOG_DIR"
|
stop_current_aligner
|
run_logged package-app "$SCRIPT_DIR/package-app.sh"
|
|
rm -f "$INTERACTION_REPORT" "$LIFECYCLE_REPORT" "$INSTRUMENTS_REPORT" "$POTENTIAL_HANGS_XML" "$HANG_RISKS_XML" "$SUMMARY"
|
rm -rf "$TRACE"
|
|
"$APP/Contents/MacOS/Aligner" \
|
--round0-skip-permissions \
|
--round01-open-quick-switch \
|
--round01-fixture-app-count="$APP_COUNT" \
|
--round01-fixture-windows-per-app="$WINDOWS_PER_APP" \
|
--round01-disable-screenshot-refresh \
|
--round01-debug-key-sequence="$KEY_SEQUENCE" \
|
--round01-debug-mouse-sequence="$MOUSE_SEQUENCE" \
|
--round01-quick-switch-report="$INTERACTION_REPORT" &
|
|
APP_PID=$!
|
wait_for_interaction_report
|
assert_interaction_report "$INTERACTION_REPORT"
|
kill "$APP_PID" 2>/dev/null || true
|
wait "$APP_PID" 2>/dev/null || true
|
stop_current_aligner
|
|
"$APP/Contents/MacOS/Aligner" \
|
--round0-skip-permissions \
|
--round01-fixture-app-count="$APP_COUNT" \
|
--round01-fixture-windows-per-app="$WINDOWS_PER_APP" \
|
--round01-disable-screenshot-refresh \
|
--round01-quick-switch-lifecycle-cycles="$LIFECYCLE_CYCLES" \
|
--round01-quick-switch-lifecycle-interval="$LIFECYCLE_INTERVAL" \
|
--round01-quick-switch-lifecycle-visible-duration="$LIFECYCLE_VISIBLE_DURATION" \
|
--round01-quick-switch-report="$LIFECYCLE_REPORT"
|
|
assert_lifecycle_report
|
run_logged no-quick-switch-after-lifecycle swift "$SCRIPT_DIR/window-logic-qa.swift" --expect-no-quick-switch
|
|
run_logged screenshot-session env \
|
ALIGNER_ROUND1_SCREENSHOT_SESSION_SKIP_OVERLAY_FRAME_CHECK=1 \
|
ALIGNER_ROUND1_SCREENSHOT_SESSION_REQUIRE_REAL=0 \
|
"$SCRIPT_DIR/round1-screenshot-session-qa.sh"
|
|
run_logged xctrace-record xcrun xctrace record \
|
--quiet \
|
--no-prompt \
|
--template 'Time Profiler' \
|
--time-limit "$INSTRUMENTS_TIME_LIMIT" \
|
--output "$TRACE" \
|
--launch -- "$APP/Contents/MacOS/Aligner" \
|
--round0-skip-permissions \
|
--round01-open-quick-switch \
|
--round01-fixture-app-count="$APP_COUNT" \
|
--round01-fixture-windows-per-app="$WINDOWS_PER_APP" \
|
--round01-disable-screenshot-refresh \
|
--round01-debug-key-sequence="$KEY_SEQUENCE" \
|
--round01-debug-mouse-sequence="$MOUSE_SEQUENCE" \
|
--round01-quick-switch-auto-hide-after=8.0 \
|
--round01-quick-switch-quit-after=10.0 \
|
--round01-quick-switch-report="$INSTRUMENTS_REPORT"
|
|
assert_interaction_report "$INSTRUMENTS_REPORT"
|
run_logged xctrace-export-potential-hangs xcrun xctrace export --input "$TRACE" --xpath '/trace-toc/run[@number="1"]/data/table[@schema="potential-hangs"]' --output "$POTENTIAL_HANGS_XML"
|
run_logged xctrace-export-hang-risks xcrun xctrace export --input "$TRACE" --xpath '/trace-toc/run[@number="1"]/data/table[@schema="hang-risks"]' --output "$HANG_RISKS_XML"
|
|
POTENTIAL_HANGS_COUNT="$(count_trace_rows "$POTENTIAL_HANGS_XML" "potential-hangs")"
|
HANG_RISKS_COUNT="$(count_trace_rows "$HANG_RISKS_XML" "hang-risks")"
|
[ "$POTENTIAL_HANGS_COUNT" = "0" ] || fail "Instruments potential-hangs must be 0, got $POTENTIAL_HANGS_COUNT"
|
[ "$HANG_RISKS_COUNT" = "0" ] || fail "Instruments hang-risks must be 0, got $HANG_RISKS_COUNT"
|
|
/usr/bin/python3 - "$INTERACTION_REPORT" "$LIFECYCLE_REPORT" "$INSTRUMENTS_REPORT" "$TRACE" "$POTENTIAL_HANGS_COUNT" "$HANG_RISKS_COUNT" "$SUMMARY" <<'PY'
|
import json
|
import sys
|
|
interaction_path, lifecycle_path, instruments_path, trace_path, potential_hangs, hang_risks, summary_path = sys.argv[1:8]
|
with open(interaction_path, "r", encoding="utf-8") as file:
|
interaction = json.load(file)
|
with open(lifecycle_path, "r", encoding="utf-8") as file:
|
lifecycle = json.load(file)
|
with open(instruments_path, "r", encoding="utf-8") as file:
|
instruments = json.load(file)
|
|
summary = {
|
"interactionReport": interaction_path,
|
"lifecycleReport": lifecycle_path,
|
"instrumentsReport": instruments_path,
|
"trace": trace_path,
|
"interaction": {
|
"firstFrameP95Milliseconds": interaction["rootView"].get("firstFrameLatencyP95Milliseconds"),
|
"keyboardP95Milliseconds": interaction["rootView"].get("keyboardResponseP95Milliseconds"),
|
"hoverP95Milliseconds": interaction["rootView"].get("hoverResponseP95Milliseconds"),
|
"windowCount": interaction.get("windowCount"),
|
},
|
"lifecycle": {
|
"cycles": lifecycle.get("lifecycleCompletedCycles"),
|
"firstFrameP95Milliseconds": lifecycle["rootView"].get("firstFrameLatencyP95Milliseconds"),
|
"maximumOverlayWindows": lifecycle.get("lifecycleMaximumOverlayWindows"),
|
"residualVisibleOverlayWindows": lifecycle.get("lifecycleResidualVisibleOverlayWindows"),
|
},
|
"instruments": {
|
"firstFrameP95Milliseconds": instruments["rootView"].get("firstFrameLatencyP95Milliseconds"),
|
"keyboardP95Milliseconds": instruments["rootView"].get("keyboardResponseP95Milliseconds"),
|
"hoverP95Milliseconds": instruments["rootView"].get("hoverResponseP95Milliseconds"),
|
"potentialHangs": int(potential_hangs),
|
"hangRisks": int(hang_risks),
|
},
|
}
|
|
with open(summary_path, "w", encoding="utf-8") as file:
|
json.dump(summary, file, indent=2, ensure_ascii=False)
|
print(json.dumps(summary, indent=2, ensure_ascii=False))
|
PY
|
|
stop_current_aligner
|
trap - EXIT
|
