1. Python Brasil [5]
Modelo de Programação com Threads e
Transações Implícitas em Python
Rodrigo Hübner
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
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 multithread já existentes;
Aplicar estratégias existentes e buscar novas idéias
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. Programação paralela em Python
Bibliotecas tradicionais:
threading
multiprocessing
Com mecanismos para SMP e Clusters
PP – Parallel Python
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
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. 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. 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. 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. 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. 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, …
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. @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. @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):
...
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. 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...
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. 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?