Bystroushaak's blog / Czech section / Programování / Stackless python

Stackless python

Možná jste někdy měli na potřebu paralelizace vašeho pythonního scriptu a thready se pro vás ukázaly jako nevhodné z důvodu jejich vysoké náročnosti (zkuste si spustit 800 threadů a pochopíte o čem mluvím). Přesně pro takovéto případy byl vytvořen Stackless python, který vám umožní používat microthready/korutiny/tasklety za použití preemptivního multitaskingu.

Update

Na základě diskuze jsem se dozvěděl, že pythonní interpreter PyPy má v sobě podporu Stackless přímo zabudovanou. Pokud uvažujete o použití Stackless, tak tohle asi bude lepší cesta, než kompilace interpreteru.

Instalace

Instalaci jsem prováděl na Mintu 13, ale měla by být dost podobná na téměř všech debianovských systémech, kde již je nainstalován python 2.7. Postup je poměrně jednoduchý, ale je nutné kompilovat a upravit jeden konfigurák. Níže uvedené příkazy to automatizují tak, že je v podstatě jen stačí napastovat do konzole a občas zadat heslo na roota.

Návod je založený na článku Install Stackless Python on Ubuntu.

Příprava systému

sudo apt-get update
sudo apt-get install libreadline-dev
sudo apt-get build-dep python2.7

Stažení poslední verze stackless pythonu

cd /tmp
LAST_SL=`wgethttp://www.stackless.com/binaries/-O-2>/dev/nullgrepexport.tar.bz2grep-vmd5cut-d'"'-f8grep"stackless-2"sort|tail-n1`
wget "http://www.stackless.com/binaries/$LAST_SL"
 
tar -xvf $LAST_SL
rm $LAST_SL
LAST_SL=`echo$LAST_SL|cut-d"."-f1`
cd $LAST_SL

Kompilace a instalace

./configure --prefix=/opt/stackless --enable-unicode=ucs4
make
sudo make install

Poinstalační fix

Doplnění symlinků na standardní pythonní moduly a úprava cest, kde má stackless hledat moduly. Úprava konfiguráku proběhne automaticky, použil jsem k tomu python, protože se mi nechtělo hrát si 7 hodin se sedem a jeho escape sekvencemi.

sudo ln -s /usr/lib/python2.7/dist-packages/ /opt/stackless/lib/python2.7/site-packages
sudo ln -s /usr/local/lib/python2.7/dist-packages/ /opt/stackless/lib/python2.7/dist-packages
sudo ln -s /opt/stackless/bin/python /usr/bin/stackless
 
cd /opt/stackless/lib/python2.7/
sudo python -c "a = '            sitepackages.append(os.path.join(prefix, \"lib\", \"site-python\"))'; print open('site.py').read().replace(a, '            sitepackages.append(os.path.join(prefix, \"lib\", \"python\" + sys.version[:3], \"dist-packages\"))\n'+a)" > /tmp/site_.py
sudo mv /tmp/site_.py site.py

Odstranění instalačního smetí

cd /tmp
rm -fr $LAST_SL

Test interpreteru

Interpreter se spouští příkazem stackless.

$ stackless
Python 2.7.5 Stackless 3.1b3 060516 (default, Oct 28 2013, 15:34:27) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import stackless
>>>

Používání

Z programátorského hlediska probíhají interakce skrze modul stackless, který si ve Stackless interpreteru naimportujete. V klasickém pythonu vám importovat nepůjde, protože pro svůj běh vyžaduje úpravy interpreteru a způsobu, jakým jsou volány funkce (stackless = bez stacku).

Vytvoření taskletu

>>> import stackless
>>> def funkce(parametr):
...     print parametr
... 
>>> t = stackless.tasklet(funkce)("prvni")
>>>

Co se vlastně ve výše uvedeném kódu stalo? Vytvořil jsem funkci nazvanou poeticky funkce, která přijímá jeden parametr, jenž je vypsán na stdout. Z této funkce jsem poté udělal takzvaný tasklet a předal mu textový parametr „první“.

Tasklet byl automaticky přidán do interní fronty uvnitř modulu stackless. Reference na něj byla uložena do proměnné t.

Operace nad tasklety

Jak už jsem psal, jednotlivé tasklety jsou uchovávány ve frontě taskletů, Do této fronty mohou být přidávány pomocí .insert(), která tasklet přidá na konec fronty a také z ní mohou být odebírány pomocí .remove(). Pokud chcete přesunout konkrétní tasklet na začátek fronty a spustit ho, použijte .run(). Jestli potřebujete tasklet zabít, tak .kill().

