Was ist der schnellste Weg in Python ein c-Array aus einer Liste von Tupel von Floats zu erstellen?

Question

Der Kontext: meine Python-Code übergeben Arrays von 2D-Scheitelpunkte zu OpenGL.

Ich testete zwei Ansätze, einen mit Ctypes, den anderen mit struct, wobei letzterer mehr als zweimal schneller ist.

from random import random 
points = [(random(), random()) for _ in xrange(1000)] 

from ctypes import c_float 
def array_ctypes(points): 
    n = len(points) 
    return n, (c_float*(2*n))(*[u for point in points for u in point]) 

from struct import pack 
def array_struct(points): 
    n = len(points) 
    return n, pack("f"*2*n, *[u for point in points for u in point]) 

Jede andere Alternative? Irgendein Hinweis, wie man solchen Code beschleunigt (und ja, das ist ein Flaschenhals meines Codes)?

Answer 1

Sie könnten versuchen Cython. Für mich ergibt dies:

function  usec per loop: 
       Python Cython 
array_ctypes 1370 1220 
array_struct 384  249 
array_numpy  336  339 

So Numpy gibt nur 15% Vorteil auf meiner Hardware (alter Laptop mit Windows XP), während Cython etwa 35% ergibt (ohne zusätzliche Abhängigkeit in Ihrem verteilten Code).

Wenn Sie Ihre Anforderung lösen, dass jeder Punkt ein Tupel von Schwimmern ist, und einfach ‚Punkte‘ machen eine abgeflachte Float-Liste:

def array_struct_flat(points): 
    n = len(points) 
    return pack(
     "f"*n, 
     *[ 
      coord 
      for coord in points 
     ] 
    ) 

points = [random() for _ in xrange(1000 * 2)] 

dann die resultierende Ausgabe ist die gleiche, aber das Timing geht weiter nach unten:

function   usec per loop: 
        Python Cython 
array_struct_flat   157 

Cython könnte auch, wenn jemand klüger als ich als dies wesentlich besser geeignet sein wollte Erklärungen statischen Typ, um den Code hinzuzufügen. (Das Ausführen von 'cython -a test.pyx' ist dafür von unschätzbarem Wert, es erzeugt eine HTML-Datei, die Ihnen anzeigt, wo das langsamste (gelbe) einfache Python in Ihrem Code ist, im Gegensatz zu Python, das in reines C (weiß) konvertiert wurde ich breitete den Code oben aus auf so viele Zeilen, weil die Färbung pro-line durchgeführt wird, so hilft es, sie um sich auszubreiten ähnlich)

Voll Cython Anweisungen sind hier:. http://docs.cython.org/src/quickstart/build.html

Cython könnte produzieren ähnliche Leistungsvorteile in Ihrer gesamten Codebasis, und unter idealen Bedingungen, bei richtiger statischer Typisierung, kann die Geschwindigkeit um Faktoren von zehn oder hundert verbessert werden.

Answer 2

Sie können array (man beachte auch den Generator Ausdruck anstelle der Liste Verständnis) verwenden:

array("f", (u for point in points for u in point)).tostring() 

Eine weitere Optimierung wäre es, die Punkte von Anfang an abgeflacht zu halten.

Answer 3

Sie können numpy Arrays an PyOpenGL übergeben, ohne dass ein Overhead entsteht. (Das data Attribut des numpy Array ist ein Puffer, der auf die zugrunde liegenden C-Datenstruktur zeigt, die die gleichen Informationen wie das Array enthält Sie bauen)

import numpy as np 
def array_numpy(points): 
    n = len(points) 
    return n, np.array(points, dtype=np.float32) 

Auf meinem Computer ist dies etwa 40% schneller als der struct -basierte Ansatz.

Answer 4

Es gibt eine andere Idee, über die ich gestolpert bin. Ich habe keine Zeit, es jetzt zu profilieren, aber falls es jemand anderes tut:

# untested, but I'm fairly confident it runs 
# using 'flattened points' list, i.e. a list of n*2 floats 
points = [random() for _ in xrange(1000 * 2)] 
c_array = c_float * len(points * 2) 
c_array[:] = points 

Das heißt, zuerst schaffen wir die ctypes Array aber bevölkern es nicht. Dann füllen wir es mit der Slice-Notation. Leute, die schlauer sind als ich, sagen mir, dass das Zuweisen zu einer Scheibe wie diese der Leistung helfen kann.Es erlaubt uns, eine Liste oder iterable direkt auf dem RHS der Zuweisung zu übergeben, ohne die * iterable Syntax zu verwenden, die einige Zwischengerangel des iterable durchführen würde. Ich vermute, dass dies in den Tiefen von pyglets Batches passiert.

Vermutlich könnten Sie einfach einmal c_array erstellen und dann jedes Mal, wenn sich die Punkte-Liste ändert, neu zuordnen (die letzte Zeile im obigen Code).

Es gibt wahrscheinlich eine alternative Formulierung, die die ursprüngliche Definition von Punkten (eine Liste von (x, y) Tupel.) Akzeptiert Etwas wie folgt aus:

# very untested, likely contains errors 
# using a list of n tuples of two floats 
points = [(random(), random()) for _ in xrange(1000)] 
c_array = c_float * len(points * 2) 
c_array[:] = chain(p for p in points) 

Answer 5

Wenn die Leistung ein Problem, Sie nicht wollen, ctypes-Arrays mit der Sternoperation zu verwenden (z. B. (ctypes.c_float * size)(*t)).

In meinem Test pack ist am schnellsten gefolgt von der Verwendung des Moduls array mit einer Besetzung der Adresse (oder mit der Funktion from_buffer).

import timeit 
repeat = 100 
setup="from struct import pack; from random import random; import numpy; from array import array; import ctypes; t = [random() for _ in range(2* 1000)];" 
print(timeit.timeit(stmt="v = array('f',t); addr, count = v.buffer_info();x = ctypes.cast(addr,ctypes.POINTER(ctypes.c_float))",setup=setup,number=repeat)) 
print(timeit.timeit(stmt="v = array('f',t);a = (ctypes.c_float * len(v)).from_buffer(v)",setup=setup,number=repeat)) 
print(timeit.timeit(stmt='x = (ctypes.c_float * len(t))(*t)',setup=setup,number=repeat)) 
print(timeit.timeit(stmt="x = pack('f'*len(t), *t);",setup=setup,number=repeat)) 
print(timeit.timeit(stmt='x = (ctypes.c_float * len(t))(); x[:] = t',setup=setup,number=repeat)) 
print(timeit.timeit(stmt='x = numpy.array(t,numpy.float32).data',setup=setup,number=repeat)) 

Der array.array Ansatz ist etwas schneller als Jonathan Hartley Ansatz in meinem Test, während der numpy Ansatz Hälfte hat etwa die Geschwindigkeit:

python3 convert.py 
0.004665990360081196 
0.004661010578274727 
0.026358536444604397 
0.0028003649786114693 
0.005843495950102806 
0.009067213162779808 

Der Netto-Gewinner ist Packung.