Re: Improving performance by splitting JSP?

[gus]

David Graham schrieb:
  > I'm not sure anyone has pointed this out yet, but maybe the
performance
  > problem would go away if you shortened your jsp code (300 lines).  I'm
  > curious why it's that long?

The code is building up a gallery of up to 16 images (4cols, 4rows):


+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+
|  |  |  |  |
+--+--+--+--+


If there are less than 16 images to display the cells are left blank.

Each image block consists of three sections where each section is a
 of the whole :

   +---+ +---+
| Image || Image |...
   +---+ +---+
| Date  || Date  |...
   +---+ +---+
| Descr || Descr |...
   +---+ +---+


   > Maybe you could refactor the code into
  > custom tags or setup more of your data in a struts action class for
the
  > jsp to view.  Even if performance didn't increase you'd end up with an
  > easier to maintain jsp.

I thought about that but didn't do it because I had to put view logic
in controller classes.
But I really like to know if there are better ways in solving this
problem.

Regards
 gus



  >> From: [EMAIL PROTECTED]
  >> Reply-To: "Struts Users Mailing List" 
<[EMAIL PROTECTED]>
  >> To: "Struts Users Mailing List" <[EMAIL PROTECTED]>
  >> Subject: RE: Improving performance by splitting JSP?
  >> Date: Mon, 9 Sep 2002 15:56:45 -0500
  >>
  >>
  >> We were using the 1.3 vm - I'm not sure if it was the 02 or 03
  >> release.  03
  >> I'm pretty sure.
  >>
  >> We did not rerun any of the tests when 1.4 came out - as far as that
  >> customer's application goes they can't run 1.4 (hpux machines -
they have
  >> to wait quite awhile for vm releases).  And we all moved on to other
  >> projects / deliverables so didn't rerun our isolated tests against
1.4
  >> vm.
  >> I still have the sample application we created to try to isolate the
  >> problem, but I couldn't find any of the spreadsheets we put our
  >> results in.
  >> Might be able to find one from a coworker.
  >>
  >> The speed of the sun vm when profiling was turned on was still slower
  >> than
  >> IBM vm with lots of tags, but not orders of magnitude difference.
  >>
  >> We found orders of magnitude difference in performance between one
page
  >> with tons of tags against both:
  >>
  >> - a small page with a high-count loop around a few tags
  >> - a series of pages put together via includes
  >>
  >> Jim
  >>
  >>
  >>
  >>
  >>   "Joe Barefoot"
  >>   > Mailing List" <[EMAIL PROTECTED]>
  >>   iva.com> cc:
  >>Subject:  RE:
Improving
  >> performance by splitting JSP?
  >>   09/09/2002 12:41
  >>   PM
  >>   Please respond to
  >>   "Struts Users
  >>   Mailing List"
  >>
  >>
  >>
  >>
  >>
  >>
  >> Thanks for the information, that's great to know.  Which VM
version were
  >> you testing with?  Out of curiosity, did you ever run performance
tests
  >> using the Sun 1.4 VM to see if there was an improvement?
  >>
  >> I find it especially interesting that turning on profiling flags in
  >> the Sun
  >> VM increased performance--was the speed then comparable to IBM's
VM?  Any
  >> speculation as to the cause of this?
  >>
  >>
  >> thanks,
  >> Joe Barefoot
  >>
  >>
  >> > -Original Message-
  >> > From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
  >> > Sent: Monday, September 09, 2002 9:35 AM
  >> > To: Struts Users Mailing List
  >> > Subject: RE: Improving performance by splitting JSP?
  >> >
  >> >
  >> >
  >> >
  >> > We also ran into problems with single JSPs containing lots of bm
  >> > (bean:message) and bw (bean:write) tags.  We wrote our own
  >> > custom tag that
  >> > did not involve Struts, and found similar behavior using the
  >> > Sun vm under
  >> > both Tomcat and Weblogic on NT boxes (lousy performace with a
  >> > bunch of them
  >> > in one page - much better with same number of tags split up
  >> > over several
  >> > pages).  When we swapped out to the IBM vm, the discrepancy
  >

Re: Improving performance by splitting JSP?

[gus]

Joe Barefoot schrieb:
  > Since each JSP compiles down to a single method call in the
generated source
  > class, and (depending on how the JSP compiler generates Java
source) each
  > custom tag could potentially have its own try/catch block as well
as several
  > local variables, the more 'stuff' you have on a single page
correlates to
  > the amount of stack memory required for the local scope of the
method call.

I tried to track down the problem (with the unsplitted page) with
System.out.println statements. With this procedure I discovered that
most of the time (4 sec) is consumed in one piece (=between two source
code lines) but not always at the same source code lines. I assumed a
memory allocation problem but increasing the page buffer to 100kb
didn't help.

It looks like Tomcat is "taking a break" for 4 sec before delivering
the next content. During this break CPU load raises up to 100%.

Do you know under which circumstances this or similar behaviour can
occur with Tomcat?

Regards
 gus


  > -Original Message-
  > From: gus [mailto:[EMAIL PROTECTED]]
  > Sent: Saturday, September 07, 2002 7:15 AM
  > To: [EMAIL PROTECTED]
  > Subject: Improving performance by splitting JSP?
  >
  >
  > Hi!
  >
  > I had a performance problem in my struts application where one JSP
  > page took about 5 secs to display (Tomcat 4.0.4, Struts 1.1b1, Win2k,
  > PIII 500, 512Mb). The page uses struts taglibs (bean, logic, html) and
  > is nearly 300 lines long.
  >
  > I tried to track down the problem but with no luck. Finally I split
  > the page into 3 parts using  and now the whole page
  > loads 5 times faster.
  >
  > Does anybody made the same experience and/or has an explanation for
  > that behaviour?
  >
  > Regards
  > gus
  >
  >
  >
  > --
  > To unsubscribe, e-mail:
  > 
  > For additional commands, e-mail:
  > 
  >
  >
  > --
  > To unsubscribe, e-mail:

  > For additional commands, e-mail:

  >
  >






