O Que São Threads e Processos? Entenda a Base da Programação Paralela em C++ e HPC

Introdução

Vivemos na era da computação de alto desempenho (HPC – High Performance Computing), onde otimizar o tempo de execução de algoritmos é uma necessidade em áreas como engenharia, ciência de dados e inteligência artificial. Um dos pilares dessa otimização é a programação paralela, que permite que diferentes partes de um programa sejam executadas simultaneamente.

Dois conceitos fundamentais para entender como a programação paralela funciona são as threads e os processos. Neste post, vamos descomplicar esses conceitos e mostrar como eles se aplicam na prática, especialmente com C++ e nas arquiteturas OpenMP e OpenMPI.

1. O que é uma Thread?

Uma thread (ou “linha de execução”) é o menor fluxo sequencial de instruções dentro de um programa. Pense nela como um “trilho” por onde as instruções do seu código passam.

Com a chegada dos processadores multi-core, tornou-se possível executar múltiplas threads simultaneamente, cada uma em um núcleo diferente, o que leva a um aumento significativo na performance da aplicação.

Em resumo:

• Uma thread executa parte de um programa de forma sequencial.
• É mais leve que um processo.
• Múltiplas threads podem compartilhar a mesma memória (por exemplo, variáveis globais).

2. O que é um Processo?

Um processo é uma instância de um programa em execução. Ele possui sua própria memória e recursos, sendo mais isolado do que as threads.

Cada processo pode conter uma ou mais threads, trabalhando de forma cooperativa dentro do mesmo espaço de memória.

Além disso, com processadores modernos, também é possível rodar vários processos ao mesmo tempo, cada um executando suas próprias tarefas.

Comparando:

• Processo: ambiente independente de execução, com memória separada.
• Thread: fluxo de execução dentro de um processo, compartilhando recursos.

Como Criar Threads e Processos em C++

Criando uma Thread com C++ moderno (C++11+):

#include <iostream>
#include <thread>

void funcao() {
    std::cout << "Executando thread!\n";
}

int main() {
    std::thread t1(funcao); // Cria uma nova thread
    t1.join(); // Espera a thread terminar
    return 0;
}

#include <iostream>
#include <thread>

void funcao() {
    std::cout << "Executando thread!\n";
}

int main() {
    std::thread t1(funcao); // Cria uma nova thread
    t1.join(); // Espera a thread terminar
    return 0;
}

Criando um Processo com fork() (em sistemas Unix/Linux):

#include <iostream>
#include <unistd.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        std::cout << "Processo filho\n";
    } else if (pid > 0) {
        std::cout << "Processo pai\n";
    } else {
        std::cerr << "Erro ao criar processo\n";
    }
    return 0;
}

#include <iostream>
#include <unistd.h>

int main() {
    pid_t pid = fork();

    if (pid == 0) {
        std::cout << "Processo filho\n";
    } else if (pid > 0) {
        std::cout << "Processo pai\n";
    } else {
        std::cerr << "Erro ao criar processo\n";
    }
    return 0;
}

fork() só está disponível em ambientes POSIX (Linux, Unix, MacOS). Em Windows, o equivalente seria com CreateProcess().

4. OpenMP e OpenMPI: Arquiteturas Paralelas

OpenMP (Open Multi-Processing)

• Focada em paralelismo com threads.
• Ideal para ambientes shared memory (memória compartilhada).
• Uso de diretivas simples em C/C++ e Fortran para paralelizar loops, seções e regiões críticas.

Exemplo com OpenMP:

#include <omp.h>
#include <iostream>

int main() {
    #pragma omp parallel
    {
        std::cout << "Thread ID: " << omp_get_thread_num() << "\n";
    }
    return 0;
}

#include <omp.h>
#include <iostream>

int main() {
    #pragma omp parallel
    {
        std::cout << "Thread ID: " << omp_get_thread_num() << "\n";
    }
    return 0;
}

OpenMPI (Open Message Passing Interface)

• Focada em paralelismo com processos distribuídos.
• Ideal para ambientes distributed memory, como clusters e supercomputadores.
• Comunicação explícita entre processos usando troca de mensagens (MPI_Send, MPI_Recv).

Exemplo com MPI:

#include <mpi.h>
#include <iostream>

int main(int argc, char** argv) {
    MPI_Init(&argc, &argv);

    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    std::cout << "Olá do processo: " << rank << "\n";

    MPI_Finalize();
    return 0;
}

#include <mpi.h>
#include <iostream>

int main(int argc, char** argv) {
    MPI_Init(&argc, &argv);

    int rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    std::cout << "Olá do processo: " << rank << "\n";

    MPI_Finalize();
    return 0;
}

Conclusão

A programação paralela é fundamental para aplicações que exigem alto desempenho, como simulações numéricas, inteligência artificial, renderização gráfica e análise de big data. Dominar os conceitos de threads e processos, bem como o uso de ferramentas como OpenMP e MPI, é essencial para quem quer se destacar em áreas técnicas e científicas.