ds-harness-remote-fast/apps/android/bench/index.tsx

245 lines
16 KiB
TypeScript

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<any>('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<T=unknown>(method:string,params:unknown,signal?:AbortSignal):Promise<T>=>{
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<any>('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<any>('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 Map<string,{resolve:(value:any)=>void;reject:(error:Error)=>void;timer:ReturnType<typeof setTimeout>}>()
let bulkState: {uploadId:string;sent:number;acked:number;error?:Error;wake?:()=>void} | undefined
let ready!: () => void
const handshake = new Promise<void>(resolve => { ready = resolve })
const opened = new Promise<void>((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<any> => {
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<void>((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)<target) return
clearTimeout(timer)
if(bulkState?.error) reject(bulkState.error); else resolve()
if(bulkState) bulkState.wake=undefined
}
})
}
try {
log(`Downloading fixture over ADB control channel; payload benchmark uses LAN ${websocket?'TCP/WebSocket':'UDP'}.`)
if(file.exists) file.delete()
await File.downloadFileAsync(`${url}/fixture`,file)
if(!websocket) {
await pc.setLocalDescription(await pc.createOffer())
for(let i=0;i<100 && pc.iceGatheringState!=='complete';i++) await pause(50)
const {answer,candidates} = await post('offer',{publicKey:identity.publicKey,offer:pc.localDescription})
await pc.setRemoteDescription(answer)
for(const candidate of candidates) await pc.addIceCandidate(candidate)
}
await Promise.race([opened,pause(20000).then(()=>{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<void>[]=[]
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<file.size) {
if(bulkState.error) throw bulkState.error
if(offset-bulkState.acked>=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<file.size || pending.length)) {
while(offset<file.size && pending.length<window && !failed) {
const start=offset, count=Math.min(opened.chunkBytes,file.size-offset)
const t=performance.now(), data=binary ? handle.readBytes(count) : await readAsStringAsync(file.uri,{encoding:EncodingType.Base64,position:offset,length:count}); metrics.readMs+=performance.now()-t
if(typeof data!=='string' && data.length!==count) throw new Error('Short fixture read')
const sent=performance.now(),end=offset+count
pending.push(rpc(binary ? 'workspace.upload.chunk.binary' : 'workspace.upload.chunk',{sessionId:'bench',uploadId,offset,data}).then(ack=>{
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<string[]>([])
useEffect(()=>{ if(started)return; started=true; void run(line=>setLines(old=>[...old,line])).catch(error=>setLines(old=>[...old,String(error)])) },[])
return <ScrollView style={{padding:24,paddingTop:60,backgroundColor:'#fff'}}><Text selectable style={{color:'#111'}}>Independent transport benchmark{'\n'}{lines.join('\n\n')}</Text></ScrollView>
}
registerRootComponent(Bench)