--
To unsubscribe, e-mail:   
For additional commands, e-mail: 

RE: Improving performance by splitting JSP?

[Craig R. McClanahan]

It would also be interesting to try different JSP page compilers, which
would also make a huge difference - for example, Jasper2 (used in Tomcat
4.1.x) versus the original Jasper in Tomcat 4.0.

On the Sun JVM, one additional variable is to try the "-server" system
property at startup time for your container.  This selects the HotSpot
mode optimized for long-running server applications, versus the default
"-client" setting.

Craig


On Tue, 10 Sep 2002 [EMAIL PROTECTED] wrote:

> Date: Tue, 10 Sep 2002 13:34:08 -0500
> From: [EMAIL PROTECTED]
> Reply-To: Struts Users Mailing List <[EMAIL PROTECTED]>
> To: Struts Users Mailing List <[EMAIL PROTECTED]>
> Cc: 'Struts Users Mailing List' <[EMAIL PROTECTED]>
> Subject: RE: Improving performance by splitting JSP?
>
>
> Our test tag was using a HashMap.
>
> You can view this performance quirk yourself using Struts bean:message tag.
> To get orders of magnitude in the performance discrepancy (to make sure we
> were measuring the tag performance difference on a much more significant
> scale than server access variance times) we went to 200,000 tag exectutions
> done a variety of ways:
>
> One of our cases was a page with 20 tags, inside a loop 10,000 times.
> Another case was same page, but done by 160 tags inside a 1250 loop.
> Another case same page rendered by includes:  page included another page 8
> times inside a 1250 loop.  The included page had 20 tags.
>
> There were other varieties, but these three show the discrepancy in
> performance with the increased number of tags very significantly.  All
> three cases output the same resulting html.  All three cases executed the
> tag code 200,000 times.  The first and third cases, with 20 custom tag
> occurrences, performed roughly the same (better performance).  The second
> case with 160 tags performed much much worse.  I don't have our statistics
> anymore, alas, but it was two or more orders of magnitude worse.  We tried
> an 80 tag variety as well, and it put the expected point on the slope
> (significantly worse than same output rendered via 20 tags, not as bad as
> 160 tags).
>
> Switching to IBM VM, or turning profiling flags on in the Sun VM before
> running the tests, caused the performance discrepancy between these
> approaches to vanish (roughly the better performance mark for all three).
>
> Be wonderful if someone else could verify on their own.  Two days of
> cursing over it was enough for us ;-).  As soon as we realized we could fix
> the problem pages by restructuring them into separate JSPs, we declared
> victory over the Mystery of the VM ;-).
>
> Again this was 1.3, who knows if Sun's 1.4 vm still does this
>
> Jimbo
>
> Build a simple JSP that contains
>
>
>
>   "Hajratwala,
>           Nayan (N.)"      To:   "'Struts Users Mailing 
>List'" <[EMAIL PROTECTED]>
>   <[EMAIL PROTECTED]cc:
>   m>   Subject:  RE: Improving performance 
>by splitting JSP?
>
>   09/10/2002 01:02
>   PM
>   Please respond to
>   "Struts Users
>   Mailing List"
>
>
>
>
>
>
> Was it a Hashtable or HashMap?
>
> It might be that since Hashtable is synchronized you were encountering a
> bottleneck in your multithreaded environment, whereas just a regular loop
> would not have this problem...
>
> ---
> - Nayan Hajratwala
> - Chikli Consulting LLC
> - http://www.chikli.com
>
>
> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Tuesday, September 10, 2002 11:48 AM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
>
>
>
> I had to go back and look at the test code we used, but yes - looks like we
> did try a non-body tag.  It did a hashtable lookup for whatever key values
> was passed in as a parameter.  I remember we found that we could only
> recreate the performance discrepancy with tags that did some kind of memory
> lookup; just adding loops around arithmetic statements are writing output
> were tried, but did not exhibit the symptoms.
>
> Jim Weaver
> Software Developer - ThoughtWorks
>
>
>
>
>   "Martin Cooper"
>
>Mailing List'" <[EMAIL PROTECTED]>
>   leweed.com>cc:
>
>              Subject:  RE: Improving
> performance by splitting JSP?
>  

RE: Improving performance by splitting JSP?

[JEWeaver]

Our test tag was using a HashMap.

You can view this performance quirk yourself using Struts bean:message tag.
To get orders of magnitude in the performance discrepancy (to make sure we
were measuring the tag performance difference on a much more significant
scale than server access variance times) we went to 200,000 tag exectutions
done a variety of ways:

One of our cases was a page with 20 tags, inside a loop 10,000 times.
Another case was same page, but done by 160 tags inside a 1250 loop.
Another case same page rendered by includes:  page included another page 8
times inside a 1250 loop.  The included page had 20 tags.

There were other varieties, but these three show the discrepancy in
performance with the increased number of tags very significantly.  All
three cases output the same resulting html.  All three cases executed the
tag code 200,000 times.  The first and third cases, with 20 custom tag
occurrences, performed roughly the same (better performance).  The second
case with 160 tags performed much much worse.  I don't have our statistics
anymore, alas, but it was two or more orders of magnitude worse.  We tried
an 80 tag variety as well, and it put the expected point on the slope
(significantly worse than same output rendered via 20 tags, not as bad as
160 tags).

Switching to IBM VM, or turning profiling flags on in the Sun VM before
running the tests, caused the performance discrepancy between these
approaches to vanish (roughly the better performance mark for all three).

Be wonderful if someone else could verify on their own.  Two days of
cursing over it was enough for us ;-).  As soon as we realized we could fix
the problem pages by restructuring them into separate JSPs, we declared
victory over the Mystery of the VM ;-).

Again this was 1.3, who knows if Sun's 1.4 vm still does this

Jimbo

Build a simple JSP that contains


   
  
  "Hajratwala, 
  
  Nayan (N.)"  To:   "'Struts Users Mailing List'" 
