Programação em sistemas de memória distribuída (Message-Passing Computing) Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.1
Programação distribuída requer bibliotecas com rotinas para comunicação por mensagens. São necessários dois mecanismos base: 1. Um método para criar processos para execução em computadores/processadores diferentes 2. Um método para enviar e receber mensagens. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.2
Multiple program, multiple data (MPMD) model Source fi le Source fi le Compile to suit processor Executable Processor 0 Processor p - 1 Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.3
Single Program Multiple Data (SPMD) model Diferentes processos construídos num único programa. Instruções de controlo selecionam diferentes partes do código a serem executadas por cada processo. Todos os executáveis começam ao mesmo tempo (criação estática).. Basic MPI w a y Source fi le Compile to suit processor Ex ecutab les Processor 0 Processor p - 1 Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.4
Multiple Program Multiple Data (MPMD) Model Programas separados para cada processador. Um processador executa o processo master. Os outros processos são criados dinamicamente pelo master. Process 1 spawn(); Star t e x ecution of process 2 Process 2 Time Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.5
Rotinas para comunicação ponto a ponto: Send and Receive Envio de uma mensagem entre processos: Process 1 Process 2 x y send(&x, 2); Mo v ement of data recv(&y, 1); Sintaxe genérica) Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.6
Comunicação por mensagens síncrona Rotinas que só retornam quando a transferência da mensagem está completa. Rotina de envio (send) síncrona Antes de enviar a mensagem, espera até que a mesma possa ser aceite pelo processo receptor. Rotina de receção (receive) síncrona Espera até que a mensagem esperada chegue. Rotinas síncronas executam duas ações: transferem dados e sincronizam processos. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.7
Synchronous send() and recv() using 3-way protocol Process 1 Process 2 Time Suspend process Both processes contin ue send(); (a) When send() Request to send Ac kno wledgment recv(); Message occurs bef ore recv() Process 1 Process 2 Time Both processes contin ue send(); (b) When recv() Request to send Message Ac kno wledgment occurs bef ore send() recv(); Suspend process Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.8
Comunicação por mensagens assíncrona Rotinas não esperam que a comunicação termine antes de retornarem. É necessário um sistema de armazenamento de mensagens. Mais do que uma versão, dependendo da semântica de retorno. Geralmente não sincronizam processos mas permitem aumentar o paralelismo. Devem ser usadas com cuidado. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.9
Blocking versus Non-Blocking em MPI Blocking retornam após as operações locais serem completadas, a transferência da mensagem pode não estar completa. Non-blocking retornam imediatamente. Assume que os dados a transferir não são alterados por outras instruções antes de serem transferidos. Assegurar isso é da responsabilidade do programador. Os termos blocking / non-blocking podem ter diferentes interpretações, dependendo da implementação. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.10
Rotinas que retornam antes da mensagem ser transferida: Necessário um Buffer de mensagens entre a origem e o destino: Process 1 Process 2 Time Contin ue process send(); Message b uff er recv(); Read message b uff er Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.11
Rotinas assíncronas (blocking) que passam a rotinas síncronas Quando as operações locais estão completas e a mensagem está armazenada em segurança, o emissor prossegue o seu trabalho. O buffer tem tamanho finito, pode acontecer que a rotina de envio bloqueie porque o buffer está cheio. Nesse caso, a rotina de send é suspensa até que o buffer esteja disponível, i.e., a rotina comporta-se como se fosse síncrona. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.12
Etiquetas (tags) em mensagens Usadas para diferenciar mensagens de diferentes tipos. A etiqueta é enviada com a mensagem. Se a mensagem pode ser qualquer, poderá ser usado um wild card na mensagem. Assim um receive vai corresponder a qualquer send. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.13
Exemplo de uma Message Tag Envio da mensagem, x, com a tag 5 pelo processo 1 para o processo 2 sendo atribuída a y: Process 1 Process 2 x y send(&x,2, 5 ); Mo v ement of data recv(&y,1, 5 ); Espera mensagem do processo 1 com a tag 5 Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.14
Rotinas de Grupo Existem rotinas que enviam mensagens para um grupo de processos ou que recebem mensagens de um grupo de processos. Mais eficiente do que usar rotinas de comunicação ponto a ponto separadamente. Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.15
Broadcast Envio de mensagens a todos os processos relacionados com o problema a resolver. Multicast enviar a mesma mensagem a um grupo prédefinido de processos. Process 0 Process 1 Process p - 1 data data data Action buf Code bcast(); bcast(); bcast(); MPI f or m Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.16
Scatter Enviar cada elemento de um array no processo root para outro processo. Conteúdo da posição i do array é enviado para o processo i. Process 0 Process 1 Process p - 1 data data data Action buf Code scatter(); scatter(); scatter(); MPI f or m Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.17
Gather Um processo recolhe valores individuais de um conjunto de processos. Process 0 Process 1 Process p - 1 data data data Action buf Code gather(); gather(); gather(); MPI f or m Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.18
Reduce Operação de gather combinada com uma operação aritmética ou lógica. Exemplo: valores são recolhido e adicionados no processo root: Process 0 Process 1 Process p - 1 data data data Action buf + Code reduce(); reduce(); reduce(); MPI f or m Slides for Parallel Programming Techniques & Applications Using Networked Workstations & Parallel Computers 2nd Edition, by B. Wilkinson & M. Allen, 2004 Pearson Education Inc. All rights reserved. 2.19
2.20 Modelos híbridos de programação CPU CPU CPU CPU threading memory threading memory CPU CPU CPU CPU network MPI MPI MPI MPI CPU CPU CPU CPU threading memory threading memory CPU CPU CPU CPU
2.21 Modelos híbridos de programação GPU C U D A GPU O P E N C L CPU CPU CPU CPU threading memory threading memory CPU CPU CPU CPU network MPI MPI
Programação distribuída em python módulo multiprocessing #Criar um processo: import multiprocessing def function(i): print ('called function in process: %s' %i) return if name == ' main ': Process_jobs = [] for i in range(5): p = multiprocessing.process(target=function, args=(i,)) Process_jobs.append(p) p.start() # iniciar execução p.join() # esperar que termine 2.22
2.23 Programação distribuída em python módulo multiprocessing #output called function in process: 0 called function in process: 1 called function in process: 2 called function in process: 3 called function in process: 4
2.24 Programação distribuída em python módulo multiprocessing #Classe Process: class multiprocessing.process(group=none, target=none, name =None, args=(), kwargs={}, *, daemon=none) Permite criar um fluxo de atividade que executará num processo separado. group - só existe por compatibilidade com threading.thread target - callable object invocado pelo método run. name - nome do processo.
2.25 Programação distribuída em python módulo multiprocessing #Classe Process: args - tuplo com os argumentos para a invocação do target. invocation. daemon - True ou False, por omissão, o processo herda o valor do processo pai.
2.26 Programação distribuída em python módulo multiprocessing #Dar nome a um processo import multiprocessing import time def foo(): name = multiprocessing.current_process().name print ("Starting %s \n" %name) time.sleep(3) print ("Exiting %s \n" %name)
2.27 Programação distribuída em python módulo multiprocessing #Dar nome a um processo if name == ' main ': process_with_name = multiprocessing.process\ (name='foo_process', target=foo) process_with_default_name = multiprocessing.process \ (target=foo) process_with_name.start() process_with_default_name.start()
2.28 Programação distribuída em python módulo multiprocessing #Output Starting Process-2 Exiting Process-2 Starting foo_process Exiting foo_process
2.29 Programação distribuída em python módulo multiprocessing #Terminar um processo import multiprocessing import time def foo(): print ('Starting function') time.sleep(0.1) print ('Finished function')
2.30 Programação distribuída em python módulo multiprocessing if name == ' main ': p = multiprocessing.process(target=foo) print ('Process before execution:', p, p.is_alive()) p.start() print ('Process running:', p, p.is_alive()) p.terminate() print ('Process terminated:', p, p.is_alive()) p.join() print ('Process joined:', p, p.is_alive()) print ('Process exit code:', p.exitcode)
2.31 Programação distribuída em python módulo multiprocessing #output Process before execution: <Process(Process-1, initial)> False Process running: <Process(Process-1, started)> True Process terminated: <Process(Process-1, started)> True Process joined: <Process(Process-1, stopped[sigterm])> False Process exit code: -15
Programação distribuída em python módulo multiprocessing if name == ' main ': p = multiprocessing.process(target=foo) print ('Process before execution:', p, p.is_alive()) p.start() print ('Process running:', p, p.is_alive()) time.sleep(5) p.terminate() print ('Process terminated:', p, p.is_alive()) p.join() print ('Process joined:', p, p.is_alive()) print ('Process exit code:', p.exitcode) 2.32
2.33 Programação distribuída em python módulo multiprocessing #output Process before execution: <Process(Process-1, initial)> False Process running: <Process(Process-1, started)> True Starting function Finished function Process terminated: <Process(Process-1, stopped)> False Process joined: <Process(Process-1, stopped)> False Process exit code: 0 O que aconteceu de diferente?
2.34 Programação distribuída em python módulo multiprocessing # Criar um processo como subclasse de Process import multiprocessing class MyProcess(multiprocessing.Process): #sobrepor métod run def run(self): print ('called run method in %s' %self.name) return
2.35 Programação distribuída em python módulo multiprocessing # Criar um processo como subclasse de Process if name == ' main ': jobs = [] for i in range(5): p = MyProcess() jobs.append(p) p.start() p.join()
2.36 Programação distribuída em python módulo multiprocessing # output: called run method in MyProcess-1 called run method in MyProcess-2 called run method in MyProcess-3 called run method in MyProcess-4 called run method in MyProcess-5
2.37 Exemplo: Somar os inteiros de uma lista, sequencialmente, com threads, com processos: import threading import multiprocessing import random import time SIZE = 10000000 def somaparcial ( lista, p, u ): soma = 0 for i in range(p, u): soma += lista[i] print (soma) return soma
2.38 Exemplo: Somar os inteiros de uma lista, sequencialmente, com threads, com processos: if name ==" main ": start= time.time() lista = [random.randint(1,10) for i in range(size)] print ("random values %s" % (time.time() - start) ) print ("starting") start= time.time() somaparcial(lista, 0, SIZE) print ("Sequential time = %s" %(time.time() - start))
2.39 Exemplo: Somar os inteiros de uma lista, sequencialmente, com threads, com processos: start= time.time() t1 = threading.thread (target = somaparcial, args =(lista, 0, \ int(size/2)) ) t2 = threading.thread (target = somaparcial, args =(lista, \ int(size/2), SIZE)) t1.start() t2.start() t1.join() t2.join() print ("Multithreaded time = %s" % (time.time() - start))
2.40 Exemplo: Somar os inteiros de uma lista, sequencialmente, com threads, com processos: print ("Multithreaded time = %s" % (time.time() - start)) start= time.time() t1 = multiprocessing.process (target = somaparcial, args = \ (lista, 0, int(size/2)) ) t2 = multiprocessing.process (target = somaparcial, args = \ (lista, int(size/2), SIZE)) t1.start() t2.start() t1.join() t2.join() print ("Multiprocessing time = %s" % (time.time() - start))
2.41 Exercício: - Testar o programa anterior, analisando os tempos de execução. - Exercício para férias: Como obter o valor parcial calculado por cada thread e cada processo? - Quais os tempos de execução, se na versão multiprocessador, só passarmos para cada Processo a parte da lista que vai ser somada?
2.42 Programação distribuída em python módulo multiprocessing Modifique o código da aula teórica T03 (pp. 31-34) para Estudar os tempos de execução das 3 funções analisadas, lançadas em processos independentes. Teste para 1, 2, 4 e 8 processos.
2.43 Python multiprocessing Comunicação de dados entre processos Queues permite vários produtores e vários recetores. Pipes comunicar entre dois processos
2.44 Python multiprocessing Comunicação de dados entre processos #Queue - exemplo import multiprocessing import random import time class producer(multiprocessing.process): def init (self, queue): multiprocessing.process. init (self) self.queue = queue
2.45 Python multiprocessing Comunicação de dados entre processos def run(self) : for i in range(10): item = random.randint(0, 256) self.queue.put(item) print ("Process Producer : item %d appended to queue %s % (item,self.name)) time.sleep(1) print ("The size of queue is %s % self.queue.qsize())
2.46 Python multiprocessing Comunicação de dados entre processos class consumer(multiprocessing.process): def init (self, queue): multiprocessing.process. init (self) self.queue = queue
2.47 Python multiprocessing Comunicação de dados entre processos def run(self): while True: if (self.queue.empty()): print("the queue is empty") break; else : time.sleep(2) item = self.queue.get() print ('Process Consumer : item %d popped from by %s time.sleep(1) Método task_done() não existe \n % (item, self.name))
2.48 Python multiprocessing Comunicação de dados entre processos if name == ' main ': queue = multiprocessing.queue() process_producer = producer(queue) process_consumer = consumer(queue) process_producer.start() process_consumer.start() process_producer.join() process_consumer.join()
2.49 Python multiprocessing Comunicação de dados entre processos #Pipe exemplo import multiprocessing class producer(multiprocessing.process): def init (self, pipe): multiprocessing.process. init (self) self.pipe = pipe
2.50 Python multiprocessing Comunicação de dados entre processos def run(self) : output_pipe, input_pipe = self.pipe for item in range(10): output_pipe.send(item) output_pipe.send(99) output_pipe.close() #Pipe() devolve um par de connection objects ligados por um pipe bidirecional.
2.51 Python multiprocessing Comunicação de dados entre processos class consumer(multiprocessing.process): def init (self, pipe): multiprocessing.process. init (self) self.pipe = pipe def run(self): close, input_pipe = self.pipe close.close() while (True): item = input_pipe.recv() if (item == 99): break input_pipe.close() print ("1: ", str(item * item))
2.52 Python multiprocessing Comunicação de dados entre processos if name == ' main ': pipe = multiprocessing.pipe() process_producer = producer(pipe) process_consumer = consumer(pipe) process_producer.start() process_consumer.start() process_producer.join() process_consumer.join()
2.53 Python multiprocessing Sincronização de processos Lock, Rlock, Semaphore, Condition, Event Barrier ponto de sincronização entre um conjunto de processos Todos os processos têm de atingir um determinado ponto antes de prosseguirem a execução em paralelo
import multiprocessing Python multiprocessing Sincronização de processos from multiprocessing import Barrier, Lock, Process from time import time from datetime import datetime if name == ' main ': synchronizer = Barrier(2) número de processo na barreira: 2 serializer = Lock() Process(name='p1 - test_with_barrier, target=test_with_barrier,\ args=(synchronizer, serializer)).start() Process(name='p2 - test_with_barrier', target=test_with_barrier,\ args=(synchronizer,serializer)).start() Process(name='p3 - test_without_barrier, target=test_without_barrier).start() Process(name='p4 - test_without_barrier,target=test_without_barrier).start() 2.54
2.55 Python multiprocessing Sincronização de processos def test_with_barrier(synchronizer, serializer): name = multiprocessing.current_process().name synchronizer.wait() # barrier now = time() with serializer: print("process %s ----> %s" %(name,datetime.fromtimestamp(now))) def test_without_barrier(): name = multiprocessing.current_process().name now = time() print("process %s ----> %s" %(name,datetime.fromtimestamp(now)))
2.56 Python multiprocessing Sincronização de processos Output: process p3 - test_without_barrier ----> 2018-04-01 19:27:49.878603 process p2 - test_with_barrier ----> 2018-04-01 19:27:49.878603 process p1 - test_with_barrier ----> 2018-04-01 19:27:49.878603 process p4 - test_without_barrier ----> 2018-04-01 19:27:49.931988
Instrução with import threading import logging logging.basicconfig(level=logging.debug, format='(%(threadname)-10s) %(message)s',) if name == ' main ': lock = threading.lock() t1 = threading.thread(target=threading_with, args=(lock,)) t2 = threading.thread(target=threading_not_with, args=(lock,)) t1.start() t2.start() t1.join() t2.join() 2.57
2.58 #Instrução with def threading_with(statement): with statement: logging.debug('%s acquired via with' %statement) def threading_not_with(statement): statement.acquire() try: logging.debug('%s acquired directly' %statement ) finally: statement.release()
2.59 #Instrução with Output: (Thread-5 ) <_thread.lock object at 0x000000000689ADC8> acquired via with (Thread-6 ) <_thread.lock object at 0x000000000689ADC8> acquired directly Com with o lock é adquirido, só existe dentro do âmbito do with e é libertado quando termina o bloco do with
2.60 Python multiprocessing Process Pool - Permite criar um conjunto de processos Algumas funções: - map () divide um conjunto iterável de dados em pedaços que submete aos processos da pool como tarefas individuais; bloqueia até à obtenção do resultado; - map_async() map não bloqueante; devolve um objeto
2.61 Python multiprocessing Process Pool - exemplo import multiprocessing def function_square(data): result = data*data return result
2.62 Python multiprocessing Process Pool - exemplo if name == ' main ': inputs = list(range(0,100)) pool = multiprocessing.pool(processes=4) pool_outputs = pool.map(function_square, inputs) print ('Pool :', pool_outputs) inputs2 = list(range(100,200)) pool2 = multiprocessing.pool(processes=4) x = pool2.map_async(function_square, inputs2) #some work... x.wait() print ('Pool :', x.get())