Campeones de pádel Open Original Tonic

IgnasiBarri-GerardRabell

Pues sí, el pádel es uno de mis deportes preferidos.

El domingo pasado jugué en el Padel Indoor Lleida la final de pádel con mi compañero Gerard Rabell del Open Original Open.

OpenPádelOpen

Fue una semana larga, más aún considerando que jugamos 5 partidos antes de llegar a la final y las piernas estaban bastante cargadas, más aún considerando que jugamos la mayoría de partidos a 3 sets.

Supongo que nuestros adversarios estaban en condiciones parecidas, así que el partido se tenía que jugar con un punto de paciencia, pero evitando estar muy parado y adormecerse. Así pues, jugamos de forma constante des de buen principio, sin ceder break alguno fuimos capaces de apuntarnos el primer set con un 6-3.

La cosa parecía ir sobre ruedas, sin embargo, empezamos el segundo set con un break abajo, en ese punto de desconcierto, la pelota no corría lo suficientemente rápido cuando la apretábamos y poco a poco nuestros adversarios se iban encontrando más y más cómodos.

En ese momento, mi compañero Gerard sacó a relucir su gran capacidad técnica y acabamos el segundo set con un 6-4 arriba después de romper dos veces el servicio a la pareja rival.

De este modo completamos un partido serio aunque con ciertos altibajos, pero que nos permitió proclamarnos campeones de la segunda categoría masculina.

Ahora toca descansar un poco y sobretodo entrenar, puesto que mi compañero Gerard está muy fuerte!

Os dejo algunas fotos más del torneo...

público

photocall

Posted in gintonic, sports

More about Assembly (Von Neumann simulator)

Today I've been in the campus with our computer science students in their first official test of the subject.

The test has been composed by 3 questions. With the second question we have tested the assembly language' knowledge of the students. In this case, rather than ask to students to implement a program from scratch, we have asked them about a provided code; concretely the following:

1	CONSTANT1 EQU 03h 
2	CONSTANT2 EQU 00h  
3	
4	ORIGEN 00h  
5	
6	INICIO ini  
7	
8	.DATOS 
9	
10	     vector1 VALOR 0001h, 0002h, 0003h 
11	     vector2 VALOR 0005h, 0004h, 0003h 
12	     sortida VALOR 3 VECES 0001h  
13	
14	.CODIGO   
15	ini:  	        
16	
17	     MOVL R1, CONSTANT1       
18	     MOVH R1, CONSTANT2
19	 	       
20	     MOVL R2, BYTEBAJO DIRECCION vector1       
21	     MOVH R2, BYTEALTO DIRECCION vector1        
22	
23	     MOVL R3, BYTEBAJO DIRECCION vector2       
24	     MOVH R3, BYTEALTO DIRECCION vector2        
25	
26	     MOVL R4, BYTEBAJO DIRECCION sortida       
27	     MOVH R4, BYTEALTO DIRECCION sortida  
28	
29	carrega:       
30	     MOVL R0, 00h       
31	     MOVH R0, 00h       
32	     MOV R5, [R2]                                 
33	     MOV R6, [R3]			          
34	
35	multiplica:       
36	     ADD R0, R0, R5       
37	     DEC R6       
38	     BRNZ multiplica  
39	
40	desa:        
41	     MOV [R4], R0       
42	     INC R2       
43	     INC R3       
44	     INC R4       
45	     DEC R1       
46	     BRNZ carrega  
47	
48	final:     
49	JMP -1  
50	FIN

And the questions have been:

  1. Specify the origin memory address of the previous code.
  2. Specify the hexadecimal value contained in the memory address 0003h.
  3. In line 19 of the previous code, what is the value contained in R1?
  4. In line 22 of the previous code, what is the value contained in R2?
  5. In line 25 of the previous code, what is the value contained in R3?
  6. In line 28 of the previous code, what is the value contained in R4?
  7. Specify the tag containing the code in charge of change some memory contents?
  8. Which are the modified memory address after executing this code?
  9. Taking the previous answer into account, please, specify the contents of these modified memory addresses.
  10. Could you write the formula resolved in the previous code?

