Deprecate --gfe2_reloadable_flag_quic_packet_creator_prefetch.

net/quic/quic_packet_creator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_packet_creator.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
@@ skipping 329 matching lines @@
                                      size_t iov_offset,
                                      size_t length,
                                      char* buffer) {
   int iovnum = 0;
   while (iovnum < iov.iov_count && iov_offset >= iov.iov[iovnum].iov_len) {
     iov_offset -= iov.iov[iovnum].iov_len;
     ++iovnum;
   }
   DCHECK_LE(iovnum, iov.iov_count);
   DCHECK_LE(iov_offset, iov.iov[iovnum].iov_len);
-  if (FLAGS_quic_packet_creator_prefetch) {
-    if (iovnum >= iov.iov_count || length == 0) {
-      return;
+  if (iovnum >= iov.iov_count || length == 0) {
+    return;
+  }
+
+  // Unroll the first iteration that handles iov_offset.
+  const size_t iov_available = iov.iov[iovnum].iov_len - iov_offset;
+  size_t copy_len = min(length, iov_available);
+
+  // Try to prefetch the next iov if there is at least one more after the
+  // current. Otherwise, it looks like an irregular access that the hardware
+  // prefetcher won't speculatively prefetch. Only prefetch one iov because
+  // generally, the iov_offset is not 0, input iov consists of 2K buffers and
+  // the output buffer is ~1.4K.
+  if (copy_len == iov_available && iovnum + 1 < iov.iov_count) {
+    // TODO(ckrasic) - this is unused without prefetch()
+    // char* next_base = static_cast<char*>(iov.iov[iovnum + 1].iov_base);
+    // char* next_base = static_cast<char*>(iov.iov[iovnum + 1].iov_base);
+    // Prefetch 2 cachelines worth of data to get the prefetcher started; leave
+    // it to the hardware prefetcher after that.
+    // TODO(ckrasic) - investigate what to do about prefetch directives.
+    // prefetch(next_base, PREFETCH_HINT_T0);
+    if (iov.iov[iovnum + 1].iov_len >= 64) {
+      // TODO(ckrasic) - investigate what to do about prefetch directives.
+      // prefetch(next_base + CACHELINE_SIZE, PREFETCH_HINT_T0);
     }
+  }
 
-    // Unroll the first iteration that handles iov_offset.
-    const size_t iov_available = iov.iov[iovnum].iov_len - iov_offset;
-    size_t copy_len = min(length, iov_available);
-
-    // Try to prefetch the next iov if there is at least one more after the
-    // current. Otherwise, it looks like an irregular access that the hardware
-    // prefetcher won't speculatively prefetch. Only prefetch one iov because
-    // generally, the iov_offset is not 0, input iov consists of 2K buffers and
-    // the output buffer is ~1.4K.
-    if (copy_len == iov_available && iovnum + 1 < iov.iov_count) {
-      // TODO(ckrasic) - this is unused without prefetch()
-      // char* next_base = static_cast<char*>(iov.iov[iovnum + 1].iov_base);
-      // Prefetch 2 cachelines worth of data to get the prefetcher started;
-      // leave it to the hardware prefetcher after that.
-      // TODO(ckrasic) - investigate what to do about prefetch directives.
-      // prefetch(next_base, PREFETCH_HINT_T0);
-      if (iov.iov[iovnum + 1].iov_len >= 64) {
-        // TODO(ckrasic) - investigate what to do about prefetch directives.
-        // prefetch(next_base + CACHELINE_SIZE, PREFETCH_HINT_T0);
-      }
+  const char* src = static_cast<char*>(iov.iov[iovnum].iov_base) + iov_offset;
+  while (true) {
+    memcpy(buffer, src, copy_len);
+    length -= copy_len;
+    buffer += copy_len;
+    if (length == 0 || ++iovnum >= iov.iov_count) {
+      break;
     }
-
-    const char* src = static_cast<char*>(iov.iov[iovnum].iov_base) + iov_offset;
-    while (true) {
-      memcpy(buffer, src, copy_len);
-      length -= copy_len;
-      buffer += copy_len;
-      if (length == 0 || ++iovnum >= iov.iov_count) {
-        break;
-      }
-      src = static_cast<char*>(iov.iov[iovnum].iov_base);
-      copy_len = min(length, iov.iov[iovnum].iov_len);
-    }
-  } else {
-    while (iovnum < iov.iov_count && length > 0) {
-      const size_t copy_len = min(length, iov.iov[iovnum].iov_len - iov_offset);
-      memcpy(buffer, static_cast<char*>(iov.iov[iovnum].iov_base) + iov_offset,
-             copy_len);
-      iov_offset = 0;
-      length -= copy_len;
-      buffer += copy_len;
-      ++iovnum;
-    }
+    src = static_cast<char*>(iov.iov[iovnum].iov_base);
+    copy_len = min(length, iov.iov[iovnum].iov_len);
   }
   LOG_IF(DFATAL, length > 0) << "Failed to copy entire length to buffer.";
 }
 
 SerializedPacket QuicPacketCreator::ReserializeAllFrames(
     const RetransmittableFrames& frames,
     EncryptionLevel original_encryption_level,
     QuicPacketNumberLength original_length,
     char* buffer,
     size_t buffer_len) {
@@ skipping 409 matching lines @@
   hash_map<QuicPathId, QuicPacketNumber>::iterator it =
       multipath_packet_number_.find(path_id);
   // If path_id is not in the map, it's a new path. Set packet_number to 0.
   packet_number_ = it == multipath_packet_number_.end() ? 0 : it->second;
   current_path_ = path_id;
   // Switching path needs to update packet number length.
   UpdatePacketNumberLength(least_packet_awaited_by_peer, max_packets_in_flight);
 }
 
 }  // namespace net