miércoles, 18 de abril de 2012

TAREA ENSAMBLADOR

Despues de pelearme estudiar ensamblador y comprender como funciona (no todo, pero ya minimo tengo la idea) POR FIN hice mi tarea ensamblador.

Algo que tendo que decir es que no me fui por el camino de todos, hice el programa ensamblador casi desde "0", digo casi desde "0" porque me basaba en muchos codigos ejemplo.

Programa en C
El programa trata de la suma de elementos de un arreglo de n enteros.

#include 

//Declaracion de funciones
void Leer_datos();
void Sumar_datos();
void Imprimir_datos();

//Declaracion de variables globales
int i,n,lista[10],sumatoria;


main () 
{
 Leer_datos();
 Sumar_datos();
 Imprimir_datos();
} /*fin de la funcion main()*/


void Leer_datos()
{
 printf( "Introduzca el numero de elementos del arreglo: " );
 scanf("%d",&n);
 
 for( i=1;i<=n;i++ )
 { 
  printf( "Introduzca a[ %d ]: ", i );
  scanf("%d", &lista[i]); 
 } 
 return;
} /*fin de la funcion Leer_datos()*/

void Sumar_datos()
{
 sumatoria=0;
 for( i=1;i<=n;i++ )
 {
  sumatoria = sumatoria + lista[i];
 }
 return;
} /*fin de la funcion Sumar_datos()*/

void Imprimir_datos()
{
 printf("La suma de los elementos del arreglo es: %d\n", sumatoria);
 return;
}/*fin de la funcion Imprimir_datos()*/


Codigo en Ensamblador

.section .data     #se declaran datos inicializados
  lee: .asciz"Introduzca el numero de elementos del arreglo: "
  leen: .asciz"%d"  
  leenum: .asciz"Introduzca a[%d]: "
  resul: .asciz"La suma de los elementos del arreglo es: %d\n"
  n: .long 0  
  x: .long 0

.section .bss     #se declaran datos NO inicializados
  arreglo:.space 400  #se declara un arreglo de 400 bytes

.section .text     #instrucciones
  .globl _start  

_start:  
  pushl $lee   # Apila el mensaje inicial
  call printf   # Imprime el contenido de %eax en este caso 
        # "lee"
  leal n, %eax   # Actualiza el registro %eax con la dirección 
      # de n
      #############################################
      #  leal:permite obtener la dirección de un  # 
      #  operando en vez de su valor              #
      #############################################
  pushl %eax 
  pushl $leen 
  call scanf   # lee n (numero de elementos del arreglo)
  xorl %esi, %esi   # %esi es el indice del arreglo (i)
  xorl %edi, %edi   # %edi es el acumulador
leeSum: 
  cmpl n, %esi   # compara i con n
  je fin    # cuando i=n salta a fin
  pushl %esi 
  pushl $leenum 
  call printf   # imprime mensaje para lectura de a[i]
  leal x, %ebx 
  pushl %ebx 
  pushl $leen 
  call scanf   # lee a[i]
  addl x, %edi   # suma a[i] a %edi
  incl %esi   # incrementa %esi (i)
  jmp leeSum   # vuelve a leer siguiente elemento
fin: 
  pushl %edi 
  pushl $resul 
  call printf   # muestra por pantalla la suma
  movl $1, %eax   # fin 
  movl $0, %ebx          # del
  int $0x80   # programa


Si nos encargaran otra tarea como esta, preferiria pagar para que me la hagan.

De las cosas que hay que destacar es que en ensamblador, casi todo es "una función" un FOR, un pedazo de IF, es por eso yo ya no me meto con ensamblador, si no es necesario.

Tambien hay que tener en cuenta todos los registro que se usan y que es lo que contiene esos registros, yo sugiero que al momento de hacer un programa en ensamblador tengan una libreta a la mano para que esten checando que es lo que contiene cada registro y asi no se nos dificulte a la hora, por ejemplo, de hacer sumas, restas o cualquier otra operacion aritmetica.

REFERENCIAS

http://learnassembler.com/valor.html
atc.ugr.es/pedro/docencia/ec1/practica1/1_pract_intro.pdf

jueves, 5 de abril de 2012

Reporte 9 - Paralelos

Viendo ejemplos de como podría mandar datos a los demás nodos en cierto orden y que estos me los regresen también en cierto orden me encontré con una serie de métodos que nos sirvan para la comunicación colectiva.

Uno de los comandos utilizados con mas frecuencia en la comunicación colectiva es:

Broadcast: Bcast(buffer,size,datatype,root,communicator)

En el nodo cuyo rango MPI es igual al root: Induce la distribución de los datos en la memoria de los demás nodos.

En todos los demás nodos: se llena la memoria con datos recibidos desde el nodo root

Otros comandos frecuentes son:

Scatter()/Scatterv(): Envía un vector de datos desde un nodo (por lo general en nodo root) de manera que cada nodo recibe una parte.

Gather()/Gatherv(): Recoge las partes de un vector que son distribuidos en todos los nodos, en el buffer de un nodo (por lo general del nodo root)

Allgather()/Allgatherv(): Recoge las partes de un vector de manera que cada nodo se obtiene un conjunto completo de todas las partes.

Alltoall()/Alltoallv(): Intercambia partes de una colección de vectores.

La variante -v es utilizada para datos de un tamaño no-uniforme. 

y este es un codigo ejemplo, para ver el funcionamiento de algunos metodos.

import mpi4py.MPI as MPI, cPickle, numpy

comm=MPI.COMMWORLD
mpi_size = comm.Get_size()
mpi_rank = comm.Get_rank()

def pybroadcast_master(x):
 x_str = cPickle.dumps(x)
 buf_xlen = numpy.array( [len( x_str )],
    dtype=numpy.uint32 )
 # MPI Collective Command:
 comm.Bcast([buf_xlen, 1, MPI.INT], 0)
 buf_xdata = numpy.array([ord(c) for c in x_str],
    dtype = numpy.uint8)
 # MPI Collective Command:
 comm.Bcast([buf_xdata, len(x_str), MPI .CHAR],0 )
 return x

def pybroadcast_slave():
 buf_xlen=numpy.zeros(1, dtype=numpy.uint32)
 #MPI Collective Command:
 comm.Bcast([buf_xlen, 1, MPI.INT])
 nbytes = bufxlen[0]
 recv = numpy.zeros(nbytes, dtype=numpy.uint8)
 # MPI Collective Command:
 comm.Bcast([recv, nbytes, MPI.CHAR], 0)
 return cPickle.loads( ””.join([chr(x) for x in recv]) )

def pybroadcast( x=None ):
 if mpi_rank == 0:
  return pybroadcast_master(x)
 else:
  return pybroadcast_slave()

the_data = None

if mpi_rank == 0:
 n = int(raw input(”Please give a number: ” ))
 the_data = [x*x for x in range (n)]

mydata = pybroadcast(the_data)

print ”I am node %d/%d and have data %s\n”%\
    (mpi_rank, mpi_size, str(mydata))

lo que da como resultado




Nomino a Jose Guadalupe por su ultima entrada

http://elisa.dyndns-web.com/progra/ComunicacionMPI