Pro úplnost dodám, že tyto metody se volají přímo nad instancí konkrétního taskletu, tedy nad t z ukázky, nikoliv nad modulem stackless.

Ukázka

Pokud zavoláme nad konkrétním taskletem .run(), tak se přesune na vrchol fronty a provede:

>>> t.run()
prvni

Tasklet může proběhnout jen jednou, proto pokusíme-li se ho spustit znova, dostaneme chybu:

>>> t.run()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
RuntimeError: You cannot run an unbound(dead) tasklet

Běh fronty taskletů

Výše uvedené ukázky nejsou moc platné a v podstatě neukazují nic, co by neuměl python sám o sobě. Nyní vám předvedu, jak spustit celou frontu taskletů:

#!/usr/bin/env stackless
# -*- coding: utf-8 -*-
import time
import stackless
 
 
def funkce(parametr):
    t1 = time.time()
    print "starting", parametr, t1
     
    for i in range(10000000):
        pass
 
    t2 = time.time()
    print "ending", parametr, t2, "-", t2 - t1
 
 
stackless.tasklet(funkce)("prvni")
stackless.tasklet(funkce)("druhy")
stackless.tasklet(funkce)("treti")
 
 
while stackless.getruncount() > 1:
    t = stackless.run(100)
 
    if t:
        t.insert()

funkce() tentokrát obsahuje výpis informací pro primitivní benchmark. Všimněte si foru, který iteruje skrz 10000000 položek. Použil jsem ho záměrně místo time.sleep(). Proč se dozvíte za okamžik.

while cyklus na konci scriptu obstarává veškerou práci - z fronty vyjme jeden tasklet, nechá ho proběhnout 100 python instrukcí a pokud mezi tím neskončil, tak ho vloží na konec fronty.

Z výše uvedeného odstavce plynou dvě věci:

  1. Jedná se o preemptivní multitasking.
  1. Multitasking se vztahuje na instrukce pythonního bytecode, ne na volání C API.

Nyní doufám chápete, proč jsem použil místo time.sleep() for smyčku - time.sleep() je callback na C API, což znamená, že se na něj multitasking nevztahuje. To je dobré mít na paměti.

Zatímco kooperativního multitaskingu lze do jisté míry dosáhnout i v obyčejném pythonu pomocí generátorů, preemptivní je možné dosáhnout pouze pomocí procesů, threadů, či Stackless pythonem, jehož tasklety jsou nejméně náročné na prostředky počítače.

Výstup

$ time stackless stackless.py 
starting prvni 1382985236.72
starting druhy 1382985237.26
starting treti 1382985237.8
ending druhy 1382985243.4 - 6.14155387878
ending prvni 1382985243.67 - 6.95054602623
ending treti 1382985243.92 - 6.12157416344
 
real    0m8.101s
user    0m6.888s
sys 0m1.136s

Pokud nechám funkci proběhnout třikrát lineárně za sebou, dostanu tyto hodnoty:

$ time stackless stackless.py 
starting první 1382985343.08
ending první 1382985345.28 - 2.19586610794
starting druhá 1382985345.28
ending druhá 1382985346.91 - 1.63068413734
starting třetí 1382985346.91
ending třetí 1382985348.51 - 1.59492611885
 
real    0m5.804s
user    0m5.036s
sys 0m0.568s

Paralelní běh tedy trval o 2.3s déle, než běh lineární. To je daň za přepínání taskletů a hlavně za jejich spuštění a ukončení, což je dle výpisu poměrně časově náročná činnost trvající desítky/stovky milisekund.

Rozdíl mezi kooperativním a preemptivním multitaskingem

Mladší ročníky, které si nepamatují doby DOSu a prvních Windows možná nebudou tušit, jaký je rozdíl mezi kooperativním a preemptivním multitaskingem.

Kooperativní multitasking je triviálnější. Spočívá v tom, že funkci (či procesu/programu) předáte řízení a doufáte, že vám ho někdy vrátí, aby jste mohli provést zase něco jiného. Po dobu běhu funkce nemáte nad systémem žádnou kontrolu a musíte doufat, že se funkce nedostane do stavu, kde se zasekne a celý systém zamrzne.

V kooperativním multitaskingu může běžet víc procesů zároveň, ale je na procesech, aby běžely jen zlomky času, po kterém vždy vrátí řízení systému, který mezi nimi přepne. Pokud se náhodou nějaký proces zdrží, tak všechny běžící procesy na chvíli zmrznou.

