docs: public long getNextUniqueTransactionId() {
          // get the current time, usually the salt value is zero
          // in testing it is used to simulate clock skew
          long currentTime = m_clock.get() + m_timestampTestingSalt;
          if (currentTime == lastUsedTime) {
              // increment the counter for this millisecond
              counterValue++;
  
              // handle the case where we've run out of counter values
              // for this particular millisecond (feels unlikely)
              if (counterValue > COUNTER_MAX_VALUE) {
                  // spin until the next millisecond
                  while (currentTime == lastUsedTime) {
                      currentTime = m_clock.get();
                  }
                  // reset the counter and lastUsedTime for the new millisecond
                  lastUsedTime = currentTime;
                  counterValue = 0;
              }
          }
          else {
              // reset the counter and lastUsedTime for the new millisecond
              if (currentTime < lastUsedTime) {
                  VoltLogger log = new VoltLogger("HOST");
                  double diffSeconds = (lastUsedTime - currentTime) / 1000.0;
                  String msg = String.format("Initiator time moved backwards from: %d to %d, a difference of %.2f seconds.",
                          lastUsedTime, currentTime, diffSeconds);
                  log.error(msg);
                  System.err.println(msg);
                  // if the diff is less than some specified amount of time, wait a bit
                  if ((lastUsedTime - currentTime) < BACKWARD_TIME_FORGIVENESS_WINDOW_MS) {
                      log.info("This node will delay any stored procedures sent to it.");
                      log.info(String.format("This node will resume full operation in  %.2f seconds.", diffSeconds));
  
                      long count = BACKWARD_TIME_FORGIVENESS_WINDOW_MS;
                      // note, the loop should stop once lastUsedTime is PASSED, not current
                      while ((currentTime <= lastUsedTime) && (count-- > 0)) {
                          try {
                              m_clock.sleep(1);
                          } catch (InterruptedException e) {}
                          currentTime = m_clock.get();
                      }
                      // if the loop above ended because it ran too much
                      if (count < 0) {
                          org.voltdb.VoltDB.crashLocalVoltDB(
                                "VoltDB was unable to recover after the system time was externally negatively adusted. " +
                                 "It is possible that there is a serious system time or NTP error. ", false, null);
                      }
                  }
                  // crash immediately if time has gone backwards by too much
                  else {
                      org.voltdb.VoltDB.crashLocalVoltDB(
                              String.format("%.2f is larger than the max allowable number of seconds that " +
                                      "the clock can be negatively adjusted (%d)",
                                  diffSeconds, BACKWARD_TIME_FORGIVENESS_WINDOW_MS / 1000), false, null);
                  }
              }
              lastUsedTime = currentTime;
              counterValue = 0;
          }
  
          lastTxnId = makeIdFromComponents(currentTime, counterValue, initiatorId);
  
          return lastTxnId;
      }