domingo, 17 de mayo de 2015







 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.





ALUMNO: JUAN GARCÍA GARCÍA.


PROBLEMA DE LA COHERENCIA DE CACHÉ Y SOLUCIONES.



PROBLEMA DE LA COHERENCIA DE CACHÉ

La memoria debe proporcionar un conjunto de direcciones para almacenar valores, y cuando se lea una de estas direcciones debe devolver el último valor escrito  en ella.

 Es en esta propiedad fundamental de las memorias en la que descansan los programas secuenciales cuando usamos la memoria para comunicar un valor desde un punto del programa donde se calcula a otros puntos donde es usado.
También nos basamos en esta propiedad cuando el sistema usa un espacio de direcciones compartido para comunicar datos entre hebras o procesos que se están ejecutando en un procesador. Una lectura devuelve el ´ultimo valor escrito en esa dirección, sin importar el proceso que escribió dicho valor.


 Las cachés (antememorias) no interfieren con el uso de múltiples procesos en un procesador, ya que todos ellos ven la memoria a través de la misma jerarquía de cachés. En el caso de usar varios procesadores, nos gustaría poder basarnos en la misma propiedad cuando dos procesos se ejecuten sobre diferentes procesadores de tal forma que el resultado de ejecutar un programa que usa varios procesos sea el mismo independientemente de si los procesos se ejecutan o no en diferentes procesadores físicos. Sin embargo, cuando dos procesos ven la memoria compartida a través de diferentes cachés, existe el peligro de que uno vea el nuevo valor en su caché mientras que el otro todavía vea el antiguo.

Informalmente se puede decir que un sistema de memoria es coherente si cualquier lectura de un dato devuelve el valor más recientemente escrito de ese dato. Esta definición, aunque intuitivamente correcta, es vaga y simple; la realidad es bastante más compleja. Esta definición simple contiene dos aspectos diferentes del comportamiento del sistema de memoria, siendo los dos críticos a la hora de escribir programas en memoria compartida. El primer aspecto, llamado coherencia definen los datos devueltos por una lectura. El segundo aspecto, llamado consistencia, determina cuando un valor escrito ser´a devuelto por una lectura



Los problemas de coherencia en la caché también ocurren cuando utilizamos un ´único procesador en el caso de las operaciones de E/S. La mayoría de estas operaciones se realizan a través de dispositivos DMA con lo que es posible que que el contenido de la memoria principal y la memoria caché dejen de ser coherentes.



SOLUCIONES

Dado que las operaciones de E/S son mucho menos frecuentes que las operaciones de acceso a memoria, se han adoptado soluciones sencillas como usar direcciones de memoria que se marcan como no almacenables en la memoria caché o eliminar todos los bloques existentes en las cachés de las páginas que se van a utilizar en la operación de E/S antes de proceder a realizar dicha operación. En la actualidad, casi todos los microprocesadores proporcionan mecanismos para soportar la coherencia de cachés


REFERENCIAS

http://www.azulweb.net/ley-de-moore-podcast-5/
http://informatica.uv.es/iiguia/AAC/AA/apuntes/aic_multiproc.pdf
http://es.wikipedia.org/wiki/Coherencia_de_cach%C3%A9

jueves, 26 de marzo de 2015




FECHA: 26 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

#MULTIPLICACION DE MATRICES CREW
#JUAN GARCIA GARCIA

from threading import Thread
import math

##Usando 2 hilos como nos dice la descripcion del problema
def hilo1(i,j,k):
    C[k][i][j]=int(A[i][k])* int(B[k][j])

def hilo2(i,j,k,l):
    if(((2*k) % (2 **l))==0):
        C2[2*k][i][j]=int(C[2*k][i][j]+C[2*k-(2**(l))][i][j])

print"--------------------------------------------------------------------------------"
print "                        MULTIPLICACION DE MATRICES CREW"
print"--------------------------------------------------------------------------------"
print""

A=[[0 for _ in range(2)] for _ in range(2)]
B=[[0 for _ in range(2)] for _ in range(2)]
C=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
C2=[[[0 for _ in range(2)] for _ in range(2)] for _ in range(2)]
    
lg=int(math.log(2,2))
print "\n\n                       Matriz A:"
i=0
while(i<2):
    j=0
    while(j<2):
        #Llenado de la Matriz A
        print "Dame la cordenada [",i+1 ,", ",j+1," ]: "
        x=int(raw_input())
        A[i][j]=x
        j=j+1
    i=i+1

print "\n\n                     Matriz B:"
i=0
while(i<2):
    j=0
    while(j<2):
        #Llenado de la Matriz B
        print "Dame la cordenada [",i+1 ,", ",j+1," ]: "
        x=int(raw_input())
        B[i][j]=x
        j=j+1
    i=i+1

#Mostrando la operacion a realizar
print "\nMultiplicaciones : \n"
print "[ ",A[0][0],"  ",A[0][1]," ]      X      [ ",B[0][0],"  ",B[0][1]," ]"
print "[ ",A[1][0],"  ",A[1][1]," ]      X      [ ",B[1][0],"  ",B[1][1]," ]"