Preemptivní multitasking je chytřejší, i když náročnější na implementaci a na běh. Místo toho, aby procesu předal kompletní řízení mu předává řízení jen na nějaký okamžik. Může to být třeba na 1ms, nebo na 1000 instrukcí, to už záleží na konkrétní implementaci. Výhoda je v tom, že pokud se daný proces/fukce/program zasekne, tak neshodí celý systém a ostatní funkce/procesy/.. dále běží.

Kooperativní multitasking v pythonu

Pokud by někoho zajímalo, jak by vypadala výše uvedená ukázka přepsaná do čistého pythonu v kooperativním režimu pomocí generátorů:

#!/usr/bin/env python
# -*- coding: utf-8 -*-
import time
 
def funkce(parametr):
    t1 = time.time()
    print "starting", parametr, t1
     
    for i in range(10000000):
        if i % 100 == 0:
            yield
 
    t2 = time.time()
    print "ending", parametr, t2, "-", t2 - t1
 
 
fronta = [
    funkce("prvni"),
    funkce("druhy"),
    funkce("treti"),
]
 
while len(fronta) > 0:
    for f in fronta:
        try:
            f.next()
        except StopIteration:
            fronta.remove(f)

a zde je výstup:

$ time ./yield.py 
starting prvni 1382984400.16
starting druhy 1382984400.6
starting treti 1382984401.04
ending prvni 1382984412.9 - 12.7446539402
ending treti 1382984413.17 - 12.1312551498
ending druhy 1382984413.44 - 12.8393118382
 
real    0m14.347s
user    0m12.757s
sys 0m1.112s

Pokud dojde ve forsmyčce, kde je vyhazován yield k chybě (třeba nějaký cyklus, nebo špatně vyhodnocená podmínka), celý kód se zasekne a nepoběží ani jeden ze tří generátorů.

Zajímavé je, že kód běžel delší dobu, než v případě Stackless taskletů. Povšimněte si pořadí ukončení jednotlivých generátorů.

Pro úplnost dodám, že Stackless také umožňuje kooperativní multitasking, jen místo yield voláte stackless.schedule(). Jelikož python nabízí dost podobnou funkcionalitu v základu, nebudu se tím dále zabývat.

Komunikace

Jednotlivé tasklety spolu mohou komunikovat pomocí kanálů, což je vlastnost, kterou čisté pythonní generátory až do nedávna neměly a i v dnešní době to není tak přímočaré.

Kanál je možné vytvořit pomocí volání stackless.channel(). Data se odesílají přes volání ch.send() a přijímají přes ch.receive(). Dotaz na počet zpráv v kanálu je možné provést skrz property ch.balance (default 0).

Jak příjem, tak odesílání dat je blokující a zasekne celý tasklet. Nemá cenu to zkoušet v singleplayeru, pokud nemáte kód, který běží paralelně tak se to prostě zasekne a nic se neděje.

Zde je ukázka posílání dat mezi dvěma funkcemi:

#!/usr/bin/env stackless
# -*- coding: utf-8 -*-
import time
import stackless
 
def prvni(ch):
    ch.send("odesláno z první")
 
def druha(ch):
    print "druhá:", ch.receive()
 
 
ch = stackless.channel()
 
stackless.tasklet(prvni)(ch)
stackless.tasklet(druha)(ch)
 
 
while stackless.getruncount() > 1:
    t = stackless.run(100)
 
    if t:
        t.insert()

Odeslat je možné všechno možné, nemusí to být string, ale klidně pole, číslo atp..

Výstup

$ ./stackless.py 
druhá: odesláno z první

To je vše?

Téměř vše. Dokumentace se ještě zmiňuje o serializaci taskletů/kanálů, ale protože jsem to zatím neměl potřebu použít, tak jí zde nebudu rozmazávat - tenhle článek se brutálně zvrhl z osobních poznámek k instalaci, protože jsem zapomněl přestat psát. Berte ho tedy spíš jako takové představení Stackless v češtině, ne kompletní manuál.

Pokud vás Stackless zaujal, vřele doporučuji navštívit jeho domovskou stránku a přečíst si dokumentaci - jedná se jen o pár stránek.

Pokud by měl někdo potřebu většího tutoriálu, tak jeden drobně zastaralý (python 2.4) se dá najít zde: Introduction to Concurrent Programming with Stackless Python.

Kde Stackless používám

Stackless u mě našel využití v paralelním síťovém kódu, který prochází webem. Jednotlivé navázání spojení je totiž časově náročnější operace, než samotné stahování. Takhle se neustále načítají nové a nové tasklety s požadavky na webové stránky, takže program pořád něco dělá, místo aby vždy čekal 2 vteřiny na navázání spojení.

Become a Patron