use split_to instead of cloning

quinn-proto/src/connection/mod.rs

@@ -482,7 +482,6 @@ impl Connection {
                     SpaceId::Data,
                     "PATH_CHALLENGE queued without 1-RTT keys"
                 );
-
                 buf.reserve(self.path.current_mtu() as usize);
 
                 let buf_capacity = buf.capacity();
@@ -686,7 +685,7 @@ impl Connection {
                     // (e.g. purely containing ACKs), modern memory allocators
                     // (e.g. mimalloc and jemalloc) will pool certain allocation sizes
                     // and therefore this is still rather efficient.
-                    buf.reserve(max_datagrams * self.path.current_mtu() as usize - buf.capacity());
+                    buf.reserve(max_datagrams * self.path.current_mtu() as usize);
                 }
                 num_datagrams += 1;
                 coalesce = true;

quinn-proto/src/tests/util.rs

@@ -353,9 +353,9 @@ impl TestEndpoint {
                         self.conn_events.entry(ch).or_default().push_back(event);
                     }
                     DatagramEvent::Response(transmit) => {
+                        let size = transmit.size;
                         self.outbound
-                            .extend(split_transmit(transmit, buf.clone().freeze()));
-                        buf.clear();
+                            .extend(split_transmit(transmit, buf.split_to(size).freeze()));
                     }
                 }
             }
@@ -378,10 +378,10 @@ impl TestEndpoint {
                 while let Some(event) = conn.poll_endpoint_events() {
                     endpoint_events.push((*ch, event));
                 }
-                while let Some(x) = conn.poll_transmit(now, MAX_DATAGRAMS, &mut buf) {
+                while let Some(transmit) = conn.poll_transmit(now, MAX_DATAGRAMS, &mut buf) {
+                    let size = transmit.size;
                     self.outbound
-                        .extend(split_transmit(x, buf.clone().freeze()));
-                    buf.clear();
+                        .extend(split_transmit(transmit, buf.split_to(size).freeze()));
                 }
                 self.timeout = conn.poll_timeout();
             }

quinn/src/connection.rs

@@ -879,7 +879,6 @@ impl State {
                 // See https://github.com/quinn-rs/quinn/issues/1126
                 return true;
             }
-            buffer.clear();
         }
 
         false

quinn/src/endpoint.rs

@@ -444,17 +444,19 @@ impl State {
                                         .unwrap()
                                         .send(ConnectionEvent::Proto(event));
                                 }
-                                Some(DatagramEvent::Response(t)) => {
+                                Some(DatagramEvent::Response(transmit)) => {
                                     // Limiting the memory usage for items queued in the outgoing queue from endpoint
                                     // generated packets. Otherwise, we may see a build-up of the queue under test with
                                     // flood of initial packets against the endpoint. The sender with the sender-limiter
                                     // may not keep up the pace of these packets queued into the queue.
                                     if self.transmit_queue_contents_len
                                         < MAX_TRANSMIT_QUEUE_CONTENTS_LEN
                                     {
-                                        let contents_len = buffer.len();
-                                        self.outgoing
-                                            .push_back(udp_transmit(t, buffer.clone().freeze()));
+                                        let contents_len = transmit.size;
+                                        self.outgoing.push_back(udp_transmit(
+                                            transmit,
+                                            buffer.split_to(contents_len).freeze(),
+                                        ));
                                         self.transmit_queue_contents_len = self
                                             .transmit_queue_contents_len
                                             .saturating_add(contents_len);