k=0
while(k<2):
    i=0
    while(i<2):
        j=0
        while(j<2):
            t=Thread(target=hilo1,args=(i,j,k))
            t.start()
            t.join()
            j=j+1
        i=i+1
    k=k+1

#Descomposicion
print "\n\nPrimer Proceso: ",C

l=0
while(l<lg):
    i=0
    while(i<2):
        j=0
        while(j<2):
            k=0
            while(k<1):
                t=Thread(target=hilo2,args=(i,j,k,l))
                t.start()
                t.join()
                k=k+1
            j=j+1
        i=i+1
    l=l+1

#Resultado de la multiplicacion CREW
print "\nResolucion de  A X B: \n"

print "          [ ",C2[0][0][0],"  ",C2[0][0][1]," ]"
print "          [ ",C2[0][1][0],"  ",C2[0][1][1]," ]"
    

  





FECHA: 19 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  




#ORDENAMIENTO PRAM EREW RECURSIVO
#JUAN GARCIA GARCIA


from threading import Thread

def hilo3(L2,INI,FIN):
    oddEvenMerge(L2,INI,FIN)
    print "procesos: ",L2[1:FIN+1]
 

def OddEvenMerge(L2,INI,FIN):
    t3=Thread(target=oddEvenMerge,args=(L2,INI,FIN))
    t3.start()
    t3.join()

def oddEvenMerge(L2,INI,FIN):
    m=(FIN-INI)+1
    odd=[0 for _ in range((m/2)+1)]
    even=[0 for _ in range((m/2)+1)]
    if(m==2):
        if(L2[INI]>L2[FIN]):
            intercambio(L2,INI,FIN)
    else:
        oddEvenSplit(L2,odd,even,INI,m)
        t=Thread(target=ordena,args=(odd,(m/2)))
        t.start()
        t.join()
        t2=Thread(target=ordena,args=(even,(m/2)))
        t2.start()
        t2.join()
     
        i=1
        while(i<=(m/2)):
            t=Thread(target=mezcla,args=(L2,odd,even,i,1))
            t.start()
            t.join()
            i=i+1
         
        i=1
        while(i<int(m/2)):
            t=Thread(target=HiloOddEven,args=(L2,i))
            t.start()
            t.join()
            i=i+1
        i=1
        while(i<=int(m/2)):
            t=Thread(target=HiloOddEvenC,args=(L2,i))
            t.start()
            t.join()
            i=i+1
     

def intercambio(L2,INI,FIN):
    aux=L2[INI]
    L2[INI]=L2[FIN]
    L2[FIN]=aux


def oddEvenSplit(L2,odd,even,INI,FIN):
    od=1
    ev=1
    x=INI
    while(x<=FIN):
        if((x%2)==0):
            even[ev]=L2[x]
            ev=ev+1
        else:
            odd[od]=L2[x]
            od=od+1
        x=x+1
    print "valor  odd: ",odd[1:FIN+1]
    print "\nvalor  even: ",even[1:FIN+1]

 
def ordena(L2,FIN):
    L3=L2
    numero=FIN
    OddEvenMerge(L3,1,numero)


def mezcla(L2,odd,even,j,aux):
    m=L2
    impar=odd
    par=even
    m[(2*j)-1]=impar[j]
    m[2*j]=par[j]


def HiloOddEven(num,i):
    numero=num
    j=i
    a=(2*j)
    b=(2*j)+1
    if(numero[a]>numero[b]):
        intercambio(numero,a,b)

def HiloOddEvenC(num,i):
    numero=num
    j=i
    a=(2*j)-1
    b=(2*j)
    if(numero[a]>numero[b]):
        intercambio(numero,a,b)







print "                                ORDENAMIENTO PRAM EREW RECURSIVO"
print"-------------------------------------------------------------------------------"
print"(SOLO CON MULTIPLOS DE 2 (2-4-8-etc))"
print""
print "\n Con cuantos datos desea trabajar? : "
n=int(raw_input())
while((n%2)!=0):
    print "La dimension de la lista no es multiplo de 2!"
    print "Ingrese una dimension que sea multiplo de 2: "
    n=int(raw_input())

L=[0 for _ in range(n+1)]
 
i=0
while(i<n):
    print "\nDame numero ",i+1
    x=int(raw_input())
    L[i+1]=x
    i=i+1
 
print "Vector Inicial: ",L[1:n+1]
OddEvenMerge(L,1,n)

print "\nVector Ordenado: ",L[1:n+1]




FECHA: 17 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.



#ORDENAMIENTO CRCW
#JUAN GARCIA GARCIA




from threading import Thread

#Procesos de Hilos

def hilo1(win,i):
    win.insert(i,0)


def hilo2(win,i,j):
    if(L[i]>L[j]):
        win[i]=win[i]+1
    else:
        win[j]=win[j]+1


def hilo3(i,win):
    L2.insert(win[i],L[i])
    L2.pop(win[i]+1)



L=[]
L2=[]
WIN=[]
indexMin=[]

print"                                  ORDENAMIENTO CRCW"
print"---------------------------------------------------------------------------"
print""

n=int(raw_input("Con que cantidad de datos deseas Trabajar: "))
i=0
while(i<n):
    print "Dame numero",i+1,":",
    x=int(raw_input())
    L.append(x)
    L2.append(0)
    i=i+1

