2. Programação paralela
● O que é programação paralela?
● Por que se preocupar com programação
paralela?
● Melhor aproveitamento dos recursos de hardware;
● Aumento do desempenho das aplicações (nem
sempre).
3. Processos e threads
● Processos: são programas em execução que
ocupam uma região própria na memória e
podem ser distribuídos para processadores
pelo sistema operacional;
● Threads: são fluxos de execução de um
mesmo processo que compartilham a região de
memória do processo.
4. Processos e threads
● Criar um novo processo a partir de um
processo existente consiste em alocar uma
região nova de memória contendo uma cópia
do processo criador;
● Criar uma thread consiste em alocar uma
pequena região de memória contendo as
informações da thread, o resto é compartilhado
com o processo criador.
6. A libdispatch
● Biblioteca criada pela Apple para facilitar a
utilização de multiprocessamento nas
aplicações;
● Abstrai o processo de criação e manutenção de
threads;
● “Escreva menos código e faça mais”;
7. Blocks
● Extensão da linguagem C criada pela Apple e usada pelo
GCD para encapsular tarefas.
typedef void (^UmBlocoVoid)();
UmBlocoVoid bloco = ^{
printf("Dentro de um Blockn");
int i;
for(i=0;i<100;i++){
printf("Exemplo %dn", i);
}
};
8. Dispatch Queues
● São filas para onde as tarefas serão enviadas
e, uma a uma, retiradas e processadas;
● O GCD disponibiliza 3 tipos de filas;
● Main Queue (Serial);
● Private Queue (Serial);
● Global Queue (Concorrente);
10. Executando tarefas
● Tarefas podem ser enviadas para as filas com
as seguintes funcões:
● dispatch_sync();
● dispatch_async();
● dispatch_apply();
● dispatch_sync_f();
● dispatch_async_f();
● dispatch_apply_f().
12. Paralelizando loops
● Iterações de um loop podem ser paralelizadas
com a função dispatch_apply():
dispatch_apply(ITERACOES, queue, ^(size_t i){
// loop
});
13. Grupos
● Permitem bloquear a execução do programa
para esperar que uma ou mais threads
terminem (join);
dispatch_group_t grupo = dispatch_group_create();
dispatch_queue_t fila = dispatch_get_global_queue(0, 0);
dispatch_group_async(grupo, fila, ^{
// bloco de execução
});
dispatch_group_wait(grupo, DISPATCH_TIME_FOREVER);
14. Semáforos
● Mecanismo de sincronização que possibilita a
exclusão mútua e o controle do uso de recursos
limitados;
dispatch_semaphore_t sema = dispatch_semaphore_create(1);
…
dispatch_async(fila, ^{
…
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
// Região crítica
dispatch_semaphore_signal(sema);
});
15. Dispatch Sources
● Mecanismo criado para detectar e processar
eventos do sistema;
● Um dispatch source pode substituir os recursos
nativos de tratamento assíncrono de eventos (poll,
epoll, kqueue e etc);
● Um dispatch source permite:
● Criar timers;
● Monitorar sinais enviados pelo sistema;
● Monitorar descritores de arquivos;
● Monitorar processos (exit, fork, exec e etc).