A computação paralela é uma técnica que permite a execução simultânea de múltiplas tarefas, aumentando significativamente a eficiência e velocidade de processamento. No ambiente Apple, especialmente em sistemas macOS, a computação paralela pode ser implementada utilizando várias ferramentas e bibliotecas disponíveis. Este artigo irá explorar como configurar e executar computação paralela em um Mac, utilizando frameworks como Grand Central Dispatch (GCD) e OpenMP.

Exemplos:

Exemplo 1: Utilizando Grand Central Dispatch (GCD)

Grand Central Dispatch (GCD) é uma tecnologia desenvolvida pela Apple para otimizar a execução de tarefas em paralelo. Abaixo está um exemplo de como usar GCD em Swift para realizar computação paralela.

import Foundation

let queue = DispatchQueue(label: "com.example.myqueue", attributes: .concurrent)

queue.async {
    for i in 1...5 {
        print("Tarefa 1 - \(i)")
    }
}

queue.async {
    for i in 1...5 {
        print("Tarefa 2 - \(i)")
    }
}

// Esperar um tempo para garantir que todas as tarefas sejam concluídas.
sleep(1)

Exemplo 2: Utilizando OpenMP

OpenMP é uma API para programação paralela que pode ser utilizada em sistemas macOS. Abaixo está um exemplo de como compilar e executar um programa C utilizando OpenMP.

1. Código C com OpenMP:

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

int main() {
    #pragma omp parallel
    {
        int thread_id = omp_get_thread_num();
        printf("Olá do thread %d\n", thread_id);
    }
    return 0;
}

2. Compilação e execução via Terminal:

gcc -fopenmp -o parallel_program parallel_program.c
./parallel_program

Exemplo 3: Utilizando Swift NIO

Swift NIO é uma biblioteca que facilita a construção de aplicativos de rede de alto desempenho e baixa latência em Swift. Abaixo está um exemplo de como usar Swift NIO para criar um servidor TCP simples que lida com conexões em paralelo.

import NIO

let group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
let bootstrap = ServerBootstrap(group: group)
    .serverChannelOption(ChannelOptions.backlog, value: 256)
    .childChannelInitializer { channel in
        channel.pipeline.addHandler(EchoHandler())
    }
    .childChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)

defer {
    try! group.syncShutdownGracefully()
}

let channel = try bootstrap.bind(host: "localhost", port: 8888).wait()
print("Servidor rodando em:", channel.localAddress!)

try channel.closeFuture.wait()

final class EchoHandler: ChannelInboundHandler {
    typealias InboundIn = ByteBuffer
    typealias OutboundOut = ByteBuffer

    func channelRead(context: ChannelHandlerContext, data: NIOAny) {
        var buffer = self.unwrapInboundIn(data)
        if let received = buffer.readString(length: buffer.readableBytes) {
            print("Recebido: \(received)")
            var response = context.channel.allocator.buffer(capacity: received.utf8.count)
            response.writeString(received)
            context.write(self.wrapOutboundOut(response), promise: nil)
        }
    }

    func channelReadComplete(context: ChannelHandlerContext) {
        context.flush()
    }

    func errorCaught(context: ChannelHandlerContext, error: Error) {
        print("Erro: \(error)")
        context.close(promise: nil)
    }
}