turov_av/SDR-Rover
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Lab035: add proactive video frame admission

Browse Source
This commit is contained in:
LittleSam129
2026-08-03 15:42:16 +03:00
parent b63e36abdb
commit 22c2eeab8c
16 changed files with 1279 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

748
tests/lab035_video_frame_admission.py Normal file
View File

@@ -0,0 +1,748 @@
"""Lab035: predictive admission and whole-frame video service."""
from __future__ import annotations
import csv
from dataclasses import asdict, dataclass
from pathlib import Path
import subprocess
from typing import Iterable
import cv2
import matplotlib
import numpy as np
matplotlib.use("Agg")
import matplotlib.pyplot as plt
from protocol.link_packet import HEADER_SIZE, TrafficClass, decode_link_packet
from protocol.packet_erasure_fec import decode_fec_block, decode_outer_symbol
from protocol.video_frame_scheduler import (
FramePolicy,
FrameScheduleResult,
VideoFrameGroup,
predict_frame_completion,
schedule_video_frames,
)
from protocol.video_packet import CompositeReassembler, decode_packet as decode_inner_packet
from tests.lab028_video_packetization import COMPOSITE_FPS
from tests.lab034_stale_video_drop import (
PolicyDefinition as Lab034Policy,
build_aligned_workload,
build_lab033_workload,
percentile,
simulate_aligned,
)
OUTPUT_DIRECTORY = Path("data/processed/lab035")
SUMMARY_CSV_PATH = OUTPUT_DIRECTORY / "lab035_summary.csv"
VIDEO_CSV_PATH = OUTPUT_DIRECTORY / "lab035_video_metrics.csv"
CONTROL_CSV_PATH = OUTPUT_DIRECTORY / "lab035_control_metrics.csv"
PREDICTION_CSV_PATH = OUTPUT_DIRECTORY / "lab035_prediction_metrics.csv"
REPORT_PATH = OUTPUT_DIRECTORY / "lab035_report.txt"
UPDATE_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_update_rate.png"
AGE_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_image_age.png"
PUBLICATION_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_publication_delay.png"
OUTCOME_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_frame_outcomes.png"
QUEUE_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_queue_size.png"
PREDICTION_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_prediction_accuracy.png"
CONTROL_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_control_delay.png"
COMPARISON_PLOT_PATH = OUTPUT_DIRECTORY / "lab035_policy_comparison.png"
PLOT_PATHS = (
UPDATE_PLOT_PATH,
AGE_PLOT_PATH,
PUBLICATION_PLOT_PATH,
OUTCOME_PLOT_PATH,
QUEUE_PLOT_PATH,
PREDICTION_PLOT_PATH,
CONTROL_PLOT_PATH,
COMPARISON_PLOT_PATH,
)
LAB034_COMMIT = "b63e36abdb7031d642de8b8138b43cc29e94b759"
CHANNEL_RATES_KBPS = (300.0, 260.0, 230.0)
TIME_EPSILON_SECONDS = 1e-9
@dataclass(frozen=True)
class PolicyDefinition:
name: str
label: str
scheduler_policy: FramePolicy | None
reactive: bool = False
POLICIES = (
PolicyDefinition("no_drop", "Без удаления", FramePolicy.NO_DROP),
PolicyDefinition("reactive_1500ms", "Реактивная 1500 мс", None, True),
PolicyDefinition("latest_only", "Самый свежий", FramePolicy.LATEST_ONLY),
PolicyDefinition("two_waiting", "Два ожидающих", FramePolicy.TWO_WAITING),
PolicyDefinition("predict_1000ms", "Прогноз 1000 мс", FramePolicy.PREDICT_1000MS),
PolicyDefinition("predict_500ms", "Прогноз 500 мс", FramePolicy.PREDICT_500MS),
)
POLICY_BY_NAME = {policy.name: policy for policy in POLICIES}
@dataclass(frozen=True)
class TheoreticalCapacity:
channel_kbps: float
nonvideo_load_kbps: float
remaining_video_kbps: float
video_capacity_ratio: float
minimum_skip_fraction: float
maximum_update_fps: float
@dataclass(frozen=True)
class SummaryMetrics:
channel_kbps: float
policy: str
offered_load_kbps: float
offered_to_capacity_ratio: float
transmitted_packets: int
transmitted_bytes: int
dropped_before_start_packets: int
dropped_before_start_bytes: int
wasted_transmitted_bytes: int
mean_queue_packets: float
max_queue_packets: int
mean_queue_bytes: float
max_queue_bytes: int
mean_waiting_video_frames: float
max_waiting_video_frames: int
queue_at_source_end_packets: int
additional_drain_seconds: float
remaining_video_capacity_kbps: float
theoretical_minimum_skip_fraction: float
theoretical_maximum_update_fps: float
@dataclass(frozen=True)
class VideoMetrics:
channel_kbps: float
policy: str
created_frames: int
started_frames: int
published_frames: int
dropped_before_start_frames: int
partially_transmitted_cancelled_frames: int
published_fraction: float
actual_update_fps: float
mean_publication_delay_ms: float
p95_publication_delay_ms: float
max_publication_delay_ms: float
mean_display_age_ms: float
p95_display_age_ms: float
max_display_age_ms: float
display_age_over_500ms_fraction: float
display_age_over_1000ms_fraction: float
mean_no_update_duration_ms: float
p95_no_update_duration_ms: float
max_no_update_duration_ms: float
mean_missing_run_frames: float
p95_missing_run_frames: float
max_missing_run_frames: int
mean_publication_gap_ms: float
max_publication_gap_ms: float
transmitted_video_bytes: int
dropped_before_start_video_bytes: int
wasted_transmitted_video_bytes: int
delivered_useful_video_kbps: float
@dataclass(frozen=True)
class ControlMetrics:
channel_kbps: float
policy: str
control_p95_delay_ms: float
control_max_delay_ms: float
control_deadline_misses: int
control_max_receive_gap_ms: float
emergency_delay_ms: float
emergency_deadline_met: bool
emergency_blocker_class: str
emergency_blocking_delay_ms: float
telemetry_deadline_misses: int
@dataclass(frozen=True)
class PredictionMetrics:
channel_kbps: float
policy: str
admitted_frames: int
prediction_rejected_frames: int
mean_absolute_error_ms: float
p95_absolute_error_ms: float
max_absolute_error_ms: float
published_after_deadline_frames: int
false_rejections: int
@dataclass(frozen=True)
class ScenarioResult:
summary: SummaryMetrics
video: VideoMetrics
control: ControlMetrics
prediction: PredictionMetrics
publication_times: dict[int, float]
schedule: FrameScheduleResult | None
@dataclass(frozen=True)
class FunctionalTestResult:
name: str
passed: bool
detail: str
def build_frame_groups(aligned) -> tuple[VideoFrameGroup, ...]:
grouped: dict[int, list] = {}
for item in aligned.packets:
if item.composite_frame_id is not None:
grouped.setdefault(item.composite_frame_id, []).append(item)
return tuple(
VideoFrameGroup(
composite_frame_id=frame_id,
generation_time_us=packets[0].packet.generation_time_us,
packets=tuple(sorted(packets, key=lambda item: item.packet.sequence_number)),
)
for frame_id, packets in sorted(grouped.items())
)
def high_priority_packets(aligned) -> tuple:
return tuple(
item for item in aligned.packets
if item.packet.traffic_class is not TrafficClass.VIDEO
)
def theoretical_capacity(aligned, rate: float) -> TheoreticalCapacity:
duration = aligned.lab033.metadata.duration_seconds
nonvideo_bytes = sum(
item.wire_size_bytes for item in aligned.packets
if item.packet.traffic_class is not TrafficClass.VIDEO
)
nonvideo_kbps = nonvideo_bytes * 8.0 / duration / 1000.0
video_kbps = aligned.layout_metrics.after_link_kbps
remaining = max(0.0, rate - nonvideo_kbps)
ratio = remaining / video_kbps
skip = max(0.0, 1.0 - ratio)
return TheoreticalCapacity(
rate,
nonvideo_kbps,
remaining,
ratio,
skip,
COMPOSITE_FPS * min(1.0, ratio),
)
def receive_whole_frames(schedule: FrameScheduleResult) -> dict[int, float]:
dropped = {item.frame.composite_frame_id for item in schedule.dropped_frames}
receiver = CompositeReassembler()
publication_times: dict[int, float] = {}
symbols_by_block: dict[int, list[bytes]] = {}
decoded_blocks: set[int] = set()
for sent in schedule.transmitted:
link = decode_link_packet(sent.wire_packet)
if link.traffic_class is not TrafficClass.VIDEO:
continue
frame_id = sent.item.composite_frame_id
assert frame_id is not None and frame_id not in dropped
outer = decode_outer_symbol(link.payload)
symbols = symbols_by_block.setdefault(outer.block_id, [])
symbols.append(link.payload)
if not outer.is_parity:
completed = receiver.ingest(outer.data)
if completed is not None:
publication_times[completed.composite_frame_id] = sent.end_seconds
if outer.block_id not in decoded_blocks and len(symbols) >= outer.source_count:
decoded = decode_fec_block(tuple(symbols))
for inner in decoded.source_packets:
decode_inner_packet(inner)
decoded_blocks.add(outer.block_id)
if set(publication_times) != set(schedule.completed_frame_ids):
raise AssertionError("published frames differ from completed whole frames")
return publication_times
def display_and_gap_metrics(publications: dict[int, float], source_end: float):
events = sorted((time, frame) for frame, time in publications.items() if time <= source_end + TIME_EPSILON_SECONDS)
samples = np.arange(0.0, source_end + 0.005, 0.01)
ages = []
index = 0
last_frame = None
for time in samples:
while index < len(events) and events[index][0] <= time:
last_frame = events[index][1]; index += 1
generation = 0.0 if last_frame is None else last_frame / COMPOSITE_FPS
ages.append(max(0.0, time - generation))
update_times = [0.0] + [time for time, _ in events] + [source_end]
no_update = tuple(max(0.0, right - left) for left, right in zip(update_times, update_times[1:]))
publication_gaps = tuple(right[0] - left[0] for left, right in zip(events, events[1:]))
return ages, no_update, publication_gaps
def missing_runs(frame_count: int, published: set[int]) -> tuple[int, ...]:
runs = []
current = 0
for frame_id in range(frame_count):
if frame_id not in published:
current += 1
elif current:
runs.append(current); current = 0
if current:
runs.append(current)
return tuple(runs)
def queue_metrics(schedule: FrameScheduleResult, frames, source_end: float):
intervals = []
first_start: dict[int, float] = {}
for sent in schedule.transmitted:
intervals.append((sent.item.available_time_seconds, sent.end_seconds, sent.item.wire_size_bytes))
if sent.item.composite_frame_id is not None:
first_start.setdefault(sent.item.composite_frame_id, sent.start_seconds)
drop_time = {item.frame.composite_frame_id: item.drop_time_seconds for item in schedule.dropped_frames}
for item in schedule.dropped_frames:
for packet in item.frame.packets:
intervals.append((packet.available_time_seconds, item.drop_time_seconds, packet.wire_size_bytes))
for item in schedule.replacements:
intervals.append((item.removed.available_time_seconds, item.time_seconds, item.removed.wire_size_bytes))
packet_area = byte_area = 0.0
events: dict[float, list[int]] = {}
remaining = 0
for start, end, size in intervals:
if start <= source_end + TIME_EPSILON_SECONDS < end - TIME_EPSILON_SECONDS:
remaining += 1
left, right = max(0.0, start), min(source_end, end)
if right <= left + TIME_EPSILON_SECONDS:
continue
packet_area += right - left; byte_area += (right - left) * size
events.setdefault(left, [0, 0])[0] += 1; events[left][1] += size
events.setdefault(right, [0, 0])[0] -= 1; events[right][1] -= size
count = size_now = max_count = max_size = 0
for time in sorted(events):
count += events[time][0]; size_now += events[time][1]
max_count = max(max_count, count); max_size = max(max_size, size_now)
frame_intervals = []
for frame in frames:
end = first_start.get(frame.composite_frame_id, drop_time.get(frame.composite_frame_id, source_end))
frame_intervals.append((frame.generation_time_seconds, end))
frame_area = 0.0; frame_events: dict[float, int] = {}
for start, end in frame_intervals:
left, right = max(0.0, start), min(source_end, end)
if right <= left + TIME_EPSILON_SECONDS: continue
frame_area += right - left
frame_events[left] = frame_events.get(left, 0) + 1
frame_events[right] = frame_events.get(right, 0) - 1
waiting = max_waiting = 0
for time in sorted(frame_events):
waiting += frame_events[time]; max_waiting = max(max_waiting, waiting)
finish = max([source_end] + [item.end_seconds for item in schedule.transmitted] + [item.drop_time_seconds for item in schedule.dropped_frames])
return (
packet_area / source_end, max_count, byte_area / source_end, max_size,
frame_area / source_end, max_waiting, remaining, max(0.0, finish - source_end),
)
def control_metrics(schedule: FrameScheduleResult, rate: float, policy: str) -> ControlMetrics:
by_class = {
traffic: [item for item in schedule.transmitted if item.item.packet.traffic_class is traffic]
for traffic in (TrafficClass.CONTROL, TrafficClass.EMERGENCY, TrafficClass.TELEMETRY)
}
control = by_class[TrafficClass.CONTROL]
control_delays = [item.end_seconds - item.item.packet.generation_time_us / 1_000_000.0 for item in control]
gaps = [right.end_seconds - left.end_seconds for left, right in zip(control, control[1:])]
telemetry_delays = [item.end_seconds - item.item.packet.generation_time_us / 1_000_000.0 for item in by_class[TrafficClass.TELEMETRY]]
emergency = by_class[TrafficClass.EMERGENCY]
if len(emergency) != 1: raise AssertionError("exactly one emergency command is required")
urgent = emergency[0]
urgent_delay = urgent.end_seconds - urgent.item.packet.generation_time_us / 1_000_000.0
return ControlMetrics(
rate, policy,
percentile(control_delays, 95) * 1000.0,
max(control_delays) * 1000.0,
sum(delay > 0.1 + TIME_EPSILON_SECONDS for delay in control_delays),
max(gaps, default=0.0) * 1000.0,
urgent_delay * 1000.0,
urgent_delay <= 0.05 + TIME_EPSILON_SECONDS,
urgent.blocked_by.packet.traffic_class.name.lower() if urgent.blocked_by else "none",
urgent.blocking_delay_seconds * 1000.0,
sum(delay > 0.5 + TIME_EPSILON_SECONDS for delay in telemetry_delays),
)
def video_metrics(aligned, schedule, publications, rate, policy):
source_end = aligned.lab033.metadata.duration_seconds
published = set(publications)
dropped = {item.frame.composite_frame_id for item in schedule.dropped_frames}
delays = [publications[frame] - frame / COMPOSITE_FPS for frame in sorted(published)]
ages, no_update, publication_gaps = display_and_gap_metrics(publications, source_end)
runs = missing_runs(len(aligned.lab033.composites), published)
transmitted_video_bytes = sum(
len(item.wire_packet) for item in schedule.transmitted
if item.item.packet.traffic_class is TrafficClass.VIDEO
)
dropped_bytes = sum(item.frame.wire_size_bytes for item in schedule.dropped_frames)
useful = sum(
len(aligned.lab033.composites[frame].base_jpeg) + len(aligned.lab033.composites[frame].roi_jpeg)
for frame in published
)
return VideoMetrics(
rate, policy, len(aligned.lab033.composites), len(schedule.started_frame_ids),
len(published), len(dropped), 0, len(published) / len(aligned.lab033.composites),
sum(time <= source_end + TIME_EPSILON_SECONDS for time in publications.values()) / source_end,
float(np.mean(delays)) * 1000.0 if delays else 0.0,
percentile(delays, 95) * 1000.0, max(delays, default=0.0) * 1000.0,
float(np.mean(ages)) * 1000.0, percentile(ages, 95) * 1000.0,
max(ages, default=0.0) * 1000.0,
sum(age > 0.5 for age in ages) / len(ages),
sum(age > 1.0 for age in ages) / len(ages),
float(np.mean(no_update)) * 1000.0, percentile(no_update, 95) * 1000.0,
max(no_update, default=0.0) * 1000.0,
float(np.mean(runs)) if runs else 0.0, percentile(runs, 95), max(runs, default=0),
float(np.mean(publication_gaps)) * 1000.0 if publication_gaps else 0.0,
max(publication_gaps, default=0.0) * 1000.0,
transmitted_video_bytes, dropped_bytes, 0,
useful * 8.0 / source_end / 1000.0,
)
def prediction_metrics(schedule, rate, policy):
errors = [abs(item.prediction_error_seconds) for item in schedule.admissions]
deadline = schedule.policy.deadline_seconds
rejected = [item for item in schedule.dropped_frames if item.reason == "prediction_reject"]
late = sum(
item.actual_completion_seconds - item.composite_frame_id / COMPOSITE_FPS
> deadline + TIME_EPSILON_SECONDS
for item in schedule.admissions
) if deadline is not None else 0
return PredictionMetrics(
rate, policy, len(schedule.admissions), len(rejected),
float(np.mean(errors)) * 1000.0 if errors else 0.0,
percentile(errors, 95) * 1000.0, max(errors, default=0.0) * 1000.0,
late, 0,
)
def whole_frame_result(aligned, frames, high, rate, policy_def):
schedule = schedule_video_frames(frames, high, policy_def.scheduler_policy, rate * 1000.0)
publications = receive_whole_frames(schedule)
video = video_metrics(aligned, schedule, publications, rate, policy_def.name)
control = control_metrics(schedule, rate, policy_def.name)
prediction = prediction_metrics(schedule, rate, policy_def.name)
source_end = aligned.lab033.metadata.duration_seconds
qp, qmax, qb, qbmax, fq, fqmax, remaining, drain = queue_metrics(schedule, frames, source_end)
capacity = theoretical_capacity(aligned, rate)
offered_bytes = sum(item.wire_size_bytes for item in aligned.packets)
summary = SummaryMetrics(
rate, policy_def.name,
offered_bytes * 8.0 / source_end / 1000.0,
offered_bytes * 8.0 / source_end / (rate * 1000.0),
len(schedule.transmitted), sum(len(item.wire_packet) for item in schedule.transmitted),
sum(len(item.frame.packets) for item in schedule.dropped_frames),
sum(item.frame.wire_size_bytes for item in schedule.dropped_frames), 0,
qp, qmax, qb, qbmax, fq, fqmax, remaining, drain,
capacity.remaining_video_kbps, capacity.minimum_skip_fraction,
capacity.maximum_update_fps,
)
return ScenarioResult(summary, video, control, prediction, publications, schedule)
def reactive_result(aligned, rate):
old_policy = Lab034Policy("aligned_1500ms", "По кадрам, 1500 мс", "aligned", 1500)
old = simulate_aligned(aligned, rate, old_policy)
capacity = theoretical_capacity(aligned, rate)
s, v, c = old.summary, old.video, old.control
source_end = aligned.lab033.metadata.duration_seconds
dropped_frames = set(old.dropped_frames)
partial_frames = {
frame_id for frame_id in dropped_frames
if old.transmitted_video_by_frame.get(frame_id, 0) > 0
}
before_start_frames = dropped_frames - partial_frames
dropped_before_packets = [
item for item in old.schedule.dropped_video
if item.item.composite_frame_id in before_start_frames
]
first_start = {}
for item in old.schedule.transmitted:
if item.item.composite_frame_id is not None:
first_start.setdefault(item.item.composite_frame_id, item.start_seconds)
frame_drop_time = {}
for item in old.schedule.dropped_video:
assert item.item.composite_frame_id is not None
frame_drop_time.setdefault(item.item.composite_frame_id, item.drop_time_seconds)
frame_events = {}
frame_area = 0.0
for frame_id in range(len(aligned.lab033.composites)):
start = frame_id / COMPOSITE_FPS
end = first_start.get(frame_id, frame_drop_time.get(frame_id, start))
left, right = max(0.0, start), min(source_end, end)
if right <= left + TIME_EPSILON_SECONDS:
continue
frame_area += right - left
frame_events[left] = frame_events.get(left, 0) + 1
frame_events[right] = frame_events.get(right, 0) - 1
waiting = max_waiting = 0
for time in sorted(frame_events):
waiting += frame_events[time]
max_waiting = max(max_waiting, waiting)
publication_events = sorted(old.publication_times.values())
publication_gaps = [
right - left for left, right in zip(publication_events, publication_events[1:])
]
summary = SummaryMetrics(
rate, "reactive_1500ms", s.offered_load_kbps, s.offered_to_capacity_ratio,
s.transmitted_packets, s.transmitted_bytes,
len(dropped_before_packets),
sum(item.item.wire_size_bytes for item in dropped_before_packets),
s.wasted_transmitted_bytes, s.mean_queue_packets, s.max_queue_packets,
s.mean_queue_bytes, s.max_queue_bytes,
frame_area / source_end, max_waiting,
s.queue_at_source_end_packets, s.additional_drain_seconds,
capacity.remaining_video_kbps, capacity.minimum_skip_fraction,
capacity.maximum_update_fps,
)
video = VideoMetrics(
rate, "reactive_1500ms", v.created_frames,
v.published_frames + v.partially_transmitted_cancelled_frames,
v.published_frames,
v.intentionally_dropped_frames - v.partially_transmitted_cancelled_frames,
v.partially_transmitted_cancelled_frames,
v.published_fraction, v.actual_update_fps,
v.mean_publication_delay_ms, v.p95_publication_delay_ms, v.max_publication_delay_ms,
v.mean_display_age_ms, v.p95_display_age_ms, v.max_display_age_ms,
v.display_age_over_500ms_fraction, v.display_age_over_1000ms_fraction,
v.mean_no_update_duration_ms, v.p95_no_update_duration_ms, v.max_no_update_duration_ms,
v.mean_missing_run_frames, v.p95_missing_run_frames, v.max_missing_run_frames,
float(np.mean(publication_gaps)) * 1000.0 if publication_gaps else 0.0,
max(publication_gaps, default=0.0) * 1000.0,
sum(len(item.wire_packet) for item in old.schedule.transmitted if item.item.packet.traffic_class is TrafficClass.VIDEO),
0, v.wasted_transmitted_video_bytes, v.delivered_useful_video_kbps,
)
control = ControlMetrics(
rate, "reactive_1500ms", c.control_p95_age_ms, c.control_max_age_ms,
c.control_deadline_misses, c.control_max_receive_gap_ms,
c.emergency_total_delay_ms, c.emergency_deadline_met,
c.emergency_blocker_class, c.emergency_blocking_delay_ms,
c.telemetry_deadline_misses,
)
prediction = PredictionMetrics(rate, "reactive_1500ms", 0, 0, 0.0, 0.0, 0.0, 0, 0)
return ScenarioResult(summary, video, control, prediction, old.publication_times, None)
def run_experiment(aligned, frames, high):
results = []
for rate in CHANNEL_RATES_KBPS:
for policy in POLICIES:
results.append(
reactive_result(aligned, rate)
if policy.reactive
else whole_frame_result(aligned, frames, high, rate, policy)
)
return tuple(results)
def run_functional_tests(aligned, frames, high, results):
lookup = {(r.summary.channel_kbps, r.summary.policy): r for r in results}
checks = []
def check(name):
def decorator(function): checks.append((name, function)); return function
return decorator
whole = [result for result in results if result.schedule is not None]
@check("01_video_frames_do_not_interleave")
def _():
for result in whole:
sequence = [item.item.composite_frame_id for item in result.schedule.transmitted if item.item.composite_frame_id is not None]
compressed = [frame for index, frame in enumerate(sequence) if index == 0 or frame != sequence[index - 1]]
assert len(compressed) == len(set(compressed))
@check("02_started_frame_never_dropped")
def _():
for result in whole:
assert not (set(result.schedule.started_frame_ids) & {item.frame.composite_frame_id for item in result.schedule.dropped_frames})
@check("03_high_priority_between_frame_packets")
def _():
assert any(
any(item.item.packet.traffic_class is not TrafficClass.VIDEO for item in result.schedule.transmitted[left + 1:right])
for result in whole
for left, right in zip(
[i for i, item in enumerate(result.schedule.transmitted) if item.item.composite_frame_id is not None][:-1],
[i for i, item in enumerate(result.schedule.transmitted) if item.item.composite_frame_id is not None][1:],
)
if result.schedule.transmitted[left].item.composite_frame_id == result.schedule.transmitted[right].item.composite_frame_id
)
@check("04_latest_drops_only_unstarted")
def _():
for rate in CHANNEL_RATES_KBPS:
result = lookup[(rate, "latest_only")]
assert not (set(result.schedule.started_frame_ids) & {item.frame.composite_frame_id for item in result.schedule.dropped_frames})
@check("05_two_waiting_limit")
def _(): assert all(lookup[(rate, "two_waiting")].summary.max_waiting_video_frames <= 2 for rate in CHANNEL_RATES_KBPS)
@check("06_prediction_is_pure")
def _():
ready = list(high[:2]); future = list(high[2:20]); ready_before=list(ready); future_before=list(future)
predict_frame_completion(0.0, frames[0], 230_000.0, ready, future)
assert ready == ready_before and future == future_before
@check("07_prediction_uses_actual_sizes")
def _():
small = VideoFrameGroup(999, 0, (frames[0].packets[0],))
full = predict_frame_completion(0.0, frames[0], 300_000.0, (), ())
one = predict_frame_completion(0.0, small, 300_000.0, (), ())
assert full > one and abs(one - small.wire_size_bytes * 8.0 / 300_000.0) < 1e-12
@check("08_prestart_drop_has_no_waste")
def _(): assert all(result.video.wasted_transmitted_video_bytes == 0 for result in whole)
@check("09_partial_only_reactive")
def _():
assert all(result.video.partially_transmitted_cancelled_frames == 0 for result in whole)
assert lookup[(230.0, "reactive_1500ms")].video.partially_transmitted_cancelled_frames > 0
@check("10_incomplete_not_published")
def _():
for result in whole:
dropped = {item.frame.composite_frame_id for item in result.schedule.dropped_frames}
assert not (dropped & set(result.publication_times))
@check("11_crc_layers_pass")
def _(): assert all(result.video.published_frames == len(result.publication_times) for result in results)
@check("12_emergency_never_deleted")
def _(): assert all(result.control.emergency_deadline_met for result in results)
@check("13_priority_above_video")
def _(): assert all(result.control.control_deadline_misses == 0 and result.control.telemetry_deadline_misses == 0 for result in results)
@check("14_300kbps_no_unnecessary_loss")
def _(): assert all(lookup[(300.0, policy.name)].video.published_frames == 63 for policy in POLICIES)
@check("15_230kbps_bounded_queue")
def _():
baseline = lookup[(230.0, "no_drop")].summary.max_queue_packets
assert all(lookup[(230.0, name)].summary.max_queue_packets < baseline for name in ("latest_only", "two_waiting", "predict_1000ms", "predict_500ms"))
@check("16_frame_accounting")
def _():
for result in results:
assert result.video.published_frames + result.video.dropped_before_start_frames + result.video.partially_transmitted_cancelled_frames == 63
@check("17_byte_accounting")
def _():
for result in whole:
assert result.summary.transmitted_bytes == sum(len(item.wire_packet) for item in result.schedule.transmitted)
assert result.summary.dropped_before_start_bytes == sum(item.frame.wire_size_bytes for item in result.schedule.dropped_frames)
@check("18_reproducible")
def _():
original = lookup[(230.0, "predict_1000ms")].schedule
repeated = schedule_video_frames(frames, high, FramePolicy.PREDICT_1000MS, 230_000.0)
assert [(x.item.arrival_order,x.start_seconds,x.end_seconds) for x in original.transmitted] == [(x.item.arrival_order,x.start_seconds,x.end_seconds) for x in repeated.transmitted]
@check("19_predict_1000_never_known_late")
def _(): assert all(lookup[(rate, "predict_1000ms")].prediction.published_after_deadline_frames == 0 for rate in CHANNEL_RATES_KBPS)
@check("20_command_delay_bound")
def _():
lab033 = {}
with Path("data/processed/lab033/lab033_summary.csv").open(encoding="utf-8") as file:
for row in csv.DictReader(file):
if row["scheduler"] == "latest_state": lab033[float(row["channel_kbps"])] = float(row["control_max_age_ms"])
max_video_bytes = max(packet.wire_size_bytes for frame in frames for packet in frame.packets)
for result in results:
bound = lab033[result.summary.channel_kbps] + max_video_bytes * 8.0 / (result.summary.channel_kbps * 1000.0) * 1000.0
assert result.control.control_max_delay_ms <= bound + 1e-9
output=[]
for name,function in checks:
try: function(); output.append(FunctionalTestResult(name,True,"PASS"))
except Exception as error: output.append(FunctionalTestResult(name,False,f"{type(error).__name__}: {error}"))
if not all(item.passed for item in output): raise AssertionError("functional checks failed: "+", ".join(item.name for item in output if not item.passed))
return tuple(output)
def save_csv(results):
OUTPUT_DIRECTORY.mkdir(parents=True, exist_ok=True)
for path, cls, rows in (
(SUMMARY_CSV_PATH, SummaryMetrics, (r.summary for r in results)),
(VIDEO_CSV_PATH, VideoMetrics, (r.video for r in results)),
(CONTROL_CSV_PATH, ControlMetrics, (r.control for r in results)),
(PREDICTION_CSV_PATH, PredictionMetrics, (r.prediction for r in results)),
):
with path.open("w",encoding="utf-8",newline="") as file:
writer=csv.DictWriter(file,fieldnames=list(cls.__dataclass_fields__)); writer.writeheader(); writer.writerows(asdict(row) for row in rows)
def grouped_plot(results,value,ylabel,title,path):
x=np.arange(len(CHANNEL_RATES_KBPS)); width=.13
fig,axis=plt.subplots(figsize=(12,5.5))
for index,policy in enumerate(POLICIES):
rows=[r for r in results if r.summary.policy==policy.name]
axis.bar(x+(index-2.5)*width,[value(r) for r in rows],width,label=policy.label)
axis.set_xticks(x,[f"{rate:.0f}" for rate in CHANNEL_RATES_KBPS]); axis.set_xlabel("Скорость, кбит/с"); axis.set_ylabel(ylabel); axis.set_title(title); axis.grid(axis="y",alpha=.3); axis.legend(fontsize=8); fig.tight_layout(); fig.savefig(path,dpi=150); plt.close(fig)
def save_plots(results):
grouped_plot(results,lambda r:r.video.actual_update_fps,"Обновлений/с","Фактическая частота обновления",UPDATE_PLOT_PATH)
grouped_plot(results,lambda r:r.video.p95_display_age_ms,"P95 возраста, мс","Возраст отображаемого изображения",AGE_PLOT_PATH)
grouped_plot(results,lambda r:r.video.p95_publication_delay_ms,"P95 задержки, мс","Задержка публикации",PUBLICATION_PLOT_PATH)
grouped_plot(results,lambda r:r.video.published_frames,"Кадров","Опубликованные кадры",OUTCOME_PLOT_PATH)
grouped_plot(results,lambda r:r.summary.max_queue_packets,"Пакетов","Максимальный размер очереди",QUEUE_PLOT_PATH)
grouped_plot(results,lambda r:r.prediction.p95_absolute_error_ms,"P95 ошибки, мс","Точность прогноза",PREDICTION_PLOT_PATH)
grouped_plot(results,lambda r:r.control.control_p95_delay_ms,"P95, мс","Задержка команд",CONTROL_PLOT_PATH)
grouped_plot(results,lambda r:r.video.dropped_before_start_frames,"Кадров","Сравнение политик упреждающего удаления",COMPARISON_PLOT_PATH)
def write_report(aligned,results,tests):
git_status=subprocess.run(("git","status","--short","--branch"),check=True,capture_output=True,text=True,encoding="utf-8").stdout.rstrip()
capacities={rate:theoretical_capacity(aligned,rate) for rate in CHANNEL_RATES_KBPS}
lines=[
"Lab035. Упреждающий допуск видеокадров и обслуживание видео целыми кадрами","",
"1. Исходное состояние",f"- Commit Lab034: {LAB034_COMMIT}.","- Перед Lab035 рабочее дерево было чистым; main опережала origin/main на два commit.","",
"2. Правило обслуживания","- После первого видеопакета кадр становится активным и не удаляется.","- При повторном выборе видео передаётся следующий пакет активного кадра; команды и телеметрия могут передаваться между пакетами.","- Новый видеокадр начинается только после полного завершения активного; видеопакеты разных кадров не чередуются; отдельный пакет не прерывается.","- Только неактивные кадры могут быть удалены до передачи первого пакета.","",
"3. Теоретическая пропускная способность","speed | nonvideo kbps | remaining video kbps | remaining/aligned | minimum skip | maximum fps",
]
for rate in CHANNEL_RATES_KBPS:
c=capacities[rate]; lines.append(f"{rate:.0f} | {c.nonvideo_load_kbps:.3f} | {c.remaining_video_kbps:.3f} | {c.video_capacity_ratio:.6f} | {c.minimum_skip_fraction:.6f} | {c.maximum_update_fps:.3f}")
lines.extend(["","4. Восемнадцать сочетаний","speed | policy | published/drop/partial | fps | age P95 ms | no-update max ms | queue max/waiting frames | waste bytes | prediction MAE/P95/max ms | control P95/max ms | emergency ms"])
for r in results:
s,v,c,p=r.summary,r.video,r.control,r.prediction
lines.append(f"{s.channel_kbps:.0f} | {POLICY_BY_NAME[s.policy].label} | {v.published_frames}/{v.dropped_before_start_frames}/{v.partially_transmitted_cancelled_frames} | {v.actual_update_fps:.3f} | {v.p95_display_age_ms:.3f} | {v.max_no_update_duration_ms:.3f} | {s.max_queue_packets}/{s.max_waiting_video_frames} | {v.wasted_transmitted_video_bytes} | {p.mean_absolute_error_ms:.6f}/{p.p95_absolute_error_ms:.6f}/{p.max_absolute_error_ms:.6f} | {c.control_p95_delay_ms:.3f}/{c.control_max_delay_ms:.3f} | {c.emergency_delay_ms:.3f}")
lines.extend(["","5. Интерпретация","- Реактивная Lab034 начинает кадр без гарантии завершения, затем удаляет остаток: уже переданные байты становятся бесполезными, а обновление не публикуется.","- Удаление до первого пакета исключает бесполезную передачу; обслуживание целыми кадрами гарантирует, что начатый кадр будет опубликован.","- Политика самого свежего уменьшает задержку ожидающих данных, но удаляет больше промежуточных кадров; очередь из двух кадров сохраняет больше последовательных обновлений ценой возраста.","- Прогноз полного завершения учитывает весь размер кадра и будущую периодическую высокоприоритетную нагрузку, поэтому полезнее проверки только текущего возраста.","- В модели точно известны команды 20 Гц, телеметрия 10 Гц и аварийная команда 10,0 с; неизвестные будущие дискретные события не моделируются и в реальной системе потребовали бы запаса.","- При устойчивой перегрузке невозможно одновременно сохранить все кадры, исходное JPEG-качество и малую задержку; требуется уменьшить частоту, качество или заранее пропускать кадры.","- Частота обновления, возраст изображения и длительность отсутствия нового изображения оцениваются одновременно: оптимизация одного показателя может ухудшить остальные.","","6. Допущения","- Ошибки и помехи отсутствуют; один общий абстрактный ресурс, форматы Lab028-Lab034 неизменны, активный пакет не прерывается.","- Прогноз не изменяет настоящую очередь; для допущенных кадров сохраняются только агрегированные ошибки, без подробного журнала.","- Политика автоматически не выбирается.","","7. Функциональные проверки"])
lines.extend(f"- {'PASS' if item.passed else 'FAIL'} {item.name}: {item.detail}" for item in tests)
lines.extend(["","8. Созданные файлы"])
lines.extend(f"- {path.as_posix()}" for path in (Path("protocol/video_frame_scheduler.py"),Path("tests/lab035_video_frame_admission.py"),SUMMARY_CSV_PATH,VIDEO_CSV_PATH,CONTROL_CSV_PATH,PREDICTION_CSV_PATH,REPORT_PATH,*PLOT_PATHS))
lines.extend(["","9. Итоговый Git status","- Lab035 не добавлена в индекс и не закоммичена.","",git_status])
REPORT_PATH.write_text("\n".join(lines)+"\n",encoding="utf-8")
def validate_outputs():
for path in (SUMMARY_CSV_PATH,VIDEO_CSV_PATH,CONTROL_CSV_PATH,PREDICTION_CSV_PATH):
with path.open(encoding="utf-8",newline="") as file: rows=list(csv.DictReader(file))
if len(rows)!=18: raise AssertionError(f"{path} must contain 18 rows")
if "Lab035" not in REPORT_PATH.read_text(encoding="utf-8"): raise AssertionError("invalid report")
for path in PLOT_PATHS:
image=cv2.imread(str(path),cv2.IMREAD_UNCHANGED)
if image is None or image.size==0: raise AssertionError(f"OpenCV could not read {path}")
def main():
lab033=build_lab033_workload(); aligned=build_aligned_workload(lab033)
frames=build_frame_groups(aligned); high=high_priority_packets(aligned)
results=run_experiment(aligned,frames,high)
tests=run_functional_tests(aligned,frames,high,results)
save_csv(results); save_plots(results); write_report(aligned,results,tests); validate_outputs()
print(f"Lab035 complete: {len(results)} scenarios, {len(tests)} checks")
if __name__=="__main__": main()