[ANN] fastthread 0.6.2

ruby-talk
1

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-locking/fastthread-0.6.2.gem

Tarball:
http://moonbase.rydia.net/software/optimized-locking/fastthread-0.6.2.tgz

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

2

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

···

On 1/18/07, MenTaLguY <mental@rydia.net> wrote:

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.

3

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.

   Any reasons for not including it in the standard ruby library?

···

On 1/19/07, MenTaLguY <mental@rydia.net> wrote:

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-locking/fastthread-0.6.2.gem

Tarball:
http://moonbase.rydia.net/software/optimized-locking/fastthread-0.6.2.tgz

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

--
If it's there, and you can see it, it's real.
If it's not there, and you can see it, it's virtual.
If it's there, and you can't see it, it's transparent.
If it's not there, and you can't see it, you erased it.

4

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

-mental

···

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?

5

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

···

On Fri, 2007-01-19 at 13:03 +0900, Tim Pease wrote: