Debugging Code in Beta 2

Question

Hello;
We're currently trying to do some performance analysis of an application on
BEA WLS 6.0 Beta 2 that makes heavy use of MDBs, and new EJB 2.0 Entity Bean
features. We're starting to get some interesting numbers back from JProbe.
Before we go into the analysis of the JProbe results too deeply, I wonder if
you could enumerate for us where in WLS 6.0 Beta 2 you still have
non-optimized debugging code. This will allow us to "temporary disregard"
these areas, or at the very least, not panic, if the performance seems less
than we would expect.
Brian.

Answer 1

Yes, I suspect the separate jar files are your problem. WL 6 optimizes
RMI calls within an application, but calls across applications are much
more expensive.
As a first step, I would deploy the session and entity bean in the same
jar file.
-- Rob
Brian Dueck wrote:
>
Let's start with the basic scenario. We're implementing an active objects
pattern using MDBs, with the state of the active objects stored in EBs. All
this action is shielded from the client through a session bean "controller".
Here's the sequence of operations that we go through (simplified of course):
1. A client application invokes a session bean, which in turn creates an
entity bean. After creating the entity bean, the session bean then puts a
message into a non-persistent JMS topic and returns to the client.
2. An MDB picks up the message that was put into JMS by the session bean,
does some work (including updates on the entity bean), and then puts a
message into a non-persisten JMS queue or topic before returning from
onMessage().
3. MDB(s) pick up the message placed in the topic/queue, they do some work,
and then possibly generate more JMS messages. These are in turn processed by
more MDBs and so on and so forth.
In the simplest possible "hello world" variation of the above scenario, it
looks like we're doing pretty poorly performance wise right now. We're
trying to tear the scenario down though and build it back up step by step,
using the WLS 6.0 examples as a reference. For instance, I've been playing
with the ejb20.message example to do some rough throughput measurements for
the types of messages that we're producing/consuming. The modified example
is giving me much better numbers than my "hello world" scenario above - by
2 orders of magnitude actually.
I haven't run out of things to try yet, but am hoping for some advice that
will steer me in the right direction (vs. brute force trial and error...).
One of the things I noticed, is that the "hello world" implementation is
broken up across multiple jar files - any possibility that is causing major
performance issues. I seem to recall another posting indicating this sort of
multi-jar deployment will cause BEA to not be able to optimize calls.
Thanks for any help,
Brian Dueck
"Rob Woollen" <[email protected]> wrote in message
news:[email protected]...
There have been some performance improvements since beta-2.
However, I would be interested in seeing your profile data. We're always
looking to make the product faster.
-- Rob
Brian Dueck wrote:
Hello;
We're currently trying to do some performance analysis of an application
on
BEA WLS 6.0 Beta 2 that makes heavy use of MDBs, and new EJB 2.0 EntityBean
features. We're starting to get some interesting numbers back fromJProbe.
Before we go into the analysis of the JProbe results too deeply, Iwonder if
you could enumerate for us where in WLS 6.0 Beta 2 you still have
non-optimized debugging code. This will allow us to "temporarydisregard"
these areas, or at the very least, not panic, if the performance seemsless
than we would expect.
Brian.