<[EMAIL PROTECTED]>  
  <[EMAIL PROTECTED]cc: 
  
      m>           Subject:  RE: Improving performance by 
splitting JSP? 
   
  
  09/10/2002 01:02 
  
  PM   
  
  Please respond to
  
  "Struts Users
  
  Mailing List"
  
   
  
   
  




Was it a Hashtable or HashMap?

It might be that since Hashtable is synchronized you were encountering a
bottleneck in your multithreaded environment, whereas just a regular loop
would not have this problem...

---
- Nayan Hajratwala
- Chikli Consulting LLC
- http://www.chikli.com


-Original Message-
From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
Sent: Tuesday, September 10, 2002 11:48 AM
To: Struts Users Mailing List
Subject: RE: Improving performance by splitting JSP?



I had to go back and look at the test code we used, but yes - looks like we
did try a non-body tag.  It did a hashtable lookup for whatever key values
was passed in as a parameter.  I remember we found that we could only
recreate the performance discrepancy with tags that did some kind of memory
lookup; just adding loops around arithmetic statements are writing output
were tried, but did not exhibit the symptoms.

Jim Weaver
Software Developer - ThoughtWorks




  "Martin Cooper"

  
  leweed.com>        cc:

             Subject:  RE: Improving
performance by splitting JSP?
  09/09/2002 05:24 PM

  Please respond to

  "Stru

RE: Improving performance by splitting JSP?

[Joe Barefoot]

True.  However, Jim encountered this performance problem with the bean:write and 
bean:message tags provided with Struts as well, and AFAIK they use an unsyncronized 
FastHashMap, so that wouldn't explain the slow-down he got with lots of write/message 
tags (that's why they were trying to write their own custom tags to replace them in 
the first place).

peace,
Joe

> -Original Message-
> From: Hajratwala, Nayan (N.) [mailto:[EMAIL PROTECTED]]
> Sent: Tuesday, September 10, 2002 11:02 AM
> To: 'Struts Users Mailing List'
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> Was it a Hashtable or HashMap?
> 
> It might be that since Hashtable is synchronized you were 
> encountering a
> bottleneck in your multithreaded environment, whereas just a 
> regular loop
> would not have this problem...
> 
> ---
> - Nayan Hajratwala
> - Chikli Consulting LLC
> - http://www.chikli.com
> 
> 
> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Tuesday, September 10, 2002 11:48 AM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> 
> I had to go back and look at the test code we used, but yes - 
> looks like we
> did try a non-body tag.  It did a hashtable lookup for 
> whatever key values
> was passed in as a parameter.  I remember we found that we could only
> recreate the performance discrepancy with tags that did some 
> kind of memory
> lookup; just adding loops around arithmetic statements are 
> writing output
> were tried, but did not exhibit the symptoms.
> 
> Jim Weaver
> Software Developer - ThoughtWorks
> 
> 
>  
> 
>   "Martin Cooper"
> 
>"'Struts Users
> Mailing List'" <[EMAIL PROTECTED]>  
>   leweed.com>cc:
> 
>  Subject:  
> RE: Improving
> performance by splitting JSP? 
>   09/09/2002 05:24 PM
> 
>   Please respond to
> 
>   "Struts Users
> 
>       Mailing List"
> 
>  
> 
>  
> 
> 
> 
> 
> 
> 
> 
> > -Original Message-
> > From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> > Sent: Monday, September 09, 2002 2:51 PM
> > To: Struts Users Mailing List
> > Subject: RE: Improving performance by splitting JSP?
> >
> >
> >
> > Yup, we looked at overall size of the JSP as well, and the
> > association with
> > performance was definitely number of bm/bw tags within a
> > single JSP rather
> > than overall JSP size.  We even tried editing the generated
> > servlet code
> > and adding big unused methods to see if the problem had to do with
> > generated servlet file size.  That would kind've made 
> sense, but was a
> > negative.  I believe we also tried a tag that just did a
> > sysout rather than
> > any kind of memory lookup (hashtable or properties file) and
> > found that
> > this performance quirk in the sun vm did not appear in that case.
> 
> When you wrote your own tags (the message/write equivalents, 
> I mean), did
> you happen to play with body versus non-body tags? When I was 
> wrestling
> with
> the "too many tags" problem a while ago, I ended up writing 
> my own versions
> of some of the Struts tags so that they were non-body tags, 
> because they
> caused noticeably less code to be generated. I didn't measure 
> performance
> differences, but I wouldn't be surprised to see a noticeable 
> improvement
> there too.
> 
> --
> Martin Cooper
> 
> 
> >
> > We could never pin down a why, it seemed that the sun 1.3 vm
> > just ran like
> > a snail with a lot of bm or bw tags in a single page, so we
> > stopped doing
> > that ;-).  Same number of tags split up into multiple JSPs,
> > or a few tags
> > called the same number of times via a loop - OK performance.
> >
> > It is very true also that splitting them up into smaller
> > bites makes them
> > more readable and maintainable, so it was a good solution all
> > around.  It's
> > just that you are always nervous when you fix a problem and
> > don't know the
> > why of it ;-).
> >
> > Jimbo
> >
> >
> >
> > --
> > To unsubscribe, e-mail:
> > <mailto:[EMAIL PROTECTED]>
> > For additional commands, e-mail:
> > <mailto:[EMAIL PROTECTED]>
> >
> >
> 
> 
> --
> To unsubscribe, e-mail:   <
> mailto:[EMAIL PROTECTED]>
> For additional commands, e-mail: <
> mailto:[EMAIL PROTECTED]>
> 
> 
> 
> 
> 
> 
> 
> --
> To unsubscribe, e-mail:
> <mailto:[EMAIL PROTECTED]>
> For additional commands, e-mail:
> <mailto:[EMAIL PROTECTED]>
> 
> --
> To unsubscribe, e-mail:   
<mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>


--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

RE: Improving performance by splitting JSP?

[Hajratwala, Nayan (N.)]

Was it a Hashtable or HashMap?

It might be that since Hashtable is synchronized you were encountering a
bottleneck in your multithreaded environment, whereas just a regular loop
would not have this problem...

