Forum: Ruby fastthread 0.6.2

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
912c61d9da47754de7039f4271334a9f?d=identicon&s=25 MenTaLguY (Guest)
on 2007-01-19 16:31
(Received via mailing list)
It looks like I got too creative in 0.6.1 and consequently ran afoul of
a bug in the Ruby interpreter.  0.6.2 works around the bug and should be
entirely stable at this point.

Thanks to Young Hyun for his help in coming up with test cases.

== what?

fastthread is a Ruby library which provides a faster (and
non-memory-leaking) C implementation of the concurrency primitives from
stdlib's thread.rb.  It aims to be 100% compatible with thread.rb's
public API.

So, how much faster?  In the single-threaded case, fastthread's version
of Mutex#lock and Mutex#synchronize are comparable in performance to
Thread.critical= and Thread.exclusive.  With multiple threads, it has an
additional advantage over Thread.critical in that entering a critical
section doesn't suspend any other threads unless they're competing for
the same lock.  (Compare that to Thread.critical, which stops all other
threads dead!)

I know a lot of folks have been avoiding stdlib's Mutex because all the
method calls killed performance.  But no more, with fastthread!  Why use
Thread.critical when you can use the real thing?

== how?

Simply require 'fastthread' in addition to 'thread'.  If you want to
make fastthread optional (recommended!), do it this way:

        require 'thread'
        begin
          require 'fastthread'
        rescue LoadError
        end

This way, your program will still work on systems that don't have (or
don't need -- e.g. JRuby) fastthread, but you still get a performance
boost on systems where it's available.

== where?

Gem:
http://moonbase.rydia.net/software/optimized-locki...

Tarball:
http://moonbase.rydia.net/software/optimized-locki...

fastthread is also available on Rubyforge (and therefore the main gems
repository), courtesy of the Mongrel project:

https://rubyforge.org/frs/?group_id=1306

-mental
912c61d9da47754de7039f4271334a9f?d=identicon&s=25 Mental Guy (mental)
on 2007-09-25 22:36
(Received via mailing list)
On Fri, 2007-01-19 at 13:03 +0900, Tim Pease wrote:

> Does fastthread allow you to see who has the lock on the mutex?

fastthread is just a re-implementation of the standard API offered by
Mutex, ConditionVariable, Queue and SizedQueue in thread.rb.  That isn't
an ability offered by stdlib's Mutex.

> Sync allows you to do this,

Not safely, actually.  Why do you need to do that?

> and it allows me to write re-entrant methods much more easily.

Yes, since Sync locks are reentrant, but personally I would avoid Sync
because it has some bugs, memory leaks, and the implementation isn't
very nice generally.

If do you need both a reentrant lock and the ability to see who's
currently holding it, what I'd suggest instead is writing your own lock
class along these lines:

 class MyLock
   def initialize
     @lock = Mutex.new
     @ready = ConditionVariable.new
     @count = 0
   end

   def lock
     @lock.synchronize do
       @ready.wait @lock while @owner and @owner != Thread.current
       @owner = Thread.current
       @count += 1
     end
     self
   end

   def unlock
     @lock.synchronize do
       return self unless @owner
       @count -= 1
       if @count.zero?
         @owner = nil
         @ready.signal
       end
     end
     self
   end

   # safely pass the current holder of the lock to a block
   def with_locker
     @lock.synchronize { yield @owner }
   end
 end

The above code should work fine with or without fastthread.  fastthread
would just make it a little faster (I'd recommend making it an optional
require, as described in the announcement).

I'd strongly recommend against writing code which checks the current
owner of a lock, by the way, but if you really need to do it (I don't
know your specific requirements), something like MyLock#with_locker is
probably the safest way to do so.

-mental
Db0cb55ad80691cc17e8760d6ca2d660?d=identicon&s=25 Vlad GALU (Guest)
on 2007-09-25 22:41
(Received via mailing list)
On 1/19/07, MenTaLguY <mental@rydia.net> wrote:
> stdlib's thread.rb.  It aims to be 100% compatible with thread.rb's
> public API.

   Any reasons for not including it in the standard ruby library?
912c61d9da47754de7039f4271334a9f?d=identicon&s=25 Mental Guy (mental)
on 2007-09-25 22:45
(Received via mailing list)
On Fri, 2007-01-19 at 16:35 +0900, Vlad GALU wrote:
> > fastthread is a Ruby library which provides a faster (and
> > non-memory-leaking) C implementation of the concurrency primitives from
> > stdlib's thread.rb.  It aims to be 100% compatible with thread.rb's
> > public API.
>
>    Any reasons for not including it in the standard ruby library?

I want to make sure it's sufficiently polished, first.  Then I will
indeed submit it as a patch.

-mental
4d5b5dd4e263d780a5dfe7ac8b8ac98c?d=identicon&s=25 Tim Pease (Guest)
on 2007-09-25 22:49
(Received via mailing list)
On 1/18/07, MenTaLguY <mental@rydia.net> wrote:
> stdlib's thread.rb.  It aims to be 100% compatible with thread.rb's
> I know a lot of folks have been avoiding stdlib's Mutex because all the
>           require 'fastthread'
>         rescue LoadError
>         end
>
> This way, your program will still work on systems that don't have (or
> don't need -- e.g. JRuby) fastthread, but you still get a performance
> boost on systems where it's available.
>

Does fastthread allow you to see who has the lock on the mutex?  Sync
allows you to do this, and it allows me to write re-entrant methods
much more easily.

Blessings,
TwP
This topic is locked and can not be replied to.