docs: protected void startSession(boolean deliverImmediately) throws SIException
      {
          final String methodName = "startSession";
          if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
              SibTr.entry(this, TRACE, methodName, new Object[] { this, new Boolean(deliverImmediately) });
          }
  
          boolean sessionStartingByThisThread = false;
  
          // Check to see if we need to do the session start ourselves
          synchronized (sessionStartingLock)
          {
              if (!sessionStarting)
              {
                  /**
                   * Start *if*:
                   * SIB pacing says we should start
                   * XD says we should start
                   * Our global start switch is on
                   */
                  if (sibPacingSessionStarted && mpcPacingSessionStarted && sessionStarted)
                  {
                      sessionStarting = true;
                      sessionStartingByThisThread = true;
                  }
              }
  
              if (TRACE.isDebugEnabled())
              {
                  SibTr.debug(TRACE, methodName, "sibPacingSessionStarted: " + sibPacingSessionStarted
                                                 + "\nmpcPacingSessionStarted: " + mpcPacingSessionStarted
                                                 + "\ncallbackWaiting: " + callbackWaiting
                                                 + "\nsessionStarted: " + sessionStarted
                                                 + "\nsessionStartingByThisThread: " + sessionStartingByThisThread);
              }
          }
  
          if (sessionStartingByThisThread)
          {
              /*
               * We'll only start if there's no callback waiting. If a callback is waiting then
               * we'll simply wake that up, and the callback will perform the start for us.
               * Otherwise we'll do the start here
               */
              boolean startRequired = false;
              synchronized (asyncResumeCallbackWaitLock)
              {
                  if (callbackWaiting)
                  {
                      asyncResumeCallbackWaitLock.notifyAll();
                      callbackWaiting = false;
                  }
                  else
                      startRequired = true;
              }
              if (startRequired)
                  _session.start(deliverImmediately);
  
              sessionStarting = false;
          }
  
          if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled())
          {
              SibTr.exit(this, TRACE, methodName);
          }
      }