[ruby-core:31340] Re: [rubysoc] Queue C-extension patch to come

Hi,
On 18 July 2010 02:05, Nobuyoshi Nakada <[e-mail]> wrote:
> Hi,
>
> At Sun, 18 Jul 2010 06:00:56 +0900,
> Ricardo Panaggio wrote in [ruby-core:31333]:
>> My implementation is almost 4 times faster than the existing one.
>> Maybe it's enough, maybe it's not. Let me know if it isn't, so that I
>> can make any extra tuning, if needed.
>
> It was 3 and a half faster on my machine.
>
> ser system otal eal
> ueue: 00| .990000 0.030000 1.020000 ( .036857)
> ueue: 1000| .910000 0.320000 0.230000 ( 10.677039)
> ueue:10000| 99.010000 3.130000 102.140000 (105.404587)
> ser system otal eal
> Thread::Queue: 00| .280000 0.020000 0.300000 ( .315329)
> Thread::Queue: 1000| .870000 0.140000 3.010000 ( .050338)
> Thread::Queue:10000| 28.540000 1.450000 9.990000 ( 30.711049)
>
> Thread::Queue is C-implementation.
> --
> Nobu Nakada

3 times on my machine:
                          user     system      total        real
Queue: 100            0.380000   0.020000   0.400000 (  0.390914)
Queue: 1000           3.750000   0.130000   3.880000 (  3.934827)
Queue: 10000         37.270000   1.340000  38.610000 ( 39.136691)
Thread::Queue: 100    0.130000   0.000000   0.130000 (  0.132765)
Thread::Queue: 1000   1.260000   0.060000   1.320000 (  1.353208)
Thread::Queue: 10000 12.490000   0.580000  13.070000 ( 13.228104)

(ruby 1.9.3dev (2010-07-18 trunk 28676) [x86_64-darwin10.4.0] with the
patch of Nobu)

Just for the fun, I did another benchmark to compare method by method,
running each N time (this is obviously not real word use).
#clear is using #push(N/2 times), so results are exaggerated for Ruby
(actually Ruby beats C if it is only N.times{q.clear}).
(See http://gist.github.com/480359)
Q is Queue, T is Thread::Queue (C)
                    user     system      total        real
Q#push          0.810000   0.000000   0.810000 (  0.818967)
T#push          0.350000   0.000000   0.350000 (  0.369173)
Q#pop           1.710000   0.010000   1.720000 (  1.719467)
T#pop           0.340000   0.000000   0.340000 (  0.344720)
Q#empty?        0.200000   0.000000   0.200000 (  0.202756)
T#empty?        0.310000   0.000000   0.310000 (  0.317207)
Q#clear         0.590000   0.000000   0.590000 (  0.586336)
T#clear         0.450000   0.000000   0.450000 (  0.450514)
Q#size          0.160000   0.000000   0.160000 (  0.162851)
T#size          0.310000   0.000000   0.310000 (  0.316331)
Q#num_waiting   0.160000   0.010000   0.170000 (  0.166712)
T#num_waiting   0.310000   0.000000   0.310000 (  0.315460)

So, Ruby implementation seems faster for #empty?, #size and
#num_waiting (and #clear), which are all methods with a simple call to
an Array method.
But C #push ~2 times faster, and #pop ~5 times faster (implementation
is better in C).
Knowing these are the most used operations, this is a good improvement.

B.D.

P.S.: queue.c:82 produce a warning: (braces around scalar initializer
(near initialization for 倉ueue_data_type.dmark)