Simple Python Défi: le plus Rapide XOR au niveau du Bit sur les Tampons de Données

D'Abord Essayer De

À l'aide de scipy.tissage et SSE2 intrinsèques donne une amélioration marginale. La première invocation est un peu plus lent étant donné que le code doit être chargé à partir du disque et de la mise en cache, à la suite d'invocations sont plus rapides:

import numpy
import time
from os import urandom
from scipy import weave

SIZE = 2**20

def faster_slow_xor(aa,bb):
    b = numpy.fromstring(bb, dtype=numpy.uint64)
    numpy.bitwise_xor(numpy.frombuffer(aa,dtype=numpy.uint64), b, b)
    return b.tostring()

code = """
const __m128i* pa = (__m128i*)a;
const __m128i* pend = (__m128i*)(a + arr_size);
__m128i* pb = (__m128i*)b;
__m128i xmm1, xmm2;
while (pa < pend) {
  xmm1 = _mm_loadu_si128(pa); //must use unaligned access 
  xmm2 = _mm_load_si128(pb); //numpy will align at 16 byte boundaries
  _mm_store_si128(pb, _mm_xor_si128(xmm1, xmm2));
  ++pa;
  ++pb;
}
"""

def inline_xor(aa, bb):
    a = numpy.frombuffer(aa, dtype=numpy.uint64)
    b = numpy.fromstring(bb, dtype=numpy.uint64)
    arr_size = a.shape[0]
    weave.inline(code, ["a", "b", "arr_size"], headers = ['"emmintrin.h"'])
    return b.tostring()

Deuxième Essai

En prenant en compte les commentaires, j'ai revisité le code pour savoir si la copie pourrait être évité. S'avère que j'ai lu la documentation de l'objet string de mal, alors, voici mon deuxième essai:

support = """
#define ALIGNMENT 16
static void memxor(const char* in1, const char* in2, char* out, ssize_t n) {
    const char* end = in1 + n;
    while (in1 < end) {
       *out = *in1 ^ *in2;
       ++in1; 
       ++in2;
       ++out;
    }
}
"""

code2 = """
PyObject* res = PyString_FromStringAndSize(NULL, real_size);

const ssize_t tail = (ssize_t)PyString_AS_STRING(res) % ALIGNMENT;
const ssize_t head = (ALIGNMENT - tail) % ALIGNMENT;

memxor((const char*)a, (const char*)b, PyString_AS_STRING(res), head);

const __m128i* pa = (__m128i*)((char*)a + head);
const __m128i* pend = (__m128i*)((char*)a + real_size - tail);
const __m128i* pb = (__m128i*)((char*)b + head);
__m128i xmm1, xmm2;
__m128i* pc = (__m128i*)(PyString_AS_STRING(res) + head);
while (pa < pend) {
    xmm1 = _mm_loadu_si128(pa);
    xmm2 = _mm_loadu_si128(pb);
    _mm_stream_si128(pc, _mm_xor_si128(xmm1, xmm2));
    ++pa;
    ++pb;
    ++pc;
}
memxor((const char*)pa, (const char*)pb, (char*)pc, tail);
return_val = res;
Py_DECREF(res);
"""

def inline_xor_nocopy(aa, bb):
    real_size = len(aa)
    a = numpy.frombuffer(aa, dtype=numpy.uint64)
    b = numpy.frombuffer(bb, dtype=numpy.uint64)
    return weave.inline(code2, ["a", "b", "real_size"], 
                        headers = ['"emmintrin.h"'], 
                        support_code = support)

La différence est que la chaîne est allouée à l'intérieur de la C code. Il est impossible d'avoir aligné à 16 octets-frontière comme requis par les instructions SSE2, donc la non alignés régions de la mémoire au début et à la fin sont copiés à l'aide de byte-sage d'accès.

Les données d'entrée est remis à l'aide de tableaux numpy de toute façon, parce que weave insiste sur la copie Python str objets à std::strings. frombuffer ne copie pas, donc c'est très bien, mais la mémoire n'est pas aligné à 16 octets, donc nous avons besoin d'utiliser _mm_loadu_si128 au lieu de la plus rapide _mm_load_si128.

Au lieu d'utiliser _mm_store_si128, nous utilisons _mm_stream_si128, qui sera assurez-vous que toutes les écritures sont diffusées en direct à la mémoire principale dès que possible---de cette façon, la sortie de la matrice de ne pas utiliser de précieuses lignes de cache.

Timings

Comme pour les timings, la slow_xor entrée dans la première édition visée à ma version améliorée (inline xor au niveau du bit, uint64), j'ai supprimé cette confusion. slow_xor fait référence au code de l'origine des questions. Tous les horaires sont fait pour 1000 pistes.