n=len(L)
print "\nVector de Entrada:           ",L
i=1
while(i<=n):
    t=Thread(target=hilo1,args=(WIN,i))
    t.start()
    t.join()
    i=i+1
print "\nInicializa WIN:              ",WIN
i=0

while(i<=n):
    j=i+1
    while(j<n and i<j):
        t=Thread(target=hilo2,args=(WIN,i,j))
        t.start()
        t.join()
        j=j+1  
    i=i+1

print "\nLlenando el indice de  WIN:  ",WIN
i=0
while(i<n):
    t=Thread(target=hilo3,args=(i,WIN))
    t.start()
    t.join()
    i=i+1
print "\nVector Ordenado:             ",L2


  

  





FECHA: 14 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  
#BUSQUEDA PRAM CRCW
#JUAN GARCIA GARCIA


import math
from threading import Thread

#HILOS

def hilo1(Win,i):
    Win[i]=0
    
def hilo2(L,Win,i,j):
    if(L[i]>L[j]):
        Win[i]=1
    else:
        Win[j]=1
    
def hilo3(Win,i,ind):
    if(Win[i]==0):
        ind[0]=i


print "                              BUSQUEDA PRAM CRCW"
print"----------------------------------------------------------------------------"

#Aqui esta el vector inicial estatico  Dado
L=[95,34,6,56]
Win=[1,1,1,1]
ind=[10000000]
i=0
n=len(L)

#WHILES......

while(i<n):
    if(i>=0):
        t = Thread(target=hilo1, args = (Win,i))
        t.start()
        t.join()
    i=i+1
i=0
j=i+1

print "PROCESO 1"
print "Vector original:----->", L
print Win

while(j<n):
    if(i<j):
        if(i>=0):
            t = Thread(target=hilo2, args = (L,Win,i,j))
            t.start()
            t.join()
    i=i+1
    j=j+1
i=0
print "\nPROCESO 2"
print Win



while(i<n):
    if(i>=0):
        t = Thread(target=hilo3, args = (Win,i,ind))
        t.start()
        t.join()
        i=i+1

print "\nPROCESO 3"
print "Encontrando el minimo señalado con un 0\n", Win 

        
print " \nEl valor minimo es:  ", L[ind[0]]





FECHA: 12 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  
#BUSQUEDA PRAM EREW
#JUAN GARCIA GARCIA

import math
from threading import Thread


def hilo1(Temp2,i,j):
    Temp2.insert(j,Temp2[j-(2**i-1)])
    

def hilo2(K,Temp2,x,n):
    if(x<(n-1)):
        if(K[x]==Temp2[x]):
            Temp2[x]=x+1
        else:
            Temp2[x]=99999


def hilo3(Temp2,n,k):
    if(Temp2[(2**(k))-1]>Temp2[2**k]):
        Temp2[k]=Temp2[2*k]
    else:
        Temp2[k]=Temp2[(2**(k))-1]


def Broadcast(Temp,x,n):
    Temp2=[]
    Temp2=Temp
    Temp2.insert(0,numero)
    Temp2.insert(1,numero)
    i=1
    while(i<=lg):
        j=(2**(i-1))+1
        while(j<=2**i):
            t=Thread(target=hilo1,args=(Temp2,i,j))
            t.start()
            t.join()
            j=j+1
        i=i+1
        


def SearchPram(Temp,lista,n):
    i=0
    while(i<=n):
        t=Thread(target=hilo2,args=(lista,Temp,i,n))
        t.start()
        t.join()
        i=i+1


def MinPram(Temp,n):
    i=1
    while(i<=lg):
        j=1
        while(j<=int(n/(2**j))):
            t=Thread(target=hilo3,args=(Temp,n,i))
            t.start()
            t.join()
            j=j+1
        i=i+1





a=[]
Temp=[]
lista=[2,-1,23,-4,2,5,-2,5,-2,0,5,1,5,-5,8,5,3,-2]
n=len(lista)
lg=int(math.log(n,2))
# ->  Esta parte es estatica solo agregar a la variable  numero el numero a buscar
numero=0 
print "                             BUSQUEDA PRAM EREW"
print "------------------------------------------------------------------------"
print "VECTOR DE ENTRADA:"
print lista
Broadcast(Temp,numero,n)
print "------------------------------------------------------------------------"
print "\nVECTOR TEMPORAL: "
print Temp
SearchPram(Temp,lista,n)
print "------------------------------------------------------------------------"
print "\nINDICES:"
print Temp
MinPram(Temp,n)
h=1
while(h<len(Temp)):
    if(Temp[h]!=99999):
        pos=Temp[h]
        break
    h=h+1
print "------------------------------------------------------------------------"
print "DONDE",numero," ESTA EN LA POSICION NUMERO: ",pos





FECHA: 10 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  
#SUMA PRAM CREW
#JUAN GARCIA GARCIA


import math
from threading import Thread


def hilo(i,j):
    b[j] = a[j]+a[int(j-2**(i-1))]