And the answers:

  1. The program starts at 0000h memory address, given that we have specified explicitly in the code with the code:
    ORIGEN 00h

    .

  2. I include below, the memory mapping and values of registers (2, 3 and 4), considering we stop the execution at line 28 ; with the following info we will be able to answer questions 2, 3, 4, 5 and 6:
  3. Register Memory Address Value
    R2 points to 0000h 0000h 0001h
    0001h 0002h
    0002h 0003h
    R3 points to 0003h 0003h 0005h
    0004h 0004h
    0005h 0003h
    R4 points to 0006h 0006h 0001h
    0007h 0001h
    0008h 0001h

    Regarding the register 1, its content is 0003h , the first Byte (low 8 bits) is set to CONSTANT1 (i.e. 0003h) whereas the second Byte (high 8 bits) is set to CONSTANT2 (i.e. 0000h), resulting the following value 00000000h | 00000003h .

  4. The tag in charge of storing new values in the memory, is named " DESA ", more concretely the code:
    MOV [R4], R0

    stores the content of R0 in the memory addresses contained in R4 , 0006h , 0007h and 0008h (one address in each loop).

  5. Again a memory map helps to answer the questions 8 and 9:
    Memory Address Value (Updated)
    0006h 0005h
    0007h 0008h
    0008h 0009h
  6. The formula or operation performed by this program is:
  7. SORTIDA[i] \;= \;VECTOR1[i] \;\cdot \;VECTOR2[i] \;\forall \;i \;\in \;]0,3]

Posted in computer science, teaching

Stop Terrorism

You don't have to teach people how to be human. You have to teach them how to stop being inhuman.

Stop Terrorism

STOP TERRORISM!

Posted in peace

Simulador máquina Von Neumann

Inauguro la publicación en el blog con un post que habla sobre el simulador de la máquina de Von Neumann desarrollado por la Universidad de Oviedo.

Se trata de un simulador portable para sistemas operativos Windows que permite emular el funcionamiento de un computador con arquitectura Von Neumann.

Al ser una herramienta con interfaz gráfica (ver la imagen del post), podemos ver los registros que hay contenidos en la CPU, la memoria, las líneas de conexión entre estos elementos (buses), etc.

Captura de pantalla del Simulador máquina de Von Neumann

Captura de pantalla del Simulador máquina de Von Neumann

Así pues, ésta herramienta nos permite monitorizar:

  1. Los señales internos de la CPU y los valores que hay en los registros de la misma.
  2. Las líneas de transmisión de información (buses) del sistema.

Y entre otras cosas, el simulador nos permite configurar la memoria del sistema así como dispositivos de entrada y salida como teclado (input), pantalla (output) o luces (input y output).

Voy a obviar mucha información sobre este simulador y pasaré a comentar el código del primer ejercicio de la asignatura Estructura de Computadores II de los alumnos del grado de informática de la Escuela Politécnica Superior de la Universidad de Lleida.

El enunciado, a modo resumen requería implementar un programa con inicio en la posición de memoria 0400h y que realizara la siguiente operación:

 resultado[i] \;= \;2 \cdot (2 \cdot operando1[i] + operando2[i]) - operando3[i] \;\forall \;i \;\in \;[0,4]

Dados 4 vectores operando1, operando2, operando3 y resultado; con los siguientes valores respectivamente:

  • operando1 = [0001h, 0002h, 0003h, 0004h, 0005h]
  • operando2 = [0005h, 0004h, 0003h, 0002h, 0001h]
  • operando3 = [0002h, 0002h, 0002h, 0002h, 0002h]
  • resultado = [0001h, 0001h, 0001h, 0001h, 0001h]