---
- Nayan Hajratwala
- Chikli Consulting LLC
- http://www.chikli.com


-Original Message-
From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
Sent: Tuesday, September 10, 2002 11:48 AM
To: Struts Users Mailing List
Subject: RE: Improving performance by splitting JSP?



I had to go back and look at the test code we used, but yes - looks like we
did try a non-body tag.  It did a hashtable lookup for whatever key values
was passed in as a parameter.  I remember we found that we could only
recreate the performance discrepancy with tags that did some kind of memory
lookup; just adding loops around arithmetic statements are writing output
were tried, but did not exhibit the symptoms.

Jim Weaver
Software Developer - ThoughtWorks


 

  "Martin Cooper"


  leweed.com>cc:

     Subject:  RE: Improving
performance by splitting JSP? 
  09/09/2002 05:24 PM

  Please respond to

  "Struts Users

  Mailing List"

 

 







> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 2:51 PM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
>
>
>
> Yup, we looked at overall size of the JSP as well, and the
> association with
> performance was definitely number of bm/bw tags within a
> single JSP rather
> than overall JSP size.  We even tried editing the generated
> servlet code
> and adding big unused methods to see if the problem had to do with
> generated servlet file size.  That would kind've made sense, but was a
> negative.  I believe we also tried a tag that just did a
> sysout rather than
> any kind of memory lookup (hashtable or properties file) and
> found that
> this performance quirk in the sun vm did not appear in that case.

When you wrote your own tags (the message/write equivalents, I mean), did
you happen to play with body versus non-body tags? When I was wrestling
with
the "too many tags" problem a while ago, I ended up writing my own versions
of some of the Struts tags so that they were non-body tags, because they
caused noticeably less code to be generated. I didn't measure performance
differences, but I wouldn't be surprised to see a noticeable improvement
there too.

--
Martin Cooper


>
> We could never pin down a why, it seemed that the sun 1.3 vm
> just ran like
> a snail with a lot of bm or bw tags in a single page, so we
> stopped doing
> that ;-).  Same number of tags split up into multiple JSPs,
> or a few tags
> called the same number of times via a loop - OK performance.
>
> It is very true also that splitting them up into smaller
> bites makes them
> more readable and maintainable, so it was a good solution all
> around.  It's
> just that you are always nervous when you fix a problem and
> don't know the
> why of it ;-).
>
> Jimbo
>
>
>
> --
> To unsubscribe, e-mail:
> <mailto:[EMAIL PROTECTED]>
> For additional commands, e-mail:
> <mailto:[EMAIL PROTECTED]>
>
>


--
To unsubscribe, e-mail:   <
mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <
mailto:[EMAIL PROTECTED]>







--
To unsubscribe, e-mail:
<mailto:[EMAIL PROTECTED]>
For additional commands, e-mail:
<mailto:[EMAIL PROTECTED]>

--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

RE: Improving performance by splitting JSP?

[JEWeaver]

I had to go back and look at the test code we used, but yes - looks like we
did try a non-body tag.  It did a hashtable lookup for whatever key values
was passed in as a parameter.  I remember we found that we could only
recreate the performance discrepancy with tags that did some kind of memory
lookup; just adding loops around arithmetic statements are writing output
were tried, but did not exhibit the symptoms.

Jim Weaver
Software Developer - ThoughtWorks


   

  "Martin Cooper"  


  leweed.com>cc:   

     Subject:  RE: Improving performance 
by splitting JSP? 
  09/09/2002 05:24 PM  

  Please respond to

  "Struts Users

  Mailing List"

   

   







> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 2:51 PM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
>
>
>
> Yup, we looked at overall size of the JSP as well, and the
> association with
> performance was definitely number of bm/bw tags within a
> single JSP rather
> than overall JSP size.  We even tried editing the generated
> servlet code
> and adding big unused methods to see if the problem had to do with
> generated servlet file size.  That would kind've made sense, but was a
> negative.  I believe we also tried a tag that just did a
> sysout rather than
> any kind of memory lookup (hashtable or properties file) and
> found that
> this performance quirk in the sun vm did not appear in that case.

When you wrote your own tags (the message/write equivalents, I mean), did
you happen to play with body versus non-body tags? When I was wrestling
with
the "too many tags" problem a while ago, I ended up writing my own versions
of some of the Struts tags so that they were non-body tags, because they
caused noticeably less code to be generated. I didn't measure performance
differences, but I wouldn't be surprised to see a noticeable improvement
there too.

--
Martin Cooper


>
> We could never pin down a why, it seemed that the sun 1.3 vm
> just ran like
> a snail with a lot of bm or bw tags in a single page, so we
> stopped doing
> that ;-).  Same number of tags split up into multiple JSPs,
> or a few tags
> called the same number of times via a loop - OK performance.
>
> It is very true also that splitting them up into smaller
> bites makes them
> more readable and maintainable, so it was a good solution all
> around.  It's
> just that you are always nervous when you fix a problem and
> don't know the
> why of it ;-).
>
> Jimbo
>
>
>
> --
> To unsubscribe, e-mail:
> <mailto:[EMAIL PROTECTED]>
> For additional commands, e-mail:
> <mailto:[EMAIL PROTECTED]>
>
>


--
To unsubscribe, e-mail:   <
mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <
mailto:[EMAIL PROTECTED]>







--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

Re: Improving performance by splitting JSP?

[Peter A. J. Pilgrim]

[EMAIL PROTECTED] wrote:
> Yup, we looked at overall size of the JSP as well, and the association with
> performance was definitely number of bm/bw tags within a single JSP rather
> than overall JSP size.  We even tried editing the generated servlet code
> and adding big unused methods to see if the problem had to do with
> generated servlet file size.  That would kind've made sense, but was a
> negative.  I believe we also tried a tag that just did a sysout rather than
> any kind of memory lookup (hashtable or properties file) and found that
> this performance quirk in the sun vm did not appear in that case.
> 

