docs: public void handleIv2InitiateTaskMessage(Iv2InitiateTaskMessage message)
      {
          final String procedureName = message.getStoredProcedureName();
  
          /*
           * If this is CL replay, use the txnid from the CL and use it to update the current txnid
           */
          long mpTxnId;
          //Timestamp is actually a pre-IV2ish style time based transaction id
          long timestamp = Long.MIN_VALUE;
  
          // Update UID if it's for replay
          if (message.isForReplay()) {
              timestamp = message.getUniqueId();
              m_uniqueIdGenerator.updateMostRecentlyGeneratedUniqueId(timestamp);
          } else  {
              timestamp = m_uniqueIdGenerator.getNextUniqueId();
          }
  
          TxnEgo ego = advanceTxnEgo();
          mpTxnId = ego.getTxnId();
  
          final String threadName = Thread.currentThread().getName(); // Thread name has to be materialized here
          final VoltTrace.TraceEventBatch traceLog = VoltTrace.log(VoltTrace.Category.MPI);
          if (traceLog != null) {
              traceLog.add(() -> VoltTrace.meta("process_name", "name", CoreUtils.getHostnameOrAddress()))
                      .add(() -> VoltTrace.meta("thread_name", "name", threadName))
                      .add(() -> VoltTrace.meta("thread_sort_index", "sort_index", Integer.toString(100)))
                      .add(() -> VoltTrace.beginAsync("initmp", mpTxnId,
                                                      "txnId", TxnEgo.txnIdToString(mpTxnId),
                                                      "ciHandle", message.getClientInterfaceHandle(),
                                                      "name", procedureName,
                                                      "read", message.isReadOnly()));
          }
  
          // Don't have an SP HANDLE at the MPI, so fill in the unused value
          Iv2Trace.logIv2InitiateTaskMessage(message, m_mailbox.getHSId(), mpTxnId, Long.MIN_VALUE);
  
          // Handle every-site system procedures (at the MPI)
          final Config sysprocConfig = SystemProcedureCatalog.listing.get(procedureName);
          if (sysprocConfig != null &&  sysprocConfig.getEverysite()) {
              // Send an SP initiate task to all remote sites
              final Long localId = m_mailbox.getHSId();
              Iv2InitiateTaskMessage sp = new Iv2InitiateTaskMessage(
                      localId, // make the MPI the initiator.
                      message.getCoordinatorHSId(),
                      m_repairLogTruncationHandle,
                      mpTxnId,
                      timestamp,
                      message.isReadOnly(),
                      true, // isSinglePartition
                      null,
                      message.getStoredProcedureInvocation(),
                      message.getClientInterfaceHandle(),
                      message.getConnectionId(),
                      message.isForReplay());
              DuplicateCounter counter = new DuplicateCounter(
                      message.getInitiatorHSId(),
                      mpTxnId,
                      m_iv2Masters,
                      message);
              safeAddToDuplicateCounterMap(mpTxnId, counter);
              EveryPartitionTask eptask =
                  new EveryPartitionTask(m_mailbox, m_pendingTasks, sp,
                          m_iv2Masters);
              m_pendingTasks.offer(eptask);
              return;
          }
          // Create a copy so we can overwrite the txnID so the InitiateResponse will be
          // correctly tracked.
          Iv2InitiateTaskMessage mp =
              new Iv2InitiateTaskMessage(
                      message.getInitiatorHSId(),
                      message.getCoordinatorHSId(),
                      m_repairLogTruncationHandle,
                      mpTxnId,
                      timestamp,
                      message.isReadOnly(),
                      message.isSinglePartition(),
                      null,
                      message.getStoredProcedureInvocation(),
                      message.getClientInterfaceHandle(),
                      message.getConnectionId(),
                      message.isForReplay());
          // Multi-partition initiation (at the MPI)
          MpProcedureTask task = null;
          if (isNpTxn(message) && NP_PROCEDURE_CLASS.hasProClass()) {
              Set<Integer> involvedPartitions = getBalancePartitions(message);
              if (involvedPartitions != null) {
                  HashMap<Integer, Long> involvedPartitionMasters = Maps.newHashMap(m_partitionMasters);
                  involvedPartitionMasters.keySet().retainAll(involvedPartitions);
  
                  task = instantiateNpProcedureTask(m_mailbox, procedureName,
                          m_pendingTasks, mp, involvedPartitionMasters,
                          m_buddyHSIds.get(m_nextBuddy), false, m_hostId);
              }
  
              // if cannot figure out the involved partitions, run it as an MP txn
          }
  
          int[] nPartitionIds = message.getNParitionIds();
          if (nPartitionIds != null) {
              HashMap<Integer, Long> involvedPartitionMasters = new HashMap<>();
              for (int partitionId : nPartitionIds) {
                  involvedPartitionMasters.put(partitionId, m_partitionMasters.get(partitionId));
              }
  
              task = instantiateNpProcedureTask(m_mailbox, procedureName,
                      m_pendingTasks, mp, involvedPartitionMasters,
                      m_buddyHSIds.get(m_nextBuddy), false, m_hostId);
          }
  
  
          if (task == null) {
              task = new MpProcedureTask(m_mailbox, procedureName,
                      m_pendingTasks, mp, m_iv2Masters, m_partitionMasters,
                      m_buddyHSIds.get(m_nextBuddy), false, m_hostId, false);
          }
  
          m_nextBuddy = (m_nextBuddy + 1) % m_buddyHSIds.size();
          m_outstandingTxns.put(task.m_txnState.txnId, task.m_txnState);
          m_pendingTasks.offer(task);
      }