sync sample package

record_54f74a4c-ee9d-4f28-9d30-04c54fa447d7.json

@@ -0,0 +1,15 @@
+{
+  "source_code": "from typing import Sequence\n\nclass StepScheduler:\n    def __init__(self, components: Sequence[object]):\n        self.components = components\n        self.time = 0.0\n\n    def run(self, stop_time: float, step: float) -> float:\n        if step <= 0:\n            raise ValueError('step must be positive')\n\n        while self.time < stop_time:\n            target = min(self.time + step, stop_time)\n            for component in self.components:\n                component.set_time(target)\n            for component in self.components:\n                component.advance()\n            for component in self.components:\n                component.wait_until(target)\n            self.time = target\n\n        return self.time",
+  "execution_order": [
+    "Validate that step is positive; otherwise raise ValueError before scheduling any component.",
+    "Calculate target as min(self.time + step, stop_time).",
+    "Call set_time(target) on each component in sequence.",
+    "Call advance() on each component in sequence, after all components have received the target time.",
+    "Call wait_until(target) on each component in sequence, after all advance calls have returned.",
+    "Assign target to self.time and repeat until the stop time is reached; then return self.time."
+  ],
+  "analysis_question": "Explain the scheduler's per-step control flow, the order in which component methods are called, and how it advances and synchronizes simulation time.",
+  "understanding_answer": "The scheduler rejects a nonpositive step, then repeatedly chooses the next target as the smaller of the current time plus the step and the stop time. For each target, it sets that time on every component, calls advance on every component, and then calls wait_until on every component. Only after all waits return does it update its own time. The final interval may therefore be shorter than the configured step. The method returns the last reached time.",
+  "control_flow_explanation": "run first checks the step-size guard and raises ValueError if the step is not positive. Otherwise, the while loop continues while self.time is less than stop_time. Each iteration calculates a bounded target and executes three separate loops over components: set_time, advance, and wait_until. Control returns to the loop only after all three loops finish; self.time is then assigned the target. When the loop condition becomes false, run returns self.time.",
+  "timing_and_synchronization_explanation": "Simulation time starts at 0.0. Each target advances by step unless that would pass stop_time, in which case the target is capped at stop_time. The scheduler calls wait_until(target) for every component before changing its own time and beginning the next iteration. This establishes a per-target waiting phase, though the code does not define the internals of the component methods or a separate parallel barrier."
+}

record_82948c94-c862-49bc-abfa-9cba6e54ba3b.json

@@ -0,0 +1,15 @@
+{
+  "source_code": "class GrantScheduler:\n    def __init__(self, master, components):\n        self.master = master\n        self.components = components\n\n    def run(self, stop_time: float, quantum: float) -> float:\n        if quantum <= 0:\n            raise ValueError('quantum must be positive')\n\n        now = 0.0\n        while now < stop_time:\n            requested = min(now + quantum, stop_time)\n            granted = self.master.request_time(requested)\n            if not now < granted <= requested:\n                raise RuntimeError('invalid time grant')\n\n            elapsed = granted - now\n            for component in self.components:\n                component.do_step(granted, elapsed)\n            now = granted\n\n        return now",
+  "execution_order": [
+    "Validate that quantum is positive; otherwise raise ValueError.",
+    "Set the local simulation time to 0.0 and check whether it is below stop_time.",
+    "Compute requested as min(now + quantum, stop_time), then ask master.request_time(requested) for a grant.",
+    "Validate that now < granted <= requested; raise RuntimeError if this condition is false.",
+    "Compute elapsed as granted - now and call do_step(granted, elapsed) on each component in sequence.",
+    "Update now to granted; repeat the request cycle until now reaches stop_time, then return now."
+  ],
+  "analysis_question": "Describe how the master controls time advancement, what grant values are accepted, and how the components are scheduled after a grant.",
+  "understanding_answer": "The scheduler starts at time 0.0 and requests a time no later than stop_time, at most quantum beyond now. It accepts a grant only if it is strictly later than now and no later than the requested time; otherwise it raises RuntimeError before calling any component for that iteration. For a valid grant, it computes the elapsed interval and calls do_step(granted, elapsed) on each component in sequence. It updates now only after all those calls return. The loop ends when now reaches stop_time, and the method returns now.",
+  "control_flow_explanation": "run first rejects a nonpositive quantum. Inside the loop, it computes requested and calls master.request_time(requested). The grant-validation branch raises RuntimeError if the grant is outside the open interval after now through requested, so no component step is issued for an invalid grant. For a valid grant, the scheduler calculates elapsed, iterates through components calling do_step, then assigns granted to now. The loop repeats or exits based on the updated now value.",
+  "timing_and_synchronization_explanation": "The quantum limits the requested advance, while stop_time caps the request at the end of the run. Actual progress is determined by the master's granted time, which must be later than the current time and cannot exceed the request. Each component receives the same granted endpoint and elapsed interval. The code waits for the sequential do_step calls to return before updating now and making another request; it does not include a separate wait or barrier call."
+}

record_bdec3876-2efb-44ae-a80c-16d38e2fb1fc.json

@@ -0,0 +1,15 @@
+{
+  "source_code": "class EventScheduler:\n    def __init__(self, components):\n        self.components = components\n\n    def run(self, stop_time: float) -> float:\n        now = 0.0\n        while now < stop_time:\n            next_times = [component.next_event_time(now)\n                          for component in self.components]\n            target = min([stop_time, *next_times])\n            if target <= now:\n                raise RuntimeError('components must report a future event')\n\n            for component in self.components:\n                component.advance_to(target)\n            for component in self.components:\n                component.process_events_at(target)\n            now = target\n\n        return now",
+  "execution_order": [
+    "Initialize now to 0.0 and continue while it is less than stop_time.",
+    "Call next_event_time(now) on each component and collect the reported times.",
+    "Choose the minimum of stop_time and the reported event times; raise RuntimeError if the result is not later than now.",
+    "Call advance_to(target) on every component in sequence.",
+    "After all advance_to calls return, call process_events_at(target) on every component in sequence.",
+    "Set now to target and repeat; return now after reaching stop_time."
+  ],
+  "analysis_question": "Explain how the scheduler selects each synchronization boundary and why it has separate advance and event-processing loops.",
+  "understanding_answer": "At each iteration, the scheduler asks every component for its next event time relative to now, then selects the earliest of those times and stop_time. If that target is not later than now, it raises RuntimeError. Otherwise, it advances every component to the selected target before calling process_events_at(target) on any component. It then updates now and repeats until stop_time is reached. Thus event processing at a boundary begins only after all component advance_to calls for that boundary have returned.",
+  "control_flow_explanation": "The while loop runs while now is below stop_time. A list comprehension gathers next_event_time(now) from each component, and min selects the earliest reported time or stop_time, whichever is earlier. The guard rejects a target at or before now. For a valid target, the first component loop advances all components; only when it completes does the second loop process events at that target. The scheduler then assigns target to now, returning to the loop condition.",
+  "timing_and_synchronization_explanation": "The scheduler advances from one selected boundary to the next rather than using a fixed step. Each boundary is the earliest component-reported event time, capped at stop_time. All components are advanced to the same target before any component processes events there, making the advance phase precede the event-processing phase at each boundary. The code requires the selected target to be strictly later than now but does not otherwise specify how components calculate their event times."
+}