Introdução à Programação Paralela e Distribuída

Lei de Amdahl

A Lei de Amdahl determina o potencial de aumento de velocidade a partir da porcentagem paralelizável de um programa.

A Lei de Amdahl é a lei que governa o speedup na utilização de processadores paralelos em relação ao uso de apenas um processador.

Numa aplicação, existe sempre uma parte que não pode ser paralelizada (ou seja, uma parte sequencial). Se s for a parte sequencial, (1 - s) será a parte possível de ser paralelizada. Mesmo que a parte paralela seja perfeitamente escalável, o desempenho (speedup) está limitado pela parte sequencial.

Speedup: o ganho de velocidade observado quando se executa um processo em x processadores em relação ao processado em 1 processador. Mostra que, para obter ganhos elevados, é necessário reduzir ou eliminar os blocos sequenciais do algoritmo. Impõe um limite no speedup que pode ser obtido com os processadores.

Camadas de Programação em Grid

As camadas de programação em Grid são: Camada de Rede, Camada de Recursos (ou Membros), Middleware, Aplicações e Serviços.

• Camada de Rede: Faz a comunicação entre os membros e utiliza a parte física das redes dos mesmos.
• Camada de Membros: Supercomputadores, servidores, serviço de armazenamento, sensores, etc.
• Middleware: Software ou conjunto de softwares que compõem o Grid, intermediando tudo. É composto por uma série de camadas relativas à programação, protocolação, segurança e nível de abstração.
• Aplicações e Serviços: Programa ou projeto em que está sendo utilizada a Grid Computing, como em faculdades, CERN, LHC, BOINC, pesquisas médicas, etc.

Diferença entre Processo e Thread

Threads são fluxos de execução que rodam dentro de um processo (aplicação). Normalmente, as threads compartilham regiões de memória, mas não necessariamente. Processos, os "ancestrais" das threads, permitem que o sistema operacional execute mais de uma aplicação ao mesmo tempo, enquanto as threads permitem que sua aplicação execute mais de um método ao mesmo tempo.

Modelos de Programação Paralela

• Memória Compartilhada: Ambiente com vários processadores que compartilham o espaço de endereçamento de uma única memória. Exemplo: OpenMP.
• Memória Distribuída/Passagem de Mensagens: Ambiente com vários processadores, cada um com sua própria memória e interconectados por uma rede de comunicação. O programador é responsável pela comunicação entre os processadores. Exemplo: MPI.
• Programação Paralela de Dados: Modelo de programação que utiliza memória compartilhada, permitindo a todas as tarefas acesso à estrutura de dados na memória global. Exemplo: CUDA.
• Threads/Multithreads: A estrutura responsável pela manutenção de todas as informações necessárias à execução de um programa, como conteúdo de registradores e espaço de memória. Exemplo: pthreads.

Sorteio de Números com Threads

Código que realiza sorteios de números de 1 a 50, com cada número sorteado por uma thread diferente. A thread principal (mestre) informa quais threads sortearam números pares.

#include <stdio.h>
#include <omp.h>
#include <stdlib.h>

int main() {
    int nthreads, tid, num;
    int vetor[50];

    omp_set_num_threads(50);

    #pragma omp parallel private(nthreads, tid, num)
    {
        tid = omp_get_thread_num();
        num = rand() % 51;
        if (num % 2 == 0) {
            vetor[tid] = tid;
        } else {
            vetor[tid] = -1; // Valor para indicar que não é par
        }
    }

    printf("Threads que sortearam pares:\n");
    for (int i = 0; i < 50; i++) {
        if (vetor[i] != -1) {
            printf("Thread %d\n", vetor[i]);
        }
    }

    return 0;
}

Comunicação entre Máquinas em Java RMI

Duas máquinas conectadas, uma como cliente e outra como servidor em Java RMI. O cliente envia uma requisição para o servidor, que processa e retorna uma resposta. A comunicação é feita através de objetos remotos, que são interfaces que definem os métodos que podem ser chamados remotamente.

Paralelização de Trecho de Código

#include <stdio.h>
#include <omp.h>

int main() {
    int var1, var2, var3;

    // ... Código serial ...

    omp_set_num_threads(16);

    #pragma omp parallel private(var1, var2) shared(var3)
    {
        // ... Seção paralela executada por todas as threads ...
    }

    // ... Código serial ...

    return 0;
}

A diretiva #pragma omp parallel private(var1, var2) shared(var3) cria 16 threads que executam o bloco de código em paralelo. private(var1, var2) significa que cada thread terá suas próprias cópias de var1 e var2. shared(var3) indica que todas as threads compartilham a mesma variável var3.