I tried to be clever. I once created 
tag 14 months ago. I learnt to my cost the amount of java
code it generated.


...

JSP bloat.

I use scriptlets and JSP include fragment to cut the size


<% // Fragment
String contextPath = request.getContextPath();
  %>
...

<@include page="init.jsp" >

...

" />



-- 
Peter Pilgrim +-\ +-+++++
Java Technologist | | | ||||| 'n' Shine
   |  O  | | ||  --+| ---+
 /\| ._  / | | \  \ ||
/  \   | | \ \ | |+--  || ---+ A new day
   /_  _\  "Up"| | | | | ||||| is coming
 ||+-+ +-+ +-+++++
http://www.xenonsoft.demon.co.uk/"; />


--
To unsubscribe, e-mail:   
For additional commands, e-mail: 

RE: Improving performance by splitting JSP?

[Martin Cooper]

> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 2:51 PM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> 
> Yup, we looked at overall size of the JSP as well, and the 
> association with
> performance was definitely number of bm/bw tags within a 
> single JSP rather
> than overall JSP size.  We even tried editing the generated 
> servlet code
> and adding big unused methods to see if the problem had to do with
> generated servlet file size.  That would kind've made sense, but was a
> negative.  I believe we also tried a tag that just did a 
> sysout rather than
> any kind of memory lookup (hashtable or properties file) and 
> found that
> this performance quirk in the sun vm did not appear in that case.

When you wrote your own tags (the message/write equivalents, I mean), did
you happen to play with body versus non-body tags? When I was wrestling with
the "too many tags" problem a while ago, I ended up writing my own versions
of some of the Struts tags so that they were non-body tags, because they
caused noticeably less code to be generated. I didn't measure performance
differences, but I wouldn't be surprised to see a noticeable improvement
there too.

--
Martin Cooper


> 
> We could never pin down a why, it seemed that the sun 1.3 vm 
> just ran like
> a snail with a lot of bm or bw tags in a single page, so we 
> stopped doing
> that ;-).  Same number of tags split up into multiple JSPs, 
> or a few tags
> called the same number of times via a loop - OK performance.
> 
> It is very true also that splitting them up into smaller 
> bites makes them
> more readable and maintainable, so it was a good solution all 
> around.  It's
> just that you are always nervous when you fix a problem and 
> don't know the
> why of it ;-).
> 
> Jimbo
> 
> 
> 
> --
> To unsubscribe, e-mail:   
> <mailto:[EMAIL PROTECTED]>
> For additional commands, e-mail: 
> <mailto:[EMAIL PROTECTED]>
> 
> 


--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

RE: Improving performance by splitting JSP?

[Joe Barefoot]

Thanks again for the info.  I've seen similar complaints from several people, and 
nobody seems to have a satisfactory explanation for the performance issue (other than 
the nested tc bug, which you accounted for).  Very weird.  

peace,
Joe  

> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 2:51 PM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> 
> Yup, we looked at overall size of the JSP as well, and the 
> association with
> performance was definitely number of bm/bw tags within a 
> single JSP rather
> than overall JSP size.  We even tried editing the generated 
> servlet code
> and adding big unused methods to see if the problem had to do with
> generated servlet file size.  That would kind've made sense, but was a
> negative.  I believe we also tried a tag that just did a 
> sysout rather than
> any kind of memory lookup (hashtable or properties file) and 
> found that
> this performance quirk in the sun vm did not appear in that case.
> 
> We could never pin down a why, it seemed that the sun 1.3 vm 
> just ran like
> a snail with a lot of bm or bw tags in a single page, so we 
> stopped doing
> that ;-).  Same number of tags split up into multiple JSPs, 
> or a few tags
> called the same number of times via a loop - OK performance.
> 
> It is very true also that splitting them up into smaller 
> bites makes them
> more readable and maintainable, so it was a good solution all 
> around.  It's
> just that you are always nervous when you fix a problem and 
> don't know the
> why of it ;-).
> 
> Jimbo
> 
> 
> 
> --
> To unsubscribe, e-mail:   
<mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>


--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

RE: Improving performance by splitting JSP?

[JEWeaver]

Yup, we looked at overall size of the JSP as well, and the association with
performance was definitely number of bm/bw tags within a single JSP rather
than overall JSP size.  We even tried editing the generated servlet code
and adding big unused methods to see if the problem had to do with
generated servlet file size.  That would kind've made sense, but was a
negative.  I believe we also tried a tag that just did a sysout rather than
any kind of memory lookup (hashtable or properties file) and found that
this performance quirk in the sun vm did not appear in that case.

We could never pin down a why, it seemed that the sun 1.3 vm just ran like
a snail with a lot of bm or bw tags in a single page, so we stopped doing
that ;-).  Same number of tags split up into multiple JSPs, or a few tags
called the same number of times via a loop - OK performance.

It is very true also that splitting them up into smaller bites makes them
more readable and maintainable, so it was a good solution all around.  It's
just that you are always nervous when you fix a problem and don't know the
why of it ;-).

Jimbo



--
To unsubscribe, e-mail:   
For additional commands, e-mail: 

RE: Improving performance by splitting JSP?

[Joe Barefoot]

1.  Shortening JSP code does not necessarily reduce the java code generated from them.
2.  Ditto for custom tags.  Too many tags is exactly what we're talking about.
3.  Try reading the thread first.  Jim was not seeking a solution for anything, merely 
posting an observation regarding performance after seeing a post regarding same.  He 
already solved his performance issue by splitting the pages via includes.

peace,
Joe

