Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/
Ja. Hier zum Beispiel die Anwendung einer Gammakorrektur auf ein ein zufällig erzeugtes Bild. Der entsprechende Teil besteht hier aus einer Zeile die der obigen zumindest ziemlich ähnlich aussieht.BlackJack hat geschrieben:@HerrHagen: Das ist jetzt wirklich praxisrelavanter? Es gibt praxisrelevante wissenschaftliche Programme die nur aus dieser Zeile und nix anderem bestehen? Oder wo diese Zeile wirklich den Kern ausmacht?
Code: Alles auswählen
import random
from time import clock
GAMMA = 1.4
image = [random.randint(0, 255) for _ in xrange(1000*1000)]
LUT = [(x/255.)**GAMMA for x in xrange(256)]
t = clock()
image_lut = [LUT[x]*255 for x in image]
print clock() - tCode: Alles auswählen
C:\Python26>python test.py
0.264631174997
D:\Download\pypy-1.5-win32\pypy-1.5.0a0-win32>pypy test.py
0.333214312653Zumindest lässt es sich schon allein dadurch, dass man den Code in eine Funktion verpackt zugunsten von CPython deutlich beschleunigen.HerrHagen hat geschrieben:Vielleicht lässt sich das Beispiel auch entsprechend umformulieren, dass es in PyPy schneller läuft.
Code: Alles auswählen
import random
from time import time
GAMMA = 1.4
image = [random.randint(0, 255) for _ in xrange(1000*1000)]
def f1(): # Original
LUT = [(x/255.)**GAMMA for x in xrange(256)]
t = time()
image_lut = [LUT[x]*255 for x in image]
return time() - t
def f2(): # pypy "schneller"
t = time()
image_lut = []
for x in image:
image_lut.append((x/255.)**GAMMA*255)
return time() - t
print f1(), f2()Code: Alles auswählen
python2.7 test.py
0.161140918732 0.612797021866
pypy1.5 test.py
0.365215063095 0.538238048553
.
Der Übersetzungsprozess ist sicher ein Musterbeispiel für einen sehr (sehr) komplexen Ablauf. Dort wird sicherlich nicht die komplette Rechenzeit in einer Zeile verbraten. Das heißt jedoch nicht das alle geschwindigkeitskritischen Programme derart komplex sind. Das von mir gezeigte Beispiel ist durchaus realistisch. Programme aus dem Bereich Bildverarbeitung sind tatsächlich meist so gestrickt, dass ein paar wenige Operationen fast die komplette Rechenzeit ausmachen. Im Hintergrund läuft natürlich meist auch eine komplexe Steuerungslogik. Die fällt aber zeitlich gerade nicht ins Gewicht, da hier die meißten Operationen dort nur einmal, statt für jeden Bildpunkt durchgeführt werden. Wenn man einen guten Benchmark will, sollte man also beides drin haben: eine sehr komplexe, verschachtelte Anwendung und eine vergleichsweise einfache Schleife, die dafür mit umso mehr Wiederholungen läuft. Für beide Applikationen existieren reale Anwendungen.Betrachtet man aber den Übersetzungsprozess von PyPy selbst, wahrscheinlich eine der komplexesten (Open Source) Python Anwendungen überhaupt läuft der mit PyPy etwa 2x so schnell wie mit CPython.
Ja stimmt, ich erwarte bald Kernelmodule in Python schreiben zu können.HerrHagen hat geschrieben:Ich will bloß, dass bestimmte Anwendungen nicht als unrealistisch abgetan werden, nur weil sie momentan nicht zu den typischen Python-Applikationen gehören.
Weil ich mir bei der ganzen Microbenchmark-Diskussion an den Kopf fassen muss.Code: Alles auswählen
[k * k for k in xrange(10 ** 6)]Code: Alles auswählen
static Obj example() {
Obj result = new List();
Obj iter = new Range(new Int(1000000)).iter();
Obj k = iter.next();
while (k != null) {
result.append(k.mul(k));
k = iter.next();
}
return result;
}Code: Alles auswählen
static abstract class Obj {
public Obj next() { throw new UnsupportedOperationException(); }
public void append(Obj obj) { throw new UnsupportedOperationException(); }
public Obj mul(Obj other) { throw new UnsupportedOperationException(); }
}Code: Alles auswählen
static class List extends Obj {
private final ArrayList<Obj> values = new ArrayList<Obj>();
public void append(Obj obj) {
values.add(obj);
}
}Code: Alles auswählen
static class Int extends Obj {
private final int value;
public Int(int value) {
this.value = value;
}
public Obj mul(Obj other) {
return new Int(value * ((Int) other).value);
}
}Code: Alles auswählen
static class Range extends Obj {
private final int stop;
public Range(Obj stop) {
this.stop = ((Int) stop).value;
}
public Obj iter() {
return new Obj() {
private int index;
public Obj next() {
return index < stop ? new Int(index++) : null;
}
};
}
}Code: Alles auswählen
public static void main(String[] args) {
for (int i = 0; i < 10; i++) {
long t = System.currentTimeMillis();
example();
System.out.println(System.currentTimeMillis() - t);
}
}Code: Alles auswählen
...
for _ in range(10000):
print f1(), f2()Code: Alles auswählen
0.374000072479 0.611999988556
0.389999866486 0.611999988556
0.384999990463 0.586999893188
0.388999938965 0.601999998093
0.352999925613 0.611000061035
0.385999917984 0.621999979019
0.381999969482 0.586000204086
0.453000068665 0.598999977112
0.352999925613 0.614000082016
0.384000062943 0.604000091553
0.361000061035 0.674000024796
0.37700009346 0.582000017166
...
0.379999876022 0.584000110626Nein?! Welche andere Zielsetzung sollte PyPy den haben? Sicherlich hat es auch andere Ziele als CPython aber bessere Performance (und geringerer Speicherverbrauch) sind definitiv Ziele auf die sich die PyPy Leute konzentrieren.snafu hat geschrieben:Wenn die Geschwindigkeit zur Laufzeit tatsächlich eine Rolle spielt, würde ich ohnehin eher zu Cython raten. Die Zielsetzung von PyPy ist ja primär eine andere.
Im PyPy-Blog war mal ein Beispiel für JIT-Code der schneller war als eine C-Umsetzung, demnach gibt es auch mindestens ein Beispiel bei dem von Cython generierter Code wohl auch langsamer ist. 
Code: Alles auswählen
chr(); chr(); chr()
Bei solchen recht knapp gehaltenen Aussagen sind Belege immer ganz nett. Nicht so sehr wegen der Glaubwürdigkeit, sondern einfach für diejenigen, die an Details interessiert sind.scoder hat geschrieben:Da in diesem Thread schon öfter mal Cython erwähnt wurde: es wird aktuell an einem Cython-Backend für ctypes/Python/PyPy gearbeitet.