Archive 4 checkpoints (1-4)

paper-releases/pbisc-diffusion/updates/20261013T223459Z-f01-two-host-dispatch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/downstream.py

@@ -0,0 +1,111 @@
+"""Execute the sealed same-gene-context matrix. No unchanged baseline training."""
+from pathlib import Path
+from datetime import datetime,timezone
+import json,os,sys,shutil,subprocess
+P=Path(__file__).resolve().parents[1];M=P.parents[1];S=M/'plans/paper_figures_strictpairs_20261012';F=M/'plans/paired_finetune_intradataset_20260927'
+sys.path.insert(0,str(S/'tools'))
+from runtime import Runtime,sha256,atomic_json
+from dual_runtime import RemoteRuntime,LOCAL,CPU_LOCK,STATUS_LOCK,parallel_lanes,singleton
+PY='/home/sj_server_1/miniforge3/envs/b2sc-cu130/bin/python';CPU='/home/sj_server_1/miniforge3/envs/cxg_corpus/bin/python'
+def status(phase,**kw):
+ with STATUS_LOCK:
+  host=getattr(LOCAL,'host','server_1');record={'phase':phase,'host':host,'at':datetime.now(timezone.utc).isoformat(),**kw}
+  atomic_json(P/f'DOWNSTREAM_{host}.json',record);atomic_json(P/'DOWNSTREAM_STATUS.json',record)
+def safe_storage():
+ contract=json.loads((P/'CONTRACT.json').read_text())
+ for source,digest in {**contract['sources'],**contract['configs']}.items():assert sha256(Path(source))==digest,source
+ for source,digest in json.loads((P/'WORKFLOW_SEAL.json').read_text())['files'].items():assert sha256(Path(source))==digest,source
+ assert os.path.ismount(P/'payload'),'NAS unmounted; stop before falling back to local storage'
+ v=os.statvfs(P/'payload');assert v.f_bavail*v.f_frsize>120*2**30,'NAS free space below reserve'
+def main():
+ matrix=json.loads((P/'MATRIX.json').read_text());verified=json.loads((P/'PRETRAIN_VERIFIED.json').read_text());safe_storage()
+ base=Path(verified['checkpoint']);assert sha256(base)==verified['checkpoint_sha256']
+ cache=P/'base_cache';cache.mkdir(exist_ok=True);local=cache/'checkpoint_epoch_016.pt'
+ if not local.exists():shutil.copyfile(base,local)
+ assert sha256(local)==verified['checkpoint_sha256'];base=local
+ rt=Runtime(P/'payload/runtime');remote=RemoteRuntime(P/'payload/runtime');parent_sha=verified['checkpoint_sha256']
+ ownership=json.loads((P/'TWO_HOST_PLAN.json').read_text())['owners']
+ def execute(tag,args,resource='cpu',inputs=(),outputs=(),mem=32):
+  safe_storage()
+  runner=remote if resource=='gpu' and getattr(LOCAL,'host','server_1')=='server_2' else rt
+  if resource=='cpu':
+   with CPU_LOCK:runner.execute(tag,args,resource=resource,memory_gib=mem,threads=4,inputs=list(inputs),outputs=list(outputs))
+  else:runner.execute(tag,args,resource=resource,memory_gib=mem,threads=4,inputs=list(inputs),outputs=list(outputs))
+ def sample(tag,cp,condition,out,seed):
+  out.parent.mkdir(parents=True,exist_ok=True)
+  execute(tag,[PY,'-u',str(S/'tools/sample_one.py'),'--checkpoint',str(cp),'--checkpoint-sha',sha256(cp),'--condition',str(condition),'--output',str(out),'--seed',str(seed)],'gpu',[cp,condition,S/'tools/sample_one.py'],[out,out.with_suffix('.log')],48)
+ execute('hf-pretrain-backup',['/home/sj_server_1/miniforge3/bin/python',str(P/'tools/publish_core.py'),'--pretrain'],inputs=[P/'PRETRAIN_VERIFIED.json',P/'tools/publish_core.py'],outputs=[P/'HF_PRETRAIN_VERIFIED.json'],mem=4)
+ # Final E16 fixed before downstream outcomes. The SLE builder uses a namespace-local compatibility tag.
+ def sle(row):
+  folder=P/f"payload/sle/seed{row['seed_index']}";g=folder/'generated_f016k_e16.npz';status('sle',seed=row['seed'])
+  sample('sle-'+str(row['seed_index']),base,M/'artifacts/gse135779_scsemi_split_target42_20260913/donor_conditions.npz',g,row['seed'])
+  execute('sle-score-'+str(row['seed_index']),[CPU,str(P/'tools/score_sle.py'),str(row['seed_index'])],inputs=[g,P/'tools/score_sle.py'],outputs=[folder/'DONE.json'])
+ parallel_lanes(matrix['sle'],sle,lambda row:['server_1','server_2'][row['seed_index']%2])
+ # Unadapted/reference-calibrated outputs depend on the new pretrained checkpoint, so cannot reuse x1 cells.
+ def global_sample(item):
+  cohort,arm=item
+  c=S/f'data/external_refcal/{cohort}/conditions_{arm}.npz';g=P/f'payload/global/{cohort}/{arm}.npz'
+  status('global_generation',cohort=cohort,arm=arm);sample('global-'+cohort+'-'+arm,base,c,g,20260928)
+ global_items=[(c,a) for c in matrix['global_cohorts'] for a in ['raw','refcal']]
+ parallel_lanes(global_items,global_sample,lambda item:['server_1','server_2'][global_items.index(item)%2])
+ jobs=matrix['paired_jobs'];byid={j['id']:j for j in jobs}
+ # Canonical strict40 first, then historical full/rank CV, then additional legacy-donor supports.
+ def paired(item):
+  index,j=item
+  tag=j['id'].replace('/','-');out=Path(j['output']);out.mkdir(parents=True,exist_ok=True);status('paired',job=j['id'],index=index,total=len(jobs))
+  if j.get('adapter_alias'):
+   alias=byid[j['adapter_alias']];run=Path(alias['output'])/'run'
+   r=json.loads((run/'RUN.json').read_text());assert set(r['train_rows'])==set(j['train_samples']) and set(r['test_rows_never_loaded_for_training'])==set(j['test_samples'])
+   atomic_json(out/'ADAPTER_ALIAS.json',{'source_run':str(run),'checkpoint_sha256':r['checkpoint_sha256'],'reason':'identical support/test, seed, fixed3000 schedule and exact same f01x4 parent; do not train twice'})
+  else:
+   run=out/'run';ds=F/f"data/{j['cohort']}"
+   if j['family']!='strict':
+    execute(tag+'-isolate',[CPU,str(P/'tools/prepare_legacy.py'),j['id']],inputs=[P/'MATRIX.json',ds/'cells_panel6k.npz',ds/'folds.csv',P/'tools/prepare_legacy.py'],outputs=[out/'input'/j['cohort']/'ISOLATION.json'])
+    ds=out/'input'/j['cohort']
+   cmd=[PY,'-u',str(F/'tools/ft_sdd.py'),'--checkpoint',str(base),'--checkpoint-sha',parent_sha,'--dataset-dir',str(ds),'--condition-npz',j['condition'],'--fold',str(j.get('fold',0)),'--mode',j['mode'],'--lora-rank',str(j['rank']),'--lora-alpha',str(j['alpha']),'--lr',str(j['lr']),'--warmup',str(j['warmup']),'--batch-size',str(j['batch_size']),'--ema-decay',str(j['ema_decay']),'--seed',str(j['seed']),'--max-cuda-gib','24','--min-system-gib','32','--out-dir',str(run)]
+   if j['fixed_steps']:cmd+=['--fixed-steps',str(j['fixed_steps'])]
+   if j['family']=='strict':cmd+=['--support-manifest',j['support_path']]
+   elif j['family']=='legacy5':cmd+=['--train-donors-file',str(ds/'train_donors.txt')]
+   else:cmd+=['--max-steps',str(j['max_steps']),'--eval-every',str(j['eval_every']),'--patience',str(j['patience'])]
+   execute(tag+'-train',cmd,'gpu',[base,P/'MATRIX.json',Path(j['condition']),ds/'cells_panel6k.npz',F/'tools/ft_sdd.py'],[run/'RUN.json',run/'checkpoint_ft.pt'],64)
+  r=json.loads((run/'RUN.json').read_text());assert r['source_checkpoint_sha256']==parent_sha;assert set(r['train_rows'])==set(j['train_samples']);assert set(r['inner_val_rows'])==set(j['validation_samples']);assert set(r['test_rows_never_loaded_for_training'])==set(j['test_samples'])
+  if j.get('generation_alias'):
+   alias=byid[j['generation_alias']]
+   for ext in ['.npz','.log']:
+    dst=out/('generated'+ext)
+    if not dst.exists():dst.symlink_to(Path(alias['output'])/('generated'+ext))
+   atomic_json(out/'GENERATION_ALIAS.json',{'source':alias['output'],'proof':str(P/'GENERATION_REUSE_PROOF.json')})
+  else:sample(tag+'-generate',run/'checkpoint_ft.pt',Path(j['test_condition']),out/'generated.npz',j['sampling_seed'])
+  if j['family']=='strict':sample(tag+'-pairedcal',base,Path(j['cal_condition']),out/'pairedcal.npz',20260928)
+  if j.get('generation_alias'):
+   dest=out/'evaluation'
+   if not dest.exists():dest.symlink_to(Path(byid[j['generation_alias']]['output'])/'evaluation',target_is_directory=True)
+   atomic_json(out/'EVALUATION_ALIAS.json',{'source':str(dest.resolve()),'reason':'Same generated cells, test donors and scoring contract; reuse exact strict Sepsis metrics.'})
+  else:execute(tag+'-score',[CPU,str(P/'tools/score_paired.py'),j['id']],inputs=[out/'generated.npz',P/'MATRIX.json',P/'tools/score_paired.py'],outputs=[out/'evaluation/DONE.json'])
+ parallel_lanes(list(enumerate(jobs)),paired,lambda item:ownership[item[1]['id']])
+ # CV metrics must be scored on the same pooled held-out donors, not averaged fold P/C.
+ execute('pool-cv-and-score',[CPU,str(P/'tools/pool_cv.py')],inputs=[P/'MATRIX.json',P/'tools/pool_cv.py'],outputs=[P/'payload/pooled/DONE.json'])
+ # Published bulk-only condition files are reused; matching legacy-donor adaptation is explicit.
+ bulk_items=[]
+ for cohort in matrix['bulkonly_cohorts']:
+  B=M/'plans/bulkonly_lora5_20261006/data'/cohort
+  conditions=sorted(B.glob('bulkonly_raw_part*.npz')) or [B/'bulkonly_raw.npz']
+  bulk_items.extend((cohort,draw,part,condition) for draw in range(5) for part,condition in enumerate(conditions))
+ def bulk(item):
+  cohort,draw,part,condition=item
+  j=byid[f'legacy5/{cohort}/draw{draw}'];source=byid[j['adapter_alias']] if j.get('adapter_alias') else j;cp=Path(source['output'])/'run/checkpoint_ft.pt'
+  dest=P/f'payload/bulkonly/{cohort}/draw{draw}/part{part}/generated.npz';status('bulkonly',cohort=cohort,draw=draw,part=part)
+  sample(f'bulk-{cohort}-{draw}-{part}',cp,condition,dest,20260927)
+  execute(f'bulk-compact-{cohort}-{draw}-{part}',[CPU,str(P/'tools/bulk_compact.py'),cohort,str(draw),str(part)],inputs=[dest,P/'tools/bulk_compact.py'],outputs=[dest.parent/'COMPACT.json'])
+ parallel_lanes(bulk_items,bulk,lambda item:ownership[f'legacy5/{item[0]}/draw{item[1]}'])
+ execute('assemble-comparisons',[CPU,str(P/'tools/finalize.py')],inputs=[P/'MATRIX.json',P/'tools/finalize.py'],outputs=[P/'RESULTS_STATUS.json'])
+ result=json.loads((P/'RESULTS_STATUS.json').read_text());status(result['phase'],result=str(P/'RESULTS_STATUS.json'))
+ execute('hf-core-backup',['/home/sj_server_1/miniforge3/bin/python',str(P/'tools/publish_core.py')],inputs=[P/'RESULTS_STATUS.json',P/'tools/publish_core.py'],outputs=[P/'HF_CORE_VERIFIED.json'],mem=4)
+ try:
+  execute('archive-completed',["/home/sj_server_1/miniforge3/bin/python",str(P/'tools/archive_completed.py')],inputs=[P/'RESULTS_STATUS.json',P/'tools/archive_completed.py'],outputs=[P/'FINAL_ARCHIVE.json'],mem=4)
+ except Exception as e:
+  status('data_complete_archive_pending',result=str(P/'RESULTS_STATUS.json'),error=str(e))
+if __name__=='__main__':
+ try:
+  with singleton():main()
+ except BaseException as e:status('stopped_needs_inspection',error=str(e));raise

