Ruby 1.9 nie jest i (nie będzie) przeznaczony do użytku publicznego

Opublikowane przez Jarosław Zabiełło Sun, 16 Dec 2007 02:08:00 GMT

Wiele zamieszania i niezrozumienia panuje wokół mającej wkrótce być wydanej wersji Rubiego 1.9. Wiemy już teraz, że zawiera wbudowaną wirtualną maszynę YARV i jest w testach 3-10x szybszy od Rubiego 1.8.x. Wiele osób sobie ostrzy zęby na przyśpieszenie aplikacji Rubiego działających na Ruby 1.9, np. Rails. Nie bardziej błędnego.

Czytaj dalej...

Tagi ,  | 10 comments

Python vs. Ruby 1.9 YARV. Cz. II

Opublikowane przez Jarosław Zabiełło Sat, 06 Jan 2007 17:44:00 GMT

Z wcześniejszych testów wynikało że Ruby 1.9 (wykorzystujący wirtualną maszynę YARV) jest szybszy od Pythona. Aby zwolennicy Rubiego zbyt się nie cieszyli, przygotowałem test na wywołania rekurencyjne. Najcięższą jest tu funkcja rekurencyjna. Długość 7 znaków daje prawie 900 tys. wywołań rekurencyjnych i w miarę sensowne czasy aby coś zobaczyć. Postanowiłem ją wziąć na rozkład. Tym razem z 10 prób brany jest najlepszy (najkrótszy) wynik.

Python:

try:
  import psyco
  psyco.all()
except:
  pass

from time import time
def wariancje(s, n):
    if n==0:
      yield []
    else:
        for i in xrange(len(s)):
            for c in wariancje(s, n-1):
                yield [s[i]] + c
s = "abcdefg"
nelem = len(s)
i = 0
results = []
for unused in range(10):
  t = time()
  for s in wariancje(s, nelem):
    i += 1
  tmp = time() - t
  results.append(tmp)
  print tmp
print min(results), max(results), nelem, i

Ruby

def wariancje(s, n)
  if n == 0
    yield []
  else
    s.size.times do |i|
      wariancje(s, n-1) { |c| yield [s[i]] + c }
    end
  end
end
t = Time.now
s = "abcdefg"
size = s.size
i = 0
results = []
10.times do
  t = Time.now
  wariancje(s, size) do
    i += 1
  end
  tmp = Time.now - t
  results << tmp
  puts tmp
end
puts "\n#{results.min}, #{results.max}, #{size}, #{i}"

Rezultat:

  1. Python 2.5: 3.86356806755 s.
  2. Python 2.4 4.09678792953 s.
  3. Ruby 1.9: 6.418052 s.
  4. Ruby 1.8.5: 8.000223 s.

Tym razem Python nie dał szans Rubiemu. Jest od niego wyraźnie szybszy. Jednak na obronę można powiedzieć że YARV nie jest tu jeszcze zbyt zoptymalizowany. Wiele opcji optymalizacyjnych ma po prostu wyłączonych, Ruby 1.9 i YARV to na razie kod eksperymentalny. Na razie więc dominacja wydajnościowa Pythona jest niepodważalna.

Tagi , , ,  | 10 comments

Ruby 1.9 (YARV) vs. Python, Lua & PHP

Opublikowane przez Jarosław Zabiełło Mon, 01 Jan 2007 18:36:00 GMT

Korzystając z tego, że niedawno do repozytorium Rubiego został dodany YARV (wirtualna maszyna Rubiego) pokusiłem się o małe porównanie wydajności. Jako test użyłem prostego programu jaki pojawił się na liście pl.comp.lang.pyhon (musiałem tylko trochę zwiększyć pętle do 10 milionów iteracji, aby były widoczne jakieś wyniki) Użyty sprzęt: Athlon64 3700+, 64bit Ubuntu 6.0.6.

Sprawdziłem też z ciekawości PHP 5.2 na tym samym sprzęcie. Dla tak prostego testu powinien móc dać z siebie wszystko. Jest jednak wolniejszy od Rubiego 1.9.

Kod dla Pythona:

import time
t=time.time()
a=0
for i in xrange(10000000):
    a += i
print a
print time.time() - t
Kod dla Lua:
t = os.clock()
a = 0
for i = 1,10000000 do
    a=a+i
end
print(a)
print(os.clock() - t)

Kod dla Rubiego:

t = Time.now
a = 0
for i in 1..10_000_000
  a = a+i
end
puts a
puts Time.now - t

Kod dla PHP:

<?php
function microtime_float() {
 $time = microtime();
 return (double)substr($time, 11) + (double)substr($time, 0, 8);
}
$t =  microtime_float();
$a = 0;
for ($i = 0; $i < 10000000; $i++) {
  $a += $i;
}
print "$a\n";
print  microtime_float()- $t;
?>

Wyniki:

  1. Lua: 1.14 s
  2. Ruby 1.9: 1.49 s
  3. PHP 5.2: 1.74 s
  4. Python 2.5: 2.64 s
  5. Python 2.4.3: 2.72 s
  6. Ruby 1.8.5: 3.83 s.

Drugie podejście

Tym razem wynik uśredniam dla 10 prób. Zwiększyłem ilość iteracji do 20 mln. No i… Ruby 1.9 pobił wszystko. Zarówno Pythona jak i Lua! (PHP 5.2 po 30 sek. zgłosił timeout. Musiałem więc uśrednić po 5 wynikach.)

PYTHON

import time
def bench():
    a, t = 0, time.time()
    for i in xrange(20000000):
        a+=i
    return time.time()-t
result = 0
for i in range(10):
  result += bench()
print result / 10.0

RUBY

def bench
  a, t = 0, Time.now
  20_000_000.times { |i| a += i }
  Time.now - t
end
result = 0
10.times { |i| result += bench }
puts result / 10

LUA

function bench()
  a = 0
  t = os.time()
  for i = 1, 20000000 do
    a = a + i
  end
  return os.time() - t
end
result = 0
for x = 1,10 do
  result = result + bench()
end
print(result/10)

PHP

<?php
function bench() {
  $a = 0;
  $t =  time();
  for ($i = 0; $i < 20000000; $i++) $a += $i;
  return time() - $t;
}
$result = 0;
for ($x = 1; $x <= 5; $x++) $result += bench();
print $result / 5.0;
?>

Wyniki

  1. Ruby 1.9: 2.0953268 s.
  2. Lua 5.1: 2.4 s.
  3. Python 2.5: 2.49481592178 s.
  4. Python 2.4.3: 2.71687791348 s.
  5. PHP 5.2: 4.2 s.
  6. Ruby 1.8.5: 9.0153751 s.

Jestem ciekaw kiedy wyjdzie Rails dostosowany do Ruby 1.9. Zapowiada się bardzo obiecująco!

Posted in , ,  | Tagi , , , , ,  | 19 comments