# --> Aqui agregamos el arreglo estatico que se desea SUMAR
print "                           SUMA PRAM CREW"
print "------------------------------------------------------------------------"
a = [0,5,2,10,1,8,12,7,3]
b=[0,0,0,0,0,0,0,0,0]
n = len(a)-1
lg = int(math.log(n,2))
print a
print "Vector Inicial"
print ""
i = 1
while(i<lg):
    j=i
    while(j<=n):
        if((2**(i-1))+1<=j):
            t = Thread(target=hilo, args=(i,j))
            t.start()
            j = j+1
            t.join()
        else:
            b[j]=a[j]
            j=j+1
        print "Proceso Suma"
        print b
    i=i+1
    a=b





FECHA: 05 DE MARZO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  

#SUMA SECUENCIAL
#SUMA PRAM EREW
#JUAN GARCIA GARCIA


import math
def hilo(i,j):
    if((2*j % 2**i) == 0):
        a[int(2*j)] = a[int(2*j)] + a[int(2*j - 2**(i-1))]


print"                             SUMA PRAM EREW"
print"------------------------------------------------------------------------"

#Vector estatico
a = [0,1,1,1,1,1,1,1,1]
n = len(a)
lg = int(math.log(n,2))
print a
print "Vector Inicial"
print""

i = 1
while(i<=lg):
    j=1
    while(j<=n/2):
        hilo(i,j)
        j = j+1
    print "Proceso"
    print a
    i=i+1
   

domingo, 15 de marzo de 2015




FECHA: 26 DE FEBRERO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  TRABAJO/TAREA: PROCESAMIENTO PIPELINE.






Definición de Peline

En computación, se le llama pipeline a una serie de elementos de procesamiento de datos ordenados de tal modo que la salida de cada uno es la entrada del siguiente, como quien dice una cadena de montaje pero en vez de orientada a la manufactura, orientada al procesamiento de datos e instrucciones. En esta guía explicaremos cómo funcionan.

La arquitectura en pipeline (basada en filtros) consiste en ir transformando un flujo de datos en un proceso comprendido por varias fases secuenciales, siendo la entrada de cada una la salida de la anterior.
Esta arquitectura es muy común en el desarrollo de programas para el interprete de comandos, ya que se pueden concatenar comandos fácilmente con tuberías.
También es una arquitectura muy natural en el paradigma de programación funcional, ya que equivale a la composición de funciones matemáticas.

Pipeline (Tuberias) es un término que pertenece a la ingeniería de software  y consiste en una cadena de elementos de procesamiento ordenados de tal manera que la salida de cada elemento es la entrada del siguiente elemento  con almacenamiento temporal de datos o buffering entre todos  los procesos.

Aplicaciones de pipelines en informática
– Pipelines graficos  se encuentran en la mayoría de las tarjetas graficadoras y consiste en múltiples unidades aritméticas o
CPUs completas  que implementan variados escenarios de operaciones típicas, por ejemplo calculos de luz y colores  renderizado
proyección de perspectiva entre otros.
– En software o tuberías  consiste en varios  procesos ordenados de tal forma que el flujo de salida de un proceso alimenta la entrada
del siguiente proceso. Como por ejemplo, los pipelines de Unix.
Consumo en la Aquitectura  Pipeline
A fin de reducir consumo  se investiga una solución de compromiso entre la
resolución por etapa y la cantidad de etapas.
El  método de escalamiento de capacitores está descrito para reducir la potencia  con el cual se ha sobredimensionado en las últimas etapas del caso de una arquitectura Pipeline
–       Tarea o Procedimientos.- Acciones que se toman dentro de un mismo programa ejecutándose procesos independientes en forma simultánea.

–       Interinstrucciones.- Acciones a nivel de instrucción o sea  dentro de mismo proceso o tarea se pueden ejecutar instrucciones independientes en forma simultánea.

Referencias:
http://www.chw.net/2006/06/como-funcionan-los-pipelines-de-un-cpu/



FECHA: 24 DE FEBRERO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  TRABAJO/TAREA: ALGORITMOS DE ORDENAMIENTO Y BÚSQUEDA SECUENCIAL.




a=input("INTRODUCE EL TAMAÑO DEL LISTADO A ORDENAR:")
length of the list
l=[]                                              
for g in range (a):                        
    b=input("DIGITA EL ELEMENTO DE LA LISTA :")        
   
    l.append(b)                              
print "LA LISTA INTRODUCIDA ES: ",l
for  i in range (len(l)):                        
    index=i                                
    num=l[i]                              
    for j in range(i+1,len(l)):      
        if num>l[j]:                    
            index=j                
            num=l[j]              
    tem=l[i]                        
    l[i]=l[index]                
    l[index]=tem
print "DESPUES DE ORDENAR: ",l



BubbleSort:

def BubbleSort(lst):
    lst = list(lst) #copy collection to list
    for passesLeft in range(len(lst)-1, 0, -1):
        for i in range(passesLeft):
            if lst[i] < lst[i + 1]:
               lst[i], lst[i + 1] = lst[i + 1], lst[i]
    return lst


Insertsort:

def insertsort(array):
    for removed_index in range(1, len(array)):
        removed_value = array[removed_index]
        insert_index = removed_index
        while insert_index > 0 and array[insert_index - 1] > removed_value:
            array[insert_index] = array[insert_index - 1]
            insert_index -= 1
        array[insert_index] = removed_value



