Message Flow Control

Question

Hello,
          as I read, WLS provides the possibility to slow down message producers when certain paging thresholds are exceeded. I'm not quite sure, if the slow down of a producer is tied to it's session lifecycle, i.e. if the producer is slowed down only within its current session - or are producers, which are created from a new session, also slowed down right from the start.
          It would be great if someone could answer that. Unfortunately I have found nothing about that in the documentation.
          Regards,
          Dirk

Answer 1

Hello Tom.
          First of all, thank you for your quick response. This forum is really working!
          I searched for this topic in the documentation, but didn't find anything appropriate explaining the in-depth details of the JMS flow control mechanism. Therefore, I wrote a simple test case (implementation and server configuration is attached at the end of this message) to check the flow control handling for certain conditions. Since there is no API to access the flow control properties of a message producer, I measured the JMS throughput within the test case and tried to derive some conclusions.
          Regarding the server configuration:
          - I configured one JMS Server (Test_JMSServer) with one Queue (TestQueue). I enabled the message paging at server level, starting at 1000 messages (i.e. message threshold high). The lower message threshold was set to 100 messages. As a paging store a file store (TestPagingStore) was used.
          - Message thresholds at destination level was disabled.
          - I further configured a connection factory (TestConnectionFactory) for which I enabled the flow control with a max. throughput of 50 msg/sec and a min. throughput of 1 msg/sec. The flow interval was set to 60 seconds, the number of steps was set to 6.
          Regarding the test case:
          There are 3 scenarios within the test case. Within each scenario
          - first all messages are consumed from the queue,
          - then 1000 messages are send to the queue in a row, thereby measuring the throughput,
          - finally again 1000 messages are send to the queue in a row, thereby measuring the throughput.
          The scenarios differ in how the bulk-send operation is performed.
          - The first scenario (test_noReuse) creates a new connection for each message to be send.
          - The second scenario (test_sessionReuse) creates a new session at the start and reuses that session for sending the messages. A new sender is created of each message.
          - The third scenario (test_senderReuse) creates a new sender at the start and reuses that sender for sending the messages.
          Here are the results of the test:
          ==[test_noReuse]=======================
          Cleaned up <2000> messages.
          Throughput (messages/second): 51 [startMillis=1161249409788;endMillis=1161249429210;messagesSend=1000]
          Throughput (messages/second): 62 [startMillis=1161249429210;endMillis=1161249445304;messagesSend=1000]
          ==[test_sessionReuse]=======================
          Cleaned up <2000> messages.
          Throughput (messages/second): 231 [startMillis=1161249452773;endMillis=1161249457101;messagesSend=1000]
          Throughput (messages/second): 245 [startMillis=1161249457101;endMillis=1161249461179;messagesSend=1000]
          ==[test_senderReuse]=======================
          Cleaned up <2000> messages.
          Throughput (messages/second): 790 [startMillis=1161249467351;endMillis=1161249468616;messagesSend=1000]
          Throughput (messages/second): 1 [startMillis=1161249468616;endMillis=1161249999226;messagesSend=1000]
          To me it seems, that reusing a session has no effect on the message flow control if a new sender is created for sending a message. The only scenario where a throttling occurs (at least it seems to be that way) is the last scenario, where the sender is reused for all messages.
          So my conclusion is, that message control flow is superfluous to configure, as long as
          - you don't have a small amount of (batch) message producers, each of which reusing a single sender for each message,
          - or you have some cache of senders (or a single sender) in your application and reuse the cached senders for sending messages.
          The latter is, of course, strongly discouraged, since neither JMS sessions, nor senders are thread-safe. So you need to implement some thread-safe cache and also have to deal with re-creating stalled JMS resources within that cache -- a really non-trivial implementation. Further, if many different threads produce messages, the flow control has no (or at least few) effect on the message load in the server.
          I just ask myself, what the flow control was designed for, since the cases where it really applies are rather rare, IMHO. Or have I made some error in the test or in the server configuration?
          Best regards,
          Dirk
          The test class:
          <pre>
          import java.util.Hashtable;
          import javax.jms.BytesMessage;
          import javax.jms.JMSException;
          import javax.jms.Message;
          import javax.jms.Queue;
          import javax.jms.QueueConnection;
          import javax.jms.QueueConnectionFactory;
          import javax.jms.QueueReceiver;
          import javax.jms.QueueSender;
          import javax.jms.QueueSession;
          import javax.jms.Session;
          import javax.naming.InitialContext;
          import junit.framework.TestCase;
          public class JMSFlowControlTest extends TestCase {
          private int messagesThresholdHigh = 1000;
          private QueueConnectionFactory conFactory;
          private Queue queue = null;
          protected void setUp() throws Exception {
          super.setUp();
          InitialContext ctx = null;
          Hashtable ctxEnv = null;
          ctxEnv = new Hashtable();
          ctxEnv.put(
          InitialContext.INITIAL_CONTEXT_FACTORY,
          "weblogic.jndi.WLInitialContextFactory");
          ctxEnv.put(
          InitialContext.PROVIDER_URL,
          "t3://localhost:7001");
          ctx = new InitialContext(ctxEnv);
          this.queue = (Queue) ctx.lookup("jms/queue/TestQueue");
          this.conFactory = (QueueConnectionFactory)
          ctx.lookup("jms/factory/TestConnectionFactory");
          public void test_noReuse() throws Exception {
          System.out.println();
          System.out.println("==[" + this.getName() + "]=======================");
          this.cleanupQueue();
          System.out.println(
          this.bulkSendMessage(
          this.messagesThresholdHigh,
          1024));
          System.out.println(
          this.bulkSendMessage(
          this.messagesThresholdHigh,
          1024));
          public void test_sessionReuse() throws Exception {
          QueueConnection con = null;
          QueueSession session = null;
          System.out.println();
          System.out.println("==[" + this.getName() + "]=======================");
          try {
          con = this.conFactory.createQueueConnection();
          session =
          con.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
          this.cleanupQueue();
          System.out.println(
          this.bulkSendMessage(
          session,
          this.messagesThresholdHigh,
          1024));
          System.out.println(
          this.bulkSendMessage(
          session,
          this.messagesThresholdHigh,
          1024));
          } finally {
          if (con != null) {
          try {
          con.close();
          } catch (JMSException e) {}
          public void test_senderReuse() throws Exception {
          QueueConnection con = null;
          QueueSession session = null;
          QueueSender sender = null;
          System.out.println();
          System.out.println("==[" + this.getName() + "]=======================");
          try {
          con = this.conFactory.createQueueConnection();
          session =
          con.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
          sender = session.createSender(this.queue);
          this.cleanupQueue();
          System.out.println(
          this.bulkSendMessage(
          session,
          sender,
          this.messagesThresholdHigh,
          1024));
          System.out.println(
          this.bulkSendMessage(
          session,
          sender,
          this.messagesThresholdHigh,
          1024));
          } finally {
          if (con != null) {
          try {
          con.close();
          } catch (JMSException e) {}
          private Throughput
          bulkSendMessage(
          int messagesToSend,
          int messageSizeBytes)
          throws Exception {
          int messagesSend = 0;
          long startMillis = 0L;
          long endMillis = 0L;
          QueueConnection con = null;
          QueueSession session = null;
          QueueSender sender = null;
          startMillis = System.currentTimeMillis();
          for (int i = 0; i < messagesToSend; i++) {
          try {
          con = this.conFactory.createQueueConnection();
          session =
          con.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
          sender = session.createSender(this.queue);
          sender.send(this.createMessage(session, messageSizeBytes));
          messagesSend++;
          } finally {
          if (con != null) {
          try {
          con.close();
          } catch (JMSException e) {}
          endMillis = System.currentTimeMillis();
          return new Throughput(startMillis, endMillis, messagesSend);
          private Throughput
          bulkSendMessage(
          QueueSession session,
          int messagesToSend,
          int messageSizeBytes)
          throws Exception {
          int messagesSend = 0;
          long startMillis = 0L;
          long endMillis = 0L;
          QueueSender sender = null;
          startMillis = System.currentTimeMillis();
          for (int i = 0; i < messagesToSend; i++) {
          sender = session.createSender(this.queue);
          sender.send(this.createMessage(session, messageSizeBytes));
          messagesSend++;
          endMillis = System.currentTimeMillis();
          return new Throughput(startMillis, endMillis, messagesSend);
          private Throughput
          bulkSendMessage(
          QueueSession session,
          QueueSender sender,
          int messagesToSend,
          int messageSizeBytes)
          throws Exception {
          int messagesSend = 0;
          long startMillis = 0L;
          long endMillis = 0L;
          startMillis = System.currentTimeMillis();
          for (int i = 0; i < messagesToSend; i++) {
          sender.send(this.createMessage(session, messageSizeBytes));
          messagesSend++;
          endMillis = System.currentTimeMillis();
          return new Throughput(startMillis, endMillis, messagesSend);
          private Message
          createMessage(
          Session session,
          int messageSizeBytes)
          throws Exception {
          BytesMessage message = null;
          message = session.createBytesMessage();
          message.writeBytes(new byte[messageSizeBytes]);
          return message;
          private void cleanupQueue() throws Exception {
          QueueConnection con = null;
          QueueSession session = null;
          QueueReceiver receiver = null;
          Message message = null;
          int messageCount = 0;
          try {
          con = this.conFactory.createQueueConnection();
          session =
          con.createQueueSession(false, QueueSession.AUTO_ACKNOWLEDGE);
          receiver = session.createReceiver(this.queue);
          con.start();
          do {
          message = null;
          message = receiver.receiveNoWait();
          if (message != null) {
          messageCount++;
          } while (message != null);
          } finally {
          if (con != null) {
          try {
          con.close();
          } catch (JMSException e) {}
          System.out.println("Cleaned up <" + messageCount + "> messages.");
          private static final class Throughput {
          private final long startMillis;
          private final long endMillis;
          private final int messagesSend;
          public Throughput(long startMillis, long endMillis, int messagesSend) {
          this.startMillis = startMillis;
          this.endMillis = endMillis;
          this.messagesSend = messagesSend;
          public int value() {
          long timeElapsedMillis = 0L;
          int timeElapsedSeconds = 0;
          int value = 0;
          timeElapsedMillis = this.endMillis - this.startMillis;
          if (timeElapsedMillis == 0) {
          timeElapsedMillis = 1;
          value = (int) ((this.messagesSend * 1000L) / timeElapsedMillis);
          return value;
          public String toString() {
          StringBuffer buffer = new StringBuffer();
          buffer
          .append("Throughput (messages/second): ").append(this.value())
          .append(" [startMillis=").append(this.startMillis)
          .append(";endMillis=").append(this.endMillis)
          .append(";messagesSend=").append(this.messagesSend)
          .append("]");
          return buffer.toString();
          </pre>
          The (partial) server configuration:
          <pre>
          <JMSConnectionFactory
          DefaultDeliveryMode="Non-Persistent"
          FlowMaximum="50"
          FlowMinimum="1"
          FlowSteps="6"
          JNDIName="jms/factory/TestConnectionFactory"
          Name="TestConnection Factory"
          Targets="SchufaDev"
          XAConnectionFactoryEnabled="true"/>
          <JMSFileStore Directory="filestore/paging" Name="TestPagingStore"/>
          <JMSServer
          MessagesPagingEnabled="true"
          MessagesThresholdHigh="1000"
          MessagesThresholdLow="100"
          Name="Test_JMSServer"
          PagingStore="TestPagingStore"
          Targets="SchufaDev">
          <JMSQueue
          CreationTime="1151395702234"
          JNDIName="jms/queue/TestQueue"
          JNDINameReplicated="false"
          Name="TestQueue"
          RedeliveryDelayOverride="5000"
          RedeliveryLimit="5"
          StoreEnabled="false"/>
          </JMSServer>
          </pre>