CANParser: optimize data handling by eliminating data copy after Update()

[deanlee]

This pull request removes unnecessary data copying from MessageState to dictionaries following update() calls. By encapsulating MessageState within a Cython object and implementing a read-only dictionary for direct access to the signal data, we eliminate the need to clear vl_all and copy updated data to vl, vl_all and ts_nanos. This optimization yields approximately a 1x performance improvement on the 3X device.

With this refactor, the impact on dictionary read performance is negligible, as the read-only dictionary is a minimal wrapper around the C++ MessageState, allowing direct access to data from the C++ unordered_map without additional overhead.

Passes tests on the device and OpenPilot branch #33926.

Key Changes:

1. Encapsulated MessageState in a Cython Class: Enables direct access to signal data from the C++ MessageState, eliminating the need for data copying after update().
2. Implemented a Custom ReadOnlyDict: Overrides __getitem__ to retrieve data from C++ MessageState, ensuring read-only access.
3. Adjusted test_checksum.py: Removed deep copy requirements as the new implementation is read-only.

Below is the benchmark comparison on the 3X device:

Benchmark (PR):

6000 CAN packets, 10 runs
265.55 mean ms, 267.66 max ms, 264.63 min ms, 0.86 std ms
0.0443 mean ms / CAN packet

Benchmark (Master):

6000 CAN packets, 10 runs
491.51 mean ms, 492.63 max ms, 490.43 min ms, 0.71 std ms
0.0819 mean ms / CAN packet

---

This PR is an improved version of #1046

[deanlee]

After this, only one bottleneck remains: the conversion related to can_capnp_to_can_list_cpp. By using a NumPy array, the existing multi-step conversion:

capnp string -> vector[CanData] -> Python list -> vector[CanData]

can be streamlined into a single step:

capnp string -> NumPy array.

This would allow CanParser updates to be executed almost entirely in C++ code, with Cython serving as a simple wrapper for the C++ function, as shown below:

def update_strings(self, np.ndarray[uint8_t, ndim=1, mode="c"] byte_array, sendcan=False):
   cdef uint8_t[::1] arr_memview = byte_array
   return self.can.update(&arr_memview[0], byte_array.shape[0])
   

In my local draft, this optimization has the potential to double performance, reducing the processing time from 0.0443 ms per CAN packet to 0.0202 ms per CAN packet.

It’s important to note that using a NumPy array is just one option. Other alternatives may also be worth exploring.

[sshane]

Any way we can get by with ReadonlyDict?

[deanlee]

how about ebf4696

[sshane]

This brings down Bronco card CPU usage from 28% to 21%!

[deanlee]

This brings down Bronco card CPU usage from 28% to 21%!

by the way, I've also eliminate the multiple conversions from capnp can data to vector[CanFrame] while call CanParser.update. I'll test and submit soon. With this PR and the conversion simplification, CanParser and can_capnp_to_list will run entirely in C++ at full speed—extremely fast!

[update]: submitted: #1452