Mergesort:

def mergesort(arr):
    if len(arr) == 1:
        return arr
   
    m = len(arr) / 2
    l = mergesort(arr[:m])
    r = mergesort(arr[m:])

    if not len(l) or not len(r):
        return l or r
       
    result = []
    i = j = 0
    while (len(result) < len(r)+len(l)):        
        if l[i] < r[j]:
            result.append(l[i])
            i += 1
        else:
            result.append(r[j])
            j += 1            
        if i == len(l) or j == len(r):            
            result.extend(l[i:] or r[j:])
            break
       
    return result




Qsort:

def qsort2(L):
    if len(L)<=1:
        return L
    pivot=L[0]
    less=    [x for x in L if x<pivot]
    equal=   [x for x in L if x==pivot]
    greater= [x for x in L if x>pivot]
    return qsort2(less)+equal+qsort2(greater)



BinarySearch:

def binarySearch(array, key, low, high):
    if low > high: # termination case
        return -1

    middle = (low + high) / 2 # gets the middle of the array

    if array[middle] == key:  # if the middle is our key
        return middle
    elif key < array[middle]: # our key might be in the left sub-array
        return binarySearch(array, key, low, middle-1)
    else:                     # our key might be in the right sub-array
        return binarySearch(array, key, middle+1, high)



Busqueda secuencial: 

vector=['1','33','23','45','12','78','99','21','31']
valor_a_buscar='21'
posicion=0
encontrado='No'
posicion_del_valor_a_buscar=0
longuitud_del_vector=len(vector)
while posicion< longuitud_del_vector:
    if vector[posicion]==valor_a_buscar :
        posicion_del_valor_a_buscar=posicion
    encontrado='Si'
    posicion=posicion+1
   if encontrado=='Si':
       print 'Valor '+valor_a_buscar+' encontrado en posicion '+str(posicion)
   else:

       print 'Valor no encontrado

REFERENCIAS:
http://www.codecodex.com/wiki/Quicksort





FECHA: 21 DE FEBRERO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  TRABAJO/TAREA: PROGRAMACIÓN DE COMPUTADORAS PARALELAS.


INTRODUCCIÓN. 
 En el año de 1988 Axelrod y McGraw se dieron a la tarea de identificar las cuatro formas que hasta el día de hoy nos sirven como guía principal en el desarrollo de software para las computadoras paralelas, y son las siguientes:
Extender o enriquecer un compilador existente para que traduzca programas secuenciales en programas paralelos.
Extender o enriquecer un lenguaje existente con nuevas operaciones que permita a los usuarios expresar el paralelismo.
Agregar una nueva capa de lenguaje paralelo encima de un lenguaje secuencial existente.
Definir totalmente un nuevo lenguaje paralelo así como su compilador.
En esta ocasión únicamente veremos lo relacionado a los enfoques tres y cuatro.

DESARROLLO.
Con lo referente al enfoque numero tres "AGREGAR UNA CAPA DE PROGRAMACIÓN PARALELA", imaginemos que la programación paralela tiene dos capas: la capa inferior contiene el núcleo del cómputo, donde un proceso manipula su parte de los datos para producir su parte del resultado, mientras que la capa superior controla la creación y sincronización de los procesos y la partición de los datos entre los procesos. El compilador sería responsable de traducir estas dos capas del programa paralelo en código listo para su ejecución sobre una computadora paralela.
Dos ejemplos de este enfoque son:
CODE (Computationally Oriented Display Environment): es un lenguaje de programación visual el cual permite al usuario convertir programa secuenciales a paralelos.
HENCE (Heterogeneous Network Computing Environment): es un programa diseñado para asistir al usuario en el desarrollo de programas paralelos que funcionen en una red de computadoras.
Este enfoque requiere que el programador aprenda y use un nuevo sistema de programación paralelo, lo cual puede ser la razón por la que no ha captado mucha atención en la comunidad de programación paralela.
Y en cuanto al enfoque numero cuatro "CREAR UN LENGUAJE PARALELO", consiste en desarrollar un lenguaje de programación desde cero. El lenguaje de programación OCCAM (desarrollado por el Inglés David May) es un ejemplo famoso de este enfoque. Cuenta con una sintaxis totalmente diferente de los lenguajes tradicionales, este lenguaje soporta tanto la ejecución de procesos en paralelo como secuenciales, así como la comunicación y la sincronización entre ellos.
Una desventaja de este enfoque es el hecho de que al agregar instrucciones paralelas a un lenguaje de programación existente o crear por completo un nuevo lenguaje de programación paralelo requiere el desarrollo de nuevos compiladores. El desarrollo de un compilador nuevo de alta calidad normalmente lleva años de trabajo.
Algunos lenguajes paralelos, tales como C*, no fueron adoptados como estándar. En esta situación muchos vendedores en competencia decidieron no proporcionar compiladores para el lenguaje en sus máquinas. Cuando esto pasa, la portabilidad de códigos se encuentra severamente en peligro.
Otra barrera para la adopción de nuevos lenguajes de programación es la resistencia del usuario. Cuando nuevas construcciones paralelas se agregan a un lenguaje de programación, los programadores deben aprender cómo usar estas nuevas construcciones. Muchos programadores están renuentes a tomar esta transición.