• slow_xor: 1.85 s (1x)
• faster_slow_xor: 1.25 s (1.48 x)
• inline_xor: 0.95 s (1,95 x)
• inline_xor_nocopy: 0.32 s (5.78 x)

Le code a été compilé avec gcc 4.4.3 et j'ai vérifié que le compilateur utilise le jeu d'instructions SSE.

Voici mes résultats pour cython

slow_xor   0.456888198853
faster_xor 0.400228977203
cython_xor 0.232881069183
cython_xor_vectorised 0.171468019485

Vectorising en cython rasages environ 25% de rabais pour la boucle sur mon ordinateur, Cependant, plus de la moitié du temps est consacré à la construction de la chaîne python (le return déclaration) - je ne pense pas que la copie supplémentaire peut être évité (légalement) le tableau peut contenir des octets nuls.

La manière illégale, serait de passer une chaîne Python et muter en place et permettrait de doubler la vitesse de la fonction.

xor.py

from time import time
from os import urandom
from numpy import frombuffer,bitwise_xor,byte,uint64
import pyximport; pyximport.install()
import xor_

def slow_xor(aa,bb):
    a=frombuffer(aa,dtype=byte)
    b=frombuffer(bb,dtype=byte)
    c=bitwise_xor(a,b)
    r=c.tostring()
    return r

def faster_xor(aa,bb):
    a=frombuffer(aa,dtype=uint64)
    b=frombuffer(bb,dtype=uint64)
    c=bitwise_xor(a,b)
    r=c.tostring()
    return r

aa=urandom(2**20)
bb=urandom(2**20)

def test_it():
    t=time()
    for x in xrange(100):
        slow_xor(aa,bb)
    print "slow_xor  ",time()-t
    t=time()
    for x in xrange(100):
        faster_xor(aa,bb)
    print "faster_xor",time()-t
    t=time()
    for x in xrange(100):
        xor_.cython_xor(aa,bb)
    print "cython_xor",time()-t
    t=time()
    for x in xrange(100):
        xor_.cython_xor_vectorised(aa,bb)
    print "cython_xor_vectorised",time()-t

if __name__=="__main__":
    test_it()

xor_.custode

cdef char c[1048576]
def cython_xor(char *a,char *b):
    cdef int i
    for i in range(1048576):
        c[i]=a[i]^b[i]
    return c[:1048576]

def cython_xor_vectorised(char *a,char *b):
    cdef int i
    for i in range(131094):
        (<unsigned long long *>c)[i]=(<unsigned long long *>a)[i]^(<unsigned long long *>b)[i]
    return c[:1048576]

Votre problème n'est pas la vitesse de NumPy du xOr méthode, mais plutôt avec l'ensemble de la mise en mémoire tampon/conversions de types de données. Personnellement, je soupçonne que le point de ce post peut ont vraiment été pour se vanter de Python, parce que ce que vous faites ici, c'est le traitement de TROIS GIGAOCTETS de données dans les délais, à égalité avec les langages interprétés, qui sont intrinsèquement plus rapide.

Le code ci-dessous montre que, même à mon humble ordinateur Python peut xOr "aa" (1 MO) et "bb" (1 MO) en "c" (1 MO) d'un millier de fois (total de 3 go) en vertu de deux secondes. Sérieusement, combien plus l'amélioration voulez-vous? En particulier à partir d'un langage interprété! 80% du temps a été passé en appelant "frombuffer" et "tostring". La réelle xOr-ing est réalisé dans les autres 20% du temps. À 3 GO en 2 secondes, vous serait difficile à améliorer que sensiblement même juste en utilisant memcpy dans c.

Dans le cas où c'était une vraie question, et pas seulement secrète se vanter de Python, la réponse est pour le code, de façon à minimiser le nombre, le montant et la fréquence de vos conversions de types tels que "frombuffer" et "tostring". Le réel qui utilise xOr est rapide comme l'éclair déjà.

from os import urandom
from numpy import frombuffer,bitwise_xor,byte,uint64

def slow_xor(aa,bb):
    a=frombuffer(aa,dtype=byte)
    b=frombuffer(bb,dtype=byte)
    c=bitwise_xor(a,b)
    r=c.tostring()
    return r

bb=urandom(2**20)
aa=urandom(2**20)

def test_it():
    for x in xrange(1000):
    slow_xor(aa,bb)

def test_it2():
    a=frombuffer(aa,dtype=uint64)
    b=frombuffer(bb,dtype=uint64)
    for x in xrange(1000):
        c=bitwise_xor(a,b);
    r=c.tostring()    

test_it()
print 'Slow Complete.'
#6 seconds
test_it2()
print 'Fast Complete.'
#under 2 seconds

