Jarosław Zabiełło - BLOG: Tag yarv

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

Jarosław Zabiełło — Sun, 16 Dec 2007 03:08:00 +0100

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.

Otóż Ruby 1.9 (z założenia) nie jest wersją do użytku publicznego (jako naturalne zastępstwo dla Rubiego 1.8.x). Ten numer wersji to tylko informacja kierowana tylko do developerów języka Rubiego, że zamrożono API wewnętrznych funkcji C i teraz trwa proces jego stabilizacji. Ten krok był niezbędny w związku w integracją wirtualnej maszyny YARV. Wprowadziła ona taką rewolucję w wewnętrznej implementacji Rubiego, że trzeba było zaprowadzić jak najszybciej porządek w API aby wszelkie rozszerzenia w C działaly spójnie i stabilnie.

Co to wszystko znaczy dla użytkowników Rubiego czy Railsów? Po pierwsze, należy zapomnieć o tym, że Rails będzie chodził na Ruby 1.9, trzeba zaczekać do Rubiego 2.0 a może i 2.1. Pewnie jakiś rok, trudno powiedzieć. Prawie na pewno, Ruby 2.0 nie będzie w pełni zgodny z 1.8. Ma za to być lepszy, szybszy, posiadać pełny Unicode itp. Trzeba więc będzie trochę popracować nad dopracowaniem zgodności Rails i innych aplikacji z Ruby 2.0.

Jeśli ktoś chce przyśpieszyć aplikacje webowe działające w Ruby to może popróbować użycia JRuby. Już teraz jest on szybszy od klasycznego Rubiego 1.8.x a prace optymalizacyjne dopiero nabierają tempa. JRuby 1.1 (ma wyjść w tym miesiącu) ma wejść w dalszą fazę optymalizacji i odchudzania. To, plus fakt, że wirtualna maszyna Javy (JVM) sama w sobie jest bardzo mocno zoptymalizowana wydajnościowo (tak że czasem bije na głowę C++) powoduje, że to jest obiecujący kierunek rozwoju.

Innym wyjściem jest pożegnanie się z Rails i spróbowanie konkurencyjnego frameworku – Merb. Generalnie jest bardzo podobny do Rails, więc migracja jest łatwa. Merb jest za to dużo szybszy, wielowątkowy i bardziej uporządkowany. Oczywiście Merb można też odpalać pod JRuby, choć tego jeszcze nie próbowałem.

Python vs. Ruby 1.9 YARV. Cz. II

Jarosław Zabiełło — Sat, 06 Jan 2007 18:44:00 +0100

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:

Python 2.5: 3.86356806755 s.
Python 2.4 4.09678792953 s.
Ruby 1.9: 6.418052 s.
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.

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

Jarosław Zabiełło — Mon, 01 Jan 2007 19:36:00 +0100

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:

Lua: 1.14 s
Ruby 1.9: 1.49 s
PHP 5.2: 1.74 s
Python 2.5: 2.64 s
Python 2.4.3: 2.72 s
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

Ruby 1.9: 2.0953268 s.
Lua 5.1: 2.4 s.
Python 2.5: 2.49481592178 s.
Python 2.4.3: 2.71687791348 s.
PHP 5.2: 4.2 s.
Ruby 1.8.5: 9.0153751 s.

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