From: Weston Sewell <weston.sewell@...>
Date: 2009-05-15T16:37:56+09:00
Subject: [ruby-core:23456] REXML Thread Safety

--0016369891d511b00f0469ee859b
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: 7bit

I've been using Ruby for several years but I just joined the list because I
ran into a problem that I'm not sure how to solve (sorry for not lurking for
the requisite eon, I've been working night and day on a Ruby project for
work).

It appears that REXML may not be completely thread-safe. Is it intended to
be? I've run into a problem that I was able to reproduce in a test that I'll
post at the bottom. Basically, it appears that accessing either #to_s or
#value on REXML::Attribute causes a change in the state of the instance
(setting @normalized and @unnormalized to a computed value or 'nil'). And
since these are not intended to be "destructive" calls, neither are some of
the Element methods that call them (i.e. Element#inspect). When using
threads of course we are not protecting non-destructive calls with semaphors
(and actually we are using XMPP4r so we don't have complete conrol over what
gets called and how).

Is there anyone who is familiar with this situation?

TIA
Weston

Test Code  - exception occurs in either #to_s or #value (on my system this
always happens within 900 iterations)
------------------------------------------------------------------------------
common_doc = REXML::Document.new( '<foo bar="somevalue" />' )

def parse(doc)
    foo = doc.root
    foo.inspect
    foo.attributes['bar']
end

def multiparse(doc)
    1000000.times do |iteration|
        puts "Iteration #{iteration}" if(iteration == 0 || (iteration % 100
== 0))
        parse(doc)
    end
end

threads = []
threads << Thread.new { multiparse(common_doc) }
threads << Thread.new { multiparse(common_doc) }
threads << Thread.new { multiparse(common_doc) }
threads << Thread.new { multiparse(common_doc) }
threads << Thread.new { multiparse(common_doc) }
threads << Thread.new { multiparse(common_doc) }

threads.each do |thread|
    thread.join
end

--0016369891d511b00f0469ee859b
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

I&#39;ve been using Ruby for several years but I just joined the list becau=
se I ran into a problem that I&#39;m not sure how to solve (sorry for not l=
urking for the requisite eon, I&#39;ve been working night and day on a Ruby=
 project for work).<br>
<br>It appears that REXML may not be completely thread-safe. Is it intended=
 to be? I&#39;ve run into a problem that I was able to reproduce in a test =
that I&#39;ll post at the bottom. Basically, it appears that accessing eith=
er #to_s or #value on REXML::Attribute causes a change in the state of the =
instance (setting @normalized and @unnormalized to a computed value or &#39=
;nil&#39;). And since these are not intended to be &quot;destructive&quot; =
calls, neither are some of the Element methods that call them (i.e. Element=
#inspect). When using threads of course we are not protecting non-destructi=
ve calls with semaphors (and actually we are using XMPP4r so we don&#39;t h=
ave complete conrol over what gets called and how).<br>
<br>Is there anyone who is familiar with this situation?<br><br>TIA<br>West=
on<br><br>Test Code=A0 - exception occurs in either #to_s or #value (on my =
system this always happens within 900 iterations)<br>----------------------=
--------------------------------------------------------<br>
common_doc =3D REXML::Document.new( &#39;&lt;foo bar=3D&quot;somevalue&quot=
; /&gt;&#39; )<br><br>def parse(doc)<br>=A0=A0=A0 foo =3D doc.root<br>=A0=
=A0=A0 foo.inspect<br>=A0=A0=A0 foo.attributes[&#39;bar&#39;]<br>end<br><br=
>def multiparse(doc)<br>
=A0=A0=A0 1000000.times do |iteration|<br>=A0=A0=A0=A0=A0=A0=A0 puts &quot;=
Iteration #{iteration}&quot; if(iteration =3D=3D 0 || (iteration % 100 =3D=
=3D 0))<br>=A0=A0=A0=A0=A0=A0=A0 parse(doc)<br>=A0=A0=A0 end<br>end<br><br>=
threads =3D []<br>threads &lt;&lt; Thread.new { multiparse(common_doc) }<br=
>
threads &lt;&lt; Thread.new { multiparse(common_doc) }<br>threads &lt;&lt; =
Thread.new { multiparse(common_doc) }<br>threads &lt;&lt; Thread.new { mult=
iparse(common_doc) }<br>threads &lt;&lt; Thread.new { multiparse(common_doc=
) }<br>
threads &lt;&lt; Thread.new { multiparse(common_doc) }<br><br>threads.each =
do |thread|<br>=A0=A0=A0 thread.join<br>end<br><br>

--0016369891d511b00f0469ee859b--