paper-releases/pbisc-diffusion/updates/20261013T223459Z-f01-two-host-dispatch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/dual_runtime.py

@@ -0,0 +1,71 @@
+"""Two fixed GPU lanes; canonical receipts stay on server_1, outputs on shared NAS."""
+from pathlib import Path
+import fcntl,json,os,shlex,subprocess,threading
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from runtime import Runtime,atomic_json,sha256
+P=Path(__file__).resolve().parents[1]
+REMOTE_PY='/home/sj_server_2/miniforge3/envs/b2sc-infer/bin/python'
+LOCAL=threading.local()
+CPU_LOCK=threading.Lock()
+STATUS_LOCK=threading.Lock()
+
+def ssh(argv,**kwargs):
+ return subprocess.run(['ssh','-o','BatchMode=yes','spark-0110',shlex.join(argv)],check=True,**kwargs)
+
+def parallel_lanes(items,fn,owners):
+ """Each item has exactly one immutable owner; failures never reassign or retry."""
+ stop=threading.Event()
+ def lane(host):
+  LOCAL.host=host
+  for item in items:
+   if stop.is_set():return
+   if owners(item)!=host:continue
+   try:fn(item)
+   except BaseException:
+    stop.set();raise
+ with ThreadPoolExecutor(max_workers=2) as pool:
+  futures=[pool.submit(lane,h) for h in ['server_1','server_2']]
+  for future in futures:future.result()
+ LOCAL.host='server_1'
+
+@contextmanager
+def singleton():
+ with (P/'ops/downstream.lock').open('a') as f:
+  fcntl.flock(f,fcntl.LOCK_EX|fcntl.LOCK_NB)
+  yield
+
+class RemoteRuntime(Runtime):
+ def preflight(self,resource,memory_gib):
+  if resource!='gpu':return super().preflight(resource,memory_gib)
+  result=subprocess.run(['ssh','-o','BatchMode=yes','spark-0110',shlex.join([REMOTE_PY,str(P/'tools/remote_gpu.py'),'--check'])],capture_output=True,text=True)
+  if result.returncode==75:raise BlockingIOError(result.stdout+result.stderr)
+  if result.returncode:raise RuntimeError(result.stdout+result.stderr)
+ def wrapped_command(self,name,argv,resource,memory_gib,threads):
+  assert resource=='gpu'
+  request=P/f'payload/dispatch/{name}.json';request.parent.mkdir(parents=True,exist_ok=True)
+  atomic_json(request,{'argv':argv,'threads':threads,'name':name})
+  return ['ssh','-o','BatchMode=yes','spark-0110',shlex.join([REMOTE_PY,str(P/'tools/remote_gpu.py'),str(request)])]
+ def execution_metadata(self,argv=None,command=None):
+  d=super().execution_metadata(argv,command);d.update(host='spark-0110',coordinator='server_1',remote_python=REMOTE_PY);return d
+ def execute(self,name,argv,**kwargs):
+  bindings=json.loads((P/'REMOTE_CODE_VERIFIED.json').read_text())['files']
+  verify='import json,pathlib,hashlib,sys; b=json.load(sys.stdin); assert all(hashlib.file_digest(pathlib.Path(p).open("rb"),"sha256").hexdigest()==h for p,h in b.items()), "remote code changed"'
+  ssh(['python3','-c',verify],input=json.dumps(bindings),text=True)
+  # Inputs in payload are already visible through the shared NAS. Stage only immutable external inputs.
+  files=set(Path(x) for x in kwargs.get('inputs',[]) if Path(x).is_file())
+  for flag in ['--condition','--condition-npz','--support-manifest','--train-donors-file']:
+   if flag in argv:files.add(Path(argv[argv.index(flag)+1]))
+  if '--dataset-dir' in argv:
+   ds=Path(argv[argv.index('--dataset-dir')+1]);files.update([ds/'cells_panel6k.npz',ds/'folds.csv'])
+  for f in sorted(files):
+   if f.is_relative_to(P/'payload'):continue
+   digest=sha256(f)
+   code='import pathlib,hashlib,sys; p=pathlib.Path(sys.argv[1]); print(hashlib.file_digest(p.open("rb"),"sha256").hexdigest() if p.is_file() else "MISSING")'
+   got=ssh(['python3','-c',code,str(f)],capture_output=True,text=True).stdout.strip()
+   if got=='MISSING':
+    ssh(['mkdir','-p',str(f.parent)])
+    subprocess.run(['rsync','-a',str(f),'spark-0110:'+str(f)],check=True)
+    got=ssh(['python3','-c',code,str(f)],capture_output=True,text=True).stdout.strip()
+   if got!=digest:raise RuntimeError('Remote input differs; preserve and inspect: '+str(f))
+  return super().execute(name,argv,**kwargs)