> -Original Message-
> From: David Graham [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 2:15 PM
> To: [EMAIL PROTECTED]
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> I'm not sure anyone has pointed this out yet, but maybe the 
> performance 
> problem would go away if you shortened your jsp code (300 
> lines).  I'm 
> curious why it's that long?  Maybe you could refactor the 
> code into custom 
> tags or setup more of your data in a struts action class for 
> the jsp to 
> view.  Even if performance didn't increase you'd end up with 
> an easier to 
> maintain jsp.
> 
> Dave
> 
> 
> >From: [EMAIL PROTECTED]
> >Reply-To: "Struts Users Mailing List" 
> <[EMAIL PROTECTED]>
> >To: "Struts Users Mailing List" <[EMAIL PROTECTED]>
> >Subject: RE: Improving performance by splitting JSP?
> >Date: Mon, 9 Sep 2002 15:56:45 -0500
> >
> >
> >We were using the 1.3 vm - I'm not sure if it was the 02 or 
> 03 release.  03
> >I'm pretty sure.
> >
> >We did not rerun any of the tests when 1.4 came out - as far as that
> >customer's application goes they can't run 1.4 (hpux 
> machines - they have
> >to wait quite awhile for vm releases).  And we all moved on to other
> >projects / deliverables so didn't rerun our isolated tests 
> against 1.4 vm.
> >I still have the sample application we created to try to isolate the
> >problem, but I couldn't find any of the spreadsheets we put 
> our results in.
> >Might be able to find one from a coworker.
> >
> >The speed of the sun vm when profiling was turned on was 
> still slower than
> >IBM vm with lots of tags, but not orders of magnitude difference.
> >
> >We found orders of magnitude difference in performance 
> between one page
> >with tons of tags against both:
> >
> >- a small page with a high-count loop around a few tags
> >- a series of pages put together via includes
> >
> >Jim
> >
> >
> >
> >
> >   "Joe Barefoot"
> >"Struts Users 
> >Mailing List" <[EMAIL PROTECTED]>
> >   iva.com> cc:
> >Subject:  
> RE: Improving 
> >performance by splitting JSP?
> >   09/09/2002 12:41
> >   PM
> >   Please respond to
> >   "Struts Users
> >   Mailing List"
> >
> >
> >
> >
> >
> >
> >Thanks for the information, that's great to know.  Which VM 
> version were
> >you testing with?  Out of curiosity, did you ever run 
> performance tests
> >using the Sun 1.4 VM to see if there was an improvement?
> >
> >I find it especially interesting that turning on profiling 
> flags in the Sun
> >VM increased performance--was the speed then comparable to 
> IBM's VM?  Any
> >speculation as to the cause of this?
> >
> >
> >thanks,
> >Joe Barefoot
> >
> >
> > > -Original Message-
> > > From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> > > Sent: Monday, September 09, 2002 9:35 AM
> > > To: Struts Users Mailing List
> > > Subject: RE: Improving performance by splitting JSP?
> > >
> > >
> > >
> > >
> > > We also ran into problems with single JSPs containing lots of bm
> > > (bean:message) and bw (bean:write) tags.  We wrote our own
> > > custom tag that
> > > did not involve Struts, and found similar behavior using the
> > > Sun vm under
> > > both Tomcat and Weblogic on NT boxes (lousy performace with a
> > > bunch of them
> > > in one page - much better with same number of tags split up
> > > over several
> > > pages).  When we swapped out to the IBM vm, the discrepancy
> > > in performance
> > > went away - both styles reasonably fast.  To get 
> significant numbers
> > > (orders of magnitude difference i

RE: Improving performance by splitting JSP?

[David Graham]

I'm not sure anyone has pointed this out yet, but maybe the performance 
problem would go away if you shortened your jsp code (300 lines).  I'm 
curious why it's that long?  Maybe you could refactor the code into custom 
tags or setup more of your data in a struts action class for the jsp to 
view.  Even if performance didn't increase you'd end up with an easier to 
maintain jsp.

Dave


>From: [EMAIL PROTECTED]
>Reply-To: "Struts Users Mailing List" <[EMAIL PROTECTED]>
>To: "Struts Users Mailing List" <[EMAIL PROTECTED]>
>Subject: RE: Improving performance by splitting JSP?
>Date: Mon, 9 Sep 2002 15:56:45 -0500
>
>
>We were using the 1.3 vm - I'm not sure if it was the 02 or 03 release.  03
>I'm pretty sure.
>
>We did not rerun any of the tests when 1.4 came out - as far as that
>customer's application goes they can't run 1.4 (hpux machines - they have
>to wait quite awhile for vm releases).  And we all moved on to other
>projects / deliverables so didn't rerun our isolated tests against 1.4 vm.
>I still have the sample application we created to try to isolate the
>problem, but I couldn't find any of the spreadsheets we put our results in.
>Might be able to find one from a coworker.
>
>The speed of the sun vm when profiling was turned on was still slower than
>IBM vm with lots of tags, but not orders of magnitude difference.
>
>We found orders of magnitude difference in performance between one page
>with tons of tags against both:
>
>- a small page with a high-count loop around a few tags
>- a series of pages put together via includes
>
>Jim
>
>
>
>
>   "Joe Barefoot"
>       Mailing List" <[EMAIL PROTECTED]>
>   iva.com> cc:
>Subject:  RE: Improving 
>performance by splitting JSP?
>   09/09/2002 12:41
>   PM
>   Please respond to
>   "Struts Users
>   Mailing List"
>
>
>
>
>
>
>Thanks for the information, that's great to know.  Which VM version were
>you testing with?  Out of curiosity, did you ever run performance tests
>using the Sun 1.4 VM to see if there was an improvement?
>
>I find it especially interesting that turning on profiling flags in the Sun
>VM increased performance--was the speed then comparable to IBM's VM?  Any
>speculation as to the cause of this?
>
>
>thanks,
>Joe Barefoot
>
>
> > -Original Message-
> > From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> > Sent: Monday, September 09, 2002 9:35 AM
> > To: Struts Users Mailing List
> > Subject: RE: Improving performance by splitting JSP?
> >
> >
> >
> >
> > We also ran into problems with single JSPs containing lots of bm
> > (bean:message) and bw (bean:write) tags.  We wrote our own
> > custom tag that
> > did not involve Struts, and found similar behavior using the
> > Sun vm under
> > both Tomcat and Weblogic on NT boxes (lousy performace with a
> > bunch of them
> > in one page - much better with same number of tags split up
> > over several
> > pages).  When we swapped out to the IBM vm, the discrepancy
> > in performance
> > went away - both styles reasonably fast.  To get significant numbers
> > (orders of magnitude difference in performance) we went to
> > thousands of
> > tags, by the way.
> >
> > We took lots of statistics and made a lot of posts on
> > newsgroups, and never
> > really got any good explanation from anyone.  Interestingly,
> > when we turned
> > profiling flags on in the sun vm to try to track what was
> > going on, the
> > symptoms went away.
> >
> > We experimented with try/catch blocks (manually editing
> > generated servlet
> > code to drastically reduce them), since there were some known
> > performance
> > bugs at the time against the sun vm regarding tc blocks.  This had no
> > effect, and we didn't really expect any, since the bugs had to do with
> > nested tcs rather than lots in serial.
> >
> > In the end our solution was just to be careful about the size
> > of the JSPs,
> > since our client could not go to the IBM vm.
> >
> > Jim
> >
> >
> >
> >
> >
> >   "Joe Barefoot"
> >
> >
> >> "Struts Users Mailing List" <[EMAIL PROTECTED]>
> >
> > 

RE: Improving performance by splitting JSP?

[JEWeaver]

We were using the 1.3 vm - I'm not sure if it was the 02 or 03 release.  03
I'm pretty sure.

We did not rerun any of the tests when 1.4 came out - as far as that
customer's application goes they can't run 1.4 (hpux machines - they have
to wait quite awhile for vm releases).  And we all moved on to other
projects / deliverables so didn't rerun our isolated tests against 1.4 vm.
I still have the sample application we created to try to isolate the
problem, but I couldn't find any of the spreadsheets we put our results in.
Might be able to find one from a coworker.

The speed of the sun vm when profiling was turned on was still slower than
IBM vm with lots of tags, but not orders of magnitude difference.

We found orders of magnitude difference in performance between one page
with tons of tags against both:

- a small page with a high-count loop around a few tags
- a series of pages put together via includes

Jim



   
  
  "Joe Barefoot"   
  
  
  iva.com> cc: 
  
                   Subject:  RE: Improving performance by 
splitting JSP? 
  09/09/2002 12:41 
  
  PM   
  
  Please respond to
  
  "Struts Users
  
  Mailing List"
  
   
  
   
  




Thanks for the information, that's great to know.  Which VM version were
you testing with?  Out of curiosity, did you ever run performance tests
using the Sun 1.4 VM to see if there was an improvement?

I find it especially interesting that turning on profiling flags in the Sun
VM increased performance--was the speed then comparable to IBM's VM?  Any
speculation as to the cause of this?


thanks,
Joe Barefoot


> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 9:35 AM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
>
>
>
>
> We also ran into problems with single JSPs containing lots of bm
> (bean:message) and bw (bean:write) tags.  We wrote our own
> custom tag that
> did not involve Struts, and found similar behavior using the
> Sun vm under
> both Tomcat and Weblogic on NT boxes (lousy performace with a
> bunch of them
> in one page - much better with same number of tags split up
> over several
> pages).  When we swapped out to the IBM vm, the discrepancy
> in performance
> went away - both styles reasonably fast.  To get significant numbers
> (orders of magnitude difference in performance) we went to
> thousands of
> tags, by the way.
>
> We took lots of statistics and made a lot of posts on
> newsgroups, and never
> really got any good explanation from anyone.  Interestingly,
> when we turned
> profiling flags on in the sun vm to try to track what was
> going on, the
> symptoms went away.
>
> We experimented with try/catch blocks (manually editing
> generated servlet
> code to drastically reduce them), since there were some known
> performance
> bugs at the time against the sun vm regarding tc blocks.  This had no
> effect, and we didn't really expect any, since the bugs had to do with
> nested tcs rather than lots in serial.
>
> In the end our solution was just to be careful about the size
> of the JSPs,
> since our client could not go to the IBM vm.
>
> Jim
>
>
>
>
>
>   "Joe Barefoot"
>
>
>"Struts Users Mailing List" <[EMAIL PROTECTED]>
>
>   bal.net> cc:
>
>
>Subject:  RE:
> Improv

RE: Improving performance by splitting JSP?

[Joe Barefoot]

Thanks for the information, that's great to know.  Which VM version were you testing 
with?  Out of curiosity, did you ever run performance tests using the Sun 1.4 VM to 
see if there was an improvement?

I find it especially interesting that turning on profiling flags in the Sun VM 
increased performance--was the speed then comparable to IBM's VM?  Any speculation as 
to the cause of this?


thanks,
Joe Barefoot


> -Original Message-
> From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]]
> Sent: Monday, September 09, 2002 9:35 AM
> To: Struts Users Mailing List
> Subject: RE: Improving performance by splitting JSP?
> 
> 
> 
> 
> We also ran into problems with single JSPs containing lots of bm
> (bean:message) and bw (bean:write) tags.  We wrote our own 
> custom tag that
> did not involve Struts, and found similar behavior using the 
> Sun vm under
> both Tomcat and Weblogic on NT boxes (lousy performace with a 
> bunch of them
> in one page - much better with same number of tags split up 
> over several
> pages).  When we swapped out to the IBM vm, the discrepancy 
> in performance
> went away - both styles reasonably fast.  To get significant numbers
> (orders of magnitude difference in performance) we went to 
> thousands of
> tags, by the way.
> 
> We took lots of statistics and made a lot of posts on 
> newsgroups, and never
> really got any good explanation from anyone.  Interestingly, 
> when we turned
> profiling flags on in the sun vm to try to track what was 
> going on, the
> symptoms went away.
> 
> We experimented with try/catch blocks (manually editing 
> generated servlet
> code to drastically reduce them), since there were some known 
> performance
> bugs at the time against the sun vm regarding tc blocks.  This had no
> effect, and we didn't really expect any, since the bugs had to do with
> nested tcs rather than lots in serial.
> 
> In the end our solution was just to be careful about the size 
> of the JSPs,
> since our client could not go to the IBM vm.
> 
> Jim
> 
> 
>   
>   
>  
>   "Joe Barefoot"  
>   
>  
>"Struts Users Mailing List" <[EMAIL PROTECTED]>  
>   
>           bal.net> cc:
>   
>  
>Subject:  RE: 
> Improving performance by splitting JSP?   
  
