[Ruby] String concatenation performance in Rails partials

[Tom Lianza]

Evan and a few others saw me working on this problem tonight, and I just
stumbled upon a development that was fairly surprising to me.

Basically, I have a chunk of HTML I want to render, say, 50 times on a page
(this is a 'search results' page).  Each of the objects looks very similar,
so I use a partial, and call it 50 times. Rails has a convenient way of
doing this:

<%=render(:partial=>'list_item', :collection=>bookmark_list)%>
(bookmark_list is an array of 50 things)--------------^

The problem is that this seemed to be taking a long time to render.  The DB
query was quick, but the rendering took 2.5 seconds per request (benchmark
of 6 consecutive requests):
    user     system      total        real
  2.270000   0.040000   2.310000 (  2.483692)
  2.230000   0.030000   2.260000 (  2.488522)
  2.230000   0.020000   2.250000 (  2.477388)
  2.250000   0.040000   2.290000 (  2.622520)
  2.250000   0.040000   2.290000 (  2.768218)
  2.270000   0.030000   2.300000 (  2.727301)

Here's the thing that's really weird - I ripped out the code I was looping
on (the ruby and html in the list_item partial) and replaced it with totally
static code - no ruby at all.  The performance was virtually *identical.*

So, on a hunch, I took that partial (about 40 lines html) and removed all of
the whitespace, so it was all on one line.  The performance changed fairly
dramatically:

     user     system      total        real
  1.500000   0.020000   1.520000 (  1.808402)
  1.470000   0.030000   1.500000 (  1.698254)
  1.470000   0.020000   1.490000 (  1.905468)
  1.460000   0.020000   1.480000 (  1.622462)
  1.500000   0.030000   1.530000 (  1.923870)
  1.490000   0.030000   1.520000 (  2.136822)

Rendering time was cut by about 1/3.

If I cut down the html so I'm rendering a tiny amount (like one short line)
the whole thing screams.  So... this really smells to me like some kind of
string concatenation problem/slowdown.  Is anyone familliar with these kinds
of issues in Ruby?  Or, might there be an issue in the Rails code?  I had
never heard any recommendations that stripping whitespace out of templates
improves performance in any way, so I feel like this kind of behavior is not
by design.

Thanks,
Tom