Ausnahme

La idea no es postear links pelados, pero este se relaciona directamente con el post anterior.
Prueben versions.
Es un placer de usar, es rápido, lo que me hace sospechar que encajan abundantes prefetchs de metadata, y tiene muchas features que faltaban en los cilientes que he probado, cosas tan básicas como el "blame".
Está en beta 2, y calculo que se volverá pago en breve, pero igual vale la pena.

tortoiseSVN para mac

Bueno, en realidad no es la tortuga, pero se le parece.

En diciembre de 2007 la misma gente de subversion y el tortoiseSVN sacó algo que se estaba necesitando hace rato: un plugin del finder de mac os que inspirado la tortuga.

La falta de clientes decentes para subversion fuera de windows me llamó mucho la atención cuando pasé a desarrollar en mac (viniendo de xp), decí que al ser un unixoid, el uso de la terminal es bien cómodo y uno casi se olvida del click derecho.

Claro que al ser una version bastante beta, le faltan cosas importantes (como un repository browser) y tiene montones de issues. Un detalle, si ya tienen varias working copies apuntando a servidores que requieren autenticación, es probable que no les anden de entrada las operaciones que van contra el servidor (las importantes, bah). Por lo que vi, el plugin guarda las credenciales en el keychain del mac os, mientras que el cliente svn nativo usa el chache que vive en ~/.subversion/auth.

Para "arreglar" ese "problema", simplemente hay que hacer un checkout con las credenciales que faltan y santo remedio.


scplugin

SIMD con gcc para las masas

En estos últimos meses la blogósfera fue testigo de un montón de información respecto a la programación de gpu's con propósitos generales. Estos procesadores basan su alto rendimiento en la ejecución de operaciones sobre varios conjuntos de datos simultáneamente a este modelo de paralelismo se le conoce como (SIMD Single Instruction Multiple Data).

Lo que la gente a veces se olvida es que las instrucciones SIMD están presentes en los procesadores x86 desde 1997, y encima de todo eso no precisás tener una geforce 8 para probar.

En efecto, desde la serie Pentium de Intel (aunque desde mucho antes en otras arquitecturas). Las extensiones MMX ya permitían la ejecución de de adiciones, restas y multiplicaciones sobre registros de 64-bits que se usan en forma de vector representando dos enteros de 32 bits, cuatro enteros de 16 bits o 8 enteros de 8 bits.

Sucesores de MMX (SSE, Altivec y 3DNow!) permiten también la utilización de valores en punto flotante y vectores de mayor tamaño. La colección de compiladores de gnu (gcc para los amigos) ofrece el acceso a las instrucciones SIMD de los procesadores x86 sin tener que escribir una sola línea de código assembler. Para eso se vale de extensiones del compilador que están documentadas en este link.

A modo de ejemplo de utilización de SSE2:

#include <iostream>
#include <sys/time.h>

using namespace std;

//con este typedef se declara un vector de 4 shorts y es casi
//todo lo automágico que se precisa del compilador
typedef unsigned short int v4si __attribute__ ((vector_size (16)));

//devuelve el tiempo en milisegundos
long tick() {

struct timeval start;

gettimeofday(&start, NULL);

return (long)(start.tv_sec * 1000 + (int) start.tv_usec / 1000);
}

void test() {

int size = 100000;

v4si ones   = {1, 1, 1, 1};
v4si result = {0, 0, 0, 0};

long before = tick();

for (int i = 0; i < size; i++)
    result += ones; //esto es una suma vectorial

long now = tick();

cout << "\tresult[0] = " << ((unsigned short int*)&result)[0] << endl
     << "\tresult[1] = " << ((unsigned short int*)&result)[1] << endl
     << "\tresult[2] = " << ((unsigned short int*)&result)[2] << endl
     << "\tresult[3] = " << ((unsigned short int*)&result)[3] << endl

     << "total time: " << now - before << "ms" << endl;
}

int main() {
 test();
 return 0;
}

Para poder usar el sse2 con las extensiones hay que poner la flag adecuada al compilar

$ g++ -o test -Wall -msse2 vector_extensions_test.cc

y usando un desensamblador y un poquito de grep podemos apreciar el uso de los registros sse (xmm0 - xmm7)

$ objdump -d test | grep xmm
80487d0:       66 0f 6f 05 b0 8a 04    movdqa 0x8048ab0,%xmm0
80487d8:       66 0f 7f 45 b8          movdqa %xmm0,-0x48(%ebp)
80487dd:       66 0f ef c0             pxor   %xmm0,%xmm0
80487e1:       66 0f 7f 45 c8          movdqa %xmm0,-0x38(%ebp)
80487e6:       66 0f 6f 45 c8          movdqa -0x38(%ebp),%xmm0
80487eb:       66 0f 7f 45 a8          movdqa %xmm0,-0x58(%ebp)
8048801:       66 0f 6f 45 a8          movdqa -0x58(%ebp),%xmm0
8048806:       66 0f fd 45 b8          paddw  -0x48(%ebp),%xmm0
804880b:       66 0f 7f 45 a8          movdqa %xmm0,-0x58(%ebp)

En cuanto a rendimiento la salida del programa es reveladora

$ ./test
  result[0] = 34464
  result[1] = 34464
  result[2] = 34464
  result[3] = 34464
total time: 1ms

Recompilando sin sse y comprobando

$ g++ -o test -Wall vector_extensions_test.cc
$ obj
$ ./test
  result[0] = 34464
  result[1] = 34464
  result[2] = 34464
  result[3] = 34464
total time: 6ms

De 6ms a 1ms usando sse, contundente verdad?. Estas mejoras de rendimiento tienen como contrapartida que los vectores utilizados en los cálculos deben respetar la alineación de memoria, eso puede plantear un contratiempo importante puesto que re-alinear los bytes implica un gran costo en poder de cómputo, sin embargo las mejoras pueden ser de importancia si se usa con sabiduría.

Así que bueno si alguien quiere internarse en el lado SIMD de la paralelización estos piques pueden servir de introducción.