>   09/08/2002 07:21
>   
>  
>   PM  
>   
>  
>   Please respond to   
>   
>  
>   "Struts Users   
>   
>  
>   Mailing List"   
>   
>  
>   
>   
>  
>   
>   
>  
> 
> 
> 
> 
> Wow. I dunno, but here's a guess (you could look at the code 
> generated to
> get a better idea if this is a contributing factor):
> 
> Since each JSP compiles down to a single method call in the generated
> source
> class, and (depending on how the JSP compiler generates Java 
> source) each
> custom tag could potentially have its own try/catch block as well as
> several
> local variables, the more 'stuff' you have on a single page 
> correlates to
> the amount of stack memory required for the local scope of 
> the method call.
> 
> I imagine that the overhead for the much larger (single page) 
> method call
> would hinder perfomance *somewhat*, but if splitting it up 
> increases speed
> that much, there must be something else awry here.
> 
> peace,
> Joe
> 
> 
> -Original Message-
> From: gus [mailto:[EMAIL PROTECTED]]
> Sent: Saturday, September 07, 2002 7:15 AM

RE: Improving performance by splitting JSP?

[JEWeaver]

We also ran into problems with single JSPs containing lots of bm
(bean:message) and bw (bean:write) tags.  We wrote our own custom tag that
did not involve Struts, and found similar behavior using the Sun vm under
both Tomcat and Weblogic on NT boxes (lousy performace with a bunch of them
in one page - much better with same number of tags split up over several
pages).  When we swapped out to the IBM vm, the discrepancy in performance
went away - both styles reasonably fast.  To get significant numbers
(orders of magnitude difference in performance) we went to thousands of
tags, by the way.

