De momento no soy capaz de hacer nada estoy bloqueado, he estado mirando la instruccion punpckhw y de momento nada, tambien podria mirar de hacerla con xors, cualquier ayuda es bienvenida.

Solo optimize una la mas facil claro, rotword.

pshuflw $0xb1, %xmm0, %xmm0
pshufhw $0xb1, %xmm0, %xmm0

Le saque bastante en diferencia a la del codigo no?

Un saludo.

Si ya tengo una idea de como hacerlo con shift, pero entendi mal shiftrows no funciona de la manera que lo explique, bueno cuando tenga el codigo ya veras.

Bueno y sobre la funcion rotword creo que me quedo bastante mejor, este es del codigo de exemplo.


Y este ejemplo lo saque de unos de los pdf de intel.


Y solo rotan uno, yo con esas dos instrucciones todos y sin usar direcciones de memoria, le saco bastante, pero bueno es la mas facil que hay jeje.


jajaja pero en realidad seria bueno hacerlo, se desperdicia mucha potencia de las tarjetas graficas, ejemplo mi HD 5870 tiene unos 2,7 TeraFlops, y sin contar los modelos nuevos que comercializaron Nvidia y AMD. Tesla FireGL...

Un saludo.

Edito:

Se rota un byte en rotword, tendre que corregirlo.

---

Como te prometi aqui tienes el codigo. Esta programado con la extension SSE2 asi que es bastante compatible con mas CPU's.

La funcion son unos 158 bytes seguro que no es una buena funcion para tus bichos jaja, bueno tambien mire que OPS y latencias podria consumir, lei unos documentos de Agner Fog que explicaba los OPS y las latencias que consumia cada instruccion de la CPU especifica. Tengo un K10 segun ese documento son unos 34 OPS y unas 77 Latencias, es lo que me importa, de verdad como lo ves?

Si quieres posteo el dissasembler de la funcion del codigo en C++, y me dices si esta implementacion es mas rapida.

Bueno aqui el codigo.

movdqa %xmm0, %xmm1
movdqa %xmm0, %xmm2
movdqa %xmm0, %xmm3
movdqa %xmm0, %xmm4
movdqa %xmm0, %xmm5
movdqa %xmm0, %xmm6
pslld $0x18, %xmm0
psrld $0x18, %xmm0
pslldq $0x4, %xmm1
psrld $0x18, %xmm1
pslld $0x18, %xmm1
psrld $0x18, %xmm2
psrldq $0x9, %xmm2
psrlw $0x8, %xmm3
psllw $0x8, %xmm3
pslld $0x8, %xmm3
psrldq $0x5, %xmm3
psllw $0x8, %xmm4
psrlw $0x8, %xmm4
psrld $0x10, %xmm4
pslldq $0xa, %xmm4
psllw $0x8, %xmm5
psrlw $0x8, %xmm5
psrld $0x10, %xmm5
psrldq $0x6, %xmm5
psrlw $0x8, %xmm6
pslld $0x10, %xmm6
pslldq $0xb, %xmm6
pxor %xmm1, %xmm0
pxor %xmm2, %xmm0
pxor %xmm3, %xmm0
pxor %xmm4, %xmm0
pxor %xmm5, %xmm0
pxor %xmm6, %xmm0

Seguro que se puede mejorar algo, pero de momento paso.

Bueno hilo solucionado, y cualquier mejora sobre el codigo pues bienvenida.

Un saludo y siento el doble post.

---

Bueno, aqui les dejo la optimizacion, el anterior codigo parece una p**a chapuza al lado de este, esta 100% escrito por mi, lo sorprendente es que no vi ninguna implementacion en SSE2 para este tipo de funcion solo en SSSE3.

OPS 13 & Latencia 30.5 en un K10.

.section .data
 
sldw:
.quad 0x000000ff000000ff,0x000000ff000000ff
slw:
.quad 0x0000ff000000ff00,0x0000ff000000ff00
shw:
.quad 0x00ff000000ff0000,0x00ff000000ff0000
shdw:
.quad 0xff000000ff000000,0xff000000ff000000
 
.section .text
.globl _start
 
_start:
 
movdqa %xmm0, %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm2, %xmm3
andpd sldw, %xmm0
andpd slw, %xmm1
pshufd $0x39, %xmm1, %xmm1
pxor %xmm1, %xmm0
andpd shw, %xmm2
pshufd $0x4e, %xmm2, %xmm2
pxor %xmm2, %xmm0
andpd shdw, %xmm3
pshufd $0x93, %xmm3, %xmm3
pxor %xmm3, %xmm0

En xmm0 es donde esta la matriz logico.

Un saludo.

El code son unos 75 bytes mas la tabla son unos 139 bytes algo se bajo, pero no es el peso si no la optimizacion, le saco el doble por lo menos, y ya no te digo lo que le saco a la de C++ jeje.

Bueno creo que esta bastante bien, ahora tengo que ir a por otra ya tengo shiftrows y rotword, ya las ire publicando en el subforo de criptografia que es el sitio mas indicado.

Y sobre el peso, creo que cuando lo tenga todo acabado no pasara de 1.3kB, ya dije anteriormente para que lo queria, tampoco pesa tanto no?

Un saludo.

Bueno, le baje el peso en 10 bytes ahora son 129 bytes, simplemente copie la direccion a un registro de general purpose rsi creo que es el mejor para ese trabajo y quedo de esta forma, segun el manual que estoy leyendo mover una constante a un registro son 1 ops y 1 latencia, asi que se queda al final en 14 OPS & 31.5 Latencias, por 10 bytes creo que esta bien.

.section .data
 
sldw:
.quad 0x000000ff000000ff,0x000000ff000000ff
slw:
.quad 0x0000ff000000ff00,0x0000ff000000ff00
shw:
.quad 0x00ff000000ff0000,0x00ff000000ff0000
shdw:
.quad 0xff000000ff000000,0xff000000ff000000
 
.section .text
.globl _start
 
_start:
 
movq $sldw, %rsi
movdqa %xmm0, %xmm1
movdqa %xmm1, %xmm2
movdqa %xmm2, %xmm3
andpd (%rsi), %xmm0
andpd 16(%rsi), %xmm1
pshufd $0x39, %xmm1, %xmm1
pxor %xmm1, %xmm0
andpd 32(%rsi), %xmm2
pshufd $0x4e, %xmm2, %xmm2
pxor %xmm2, %xmm0
andpd 48(%rsi), %xmm3
pshufd $0x93, %xmm3, %xmm3
pxor %xmm3, %xmm0

Si alguien quiere probarlo que mueva la matriz de 4 x 4 a xmm0, aqui se da por sentado de que ya esta, cualquier pregunta o duda pues ya saben, bueno no me enrrollo mas y ahora si que doy el tema por cerrado.

Un saludo.