Pues bien, una de las posibles soluciones a esta práctica es la que se muestra a continuación:

CONSTANTE1 EQU 05h

ORIGEN 400h
INICIO ini

.DATOS
operand01 VALOR 0001h, 0002h, 0003h, 0004h, 0005h
operand02 VALOR 0005h, 0004h, 0003h, 0002h, 0001h
operand03 VALOR 5 VECES 0002h
resultado VALOR 5 VECES 0001h

.CODIGO

ini:
      MOVL R0, CONSTANTE1
      MOVH R0, 00h

      MOVL R1, BYTEBAJO DIRECCION operando1
      MOVH R1, BYTEALTO DIRECCION operando1
      MOVL R2, BYTEBAJO DIRECCION operando2
      MOVH R2, BYTEALTO DIRECCION operando2
      MOVL R3, BYTEBAJO DIRECCION operando3
      MOVH R3, BYTEALTO DIRECCION operando3
      MOVL R4, BYTEBAJO DIRECCION resultado
      MOVH R4, BYTEALTO DIRECCION resultado

operar:
      MOV R5, [R1]
      MOV R6, [R2]
      ADD R5, R5, R5
      ADD R5, R5, R6
      ADD R5, R5, R5
      MOV R6, [R3]
      SUB R5, R5, R6
      MOV R6, R4
      MOV [R6], R5
      INC R1
      INC R2
      INC R3
      INC R4
      DEC R0
      BRNZ operar

final:
    JMP -1

FIN

Así pues, en la primera parte del código, veremos como R1, R2, R3 y R4 están apuntando a las posiciones de memoria de los primeros valores de los vectores operando1, operando2, operando3 y resultado respectivamente. Teniendo en cuenta que el programa empieza en la posición de memoria 0400h y que los 4 vectores tienen 5 elementos, antes de la etiqueta operar los valores de los registros mencionados serán:

  1. R1=400h
  2. R1=405h
  3. R1=40Ah
  4. R1=40Fh

De este modo, una vez dentro de la función (bucle) con etiqueta operar lo que hacemos es:

operar:
MOV R5, [R1]
MOV R6, [R2]

Cargamos el contenido de la dirección de memoria que apuntada por R1 y R2 en los registros R5 y R6 respectivamente. Por tanto, la primera vez que se ejecutan ambas sentencias, los valores de R5 y R6 serán 0001h y 0005h respectivamente.

En la siguiente porción de código, realizamos la operación que nos pide realizar el problema, para una iterador o [code]i[/code] concreto.

ADD R5, R5, R5
ADD R5, R5, R6
ADD R5, R5, R5
MOV R6, [R3]
SUB R5, R5, R6

Uno de los requisitos del problema, es almacenar el resultado de cada iteración en el vector resultado[i]. Para ello cargamos la dirección de memoria que tenemos almacenada en el registro R4 a R6, lo cual nos cargará en la primera iteración el valor 040Fh ; para luego almacenar el resultado de la operación almacenado en R5 en la dirección de memoria apuntada por R6, es decir [R6].

MOV R6, R4
MOV [R6], R5

Por último, tenemos que incrementar el iterador i, lo cual nos permitirá saltar al siguiente valor de los vectores. Para ello, incrementamos los registros R1 a R4. Por último, decrementaremos el registro R0, que contiene el valor hexadecimal 0005h , valor que se decrementaremos cada vez que hayamos finalizado una iteración. Hasta cuánto iteraremos? Pues bien, ejecutaremos el código que hay dentro de la función o etiqueta operacion mientras R0 no sea 0000h , lo cual nos va a permitir realizar 5 iteraciones (de 0005h a 0001h ambos incluidos).

INC R1
INC R2
INC R3
INC R4
DEC R0
BRNZ operar

Por último finalizamos el código una vez acabadas las iteraciones.

final:
    JMP -1

FIN
Posted in computer science, teaching