CONCLUSIONES.
Como nos podemos dar cuenta, la programación paralela nos ayuda a mejorar y optimizar el rendimiento de las computadoras, ya que al poder ejecutar varias instrucciones al mismo tiempo podemos reducir tiempos de ejecución. De la misma manera en que nos podemos percatar de los beneficios de los programas paralelos, también podemos ver que son más complicados de escribir que los secuenciales es por tal motivo que es importante contar con el conocimiento y saber como y cuando aplicarlo.

REFERENCIAS.
http://es.wikibooks.org/wiki/Mantenimiento_y_Montaje_de_Equipos_Inform%C3%A1ticos/Texto_completo

miércoles, 18 de febrero de 2015


ENCUESTA


En la entrada pasada se introdujo al blog un link de una encuesta realizada en linea, donde participaron alumnos y profesores de la UAEMex, Con esta encuesta se pretendía que con una participación de 50 personas se pudiera sacar una interpretación gráfica de la situación actual de la Programación Paralela en cuanto a sus aplicaciones y el conocimiento de la misma.

Aquí los resultados.





Como verán, la encuesta demuestra que mas de la mitad de los encuestados considera que el rendimiento y la escalabilidad son importantes, pero en equilibrio con la resistencia y seguridad. Y dentro de los resultados mas significativos también esta con un 48% de los encuestados, que optimizar el rendimiento multinucleo con el mínimo esfuerzo es mas importante dentro de este ámbito para sus empresas.


Saludos.


martes, 10 de febrero de 2015

  



FECHA: 10 DE FEBRERO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  TRABAJO/TAREA: LAS COMPUTADORAS CUÁNTICAS.






INTRODUCCIÓN.

Les cuento acerca de las computadoras cuánticas.

En este articulo del blog, tratare de introducir uno de los nuevos campos que está entrando con fuerza en el ámbito de la ingeniería en Computación y es desarrollado tanto por Ingenieros como por Físicos y Matemáticos. Tengo que mencionar que al momento de hacer esta investigación para mi clase de Programación Paralela y Distribuida me percate de que existen diversos enfoques para este tema, por lo que me di a la tarea de escoger aquel enfoque que se prestara a una fácil comprensión del mismo.

¡Comencemos!

DESARROLLO.

Tras la reciente noticia sobre los supuestos planes de la Agencia de Seguridad Nacional (NSA, por sus siglas en inglés) de Estados Unidos de manufacturar una supercomputadora cuántica, muchos se preguntan qué significa exactamente la construcción de semejante computadora.

Michael Marthaler, adscrito al Instituto de Física Teórica de Cuerpos Sólidos en el Instituto de Tecnología de Karlsruhe (KIT), en Alemania, investiga el fascinante mundo de las computadoras cuánticas. Un mundo apenas explorado todavía que parece ser el próximo horizonte en el mundo de la computación, aunque de momento solo se explora en laboratorios.

“En una computadora clásica, la unidad base es el bit. Éste puede tener forma de los números 0 ó 1. En una computadora cuántica, los bits pueden adoptar otros estados, y con ello son capaces de transferir cantidades mucho mayores de información, y realizar incontables operaciones informáticas al mismo tiempo”, explica Marthaler.

Utilidades


Actualmente, se experimenta el potencial de la computación cuántica para descodificar mensajes cifrados con criptografías de clave pública o asimétrica. Este es un sistema que requieren que ambos agentes en el envío de un mensaje, el remitente y el receptor, tengan dos claves: una pública y una privada. A la clave pública de una persona puede acceder todo el que esté interesado, pero la privada la debe conocer solo el propietario.

Para enviar un mensaje encriptado con esta clave, el remitente debe cifrar su mensaje usando la clave pública del receptor. Una vez hecho esto, la única clave que descodificará el mensaje será la clave privada del receptor, ni siquiera el remitente tendrá ya acceso a ese mensaje. Así se garantiza la confidencialidad; sería algo así como un buzón privado: todo el mundo tiene acceso a su ranura, y puede dejar cartas, pero solo el receptor tiene la llave para abrirlo y recibir esos mensajes.

Estas claves son extremadamente difícil de descifrar, pero no imposibles, según Marthaler: “En una clave pública digital se toman dos números primos, se multiplican, y el número resultante sería un factor de la clave. Para descifrar esa clave, solo debo dividir de nuevo esos números primos, pero es un proceso asimétrico: si añado un bit, el tiempo que una computadora clásica requiere para la descodificación se dobla”.

Y agrega que “si añado otro bit, el tiempo se multiplica de nuevo, y así sucesivamente. Añadiendo solo unos pocos bits puedo colapsar la computadora, independientemente de lo potente que sea. Por ello, este código no es practicable en una computadora estándar. En una computadora cuántico, en cambio, sí sería posible”.

Peter Shor, ingeniero de computación estadounidense, creó el llamado “algoritmo de Shor” en 1994, capaz de dividir los factores de una clave pública rápidamente en una computadora cuántica y, por tanto, descifrar la mayoría de las criptografías existentes en este momento.

¿Cuántica impráctica?


