Teniendo ya Mandelbrot, era trivial hacer Julia. Pero para hacerlo más interesante, el programa en ensamblador cambia la constante de Julia por una , y vuelve a dibujar el fractal. Esto resulta en una “animación” (entre comillas porque mi simulador tarda unos siete segundos en dibujar todo el “monitor”), que me dieron ganas de mostrar en el blog.

Para esto, utilicé la opción que tienen los GdkPixbufs de salvarse a archivos gráficos, y modifiqué el simulador para que lo haga si el usuario lo invoca con un parámetro en la línea de comando. En el camino, arreglé todas las broncas de sincronización que tenía el simulador (el ciclo del simulador es un hilo de ejecución (thread) independiente de gtk_main()), y de una vez limpié todo mi uso de Gdk. Quedó mucho más bonito.

Para generar automáticamente las 325 imágenes de la animación, hice un hack para que el simulador guarde una copia de la imagen cada vez que se ejecuta la instrucción shl (shift left), porque esa instrucción no se usa en el programa de Mandelbrot o Julia. El hack es necesario porque el simulador sólo guarda la imagen cuando entra en un ciclo infinito que no hace nada, que es como “oficialmente” acaban los programas correctos en nuestro micro. El programa de Julia no tiene ciclo infinito que no haga nada; tiene un ciclo infinito que dibuja Julia en cada iteración, y no iba a generar las 325 imágenes a pie.

La animación quedó bonita:

Los inges siguen avanzando con el micro. Or so they say.

 Imprimir entrada

Con Alejandro en nuestro proyecto de Arquitectura:

Yo: ¿Entonces VHDL no permite if‘s anidados ni elsif‘s?
Alejandro: No, la bronca es que cuando hacemos

if (pin = ‘0’) then
        do shit
else
        esto no quiere decir que pin es ‘1’, sólo no es ‘0’
end if;

Yo: Y es por eso que no estudié en Ingeniería.

De donde yo vengo, los bits valen cero o uno. Y ya.

 Imprimir entrada

Sólo he escrito entradas de Arquitectura de Computadoras últimamente, porque ha sido mi coco este semestre (no es que sea difícil; no lo es… es sólo que esta materia tiene todos los elementos por los cuales acabé en la Facultad de Ciencias y no en la de Ingeniería). Pero eso no quiere decir que no tenga un fin de semestre completito.

Mañana son las reposiciones de Lenguajes de Programación. La materia ha sido muy frustante, básicamente por el ayudante. Tengo un historial añejo de pelearme con ayudantes. El resultado es que no sé qué he sacado en mis exámenes; sé que no he reprobado ninguno, y que (creo) en ninguno tengo menos de ocho. Pero no sé exactamente qué calificaciones tengo, además de que el antes mencionado ayudante no ha entregado las calificaciones de los últimos dos exámenes que hicimos. Entonces no sé si tengo 10 de calificación… y quiero 10, así que ante la duda (si no nos entregan calificaciones antes), tendré que hacer reposiciones.

El lunes tengo examen de Análisis de Algoritmos. Ha sido sin duda mi mejor materia, incluido un 6 idiota que tuve en un examen, especialmente por la tarea 3, de la cual hablaré (espero) al fin del semestre. El punto es que no me preocupa demasiado el examen; creo que estoy en condiciones suficientemente buenas para pasarlo bien.

El martes es el día que entregamos nuestro micro en Arquitectura de Computadoras. Creo que sí acabamos a tiempo, y creo que va a quedar muy padre ese proyecto. Cómo carajo se va a ver reflejado eso en mi calificación, no tengo idea.

Y por último el miércoles tengo mi último examen de Autómatas y Lenguajes Formales. Exceptuando un 7.2 y un 8.5 en dos de las ocho tareas, tengo 10 o más de 9.5 en todo lo demás (incluido el primer y hasta ahora único examen). Pero este segundo examen es el 40% de la calificación, así que más vale que lo saque bien.

Independientemente de que es fin de semestre completito, el cansancio ya comienza a ser evidente. Es la primera vez que en diciembre no descansé nada (estuve yendo al IIMAS diario o trabajando desde mi casa en cosas de Arquitectura y Algoritmos), y además ya comienzo a hartarme. Pero falta menos de una semana para que este semestre acabe.

