Copa congestion control: in-tree or BPF struct_ops?

Hi,

I'm considering implementing Copa congestion control for Linux TCP, and
wanted to check whether an in-tree implementation would make sense before
doing the work.

As far as I can tell, there is no in-tree Copa implementation in mainline
Linux today. Copa has been implemented using CCP, with an out-of-tree Linux
kernel datapath and the congestion-control logic running through CCP. There
is also a Copa implementation in mvfst for QUIC.

Meta evaluated Copa with QUIC on Facebook Live at scale. Their initial
deployment used a fixed delta without Copa's competitive mode, and they
reported lower latency than CUBIC together with good goodput results.

I don't see anything obviously missing from tcp_congestion_ops that would
prevent a native implementation. Copa needs RTT history for its RTTmin and
RTTstanding estimates, pacing, and per-flow state for delta and competitive
mode. BBR already maintains its own min-RTT state and controls the pacing
rate, so these parts seem possible with the existing TCP congestion-control
interface.

On the other hand, the real-world Copa use I can find is mostly in
userspace QUIC rather than Linux TCP. BPF struct_ops also supports
tcp_congestion_ops, including cong_control, so perhaps that is a better
place for an algorithm like this initially.

Would an in-tree Copa implementation be worth submitting, or would you
rather see it implemented using BPF struct_ops?

If an in-tree implementation is reasonable, what kind of evaluation would
you want to see with it? I can compare it with CUBIC and BBR across
different RTTs and buffer sizes, and test coexistence with CUBIC and
variable-rate paths. I'd rather focus on the cases that would matter for
review.

Some references I looked at:

Copa paper:
https://www.usenix.org/conference/nsdi18/presentation/arun

Copa over CCP:
https://github.com/venkatarun95/ccp_copa
https://github.com/ccp-project/ccp-kernel

Meta's Copa/QUIC evaluation:
https://engineering.fb.com/2019/11/17/video-engineering/copa/

Current Linux TCP BPF struct_ops implementation:
https://github.com/torvalds/linux/blob/master/net/ipv4/bpf_tcp_ca.c

BBR implementation for comparison:
https://github.com/torvalds/linux/blob/master/net/ipv4/tcp_bbr.c

Thanks,
Ali