[Chuck Irvine <Chuck.Irvine@ma...>]

Pat,

I've attached a test case that illustrates the possible performance
issue referred to in the attached. The testcase instantiates an
Interpreter and evaluates a boolean expression string only once. You can
change the length of the string by modifying a class field. In addition
to using BeanShell to evaluate the expression string, the test case
evaluates a pre-parsed, equivalent binary expression tree. Modifying the
above mentioned field also increases the size of the expression tree. I
evaluate the leaves of the expression tree using Java reflection. If you
run the test case you will see that evaluating the pre-parsed expression
is much faster (by as much as x100), especially if you bump of the
length of the expression string passed to BeanShell.

Comments in the main file clarify the forms of the expression string and
binary tree.

Let me admit up front that comparing the forms of evaluation might be
(and probably is, to a certain extent) comparing "apples and oranges".
I'm just trying to tune my app and it is appearing that BeanShell
expression evaluation is a bottleneck.

Any input would be appreciated. If you are interested in running the
test case and have question, please let me know. Thanks!

Chuck Irvine
Sprint




-----Original Message-----
From: pat [mailto:pat@...]
Sent: Tuesday, August 15, 2000 2:44 PM
To: beanshell-users
Cc: pat
Subject: Re: [Beanshell-users] Performance of Expression Evaluation


On Tue, Aug 15, 2000 at 11:57:29AM -0500, Chuck Irvine wrote:
> I've got an applciation that dynamically evaluates using BeanShell a
> boolean expression of the form:
> 
> "Exp && Exp && Exp ...."
> where Exp is of the form: (Boolean) object.method(value)
> 
> I'm trying to performance tune my application and I'm finding that
> BeanShell expression evaluation is one of my bottlenecks.
Experimenting,
> I programmically create a parse tree equivalent to the expression
passed
> to BeanShell and evaluate it using Java reflection. Interestingly, I
> find that the latter evaluation performs better by a factor of 100. 

Is this true even with repeated evaluation or is it just the first call
that is slow?  As Daniel pointed out on a previous post BeanShell loads
a
lot of classes lazily (the first time they are used).  You might be able
to
ameliorate this situation by re-using the same interpreter instance.

I have not yet done any tuning or performance testing on BeanShell...
but
I do intend to look into this.  I cannot see any reason that bsh should
be
two orders of magnitude slower than a similar construct after parsing.
So 
it's possible that something is wrong.


Thanks,
Pat

_______________________________________________
Beanshell-users mailing list
Beanshell-users@...
http://lists.sourceforge.net/mailman/listinfo/beanshell-users