Y mañana sale el nuevo capítulo de Battlestar Galactica.

 Imprimir entrada

Hoy acabé la parte de software para nuestro proyecto de Arquitectura de Computadoras. Por supuesto no va a servir de mucho si los inges no acaban el micro, pero me he divertido al menos.

Nuestro micro es bastante sencillo; tiene instrucciones para manejo de memoria, una pilita (en la misma memoria), saltos, un ALU de enteros, y (el chiste), una unidad aritmética de complejos.

La idea era hacer algo nuevo.

La aplicación obvia para nuestro micro es un fractal; sobre todo porque tenemos salida VGA de nuestra tarjeta Spartan-3E, y entonces (mientras los inges se hacen bolas con el código VHDL), yo hice un ensamblador, un desensamblador, un convertidor de código máquina a VHDL, y un emulador. La idea es tener todo el software depurado para que al momento de correr la aplicación en la tarjeta, si algo sale mal, sepamos que de hecho es el código VHDL y no algún error bobo en el software.

El ensamblador lo hice con Yacc y Lex (y sé que no era necesario; sólo era muy sencillo hacerlo así), el desensamblador en Perl (aunque lo pasé a C porque cómo joden los inges con la eficiencia), el convertidor en C, y el emulador también en C, utilizando Gtk+ para emular el monitor. Ya entrados y en el vicio, hice también el programa en ensamblador que dibujara Mandelbrot en la pantalla.

Para que se den una idea, este es un programa en nuestro ensamblador que dibuja una línea vertical justo al centro del monitor (en VGA tenemos 640×480 de resolución):

1:    start:
2:              mov     0, %ebx
3:              mov     7, %ecx
4:              mov     320, %eax
5:    for:
6:              vput
7:              mov     1, %edx
8:              add     %ebx, %edx
9:              mov     480, %edx
10:             sub     %edx, %ebx
11:             jz      end
12:             jmp     for
13:    end:
14:             jmp     end

Les queda de tarea descifrarlo. Sólo quiero especificar que el ciclo infinito al final es idea de los inges: parece que la idea de que las cosas terminen les molesta.

Tenemos sólo cuatro registros enteros (%eax, %ebx, %ecx y %edx), y cuatro complejos (iguales, pero “c” en lugar de “e”). Cada complejo tiene una parte real y una imaginaria. No pongo el algoritmo de Mandelbrot porque está bastante más largo (108 líneas de ensamblador; pequeño para todo lo que hace), pero sí les pongo que para graficarlo uno calcula

donde , y recorre un área que será la que cubra la pantalla.

(Realmente no había razón para ponerles la fórmula; pero ya tengo rato buscando un pretexto para utilizar mi renderer).

Mi emulador ya pudo dibujar Mandelbrot, y sin más preámbulo se los presento:

Si les parece que los colores son demasiado “All the leaves are brown…”, tienen toda la razón. Sólo tenemos 3 bits para representar colores, así que sólo tenemos ocho: negro, azul, verde, rojo, magenta, cyan, amarillo y blanco. Así que la caballada estaba flaca para empezar.

El proyecto está bonito; si lo acabamos lo va a estar más.

 Imprimir entrada

Y resulta que tengo que hacer un ensamblador para mi proyecto final de Arquitectura de computadoras. Un ensamblador no es un compilador. Trato de decirle eso a un montón de gente pero no entienden; un ensamblador es (básicamente) un reemplazo textual de instrucciones en ensamblador a lenguaje de máquina. Puede hacerse bonito; pero excepto transformar literales, cuidar que los jumps vayan a etiquetas definidas, y ver que las instrucciones reciban los parámetros que necesitan, no hace nada interesante.

Es tan trivial la tarea, que no sé si hacerla en Java, Perl o C. E independientemente de qué lenguaje utilice, no sé si usar una herramienta ya hecha (como JavaCC o Lex), o hacerlo a pie.

Como sea, si uso Lex (que nunca he usado) necesito saber cómo funciona, así que me puse a leer su página del manual. Es el manual más mamón que he visto:

The lex utility shall generate C programs to be used in lexical processing of character input, and that can be used as an interface to yacc.

(El énfasis es mío.)

¿Shall? ¿En una página del manual?

Chale.

 Imprimir entrada