De toute façon, le "test_it2" ci-dessus accomplit exactement le même montant de xOr-ing "test_it", mais à 1/5 du temps. 5x amélioration de la vitesse devrait être considéré comme "important", non?

Python3 a int.from_bytes et int.to_bytes, donc:

x = int.from_bytes(b"a" * (1024*1024), "big")
y = int.from_bytes(b"b" * (1024*1024), "big")
(x ^ y).to_bytes(1024*1024, "big")

Il est plus rapide que d'IO, un peu dur à tester juste la façon dont il est rapide, ressemble de 0,018 .. 0.020 s sur ma machine. Étrangement "little"-endian conversion est un peu plus rapide.

Disponible 2.x a la fonction sous-jacente _PyLong_FromByteArray, il n'est pas exporté, mais accessible par l'ctypes:

In [1]: import ctypes
In [2]: p = ctypes.CDLL(None)
In [3]: p["_PyLong_FromByteArray"]
Out[3]: <_FuncPtr object at 0x2cc6e20>

Python 2 les détails sont laissé comme exercice au lecteur.

À quel point avez-vous besoin d'une réponse comme une chaîne de caractères? Notez que le c.tostring() méthode a pour copie les données dans c à une nouvelle chaîne, comme Python chaînes sont immuables (et c est mutable). Python 2.6 et 3.1 ont un bytearray type, qui agit comme str (bytes en Python 3.x) sinon pour être mutable.

Une autre optimisation est à l'aide de la out paramètre bitwise_xor pour spécifier l'emplacement où stocker le résultat.

Sur ma machine je obtenir

slow_xor (int8): 5.293521 (100.0%)
outparam_xor (int8): 4.378633 (82.7%)
slow_xor (uint64): 2.192234 (41.4%)
outparam_xor (uint64): 1.087392 (20.5%)

avec le code à la fin de ce post. Notez en particulier que la méthode à l'aide d'un préaffectés tampon est deux fois plus rapide que la création d'un nouvel objet (sur 4 octets (uint64) morceaux). Ceci est cohérent avec la méthode plus lente à effectuer deux opérations par morceau (xor + copie) à l'accélération de l'1 (juste xor).

Aussi, FWIW, a ^ b est équivalent à bitwise_xor(a,b), et a ^= b est équivalent à bitwise_xor(a, b, a).

Donc, 5x speedup sans écrire de modules externes 🙂

from time import time
from os import urandom
from numpy import frombuffer,bitwise_xor,byte,uint64
def slow_xor(aa, bb, ignore, dtype=byte):
a=frombuffer(aa, dtype=dtype)
b=frombuffer(bb, dtype=dtype)
c=bitwise_xor(a, b)
r=c.tostring()
return r
def outparam_xor(aa, bb, out, dtype=byte):
a=frombuffer(aa, dtype=dtype)
b=frombuffer(bb, dtype=dtype)
c=frombuffer(out, dtype=dtype)
assert c.flags.writeable
return bitwise_xor(a, b, c)
aa=urandom(2**20)
bb=urandom(2**20)
cc=bytearray(2**20)
def time_routine(routine, dtype, base=None, ntimes = 1000):
t = time()
for x in xrange(ntimes):
routine(aa, bb, cc, dtype=dtype)
et = time() - t
if base is None:
base = et
print "%s (%s): %f (%.1f%%)" % (routine.__name__, dtype.__name__, et,
(et/base)*100)
return et
def test_it(ntimes = 1000):
base = time_routine(slow_xor, byte, ntimes=ntimes)
time_routine(outparam_xor, byte, base, ntimes=ntimes)
time_routine(slow_xor, uint64, base, ntimes=ntimes)
time_routine(outparam_xor, uint64, base, ntimes=ntimes)

Le moyen le plus rapide (speedwise) feront ce qu'Max. S recommandé. Mettre en œuvre dans C.

Le code de prise en charge pour cette tâche devrait être assez simple à écrire. C'est juste une fonction dans un module de création d'une nouvelle chaîne et de faire le xor. C'est tout. Lorsque vous avez mis en place un module comme ça, il est simple de prendre le code en tant que modèle. Ou même de prendre un module de mise en œuvre de quelqu'un d'autre qui implémente une amélioration simple module de Python et de les jeter tout ce qui n'est pas nécessaire pour votre tâche.

Le réel complexe, ce qui est juste, de faire le RefCounter-des Trucs à droite. Mais une fois compris comment ça fonctionne, c'est gérable, c'est aussi la tâche à portée de main est vraiment simple (allouer de la mémoire, et de la retourner -- params sont de ne pas être touché (Ref-sage)).