"""Allocated-CPU group renderer: true two-time RIRs and four-channel FOA.""" from __future__ import annotations import argparse,gzip,json,os,shutil,tempfile,time,math,subprocess,sys from pathlib import Path import numpy as np import soundfile as sf from dynamic_demo.render import Renderer,make_dry,two_time_convolution from .common import * from .geometry import audit from .runtime import ensure_compute def sampling_nodes(entity,step): """Common scene-zero clock; every moving source/receiver uses 0, .2, .4, ...""" if not np.any(entity['displacement_m']):return [0.] end=entity.get('motion_start_s',0.)+entity['motion_duration_s'] last=math.ceil((end-1e-9)/step) return [round(i*step,9) for i in range(last+1)] def render_group(root,group,temp_root=None,cache_base=None,keep_cache=False): marker=root/'reports/groups'/(group['group_id']+'.json') if marker.exists(): previous=read(marker) if previous.get('passed') and all(sha(root/r['path'])==r['sha256'] for r in previous['files']):return previous raise ValueError('Completed group has changed; restore it before resuming') started=time.monotonic();cache_base=Path(cache_base) if cache_base else Path(tempfile.mkdtemp(prefix='dish-dynamic-'+group['group_id']+'-',dir=temp_root)) cache_base.mkdir(parents=True,exist_ok=True) engine_root=cache_base/'engine';(engine_root/'assets').mkdir(parents=True,exist_ok=True) room_link=engine_root/'assets/room';room_target=root/'public/assets/rooms'/group['room_id']/'assets/room' if room_link.exists(): if not room_link.is_symlink() or room_link.resolve()!=room_target.resolve():raise ValueError('Recovery cache room differs') else:room_link.symlink_to(room_target,target_is_directory=True) engine=Renderer(engine_root,group,cache_base/'rirs',position_fn=position) mixtures={};stems={};source_gains=[];geometries=[] def tracked_kernel(source,receiver,te,tr): write(cache_base/'progress.json',dict(time=time.time(),source_id=source['entity_id'],receiver_id=receiver['entity_id'],source_time_s=te,receiver_time_s=tr)) return engine.kernel(source,receiver,te,tr) try: for scene in group['scenes']: checked=audit(scene,group['room'],full_visibility=True) if checked is None:raise ValueError('Frozen dynamic geometry failed independent rerun') geometries.append(dict(scene_id=scene['scene_id'],**checked)) dry,gains=make_dry(root,scene);source_gains.append(dict(scene_id=scene['scene_id'],gains=gains)) for receiver in scene['robots']: rid=receiver['entity_id'];key=(scene['scene_id'],rid);wave=np.zeros((scene['duration_samples'],4),np.float64) for source in scene['humans']+scene['playback_sources']: sid=source['entity_id'] if sid==rid:continue component=two_time_convolution(dry[sid],sampling_nodes(source,group['source_node_step_s']),sampling_nodes(receiver,group['receiver_node_step_s']), lambda te,tr:tracked_kernel(source,receiver,te,tr),max_tail_s=group.get('convolution_horizon_s',group['renderer']['irTime']+.001)) wave+=component;stems[(scene['scene_id'],rid,sid)]=component mixtures[key]=wave.astype(np.float32) print('RENDERED SCENE',scene['scene_id'],scene['branch'],len(engine.records),'RIRs',flush=True) peak=max(float(np.max(np.abs(w))) for w in mixtures.values());gain=.9/peak if not np.isfinite(peak) or peak<=0:raise ValueError('Invalid mixture') files=[];records=[];audio_checks=[] for scene in group['scenes']: for receiver in scene['robots']: rid=receiver['entity_id'];key=(scene['scene_id'],rid);wave=(mixtures[key]*gain).astype(np.float32) path=root/'public/audio/test'/scene['scene_id']/(rid+'_foa.wav');path.parent.mkdir(parents=True,exist_ok=True) tmp=path.with_name(rid+'_foa.tmp.wav');sf.write(tmp,wave,SR,subtype='FLOAT');tmp.replace(path) reconstructed=sum(stems[(scene['scene_id'],rid,s['entity_id'])].astype(np.float64) for s in scene['humans']+scene['playback_sources'] if s['entity_id']!=rid)*gain deviation=float(np.max(np.abs(wave-reconstructed))) if deviation>3e-7:raise ValueError('Source-stem reconstruction mismatch') reread,rate=sf.read(path,dtype='float32');np.testing.assert_array_equal(reread,wave) if rate!=SR:raise ValueError('FOA sample rate mismatch') record=dict(recording_id=uid(scene['scene_id'],rid,'recording'),scene_id=scene['scene_id'],scene_group_id=group['group_id'], receiver_robot_id=rid,path=str(path.relative_to(root)),sha256=sha(path),num_samples=len(wave),sample_rate_hz=SR, num_channels=4,channels=['W','Y','Z','X'],ordering='ACN',normalization='SN3D',subtype='FLOAT',global_start_sample=0, common_final_gain=gain) records.append(record) files.append(dict(path=str(path.relative_to(root)),sha256=sha(path),bytes=path.stat().st_size)) audio_checks.append(dict(scene_id=scene['scene_id'],receiver_id=rid,source_stem_reconstruction_max_error=deviation, own_playback_excluded=True,contributing_source_ids=[s['entity_id'] for s in scene['humans']+scene['playback_sources'] if s['entity_id']!=rid], waveform_peak=float(np.max(np.abs(wave))),all_finite=bool(np.isfinite(wave).all()), tail_energy_fraction=float(np.sum(wave[-8000:].astype(float)**2)/np.sum(wave.astype(float)**2)))) rir_log=root/'private/rir_audits'/(group['group_id']+'.jsonl.gz');rir_log.parent.mkdir(parents=True,exist_ok=True) with gzip.open(rir_log,'wt') as f: for record in sorted(engine.records.values(),key=lambda x:x['rir_id']):f.write(json.dumps(record,separators=(',',':'))+'\n') files.append(dict(path=str(rir_log.relative_to(root)),sha256=sha(rir_log),bytes=rir_log.stat().st_size)) result=dict(passed=True,group_id=group['group_id'],index=group['index'],scene_ids=[s['scene_id'] for s in group['scenes']], room_id=group['room_id'],common_final_gain=gain,recordings=records,files=files, source_gains=source_gains,geometry_checks=geometries,audio_checks=audio_checks,rir_audit_path=str(rir_log.relative_to(root)), rir_count=len(engine.records),los_rir_count=sum(r['los'] for r in engine.records.values()), maximum_los_direct_angle_error_deg=max(r['direct_angle_error_deg'] for r in engine.records.values() if r['los']), maximum_los_delay_error_s=max(abs(r['direct_delay_s']-r['geometric_delay_s']) for r in engine.records.values() if r['los']), maximum_native_tail_fraction=max(r['native_final_50ms_energy_fraction'] for r in engine.records.values()), binaural_previews=False,wall_seconds=time.monotonic()-started,completed_at=now(),human_listening_audit_completed=False,model_inference_performed=False) result['rir_sampling_policy']='source and receiver knots both on scene-zero 0.2s grid, through first knot at/after motion end; stationary entities use one knot' result['convolution_horizon_s']=group.get('convolution_horizon_s',group['renderer']['irTime']+.001) write(marker,result);print('GROUP COMPLETE',group['index'],group['group_id'],result['rir_count'],round(result['wall_seconds'],1),'s',flush=True) return result except Exception as error: write(root/'reports/failures'/(group['group_id']+'.json'),dict(group_id=group['group_id'],index=group['index'], room_id=group['room_id'],error_type=type(error).__name__,error=str(error),rir_count=len(engine.records),failed_at=now())) raise finally: engine.close() # Only this process's disposable, newly-created kernels; no source/release deletion. if not keep_cache:shutil.rmtree(cache_base) def supervise_group(root,group,temp_root=None,recovery=None,timeout=180.,attempts=3): """Fresh native process per group; restart a stalled RLR call with verified kernels.""" marker=root/'reports/groups'/(group['group_id']+'.json') if marker.exists():return render_group(root,group) cache=Path(tempfile.mkdtemp(prefix='dish-supervised-'+group['group_id']+'-',dir=temp_root)) if recovery and (Path(recovery)/group['group_id']).exists(): shutil.copytree(Path(recovery)/group['group_id'],cache/'rirs') prefix=json.loads(os.environ.get('DISH_WORKER_PYTHON_COMMAND','null')) or [sys.executable] command=prefix+['-m','dynamic_dataset.render','--root',str(root),'--single-index',str(group['index']), '--expected-group-id',group['group_id'],'--cache-dir',str(cache)] completed=False;history=[] try: for attempt in range(1,attempts+1): start=time.time();process=subprocess.Popen(command) try: while process.poll() is None: progress=cache/'progress.json';last=max(start,progress.stat().st_mtime if progress.exists() else start) if time.time()-last>timeout: process.kill();process.wait() history.append(dict(attempt=attempt,inactive_s=time.time()-last,pending_kernel=read(progress) if progress.exists() else None)) print('RESTART STALLED NATIVE WORKER',group['index'],attempt,flush=True);break time.sleep(1.) finally: if process.poll() is None:process.kill();process.wait() if marker.exists(): result=render_group(root,group);completed=True write(root/'reports/process_recovery'/(group['group_id']+'.json'),dict(passed=True,index=group['index'],attempts=attempt,restarts=history, reused_pinned_native_cache=bool(recovery),same_geometry_renderer_and_speech=True,completed_at=now())) return result if not history or history[-1]['attempt']!=attempt:raise RuntimeError('Native worker failed; inspect reports/failures for index '+str(group['index'])) raise TimeoutError('Native kernel stalled after '+str(attempts)+' fresh-process attempts; index '+str(group['index'])) finally: if completed:shutil.rmtree(cache) else:print('PRESERVED RECOVERY CACHE',str(cache),flush=True) def render(root,shard,shards,limit=0,processes=1,recovery=None,indices=None,timeout=180.): ensure_compute();root=root.resolve();groups=list(rows(root/'private/recipes.jsonl'));selected=[g for g in groups if g['index']%shards==shard] if indices is not None:selected=[g for g in selected if g['index'] in indices] if limit:selected=selected[:limit] failures=[] from concurrent.futures import ThreadPoolExecutor,as_completed with ThreadPoolExecutor(max_workers=processes) as executor: futures={executor.submit(supervise_group,root,g,recovery=recovery,timeout=timeout):g for g in selected} for future in as_completed(futures): try:future.result() except Exception as e:failures.append(dict(index=futures[future]['index'],error=str(e))) write(root/'reports/workers'/f'{shard:02d}.json',dict(passed=not failures,shard=shard,shards=shards,groups=len(selected),failures=failures,completed_at=now())) if failures:raise RuntimeError(str(len(failures))+' render groups failed; inspect reports/failures and resume this shard') if __name__=='__main__': p=argparse.ArgumentParser();p.add_argument('--root',type=Path,required=True);p.add_argument('--shard',type=int,default=0);p.add_argument('--shards',type=int,default=1);p.add_argument('--limit',type=int,default=0) p.add_argument('--processes',type=int,default=1) p.add_argument('--rir-recovery-cache',type=Path);p.add_argument('--indices',type=int,nargs='+');p.add_argument('--kernel-timeout-s',type=float,default=180.) p.add_argument('--single-index',type=int);p.add_argument('--expected-group-id');p.add_argument('--cache-dir',type=Path) a=p.parse_args() if a.single_index is not None: ensure_compute();group=next(g for g in rows(a.root/'private/recipes.jsonl') if g['index']==a.single_index) if group['group_id']!=a.expected_group_id:raise ValueError('Frozen recipe changed during worker launch') render_group(a.root.resolve(),group,cache_base=a.cache_dir,keep_cache=True) else:render(a.root,a.shard,a.shards,a.limit,a.processes,a.rir_recovery_cache,a.indices,a.kernel_timeout_s)