## Problem: Optimal Scheduling of Batched Register Operations You are tasked with implementing a function `execute_operations_from_file(file_path: str)` that reads a text file describing batches of register operations (reads and writes) on integer-indexed registers. Your primary goal is to **schedule and execute** these operations using provided primitive functions, while strictly adhering to a set of timing and dependency constraints. You are allowed to **reorder operations within a batch** to achieve a valid schedule, but operations across different batches must be processed strictly sequentially. ### Provided Primitives Assume the following functions are already implemented and available for your use: ```python def read_reg(register_index: int) -> int: """Return the current value of the register with the given index.""" ... def write_reg(register_index: int, value: int) -> None: """Write `value` into the register with the given index.""" ... ``` Your `execute_operations_from_file` implementation must parse the input file, compute a valid schedule, and then invoke `read_reg` / `write_reg` according to that schedule. ### Timing Model and Global Constraints All timing is measured in **logical milliseconds (ms)**. You do not need to introduce real-time delays; simply ensure your computed schedule respects these rules: 1. **Single Operation at a Time**: At any given logical time, a maximum of **one** operation (read or write) may be executing. 2. **Minimum Gap Between Operations**: Each operation is considered to take negligible time. However, the **start times** of any two consecutive operations must be at least **1 ms apart**. If one operation starts at time `t`, the next operation may start at `t + 1` or later. 3. **Read-After-Write Hazard**: After a **write** to register `r` starts at time `t`, no **read** of register `r` may start until time **`t + 10`** or later. This means there must be at least 10 ms between a write to register `r` and any subsequent read of `r`. Your primary objective is to produce a **valid schedule** that respects all these rules. While minimizing the total completion time of all operations is desirable, correctness (adhering to all constraints) is the fundamental requirement. ### Input Format The input is a plain text file. Each non-empty line represents either an operation or a batch separator: 1. **Write Operation**: ```text w ``` - ``: An integer register index (e.g., `0`, `1`, `2`, ...). - `w`: The literal character `w` (indicating a write). - ``: An integer value to be written. Example: `2 w 100` means: _write the value `100` to register `2`_. 2. **Read Operation (Level 1)**: ```text r ``` - ``: An integer register index. - `r`: The literal character `r` (indicating a read). Example: `5 r` means: _read from register `5`_. 3. **Batch Separator**: ```text p ``` or ```text P ``` (case-insensitive). Each `p` or `P` line **ends the current batch** and starts a **new batch**. The file consists of one or more batches of operations, separated by these lines. #### Batch Semantics * **Strict Sequential Batching**: Operations in batch `k+1` must not start before all operations in batch `k` have finished, according to the logical time schedule. * **Intra-Batch Reordering**: Operations within the same batch may be reordered arbitrarily, provided all global timing constraints (single operation, 1 ms gap, 10 ms read-after-write) and Level 2 dependency constraints (if applicable) are respected. * **No Duplicate Registers per Batch**: It is guaranteed that within a single batch, no register index appears in more than one operation (i.e., no two operations in the same batch involve the same ``). ### Level 2: Intra-Batch Read Dependencies For Level 2, some read operations within a batch may have an additional dependency on another operation line within the **same batch**. Such a dependent read operation has the format: ```text r ``` Where: * ``: An integer register index to be read. * `r`: The literal character `r`. * ``: A **1-based line index within the same batch**, referring to another operation **line** in that batch. This count includes only operation lines, not `p` / `P` lines, and restarts at 1 for each batch. The referenced line can be either a read or a write operation. It is guaranteed that `` is valid and refers to a line in the same batch as this read. **Dependency Rule**: A read operation specified as ` r ` must **not** be scheduled before the operation on the referenced line has executed. This precedence constraint must be respected in addition to all global timing constraints. ### Sample Input ```text 2 w 100 3 w 10 4 w 10 5 r p 4 r 1 r 2 r p 3 w 10 p 2 w 10 3 w 8 5 r ``` This file demonstrates multiple batches of reads and writes, separated by lines containing `p`. ### Requirements for `execute_operations_from_file` 1. **Parsing**: * Open and read the file at `file_path`. * Split the contents into batches using `p` / `P` lines as separators. * Within each batch, parse each operation line into an internal representation that captures: operation type (read/write), register index, value (for writes), and for Level 2, the optional dependency on another line within the same batch. 2. **Scheduling**: * Using a logical time in milliseconds, compute a valid schedule that assigns a **start time** to each operation such that: * Only one operation executes at any given time. * There is at least 1 ms between the start times of consecutive operations. * No read of a register occurs within 10 ms of a previous write to the same register. * All operations in batch `k` finish before any operation in batch `k+1` begins. * For Level 2, each dependent read occurs **after** its referenced operation line in the same batch. 3. **Execution**: * Invoke `write_reg` and `read_reg` according to the order implied by your schedule. * You do not need to actually sleep or delay in real time; the logical schedule is sufficient. 4. **Return Value**: * `execute_operations_from_file` does not need to return any value; its effect is the sequence of calls to `read_reg` and `write_reg` executed in a constraint-satisfying order.

Schedule batched register operations optimally