Performance logging and counters:

* Tally and duration counters for Job Queue tasks and RPC calls
    optionally rendered by server_info and server_state, and
    optionally printed to a distinct log file.
    - Tally each Job Queue task as it is queued, starts, and
      finishes running. Track total duration queued and running.
    - Tally each RPC call as it starts and either finishes
      successfully or throws an exception. Track total running
      duration for each.
  * Track currently executing Job Queue tasks and RPC methods
    along with durations.
  * Json-formatted performance log file written by a dedicated
    thread, for above-described data.
  * New optional parameter, "counters", for server_info and
    server_state. If set, render Job Queue and RPC call counters
    as well as currently executing tasks.
  * New configuration section, "[perf]", to optionally control
    performance logging to a file.
  * Support optional sub-second periods when rendering human-readable
    time points.

src/ripple/core/impl/Workers.cpp

@@ -18,6 +18,7 @@
 //==============================================================================
 
 #include <ripple/core/impl/Workers.h>
+#include <ripple/basics/PerfLog.h>
 #include <ripple/beast/core/CurrentThreadName.h>
 #include <cassert>
 
@@ -25,9 +26,11 @@ namespace ripple {
 
 Workers::Workers (
     Callback& callback,
+    perf::PerfLog& perfLog,
     std::string const& threadNames,
     int numberOfThreads)
         : m_callback (callback)
+        , perfLog_ (perfLog)
         , m_threadNames (threadNames)
         , m_allPaused (true, true)
         , m_semaphore (0)
@@ -57,12 +60,14 @@ int Workers::getNumberOfThreads () const noexcept
 //
 void Workers::setNumberOfThreads (int numberOfThreads)
 {
+    static int instance {0};
     if (m_numberOfThreads != numberOfThreads)
     {
+        perfLog_.resizeJobs(numberOfThreads);
+
         if (numberOfThreads > m_numberOfThreads)
         {
             // Increasing the number of working threads
-
             int const amount = numberOfThreads - m_numberOfThreads;
 
             for (int i = 0; i < amount; ++i)
@@ -79,15 +84,14 @@ void Workers::setNumberOfThreads (int numberOfThreads)
                 }
                 else
                 {
-                    worker = new Worker (*this, m_threadNames);
+                    worker = new Worker (*this, m_threadNames, instance++);
                     m_everyone.push_front (worker);
                 }
             }
         }
-        else if (numberOfThreads < m_numberOfThreads)
+        else
         {
             // Decreasing the number of working threads
-
             int const amount = m_numberOfThreads - numberOfThreads;
 
             for (int i = 0; i < amount; ++i)
@@ -142,9 +146,11 @@ void Workers::deleteWorkers (beast::LockFreeStack <Worker>& stack)
 
 //------------------------------------------------------------------------------
 
-Workers::Worker::Worker (Workers& workers, std::string const& threadName)
+Workers::Worker::Worker (Workers& workers, std::string const& threadName,
+    int const instance)
     : m_workers {workers}
     , threadName_ {threadName}
+    , instance_ {instance}
     , wakeCount_ {0}
     , shouldExit_ {false}
 {
@@ -216,7 +222,7 @@ void Workers::Worker::run ()
             // unblocked in order to process a task.
             //
             ++m_workers.m_runningTaskCount;
-            m_workers.m_callback.processTask ();
+            m_workers.m_callback.processTask (instance_);
             --m_workers.m_runningTaskCount;
         }