Remove usages of TimeValue from gdb-remote process plugin

[labath]

Summary

Most of the changes are very straight-forward, the only tricky part was the
"packet speed-test" function, which is very time-heavy. As the function was
completely untested, I added a quick unit smoke test for it.

[labath]

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2144 ↗

(On Diff #74013)

First function I'd like to stash somewhere.

[zturner]

source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

192 ↗

(On Diff #74013)

using namespace std is generally frowned upon, but I wonder if we could be more lenient about using namespace std::chrono? Would make a lot of those code easier on the eyes.

193–194 ↗

(On Diff #74013)

Why do you need the duration_cast here? Can't you just pass in the result of GetPacketTimeout(), where GetPacketTimeout() is updated to return a std::chrono::duration<int>?

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

266–267 ↗

(On Diff #74013)

Same here. You should just be able to pass the duration straight through, and update ReadPacket to do the cast.

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

86 ↗

(On Diff #74013)

To make this more generic, this could be a std::chrono::duration<int>. If for any reason someone wanted 3.2 seconds, they could then specify it.

[labath]

source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

192 ↗

(On Diff #74013)

I started using it in some tighter scopes, which are chrono-heavy. I'd be fine with the using directive at file level though.

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

266–267 ↗

(On Diff #74013)

These should go away, when everything is updated to use chrono, but the hierarchy there is multiple levels deep, so I cannot do it in a single pass (ReadPacket just calls WaitForPacketWithTimeoutMicroSecondsNoLock, which would also need to be updated... the real cast should only happen somewhere in the Connection classes, once you actually start issuing system calls).

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

86 ↗

(On Diff #74013)

I don't think that works the way you think it does. If you don't specify the ratio template argument, it will just get defaulted to std::ratio<1>, meaning seconds. To have it generic you'd have to make this a template function, with the ratio as the parameter, but at that point you might as well just choose a type with the highest precision you are willing to accept. So, I could make this take a milli or micro second durations, but I don't think that's necessary for a packet timeout.

[labath]

Clean up the code a bit now that I have learned better how to use the chrono library.

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

if (log)
     log->Printf(
         "PlatformRemoteGDBServer::%s() set launch architecture triple to '%s'",
         __FUNCTION__, arch_triple ? arch_triple : "<NULL>");
 
   int arg_packet_err;
   {
     // Scope for the scoped timeout object
     process_gdb_remote::GDBRemoteCommunication::ScopedTimeout timeout(
-        m_gdb_client, 5);
+        m_gdb_client, std::chrono::seconds(5));
     arg_packet_err = m_gdb_client.SendArgumentsPacket(launch_info);
   }
 
   if (arg_packet_err == 0) {
     std::string error_str;
     if (m_gdb_client.GetLaunchSuccess(error_str)) {
       const auto pid = m_gdb_client.GetCurrentProcessID(false);
       if (pid != LLDB_INVALID_PROCESS_ID) {

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

 GDBRemoteClientBase::SendPacketAndWaitForResponseNoLock(
     llvm::StringRef payload, StringExtractorGDBRemote &response) {
   PacketResult packet_result = SendPacketNoLock(payload);
   if (packet_result != PacketResult::Success)
     return packet_result;
 
   const size_t max_response_retries = 3;
   for (size_t i = 0; i < max_response_retries; ++i) {
-    packet_result =
-        ReadPacket(response, GetPacketTimeoutInMicroSeconds(), true);
+    packet_result = ReadPacket(
+        response, std::chrono::duration_cast<std::chrono::microseconds>(
+                      GetPacketTimeout())
+                      .count(),
+        true);
     // Make sure we received a response
     if (packet_result != PacketResult::Success)
       return packet_result;
     // Make sure our response is valid for the payload that was sent
     if (response.ValidateResponse())
       return packet_result;
     // Response says it wasn't valid
     Log *log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS);

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h

 #include <vector>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Communication.h"
 #include "lldb/Core/Listener.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/Predicate.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/lldb-public.h"
 
 #include "Utility/StringExtractorGDBRemote.h"
 
 namespace lldb_private {
 namespace process_gdb_remote {
 
ErrorNoSequenceLock // We couldn't get the sequence lock for a multi-packet
                         // request
   };
 
   // Class to change the timeout for a given scope and restore it to the
   // original value when the
   // created ScopedTimeout object got out of scope
   class ScopedTimeout {
   public:
-    ScopedTimeout(GDBRemoteCommunication &gdb_comm, uint32_t timeout);
+    ScopedTimeout(GDBRemoteCommunication &gdb_comm,
+                  std::chrono::seconds timeout);
     ~ScopedTimeout();
 
   private:
     GDBRemoteCommunication &m_gdb_comm;
-    uint32_t m_saved_timeout;
+    std::chrono::seconds m_saved_timeout;
   };
 
   GDBRemoteCommunication(const char *comm_name, const char *listener_name);
 
   ~GDBRemoteCommunication() override;
 
   PacketResult GetAck();
 
   size_t SendAck();
 
   size_t SendNack();
 
   char CalculcateChecksum(llvm::StringRef payload);
 
   PacketType CheckForPacket(const uint8_t *src, size_t src_len,
                             StringExtractorGDBRemote &packet);
 
   bool GetSendAcks() { return m_send_acks; }
 
   //------------------------------------------------------------------
   // Set the global packet timeout.
   //
   // For clients, this is the timeout that gets used when sending
-  // packets and waiting for responses. For servers, this might not
-  // get used, and if it doesn't this should be moved to the
-  // GDBRemoteCommunicationClient.
+  // packets and waiting for responses. For servers, this is used when waiting
+  // for ACKs.
   //------------------------------------------------------------------
-  uint32_t SetPacketTimeout(uint32_t packet_timeout) {
-    const uint32_t old_packet_timeout = m_packet_timeout;
+  std::chrono::seconds SetPacketTimeout(std::chrono::seconds packet_timeout) {
+    const auto old_packet_timeout = m_packet_timeout;
     m_packet_timeout = packet_timeout;
     return old_packet_timeout;
   }
 
-  uint32_t GetPacketTimeoutInMicroSeconds() const {
-    return m_packet_timeout * TimeValue::MicroSecPerSec;
-  }
+  std::chrono::seconds GetPacketTimeout() const { return m_packet_timeout; }
 
   //------------------------------------------------------------------
   // Start a debugserver instance on the current host using the
   // supplied connection URL.
   //------------------------------------------------------------------
   Error StartDebugserverProcess(
       const char *url,
       Platform *platform, // If non nullptr, then check with the platform for
protected:
     uint32_t NormalizeIndex(uint32_t i) const { return i % m_packets.size(); }
 
     std::vector<Entry> m_packets;
     uint32_t m_curr_idx;
     uint32_t m_total_packet_count;
     mutable bool m_dumped_to_log;
   };
 
-  uint32_t m_packet_timeout;
+  std::chrono::seconds m_packet_timeout;
   uint32_t m_echo_number;
   LazyBool m_supports_qEcho;
   History m_history;
   bool m_send_acks;
   bool m_is_platform; // Set to true if this class represents a platform,
                       // false if this class represents a debug session for
                       // a single process
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/Pipe.h"
 #include "lldb/Host/Socket.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 
if (bytes_written == packet_length) {
                     packet_data);
     }
   }
   return PacketResult::ErrorSendFailed;
 }
 
 GDBRemoteCommunication::PacketResult GDBRemoteCommunication::GetAck() {
   StringExtractorGDBRemote packet;
-  PacketResult result =
-      ReadPacket(packet, GetPacketTimeoutInMicroSeconds(), false);
+  PacketResult result = ReadPacket(
+      packet,
+      std::chrono::duration_cast<std::chrono::microseconds>(GetPacketTimeout())
+          .count(),
+      false);
   if (result == PacketResult::Success) {
     if (packet.GetResponseType() ==
         StringExtractorGDBRemote::ResponseType::eAck)
       return PacketResult::Success;
     else
       return PacketResult::ErrorSendAck;
   }
   return result;
#endif
   }
 
   return error;
 }
 
 void GDBRemoteCommunication::DumpHistory(Stream &strm) { m_history.Dump(strm); }
 
 GDBRemoteCommunication::ScopedTimeout::ScopedTimeout(
-    GDBRemoteCommunication &gdb_comm, uint32_t timeout)
+    GDBRemoteCommunication &gdb_comm, std::chrono::seconds timeout)
     : m_gdb_comm(gdb_comm) {
   m_saved_timeout = m_gdb_comm.SetPacketTimeout(timeout);
 }
 
 GDBRemoteCommunication::ScopedTimeout::~ScopedTimeout() {
   m_gdb_comm.SetPacketTimeout(m_saved_timeout);
 }
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   Error GetWatchpointSupportInfo(uint32_t &num, bool &after,
                                  const ArchSpec &arch);
 
   Error GetWatchpointsTriggerAfterInstruction(bool &after,
                                               const ArchSpec &arch);
 
   const ArchSpec &GetHostArchitecture();
 
-  uint32_t GetHostDefaultPacketTimeout();
+  std::chrono::seconds GetHostDefaultPacketTimeout();
 
   const ArchSpec &GetProcessArchitecture();
 
   void GetRemoteQSupported();
 
   bool GetVContSupported(char flavor);
 
   bool GetpPacketSupported(lldb::tid_t tid);
protected:
   uint32_t m_os_version_update;
   std::string m_os_build;
   std::string m_os_kernel;
   std::string m_hostname;
   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
                                  // qGDBServerVersion is not supported
   uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if
                                  // qGDBServerVersion is not supported
-  uint32_t m_default_packet_timeout;
+  std::chrono::seconds m_default_packet_timeout;
   uint64_t m_max_packet_size;        // as returned by qSupported
   std::string m_qSupported_response; // the complete response to qSupported
 
   bool m_supported_async_json_packets_is_valid;
   lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;
 
   bool GetCurrentProcessInfo(bool allow_lazy_pid = true);
 

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamGDBRemote.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"
 
if (m_supports_not_sending_acks == eLazyBoolCalculate) {
     m_send_acks = true;
     m_supports_not_sending_acks = eLazyBoolNo;
 
     // This is the first real packet that we'll send in a debug session and it
     // may take a little
     // longer than normal to receive a reply.  Wait at least 6 seconds for a
     // reply to this packet.
 
-    const uint32_t minimum_timeout = 6;
-    uint32_t old_timeout = GetPacketTimeoutInMicroSeconds() /
-                           lldb_private::TimeValue::MicroSecPerSec;
-    GDBRemoteCommunication::ScopedTimeout timeout(
-        *this, std::max(old_timeout, minimum_timeout));
+    ScopedTimeout timeout(
+        *this, std::max(GetPacketTimeout(), std::chrono::seconds(6)));
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("QStartNoAckMode", response, false) ==
         PacketResult::Success) {
       if (response.IsOKResponse()) {
         m_send_acks = false;
         m_supports_not_sending_acks = eLazyBoolYes;
       }
if (did_exec == false) {
     m_os_version_major = UINT32_MAX;
     m_os_version_minor = UINT32_MAX;
     m_os_version_update = UINT32_MAX;
     m_os_build.clear();
     m_os_kernel.clear();
     m_hostname.clear();
     m_gdb_server_name.clear();
     m_gdb_server_version = UINT32_MAX;
-    m_default_packet_timeout = 0;
+    m_default_packet_timeout = std::chrono::seconds(0);
     m_max_packet_size = 0;
     m_qSupported_response.clear();
     m_supported_async_json_packets_is_valid = false;
     m_supported_async_json_packets_sp.reset();
     m_supports_jModulesInfo = true;
   }
 
   // These flags should be reset when we first connect to a GDB server
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
             m_watchpoints_trigger_after_instruction =
                 llvm::StringSwitch<LazyBool>(value)
                     .Case("before", eLazyBoolNo)
                     .Case("after", eLazyBoolYes)
                     .Default(eLazyBoolCalculate);
             if (m_watchpoints_trigger_after_instruction != eLazyBoolCalculate)
               ++num_keys_decoded;
           } else if (name.equals("default_packet_timeout")) {
-            if (!value.getAsInteger(0, m_default_packet_timeout)) {
+            uint32_t timeout_seconds;
+            if (!value.getAsInteger(0, timeout_seconds)) {
+              m_default_packet_timeout = std::chrono::seconds(timeout_seconds);
               SetPacketTimeout(m_default_packet_timeout);
               ++num_keys_decoded;
             }
           }
         }
 
         if (num_keys_decoded > 0)
           m_qHostInfo_is_valid = eLazyBoolYes;

 
 const lldb_private::ArchSpec &
 GDBRemoteCommunicationClient::GetHostArchitecture() {
   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
     GetHostInfo();
   return m_host_arch;
 }
 
-uint32_t GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() {
+std::chrono::seconds
+GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() {
   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
     GetHostInfo();
   return m_default_packet_timeout;
 }
 
 addr_t GDBRemoteCommunicationClient::AllocateMemory(size_t size,
                                                     uint32_t permissions) {
   if (m_supports_alloc_dealloc_memory != eLazyBoolNo) {
if (!match_info.MatchAllProcesses()) {
         packet.PutCString("triple:");
         packet.PutCString(triple.getTriple().c_str());
         packet.PutChar(';');
       }
     }
     StringExtractorGDBRemote response;
     // Increase timeout as the first qfProcessInfo packet takes a long time
     // on Android. The value of 1min was arrived at empirically.
-    GDBRemoteCommunication::ScopedTimeout timeout(*this, 60);
+    ScopedTimeout timeout(*this, std::chrono::seconds(60));
     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
         PacketResult::Success) {
       do {
         ProcessInstanceInfo process_info;
         if (!DecodeProcessInfoResponse(response, process_info))
           break;
         process_infos.Append(process_info);
         response.GetStringRef().clear();
while (bytes_left > 0) {
     } else {
       packet.Printf("%*.*s;", bytes_left, bytes_left,
                     "abcdefghijklmnopqrstuvwxyz");
       bytes_left = 0;
     }
   }
 }
 
-template <typename T> T calculate_standard_deviation(const std::vector<T> &v) {
-  T sum = std::accumulate(std::begin(v), std::end(v), T(0));
-  T mean = sum / (T)v.size();
-  T accum = T(0);
-  std::for_each(std::begin(v), std::end(v), [&](const T d) {
-    T delta = d - mean;
+std::chrono::duration<float> calculate_standard_deviation(
+    const std::vector<std::chrono::duration<float>> &v) {
+  using Dur = std::chrono::duration<float>;
+  Dur sum = std::accumulate(std::begin(v), std::end(v), Dur());
+  Dur mean = sum / v.size();
+  float accum = 0;
+  for (auto d : v) {
+    float delta = (d - mean).count();
     accum += delta * delta;
-  });
+  };
 
-  T stdev = sqrt(accum / (v.size() - 1));
-  return stdev;
+  return Dur(sqrtf(accum / (v.size() - 1)));
 }
 
 void GDBRemoteCommunicationClient::TestPacketSpeed(const uint32_t num_packets,
                                                    uint32_t max_send,
                                                    uint32_t max_recv, bool json,
                                                    Stream &strm) {
+  using namespace std::chrono;
+
   uint32_t i;
-  TimeValue start_time, end_time;
-  uint64_t total_time_nsec;
   if (SendSpeedTestPacket(0, 0)) {
     StreamString packet;
     if (json)
       strm.Printf("{ \"packet_speeds\" : {\n    \"num_packets\" : %u,\n    "
                   "\"results\" : [",
                   num_packets);
     else
       strm.Printf("Testing sending %u packets of various sizes:\n",
                   num_packets);
     strm.Flush();
 
     uint32_t result_idx = 0;
     uint32_t send_size;
-    std::vector<float> packet_times;
+    std::vector<duration<float>> packet_times;
 
     for (send_size = 0; send_size <= max_send;
          send_size ? send_size *= 2 : send_size = 4) {
       for (uint32_t recv_size = 0; recv_size <= max_recv;
            recv_size ? recv_size *= 2 : recv_size = 4) {
         MakeSpeedTestPacket(packet, send_size, recv_size);
 
         packet_times.clear();
         // Test how long it takes to send 'num_packets' packets
-        start_time = TimeValue::Now();
+        const auto start_time = steady_clock::now();
         for (i = 0; i < num_packets; ++i) {
-          TimeValue packet_start_time = TimeValue::Now();
+          const auto packet_start_time = steady_clock::now();
           StringExtractorGDBRemote response;
           SendPacketAndWaitForResponse(packet.GetString(), response, false);
-          TimeValue packet_end_time = TimeValue::Now();
-          uint64_t packet_time_nsec =
-              packet_end_time.GetAsNanoSecondsSinceJan1_1970() -
-              packet_start_time.GetAsNanoSecondsSinceJan1_1970();
-          packet_times.push_back((float)packet_time_nsec);
-        }
-        end_time = TimeValue::Now();
-        total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() -
-                          start_time.GetAsNanoSecondsSinceJan1_1970();
+          const auto packet_end_time = steady_clock::now();
+          packet_times.push_back(packet_end_time - packet_start_time);
+        }
+        const auto end_time = steady_clock::now();
+        const auto total_time = end_time - start_time;
 
         float packets_per_second =
-            (((float)num_packets) / (float)total_time_nsec) *
-            (float)TimeValue::NanoSecPerSec;
-        float total_ms =
-            (float)total_time_nsec / (float)TimeValue::NanoSecPerMilliSec;
-        float average_ms_per_packet = total_ms / num_packets;
-        const float standard_deviation =
-            calculate_standard_deviation<float>(packet_times);
+            ((float)num_packets) / duration<float>(total_time).count();
+        auto average_per_packet = total_time / num_packets;
+        const duration<float> standard_deviation =
+            calculate_standard_deviation(packet_times);
         if (json) {
           strm.Printf("%s\n     {\"send_size\" : %6" PRIu32
                       ", \"recv_size\" : %6" PRIu32
                       ", \"total_time_nsec\" : %12" PRIu64
                       ", \"standard_deviation_nsec\" : %9" PRIu64 " }",
                       result_idx > 0 ? "," : "", send_size, recv_size,
-                      total_time_nsec, (uint64_t)standard_deviation);
+                      duration_cast<nanoseconds>(total_time).count(),
+                      duration_cast<nanoseconds>(standard_deviation).count());
           ++result_idx;
         } else {
           strm.Printf(
-              "qSpeedTest(send=%-7u, recv=%-7u) in %" PRIu64 ".%9.9" PRIu64
+              "qSpeedTest(send=%-7u, recv=%-7u) in %.9f"
               " sec for %9.2f packets/sec (%10.6f ms per packet) with standard "
               "deviation of %10.6f ms\n",
-              send_size, recv_size, total_time_nsec / TimeValue::NanoSecPerSec,
-              total_time_nsec % TimeValue::NanoSecPerSec, packets_per_second,
-              average_ms_per_packet,
-              standard_deviation / (float)TimeValue::NanoSecPerMilliSec);
+              send_size, recv_size, duration<float>(total_time).count(),
+              packets_per_second,
+              duration<float, std::milli>(average_per_packet).count(),
+              duration<float, std::milli>(standard_deviation).count());
         }
         strm.Flush();
       }
     }
 
     const uint64_t k_recv_amount = 4 * 1024 * 1024; // Receive amount in bytes
 
     const float k_recv_amount_mb = (float)k_recv_amount / (1024.0f * 1024.0f);
if (SendSpeedTestPacket(0, 0)) {
     send_size = 0;
     result_idx = 0;
     for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) {
       MakeSpeedTestPacket(packet, send_size, recv_size);
 
       // If we have a receive size, test how long it takes to receive 4MB of
       // data
       if (recv_size > 0) {
-        start_time = TimeValue::Now();
+        const auto start_time = steady_clock::now();
         uint32_t bytes_read = 0;
         uint32_t packet_count = 0;
         while (bytes_read < k_recv_amount) {
           StringExtractorGDBRemote response;
           SendPacketAndWaitForResponse(packet.GetString(), response, false);
           bytes_read += recv_size;
           ++packet_count;
         }
-        end_time = TimeValue::Now();
-        total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() -
-                          start_time.GetAsNanoSecondsSinceJan1_1970();
-        float mb_second = ((((float)k_recv_amount) / (float)total_time_nsec) *
-                           (float)TimeValue::NanoSecPerSec) /
+        const auto end_time = steady_clock::now();
+        const auto total_time = end_time - start_time;
+        float mb_second = ((float)k_recv_amount) /
+                          duration<float>(total_time).count() /
                           (1024.0 * 1024.0);
         float packets_per_second =
-            (((float)packet_count) / (float)total_time_nsec) *
-            (float)TimeValue::NanoSecPerSec;
-        float total_ms =
-            (float)total_time_nsec / (float)TimeValue::NanoSecPerMilliSec;
-        float average_ms_per_packet = total_ms / packet_count;
+            ((float)packet_count) / duration<float>(total_time).count();
+        const auto average_per_packet = total_time / packet_count;
 
         if (json) {
           strm.Printf("%s\n     {\"send_size\" : %6" PRIu32
                       ", \"recv_size\" : %6" PRIu32
                       ", \"total_time_nsec\" : %12" PRIu64 " }",
                       result_idx > 0 ? "," : "", send_size, recv_size,
-                      total_time_nsec);
+                      duration_cast<nanoseconds>(total_time).count());
           ++result_idx;
         } else {
           strm.Printf("qSpeedTest(send=%-7u, recv=%-7u) %6u packets needed to "
-                      "receive %2.1fMB in %" PRIu64 ".%9.9" PRIu64
+                      "receive %2.1fMB in %.9f"
                       " sec for %f MB/sec for %9.2f packets/sec (%10.6f ms per "
                       "packet)\n",
                       send_size, recv_size, packet_count, k_recv_amount_mb,
-                      total_time_nsec / TimeValue::NanoSecPerSec,
-                      total_time_nsec % TimeValue::NanoSecPerSec, mb_second,
-                      packets_per_second, average_ms_per_packet);
+                      duration<float>(total_time).count(), mb_second,
+                      packets_per_second,
+                      duration<float, std::milli>(average_per_packet).count());
         }
         strm.Flush();
       }
     }
     if (json)
       strm.Printf("\n    ]\n  }\n}\n");
     else
       strm.EOL();
if (HostInfo::GetHostname(hostname)) {
       stream.Printf("host:%s;", hostname.c_str());
     } else {
       // Make the GDB server we launch accept connections from any host since we
       // can't figure out the hostname
       stream.Printf("host:*;");
     }
   }
   // give the process a few seconds to startup
-  GDBRemoteCommunication::ScopedTimeout timeout(*this, 10);
+  ScopedTimeout timeout(*this, std::chrono::seconds(10));
 
   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
       PacketResult::Success) {
     llvm::StringRef name;
     llvm::StringRef value;
     while (response.GetNameColonValue(name, value)) {
       if (name.equals("port"))
         value.getAsInteger(0, port);

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/File.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Host/StringConvert.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Target/FileAction.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/JSON.h"
 #include "lldb/Utility/LLDBAssert.h"

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/Host/FileSpec.h"
 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Host/Symbols.h"
 #include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Host/TimeValue.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionGroupBoolean.h"
 #include "lldb/Interpreter/OptionGroupUInt64.h"
if (m_async_listener_sp->StartListeningForEvents(
     if (log)
       log->Printf("ProcessGDBRemote::%s failed to listen for m_gdb_comm events",
                   __FUNCTION__);
   }
 
   const uint64_t timeout_seconds =
       GetGlobalPluginProperties()->GetPacketTimeout();
   if (timeout_seconds > 0)
-    m_gdb_comm.SetPacketTimeout(timeout_seconds);
+    m_gdb_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds));
 }
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 ProcessGDBRemote::~ProcessGDBRemote() {
   //  m_mach_process.UnregisterNotificationCallbacks (this);
   Clear();
void ProcessGDBRemote::BuildDynamicRegisterInfo(bool force) {
   if (!force && m_register_info.GetNumRegisters() > 0)
     return;
 
   m_register_info.Clear();
 
   // Check if qHostInfo specified a specific packet timeout for this connection.
   // If so then lets update our setting so the user knows what the timeout is
   // and can see it.
-  const uint32_t host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
-  if (host_packet_timeout) {
-    GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout);
+  const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
+  if (host_packet_timeout > std::chrono::seconds(0)) {
+    GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout.count());
   }
 
   // Register info search order:
   //     1 - Use the target definition python file if one is specified.
   //     2 - If the target definition doesn't have any of the info from the
   //     target.xml (registers) then proceed to read the target.xml.
   //     3 - Fall back on the qRegisterInfo packets.
 
if (error.Success()) {
           if (env_entry == NULL ||
               m_gdb_comm.SendEnvironmentPacket(env_entry) != 0)
             break;
         }
       }
 
       {
         // Scope for the scoped timeout object
-        GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm, 10);
+        GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
+                                                      std::chrono::seconds(10));
 
         int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
         if (arg_packet_err == 0) {
           std::string error_str;
           if (m_gdb_comm.GetLaunchSuccess(error_str)) {
             SetID(m_gdb_comm.GetCurrentProcessID());
           } else {
             error.SetErrorString(error_str.c_str());
Error ProcessGDBRemote::DoDestroy() {
   // Interrupt if our inferior is running...
   int exit_status = SIGABRT;
   std::string exit_string;
 
   if (m_gdb_comm.IsConnected()) {
     if (m_public_state.GetValue() != eStateAttaching) {
       StringExtractorGDBRemote response;
       bool send_async = true;
-      GDBRemoteCommunication::ScopedTimeout(m_gdb_comm, 3);
+      GDBRemoteCommunication::ScopedTimeout(m_gdb_comm,
+                                            std::chrono::seconds(3));
 
       if (m_gdb_comm.SendPacketAndWaitForResponse("k", response, send_async) ==
           GDBRemoteCommunication::PacketResult::Success) {
         char packet_cmd = response.GetChar(0);
 
         if (packet_cmd == 'W' || packet_cmd == 'X') {
 #if defined(__APPLE__)
           // For Native processes on Mac OS X, we launch through the Host

 
 StructuredData::ObjectSP
 ProcessGDBRemote::GetLoadedDynamicLibrariesInfos_sender(
     StructuredData::ObjectSP args_dict) {
   StructuredData::ObjectSP object_sp;
 
   if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported()) {
     // Scope for the scoped timeout object
-    GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm, 10);
+    GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
+                                                  std::chrono::seconds(10));
 
     StreamString packet;
     packet << "jGetLoadedDynamicLibrariesInfos:";
     args_dict->Dump(packet, false);
 
     // FIXME the final character of a JSON dictionary, '}', is the escape
     // character in gdb-remote binary mode.  lldb currently doesn't escape
     // these characters in its packet output -- so we add the quoted version

lldb/trunk/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

 #endif
 #include <future>
 
 #include "GDBRemoteTestUtils.h"
 
 #include "Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h"
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/StructuredData.h"
 
 #include "llvm/ADT/ArrayRef.h"
 
 using namespace lldb_private::process_gdb_remote;
 using namespace lldb_private;
 using namespace lldb;
+using namespace llvm;
 
 namespace {
 
 typedef GDBRemoteCommunication::PacketResult PacketResult;
 
 struct TestClient : public GDBRemoteCommunicationClient {
   TestClient() { m_send_acks = false; }
 };
 
 void Handle_QThreadSuffixSupported(MockServer &server, bool supported) {
   StringExtractorGDBRemote request;
   ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
   ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef());
   if (supported)
     ASSERT_EQ(PacketResult::Success, server.SendOKResponse());
   else
     ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr));
 }
 
-void HandlePacket(MockServer &server, llvm::StringRef expected,
-                  llvm::StringRef response) {
+void HandlePacket(MockServer &server, StringRef expected, StringRef response) {
   StringExtractorGDBRemote request;
   ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
   ASSERT_EQ(expected, request.GetStringRef());
   ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
 }
 
 uint8_t all_registers[] = {'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
                            'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'};
for (const char *response : invalid_responses) {
     HandlePacket(
         server,
         R"(jModulesInfo:[{"file":"/foo/bar.so","triple":"i386-pc-linux"}])",
         response);
 
     ASSERT_FALSE(async_result.get().hasValue()) << "response was: " << response;
   }
 }
+
+TEST_F(GDBRemoteCommunicationClientTest, TestPacketSpeedJSON) {
+  TestClient client;
+  MockServer server;
+  Connect(client, server);
+  if (HasFailure())
+    return;
+
+  std::thread server_thread([&server] {
+    StringExtractorGDBRemote request;
+    PacketResult result = server.GetPacket(request);
+    if (result == PacketResult::ErrorDisconnected)
+      return;
+    ASSERT_EQ(PacketResult::Success, result);
+    StringRef ref = request.GetStringRef();
+    ASSERT_TRUE(ref.consume_front("qSpeedTest:response_size:"));
+    int size;
+    ASSERT_FALSE(ref.consumeInteger(10, size)) << "ref: " << ref;
+    std::string response(size, 'X');
+    ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
+  });
+
+  StreamString ss;
+  client.TestPacketSpeed(10, 32, 32, true, ss);
+  client.Disconnect();
+  server_thread.join();
+
+  auto object_sp = StructuredData::ParseJSON(ss.GetString());
+  ASSERT_TRUE(bool(object_sp));
+  auto dict_sp = object_sp->GetAsDictionary();
+  ASSERT_TRUE(bool(dict_sp));
+
+  object_sp = dict_sp->GetValueForKey("packet_speeds");
+  ASSERT_TRUE(bool(object_sp));
+  dict_sp = object_sp->GetAsDictionary();
+  ASSERT_TRUE(bool(dict_sp));
+
+  int num_packets;
+  ASSERT_TRUE(dict_sp->GetValueForKeyAsInteger("num_packets", num_packets))
+      << ss.GetString();
+  ASSERT_EQ(10, num_packets);
+}