We took lots of statistics and made a lot of posts on newsgroups, and never
really got any good explanation from anyone.  Interestingly, when we turned
profiling flags on in the sun vm to try to track what was going on, the
symptoms went away.

We experimented with try/catch blocks (manually editing generated servlet
code to drastically reduce them), since there were some known performance
bugs at the time against the sun vm regarding tc blocks.  This had no
effect, and we didn't really expect any, since the bugs had to do with
nested tcs rather than lots in serial.

In the end our solution was just to be careful about the size of the JSPs,
since our client could not go to the IBM vm.

Jim


   
  
  "Joe Barefoot"   
  
  
  bal.net> cc: 
  
       Subject:  RE: Improving performance by 
splitting JSP? 
  09/08/2002 07:21 
  
  PM   
  
  Please respond to
  
  "Struts Users
  
  Mailing List"
  
   
  
   
  




Wow. I dunno, but here's a guess (you could look at the code generated to
get a better idea if this is a contributing factor):

Since each JSP compiles down to a single method call in the generated
source
class, and (depending on how the JSP compiler generates Java source) each
custom tag could potentially have its own try/catch block as well as
several
local variables, the more 'stuff' you have on a single page correlates to
the amount of stack memory required for the local scope of the method call.

I imagine that the overhead for the much larger (single page) method call
would hinder perfomance *somewhat*, but if splitting it up increases speed
that much, there must be something else awry here.

peace,
Joe


-Original Message-
From: gus [mailto:[EMAIL PROTECTED]]
Sent: Saturday, September 07, 2002 7:15 AM
To: [EMAIL PROTECTED]
Subject: Improving performance by splitting JSP?


Hi!

I had a performance problem in my struts application where one JSP
page took about 5 secs to display (Tomcat 4.0.4, Struts 1.1b1, Win2k,
PIII 500, 512Mb). The page uses struts taglibs (bean, logic, html) and
is nearly 300 lines long.

I tried to track down the problem but with no luck. Finally I split
the page into 3 parts using  and now the whole page
loads 5 times faster.

Does anybody made the same experience and/or has an explanation for
that behaviour?

Regards
gus



--
To unsubscribe, e-mail:
<mailto:[EMAIL PROTECTED]>
For additional commands, e-mail:
<mailto:[EMAIL PROTECTED]>


--
To unsubscribe, e-mail:   <
mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <
mailto:[EMAIL PROTECTED]>







--
To unsubscribe, e-mail:   <mailto:[EMAIL PROTECTED]>
For additional commands, e-mail: <mailto:[EMAIL PROTECTED]>

RE: Improving performance by splitting JSP?

[Joe Barefoot]

Wow. I dunno, but here's a guess (you could look at the code generated to
get a better idea if this is a contributing factor):

Since each JSP compiles down to a single method call in the generated source
class, and (depending on how the JSP compiler generates Java source) each
custom tag could potentially have its own try/catch block as well as several
local variables, the more 'stuff' you have on a single page correlates to
the amount of stack memory required for the local scope of the method call.

I imagine that the overhead for the much larger (single page) method call
would hinder perfomance *somewhat*, but if splitting it up increases speed
that much, there must be something else awry here.

peace,
Joe


-Original Message-
From: gus [mailto:[EMAIL PROTECTED]]
Sent: Saturday, September 07, 2002 7:15 AM
To: [EMAIL PROTECTED]
Subject: Improving performance by splitting JSP?


Hi!

I had a performance problem in my struts application where one JSP
page took about 5 secs to display (Tomcat 4.0.4, Struts 1.1b1, Win2k,
PIII 500, 512Mb). The page uses struts taglibs (bean, logic, html) and
is nearly 300 lines long.

I tried to track down the problem but with no luck. Finally I split
the page into 3 parts using  and now the whole page
loads 5 times faster.

Does anybody made the same experience and/or has an explanation for
that behaviour?

Regards
gus



--
To unsubscribe, e-mail:

For additional commands, e-mail:



--
To unsubscribe, e-mail:   
For additional commands, e-mail: