95 lines
6.7 KiB
Python
95 lines
6.7 KiB
Python
"""Count-only E6 full-node cost assessment; never calls the kernel integrator."""
|
|
import argparse
|
|
import hashlib
|
|
import json
|
|
from pathlib import Path
|
|
import resource
|
|
import time
|
|
import numpy as np
|
|
from scipy.spatial import cKDTree
|
|
if __package__:
|
|
from .run_e6_real_kernel import samples
|
|
else:
|
|
from run_e6_real_kernel import samples
|
|
|
|
|
|
def sha(p):return hashlib.sha256(Path(p).read_bytes()).hexdigest()
|
|
|
|
|
|
def rss_kib():
|
|
for line in Path('/proc/self/status').read_text().splitlines():
|
|
if line.startswith('VmRSS:'):return int(line.split()[1])
|
|
raise RuntimeError('No current RSS')
|
|
|
|
|
|
def stats(a):
|
|
return dict(nodes=len(a),neighbor_sum=int(a.sum()),quantiles=dict(zip(['min','p50','p90','p99','max'],map(float,np.quantile(a,[0,.5,.9,.99,1])))))
|
|
|
|
|
|
def main():
|
|
p=argparse.ArgumentParser();p.add_argument('output',type=Path);p.add_argument('case_index',type=int);a=p.parse_args();out=a.output
|
|
contract=json.loads((out/'execution_contract.json').read_text());spec=contract['cases'][a.case_index]
|
|
for path,h in contract['input_sha256'].items():
|
|
if sha(path)!=h:raise ValueError('Input changed '+path)
|
|
case=spec['case'];print('START count-only',case,flush=True)
|
|
with (out/(case+'.started.json')).open('x') as f:json.dump(dict(contract_sha256=sha(out/'execution_contract.json')),f)
|
|
started=time.monotonic()
|
|
with np.load(spec['sample']) as data:
|
|
x=data['points_raw'];tet=data['tetra'];mass=data['node_volume_raw']
|
|
d=np.load(spec['distance']);loaded=time.monotonic();loaded_rss=rss_kib()
|
|
prior=json.loads(Path(contract['prior_run']).read_text());row=next(r for r in prior['cases'] if r['case']==case and r['rule']=='tetra_four_point')
|
|
R=row['plan']['radius'];sx,sm,_=samples(x,tet,mass,'tetra_four_point');source_done=time.monotonic();source_rss=rss_kib()
|
|
tree=cKDTree(sx);tree_done=time.monotonic();tree_rss=rss_kib()
|
|
counts=np.empty(len(x),dtype=np.int64);chunk_seconds=[]
|
|
for begin in range(0,len(x),contract['query_count_chunk']):
|
|
t=time.monotonic();stop=min(begin+contract['query_count_chunk'],len(x))
|
|
counts[begin:stop]=tree.query_ball_point(x[begin:stop],R,return_length=True,workers=1)
|
|
chunk_seconds.append(dict(first=begin,last_exclusive=stop,seconds=time.monotonic()-t))
|
|
counted=time.monotonic();count_rss=rss_kib()
|
|
with np.load(Path(contract['prior_directory'])/(row['name']+'_anchors.npz')) as old:
|
|
unique=old['unique_node_ids'];inverse=old['draw_to_unique']
|
|
np.testing.assert_array_equal(counts[unique],old['neighbor_counts'])
|
|
masks={'all_nodes':np.ones(len(x),bool),'positive_distance_nodes':d>0,'boundary_nodes':d==0}
|
|
assert all(np.isfinite(d)) and np.all(d>=0)
|
|
assert int((d>0).sum()+(d==0).sum())==len(x)
|
|
source_pairs=int(counts[unique].sum());old_seconds=row['case_elapsed_seconds_so_far']
|
|
groups={}
|
|
for name,mask in masks.items():
|
|
s=stats(counts[mask]);n=s['nodes'];visits=s['neighbor_sum'];node_ratio=n/len(unique);pair_ratio=visits/source_pairs
|
|
# Two illustrative extrapolations. Neither is a measured runtime or CI.
|
|
one_pose_base=old_seconds/2
|
|
s.update(lumped_mass_fraction=float(mass[mask].sum()/mass.sum()),
|
|
p99_times_nodes=float(np.quantile(counts[mask],.99)*n),
|
|
one_pose_pair_budget_pass=visits<=contract['kernel_evaluation_budget'],
|
|
main_plus_pose_pair_budget_pass=2*visits<=contract['kernel_evaluation_budget'],
|
|
node_count_ratio_to_old_unique=node_ratio,neighbor_work_ratio_to_old_unique=pair_ratio,
|
|
one_pose_query_scaled_seconds=one_pose_base*node_ratio,
|
|
one_pose_neighbor_scaled_seconds=one_pose_base*pair_ratio,
|
|
hypothetical_flat_int64_neighbor_ids_bytes=8*visits)
|
|
groups[name]=s
|
|
assert groups['positive_distance_nodes']['neighbor_sum']+groups['boundary_nodes']['neighbor_sum']==groups['all_nodes']['neighbor_sum']
|
|
# Source/tree remain resident; per-query scratch follows the existing serial integrate loop.
|
|
S=len(sx);N=len(x);max_neighbors=int(counts.max());observed_count_peak=resource.getrusage(resource.RUSAGE_SELF).ru_maxrss*1024
|
|
memory=dict(observed_count_peak_bytes=observed_count_peak,source_coordinates_bytes=sx.nbytes,source_mass_bytes=sm.nbytes,
|
|
hypothetical_source_tensor_bytes=72*S,raw_node_tensor_bytes=72*N,all_node_output_bytes=120*N,
|
|
output_block_4096_bytes=120*min(4096,N),scratch_allowance_per_query_bytes=256*max_neighbors,
|
|
extra_allocator_reserve_bytes=128*1024**2,
|
|
estimated_full_kernel_peak_bytes=observed_count_peak+72*S+72*N+120*N+256*max_neighbors+128*1024**2,
|
|
estimated_block_output_kernel_peak_bytes=observed_count_peak+72*S+72*N+120*min(4096,N)+256*max_neighbors+128*1024**2,
|
|
model='Observed count-process peak + full float64 source tensors + raw node tensors + E6 outputs + 256 bytes/max-neighbor scratch + 128 MiB reserve; planning allowance, NOT measured kernel RSS or a guaranteed bound.',
|
|
excludes='Unfrozen O2-rep node/edge features, training graph, gradients, multiple poses resident concurrently, global neighbor adjacency.')
|
|
np.savez_compressed(out/(case+'_counts.npz'),neighbor_counts=counts,positive_distance_mask=d>0,node_lumped_mass=mass)
|
|
result=dict(case=case,nodes=N,tets=len(tet),four_point_sources=S,radius=R,rule='E6 unchanged four-point source positions and radius; count-only',
|
|
groups=groups,old_unique_queries=len(unique),old_unique_neighbor_sum=source_pairs,old_case_seconds=old_seconds,
|
|
old_2000_draw_neighbor_sum=int(counts[unique][inverse].sum()),old_unique_neighbor_quantiles=stats(counts[unique])['quantiles'],
|
|
timing_model='Use actual full-node neighbor sums and node counts as two distinct scaling scenarios from old original+rotated case wall time / 2. Not a confidence interval or runtime bound; old timing includes source/raw preparation, tree, output and diagnostics; mixed query/neighbor/fixed costs and tail density may differ.',
|
|
timings=dict(load_seconds=loaded-started,source_position_seconds=source_done-loaded,tree_seconds=tree_done-source_done,all_node_count_seconds=counted-tree_done,wall_seconds=time.monotonic()-started),
|
|
rss_kib=dict(loaded=loaded_rss,source=source_rss,tree=tree_rss,after_count=count_rss),memory=memory,
|
|
node_cost_histogram_edges=[0,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,'infinity'],
|
|
node_cost_histogram=np.histogram(counts,bins=[0,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,np.inf])[0].tolist(),
|
|
chunk_timings=chunk_seconds,preflight_anchor_counts_exact_match=True,new_kernel_evaluations=0,new_distance_queries=0,new_soft_representation=False)
|
|
(out/(case+'.json')).write_text(json.dumps(result,indent=2)+'\n');print('DONE',case,json.dumps(groups),flush=True)
|
|
|
|
|
|
if __name__=='__main__':main()
|