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