No obstante, el desarrollo no es tan rápido como se podría desear: al parecer, la transformación de bits a bits cuánticos, o “qubits”, es algo que pocos bits soportan, según Marthaler: “Por el momento, lo máximo a lo que hemos llegado es a los 14 bits cuánticos, y aún en este caso esos bits no funcionaban a pleno rendimiento. Para una computadora cuántica universal que pudiéramos usar para la descodificación de criptografías necesitaríamos diez millones de bits”.

En realidad, no se sabe hasta dónde ha avanzado realmente la tecnología de las computadoras cuánticos. El diario “Washington Post” citó recientemente al informante estadounidense Edward Snowden afirmando que la NSA se encuentra actualmente en pleno desarrollo de una supercomputadora cuántica que podría usarse para descodificar códigos diseñados para proteger documentos globales médicos, financieros y gubernamentales.

Marthaler, no obstante, no confía en que ni siquiera la NSA sea capaz de lograr algo así a corto plazo: “Está claro que los científicos de todo el mundo trabajan en el desarrollo de la computación cuántica, pero se trata de investigaciones duraderas, diseñadas para durar otros 20 ó 30 años. Creo que es muy improbable que se pueda construir una computadora cuántica en poco tiempo capaz de usarse para descodificar códigos criptográficos”.

CONCLUSIÓN.

Como habrán visto, este es un tema que deja mucho por investigar, así como una gran inquietud por saber que se vendrá mas adelante y los alcances que tendrá todo lo mencionado. Por lo que los dejo con la invitación a que se sumen al grupo de seguidores inquietos en espera de nuevos avances o incluso a contribuir con nuevas aportaciones al tema de Computadoras Cuánticas.


Saludos.


REFERENCIAS:

http://www.invdes.com.mx/tecnologia-mobil/3910-computadoras-cuanticas-el-nuevo-horizonte-de-la-informatica
  






FECHA: 10 DE FEBRERO DE 2015.




 CLASE: PROGRAMACIÓN PARALELA Y DISTRIBUIDA.




 PROFESOR: DR. GUTIERREZ OCAMPO ELFEGO.




 ALUMNO: JUAN GARCÍA GARCÍA.

  

  TRABAJO/TAREA: LA LEY DE MOORE.




INTRODUCCIÓN.

En este trabajo abarcare algunos de los aspectos mas importantes y relevantes de todo lo relacionado con la Ley de Moore, intentando dar a conocer por medio de este documento un poco acerca del creador, así como sus expectativas y su tendencia. y por ultimo daré lo que a opinión personal, dicha ley significa.

¡Comencemos! 



DESARROLLO.

Gordon Moore, el gran visionario


El responsable del enunciado de esta ley fue Gordon Moore en un artículo para la revista Electronics que se publicó el 19 de abril de 1965. Moore, uno de los “8 traidores” que fundaron Fairchild Semiconductor, enunció este postulado basándose en sus propias observaciones y en la evolución que veía dentro de la cadena de producción de Fairchild. Su extrapolación era muy interesante: cada año se duplicaba el número de transistores que formaban parte de un circuito integrado, por tanto, aumentaba la capacidad de los mismos.


Gordon Moore y Robert Noyce en Intel en 1970 Imagen: Intel

Quizá nos pueda parecer una observación sin mucha importancia, pero cabe destacar que Gordon Moore (que luego se uniría a Robert Noyce para fundar Intel en 1968) la hizo seis años antes del desarrollo del primer microprocesador. De hecho, su intención por aquel entonces era demostrar que el transistor sería un componente fundamental para los dispositivos electrónicos y validar así el modelo de negocio de Fairchild.

Aunque formulada de manera empírica, la ley de Moore se convirtió en un modelo perfectamente validado por la industria. El número de transistores por unidad de superficie se duplicaba e iba llegando una nueva tecnología (con mayor escala de integración) que dejaba obsoleta la anterior. El ritmo, al inicio, fue vertiginoso pero, en 1975, Gordon Moore tuvo que reajustar su propia ley para cambiar el factor del tiempo y ajustarlo a 2 años porque la industria no avanzaba tan rápidamente.

Desde el ajuste de 1975, la ley de Moore ha seguido siendo el patrón de referencia dentro del desarrollo de circuitos integrados pero, evidentemente, el aumento de la escala de integración (reducción del tamaño de transistores) implica muchísimos retos para los fabricantes. Los procesadores Intel Haswell están compuestos por 1.400 millones de transistores de apenas 22 nanometros de tamaño cada uno; la tecnología de 22 nanometros es, prácticamente, la “gran barrera del silicio” y nos acercamos a un terreno en el que este material podría presentar inestabilidades si seguimos aumentando la escala de integración.

Los límites del silicio se acercan


Acercarnos a los límites del silicio puede ser un gran problema. Si bien las proyecciones realizadas por Gordon Moore se vienen cumpliendo, prácticamente, desde su enunciado en 1965, los límites del silicio han comenzado a ralentizar la evolución de la tecnología. Según las estimaciones del ITRS (International Technology Roadmap for Semiconductors), el aumento de la escala de integración y, por tanto, la evolución de los chips se está produciendo, desde 2010, cada 3 años y si bien la capacidad de los chips ha seguido aumentando, en gran medida, ha sido así gracias al uso de tecnologías con múltiples cores (núcleos).



