Skip to content

March 28, 2010

Performance Test on TIBCO ActiveMatrix BusinessWorks Subprocess Calls

One of our clients had asked us about the difference in performance between a TIBCO ActiveMatrix BusinessWorks process that uses a subprocess call and one that does not. In other words, one TIBCO process called a subprocess to perform a certain functionality, whereas the other process had the functionality embedded in itself. The functionality in question was a simple JMS Queue Sender activity that sends a JMS queue message to the JMS server. The client was concerned that there may be a large enough performance difference between these two processes to discourage the use of subprocess calls on any process where performance is critical.

The TIBCO Certified Professionals in our company set out to find out the difference in performance between these two processes. We endeavored to answer the following question: how much of a performance cost does a subprocess call incur in TIBCO ActiveMatrix BusinessWorks?

We set up one process that had the functionality embedded in it:

TIBCO BW Process with Embedded Functionality

We setup another process with the same exact functionality being called as a subprocess:

TIBCO BW Process with Subprocess Call

We then called these processes individually 10,000 times each using the following loop from a caller process:

TIBCO BW Process Repeat 10,000 Times

The time it took to for each process to execute 10,000 times was noted. The test was repeated 10 times for each process.

Here are the results:

Test No Subprocess Call With Subprocess Call
1 1484 1781
2 1563 1766
3 1453 1782
4 1469 1797
5 1422 1766
6 1469 1782
7 1437 1781
8 1485 1782
9 1437 1766
10 1516 1797
Average: 1473.5 1780.0

To execute 10,000 times, the process that had the functionality embedded in it took 1473.5 milliseconds. On the other hand, to execute 10,000 times, the process that called the functionality as a subprocess took 1780.0 milliseconds. The difference is 306.5 milliseconds. This may seem like a large difference at first, but remember that this is for 10,000 executions. For just one execution, the difference is only 0.03065 milliseconds (306.5 / 10000).

So, surely, executing an embedded functionality is always going to be faster because there is no need to call another process to perform the functionality. Notice, however, that the difference is extremely small. The question a TIBCO architect must ask is, “Is the difference of less than 1 millisecond per execution large enough to warrant giving up the advantages of subprocesses?” One must look at the performance requirements and Service-Level Agreements (SLA) in order to properly answer this question.

The processes were deployed into a desktop computer with an Intel dual core 3 GHz CPU and 2 GB of RAM.

To learn more about this performance test, or to inquire how we can help with your TIBCO projects, feel free to contact us anytime. Please kindly leave a comment, and tell us about your own experiences in performance tuning with TIBCO Software products.

Read more from TIBCO Tutorials

Share your thoughts, post a comment.

(required)
(required)

Note: HTML is allowed. Your email address will never be published.

Subscribe to comments

*