| |
| |
| import gzip |
| import json |
| from pathlib import Path |
| import tempfile |
| import unittest |
| import numpy as np |
|
|
| import prepare as p |
| from alignment import pair, sglang_groups, vllm_groups |
|
|
|
|
| def record(rank, timestamp, counter=0): |
| return {"version": 1, "worker_id": "test", "dp_rank": rank, "counter_id": counter, |
| "wall_time": .01, "received_at_ns": timestamp, "source_line": counter + rank + 1, |
| "scheduled_requests": {"num_prefill_requests": 0, "num_decode_requests": 1}, |
| "queued_requests": {"num_prefill_requests": 0, "num_decode_requests": 0}} |
|
|
|
|
| class PrepareTests(unittest.TestCase): |
| def test_timezone(self): |
| self.assertEqual(p.epoch_ns("2026-09-09T17:06:12.297086", "America/Los_Angeles"), |
| p.epoch_ns("2026-09-10T00:06:12.297086", "UTC")) |
|
|
| def test_aware_time_not_relocalized(self): |
| self.assertEqual(p.epoch_ns("2026-09-10T00:06:12.297086+00:00", "America/Los_Angeles"), |
| p.epoch_ns("2026-09-10T00:06:12.297086", "UTC")) |
|
|
| def test_drain_not_in_window(self): |
| export = {"start_time": "2026-09-10T00:00:00", "end_time": "2026-09-10T01:00:40", |
| "input_config": {"phases": [{"kind": "profiling", "duration": 3600}]}} |
| start, end = p.measured_window(export, "UTC") |
| self.assertEqual(end-start, 3600*10**9) |
| self.assertEqual(end, p.epoch_ns("2026-09-10T01:00:00", "UTC")) |
|
|
| def test_exact_integer_nanoseconds(self): |
| self.assertEqual(p.epoch_ns("2026-09-11T00:06:24.700077", "UTC"),1789085184700077000) |
|
|
| def test_sequence_join_crosses_receive_delay_and_skips_missing_step(self): |
| rng=np.random.default_rng(42) |
| walls=rng.uniform(.02,.10,100) |
| times=np.cumsum(walls) |
| a=np.column_stack((times,walls)) |
| kept=np.array([i for i in range(100) if i not in (15,41)]) |
| b=np.column_stack((times[kept]+.040,walls[kept]+.000002)) |
| result,_,_=pair(a,b) |
| expected=np.full(100,-1) |
| expected[kept]=np.arange(len(kept)) |
| np.testing.assert_array_equal(result,expected) |
|
|
| def test_sglang_validated_ordinal_not_receive_window(self): |
| rng=np.random.default_rng(42) |
| walls=rng.uniform(.02,.10,100) |
| rows=[];ordinals={} |
| for rank in (0,1): |
| for i in range(3,9): |
| row=record(rank,1789085184700077000+i*10**8+rank*500_000_000,i) |
| row['source_line']=rank*100+i |
| row['wall_time']=float(walls[i]+rank*.000002) |
| rows.append(row);ordinals[row['source_line']]=i |
| groups,audit=sglang_groups(rows,[0,1],{0:walls,1:walls+.000002},ordinals) |
| self.assertEqual(len(groups),6) |
| for members,support in groups: |
| self.assertEqual([r['dp_rank'] for r in members],[0,1]) |
| self.assertEqual(members[0]['counter_id'],members[1]['counter_id']) |
| self.assertEqual(members[1]['received_at_ns']-members[0]['received_at_ns'],500_000_000) |
|
|
| def test_sglang_unequal_counts_fail_closed(self): |
| with self.assertRaises(ValueError): |
| sglang_groups([], [0,1], {0:[.01,.02],1:[.01]}, {}) |
|
|
| def test_prefill_duration_difference_keeps_sequence_match(self): |
| rng=np.random.default_rng(42) |
| walls=rng.uniform(.02,.10,100) |
| walls[50]=.25 |
| times=np.cumsum(walls) |
| other=walls.copy();other[50]=.28 |
| result,_,_=pair(np.column_stack((times,walls)),np.column_stack((times+.001,other))) |
| self.assertEqual(result[50],50) |
|
|
| def test_multi_reference_membership_is_unique_and_lossless(self): |
| rng=np.random.default_rng(42) |
| walls=rng.uniform(.02,.10,100) |
| times=np.cumsum(walls) |
| rows=[] |
| for rank in (0,1,2): |
| for i in range(100): |
| if rank==2 and i==30: |
| continue |
| row=record(rank,int((times[i]+rank*.020)*1e9),i) |
| row['source_line']=rank*100+i+1 |
| row['wall_time']=float(walls[i]+rank*.000002) |
| rows.append(row) |
| groups,report=vllm_groups(rows,[0,1,2]) |
| actual=[r['source_line'] for group,_ in groups for r in group] |
| self.assertEqual(sorted(actual),sorted(r['source_line'] for r in rows)) |
| self.assertEqual(len(actual),len(set(actual))) |
| self.assertEqual(sum(len(g)==3 for g,_ in groups),99) |
|
|
| def test_plain_list_of_lists_and_deterministic_gzip(self): |
| values = [[record(0, 0)], [record(0, 10, 1), record(1, 11, 1)]] |
| with tempfile.TemporaryDirectory() as d: |
| files = [Path(d) / name for name in ("a.gz", "b.gz")] |
| for path in files: |
| with p.gzip_text(path) as f: |
| f.write(b"[\n") |
| for i, group in enumerate(values): |
| p.emit_array_item(f, group, i) |
| f.write(b"\n]\n") |
| with gzip.open(path, "rt") as f: |
| self.assertEqual(json.load(f), values) |
| self.assertEqual(list(p.read_groups(path)), values) |
| self.assertEqual(files[0].read_bytes(), files[1].read_bytes()) |
|
|
| def test_empty_list(self): |
| with tempfile.TemporaryDirectory() as d: |
| path = Path(d) / "a.gz" |
| with p.gzip_text(path) as f: |
| f.write(b"[\n\n]\n") |
| self.assertEqual(list(p.read_groups(path)), []) |
|
|
| def test_invalid_metric_rejected(self): |
| row = record(0, 0) |
| row["wall_time"] = float("nan") |
| with self.assertRaises(ValueError): |
| p.check_record(row, [0]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