Oblea de silicio. Imagen: UCL Engineering

Aunque hayamos salvado, hasta ahora, los límites físicos del silicio, es un escenario que se acerca irremediablemente. Durante la última LinuxCon, Linus Torvalds habló, precisamente, de la ley de Moore y su posible fin; un gran reto para que el tal vez la industria no esté preparada pero que, de manera inevitable, llegará quizás en los próximos 10 ó 15 años.

En el año 2005, el propio Gordon Moore afirmó en una entrevista que su enunciado tendría validez durante unos 10 ó 15 años más; por tanto, podríamos tocar techo entre 2015 y 2020, al menos, en cuanto al silicio se refiere. Llegaremos a un punto en el que si bajamos más el tamaño de los transistores, estos dejarán de funcionar y dejarán de comportarse como se espera.

Nuevos materiales y procesos de fabricación


El cambio de ciclo se acerca y la industria lleva tiempo preparándose para ello. El fin de la ley de Moore no implica el colapso de nuestra tecnología pero sí traerá consigo cambios en los materiales utilizados para el desarrollo de componentes electrónicos y, evidentemente, a los procesos de fabricación de chips.

Proyectos de investigación como los de Samsung y la Universidad de California-Los Ángeles (UCLA) hace tiempo que trabajan en memorias flash extremadamente pequeñas que se puedan desarrollar a partir de transistores de 10 nanometros. Para llegar al límite de los 10 nanometros y, por tanto, superar la gran barrera actual de los 22, el proyecto ha puesto el foco en un nuevo material: el grafeno.

Quizás aún sea pronto para afirmar que el grafeno sustituirá al silicio, pero es cierto que se ha postulado como un perfecto complemento que permite estabilizar el silicio cuando se superan sus barreras físicas. Además, también se están realizando múltiples investigaciones que giran alrededor del grafeno y el desarrollo de una nueva generación de chips de este material que permitan trabajar a muy alta frecuencia.

Además de la inclusión de nuevos materiales, los procesos de fabricación también cambiarán. Evidentemente, el reto es grande pero son muchas las empresas que ya han puesto en marcha estos cambios y, por ejemplo, Samsung o Matrix Semiconductorllevan tiempo trabajando en sus “chips tridimensionales” que permiten aumentar la escala de integración sin cambiar sustancialmente los procesos actuales de fotolitografía.


Transistor de grafeno de Samsung. Imagen: Samsung.

La consultora McKinsey publicó recientemente un informe, precisamente, analizando el impacto del fin de la ley de Moore en la industria de los circuitos integrados. Desde su perspectiva, McKinsey predice una transición que pasará primero por los cambios en los procesos de fabricación con el objetivo de alargar la vida del silicio. Un cambio que no se estima como rentable para los fabricantes y que podría derivar en el fin de la ley de Moore para el año 2018 y, quizás, el arranque de una nueva era en la electrónica.

Es impresionante cómo un enunciado, formulado hace casi 50 años, ha sido capaz de marcar la tecnología que hoy en día conocemos; una ley basada en la observación que, quizás, esté viviendo sus últimos años.


CONCLUSIÓN.

Luego entonces: La Ley de Moore fue una declaración formulada en 1965 por Gordon Moore, uno de los fundadores de Intel. Él observó que el número de transistores que se podían insertar en un chip de silicio se duplicaba cada año. Con el correr del tiempo, se ha determinado que éstos se duplican cada 18 meses.

Como veo las cosas, la Ley de Moore se ha convertido en un concepto empleado de manera generalizada en el area de computación: A pesar que la declaración de Moore se limitó a una cantidad muy específica --el número de transistores en un chip—ahora, en computación, se aplica para casi todo. "El poder de cómputo se duplica cada 18 meses", éste es uno de los malos usos más comunes de la observación realizada por Moore.

Hoy, se hacen comparaciones entre distintas cantidades que no tienen nada que ver con la Ley de Moore. Por ejemplo, si "el rendimiento de la red se duplica cada nueve meses", o "la densidad de almacenamiento de datos se duplica cada 12 meses", puede que se diga que estas tendencias están "demostrando" la Ley de Moore. Esto podría significar que, de alguna manera, los procesadores de los computadores no están a la par con el almacenamiento de datos y la capacidad de la red.

Esto hace caso omiso de una serie de tendencias que la Ley de Moore no considera. Por ejemplo, el ciclo de reloj de los procesadores aumenta a medida que aumenta el número de transistores por chip. Esto significa que el poder de procesamiento crece más rápido que la Ley de Moore. Además, las mejoras en la arquitectura de los chips y en los sistemas operativos, también hacen que los procesadores sean más poderosos que la mera suma de sus transistores.

En resumen, comparar diferentes tasas de crecimiento utilizando la Ley de Moore es, a menudo, engañoso. Lo mejor es ver la Ley de Moore simplemente como una metáfora del crecimiento exponencial en el rendimiento del hardware de las TI.



Saludos.





REFERENCIAS: 

http://blogthinkbig.com/ley-de-moore-electronica/