code: void notifyMessagePreConsume(SITransaction transaction) throws JMSException {
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.entry(this, tc, "notifyMessagePreConsume", transaction);
  
          if (!(transaction instanceof SIXAResource)) {
              // We wish to increment this count even under auto_ack, since we use
              // it to determine whether the onMessage calls recover.
              uncommittedReceiveCount++;
              if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() && (uncommittedReceiveCount % 100 == 0)) {
                  SibTr.debug(this, tc, "session " + this + " uncommittedReceiveCount : " + uncommittedReceiveCount);
              }
          }
  
          if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
              SibTr.exit(this, tc, "notifyMessagePreConsume");
      }
docs: This method should be called when a message has been received by JMS
  consumer code, but not yet delivered to user code.
  
  This occurs when a message is obtained using the core api before calling
  an asynchronous consumer's onMessage() method.
  
  If the message is handled under a local transaction (transacted session,
  client ack mode, dups ok ack mode, but not auto ack mode or globally
  transacted (XA) sessions), the count of uncommitted received messages is
  incremented.
  
  This count is required by a dups ok session so that it can commit every
  n messages. It is not required by any other type of session, but may be
  useful in debug scenarios. Global XA transactions do not drive commits
  through JMS code, and auto ack mode sessions do not use transactions, so
  the count is not set for these types of session.
  
  Note that the session mode is overriden if an XA transaction is
  configured, i.e. session mode may be set to transacted, or auto ack, but
  an XA transaction may be used anyway. The acknowledgeMode cannot be used
  to distinguish between these states, so the transaction in use is passed
  to this method.
  
  @param transaction
  the transaction under which the message will be consumed (null if no
  transaction is in use).
  
  @see #notifyMessagePostConsume()
  @see #notifyMessageConsumed(SITransaction)