Python Brasil [5]




Modelo de Programação com Threads e
  Transações Implícitas em Python


            Rodrigo Hübner
Conteúdo
●   Introdução
●   Motivação
●   Programação paralela implícita
●   Algumas estratégias já utilizadas
●   Princip...
Introdução

Nos modelos atuais, o programador deve solicitar a criação 
de unidades paralelas explicitamente.
Tais modelos...
Motivação



   Facilitar a construção de programas paralelos;
   Explorar programação paralela em alguma linguagem;
  ...
Modificar um compilador/interpretador
             já existente

Qualquer resultado positivo é válido e inquestionável.


...
Programação paralela em Python

Bibliotecas tradicionais:
   threading
   multiprocessing


Com mecanismos para SMP e Cl...
Python - threading



       Método mais utilizado até o momento;
       É um módulo completo, mas possuem problemas de ...
Python – threading. Exemplo de código

from threading import Thread  
def func(arg):  
    print(arg)
   
th = Thread(targ...
Python - multiprocessing



   É similar ao módulo threading;
   Oferece paralelismo local e remoto;
   Evita problemas...
Python – threading. Exemplo de código

from multiprocessing import Process  
def func(arg):  
    print(arg)
   
p = Proce...
Python – threading. Exemplo de código


Além disso...


from multiprocessing import Pool

def f(x):
    return x*x

if __n...
Novo módulo em Python baseado na
              API OpenMP

   API para programação paralela baseada em multi­
    process...
Estratégias para a criação do módulo
              em Python


from multiprocessing import Pool
@Pool(5, 'apply')
def func...
Estratégias para a criação do módulo
              em Python

        multiprocessing + @decorator = @task


@task
def som...
Python – decorators

class decorador(object):
    
    def __init(self, func):
        self.func = func
    
    def __cal...
@task: Funcionamento usando 2 cpu
@task: Exemplo de código

    for m2ti import task

    @task
    def fibonacci(n):
        a, b = 0, 1
        for i in r...
@task: Acrescentando init e final

    @init decora uma tarefa que será executada antes de 
      todos os trabalhadores;...
@task: Acrescentando init e final.
         Exemplo de código


from m2ti import task, init, final   @final
              ...
@task: Funcionamento usando 2 cpu
       com roubo de tarefas
@task(n): Exemplo de código



from m2ti import task_cilk   bar(10)
                             ...
@task(1)             ...
Pré-processamento do código fonte



   Possibilidade de acrescentar novas idéias;
   Permite inserir melhor o código de...
Pré-processamento - exclusive

Transformação simples a partir de locks

                         exclusive:
              ...
Explicit is better than implicit.
Pré-processamento - barrier

Implementação de sincronização através de barreiras
   Eventos e trabalhadores ativos estari...
Pré-processamento - atomic

Implementação de transações implícitas:
   Modo mais seguro de manipular objetos compartilhad...
Pré-processamento - atomic

   Adapatar para funcionar junto ao módulo multiprocessing
   Deixar com uma sintaxe mais py...
Conclusões e Trabalhos Futuros

   Existem muitas limitações;
   Resultados bons para alguns casos;


   Verificar agor...
@final



Perguntas?


             Rodrigo Hübner
             e-mail:
             rhubner@gmail.com
Upcoming SlideShare
Loading in...5
×

M2ti - Python Brasil

1,569

Published on

Apresentação feita no 5º Encontro Brasileiro da comunidade Python

Published in: Technology, Education
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
1,569
On Slideshare
0
From Embeds
0
Number of Embeds
2
Actions
Shares
0
Downloads
22
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

M2ti - Python Brasil

  1. 1. Python Brasil [5] Modelo de Programação com Threads e Transações Implícitas em Python Rodrigo Hübner
  2. 2. Conteúdo ● Introdução ● Motivação ● Programação paralela implícita ● Algumas estratégias já utilizadas ● Principais módulos para programação paralela em Python ● Estratégia proposta para Python ● A expansão (Pré-processamento) ● Conclusões e trabalhos futuros
  3. 3. Introdução Nos modelos atuais, o programador deve solicitar a criação  de unidades paralelas explicitamente. Tais modelos tornam a programação complexa para:  Criar  Gerenciar  Explorar a arquitetura A proposta é criar unidades paralelas de forma implícita.
  4. 4. Motivação  Facilitar a construção de programas paralelos;  Explorar programação paralela em alguma linguagem;  Expandir uma linguagem de programação baseado em  modelos multi­thread já existentes;  Aplicar estratégias existentes e buscar novas idéias
  5. 5. Modificar um compilador/interpretador já existente Qualquer resultado positivo é válido e inquestionável. Contras:  Difícil implementação para linguagens já existentes;  Resultados demoram;  Não existe linguagens que implentam unidades paralelas  de forma implícita para tomar base.
  6. 6. Programação paralela em Python Bibliotecas tradicionais:  threading  multiprocessing Com mecanismos para SMP e Clusters  PP – Parallel Python
  7. 7. Python - threading  Método mais utilizado até o momento;  É um módulo completo, mas possuem problemas de  desempenho...;  Threads utilizam o mesmo espaço de endereçamento;  Soluções: uso de locks...  GIL ­ Global Interpreter Lock
  8. 8. Python – threading. Exemplo de código from threading import Thread   def func(arg):       print(arg)     th = Thread(target=func, args=('executando thread', ) )   th.start() th.join()
  9. 9. Python - multiprocessing  É similar ao módulo threading;  Oferece paralelismo local e remoto;  Evita problemas com o GIL usando subprocessos em vez  de threads;  Shared memory e objetos ctypes compartilhados  Managers  Queues, Pipes...
  10. 10. Python – threading. Exemplo de código from multiprocessing import Process   def func(arg):       print(arg)     p = Process(target=func, args=('executando subprocesso', ) )   p.start() p.join()
  11. 11. Python – threading. Exemplo de código Além disso... from multiprocessing import Pool def f(x):     return x*x if __name__ == '__main__':     pool = Pool(processes=4)     result = pool.apply_async(f, [10])      print(pool.map(f, range(10)))
  12. 12. Novo módulo em Python baseado na API OpenMP  API para programação paralela baseada em multi­ processamento, para linguagens C, C++ e Fortran;  Base inicial para a construção de um módulo em Python: Exemplos: int main(int argc, char **argv) { const int N = 100000; int main(int argc, char* argv[]) int i, a[N]; { #pragma omp parallel #pragma omp parallel for printf("Hello, world.n"); for (i = 0; i < N; i++) return 0; a[i] = 2 * i; } return 0; }
  13. 13. Estratégias para a criação do módulo em Python from multiprocessing import Pool @Pool(5, 'apply') def func()     …  Depende de parâmetros  >>> Criar um módulo que possa enviar parâmetros através  de chamadas da função decorada
  14. 14. Estratégias para a criação do módulo em Python multiprocessing + @decorator = @task @task def soma_primos(n):      … soma_primos(1000) Outros módulos: inspect, atexit, …
  15. 15. Python – decorators class decorador(object):          def __init(self, func):         self.func = func          def __call__(self, *args, **kargs):         self.func(*args, **kargs) @decorador def foo(arg):     print(arg) foo()
  16. 16. @task: Funcionamento usando 2 cpu
  17. 17. @task: Exemplo de código for m2ti import task @task def fibonacci(n):     a, b = 0, 1     for i in range(n)         a, b = b, a+b     return a for i in range(1000):     fibonacci(i)
  18. 18. @task: Acrescentando init e final  @init decora uma tarefa que será executada antes de  todos os trabalhadores;  Permite preparar objetos que serão utilizados  pelas tarefas. Ex: Construção de uma matriz  @final decora uma tarefa que será executada depois  que todos os trabalhadores terminarem suas  execuções;  Imprimir resultados, especificar outro conjunto  de tarefas, etc.
  19. 19. @task: Acrescentando init e final. Exemplo de código from m2ti import task, init, final @final def ultima(): @init     ... def primeira():     … for n in range(100): @task     func(arg) def func(arg):     ...
  20. 20. @task: Funcionamento usando 2 cpu com roubo de tarefas
  21. 21. @task(n): Exemplo de código from m2ti import task_cilk bar(10) ... @task(1) bar(100) def foo(arg): …     ... for n in range(100): @task(2)     foo(n) def bar(arg):     …     foo(10)     ...
  22. 22. Pré-processamento do código fonte  Possibilidade de acrescentar novas idéias;  Permite inserir melhor o código depois de pré­processar;  É possível explorar melhor as funcionalidades da  linguagem e suas bibliotecas...
  23. 23. Pré-processamento - exclusive Transformação simples a partir de locks exclusive: a += 1 import multiprocessing ... lock = multiprocessing.Lock() lock.acquire() a += 1 lock.release()
  24. 24. Explicit is better than implicit.
  25. 25. Pré-processamento - barrier Implementação de sincronização através de barreiras  Eventos e trabalhadores ativos estariam implícitos  Não existe implementação de barreira no módulo  multiprocessing; Exemplo: … @task def func(arg): … barrier ...
  26. 26. Pré-processamento - atomic Implementação de transações implícitas:  Modo mais seguro de manipular objetos compartilhados; Projetos existentes:  Kamaelia ­ http://www.kamaelia.org/STM  Durus ­ http://www.mems­exchange.org/software/durus/;
  27. 27. Pré-processamento - atomic  Adapatar para funcionar junto ao módulo multiprocessing  Deixar com uma sintaxe mais pythonica :) Exemplo: def foo(): … def bar(): … atomic: a = foo() b = bar() c=a+b ...
  28. 28. Conclusões e Trabalhos Futuros  Existem muitas limitações;  Resultados bons para alguns casos;  Verificar agora o que é mais importante;  Módulo ou pré­processamento?  Outras idéias?
  29. 29. @final Perguntas? Rodrigo Hübner e-mail: rhubner@gmail.com
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×