paper-releases/pbisc-diffusion/updates/20261013T223459Z-f01-two-host-dispatch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/publish_core.py

@@ -0,0 +1,51 @@
+"""Verified immutable HF backup independent of the local archive capacity gate.
+Does not advance paper LATEST or claim the independent archive is complete.
+"""
+from pathlib import Path
+import fcntl,hashlib,json,os,sys
+os.environ['HF_HUB_DISABLE_XET']='1'
+os.environ['HF_HUB_ENABLE_HF_TRANSFER']='0'
+from huggingface_hub import HfApi,hf_hub_download
+P=Path(__file__).resolve().parents[1];RELEASE=P.parents[3]/'paper-release-20260928'
+PREFIX='campaigns/f01-6k-trunk4x-20261013'
+def digest(p):
+ with p.open('rb') as f:return hashlib.file_digest(f,'sha256').hexdigest()
+def collect(pretrain=False):
+ v=json.loads((P/'PRETRAIN_VERIFIED.json').read_text());files=[(Path(v['checkpoint']),'model','pretrain/checkpoint_epoch_016.pt')]
+ files += [(P/n,'dataset',n) for n in ['PRETRAIN_VERIFIED.json','MATRIX.json','CONTRACT.json','TWO_HOST_PLAN.json','WORKFLOW_SEAL.json']]
+ if not pretrain:
+  assert json.loads((P/'RESULTS_STATUS.json').read_text())['phase']=='data_complete_with_review_gates'
+  for j in json.loads((P/'MATRIX.json').read_text())['paired_jobs']:
+   if j.get('adapter_alias'):continue
+   out=Path(j['output']);files += [(out/'run/checkpoint_ft.pt','model',j['id']+'/checkpoint_ft.pt'),(out/'run/RUN.json','dataset',j['id']+'/RUN.json')]
+   for f in (out/'evaluation').rglob('*'):
+    if f.is_file() and f.suffix in ['.json','.csv'] and f.stat().st_size<4*2**20 and '/labels/' not in str(f):files.append((f,'dataset',str(f.relative_to(P))))
+  for root in [P/'comparison',P/'payload/pooled',P/'payload/sle',P/'payload/bulkonly']:
+   for f in root.rglob('*'):
+    if f.is_file() and f.suffix in ['.json','.csv','.png','.pdf','.svg'] and f.stat().st_size<16*2**20:files.append((f,'dataset',str(f.relative_to(P))))
+  files += [(P/n,'dataset',n) for n in ['RESULTS_STATUS.json','PENDING_EVIDENCE.json']]
+ return files
+
+def main():
+ pretrain='--pretrain' in sys.argv;records=[];api=HfApi(token=True)
+ with (RELEASE/'maintenance/.writer.lock').open('a') as lock:
+  fcntl.flock(lock,fcntl.LOCK_EX)
+  for p,kind,relative in collect(pretrain):
+   repo='junidude14/PBISC' if kind=='model' else 'junidude14/PBISC-data'
+   info=api.repo_info(repo_id=repo,repo_type=kind)
+   assert info.private if kind=='dataset' else (not info.private and info.gated in [True,'auto','manual'])
+   sha=digest(p);path=f'{PREFIX}/{relative}';head=info.sha
+   existing=api.get_paths_info(repo_id=repo,paths=[path],repo_type=kind,revision=head)
+   if not existing:
+    commit=api.upload_file(path_or_fileobj=str(p),path_in_repo=path,repo_id=repo,repo_type=kind,parent_commit=head,commit_message='Back up completed PBISC same-panel trunk4x evidence')
+    head=commit.oid;existing=api.get_paths_info(repo_id=repo,paths=[path],repo_type=kind,revision=head)
+   assert len(existing)==1 and existing[0].size==p.stat().st_size
+   lfs=existing[0].lfs
+   if lfs:assert lfs.sha256==sha,'Immutable HF content conflict'
+   else:
+    saved=Path(hf_hub_download(repo_id=repo,repo_type=kind,filename=path,revision=head,token=True));assert digest(saved)==sha,'HF readback mismatch'
+   records.append({'source':str(p),'repo':repo,'repo_type':kind,'path':path,'revision':head,'sha256':sha,'bytes':p.stat().st_size})
+   print(json.dumps(records[-1]),flush=True)
+  target=P/('HF_PRETRAIN_VERIFIED.json' if pretrain else 'HF_CORE_VERIFIED.json')
+  target.write_text(json.dumps({'state':'verified','assets':records,'independent_archive':'separate maintenance receipt; this backup does not advance LATEST'},indent=2)+'\n')
+if __name__=='__main__':main()

