From c817e10fc1826a3689446e4db1285d102663a295 Mon Sep 17 00:00:00 2001 From: QQ Date: Tue, 17 Nov 2026 08:24:48 +0800 Subject: [PATCH] Import apps/android/bench/index.tsx --- apps/android/bench/index.tsx | 244 +++++++++++++++++++++++++++++++++++ 1 file changed, 244 insertions(+) create mode 100644 apps/android/bench/index.tsx diff --git a/apps/android/bench/index.tsx b/apps/android/bench/index.tsx new file mode 100644 index 0000000..5ec6799 --- /dev/null +++ b/apps/android/bench/index.tsx @@ -0,0 +1,244 @@ +import '../src/polyfills' +import { LanUploadRoutes } from '../src/services/lan-upload' +import { nativeWebSocketSender } from '../src/services/native-websocket-binary' +import { uploadStagedFileToWorkspace, bytesToBase64 } from '../src/screens/chat-files' +// Dedicated Gradle entry. Never imported by the shipping application. +import React, { useEffect, useState } from 'react' +import { ScrollView, Text } from 'react-native' +import { registerRootComponent, requireOptionalNativeModule } from 'expo' +import { File, Paths } from 'expo-file-system' +import { readAsStringAsync, EncodingType } from 'expo-file-system/legacy' +import { RTCPeerConnection, registerGlobals } from 'react-native-webrtc' +import { generateKeyPair, NoiseIkSession, fromBase64Url } from '@dsh-remote/crypto' +import { createRpcRequest, encodeMessage, decodeMessage, SecureMessageCodec, type RpcMethod } from '@dsh-remote/protocol' +import { RtcChunkCodec } from '../../../packages/webrtc/src/rtc-chunking' +import { encodeBulkFrame, BULK_DATA_BYTES } from '../../../scripts/transport-bench/stream-codec' +import { nativeChaChaEncryptor } from '../src/services/native-chacha-poly' +import { createNativeRtcSender } from '../src/services/native-rtc-binary' + +registerGlobals() +const url = process.env.EXPO_PUBLIC_DSH_BENCH_URL! +const awake = requireOptionalNativeModule('ExpoKeepAwake') +const pause = (ms: number) => new Promise(resolve => setTimeout(resolve, ms)) +async function run(log: (line: string) => void) { + if (!url) throw new Error('EXPO_PUBLIC_DSH_BENCH_URL required') + await awake?.activate('isolated-bench') + const post = async (path: string, body: unknown) => { + const response = await fetch(`${url}/${path}`, {method:'POST',body:JSON.stringify(body),headers:{'Content-Type':'application/json'}}) + if(!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`) + return response.json() + } + const report = async (data: unknown) => { log(JSON.stringify(data)); await post('result',data) } + const file = new File(Paths.cache, 'dsh-isolated-bench.bin') + const pc = new RTCPeerConnection({iceServers:[]}) + const identity = generateKeyPair() + const config = await (await fetch(`${url}/config`)).json() + if(config.production) { + let active=true + let routes:LanUploadRoutes | undefined + try { + const sender=nativeWebSocketSender() + if(!sender) throw new Error('Production native WebSocket sender unavailable') + const {connectionId}=await post('production/setup',{publicKey:identity.publicKey}) + const control={rpc:async(method:string,params:unknown,signal?:AbortSignal):Promise=>{ + if(method.startsWith('workspace.upload.') && method!=='workspace.upload.lan.open') throw new Error('Production benchmark unexpectedly fell back to the control path') + const result=await fetch(`${url}/production/rpc`,{method:'POST',signal,headers:{'Content-Type':'application/json'},body:JSON.stringify({data:bytesToBase64(encodeMessage(createRpcRequest(method as RpcMethod,params)))})}) + const response=decodeMessage(fromBase64Url((await result.json()).data)),payload=response.payload as any + if(response.type==='rpc.error') throw Object.assign(new Error(payload.message),{code:payload.code}) + return payload.result as T + }} + routes=new LanUploadRoutes({control,identity:{...identity,deviceId:'fixture-phone',name:'fixture',platform:'android'},host:{identityKey:config.publicKey} as any,sender, + current:()=>active,mode:()=> 'LAN',connectionId:()=>connectionId,details:async()=>({webRtc:{mode:'LAN',remoteAddress:config.lanAddress}} as any)}) + const manager=routes + const rpc=Object.assign((method:string,params:unknown,signal?:AbortSignal)=>manager.rpc(method,params,signal),{supportsBinaryUpload:true}) + if(file.exists) file.delete() + await File.downloadFileAsync(`${url}/fixture`,file) + await report({phase:'production-ready',size:file.size,nativeSocket:true}) + for(let i=1;i<=2;i++) { + const start=performance.now() + const result=await uploadStagedFileToWorkspace(rpc,'bench',{id:`production-${i}`,name:`dsh-production-${i}-200MiB.bin`,uri:file.uri,size:file.size}) + const elapsedMs=performance.now()-start + const verification=await post('production/verify',{name:result.name}) + if(!verification.verified || verification.sha256!==config.sha256 || result.bytes!==config.size) throw new Error('Production upload checksum mismatch') + await report({phase:'production-upload',elapsedMs,mibPerSecond:file.size/1048576/(elapsedMs/1000),result,verification}) + } + await report({phase:'complete',transport:'production-lan'}) + } catch(error) { await report({phase:'error',error:String(error)}).catch(()=>undefined);throw error } + finally {active=false;await routes?.close();pc.close();if(file.exists)file.delete();await awake?.deactivate('isolated-bench')} + return + } + const cipher = nativeChaChaEncryptor() + const nativeSend = createNativeRtcSender(requireOptionalNativeModule('RemoteWebRtcBinary') ?? undefined) + const noise = new NoiseIkSession({role:'initiator',localPrivateKey:identity.privateKey,localPublicKey:identity.publicKey,remotePublicKey:config.publicKey,prologue:new TextEncoder().encode('dsh-isolated-bench-v1'),encryptChaChaPoly:cipher}) + const websocket=config.transport === 'websocket' + const channel: any = websocket ? new WebSocket(`${config.wsUrl}/${identity.publicKey}`) : pc.createDataChannel('bench',{ordered:true}) + const nativeSocket = websocket && config.nativeSocket ? requireOptionalNativeModule('RemoteWebRtcBinary') : undefined + if(websocket && config.nativeSocket && typeof nativeSocket?.sendSocket !== 'function') throw new Error('Native WebSocket benchmark bridge unavailable') + channel.binaryType = 'arraybuffer' + const rtcOut = new RtcChunkCodec(), rtcIn = new RtcChunkCodec(), secureOut = new SecureMessageCodec(), secureIn = new SecureMessageCodec() + const waiting = new Mapvoid;reject:(error:Error)=>void;timer:ReturnType}>() + let bulkState: {uploadId:string;sent:number;acked:number;error?:Error;wake?:()=>void} | undefined + let ready!: () => void + const handshake = new Promise(resolve => { ready = resolve }) + const opened = new Promise((resolve,reject) => { channel.onopen = () => resolve(); channel.onerror = () => reject(new Error('DataChannel error')) }) + channel.onclose = () => { + const error=new Error('Benchmark channel closed') + if(bulkState){bulkState.error=error;bulkState.wake?.()} + for(const item of waiting.values()){clearTimeout(item.timer);item.reject(error)} + waiting.clear() + } + channel.onmessage = ({data}: {data: ArrayBuffer | string}) => { + try { + if(typeof data === 'string') throw new Error('Expected binary') + const frame = rtcIn.decode(new Uint8Array(data)); if(!frame) return + if(!noise.complete) { noise.readHandshake(frame); ready(); return } + const plain = secureIn.decode(noise.decrypt(frame)); if(!plain) return + const message = decodeMessage(plain), payload = message.payload as any + if (bulkState && payload.requestId === `stream:${bulkState.uploadId}`) { + if (message.type === 'rpc.error') bulkState.error = new Error(payload.message) + else { + const offset=payload.result?.receivedBytes + if(!Number.isSafeInteger(offset) || offset < bulkState.acked || offset > bulkState.sent) throw new Error('Invalid cumulative acknowledgement') + bulkState.acked=offset + } + bulkState.wake?.(); return + } + const pending = waiting.get(payload.requestId); if(!pending) return + clearTimeout(pending.timer); waiting.delete(payload.requestId) + if(message.type === 'rpc.error') pending.reject(new Error(payload.message)); else pending.resolve(payload.result) + } catch(error) { log(String(error)); if(bulkState){bulkState.error=error as Error;bulkState.wake?.()}; for(const item of waiting.values()) item.reject(error as Error) } + } + let metrics = {readMs:0,encodeMs:0,encryptMs:0,sendMs:0,frames:0,maxBuffered:0} + let sendTail = Promise.resolve() + let sequence = 0 + const rpc = (method: string, params: unknown): Promise => { + const id = `bench-${++sequence}` + const response = new Promise((resolve,reject) => { + const timer = setTimeout(() => { waiting.delete(id); reject(new Error(`RPC timeout: ${method}`)) },60000) + waiting.set(id,{resolve,reject,timer}) + }) + // Serialize nonce/framing just as SecureTransport does, without waiting for RPC ACKs. + sendTail = sendTail.then(async () => { + let t = performance.now() + const frames = secureOut.encode(encodeMessage(createRpcRequest(method as RpcMethod,params,id))) + metrics.encodeMs += performance.now()-t + for(const plain of frames) { + t = performance.now(); const encrypted = noise.encrypt(plain); metrics.encryptMs += performance.now()-t + t = performance.now() + for(const frame of websocket ? [encrypted] : rtcOut.encode(encrypted)) { + while((channel.bufferedAmount ?? 0) > 512*1024) await pause(2) + const buffer = frame.buffer.slice(frame.byteOffset,frame.byteOffset+frame.byteLength) as ArrayBuffer + if(nativeSocket) nativeSocket.sendSocket(channel._socketId,new Uint8Array(buffer)) + else if(!nativeSend?.(channel,buffer)) channel.send(buffer) + metrics.frames++; metrics.maxBuffered = Math.max(metrics.maxBuffered,channel.bufferedAmount ?? 0) + } + metrics.sendMs += performance.now()-t + } + }).catch(error => { const item=waiting.get(id); if(item){clearTimeout(item.timer);waiting.delete(id);item.reject(error)} }) + return response + } + const sendBulk = (plain: Uint8Array) => { + const task = sendTail.then(async () => { + let t=performance.now(); const encrypted=noise.encrypt(plain); metrics.encryptMs+=performance.now()-t + t=performance.now() + for(const frame of (websocket || config.largeRtcFrames) ? [encrypted] : rtcOut.encode(encrypted)) { + while((channel.bufferedAmount ?? 0)>512*1024) await pause(2) + const buffer=frame.buffer.slice(frame.byteOffset,frame.byteOffset+frame.byteLength) as ArrayBuffer + if(nativeSocket) nativeSocket.sendSocket(channel._socketId,new Uint8Array(buffer)) + else if(!nativeSend?.(channel,buffer)) channel.send(buffer) + metrics.frames++;metrics.maxBuffered=Math.max(metrics.maxBuffered,channel.bufferedAmount ?? 0) + } + metrics.sendMs+=performance.now()-t + }) + sendTail=task.catch(()=>undefined) + return task + } + const waitAck = async (target:number) => { + if(!bulkState) throw new Error('No bulk upload') + if(bulkState.error) throw bulkState.error + if(bulkState.acked>=target) return + await new Promise((resolve,reject)=>{ + const timer=setTimeout(()=>{if(bulkState)bulkState.wake=undefined;reject(new Error('Bulk credit timeout'))},60000) + bulkState!.wake=()=>{ + if(!bulkState?.error && (bulkState?.acked??0){throw new Error('RTC open timeout')})]) + channel.send(noise.writeHandshake().buffer as ArrayBuffer) + await Promise.race([handshake,pause(10000).then(()=>{throw new Error('Noise timeout')})]) + await report({phase:'ready',transport:config.transport,nativeSocket:!!nativeSocket,nativeCipher:!!cipher,nativeRtc:!websocket && !!nativeSend,size:config.size}) + for(const {window,binary,stream} of config.experiment ? [{window:4,binary:true,stream:false},{window:4,binary:true,stream:true},{window:4,binary:true,stream:false},{window:4,binary:true,stream:true}] : [{window:4,binary:false,stream:false}, ...[4,8,16,4].map(window=>({window,binary:true,stream:false}))]) { + metrics = {readMs:0,encodeMs:0,encryptMs:0,sendMs:0,frames:0,maxBuffered:0} + const uploadId = crypto.randomUUID(), name = `bench-${uploadId}.bin` + const handle = file.open() + const started = performance.now(), latencies:number[]=[] + const pending: Promise[]=[] + let failed: unknown, received=0, offset=0 + try { + const opened = await rpc(stream ? 'bench.stream.open' : 'workspace.upload.open',{sessionId:'bench',uploadId,name,totalBytes:file.size,...(binary ? {encoding:'binary-v1'} : {})}) + if(stream) { + bulkState={uploadId,sent:0,acked:0} + const credit=1024*1024 + while(offset=credit) await waitAck(offset-credit+1) + const count=Math.min(BULK_DATA_BYTES,file.size-offset,credit-(offset-bulkState.acked)) + let t=performance.now(); const data=handle.readBytes(count);metrics.readMs+=performance.now()-t + if(data.length!==count) throw new Error('Short bulk read') + t=performance.now();const frame=encodeBulkFrame(uploadId,offset,data);metrics.encodeMs+=performance.now()-t + offset+=count;bulkState.sent=offset + await sendBulk(frame) + } + await waitAck(file.size) + received=bulkState.acked;bulkState=undefined + } + while(!stream && (offset{ + if(ack.receivedBytes!==end) throw new Error('Bad offset acknowledgement') + received+=count; latencies.push(performance.now()-sent) + }).catch(error=>{failed=error})) + offset=start+count + } + if(pending.length) await pending.shift() + if(failed) throw failed + } + const result=await rpc('workspace.upload.commit',{sessionId:'bench',uploadId}) + const elapsedMs=performance.now()-started + if(!result.verified || result.sha256!==config.sha256 || received!==file.size) throw new Error('Checksum mismatch') + latencies.sort((a,b)=>a-b) + await report({phase:'window',transport:config.transport,nativeSocket:!!nativeSocket,encoding:stream?(config.largeRtcFrames?'bulk-stream-large-rtc-v1':'bulk-stream-v1'):binary?'binary-v1':'base64',window,elapsedMs,mibPerSecond:file.size/1048576/(elapsedMs/1000),metrics,ackP50:latencies[Math.floor(latencies.length*.5)],ackP95:latencies[Math.floor(latencies.length*.95)],sha256:result.sha256,verified:true}) + } finally { await Promise.all(pending); handle.close() } + await pause(1500) + } + const stats = websocket ? new Map() : await pc.getStats() + await report({phase:'complete',transport:config.transport,stats:[...stats.values()].filter((s:any)=>s.type==='candidate-pair' || s.type==='local-candidate' || s.type==='remote-candidate')}) + } catch(error) { await report({phase:'error',error:String(error)}).catch(()=>log(String(error))); throw error } + finally { channel.close(); pc.close(); noise.destroy(); for(const item of waiting.values()){clearTimeout(item.timer);item.reject(new Error('Benchmark closed'))}; if(file.exists)file.delete(); await awake?.deactivate('isolated-bench') } +} +let started=false +function Bench() { + const [lines,setLines]=useState([]) + useEffect(()=>{ if(started)return; started=true; void run(line=>setLines(old=>[...old,line])).catch(error=>setLines(old=>[...old,String(error)])) },[]) + return Independent transport benchmark{'\n'}{lines.join('\n\n')} +} +registerRootComponent(Bench)