paper-releases/pbisc-diffusion/updates/20261013T223459Z-f01-two-host-dispatch/diffusion/dataset/server_1/model8/plans/f01_trunk4x_complete_20261013/tools/remote_gpu.py

@@ -0,0 +1,25 @@
+"""Remote entrypoint: CPU-only safety checks; CUDA command always inside remote ml-run."""
+from pathlib import Path
+import json,os,subprocess,sys
+os.environ['XDG_RUNTIME_DIR']='/run/user/1000'
+os.environ['DBUS_SESSION_BUS_ADDRESS']='unix:path=/run/user/1000/bus'
+P=Path(__file__).resolve().parents[1]
+NAS=Path('/home/sj_server_2/nas_fast')
+def check():
+ if subprocess.run(['systemctl','--user','is-active','--quiet','ml-memory-guard.service']).returncode:
+  subprocess.run(['systemctl','--user','restart','ml-memory-guard.service'],check=True)
+ subprocess.run(['systemctl','--user','is-active','ml-memory-guard.service'],check=True)
+ subprocess.run(['/home/sj_server_2/.local/libexec/ml-memory-guard','--check'],check=True)
+ processes=subprocess.check_output(['nvidia-smi','--query-compute-apps=pid,process_name,used_memory','--format=csv,noheader'],text=True)
+ if processes.strip():print(processes);raise SystemExit(75)
+ if subprocess.run(['flock','-n','/run/user/1000/ml-gpu0.lock','true']).returncode:raise SystemExit(75)
+ available=next(int(x.split()[1])/1048576 for x in Path('/proc/meminfo').read_text().splitlines() if x.startswith('MemAvailable:'))
+ if available<48:raise SystemExit(75)
+ assert os.path.ismount(NAS),'NAS unavailable'
+ assert (P/'payload').resolve()==NAS/'PBISC/pbisc-diffusion/f01_trunk4x_complete_20261013'
+ v=os.statvfs(P/'payload');assert v.f_bavail*v.f_frsize>120*2**30
+check()
+if sys.argv[1]=='--check':raise SystemExit(0)
+r=json.loads(Path(sys.argv[1]).read_text());argv=r['argv'];argv[0]=sys.executable
+# Kernel and code consistency is validated before enabling the dispatch plan.
+subprocess.run(['/home/sj_server_2/.local/bin/ml-run','/usr/bin/env','CUDA_VISIBLE_DEVICES=0','PYTHONDONTWRITEBYTECODE=1','PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True',*[f'{k}={r["threads"]}' for k in ['OMP_NUM_THREADS','OPENBLAS_NUM_THREADS','MKL_NUM_THREADS','NUMBA_NUM_THREADS']],*argv],check=True)