implementação paralela escalável e eficiente do algoritmo simplex

UNIVERSIDADE DO RIO GRANDE DO NORTEFEDERAL

Universidade Federal do Rio Grande do NorteCentro de Tecnologia

Programa de Pós-Graduação em Engenharia Elétrica ede Computação

Implementação Paralela Escalável eEficiente do Algoritmo Simplex Padrão em

Arquitetura Multicore

Demétrios A. M. Coutinho

Orientador: Prof. Dr. Samuel Xavier de Souza

Coorientador: Prof. Dr. Jorge Dantas de Melo

Dissertação de Mestrado apresentada aoPrograma de Pós-Graduação em Engenha-ria Elétrica da UFRN (área de concentração:Engenharia de Computação) como parte dosrequisitos para obtenção do título de Mestreem Ciências.

Número de ordem PPgEE: M417

Natal, RN, Janeiro de 2014

UFRN / Biblioteca Central Zila Mamede.

Catalogação da Publicação na Fonte

Coutinho, Demétrios A. M.

Implementação paralela escalável e eficiente do algoritmo simplex

padrão em arquitetura multicore / Demétrios A. M. Coutinho. – Natal,

RN, 2014.

98 f. : il..

Orientador: Prof. Dr. Samuel Xavier de Souza.

Coorientador: Prof. Dr. Jorge Dantas de Melo.

Dissertação (Mestrado) – Universidade Federal do Rio Grande do

Norte. Centro de Tecnologia. Programa de Pós-Graduação em Engenharia

Elétrica e de Computação.

1. Simplex – Dissertação. 2. CPLEX – Dissertação. 3. Eficiência

paralela – Dissertação. 4. Escalabilidade paralela – Dissertação.

5. Programação linear – Dissertação. I. Souza, Samuel Xavier de.

II. Melo, Jorge Dantas de. III. Universidade Federal do Rio Grande do

Norte. III. Título.

RN/UF/BCZM CDU 519.852

A Deus e aos meus pais.

Agradecimentos

Agradeço a Deus, pelo seu Amor incondicional na minha história, por ter meconcedido a oportunidade de conhecer pessoas que me ajudaram de forma direta ouindireta a concluir mais uma etapa na minha vida.

Aos meus pais Wilder César Coutinho e Josiane Magalhães, por sempre me apoiarem,por sempre estarem do meu lado, por sempre acreditarem em mim, e principalmenteagradeço por todo esforço realizado para que tivesse a base moral e emocional adequadapara vencer os desafios da vida.

Agradeço, especialmente, a Ayla Márcia, por todo seu carinho e zelo por mim,por ser tão paciente e compreensiva comigo, pelas correções ortográficas desse texto e orespaldo necessário para a conclusão desta jornada.

Ao meu orientador Samuel Souza, excelente profissional, pelo seu voto de confiança,por ter gasto várias horas auxiliando-me nesse trabalho, sem sua ajuda este trabalho nãoteria sido possível.

Ao meu coorientador Jorge Melo, por ter me acompanhado nessa jornada e pelosensinamentos que me foram concedidos.

Ao Prof. Daniel Aloise por ter me ajudado com a versão acadêmica do CPLEX R© epor suas orientações na área de otimização.

Ao Prof. Luiz Affonso, por ter me concedido um espaço no laboratório do LII.

À Viviane Medeiros, por sempre ter me ajudado na parte burocrática, nuncanegando um pedido de socorro.

Ao meu colega de trabalho e de dissertação, Diego Cirilo, por ter esclarecido váriospontos da norma da ABNT, por ter me socorrido em vários problemas do Latex, por todasas madrugadas que passamos escrevendo os nossos textos.

À Direção do IFRN câmpus Pau dos Ferros, nas pessoas de Antônia Francimar daSilva e Amélia Cristina Reis e Silva, por todo apoio e auxílio concedido para concluir essetrabalho.

À CAPES e CNPq pelo apoio financeiro.

“Feliz aquele que se compraz no serviço do Senhor e medita sua lei dia e noite.Ele é como a árvore plantada na margem das águas correntes:dá fruto na época própria, sua folhagem não murchará jamais.

Tudo o que empreende, prospera.(Bíblia Sagrada, Salmos 1, 2-3)

ResumoEste trabalho apresenta uma implementação paralela escalável e eficiente do algoritmoSimplex padrão em arquitetura de processadores multicore para resolver problemas deprogramação linear de grande escala. Apresenta-se um esquema geral explicando como foiparalelizado cada passo do algoritmo simplex padrão, apontando pontos importantes daimplementação paralela. Foram realizadas análises de desempenho através da comparaçãodos tempos sequenciais utilizando o Simplex tableau e Simplex do CPLEX R© da IBM.Os experimentos foram realizados em uma máquina de memória compartilhada com 24núcleos. A análise de escalabilidade foi feita com problemas de diferentes dimensões,encontrando evidências de que a implementação paralela proposta do algoritmo simplexpadrão tem melhor eficiência paralela para problemas com mais variáveis do que restrições.Na comparação com CPLEX R©, o algoritmo proposto paralelo obteve uma eficiência de até16 vezes maior.

Palavras-chaves: Simplex, CPLEX R©, Eficiência Paralela, Escalabilidade Paralela, Pro-gramação Linear.

AbstractThis work presents a scalable and efficient parallel implementation of the StandardSimplex algorithm in the multicore architecture to solve large scale linear programmingproblems. We present a general scheme explaining how each step of the standard Simplexalgorithm was parallelized, indicating some important points of the parallel implementation.Performance analysis were conducted by comparing the sequential time using the Simplextableau and the Simplex of the CPLEX R© IBM. The experiments were executed on a sharedmemory machine with 24 cores. The scalability analysis was performed with problems ofdifferent dimensions, finding evidence that our parallel standard Simplex algorithm has abetter parallel efficiency for problems with more variables than constraints. In comparisonwith CPLEX R©, the proposed parallel algorithm achieved a efficiency of up to 16 timesbetter.

Key-words: Simplex, CPLEX R©, Parallel Efficiency , Parallel Scalability, Linear Program-ming.

Lista de ilustrações

Figura 1 – A arquitetura de Von Neumann. . . . . . . . . . . . . . . . . . . . . . . 40Figura 2 – Exemplo de acesso de dados e instruções por meio de memória cache

que ocorre um cache-miss na cache L1 e um cache-hit na cache L2. . . 42Figura 3 – Acesso de dados e instruções por meio de memória cache que o dado ou

instrução não se encontra na cache L1 ou L2. . . . . . . . . . . . . . . 43Figura 4 – Arquitetura paralela SIMD. . . . . . . . . . . . . . . . . . . . . . . . . 44Figura 5 – Arquitetura paralela MIMD. . . . . . . . . . . . . . . . . . . . . . . . . 45Figura 6 – Arquitetura SMP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46Figura 7 – Arquitetura NUMA. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47Figura 8 – Arquitetura de memória distribuída. . . . . . . . . . . . . . . . . . . . 48Figura 9 – Topologia em hipercubo. . . . . . . . . . . . . . . . . . . . . . . . . . . 48Figura 10 – Topologia em malha. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49Figura 11 – Taxonomia de Flynn e suas ramificações. . . . . . . . . . . . . . . . . . 50Figura 12 – Exemplo de uma arquitetura multicore. . . . . . . . . . . . . . . . . . . 51Figura 13 – Lei de moore. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54Figura 14 – Ilustração demonstrando a diferença entre processos e threads. . . . . . 57Figura 15 – Speedup do programa paralelo de diferentes tamanhos do problema da

multiplicação de matriz por um vetor. . . . . . . . . . . . . . . . . . . 62Figura 16 – Eficiência do programa paralelo de diferentes tamanhos do problema

da multiplicação de matriz por um vetor. . . . . . . . . . . . . . . . . . 62Figura 17 – Exemplo da lei de Amdahl. . . . . . . . . . . . . . . . . . . . . . . . . 64Figura 18 – Eficiência do programa paralelo de diferentes tamanhos do problema

da multiplicação de matriz por um vetor. . . . . . . . . . . . . . . . . . 66Figura 19 – Fluxograma do algoritmo Simplex Multicore. . . . . . . . . . . . . . . 73Figura 20 – Diagrama do funcionamento do OpenMp. . . . . . . . . . . . . . . . . 76Figura 21 – Primeira parte do código paralelo. . . . . . . . . . . . . . . . . . . . . . 76Figura 22 – Segunda parte do código paralelo. . . . . . . . . . . . . . . . . . . . . . 77Figura 23 – Tempo sequencial do algoritmo Simplex e o Simplex do CPLEX R©,

fixando-se o número de variáveis. . . . . . . . . . . . . . . . . . . . . . 82Figura 24 – Tempo sequencial do algoritmo Simplex padrão e o Simplex do CPLEX R©,

fixando-se o número de restrições. . . . . . . . . . . . . . . . . . . . . . 82Figura 25 – Tempo sequencial do algoritmo Simplex do CPLEX R©. . . . . . . . . . 83Figura 26 – Speedup para 2 threads. . . . . . . . . . . . . . . . . . . . . . . . . . . 84Figura 27 – Speedup para 4 threads. . . . . . . . . . . . . . . . . . . . . . . . . . . 84Figura 28 – Speedup para 8 threads. . . . . . . . . . . . . . . . . . . . . . . . . . . 84Figura 29 – Speedup para 16 threads. . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Figura 30 – Speedup para 24 threads. . . . . . . . . . . . . . . . . . . . . . . . . . . 85Figura 31 – Eficiência para 2 threads, em relação ao Simplex padrão. . . . . . . . . 86Figura 32 – Eficiência para 4 threads, em relação ao do Simplex padrão. . . . . . . 86Figura 33 – Eficiência para 8 threads, em relação ao Simplex padrão. . . . . . . . . 87Figura 34 – Eficiência para 16 threads, em relação ao Simplex padrão. . . . . . . . . 87Figura 35 – Eficiência para 24 threads,em relação ao Simplex padrão. . . . . . . . . 87Figura 36 – Gráfico de eficiência para 24 threads, mostrando o limite dos problemas

designados pela equação 5.1. . . . . . . . . . . . . . . . . . . . . . . . . 89Figura 37 – eficiência para 2 threads, em relação ao Simplex do CPLEX R©. . . . . . 89Figura 38 – eficiência para 4 threads, em relação ao Simplex do CPLEX R©. . . . . . 90Figura 39 – eficiência para 8 threads, em relação ao Simplex do CPLEX R©. . . . . . 90Figura 40 – eficiência para 16 threads, em relação ao Simplex do CPLEX R©. . . . . . 90Figura 41 – eficiência para 24 threads, em relação ao Simplex do CPLEX R©. . . . . . 91Figura 42 – eficiência para 24 threads, em relação ao Simplex do CPLEX R©. . . . . . 91Figura 43 – eficiência para 24 threads, em relação ao Simplex do CPLEX R©. . . . . . 92

Lista de tabelas

Tabela 1 – Quadro Inicial do Simplex Tableau . . . . . . . . . . . . . . . . . . . . 35Tabela 2 – Quadro Inicial mais detalhado do Simplex Tableau. . . . . . . . . . . . 37Tabela 3 – Tempos de execução serial e paralelo da multiplicação de matriz por

um vetor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61Tabela 4 – Tabela Inicial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Lista de abreviaturas e siglas

API Application Programming Interface

CPU Unidade Central de Processamento

CM-2 Connection Machine-2

COIN-OR Computational Infrastructure for Operations Research

f.o. Função Objetivo

FSB Front Side Bus

MP MasPar

MIMD Multiple Instruction, Multiple Data streams

MISD Multiple Instruction, Single Data streams

MIT Massachusetts Institute of Technology

MPI Message Passing Interface

NUMA Non-uniform memory access

OpenMP Open Multi-Processing

OpenMP ARB OpenMP Architecture Review Board

PL Programação Linear

SBV Solução Básica Viável

SIMD Single Instruction, Multiple Data streams

SISD Single Instruction, Single Data streams

SMP Symmetric MultiProcessors

VB Variáveis Básicas

VLSI Very Large Scale Integration

VNB Variáveis Não Básicas

Lista de símbolos

A Matriz com os coeficientes das restrições.

B Submatriz quadrada de A formada pelas colunas correspondentes àsvariáveis básicas.

b Vetor de constantes do lado direito.

ct Vetor transposto de dos coeficientes da função objetivo.

cB Subvetor de c formado pelos coeficientes das variáveis básicas da funçãoobjetivo.

cN Subvetor de c formado pelos coeficientes das variáveis não básicas dafunção objetivo.

E Eficiência Paralela.

I Matriz identidade.

N Submatriz de A formada pelas colunas correspondentes às variáveis nãobásicas.

S Speedup.

TP Tempo Paralelo.

TS Tempo Sequencial.

x Vetor das variáveis de decisão.

xB Subvetor de x formado pelos coeficientes das variáveis básicas.

xN Subvetor de x formado pelas coeficientes das variáveis básicas.

Sumário

1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231.1 Motivação e Justificativa . . . . . . . . . . . . . . . . . . . . . . . . . 241.2 Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251.3 Organização do texto . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2 FUNDAMENTAÇÃO TEÓRICA . . . . . . . . . . . . . . . . . . . . 272.1 Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.1.1 Forma Padrão e Canônica . . . . . . . . . . . . . . . . . . . . . . . . . . 282.1.2 O método Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302.1.2.1 Equações Básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.1.2.2 Teste de otimalidade - Entrada na Base . . . . . . . . . . . . . . . . . . . . . . 32

2.1.2.3 Teste da Razão - Saída da Base . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.1.2.4 Atualização - Obter uma nova SBV . . . . . . . . . . . . . . . . . . . . . . . . 34

2.1.2.5 O Algoritmo Simplex . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

2.1.3 O Simplex Tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352.1.3.1 Teste de Otimalidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

2.1.3.2 Teste da Razão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2.1.3.3 Obtenção de uma nova SBV . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.1.3.4 Algoritmo do Simplex Tableau . . . . . . . . . . . . . . . . . . . . . . . . . . 38

2.1.4 Simplex Revisado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392.2 Arquiteturas Paralelas . . . . . . . . . . . . . . . . . . . . . . . . . . . 402.2.1 Arquitetura de Von Neumann . . . . . . . . . . . . . . . . . . . . . . . . 402.2.1.1 Memória Cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

2.2.2 Classificação de Computadores Paralelos . . . . . . . . . . . . . . . . . . . 432.2.3 Arquiteturas de memória em Computadores Paralelos . . . . . . . . . . . . 452.2.3.1 Memória Compartilhada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

2.2.3.2 Memória Distribuída . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

2.2.4 Máquinas Paralelas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.2.4.1 CM-2 (Connection Machine-2) . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.2.4.2 MP (MasPar) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.2.4.3 Cray T3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.2.4.4 Multicore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

2.2.4.5 Multi-Computadores/Processadores . . . . . . . . . . . . . . . . . . . . . . . . 52

2.2.5 Software Paralelo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.2.5.1 MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

2.2.5.2 OpenMP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

2.3 Paralelismo e Escalabilidade . . . . . . . . . . . . . . . . . . . . . . . 542.3.1 Conceitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562.3.1.1 Threads e Processos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2.3.1.2 Barreira . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

2.3.1.3 Região Crítica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

2.3.1.4 OverHead . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

2.3.2 Métricas de Escalabilidade paralela . . . . . . . . . . . . . . . . . . . . . . 592.3.2.1 Speedup e Eficiência . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

2.3.3 Lei de Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632.3.4 Escalabilidade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.3.4.1 Escalabilidade de Amdahl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

2.3.4.2 Escalabilidade de Gustafson . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3 REVISÃO BIBLIOGRÁFICA . . . . . . . . . . . . . . . . . . . . . . 673.1 Memória Distribuída . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673.2 Memória Compartilhada . . . . . . . . . . . . . . . . . . . . . . . . . . 693.3 Softwares de Otimização . . . . . . . . . . . . . . . . . . . . . . . . . 703.3.1 IBM ILOG CPLEX Optimization . . . . . . . . . . . . . . . . . . . . . . . 713.3.2 COIN-OR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

4 ALGORITMO SIMPLEX MULTICORE . . . . . . . . . . . . . . . . 734.1 Esquema Geral da Paralelização . . . . . . . . . . . . . . . . . . . . . 734.2 Implementação do Algoritmo Simplex Multicore . . . . . . . . . . . . 75

5 EXPERIMENTOS E RESULTADOS . . . . . . . . . . . . . . . . . . 815.1 Análise de Speedup . . . . . . . . . . . . . . . . . . . . . . . . . . . . 815.2 Análise da escalabilidade . . . . . . . . . . . . . . . . . . . . . . . . . 86

Conclusão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Referências . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

23

1 Introdução

Esse trabalho propõe uma implementação paralela escalável e eficiente do algoritmosimplex padrão na arquitetura multicore(múltiplos núcleos) para problemas de programaçãolinear de grande escala. O algoritmo proposto foi submetido a uma análise de eficiênciaparalela para problemas com diferentes dimensões. O objetivo é verificar a escalabilidadedo algoritmo, investigando em que situação é mais apropriado resolver problemas com amelhor quantidade de variáveis e restrições.

O Simplex é um dos métodos mais utilizados para resolver os problemas de pro-gramação linear (HALL, 2010; GOLDBARG; LUNA, 2000). Programação linear (PL) éuma forma matemática de alcançar o melhor resultado para problemas de otimizaçãoque tenham seus modelos representados por expressões lineares. Esses problemas sãosujeitos a restrições que são modeladas por equações ou inequações lineares. O métodoSimplex é um procedimento iterativo desenvolvido por George B. Dantzig (1947) (PASSOS,2009). Foi uma contribuição primordial na área da Pesquisa Operacional, que acabavade se desenvolver. O Simplex tem sido citado como um dos 10 algoritmos com a maiorinfluência sobre o desenvolvimento e prática da ciência e da engenharia no século 20(DONGARRA; SULLIVAN, 2000). O rápido crescimento do poder computacional, aliado aseu custo decrescente, proporcionou um grande número de implementações computacionaisdo método, resultando em uma economia de bilhões de dólares para a indústria. O númerode operações aritméticas necessárias para encontrar uma solução ótima de um problemalinear de larga escala pelo método Simplex é muito grande e não teria êxito sem utilizarferramentas computacionais de alta velocidade (CANTANE, 2009).

A evolução das ferramentas computacionais sofreu recentemente talvez a maiormudança nos últimos 40 anos. A obtenção de maior desempenho passa, desde a décadapassada, a não depender somente de um maior poder de processamento do hardware. Oconstante aumento de velocidade que os chips single core1 foram submetidos, os fez atingirseu limite de desempenho. Esse limite foi causado pelo aumento de aquecimento dos chips.Assim, a solução encontrada pela indústria, foi a produção de chips multiprocessados, ouseja, processadores com vários núcleos. Com o aumento de núcleos, pôde-se diminuir o ritmode crescimento da velocidade interna do clock, amenizando o problema de aquecimento.A partir de então, tem-se esforçado para dobrar a quantidade de núcleos a cada geração,chamando esse novo tempo de Era Multicore(BORKAR, 2007). Processadores multicorespermitem que frações do problema sejam executadas simultaneamente pelos diferentesnúcleos. Dessa forma, torna-se fundamental a exploração do paralelismo de forma eficiente.

1 um único núcleo.

24 Capítulo 1. Introdução

Nesse contexto, esse trabalho visa apresentar uma implementação paralela doalgoritmo Simplex padrão para processadores multicore, afim de solucionar problemas deprogramação linear de grande escala. Além de mostrar os efeitos causados na escalabilidadeparalela ao modificar a quantidade de restrições e variáveis. Assim como, verificar em quemomento pode ser mais eficiente resolver problemas com mais variáveis que restrições.Também é realizada uma comparação de desempenho do Simplex padrão com o Simplexdo CPLEX R©.

1.1 Motivação e Justificativa

O tempo de processamento para grandes problemas de PL é uma grande preo-cupação para a solução de qualquer sistema matemático de grande escala (PLOSKAS;SAMARAS; SIFALERAS, 2009). A exigência para cálculos mais rápidos e mais eficientesem aplicações científicas tem aumentado significativamente nos últimos anos. Por isso,necessita-se tanto de software, como hardware com desempenhos melhores. A obtenção dealta performance não depende somente de utilizar dispositivos de hardware mais rápidos,mas também em melhorias na arquitetura dos computadores e técnicas de processamento.Por isso, como resultado da demanda por maior desempenho, menor custo, e alta produti-vidade, nos últimos anos se assistiu a uma cada vez mais crescente aceitação e adoção deprocessamento paralelo, tanto para a computação de alto desempenho científico, quantopara aplicações de uso geral (TASOULIS et al., 2004; THOMADAKIS; LIU, 2006).

Hoje, o foco dos fabricantes é produzir mais processadores multiprocessados, comouma das principais soluções para amenizar o problema da muralha de energia. A muralhade energia trata-se da proporcionalidade entre o crescimento do consumo de energia dosdispositivos eletrônicos e a sua frequência de operação. Ou seja, o consumo de energiaaumenta quadraticamente com a frequência de operação (KOCH, 2005). Para agravaro problema, o número de transistores por chip cresceu drasticamente, conforme Mooreobservou (MOORE, 1965), o que aumenta densidade de componentes eletrônicos além deconsumir mais energia, produz mais calor, precisando de mais energia para ser resfriado.

Assim, propõe-se nesse trabalho paralelizar o algoritmo Simplex Padrão aplicado avários tamanhos de problemas de PL, modificando a quantidade de restrições e variáveis. E,verificar em que momento pode ser mais viável resolver problemas com mais variáveis querestrições, ou vice-versa. Além disso, se propõe também realizar a análise de escalabilidadedo algoritmo Simplex Padrão. Isso decorre diante da necessidade de obtenção de melhoresdesempenhos nas aplicações científicas na área de programação linear, aplicados a problemasde grande escala, juntamente com o avanço de softwares e hardwares paralelos, bem comoda necessidade de reduzir o aquecimento dos chips pelo aumento do número de núcleos deprocessamento.

1.2. Objetivos 25

1.2 ObjetivosO objetivo principal deste trabalho consiste em analisar a Escalabilidade e a

Eficiência Paralela do Algoritmo Simplex Padrão na Arquitetura Multicore, verificando, emque momento pode ser mais viável resolver problemas com mais variáveis que restrições, ouvice-versa. Essa metodologia será desenvolvida através da implementação da versão seriale paralela do algoritmo Simplex padrão na forma tabular. Em seguida, será comparado odesempenho desses algoritmos com o CPLEX R© e finalmente será verificada a escalabilidadedos problemas PL aplicados ao simplex paralelo, tendo como base o CPLEX R© e o SimplexPadrão.

1.3 Organização do textoO presente trabalho está dividido em seis capítulos, organizados da seguinte forma:

capítulo 1 - introdução; capítulo 2 - fundamentação teórica, onde se explica o funcionamentodo algoritmo do Simplex (seção 2.1), e também é descrita uma breve explanação sobreas arquiteturas paralelas (seção 2.2), assim como aborda conceitos sobre as métricas deanálise da escalabilidade paralela (seção 2.3). Capítulo 3 - revisão bibliográfica, onde alémde mostrar alguns trabalhos correlatos, também discorre sobre a ferramenta otimizaçãoCPLEX R©. No capítulo 4, descreve-se em detalhes a implementação do algoritmo paralelodo Simplex padrão. O capítulo 5 são apresentados os resultados experimentais obtidos,a análise de escalabilidade e de speedup do algoritmo Simplex paralelo com os dados deproblemas de programação linear de grande escala. E finalmente, o último capítulo abordaas considerações finais.

27

2 Fundamentação Teórica

Este capítulo apresenta o algoritmo do simplex padrão e tabular, as arquiteturasparalelas utilizadas em trabalhos correlatos, o conceito de escalabilidade e as métricasutilizadas para medir escalabilidade paralela.

2.1 Simplex

A Programação linear (PL) baseia-se em encontrar a melhor solução para problemasque sejam modelados por expressões lineares. Os problemas de PL são problemas deotimização os quais a partir de uma função linear, denominada Função Objetivo (f.o.),procura-se encontrar o máximo ou o mínimo desta, respeitando um sistema linear derestrições.

Esse tipo de modelagem é importante para os profissionais tomarem decisões,procurando estabelecer maneiras mais eficientes de utilizar os recursos disponíveis paraatingir determinados objetivos. Uma vantagem desse modelo está na eficiência dos algorit-mos de solução atualmente existentes, os quais disponibilizam alta capacidade de cálculo,podendo ser facilmente implementados, até mesmo através de planilhas e com o auxílio demicrocomputadores pessoais.

O método Simplex é um procedimento iterativo que fornece a solução de qualquermodelo de PL em um número finito de iterações. O rápido crescimento do poder compu-tacional aliado a seu custo decrescente produziu um grande número de implementaçõescomputacionais e resultou em uma economia de bilhões de dólares para a indústria.

O Simplex pode ser representando em uma forma tabular, em que todos os dadossão colocados em uma tabela, chamada de Tableau. Para ter uma melhor compreensãodo algoritmo Simplex na forma tabular, será mostrado primeiramente alguns aspectosmatemáticos essenciais do método Simplex padrão, e logo após, será exposto como essesaspectos estão organizados na tabela. Ressaltando, que o método do Simplex padrão naforma tabular foi utilizado para a paralelização nesse trabalho.

A seguir, são apresentadas as duas formas que devem ser utilizadas para modelaros problemas de PL, logo em seguida, os conceitos matemáticos do método Simplex, comoé feito a organização do Simplex na forma tableau e, por último, uma breve explicaçãosobre o método Simplex Revisado.

28 Capítulo 2. Fundamentação Teórica

2.1.1 Forma Padrão e Canônica

O problema de PL pode ser modelado de duas maneiras: na forma padrão oucanônica. A forma padrão é aquela em que as restrições estão expressas por meio deequações lineares:

Otimizar z = c1x1 + c2x2 + · · ·+ cnxn

sujeito a a11x1 + a12x2 + · · ·+ a1nxn = b1, b1 ≥ 0a21x1 + a22x2 + · · ·+ a2nxn = b2, b2 ≥ 0... ... ... ...

am1x1 + am2x2 + · · ·+ amnxn = bm, bm ≥ 0x1 ≥ 0, x2 ≥ 0, . . . , xn ≥ 0

(2.1)

Em termos de matrizes, pode-se representar a forma padrão da programação linearcomo:

Forma PadrãoOtimizar Z = ctx

sujeito a Ax = b, b ≥ 0x ≥ 0

(2.2)

onde:

A ∈ Rm×n, m < n, uma matriz com os coeficientes das restrições.

x ∈ Rn, um vetor das variáveis de decisão.

b ∈ Rm, vetor de constantes do lado direito.

ct é o vetor transposto de c, o qual contém os coeficientes da função objetivo, onde c ∈ Rn

O termo otimizar está sendo usado para representar a possibilidade de maximizarou minimizar uma função objetivo. A forma padrão é particularmente importante porquepermite resolver sistemas lineares, ao invés de inequações, e, além de ser, a forma utilizadapelo método Simplex. Contudo, é normal encontrar problemas que sejam mais facilmentemodelados na forma canônica:

Forma CanônicaOtimizar Z = ctx

sujeito a Ax

≤≥ b

x ≥ 0

(2.3)

2.1. Simplex 29

Um mesmo modelo de PL, pode ser reescrito em qualquer uma das formas básicasapresentadas. Esse processo de tradução é realizado através das seguintes operaçõeselementares:

Mudança no Critério de Otimização: A transformação do problema de maximizaçãopara minimização, ou vice-versa, consiste na seguinte relação:

Maximizar (f(x)) = Minimizar (−f(x)) eMinimizar (f(x)) = Maximizar (−f(x)).

Ocorrência de Desigualdades nas Restrições: A transformação de desigualdade emigualdade consiste em analisar 2 casos:

• Caso em que a restrição é uma inequação de menor ou igual, deve-se adicionaruma variável de folga xn+1 não negativa. Exemplo:

x1 + x2 + · · ·+ xn ≤ b

x1 + x2 + · · ·+ xn + xn+1 = b, xn+1 ≥ 0

• Caso em que a restrição é uma inequação de maior ou igual, deve-se subtrairuma variável de folga xn+1 não negativa. Exemplo:

x1 + x2 + · · ·+ xn ≥ b

x1 + x2 + · · ·+ xn − xn+1 = b, xn+1 ≥ 0

Ocorrência de Igualdade nas restrições: Uma restrição com igualdade é equivalentea duas desigualdades simultâneas:

x1 + x2 + · · ·+ xn = b

x1 + x2 + · · ·+ xn ≤ b

x1 + x2 + · · ·+ xn ≥ b

Ocorrência de variáveis livres: Transformar uma variável livre (xj ∈ R), em variávelnão-negativa. Nesse caso, a mudança exigirá a substituição da variável em trans-formação por duas variáveis auxiliares, ambas maiores ou iguais a zero, mas cuja asoma é igual à variável original, ou seja:

xn = x1n − x2

n e x1n ≥ 0, x2

n ≥ 0.

Constante do Lado Direito Negativa: Neste caso multiplica-se toda a equação por(-1) trocando os sinais de todos os coeficientes. No caso de desigualdade, a multipli-cação por (-1) inverte o seu sentido. Por exemplo:


x1 − x2 + x3 ≤ −b−1−→ −x1 + x2 − x3 ≥ b

2.1.2 O método Simplex

O Simplex é um algoritmo que se baseia em ferramentas da álgebra linear paradeterminar, por meio de um método iterativo, a solução ótima de um Problema deProgramação Linear. Em termos gerais, o algoritmo parte de uma solução inicial válida dosistema de equações que constituem as restrições do problema de PL. A partir da soluçãoinicial são identificadas novas soluções viáveis de valor igual ou melhor que a corrente.

Existem duas etapas na aplicação do método Simplex, após obter o modelo de PLna forma padrão:

Etapa A: Teste de otimalidade da solução ou identificação de uma solução ótima;

Etapa B: Melhoria da solução ou obtenção de solução básica viável (SBV) melhor que aatual.

Em seguida Será descrito o método Simplex para um problema de minimização, oqual, é análogo ao de maximização, com uma diferença apenas no critério de otimalidade.É importante ressaltar que o problema deve estar na forma padrão.

2.1.2.1 Equações Básicas

Considere-se o problema de Programação Linear de minimização na forma padrãoapresentada em (2.25), onde o posto da matriz A é m. Agora, particione a matriz A emduas submatrizes B e N

A = [B N] (2.4)

onde B é uma submatriz quadrada de ordem m e inversível de A, formada por vetorescolunas linearmente independentes. As variáveis associadas a essas colunas denominam-sevariáveis básicas (VB). A submatriz N de ordem m × (n−m) de A constitui o restantedas colunas da matrizA . As variáveis associadas as colunas deN são denominada variáveisnão básicas (VNB).

O vetor x também é particionado nos vetores xB e xN

x = xB

xN

(2.5)

2.1. Simplex 31

onde xB é um vetor de ordem m x 1 formado pelos coeficientes das variáveis básicas e xN

é um vetor de ordem (n−m) × 1 formado pelos coeficientes das variáveis não básicas.

Da mesma forma o vetor c é particionado nos vetores cB e cN

c = [cB cN ]t. (2.6)

onde cB são os coeficientes das variáveis básicas da função objetivo de ordem m × 1, ecN são os coeficientes das variáveis não básicas da função objetivo de ordem (n−m) × 1.

Com as partições descritas anteriormente, o problema de minimização pode serreescrito na forma:

Minimizar Z = ctbxB + ct

NxN

sujeito a BxB + NxN = b, b ≥ 0xB ≥ 0, xN ≥ 0

(2.7)

Da equação (2.7), tem-se que:

BxB + NxN = b ⇒ xB = B−1b − B−1NxN (2.8)

Esta equação mostra que as variáveis não básicas xN determinam os valores das variáveisbásicas xB, de modo que o sistema seja satisfeito. Uma solução particular é dita básica,quando o valor das variáveis não básicas é zero. Assim:

xB = B−1b, xN = 0. (2.9)

quando xB é não negativo, a solução é dita Solução Básica Viável (SBV).

Substituindo a equação (2.8) na função objetivo (2.7), tem-se:

z = ctb(B−1b − B−1NxN) + ct

NxN = ctbB−1b − ct

bB−1NxN + ct

NxN , (2.10)

logo:

z = ctbB−1b + (ct

N − ctbB−1N)xN (2.11)

Em uma SBV, ou seja, quando xN = 0, a equação (2.11) se torna

z = ctbB−1b (2.12)

que representa o valor da função objetivo para qualquer SBV.


Reescrever a função objetivo em função das variáveis não básicas é importantepara mostrar como a função se comporta para cada troca de base. Seja Y = B−1N , logo aequação (2.8) pode ser escrita como:

xB = B−1b − Y xN = B−1b −∑j∈K

yjxj (2.13)

onde yj é a coluna j da matriz Y e K é o conjunto de índices das VNB. Tomando a funçãoobjetivo novamente e substituindo a equação (2.13) nela. Tem-se:

Z = ctbxB + ct

NxN = ctb(B−1b −

∑j∈K

yjxj) +∑j∈K

cjxj = ctBB−1b +

∑j∈K

(cj − ctby

j)xj.

(2.14)

Por (2.12), obtêm-se:

Z = z +∑j∈K

(cj − ctby

j)xj. (2.15)

E, definindo a componente:

dj = cj − ctby

j, (2.16)

yj pode ser obtido por yj = B−1aj,∀j ∈ K, então tem-se que:

dj = cj − ctbB−1aj, (2.17)

onde aj é a coluna j de A. Com isso obtém-se:

Z = z +∑j∈K

djxj (2.18)

A equação (2.18) permite escrever a função objetivo em função das VNB. Comopara uma SBV, xj = 0, ∀j ∈ K, então o valor da função objetivo é Z = z.

2.1.2.2 Teste de otimalidade - Entrada na Base

O teste de otimalidade serve para verificar se uma determinada solução básicaviável é ótima ou não. Caso seja ótima, o método termina. Se não, procura-se uma VNBpara entrar na base, de modo que o valor da função objetivo diminua.

Em uma SBV em que todas as variáveis não básicas são nulas, o método Simplexescolhe somente uma para assumir valor positivo. Dessa forma, a f.o. pode ser reescritasem o somatório (2.18), assim:

Z = z + djxj. (2.19)

2.1. Simplex 33

Pela equação (2.19) pode-se estabelecer um dos critérios para melhoria da funçãoobjetivo. Se o valor do termo dj for estritamente negativo, então, quando xj assume umvalor positivo, o valor da da f.o. fica reduzido de djxj. Logo, xj é uma candidata a entrarna base. No entanto, se dj > 0 e xj elevar o seu valor, isso significa que o valor de Z

aumentaria, e isto não é conveniente para o problema de minimização e neste caso, xj nãoé candidata para entrar na base. Então, se dj ≥ 0,∀j ∈ K, não é possível melhorar o valorde Z. Neste caso, a SBV atual é ótima, com valor ótimo de f.o. sendo Z = z.

O termo dj = cj − ctbB−1aj é chamado de coeficiente de custo reduzido, pois ele

fornece uma medida de decréscimo de Z quando xj assume um valor positivo.

Um critério bastante utilizado para se escolher uma VNB para entrar na base étomar a componente mais negativa do custo reduzido, isto é:

dk = minj∈K{dj, dj < 0}, (2.20)

uma vez que a VNB associada, xk, é a que mais contribui para diminuir o valor da funçãoobjetivo na SBV atual.

2.1.2.3 Teste da Razão - Saída da Base

O teste de razão serve para verificar o quanto a variável xk pode crescer seminterferir na viabilidade da solução, ou seja, todas as variáveis básicas devem permanecernão negativas. Para isso, o método Simplex determina qual VB deve deixar a base,tornando-se não básica. Além disso, o Simplex troca uma coluna da matriz N por umacoluna da matriz B em cada iteração.

Como somente a variável xk irá entrar na base e, continuando assim, as demaisVNB nulas, somente xk afetará no valor atual das VB, ou seja, reescrevendo a equação(2.13):

xB = B−1b − ykxk, ,∀k ∈ K. (2.21)

A expressão (2.21) mostra que se existir alguma componente yki < 0, onde I é o

conjunto de índices das VB, então o xiB associado pode crescer indefinidamente com o

valor de xk. Se existir, yki > 0, então o valor de xi

B decresce a medida que o valor de xk éelevado. Ressalta-se que uma solução básica é dita viável quando nenhum dos componentesde xB é negativo, isto é:

B−1bi − yki xk ≥ 0⇒ B−1bi ≥ yk

i xk ⇒ xk ≤B−1bi

yki

(2.22)


a nova variável básica xk só poderá crescer até que alguma componente xiB seja reduzida

a zero, o que corresponde ao mínimo entre todos os B−1byk

i, yk

i > 0. Seja xks essa componente,

então:

xsB = minyk

i

{B−1b

yki

, yki > 0

},∀i ∈ I. (2.23)

2.1.2.4 Atualização - Obter uma nova SBV

Pelo teste da otimalidade, sabe-se que variável xk deve entrar na base e, pelo testeda razão, a variável xs, deve sair da base. A seguir demonstra-se como proceder com aatualização dos elementos usados pelo Simplex.

• A nova matriz B é obtida da B anterior trocando a coluna associada a variável desaída, xs

B, pela coluna da variável que entrou na base, xk, da matriz A;

• A nova matriz N é obtida da anterior, com a coluna associada a variável, xk,substituída pela coluna da variável xs

B;

• Os novos componentes cB e cN seguem as mesmas trocas de B e N isto é, ocoeficiente cs

B é substituído por ck em cB e o coeficiente ck de cN é substituído porcs

B;

• Os novos componentes xB e xN seguem o mesmo princípio, isto é, xsB é substituído

por xk em xB e xk e substituído por xsB em xN ;

• xB = B−1b⇔ BxB = b, ou seja, o novo valor das VB pode ser obtido pela resoluçãodo sistema linear. Contudo, xB também pode ser obtido diretamente da equação(2.21), com o valor de xk calculado pelo teste da razão;

• O novo valor de Z é obtido diretamente da equação (2.12), com os novos valores decB e das variáveis básicas xB.

2.1.2.5 O Algoritmo Simplex

O algoritmo Simplex descreve uma sequência de ações que devem ser realizadas paraobter a solução de um problema de PL, baseados nos critérios estabelecidos anteriormente.Resumidamente, as etapas são:

1. Determinar uma SBV inicial;

2. Aplicar o teste de otimalidade: se a solução for ótima, então o algoritmo deve parar;se não, deve-se determinar uma variável não básica xk que deverá entrar na base;

3. Aplicar o teste da razão para determinar qual variável básica xsB deve sair da base;

2.1. Simplex 35

4. Obter uma nova SBV e retornar para a segunda etapa.

2.1.3 O Simplex Tableau

Quando os cálculos do método Simplex, para problemas pequenos, precisam serfeitos manualmente é desejável seguir um procedimento organizado. Os dados são colocadosem uma tabela, chamada de tableau, onde são mostradas, em cada iteração, a soluçãobásica viável, as varáveis básicas e as variáveis não básicas, bem como o valor da f.o..

Nesta tabela são efetuadas as operações de pivoteamento: trata-se de encontrar aVNB que deve entrar na base (teste de otimalidade) e encontrar a VB que deve sair dabase (teste da razão). Para isso, é necessário que o problema esteja no formato padrão,que exista uma matriz identidade como matriz básica B e que a função objetivo estejaem função das VNB, pois as VB são zeros. O quadro inicial do Simplex Tableau pode servisto na tabela 1.

Tabela 1: Quadro Inicial do Simplex Tableau

VNB VB bcB Y I bZ −d 0 z

No quadro inicial foi usado o termo −d pois a equação da f.o. foi rescrita como,z − ctx = 0. As outras notações usadas são:

• dj = cj − ctby

j, j ∈ K, onde yj é a coluna j de Y = B−1N (dj = 0 para toda VBxj).

• b = B−1b→ valor da SBV atual.

• z = cbtb→ valor da f.o. atual.

• I é a matriz identidade que é, também, a matriz base.

Considere o seguinte problema de maximização de PL:

Maximizar Z = c1x1 + c2x2 + · · ·+ cnxn

sujeito a a11x1 + a12x2 + · · ·+ a1nxn ≤ b1

a21x2 + a22x2 + · · ·+ a2nxn ≤ b2... ...

am1x1 + am2x2 + · · ·+ amnxn ≤ bm

x1 ≥ 0, x2 ≥ 0, . . . , xn ≥ 0

(2.24)


Colocando-o na forma padrão utilizando as operações elementares vistas na seção2.1.1, tem-se:

Maximizar Z = c1x1 + c2x2 + · · ·+ cnxn + 0xn+1 + 0xn+2 + · · ·+ 0xn+s

sujeito a a11x1 + a12x2 + · · ·+ a1nxn + xn+1 + 0 + 0 + · · ·+ 0 = b1

a21x1 + a22x2 + · · ·+ a2nxn + 0 + xn+2 + 0 + · · ·+ 0 = b2... ...

am1x1 + am2x2 + · · ·+ amnxn + 0 + 0 + 0 + · · ·+ xn+s = bm

x1 ≥ 0, x2 ≥ 0, . . . , xn+s ≥ 0

(2.25)

Observe que, o SBV inicial é:

x = (x1 x2 · · · xn xn+1 xn+2 · · · xn+s)t = (0 0 · · · 0 b1 b2 · · · bm)t

onde xN = (x1 x2 · · · xn)t = (0 · · · 0)t e xB = (xn+1 xn+2 · · · xn+s)t =(b1 b2 · · · bm)t, pois a matriz identidade é obtida com os coeficientes relativos às variáveisxn+1, xn+2, . . . , xn+s. A matriz N é obtida com os coeficientes relativos às variáveis nãobásicas x1, x2, . . . , xn . Note, também que:

c = (c1 c2 · · · cn cn+1 cn+2 · · · cn+s)t

onde cB = (0 0 · · · 0)t, para toda variável básica, e cN = (c1 c2 · · · cn)t. Logo, z = 0e dj = cj,∀j ∈ K, pois cB = 0. Observe, também que:

xb = b = B−1b = Ib = b; Y = B−1N = N.

Na linha da f.o. coloca-se a equação em função das VNB, isto é:

Z − c1x1 − c2x2 − · · · − cnxn − 0xn+1 − 0xn+2 − · · · − 0xn+s = 0.

A tabela 2 2 mostra o quadro inicial do Simplex tableau mais detalhado. Perceba quea primeira linha é formada pelos os coeficientes dj da f.o., os coeficientes das variáveis básicastem valor zero, e o valor da função é inicialmente zero. Para as colunas referentes às VBnote a matriz identidade que representa a matriz básica B. As colunas associadas as VNBpossuem valores referentes aos coeficientes aij, cj,∀i = {1, 2, · · · , m}, j = {1, 2, · · · , n}, eo conjunto dos elementos aij fazem parte da matriz N.

2.1.3.1 Teste de Otimalidade

Relembrando a equação (2.19):

Z = z + djxj. (2.26)

2.1. Simplex 37

Tabela 2: Quadro Inicial mais detalhado do Simplex Tableau.

Z x1 x2 · · · xn xn+1 xn+2 · · · xn+s bZ 1 −c1 −c2 · · · −cn 0 0 · · · 0 0

xn+1 0 a11 a12 · · · a1n 1 0 · · · 0 b1xn+2 0 a21 a22 · · · a2n 0 1 · · · 0 b2... ... ... ... ... ... ... ... ... ... ...

xn+s 0 am1 am2 · · · amn 0 0 · · · 1 bm

foi visto que no problema de minimização o critério para uma VNB entrar na baseé que dj < 0, logo para o problema de maximização esse critério seria o oposto, ou seja,dj > 0. Se o coeficiente de custo reduzido for estritamente positivo fará que aumente ovalor da f.o..

Assim para o problema no Simplex Tableau tem-se que:

Z = z + djxj ⇒ Z − z − djxj = 0. (2.27)

portanto, para ser candidata a entrar na base na forma Tableau é necessário que −dj < 0.Se o problema fosse de minimização, esse critério seria −dj > 0. Se existirem váriascandidatas, pode-se escolher a que possuir coeficiente mais negativo, isto é:

−dk = minj∈K{−dj,−dj < 0}. (2.28)

A VNB xk associada é a escolhida para entrar na base e a coluna referente a essavariável é chamada de coluna pivô. O método do Simplex em sua forma tableau demaximização termina quando −dj ≥ 0,∀j ∈ K ou dj ≤ 0, pois qualquer xj ≥ 0 iria pioraro valor de Z.

2.1.3.2 Teste da Razão

Para escolha da VB que deve sair da base, relembre a expressão do teste de razão:

xsB = minyk

i

{B−1b

yki

, yki > 0

},∀i ∈ I | I = [1 m] (2.29)

Esse teste deve ser realizado em todas as linhas imediatamente depois da linha corres-pondente a f.o.. Os elementos da razão são dados pelos valores da última coluna b peloselementos positivos correspondentes da coluna do pivô. O menor desses quocientes dizqual a variável básica associada que deve sair. A linha referente a essa variável é chamadade linha pivô.


2.1.3.3 Obtenção de uma nova SBV

Para obter um novo quadro, indicando as novas variáveis básicas e seus valores,o novo valor da f.o. e as novas colunas yj é necessário realizar as operações elementaressobre linhas, descritas nas etapas a seguir:

Etapa 1. Localizar o elemento que está na intersecção da linha pivô lp e coluna pivô cp.Esse elemento é o pivô yp;

Etapa 2. Multiplicar a linha pivô por 1yp, transformado o elemento pivô em 1;

Etapa 3. Fazer a operação elementar (2.30) em todas as outras linhas, inclusive a linhacorrespondente à f.o., de modo a transformar em zeros todos os outros elementos dacoluna pivô, exceto o elemento pivô que continua sendo 1.

li = li − yplp,∀i ∈ I | I = [1 m]. (2.30)

As etapas 2 e 3 são operações elementares sobre as linhas do quadro Simplex ecorrespondem ao método de Gauss-Jordan para resolver sistemas lineares. O objetivo étransformar a coluna referente a variável que irá entrar na base em coluna identidade eretirar a antiga VB modificando os valores, deixando-a sem a coluna identidade.

2.1.3.4 Algoritmo do Simplex Tableau

O procedimento para usar o método Simplex Tableau é descrito nos passos descritosa seguir:

Passo 1. Com o problema na forma padrão, fazer o quadro inicial, colocando os dadosconforme o modelo que foi explicado;

Passo 2. Realizar o teste de otimalidade:

• Se todos os −cj ≥ 0,∀j ∈ K, então a solução ótima foi alcançada e o métododeve parar (Critério de parada).

• Caso contrário escolhe-se o menor −cj < 0, por exemplo, ck, escolhe-se, assim,a coluna pivô associado a xk para entrar na base;

Passo 3. Realizar o teste da razão para escolher a linha pivô:

xsB = minyk

i

{B−1b

yki

, yki > 0

},∀i ∈ I | I = [1 m] (2.31)

O teste deve ser realizado para todas as linhas, exceto a linha da f.o. A linha associadaao menor quociente deve ser a linha pivô.

2.1. Simplex 39

Importante: Se nenhum dos elementos abaixo da linha correspondente a f.o. nacoluna pivô for positivo, o problema não tem solução finita ótima, assim, o métododeve parar.

Passo 4. Multiplicar a linha pivô por 1yp, transformado o elemento pivô em 1;

Passo 5. Fazer a operação elementar :

li = li − yplp,∀i ∈ I | I = [1 m]. (2.32)

em todas as outras linhas, exceto a linha do pivô e inclusive a linha correspondenteà f.o., de modo a transformar em zeros todos os outros elementos da coluna pivô,isto é, todos exceto o elemento pivô que continua sendo 1.

2.1.4 Simplex Revisado

O método simplex revisado consiste em uma maneira de aplicarmos o método a umproblema de programação linear, de forma a reduzir a quantidade de operações realizadas.Se um problema possuir um número de variáveis muito maior que o de restrições, o totalde operações em cada iteração é menor, pois trabalha-se com tabelas cuja dimensãoé determinada pelo número de restrições. O método revisado tem mais vantagens emmodelos, onde há muitos coeficientes nulos nas restrições.

Simplex revisado utiliza dos mesmos princípios do Simplex Padrão, contudo nãonecessita atualizar toda a tabela em cada iteração. O método simplex revisado consistenos seguintes passos:

Passo 1 Converter um problema de programação linear do formato canônico para opadrão, como apresentado na seção 2.1.1.

Passo 2 Considerando a equação descrita em 2.11, calcule o coeficiente de custo relativor = ct

N − ctbB−1N . Se r ≥ 0, então a solução é ótima. Caso contrário:

Passo 3 Selecionar a coluna ak para entrar na base selecionando o coeficiente de custorelativo mais negativo. Calcular yk = B−1ak que expressa o novo vetor coluna ak

na base nova.

Passo 4 Se não existe nenhum yki ≥ 0 pare, pois o problema é ilimitado. Caso contrário,

calcule os quocientes B−1byk , para determinar qual variável irá sair da base. Ou seja:

xsB = minyk

i

{B−1b

yki

, yki > 0

},∀i ∈ I. (2.33)

onde I é o conjunto de índices das variáveis básicas.


Passo 5 Atualize B−1, efetuando pivoteamento gaussiano em torno e yks . Calcule a nova

solução corrente xB = B−1b e retorne ao passo 2.

2.2 Arquiteturas Paralelas

O Hardware e software paralelos foram desenvolvidos tendo como base o tradicionalhardware e software sequencial1. Assim, para entender melhor o estado atual de sistemasparalelos, será feita uma breve revisão em alguns aspectos dos sistemas sequenciais, comotambém, uma sucinta descrição sobre hardware e software paralelo e, posteriormente, serámostrado como avaliar o desempenho de um programa paralelo.

2.2.1 Arquitetura de Von Neumann

A arquitetura clássica de von Neumann consiste em memória principal, uma unidadecentral de processamento (CPU), e uma interligação entre a memória e a CPU (PACHECO,2011). A memória principal consiste de um conjunto de locais, onde cada um é capaz dearmazenar instruções e dados. Cada local consiste de um endereço, o qual é usado paraacessar à localização e o conteúdo, ou seja, as instruções ou os dados armazenados no local( ver figura 1).

Figura 1: A arquitetura de Von Neumann.

fonte: Adaptado de (LIN; SNYDER, 2008).

1 hardware e software que executam uma única tarefa de cada vez.

2.2. Arquiteturas Paralelas 41

As instruções e os dados são transferidos entre a CPU e a memória através de umbarramento chamado FSB (Front Side Bus). O FSB consiste em um conjunto de vias emparalelo e um hardware específico para controlar o acesso às vias. Na máquina de vonNeumann, uma única instrução é executada de cada vez, e esta opera em apenas algumaspartes dos dados.

Essa separação da CPU com a memória é, frequentemente, chamada de gargalo deVon Neumann, que consiste na diferença de clock entre a CPU e a memória. A taxa decomunicação de dados entre a CPU e a memória, é muito menor do que a taxa com que oprocessador pode trabalhar. Isso limita a velocidade eficaz de processamento, principal-mente quando a CPU é exigida para realizar o processamento de grandes quantidades dedados. Ela é constantemente forçada a esperar por dados que precisam ser transferidosa partir da memória, ou com destino a ela. Como a velocidade da CPU e o tamanho damemória aumentam muito mais rapidamente que a taxa de transferência entre eles, ogargalo se torna mais um problema cuja gravidade aumenta com cada geração de CPU.

Os primeiros computadores eletrônicos digitais foram desenvolvidos na décadade 1940, desde então, cientistas e engenheiros de computação têm proposto melhoriaspara a arquitetura básica de von Neumann. Muitas delas têm o objetivo de reduzir oproblema do gargalo de von Neumann, e outras são direcionadas para simplesmente tornaras CPUs mais rápidas. Pode-se citar como exemplo dessas melhorias: a separação dosbarramentos de instrução e de dados, que permitem a referência de dados e de instruçãoparalelamente, sem interferência mútua;a criação de pipelining, que é um conjunto deelementos de processamento ligados em série, onde a saída de um elemento é a entradado próximo. Esses elementos são executados em paralelo, enquanto, por exemplo, umainstrução atual está sendo decodificada, a escrita dos resultados é passada para a memória;O uso de técnicas de especulação, onde os processadores replicam unidades funcionaise tentam executar diferentes instruções de um programa simultaneamente. Ou seja, osprocessadores sequenciais já possuíam paralelismo intrínseco.

Outra melhoria desenvolvida, muito significativa para amenizar o gargalo, é amemória cache. Uma breve explicação da memória cache será descrita a seguir, vistoque apresenta uma grande influência na melhoria da arquitetura de Von Neumann, comotambém, influenciou diretamente esse trabalho.

2.2.1.1 Memória Cache

A cache é um conjunto de memórias que a CPU pode acessar mais rapidamentedo que a memória principal. Ela pode estar localizada no mesmo chip com o processadorou pode ser localizada separadamente. A memória cache pode ser acessada muito maisrápido do que um chip de memória comum (PACHECO, 2011).

A memória cache segue o princípio de localidade, a qual ao acessar uma posição


de memória (instrução ou dados) um programa acessará em uma localização próxima(localidade espacial) no futuro próximo (localidade temporal). A fim de explorar o princípioda localidade, o sistema utiliza efetivamente uma ampla interconexão para acessar os dadose instruções. Isto é, um acesso à memória que irá operar em blocos de dados e instruções,ao invés de instruções individuais e itens de dados individuais. Esses blocos são chamadosblocos de cache ou linhas de cache.

Conceitualmente, muitas vezes é conveniente pensar em uma cache da CPU comouma única estrutura monolítica. Na prática, porém, o cache é normalmente dividido emníveis: o primeiro nível (L1) é o menor e mais rápido, e níveis mais elevados (L2, L3, ...)são maiores e mais lentos. A maioria dos sistemas atualmente, tem pelo menos dois níveis,e o fato de alguns possuírem três níveis já é bastante comum.

Quando a CPU precisa acessar uma instrução ou dados, ela trabalha o seu caminhopara baixo na hierarquia do cache: Inicialmente, verifica o cache de nível 1, em seguida ode nível 2, e assim por diante. Finalmente, se a informação necessária não é encontradaem qualquer um dos caches, ela acessa a memória principal. Quando um cache tem ainformação e esta, está disponível, então é chamado de cache hit ou apenas hit, mas se ainformação não estiver disponível, é chamado de cache miss ou somente miss. Hit ou miss,são muitas vezes modificadas pelo nível, por exemplo, quando a CPU tenta acessar umavariável, ela pode ter uma L1 miss e L2 hit (ver figura 2).

Figura 2: Exemplo de acesso de dados e instruções por meio de memória cache que ocorreum cache-miss na cache L1 e um cache-hit na cache L2.

Fonte: Autoria própria.

Quando a CPU tenta ler dados ou instruções, ocorrendo uma leitura-miss em todosos níveis da cache, então será lido da memória principal o bloco de dados ou instruções (alinha de cache). Esse bloco contém as informações necessárias e estas serão armazenadasna cache (ver figura 3). Isso pode parar o processador, enquanto aguarda a memória maislenta. Ele pode interromper a execução de instruções do programa atual até que os dadosou as instruções necessárias sejam obtidas na memória principal.


Figura 3: Acesso de dados e instruções por meio de memória cache que o dado ou instruçãonão se encontra na cache L1 ou L2.


2.2.2 Classificação de Computadores Paralelos

Todas essas melhorias feitas na arquitetura de Von Neumann podem claramenteser consideradas hardware paralelo, uma vez que as unidades funcionais são replicadase os dados/instruções são executados simultaneamente. No entanto, uma vez que estaforma de paralelismo geralmente não é visível para o programador, as melhorias feitasnessa arquitetura, tratam-se de extensões para o modelo básico von Neumann. Para opropósito deste trabalho, hardware paralelo será limitado ao hardware que é visível parao programador. Em outras palavras, se a melhoria pode facilmente modificar seu códigofonte para explorá-la, então será considerado o hardware paralelo.

A taxonomia de Flynn (1972) é uma maneira comum de se caracterizar arquiteturasde computadores paralelos. As classes de arquiteturas foram propostas de acordo com aunicidade ou multiplicidade de dados e instruções, conforme descrições a seguir:

SISD - Single Instruction, Single Data streams2 refere-se aos computadores sequenciaiscom apenas um processador (a clássica máquina seqüencial de Von Neumann), ondehá um controle sobre o que está ocorrendo exatamente em cada instante de tempo eé possível de reproduzir o processo passo a passo.

SIMD - Single Instruction, Multiple Data streams3 refere-se aos sistemas paralelos denatureza síncrona, ou seja, todas as unidades de processamento recebem a mesmainstrução no mesmo instante de tempo de modo que todas possam executá-la deforma simultânea, mas contendo dados diferentes. A figura 4 apresenta um esquemapara esse tipo de arquitetura paralela.

2 Instrução Única, Dado Único.3 Instrução única, Dados múltiplos.


Figura 4: Arquitetura paralela SIMD.


MISD - Multiple Instruction, Single Data4 são conceitualmente definidas como de múlti-plos fluxos de instruções que operam sobre os mesmos dados. Além da dificuldade deimplantação deste tipo de sistemas, há ausência de uma plataforma ou paradigma deprogramação que permita utilizar este tipo de arquitetura eficientemente. Na prática,não é comum encontrar implementações desse modelo.

MIMD - Multiple Instruction, Multiple Data streams5 refere-se aos sistemas paralelosde natureza assíncrona, ou seja, as instruções são geradas por unidades de controlediferentes e cada processador executa sua instrução no seu próprio dado. Eles possuemtanto paralelismo de dados quanto de instruções. É a categoria onde grande partedos multiprocessadores atuais se encontram. A figura 5 mostra um modelo para essaarquitetura paralela.

4 Instruções Múltiplas e Dados Únicos5 Instrução múltipla, Dados múltiplos.


Figura 5: Arquitetura paralela MIMD.


2.2.3 Arquiteturas de memória em Computadores Paralelos

A arquitetura MIMD da classificação de Flynn é muito genérica para ser utilizada naprática. Essa arquitetura, teoricamente, poderia executar programas destinados a qualqueroutra arquitetura de Flynn, ou seja, todos os outros casos seriam uma sub-classificação doMIMD. Assim, ela é, geralmente decomposta de acordo com a organização de memória.Existem três tipos de sistemas paralelos, diferindo quanto a comunicação, são eles: memóriacompartilhada, memória distribuída e memória híbrida. Esses sistemas são descritos aseguir:

2.2.3.1 Memória Compartilhada

Um sistema de Memória Compartilhada é uma memória que pode ser acessadasimultaneamente por múltiplos programas com a intenção de prover comunicação entreeles ou para evitar cópias redundantes. Assim, por exemplo, um processador A desejandocomunicar-se com um B deve escrever em uma posição da memória para que B leia destamesma posição. A seguir será descrito duas das principais classes do sistema de memóriacompartilhada, SMP e NUMA.

SMPs (Symmetric MultiProcessors (Multi-Processadores Simétricos)) é uma classemuito comum desse tipo de sistema, onde dois ou mais processadores idênticos sãoconectados a uma única memória principal compartilhada. O SMP têm pleno acesso atodos os dispositivos de I/O, além do mais são controlados por uma única instância dosistema operacional, na qual todos os processadores são tratados da mesma forma.

Os processadores trabalham sozinhos compartilhando os recursos de hardware,geralmente eles são iguais, similares ou com capacidades parecidas. Por tratar todos os


processadores de forma igualitária, no multiprocessamento simétrico, qualquer unidadede processamento pode assumir as tarefas realizadas por qualquer outro processador. Astarefas são divididas e também podem ser executadas de modo concorrente em qualquerprocessador que esteja disponível. Os acessos dos processadores aos dispositivos de entradae saída, e à memória são feitos por um mecanismo de intercomunicação constituído porum barramento único (ver figura 6).

Figura 6: Arquitetura SMP.


A memória principal da máquina é compartilhada por todos os processadoresatravés de um único barramento que os interliga, de modo que essa comunicação coma memória é nativo. Um dos gargalos desse sistema é o acesso à memória principal serrealizado através de um único barramento, e esse acesso ser serial. O sistema fica limitadoa passagem de apenas uma instrução de cada vez pelo barramento, abrindo uma lacunade tempo entre uma instrução e outra. Contudo, memórias caches junto aos processadoresdiminuem o tempo de latência entre um acesso e outro à memória principal e ajudamtambém a diminuir o tráfego no barramento.

Antigamente para utilizar SMP era preciso um hardware específico, placas-mãe comdois ou mais soquetes de CPU e grandes estruturas de servidores conectados. Atualmentecom a tecnologia mullticore, as fabricantes já integram tudo isso em apenas um dispositivofísico, também conhecido como processador mullticore.

NUMA (Non-uniform memory access (Acesso não Uniforme à Memória)) é umsistema de memória compartilhada em que cada nó desse sistema possui sua própriamemória local que pode ser acessada por todos os outros processadores dele. O custode acesso à memória local é menor que o custo de acesso a dados presentes na memórialocal de outros processadores, sendo estimado em termos de tempo de acesso e latência.Entretanto, alguns blocos de memória podem ficar fisicamente mais próximos com certosprocessadores e são naturalmente associados a eles. Dessa forma, o tráfego gerado no meiode comunicação é diminuído, permitindo que mais processadores sejam adicionados aosistema.

Sistemas de arquitetura NUMA herdam um problema existente nos sistemas dearquitetura SMP: a coerência da memória principal e da memória cache. Em um sistema


Figura 7: Arquitetura NUMA.


NUMA com coerência de cache, quando um processador inicia um acesso à memória, se aposição requerida não está na cache deste processador, uma busca na memória é realizada.Se a linha requerida está na porção local da memória principal, ela é obtida por meio dobarramento local, se a posição está em uma memória remota, é feita uma requisição debusca à memória remota através do sistema de conexão que interliga os processadores.O dado é então entregue ao barramento local, que é em seguida entregue à cache e aoprocessador requisitante.

2.2.3.2 Memória Distribuída

Um sistema de Memória Distribuída são sistemas compostos por vários computa-dores, capazes de operar de forma totalmente desacoplada, e que se comunicam através deoperações de entrada e saída (CULLER; GUPTA; SINGH, 1997). Esses sistemas geral-mente são compostos por diversas unidades de processamento conectadas por uma rede dedados, onde cada processador possui uma área de memória local apenas. As unidades deprocessamento podem operar independentemente entre si e se precisarem acessar endereçosde memória não-local, esses dados geralmente são transferidos pela rede de uma área dememória para outra. A figura 8 apresenta um exemplo representativo de um computadorde memória distribuída.


Figura 8: Arquitetura de memória distribuída.


Em memória distribuída, a ligação entre os processadores é representada atravésde uma rede de interconexões. Essa rede é composta por: vértices, os quais representamum par processador-memória e as arestas representam as ligações diretas entre estespares. Existem várias topologias, ou seja, diferentes formas nas quais se pode organizar ainterligação entre cada um dos vértices do garfo, duas dessas topologias serão descritas aseguir:

Hipercubo Essa topologia é bastante usada em sistemas paralelos, devido ao seu baixonúmero de vértices (processadores), o que diminui a latência de memória6 em relaçãoa outras topologias. A figura 9 apresenta um esquema de topologia em hipercubo.

Figura 9: Topologia em hipercubo.


Malha Essa topologia possui uma boa tolerância a falhas, devido ao grande número decaminhos alternativos entre dois processadores. A figura 10 apresenta um exemplode topologia em malha.

6 Latência de memória é o tempo que um processador espera para que um dado requisitado que nãoesteja em sua memória local fique disponível.


Figura 10: Topologia em malha.


Dependendo da topologia e da tecnologia utilizadas para interconexão dos proces-sadores, a velocidade de comunicação pode ser tão rápida quanto em uma arquiteturade memória compartilhada. A princípio, não existe uma área de memória compartilhada.Cada computador possui a sua própria memória principal, constituindo assim, uma hie-rarquia de memória distribuída. Caso um processador necessite de uma informação queestá na memória principal de uma outra unidade de processamento, esta informação deveser explicitamente transferida entre os processadores utilizando-se de um mecanismo deMessage Passing7.

A passagem de mensagem é um modelo de programação paralela amplamenteutilizado. Seus programas criam múltiplas tarefas, cada uma delas encapsulando dadoslocais. Cada tarefa é identificada por um nome próprio e interage com outras através deenvio e recepção de mensagens entre elas.

Cada tarefa pode realizar operações de leitura ou escrita em sua memória local;operações aritméticas, chamadas de funções locais e, enviar ou receber mensagens. Normal-mente, o envio de uma mensagem é instantâneo e ocorre de forma assíncrona, enquanto orecebimento ocorre de forma síncrona e bloqueia o fluxo de execução da tarefa até que amensagem seja recebida.

2.2.4 Máquinas Paralelas

O computador paralelo é definido por Almasi e Gottlieb (1989) como uma coleçãode elementos de processamento que cooperam e se comunicam para resolver grandesproblemas de forma rápida. As máquinas paralelas começaram a surgir com o objetivo deresolver algumas aplicações científicas de maior porte, elas eram projetadas tendo comofoco a resolução dos problemas da forma mais rápida possível, sem preocupações compadronização entre arquiteturas.

O diagrama da figura 11 mostra a taxonomia de Flynn e suas ramificações. Algumasmáquinas foram criadas baseadas messa taxonomia, como por exemplo, o CM-2 e oMASPAR, ambos constituídos de vetores de processadores, e baseados na arquiteturaSIMD.7 Passagem de Mensagens


Figura 11: Taxonomia de Flynn e suas ramificações.


2.2.4.1 CM-2 (Connection Machine-2)

O Connection Machine (CM) foi uma série de supercomputadores que cresceu apartir da pesquisa Danny Hillis no início de 1980 no MIT. Ele foi originalmente plane-jado para aplicações em inteligência artificial e processamento simbólico, mas as versõesposteriores encontraram maior sucesso no campo da ciência computacional.

O CM-2 era configurável de 4.092 até 65.536 processadores, e com até 512 MB deDRAM, trata-se de uma máquina SIMD com memória distribuída. Seus processadoresestão organizados em um hipercubo, onde cada vértice equivale ao que é chamado desprint-node, os quais são formados por 32 processadores não poderosos (1 bit). Assim, porexemplo, utilizando uma estrutura com 65.536 processadores, logo há 2.048 sprint-nodesorganizados em um hipercubo de 11 dimensões.

2.2.4.2 MP (MasPar)

MasPar Computer Corporation é uma empresa fornecedora de mini-supercomputadorque foi fundada em 1987 por Jeff Kalb. O MP-1 era configurável de 1.024 a 16.384 pro-cessadores em duas séries (MP1100 a MP1200), sendo uma máquina SIMD de memóriadistribuída. Os processadores são customizados e estão organizados em uma topologiaem malha, com grupos de 16 processadores em malha 4 x 4. A largura de banda destarede cresce quase linearmente com o número de processadores. O MASPAR (MP) versão 1utiliza DRAMs de 16 Kbytes por processador, o que dá uma memória total de 256 Mbytes.

2.2.4.3 Cray T3D

Outra máquina produzida na arquitetura proposta por Flynn foi O Cray-T3D.Ela é considerada a primeira máquina maciçamente paralela da empresa Cray Researchlançada em 1993. O Cray T3D é uma máquina MIMD de memória compartilhada NUMA.


Nela o processador pode ler ou escrever em memórias não-locais sem conhecimento préviodos processadores locais a estas, por isso é dita compartilhada. O tamanho da memória édado pelo número de processadores, multiplicado pelo tamanho da memória local a cadaprocessador, que varia de 16 a 64 Mbytes. Logo, uma máquina com 1024 processadorespossui uma memória de até 64 Gbytes.

2.2.4.4 Multicore

A tecnologia multicore vem se solidificando no mercado atual cada vez mais.Essa tecnologia vem da arquitetura MIMD de Flynn (ver figura 11). Um processadormulticore é um componente de computação com duas ou mais unidades independentes deprocessamento, chamados núcleos. São unidades que lêem e executam as instruções doprograma, usando memória compartilhada para a comunicação entre si. Os núcleos podemou não executar múltiplas instruções ao mesmo tempo, aumentando a velocidade geral dacomputação paralela. A figura 12 mostra um exemplo de uma arquitetura de múltiplosnúcleos. A arquitetura é geralmente um SMP, ou seja, onde dois ou mais processadoresidênticos são ligados a uma única memória principal, implementado em um circuito VLSI- Very Large Scale Integration8.

Figura 12: Exemplo de uma arquitetura multicore.

fonte:(LIN; SNYDER, 2008)

Em processadores de múltiplos núcleos o sistema operacional trata cada um dessesnúcleos como um processador diferente. Na maioria dos casos, cada unidade possui seupróprio cache e alguns casos realizam acesso direto e independente à memória principal.Possibilita-se, assim, que as instruções de aplicações sejam executadas em paralelo, ou8 VLSI é o processo de criação de circuitos integrados através da combinação de milhares de transistores

em um único chip. VLSI surgiu na década de 1970, quando as tecnologias de semicondutores e decomunicação complexos estavam sendo desenvolvidos.


seja, cada processador realiza os cálculos de que é requisitado concorrentemente com ooutro, ganhando desempenho. Adicionar novos núcleos de processamento a um processadorpossibilita que as instruções das aplicações sejam executadas em paralelo, como se fossem2 ou mais processadores distintos.

Dois ou mais núcleos não somam a capacidade de processamento, mas dividem astarefas entre si. Por exemplo, um processador de dois núcleos com clock de 1.8 Ghz nãoequivale a um processador de um núcleo funcionando com clock de 3.6 Ghz, e sim doisnúcleos 1,8 Ghz operando em paralelo.

Os processadores multicore tornaram-se fundamental devido à necessidade desolucionar alguns problemas. Dentre eles pode-se destacar: a missão cada vez mais difícilde resfriar processadores single core com clocks cada vez mais altos; A concentração cadavez maior de transistores em um mesmo circuito integrado. Além dessas e outras limitaçõesdos processadores single core, que serão detalhados logo adiante na sessão 2.3.

2.2.4.5 Multi-Computadores/Processadores

A figura 11 apresenta sistemas ramificados pelo MIMD, dois deles são: o multi-processador e o multi-computador. O multi-processador é um conjunto de unidade deprocessamento, utilizando memória compartilhada; já o multi-computador é um sistemadistribuído, ou seja, dois ou mais computadores interconectados, comunicando-se pormensagem em que cada computador pode realizar uma tarefa distinta.

Essas máquinas paralelas foram produzidas a partir da década de 70 e eram carac-terizadas pelo custo elevado e pela dificuldade de programação. O programador necessitavater o conhecimento específico de cada máquina paralela para a qual seriam implementadasas aplicações paralelas, o que aumentava a complexidade do desenvolvimento do programa.Além disso, o rápido decréscimo na relação preço-desempenho de projetos de micropro-cessadores convencionais levou ao desaparecimento desses supercomputadores no final de1990.

2.2.5 Software Paralelo

Para resolver um problema, tradicionalmente, o software tem sido escrito como umfluxo serial de instruções, já a programação paralela, por outro lado, faz uso de múltiploselementos de processamento para resolvê-los. Isso é possível ao quebrar um problema empartes independentes de forma que cada elemento de processamento possa executar suaparte do algoritmo simultaneamente com outros.

Após mostrar as arquiteturas paralelas de hardware, se faz necessário tambémestudar as arquiteturas paralela de software, pois sem eles não há como utilizar o hardwarepara realizar trabalho útil. Nesse capítulo, será visto dois softwares que podem ser utilizados


para computação paralela: o MPI baseado em memória distribuída e o OpenMP, utilizadonesse trabalho, baseado em memória compartilhada.

2.2.5.1 MPI

MPI (Message Passing Interface) é um sistema de transmissão de mensagenspadronizadas, desenvolvido por um grupo de pesquisadores da academia e da indústriapara funcionar em uma ampla variedade de computadores paralelos. O padrão define asintaxe e a semântica de um núcleo de rotinas de biblioteca úteis para uma ampla gamade usuários. Os programas de transmissão de mensagens portáteis são escritos em Fortran77 ou na linguagem de programação C. Existem várias implementações bem testadas eeficientes de MPI, incluindo algumas que são gratuitas ou de domínio público.

MPI é uma API(Application Programming Interface) o qual foi desenvolvido parapermitir que os usuários criem programas que podem ser executados de forma eficiente namaioria das arquiteturas paralelas. O processo de projeto é incluído fornecedores, como:IBM, Intel, TMC, Cray, Convex; autores de bibliotecas paralelas e especialistas.

O MPI executa, inicialmente, um número fixo de processos, tipicamente, cadaprocesso é direcionado para diferentes processadores. Os processos podem usar mecanis-mos de comunicação ponto a ponto, que são operações para enviar mensagens de umdeterminado processo a outro. Um grupo de processos pode invocar operações coletivas(collective) de comunicação para executar operações globais. O MPI é capaz de suportarcomunicação assíncrona e programação modular, através de mecanismos de comunicadores(communicator) que permitem ao usuário MPI definir módulos que encapsulem estruturasde comunicação interna.

2.2.5.2 OpenMP

OpenMP (Open Multi-Processing) é uma API multiplataforma para multipro-cessamento, usando memória compartilhada. Ela consiste de um conjunto de diretivaspara o compilador, funções de biblioteca e variáveis de ambiente as quais especificam aimplementação de um programa paralelo em C/C++.

A inserção adequada de recursos OpenMP em um programa seqüencial vai permitirque muitas, talvez a maioria, das aplicações se beneficiem da arquitetura paralela dememória compartilhada com o mínimo de modificação no código. Na prática, muitas dasaplicações têm considerável paralelismo que podem ser exploradas.

A OpenMP é gerenciada por uma associação sem fins lucrativos, a OpenMP ARB(OpenMP Architecture Review Board), definida por um grupo das principais empresasde hardware e software, incluindo AMD, IBM, Intel, Cray, HP, Fujitsu, Nvidia, NEC,Microsoft, Texas Instruments, Oracle Corporation e outros (ARB, 2013). Os integrantes


da OpenMP ARB compartilham o interesse de uma abordagem portátil, de fácil utilizaçãoe eficiente para programação paralela com memória compartilhada.

2.3 Paralelismo e EscalabilidadeEm meados de 1965, o co-fundador da Intel R©, Gordon Moore (MOORE, 1965),

observou que o número de transistores dos chips teria um aumento de 60%, pelo mesmocusto, a cada período de 18 meses. Inicialmente a lei de Moore não passava de umaobservação, mas acabou tornando-se um objetivo para as indústrias de semicondutores.Muitos recursos foram gastos para poder alcançar as previsões de Moore no nível dedesempenho. A figura 13 mostra a evolução na quantidade de transistores nos processadoresIntel R©.

Figura 13: Lei de moore.

fonte: <http://pt.wikipedia.org/wiki/Lei_de_Moore>

A dedicação das grandes empresas em pesquisar e desenvolver processadores comfreqüência de clock cada vez maiores, fez com que mantivesse por mais de 40 anos aduplicação de quantidade de transistores a cada ano e meio. Contudo, essa duplicação eo aumento da freqüência de operação dos processadores têm sido mais difíceis de seremfeitos por diversos motivos.

Um desses motivos diz respeito ao tamanho dos transistores. O funcionamentodos transistores são baseados no uso de eletricidade para controlar o fluxo de elétronsentre os dois extremos (pólos). O gate, localizado no centro do transistor, é responsávelpor permitir ou bloquear o fluxo de elétrons de acordo com o estado lógico do transistor.Depois dos 10 nm, os elétrons passam aleatoriamente por ele, mesmo que o gate não esteja

http://pt.wikipedia.org/wiki/Lei_de_Moore

2.3. Paralelismo e Escalabilidade 55

ativo, fazendo com que ele deixe de ser confiável, isso é chamado de tunneling. Ao chegaraos 5 nm o problema se torna crônico e a quebra da barreira passa a ocorrer em 50% dasvezes, eliminando a possibilidade do uso de qualquer sistema de correção. Em uma escalatão pequena, o tunneling ocorre independentemente do material usado, o que elimina apossibilidade de que algum novo material possa estender o processo por mais gerações(MORIMOTO, 2012).

Um dos maiores problemas é a muralha de energia. Existem 3 fatores que estãointimamente ligados: freqüência de operação dos chips, energia e a temperatura. Aoaumentar a freqüência de operação faz-se necessária mais energia para poder operar, econseqüentemente, há maior liberação de calor. Com a miniaturização do transistor, oschips atuais são mais densos, e como consequência, aumenta-se os 3 fatores. Em 1993,por exemplo, os processadores Intel R© Pentium R© possuiam aproximadamente 3 milhões detransistores, enquanto que o processador Intel R© Itanium R© 2 possuíam cerca de 1 bilhãode transistores. Segundo Koch (2005), se essa taxa continuar, os processadores Intel R©,logo produzirão mais calor por centímetro quadrado que a superfície do sol. Por isso que oproblema do calor já estabelece difíceis limites para o aumento da frequência.

Nos últimos anos, vem crescendo a quantidade de dispositivos portáteis, comosmartphones, tablets, laptops, netbooks e outros. Todos esses dispositivos possuem pro-cessadores e memória para processar os dados. Logo, o consumo de tais aparelhos deveser o mínimo possível para prolongar o tempo da bateria. Dessa forma, o novo desafio daengenharia é trabalhar na criação de dispositivos elétricos que consumam menos energiae produzam menos calor. Freqüências muito acima dos 4 ou 4.5 GHz demandam water-coolers9 ou soluções exóticas de resfriamento, mas dificilmente serão usados pela grandemassa de usuários devido ao custo e à complexidade.

Os chips multicore podem operar em freqüências menores comparados com osprocessadores de um núcleo, já que podem realizar mais trabalhos a cada ciclo. Comoaumentar a operação, também eleva o consumo de energia, os chips multicores são um dosmeios para a solução dos problemas de energia e temperatura. Assim, tem-se esforçadopara dobrar a quantidade de núcleos a cada geração, chamando esse novo tempo de EraMulticore (BORKAR, 2007) (KOCH, 2005).

Embora a nova era paralela da computação beneficie o processamento de diversastarefas ao mesmo tempo, a aceleração de uma tarefa ou algoritmo isolado requer, desta vez,um esforço adicional. Para isso é necessário que os programas mudem, e como consequência,os programadores também devem. Como resultado, atualmente, a grande maioria dosalgoritmos não suporta paralelismo. Portanto, dentre os muitos desafios da era multicore,um dos mais urgentes é verificar se os algoritmos possuem problemas de escalabilidade

9 water-coolers ou sistemas de refrigeração a líquido, são sistemas de resfriamento, o qual utiliza águapara amenizar altas temperaturas causados por certos processadores.


de desempenho. Isso significa, a grosso modo, saber se o programa é capaz de usarprogressivamente uma maior quantidade de processadores, implicando que os avanços datecnologia de silício e o maior número de núcleos farão o programa se manter em bomdesempenho.

2.3.1 Conceitos

A seguir, serão abordados alguns temas e conceitos de paralelismo relevantes paraeste trabalho, e posteriormente, serão discutidas as métricas básicas utilizadas na análisede algoritmos paralelos.

2.3.1.1 Threads e Processos

Um processo é basicamente um programa em execução. Associado com cadaprocesso está seu espaço de endereçamento e uma lista de locais da memória a partir deum mínimo até um máximo que o processo pode ler e gravar. O espaço de endereçamentocontém o programa executável, os dados do programa e sua pilha de chamadas. Tambémassociado com cada processo está um conjunto de registradores, incluindo o contadorde programa, o ponteiro da pilha e outros registradores de hardware e todas as demaisinformações necessárias para executar o programa (TANENBAUM; WOODHUL, 2000).Vários processos podem ser associados com o mesmo programa, por exemplo, abrindovárias instâncias do mesmo programa geralmente significa mais que um processo está sendoexecutado. Os processos normalmente se comunicam entre si pelo envio de mensagens.

Threads é uma forma de um processo dividir a si mesmo em duas ou mais tarefasque podem ser executadas concorrentemente. Uma thread possui todas as característicasde um processo, menos o espaço de endereço privado. Eles também compartilham o acessoà memória, e dessa forma, podem se comunicar com outras threads lendo ou escrevendodiretamente na memória. Esta diferença entre threads e processos está ilustrada na figura14.

A programação com threads é conhecida como programação paralela de memóriacompartilhada. Em contra partida, a programação paralela com o uso de processosé geralmente referida como programação paralela por passagem de mensagens (LIN;SNYDER, 2008).

2.3.1.2 Barreira

Um grupo de threads ou processos é iniciado igualmente em um ponto do código-fonte, porém isso não garante que todos irão alcançar o fim do código de modo igual. Issoacontece devido à alguns fatores que podem ser: a carga de trabalho dos núcleos, os quaisuns podem estar mais sobrecarregados com processos de programas ou do próprio sistema


Figura 14: Ilustração demonstrando a diferença entre processos e threads.

Fonte (ROSARIO, 2012)

operacional que outros; a carga de trabalho repartida entre as threads ou processos; ou opróprio algoritmo de escalonamento que pode ocasionar mais vantagens a uns indivíduos.Contudo, muitas vezes é necessário garantir que alguns valores de dados não sejam lidosantes de serem computados por outras threads ou processos. Por isso, necessita-se de ummecanismo de sincronização entre eles.

Uma barreira é um tipo de método sincronização para um grupo de threads ouprocessos. Qualquer thread/processo deve parar em algum ponto específico do código e nãopode prosseguir até que todos os outros alcancem esse ponto. É utilizada em aplicaçõesonde todas as threads devem completar um estágio antes de irem todas juntas para apróxima fase.

O uso de barreiras gera um tempo ocioso entre as treads/processos, pois as primeirastêm que esperar as outras alcançarem o ponto de parada (barreira), antes de continuar.Se por exemplo, núcleos distintos têm diferentes cargas de trabalho, alguns deles podemficar ociosos durante pelo menos uma parte do tempo em que os outros núcleos estãotrabalhando no problema paralelo. Isso ocorre nos casos em que núcleos têm que sincronizara execução de tarefas no código. Se por acaso algum dos núcleos ainda não tiver terminadosua respectiva parte da tarefa, aqueles que terminarem antes, deverão esperar em umestado ocioso pelo núcleo atrasado ou mais atarefado. Isso é um caso de Overhead, queserá abordado logo mais adiante.

2.3.1.3 Região Crítica

Sempre que dois ou mais processos/threads estão acessando um recurso compar-tilhado na memória, por exemplo uma variável, é possível que um processo interfira emoutro. Isso se chama condição de corrida.


Por exemplo, suponha-se que duas threads estão tentando incrementar a mesmavariável x localizada na memória. Ambas têm a seguinte linha no código-fonte:

x := x + 1.

Uma maneira para cada thread executar esta declaração é ler a variável, e emseguida, adicionar um valor unitário, e depois, escrevê-lo de volta. Suponha-se que o valorde x é 3. Se ambas as threads lerem x, ao mesmo tempo, então receberão o mesmo valor3 dentro do escopo de memória de cada um. Se for adicionado o valor 1 à variável x, asthreads terão o valor 4, e tão logo terão que escrever 4 de volta na variável compartilhadax. O resultado é que ambas as threads incrementam x, mas seu valor é 4, ao invés de 5.

Para as threads executarem corretamente, deve-se assegurar que apenas uma delasexecute a instrução de cada vez. Um conjunto de instruções que pode ter apenas umprocesso/thread e executá-lo em um momento é chamado de seção crítica.

Existem algumas soluções para esse problema, as duas mais básicas são: a possibili-dade de independência do acesso de diversas threads a uma variável, isto é, se é possívelsubstituir uma variável compartilhada por uma variável local e independente para cadathread. A outra é o uso de semáforos, ou seja, para entrar em uma seção crítica, uma threaddeve obter um semáforo, o qual é liberado quando esta sai da seção. As outras threadssão impedidas de entrar, enquanto o semáforo não for liberado. Contudo, são livres paraganhar o controle do processador e executar outro código, incluindo outras seções críticasque são protegidas por diferentes semáforos.

Embora o semáforo seja uma forma eficiente de garantir a exclusão mútua, seu usopode reduzir severamente o desempenho, principalmente se a verificação de disponibilidadede acesso estiver dentro de um laço realizada com certa frequência. A independência deacesso entre threads nem sempre pode ser implementada, mas quando é possível acabarásendo mais eficiente.

2.3.1.4 OverHead

A melhoria de desempenho de um programa computacional é o principal objetivo dacomputação paralela. Porém, existem diversos problemas que digridem a potencialidade dacomputação paralela e infelizmente, esses problemas são inerentes da mesma. Idealmente,um programa que leva um tempo T para ser executado em um processador single core,deveria ser executado em um tempo T /P , sendo P o número de processadores.

Quando se utiliza o dobro de recursos de hardware, muitos podem esperar que umprograma seja executado duas vezes mais rápido. No entanto, este raramente é o caso,devido a uma variedade de overheads gerais associados ao paralelismo (GRAMA et al.,2003).

Os overheads são provenientes da interação entre processos, threads, ociosidade e


excesso de computação. Eles são uma combinação direta ou indireta de tempo excessivodo uso de computação, de memória, de largura de banda, ou de outros recursos durantealgum objetivo computacional. Ou seja, overhead é a quantidade de tempo requerido paracoordenar as tarefas em paralelo, ao invés de fazer o trabalho útil. Overhead paralelo podeincluir fatores como:

• Tempo de criação de um processo ou thread;

• Sincronizações;

• Comunicações de Dados;

• Overhead de Software imposta por línguas paralelas, bibliotecas, sistema operacional,etc;

• Tempo de destruição de um processo ou thread.

2.3.2 Métricas de Escalabilidade paralela

O algoritmo paralelo reduz o tempo de execução sequencial, porém é importanteestudar o desempenho dos programas paralelos, entendendo até que ponto é vantajosoutilizá-los. Esse tipo de análise tem o objetivo de determinar os benefícios do paralelismoaplicados a um problema considerado, e, também, o quanto o algoritmo é capaz de continuareficiente.

Antes de discutir as métricas, é importante perceber que todo algoritmo possui umafração seqüencial e paralela. A porção seqüencial é a parte do código a qual não pode serexecutado concorrentemente e limita a aceleração dos algoritmos paralelos. Dessa forma,um algoritmo sequencial ótimo, ou seja, o seu tempo de execução é mínimo, provavelmentepossua uma fração seqüencial muito alta, portanto, não tenha perfil de algoritmo paralelo.Isto é, não tendo um bom desempenho paralelo ou até mesmo difícil ou impossível deparalelizar. Enquanto que muitos códigos sequenciais ditos como lentos ou com menordesempenho possam ser mais atrativos, possuindo uma fração paralela muito maior.

Portanto, uma série de análises deve ser realizada para que sejam efetuados ajustespara ampliar a parte paralela ou compreender se um determinado algoritmo é escalável ounão. A discussão sobre as principais métricas de algoritmos paralelos é descrita na próximasubseção.

2.3.2.1 Speedup e Eficiência

Para a análise de escalabilidade, speedup e eficiência, são consideradas as principaismétricas. O speedup S, é definido como a razão entre o tempo sequencial 10, TS e o tempo10 Tempo serial é o tempo de execução do algoritmo implementado sequencialmente.


paralelo TP .

S = TS

TP

(2.34)

O speedup diz quantas vezes o algoritmo paralelo é mais rápido que o algoritmoserial. Idealmente, dividindo o trabalho igualmente entre os núcleos, sem acréscimo detrabalho inicial, obtém-se no programa paralelo um tempo P vezes mais rápido que oprograma serial. Ou seja, S = P , logo, tP = TS

P, quando isso ocorre, chama-se de speedup

linear. Quando S < P , diz que o speedup é sublinear, e S > P , o speedup é super linear. Asuper linearidade não é algo comum, porém pode ocorrer (LIN; SNYDER, 2008).

Na prática, para obter um speedup linear existe várias complicações, porque comofoi descrito na seção anterior, o uso de vários processos/threads introduz overhead. Osprogramas de memória compartilhada quase sempre terão seções críticas, o que exigiráo uso de algum mecanismo de exclusão mútua, como um semáforo. As chamadas paraas funções do semáforo possuem um overhead que não estava presente no programaserial, e o seu uso força o programa paralelo a serializar a execução da seção crítica. Osprogramas paralelos de memória distribuída quase sempre necessitam transmitir dadosatravés da rede, que normalmente é muito mais lento do que o acesso à memória local.Programas sequenciais, por outro lado, não tem esses custos. Assim, será muito incomumque programas paralelos tenham speedup linear ou super linear. Além disso, é provávelque o overhead sofra acréscimos à medida que aumentar o número de threads, ou seja,mais threads provavelmente vai significar mais acesso a seção crítica. E, mais processos,significará provavelmente mais dados a serem transmitidos através da rede.

Muitas vezes, speedups reais tendem a saturar com o aumento do número deprocessadores. Isso ocorre porque com o tamanho do problema fixo e com o aumento denúmero de processadores, há uma redução da quantidade de trabalho por processador. Commenos trabalho por processador, custos como overhead podem se tornar mais significativos,de modo que a relação entre o tempo serial e o paralelo não melhora de forma linear(GRAMA et al., 2003). Em outras palavras, significa que S/P provavelmente vai ficarcada vez menor, a medida que P aumenta. Este valor, S/P , é chamado de eficiência doprograma paralelo. Se substituirmos a fórmula de S, a eficiência é

E = S

P=

TS

TP

P= TS

PTP

(2.35)

A eficiência é uma medida normalizada de speedup que indica o quão efetivamentecada processador é utilizado. Um speedup com valor igual a P, tem uma eficiência igual1, ou seja, todos processadores são utilizados e a eficiência é linear. E, valores acima de1 é chamado de eficiência super linear. No entanto, como dito anteriormente, existemvários fatores que degradam o desempenho de um programa paralelo, logo a eficiência


será tipicamente inferior a 1, e sempre diminui à medida que o número de processadoresaumenta.

Está claro que o speedup e a eficiência dependem do número de P, número de threadsou processos. Precisa-se ter em mente que o tamanho do problema também tem influêncianessas métricas. Por exemplo, o autor Pacheco (2011, pg. 123) em seu livro intitulado AnIntroduction Parallel Programming, cita dados de um experimento realizado, utilizandoMPI para paralelizar uma função sequencial que multiplica uma matriz quadrada por umvetor. Os testes foram realizados utilizando uma matriz de ordem 1024, 2048, 4096, 8192,16384 e com 2, 4, 8, 16 processos. A tabela 3 mostra o tempo sequencial e paralelo emmilissegundos.

Tabela 3: Tempos de execução serial e paralelo da multiplicação de matriz por um vetor.Ordem da MatrizProcessos 1024 2048 4096 8192 16384

1 4.1 ms 16.0 ms 64.0 ms 270 ms 1100 ms2 2.3 ms 8.5 ms 33.0 ms 140 ms 560 ms4 2.0 ms 5.1 ms 18.0 ms 70 ms 280 ms8 1.7 ms 3.3 ms 9.8 ms 36 ms 140 ms16 1.7 ms 2.6 ms 5.9 ms 19 ms 71 ms

Adaptado da fonte: (PACHECO, 2011)

As figuras 15 e 16 mostram o speedup e eficiência, respectivamente, do programaparalelo da multiplicação de matriz por um vetor para diferentes tamanhos de problema equantidades de processos. Como pode ser visto nas figuras, quando aumenta-se o tamanhodo problema, o speedup e a eficiência também aumentam. Percebe-se, também, que ocomportamento dos gráficos apresentados nas figuras 15 e 16 são muito comuns emprogramas paralelos. O speedup cresce com o aumento da quantidade de processos/threads,contudo tende a saturar após certo ponto. A eficiência tende a diminuir com o aumentoda quantidade de processos/threads, isso ocorre devido a própria definição de eficiênciamostrada na equação 2.35 (E = S/P ).

Muitos programas paralelos são desenvolvidos para dividir o programa sequencialentre as threads/processos, contudo, deve ser lembrado o tempo de overhead paralelo,como exclusão mútua ou comunicação. Então, TO, denotando o tempo de overhead, tem-seque:

TP = TS/P + TO. (2.36)

Além disso, quando o tamanho do problema é aumentado, o TO frequentementecresce com uma taxa bem menor que o tempo sequencial. Quando isso acontece o speedup


Figura 15: Speedup do programa paralelo de diferentes tamanhos do problema da multipli-cação de matriz por um vetor.

Adaptado da fonte:(PACHECO, 2011)

Figura 16: Eficiência do programa paralelo de diferentes tamanhos do problema da multi-plicação de matriz por um vetor.

Adaptado da fonte:(PACHECO, 2011)


e a eficiência também aumentam, devido ao aumento da quantidade de trabalho porprocessador/núcleo.

Para ter melhor entendimento sobre escalabilidade, será detalhado a lei de Amdahl,a qual, mesmo tendo sido elaborada antes da era multicore, ainda possui grande influênciana área de paralelismo.

2.3.3 Lei de Amdahl

Na década de 1960, Gene Amdahl, fez uma observação que se tornou conhecidacomo a lei de Amdahl. Ela diz, resumidamente que, a menos que praticamente todo umprograma serial seja paralelizado, o possível aumento do speedup vai ser muito limitado,independentemente do número de núcleos disponíveis. A consequência disso é que haverá umlimite onde o processamento paralelo pode ser aplicado, mesmo utilizando uma quantidadeenorme de processadores/núcleo.

O tempo de execução de um problema paralelo ideal, sem overhead, é definidocomo a soma do tempo da porção paralela do código com o tempo da porção sequencial,assim como mostra a equação abaixo:

TP = (1− P )TS + P(

TS

N

)(2.37)

onde, TP é o tempo paralelo, TS é o tempo sequencial, P é a fração paralela do código,(1− P ) é fração sequencial e N é o número de processadores.

Ao manipular a equação 2.37 e sabendo da fórmula de speedup apresentada em2.34, tem-se que:

TP = TS

[(1− P ) + P

N

]⇒ S = TS

TP

= 1(1− P ) + P

N

(2.38)

A equação 2.38 diz que, ao aumentar o número de processadores/núcleos a umaquantidade exorbitante, ou seja, N →∞, a parte paralelizável será reduzida a zero e ospeedup será:

S = 1r

(2.39)

onde, r = (1−P ), ou seja, a porção serial do código. Logo, a lei de Amdahl diz, que se umafração r do código do programa sequencial permanece não paralelizável, então o speedupnunca será melhor do que 1/r. Por exemplo, r = 1− 0, 9 = 1/10, portanto, o speedup nãopoderá ser melhor do que 10. Portanto, se um r é inerentemente sequencial, isto é, nãopode ser paralelizado, então não se pode obter um aumento de velocidade melhor que 1/r.Assim, mesmo se r é muito pequena, por exemplo, 1/100 e um sistema com milhares de


núcleos, o speedup não será melhor do que 100. O exemplo exibido na figura 17 ilustra alimitação superior aplicado ao speedup, em que não importa a adição de processadores e otamanho da fração paralela, a execução paralela não será melhorada.

Figura 17: Exemplo da lei de Amdahl.

fonte:(ROSARIO, 2012).

A interpretação dessa lei como um argumento de que a melhora do desempenho porparalelismo é limitada, não leva em consideração o tamanho do problema. Para muitos casos,aumentar o tamanho do problema faz com que a fração sequencial do programa diminua.Portanto, a duplicação do tamanho do problema pode ampliar a porção sequencial paraum tamanho irrisório, fazendo com que a maior fração do problema seja necessariamenteparalela. Outro ponto importante é que existem milhares de programas usados por cientistase engenheiros que rotineiramente obtém enormes aumentos de velocidade em sistemas dememória distribuída de grande porte (PACHECO, 2011).

2.3.4 Escalabilidade

A palavra escalável tem uma grande variedade de significados em diversas áreas.Essa palavra já foi usada ao longo do texto diversas vezes. Informalmente, a tecnologia éescalável quando ela pode lidar com problemas cada vez maiores sem perdas de desempenho.No entanto, uma definição mais formal é feita por Pacheco (2011), o qual diz que, se pudermanter o valor da eficiência constante, aumentando o tamanho do problema com a mesmataxa de crescimento do número de processos/threads, então o programa é dito escalável.

Será detalhado a seguir os dois tipos de escalabilidades existentes: Escalabilidadede Amdahl e Escalabilidade de Gustafson.


2.3.4.1 Escalabilidade de Amdahl

Suponha um programa paralelo com tamanho do problema e a quantidade deprocessos/threads fixos, assim, obtêm-se uma eficiência E. Admita agora, que aumenta-sea quantidade de processos/threads usados pelo programa. Se a eficiência E manter-seconstante com esse aumento e com tamanho do problema fixo, então esse programa é ditoescalável por Amdahl (PACHECO, 2011).

Percebe-se que para a eficiência, E = S/P , manter-se constante para diferentesvalores de P , é necessário que o speedup S cresça na mesma proporção que P com otamanho do problema fixo. Para Amdahl, quanto maior for o número de unidades deprocessamento, para um problema de tamanho fixo, maior será o speedup, já que TP serámenor. Todavia, como visto anteriormente, o speedup possui um valor máximo devido àfração serial do código.

Segundo a Lei de Amdahl, a velocidade de processamento paralelo é limitada. Elaafirma que, uma pequena porção do programa que não pode ser paralelizada limitaráo aumento de velocidade disponível com o paralelismo. A consequência é que haveráum limite onde o processamento paralelo pode ser aplicado. Os algoritmos escaláveis deAmdahl tem o comportamento ilustrado pela figura 17, isto é, há uma melhoria significativado ganho de paralelização de acordo com o número de unidades de processamento. E, issodepende, da porcentagem da porção paralela que o código possui, quanto maior é essaporção, melhor é o desempenho paralelo, melhor é o speedup. Nota-se também que, quantomenor for a porção sequencial do código, menos limitado será o speedup, podendo alcançarvalores maiores.

2.3.4.2 Escalabilidade de Gustafson

Suponha, agora, um programa paralelo com tamanho do problema e a quantidade deprocessos/threads fixos, assim, obtêm-se uma eficiência E. Admita também, que aumenta-se tanto a quantidade de processos/threads usados pelo programa como o tamanho doproblema. Se a eficiência E manter-se constante nesse cenário, então esse programa é ditoescalável por Gustafson (PACHECO, 2011).

A escalabilidade de Amdahl, não leva em conta o tamanho do problema, como foiexplicado anteriormente. Gustafson percebeu isso em seu trabalho Reevaluating Amdahl’slaw (GUSTAFSON, 1988). Comparando experimentos, notou que o speedup não estavalimitado pela parte serial do algoritmo, na realidade, o paralelismo cresceu de acordo como tamanho do problema.

Para comprovar a escalabilidade Gustafson de um algoritmo paralelo, faz-se ne-cessário aumentar o tamanho do problema e verificar o aumento da eficiência. Pois, aeficiência de um programa paralelo está intimamente conectada com a porção paralela do


código. Um exemplo de um algoritmo escalável por Gustafson é apresentando na figura 18.

Figura 18: Eficiência do programa paralelo de diferentes tamanhos do problema da multi-plicação de matriz por um vetor.

Adaptado da fonte: (PACHECO, 2011).

67

3 Revisão Bibliográfica

Esse capítulo apresenta a Revisão Bibliográfica sobre a paralelização do métodoSimplex com informações obtidas a partir da literatura científica. Ele está dividido em 3seções: a primeira, apresenta os artigos realizados antes da arquitetura multicore, usandomemória compartilhada; a segunda seção apresenta artigos mais atuais, utilizando memóriacompartilhada e, por último, uma breve explicação do que é software de otimização e citaalguns exemplos destes.

3.1 Memória DistribuídaComo já descrito na seção 2.1, o método Simplex trata-se de um procedimento

utilizado para resolver problemas de Programação Linear, criado em 1947 por Dantzig.Desde então, sofreu diversas modificações e tem sido usado amplamente por programadorese profissionais de diferentes setores da indústria, assim como, nas áreas da saúde, logísticae transporte, estatística e gestão financeira.

A aplicação do processamento paralelo com o método Simplex para a programaçãolinear tem sido considerado desde o início da década de 70 e se intensificando ainda maisna década de 90 (PLOSKAS; SAMARAS; SIFALERAS, 2009). Como justificativa para talcomportamento tem-se rápido crescimento do poder computacional, principalmente dodesenvolvimento das máquinas paralelas.

Eckstein et al. (1995) descrevem 3 implementações paralelas do Simplex paraproblemas densos de PL, aplicados a um computador SIMD. A primeira usa o SimplexTableau com a regra do menor custo do valor negativo dos coeficientes da função objetivopara a escolha do pivô; a segunda utiliza o algoritmo steepest-edge1 para escolha do pivô,também para o Tableau; e por último, a paralelização do método revisado. Todas asimplementações são realizadas na Máquina de Conexão CM-2(Connection Machine CM-2).O trabalho descreve a comparação entre essas implementações e também utiliza um softwarede otimização chamado MINOS versão 5.4 em uma máquina sequencial produzida pelaSun Microsystems chamada Sun SPARCStation 2. A máquina SPARCStation é da mesmaépoca que foi desenvolvido o CM-2 e possui o mesmo poder de processamento de umaúnica unidade vetorial de processamento da máquina paralela. Os problemas de teste sãoretirados do Netlib2, e também são adicionados alguns problemas densos de aplicações reais.1 A regra de Dantzig normalizada, ou steepest-edge, consiste em escolher uma variável que tenha o

coeficiente normalizado mais negativo. Para escolher qual variável irá entrar na base deve-se primeironormalizar os coeficientes, e depois, escolher a mais negativa. Dessa forma, é possível encontrar emmenos iterações a solução ótima.

2 O repositório Netlib contém software disponível gratuitamente, documentos e bases de dados de

68 Capítulo 3. Revisão Bibliográfica

O tableau paralelo com a regra Steepest-edge obteve o melhor resultado, conseguiu ser 20vezes mais rápido que as duas outras implementações. O simplex tableau paralelo de menorcusto foi mais eficiente que o algoritmo Simplex do MINOS. Já o algoritmo revisado paralelocomparado com o tableau paralelo sem o steepest-edge foi cerca de 1.5 vezes mais rápido.Esse trabalho mostrou que o CM-2 pode render tempos de execução paralela melhor doque uma estação de trabalho que executa o mesmo algoritmo equivalente sequencialmente.Com os resultados, percebe-se que independentemente do algoritmo, problemas difíceis,de grandes escalas e densos, são mais viáveis quando resolvidos paralelamente, pois estesapresentam melhor resultado que seu algoritmo sequencial.

Outro trabalho envolvendo computadores SIMD, mais potentes quando comparadosao CM-2, foi desenvolvido por Thomadakis e Liu (1996). Eles propuseram um algoritmodo simplex paralelo escalável baseado no tableau e na regra steepest-edge para seleçãodo pivô. O algoritmo foi desenvolvido, utilizando todas as especificidades das máquinasmassivas paralelas MasPar 1 (MP-1) e MasPar-2(MP-2). Uma versão sequencial do simplexsteepest-edge foi implementada no servidor Unix Sun SPARC 1000 para efeitos de compa-ração. Em termos de desempenho, os experimentos mostraram que o algoritmo paralelodo simplex proposto executado no MP-2, com 128 x 128 elementos de processamento,alcançou um speedup de ordem 1.000 para 1.200 vezes maior que a versão sequencial.Enquanto que, no MP-1, com 64 x 64 elementos de processamento, teve ordem de 100vezes mais rápido. Este trabalho também analisou a escalabilidade fixando a quantidadede processadores e aumentando o tamanho de linhas ou colunas. Com sucesso, os autoresconseguem demonstrar que à medida que aumenta o tamanho do problema o speedupcresce, demonstrando a escalabilidade da implementação.

O trabalho desenvolvido por Hall e McKinnon (1998), utiliza um computadorMIMD3. Hall e McKinnon descrevem um variante assíncrono do método Simplex revisado,o qual é adequado para implementação paralela em um multiprocessador com memóriacompartilhada ou, em um computador MIMD com uma rápida comunicação entre osprocessadores. A implementação deste algoritmo é realizada na Cray T3D, uma máquinaque possui uma grande taxa de comunicação comparada com a computação. Isso énecessário para alcançar um bom speedup quando esse método assíncrono é usado emmemória distribuída. Um dos objetivos dessa implementação é permitir que processosoperem de uma maneira assíncrona, ou seja, o máximo de independência possível e umresultado dessa execução é que diferentes processos podem trabalhar com diferentes basesao mesmo tempo. Neste trabalho os experimentos computacionais no Cray T3D foramrealizados utilizando quatro problemas do Netlib. O método Simplex sequencial com a regra

interesse para a computação científica, numérica e outras comunidades. O repositório é mantido pelaAT & T Bell Laboratories, da Universidade do Tennessee e Oak Ridge National Laboratory.

3 Relembrando o capítulo 2.2, MIMD Refere-se aos sistemas paralelos de natureza assíncrona, ou seja,as instruções são geradas por unidades de controle diferentes e cada processador executa sua instruçãono seu próprio dado.

3.2. Memória Compartilhada 69

steepest-edge para escolha do pivô foi implementado em um computador Sun SPARCstation5, utilizando o ERGOL4 versão 1.2. Os resultados demonstraram um bom speedup entre 2.5e 4.8 para os quatro problemas. Segundo os autores, é possível implementar esta varianteem processadores de memória compartilhada com certa facilidade. Contudo, a performancenão pode ser garantida a menos que a memória cache seja capaz de armazenar os dadosque são acessados a cada iteração.

As máquinas paralelas foram produzidas a partir da década de 70 e eram caracteri-zadas pelo custo elevado e pela dificuldade de programação. O programador necessitavater o conhecimento específico de cada máquina paralela para a qual seriam implementadasas aplicações paralelas, o que aumentava a complexidade do desenvolvimento do programa.Além disso, desde meados de 2000, vem acontecendo uma mudança de paradigma, ondeos computadores não estão sendo produzidos com apenas um núcleo de processamento.Esta tendência tem sido chamada de Era Multicore, detalhado por Kock e Borkar (KOCH,2005; BORKAR, 2007) e explicado na seção 2.3.

3.2 Memória Compartilhada

Muitas das pesquisas desenvolvidas tiveram como foco o método revisado dosimplex, devido a vantagem de resolver problemas esparsos5 e, sendo, mais eficiente paraproblemas em que a quantidade de variáveis é bem maior que a quantidade de restrições(YARMISH; SLYKE, 2003). Contudo, o método revisado não é muito adequado para aparalelização (HALL, 2010).

Em 2009, Yarmish e Slyke (2009) apresentaram uma implementação distribuída doSimplex padrão para problemas de grande escala de programação linear. Nos experimentosfoi utilizado um laboratório com 7 estações de trabalho independentes conectados pelaEthernet. Para comparar com a aplicação paralela proposta, foi utilizado o método simplexrevisado do pacote de otimização MINOS. Um conjunto de testes foi elaborado com 10problemas de 1000 variáveis e 5000 restrições variando a densidade da matriz de restriçõesde 5% até 100% e foi constatado que o Simplex padrão paralelo proposto não é afetado pelavariação da densidade do problema. Além do mais, quando usa-se 7 processos é comparávelcom o método revisado sequencial com 10% de densidade, pois quanto menor a densidade,mais eficiente será o método revisado. Assim, pelo modelo matemático desenvolvido nestetrabalho, se houvesse a possibilidade da utilização de 17 processos, o algoritmo paraleloproposto seria equivalente ao método revisado sequencial com menos de 10% de densidade.Logo, é possível construir uma versão eficiente paralela do método padrão, considerandoque o método revisado é difícil de paralelizar.

4 ERGOL é um software de otimização da IBM5 Um problema é dito esparso, quando a maioria dos elementos de sua matriz de restrições são nulos.


Um outro trabalho produzido no mesmo ano, desta vez, por Ploskas, Samaras eSifaleras (2009) mostraram a implementação paralela do algoritmo do Simplex, usandoum computador pessoal de dois núcleos. Nesta abordagem, a base inversa é calculadaem paralelo, a matriz que contém a base é distribuída entre os processos e o cálculo érealizado mais rapidamente em problemas de grande escala de PL. Além da implementaçãoparalela, este trabalho apresenta um estudo computacional que mostra o speedup entre aversão serial e o paralelo em problemas PL densos gerados aleatoriamente. A comparaçãocomputacional foi realizada em um computador com processador Intel Core 2 Duo T5550,2 núcleos, 2MB de cache, 1.83 GHz, com 3Gb RAM executando a edição do WindowsProfessional XP 32-bit SP3. O algoritmo foi implementado usando a edição MATLABR2009a 32-bit Professional. Foram criados 6 problemas de tamanhos diferentes, para cadaproblema, 10 instâncias foram geradas, utilizando um número de semente distinta. Todasas instâncias foram geradas aleatoriamente, executando 5 vezes cada instância e todas asocorrências foram em média 98% densas. O melhor speedup adquirido com a paralelizaçãoda base inversa foi em torno de 4,72. Devido às matrizes muito densas e muita comunicação,a relação de computação para a comunicação foi extremamente baixa e como resultado aimplementação paralela não ofereceu speedup para o tempo total.

Nota-se que todos os trabalhos relacionados a esse tema apresentam diferentesformas de paralelizar o Simplex, buscando a melhor eficiência possível. Porém, é necessárioque os algoritmos paralelos possam ir além da melhor eficiência, pois devido a Era Multicoretem-se a cada ano um aumento exponencial do número de processadores (BORKAR, 2007).Logo, é importante que tais algoritmos acompanhem esse crescimento sem que hajarepetidas mudanças no código, ou seja, analisar a escalabilidade com diferentes númerosde núcleos, variando a dimensão do problema.

3.3 Softwares de Otimização

Um software de otimização é software matemático na área de otimização sob a formade um programa desktop ou fornecendo uma biblioteca contendo as rotinas necessárias pararesolver um problema matemático. Alguns tipos de problemas matemáticos que podem serresolvidos por esses softwares são: programação linear e não-linear, programação inteira,programação quadrática e outros.

Existem vários softwares de otimização, os quais variam: o tipo de licença, pro-prietário ou código livre, as linguagens de programação para qual os desenvolvedorespodem incorporar em seus próprios programas, e os tipos de problemas matemáticos quepodem ser resolvidos. Nessa sessão serão apresentados dois softwares, o CPLEX R© da IBM(utilizado nesse trabalho) e o COIN-OR( Computational Infrastructure for OperationsResearch), um repositório para projetos de código livre na área de softwares matemáticos.

3.3. Softwares de Otimização 71

3.3.1 IBM ILOG CPLEX Optimization

IBM R© ILOG R© CPLEX R© Optimization é uma ferramenta da IBM para resolverproblemas de otimização. Cplex foi escrito por CPLEX Optimization Inc., que foi adquiridapela ILOG em 1997 e a ILOG foi posteriormente adquirida pela IBM em janeiro de 2009.Atualmente, continua sendo desenvolvido pela IBM e reconhecido como uma das melhoresferramentas para otimização, conquistando o INFORMS Impact Prize em 2004 (LOWE,2013).

CPLEX R© oferece bibliotecas em C, C++, Java, .Net e Python. Especificamente,resolve problemas de optimização linear ou quadrática, ou seja, quando o objetivo a serotimizado pode ser expresso como uma função linear ou uma função quadrática convexa.O CPLEX R© Optimizer é acessível através de sistemas de modelagem independentes, comoAIMMS, AMPL, GAMS, AMPL, OpenOpt, OptimJ e Tomlab.

O IBM R© ILOG R© CPLEX R© consiste nos seguintes otimizadores: otimizador CPLEX R©

para programação matemática; otimizador IBM R© ILOG R© CPLEX R© CP para a programa-ção com restrições; Optimization Programming Language (OPL) (Otimização de Linguagemde Programação), o qual fornece uma descrição matemática natural dos modelos de otimi-zação e uma IDE totalmente integrado (CPLEX. . . , 2013).

O IBM R© ILOG R© CPLEX R© Optimizer resolve problemas de programação quadrática(PQ) convexa e não-convexa, de programação inteira e problemas de programação linear(PL) de grande escala, utilizando tanto as variantes primal ou dual do método Simplex,ou o método de ponto interior (barrier).

O CPLEX R© pode utilizar de multiprocessamento para melhorar o desempenho. Ootimizador concorrente (concurrent optimizer) dessa ferramenta lança diferentes PL e PQotimizadores em várias threads. Se disparar somente uma thread, o CPLEX R© funciona deforma automática, da mesma forma que sequencialmente, ou seja, escolhe qual otimizadorserá utilizado dependendo do tipo do problema. Se uma segunda thread estiver disponível,o otimizador concorrente executa o otimizador barrier. Se uma terceira ocorrer, todas ostrês otimizadores serão executados ao mesmo tempo: dual Simplex, primal Simplex e obarrier. Acima de três threads todas elas são dedicadas à paralelização do método barrier.

Percebe-se que o CPLEX R© utiliza um algoritmo para otimizar a solução usandovários otimizadores concomitantemente, para obtenção do melhor tempo possível. Contudo,não possui uma rotina que paralelize somente um único método, impossibilitando, assim,uma comparação mais concisa com o algoritmo paralelo proposto.

3.3.2 COIN-OR

COIN-OR significa, em português, Infra-estrutura Computacional para PesquisaOperacional. Trata-se de um repositório dedicado a software de código aberto para a


comunidade de pesquisa operacional. Hospedado pelo INFORMS, o site COIN-OR é ocomporta vinte e cinco projetos e uma comunidade crescente composta de aproximadamente2.003 assinaturas (COIN-OR, 2007). Ele incentiva novos projetos, fornecendo um extensoconjunto de ferramentas e suporte para o desenvolvimento de projetos colaborativos edesde 2004, tem sido gerido pela fundação COIN-OR sem fim lucrativos.

O repositório COIN-OR foi lançado como um experimento em 2000, em conjuntocom o 17o Simpósio Internacional de Programação Matemática em Atlanta, Geórgia. Dentreos projetos tem-se: ferramentas para programação linear, como CLP (COIN-OR LinearProgramming); programação não-linear como COIN-OR IPOPT(Interior Point Optimizer);programação inteira, como CBC (COIN-OR Branch and Cut) e outros (COIN-OR. . . ,2013).

CLP (COIN-OR LP) é um software de código-aberto para programação linearescrito em C++. Seus principais pontos fortes são seus algoritmos Dual e Primal Simplex.Existem, também algoritmos para resolver problemas não-lineares e quadráticos. O CLPestá disponível como uma biblioteca e como um programa standalone6.

Existem também aplicações paralelas no COIN-OR. Algumas são: o projeto CHiPPS(COIN-OR High Performance Parallel Search Framework), uma estrutura para a construçãode algoritmos de árvore de busca paralelos; BCB, (Branch-Cut-Price Framework) que éuma estrutura paralela para a implementação Branch-Cut-Price - método para resolverprogramas inteiros mistos; e PFunc (Parallel Functions), que é uma biblioteca leve eportátil que fornece APIs em C e C++ para expressar paralelismo em tarefas. Contudo,nenhum dos projetos ainda, não possui um Simplex padrão paralelo para realizar umacomparação com o algoritmo paralelo proposto.

6 São chamados standalone, os programas completamente auto-suficientes, ou seja, para seu funciona-mento não necessitam de um software auxiliar sob o qual terão de ser executados.

73

4 Algoritmo Simplex Multicore

Nesse capítulo será apresentado a metodologia utilizada, abordando inicialmente aideia geral de como o algoritmo simplex padrão na forma tabular (tableau) foi paralelizado.Logo em seguida, será apresentada a Implementação do algoritmo Simplex Multicoreem OpenMp, detalhando cada etapa. Além de mostrar a conexão entre os conceitos deparalelismo e o Simplex tableau.

4.1 Esquema Geral da Paralelização

O algoritmo paralelo proposto por esse trabalho é baseado no simplex tableauapresentado na seção 2.1.3. Esse algoritmo é composto por seis etapas como pode ser vistona figura 19.

Figura 19: Fluxograma do algoritmo Simplex Multicore.


A primeira etapa consiste em elaborar a tabela inicial do Simplex com todas asrestrições e variáveis, observando que o problema de programação linear deve estar naforma padrão. A segunda etapa deve paralelizar a seleção da coluna que tiver menorvalor negativo dos coeficientes da função objetivo - teste de otimalidade. A terceira etapadeve paralelizar a seleção da linha que tiver menor valor do quociente da equação 4.1,

74 Capítulo 4. Algoritmo Simplex Multicore

apresentado na seção 2.1.3 - teste da razão.

xsB = minyk

i

{B−1b

yki

, yki > 0

},∀i ∈ I | I = [1 m] (4.1)

A quarta etapa consiste em paralelizar a multiplicação da linha pivô por 1yp. A

quinta etapa paraleliza a operação elementar em todas as linhas das restrições, exceto aslinhas do pivô e da função objetivo, como demonstrado na equação 4.2, apresentado naseção 2.1.3:

li = li − yplp, ∀i ∈ I | I = [1 m]. (4.2)

A sexta etapa é um melhoramento que foi feito no algoritmo, na qual são paraleliza-das três operações simultaneamente: a atualização da linha da f.o. a partir da equação 4.2;a realização do teste de otimalidade e a contabilização de quantos coeficientes negativosexistem na linha que representa a f.o.

Percebe-se que a etapa I não é paralelizada, porque consiste em estruturar oproblema inicial na forma da tabela inicial do simplex. Após ter essa tabela montada, éque são iniciados de fato os passos do simplex a serem paralelizados.

A etapa II contém um laço paralelizado, isto é, cada thread é responsável porselecionar localmente a coluna que tenha o menor valor negativo da linha da funçãoobjetivo a partir de um conjunto de coeficientes. Ao terminar sua tarefa, cada tread terá acoluna que corresponde ao valor negativo mínimo do seu conjunto de trabalho. Depois disso,é necessário selecionar quais das threads possuem a coluna com o menor valor negativo.Para isso, é preciso que as threads comparem entre si suas colunas selecionadas, fazendouso de uma variável global ou compartilhada, isto é, uma variável que todas tenham acesso.Essa variável terá o índice da coluna de menor valor entre todas as threads, e cada umadeverá comparar se o valor da coluna armazenada internamente é menor que a variávelcompartilhada, caso positivo deverá escrever seu valor. Observe que, como esclarecido naseção 2.3.1, isso deve ser tratado como uma seção crítica, portanto apenas uma thread porvez poderá fazer a comparação e escrever na variável global. Em sequência, existe umabarreira para assegurar que todos as threads tenham entrado na seção crítica antes deseguir para o próximo passo.Observa-se que, uma única thread é utilizada para atualizaralgumas variáveis de controle, liberando, dessa forma, as outras threads para seguir para apróxima etapa.

Na etapa III, seleciona-se localmente, a linha que tenha o menor quociente e utiliza-se uma região crítica para selecionar o índice da linha global, da mesma maneira queacontece no passo II. Uma barreira sincroniza as threads para assegurar que todas elastenham entrado na seção crítica antes de continuar as etapas seguintes. Além disso, antes

4.2. Implementação do Algoritmo Simplex Multicore 75

da etapa IV é necessário definir quem é o pivô, assim, para que as threads não avancemsem antes assegurar que todas tenham o pivô correto, uma outra barreira é posta antesda etapa IV. O pivô é definido a partir linha e a coluna global selecionadas nas etapasanteriores.

O laço paralelo da etapa IV atualiza a linha do pivô. Cada thread é responsável poratualizar um conjunto de coeficientes da linha do pivô. Para prosseguir, é necessário queesta etapa seja concluída, porque os valores desta linha são utilizados no próximo passo,portanto, precisa-se de uma barreira.

A etapa V é um laço paralelizado para a atualização das linhas de restrição restantes,ou seja, cada thread é designada para um conjunto de linhas (exceto a linha do pivô), paramodificá-las utilizando a equação 4.2. Ao terminar as tarefas, cada thread pode ir paraa próxima etapa sem ter que esperar pelas outras, pois o próximo passo é independentedesta etapa.

A etapa VI utiliza o mesmo laço paralelizado para realizar três operações, ou seja,cada thread terá como carga de trabalho um conjunto de coeficientes da f.o. para executaras três operações. Inicialmente, será atualizada a linha da função objetivo a partir daequação 4.2. Em seguida, é selecionada localmente a coluna com o menor valor negativoda linha objetivo, como é feito na primeira parte do passo II; e finalmente, contabilizar osvalores negativos da linha objetivo. Vale ressaltar que o critério de parada do algoritmo ésatisfeito quando não existir nenhum valor negativo na f.o.. Logo após essa etapa, paragarantir a contagem correta, é necessário uma barreira, se o critério de parada não foralcançado, o ciclo reinicia na seção crítica da segunda etapa para selecionar a colunaglobal.

Observe a sincronização entre os passos, pois eles são dependentes uns dos outros.Por exemplo, o passo III só pode ser realizado se o índice da coluna é definido, o que érealizado no passo II. O passo IV, precisa do pivô, isto é, a coluna selecionada no passoII e a linha selecionada no passo III. E o passo V necessita da linha pivô atualizada.Complementando, na sincronização das seções críticas, tem-se muito tempo de overhead, oque pode prejudicar a execução paralela do algoritmo proposto. Contudo, note que, todasas sincronizações que foram utilizadas são indispensáveis para a corretude do algoritmo.Na próxima seção, será detalhada a implementação paralela.

4.2 Implementação do Algoritmo Simplex Multicore

A paralelização foi feita em C++ utilizando OpenMP (Open Multi-Processing), oqual utiliza um modelo fork(bifurcar) e join(unir). Existe um fluxo de execução principalchamado master thread, quando uma seção paralela é encontrada, threads são disparadas(fork) conforme necessário. Todas as threads começam a executar o código dentro daquela


seção paralela e ao fim da seção é feito um join, conforme listra a figura 20.

Figura 20: Diagrama do funcionamento do OpenMp.


O OpenMp utiliza diretivas de compilador para especificar o comportamento doprograma ao processar alguma entrada. A diretiva #pragma omp parallel declara umaseção paralela, criando threads como mostrado na figura 20. A criação das threads requerum tempo extra, o qual foi visto na seção 2.3.1, o qual é chamado de overhead. As diretivasutilizadas para dividir o trabalho nessa implementação somente funcionam dentro da seçãoparalela.

Parte do pseudo-código da implementação paralela simplex padrão pode ser vistonas figuras 21 e 22.

Figura 21: Primeira parte do código paralelo.


Figura 22: Segunda parte do código paralelo.

Percebe-se que as threads são disparadas no início para evitar repetição de overheadde criação e destruição de threads (linha 1; figura 21). Para efeito de otimização do código,a primeira parte da etapa II é executada antes do começo do laço (linhas 4-7; figura 21).Percebe-se ainda na primeira linha, que é possível selecionar o escopo de cada variável doprograma que irá ser paralelizado. O OpenMp tem 6 tipos diferentes de escopo, são eles:

Shared: Os dados dentro de uma região paralela são compartilhados, o que significavisível e acessível por todas as threads em simultâneo.

Private: Os dados em uma região paralela são individuais para cada thread. Com esterecurso cada thread terá uma cópia local e será utilizada como uma variável tempo-rária. Uma variável não é inicializada e o valor não é mantido para o uso fora daregião paralela;

Firstprivate: É um escopo como o private, exceto ao inicializar pelo valor original;

Lasprivate: Também semelhante ao private, exceto que o valor original é atualizadodepois da construção.

Default: Permite ao programador declarar o escopo padrão para os dados os quais serãoutilizados pelas threads.

None: Força o programador a declarar cada variável na região paralela utilizando ascláusulas atribuídas ao compartilhamento de dados.


A cláusula #pragma omp for (linha 4;figura 21), divide o intervalo de iteração dolaço entre as threads automaticamente. Esse intervalo do laço se dá a partir do primeiroelemento das colunas até qtd_col, isto é, até o último elemento. Por padrão no OpenMp,existe uma barreira implícita que sincroniza todas as treads ao final de um laço paralelizadocom #pragma omp for. Ou seja, somente, depois de todas as threads executarem seustrabalhos é que elas continuarão no resto do código do programa. Porém, é possíveladicionar uma cláusula na diretiva de tal forma que possa alterar o seu comportamento. Aclaúsula nowait, é usada a fim de eliminar uma barreira. E, no caso da linha 4, não hánecessidade de sincronização após a conclusão das tarefas de cada thread.

A segunda parte da etapa II é encontrar o índice global da coluna entre as soluçõesencontradas por cada thread. Como já foi explicado anteriormente, esta é uma seção críticae para resolver esse problema o OpenMp possui uma diretiva chamada #pragma ompcritical (linha 10; figura 21). Essa diretiva garante que todo o código executado dentrodo seu escopo, somente é executado por uma thread por vez. Por tanto, irá assegurar queapenas uma thread poderá fazer a comparação e escrever na variável global (pivo_col) porvez.

A diretiva #pragma omp barrier (linha 12; figura 21) cria uma barreira de sin-cronização para certificar que todas as threads tenham entrado na seção crítica antesde continuar. Isso garante que a variável pivo_col seja correto. A diretiva #pragma ompsingle é usada para que somente uma thread execute o código contido dentro do escopo,nesse caso, para atualizar algumas variáveis de controle (linhas 13-14; figura 21). O ompsingle também possui uma barreira implícita e a cláusula nowait, serve para que asoutras threads não precisem esperar pela única thread no interior do single.

A terceira etapa divide um conjunto de linhas para cada thread o qual encontra,localmente, a linha que tem menor valor do quociente (linhas 17-26; figura 21). O intervalodesse laço começa a partir da primeira linha até a última (qtd_lin). Note que a primeiraparte dessa etapa não precisa de barreira, igualmente como ocorre na primeira etapa dopasso II.

Retomando a equação 4.1, perceba que, como B−1 é uma matriz identidade, logoB−1b = b. E, yk

i é o coeficiente da linha i da coluna da variável não-básica k selecionadapara entrar na base. Ou seja, é o coeficiente da coluna do pivô, da linha i. Em outraspalavras, a equação 4.1, também pode ser reescrita como (linha 19-20; figura 21):

xBs = min

{tabela[i][ultima_col]tabela[i][pivo_col] , tabela[i][pivo_col] > 0

},∀i ∈ I | I = [1 m], (4.3)

Onde: ultima_col é o índice da última coluna; tabela[i][ultima_col] é o valor da constantedo lado direito indexado pelo índice i, também chamado de valor independente; tabela éuma matriz que contem os coeficientes das restrições, cada linha se refere a uma restrição e


cada coluna se refere a uma variável; i é o índice da linha; e pivo_col é o índice da colunado pivô.

A cláusula reduction (linha 16; figura 21) faz uma cópia local da variável invalidos

em cada thread. Ao término da tarefa de cada thread, os valores das cópias locais sãoresumidos (reduzido) para uma variável compartilhada global no final do laço. Note queessa variável somente é incrementada se tabela[i][pivo_col] < 0, caso contrário deve-secalcular o quociente da linha 19.

Observe o uso da diretiva #pragma omp critical (linha 27; figura 21) para en-contrar globalmente o índice da linha entre as threads. O índice encontrado será a linhado pivô (pivo_lin). Em seguida, existe uma barreira (linha 29; figura 21) que serve paragarantir que pivo_lin tenha o valor correto, não prejudicando o valor final do pivô. O#pragma omp single nowait da linha 30 (figura 21) serve para atualizar algumas variá-veis e, principalmente, para testar se todos coeficientes da coluna do pivô são negativos(invalidos == qtd_lin (linha 32; figura 21)), pois, se for o caso, o programa deve parar,indicando que não há solução ótima e o método simplex não pode continuar.

A segunda barreira (linha 36; figura 22) é para garantir que todas as threads tenhamo mesmo valor de pivô antes de continuar para a próxima etapa. Note que o pivô é oelemento da tabela de restrições indexado por pivo_lin e pivo_col

A quarta etapa paraleliza a divisão da linha pelo pivô (linhas 38-41; figura 22).Percebe-se que existe uma barreira implícita após a execução do laço, isso é necessário jáque, os próximos passos necessitam dessa linha normalizada pelo pivô.

O passo V (linhas 43-49; figura 22) é responsável por atualizar as restrições restantes,utilizando a fórmula apresentada nas linhas 47 à 49 que é a mesma em 4.2. Note a presençada cláusula nowait na diretiva #pragma omp for.

O último passo consiste em três operações no mesmo laço: a modificação da últimalinha usando a mesma fórmula utilizada no passo anterior (linhas 54-56; figura 22); seexistir algum valor negativo na f.o., então deve-se selecionar a coluna com o elementonegativo de menor valor na linha objetivo (linhas 57-59; figura 22), isto é, a mesmaoperação que é feita na primeira parte do passo II; e um incremento da variável conta

(linha 60; figura 22). Note ainda, a ausência da cláusula nowait, ou seja, a presença dabarreira implícita.

Observe a presença da cláusula reduction (linha 51; figura 22) para somar todosos coeficientes negativos da f.o. e atribuir esse valor para a variável conta. No final (linha63) tem-se o teste para o critério de parada. Se houver quaisquer números negativos nalinha objetivo, o algoritmo continua, retornando para o critical da linha 10 (figura 21).No caso, basta a variável conta ter algum número positivo.

Percebe-se que, não é tão simples implementar um algoritmo paralelo. Para que o


programador possa extrair o máximo de desempenho de sua aplicação, ele deverá estarsempre atento aos conceitos de paralelismo, como: regiões críticas, barreiras, overhead desincronização e de criação/destruição de threads, regiões de código que possuem ou nãodependência, e configuração de escopo de variáveis. Aprofundar-se na linguagem utilizadae nas diretivas de compilador, também é importante para otimizar o código paralelo omáximo possível.

No próximo capítulo serão apresentados os resultados adquiridos com essa aplicação,bem como a análise de speedup e de escalabilidade.

81

5 Experimentos e Resultados

Para realização dos experimentos, o computador usado possui dois AMD Opeteron6172 com 12 cores 2.1Ghz, 16 GB DDR3 RAM, 12 x 64KB de cache L1, 12 x 512 KB L2 e2 x 6 MB L3, contendo a versão Ubuntu 12.04.1 LTS. Para gerar o conjunto de problemasde PL utilizados nos experimentos foi necessário montar a tabela inicial representada natabela 4:

Tabela 4: Tabela InicialVNB + VB Lado direito

VB A bZ −c 0

Onde A é a matriz de restrições, c é o vetor de coeficientes da função objetivo e b é ovetor dos valores independentes. A fim de gerar os problemas de teste foi implementado noOctave1 um método em que os valores de A, c e b eram gerados com números aleatórios.Reforça-se que, a quantidade de linhas de um problema se refere ao número de restriçõese a quantidade de colunas, ao número de variáveis. As dimensões dos problemas foramos seguintes: 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096. O número de linhas eo de colunas dos problemas foram definidos pela combinação desses números e cadaproblema foi gerado 5 vezes com diferentes dados, assim, obtendo 405 (9 * 9 * 5) problemas.Por exemplo, o problema 256x256 tem 5 diferentes instâncias: 256x256_1, 256x256_2,256x256_3, 256x256_4, 256x256 _5, e todas elas possuem valores diferentes. O tempo deexecução é a média dessas instâncias.

5.1 Análise de Speedup

A figura 23 mostra o tempo sequencial do método Simplex padrão na forma tabulare do algoritmo do Simplex do CPLEX R© com o número fixo de variáveis e variando aquantidade de restrições. A quantidade de iterações do algoritmo Simplex padrão teve queser limitada em 5000, devido ao alto tempo gasto para encontrar a solução dos problemasde grande escala. Acima de 1536 variáveis, o Simplex Padrão chegou ao limite de iterações,logo para não prejudicar a comparação com o CPLEX R©, as curvas de desempenho doSimplex Padrão para esses problemas não foram apresentados. Assim, não se exibe o1 GNU Octave é uma linguagem de alto nível interpretada, principalmente para cálculos numéricos. Ele

fornece recursos para a solução numérica de problemas lineares e não lineares, e também realiza outrostipos de experimentos numéricos. A linguagem Octave é bastante semelhante ao Matlab R© fazendocom que alguns programas e scripts de ambas ferramentas sejam compatíveis.

82 Capítulo 5. Experimentos e Resultados

desempenho do Simplex padrão para os gráficos dos problemas com 1536 até 4096 variáveisda figura 23.

Figura 23: Tempo sequencial do algoritmo Simplex e o Simplex do CPLEX R©, fixando-se onúmero de variáveis.

Note que o CPLEX R© é mais rápido que o Simplex Padrão. Como visto na seção3.3.1, o CPLEX R© utiliza de algoritmos mais otimizados e técnicas refinadas para adquirirmelhor desempenho.

A figura 24 mostra o tempo sequencial do Simplex padrão e do algoritmo do Simplexdo CPLEX R© com o número fixo de restrições, variando a quantidade de variáveis.

Figura 24: Tempo sequencial do algoritmo Simplex padrão e o Simplex do CPLEX R©,fixando-se o número de restrições.

Assim como na figura 23, o CPLEX R© tem melhor tempo sequencial em todos osgráficos. Note que a curva de desempenho do algoritmo Simplex padrão está exibida até

5.1. Análise de Speedup 83

1024 variáveis, pois acima desse valor o Simplex alcança o limite de iterações. O CPLEX R©

se mostra com menor tempo em todos os gráficos.

Um dos motivos para o CPLEX R© ter melhor desempenho é que precisa de menositerações do que o Simplex Padrão para encontrar a solução. O CPLEX R© ultrapassou olimite de iterações somente quando a quantidade de variáveis é de 4096.

A figura 25 mostra o tempo sequencial do algoritmo Simplex do CPLEX R©. Percebaque para problemas com mais restrições que variáveis o tempo de execução é bem menor.Como por exemplo, o problema com 512 variáveis e 3072 restrições tem tempo de execuçãomenor que seu oposto. Note, também que o CPLEX R© resolveu os problemas com poucasrestrições e mais variáveis de forma mais eficiente.

Figura 25: Tempo sequencial do algoritmo Simplex do CPLEX R©.

O algoritmo Simplex paralelo proposto teve seu desempenho comparado ao doCPLEX R©, em virtude deste ter apresentado melhor performance para resolução dosproblemas. Isso já era esperado, visto que o CPLEX R© trata-se de uma ferramenta parasolução de problemas de otimização conhecido comercialmente. Dessa forma, ele serviráde referência para verificar a escalabilidade e eficiência do algoritmo paralelo. Para efeitode complemento, essas comparações de desempenhos também serão feitas nas mesmascondições para o algoritmo Simplex Padrão.

As figuras 26, 27, 28, 29, 30 apresentam os gráficos dos speedups de 2, 4, 8, 16e 24 threads, respectivamente. Note que para 2 threads existe uma super linearidadeultrapassando 2 unidades. Isso ocorre para alguns problemas acima de 2048 variáveis.Principalmente, para os problemas em que há mais variáveis que restrições. Para 2 threads,o speedup chegou 5.4, indicando que o algoritmo paralelo proposto chegou a ser 5.4 vezesmais rápido que o CPLEX R©.

O gráfico 27 possui curvas semelhantes com as apresentadas na figura 26, contudo


Figura 26: Speedup para 2 threads.

Super linear


Super linear


9.5Super linear

5.1. Análise de Speedup 85


14


14

possui um speedup ainda maior. Para o problema 2048 restrições com 4096 variáveis,obteve-se um speedup de 9.5, mostrando que para 4 threads o algoritmo paralelo foi 9.5vezes mais rápido que o CPLEX R©. Perceba, também, que para a maioria dos problemasacima de 2048 variáveis, o speedup é maior que 4. Isso apresenta a super linearidade paraesse gráfico.

O gráfico 28 também apresenta uma super linearidade e consegue ser até 11 vezesmais rápido que o CPLEX R©. O gráficos 29 e 30 não tem super linearidade, contudo emambos os gráficos, o algoritmo paralelo é 14 vezes mais rápido que o CPLEX R©.

Nota-se outras características importantes nesses gráficos. Primeiro, que à medidaque se aumenta a quantidade de threads, o speedup também cresce, o que é normal emsistemas paralelos (ver subseção 2.3.2.1). Segundo, para os problemas com mais variáveisque restrições, o CPLEX R© não teve uma boa performance, enquanto que o algoritmoparalelo apresentou ser melhor. E, por fim, existe uma queda no speedup em todos osgráficos, as possíveis causas dessa queda de desempenho serão discutidas na próxima seção.


5.2 Análise da escalabilidadeTodos os problemas foram executados usando a implementação paralela proposta

com 2, 4, 8, 16 e 24 threads. O tempo de execução é a média entre os tempos de execuçãodos 5 problemas do mesmo tamanho.

As figuras 31, 32, 33, 34 e 35, mostra os gráficos para 2, 4, 8, 16 e 24 threads, emrelação ao Simplex Padrão. Primeiramente, perceba que os gráficos são mostrados até1024 variáveis, pois acima desse valor o Simplex padrão ultrapassa o limite de iterações.Observa-se que à medida que aumenta o número de threads, a eficiência para todos osproblemas diminui. Note que para 2 e 4 threads os valores de eficiência para todos osproblemas são próximos de 1, o que indica uma boa utilização dos processadores.

Figura 31: Eficiência para 2 threads, em relação ao Simplex padrão.

Figura 32: Eficiência para 4 threads, em relação ao do Simplex padrão.

Note pelos gráficos de 8, 16 e 24 threads que para os problemas com mais variáveisque restrições obteve-se melhor eficiência. A seta vermelha indica a direção em que a

5.2. Análise da escalabilidade 87


14


14

Figura 35: Eficiência para 24 threads,em relação ao Simplex padrão.

14


eficiência cai nesses gráficos. Por exemplo, o problema com 1024 variáveis e 256 restriçõesnos gráficos 33, 34 e 35 tem maior eficiência que seu oposto. Note a demarcação em1024 restrições nesses gráficos. Isso mostra o limite para analisar a escalabilidade dessesproblemas, 1024 variáveis por 1024 restrições. Isso é necessário, devido a limitação dográfico em 1024 variáveis, como já explicado. Acima desse valor, não há um número derestrições correspondente para realizar a análise.

O algoritmo é escalável para todos os gráficos. Os gráficos de eficiência para 2 e4 threads se mantém próximo de 1, mostrando que o algoritmo é escalável independentedo tamanho dos problemas. Já as figuras 33, 34 e 35 o algoritmo é escalável até certotamanho do problema. Pois, a eficiência diminui com o aumento da quantidade de linhase de colunas. A seta em cima do plano do gráfico, mostra como esse se comporta aoaumentar a quantidade de restrições. A escalabilidade aumenta até uma certa quantidadede restrições e, logo em seguida, começa a declinar. Esse efeito foi causado pela quantidadelimitada de memória cache do servidor. Não há espaço suficiente para acomodar todosos valores dos problemas de grande escala, fazendo com que os dados sejam buscados namemória RAM, prejudicando, assim, o desempenho - gargalo de Von Neumann.

A quantidade total de bytes do problema de programação linear não pode ser maiorque 12 MB, que é o tamanho total da cache L3 do servidor. Os dados da matriz, querepresenta a tabela do Simplex, foi definida com o tipo primitivo double. Esse tipo dedados necessita 8 bytes para armazenamento. Logo, tem-se que:

V ×R× 8bytes ≤ 12MB ⇒ V ×R ≤ 12MB

8B⇒ V ≤ 1.572.864

R, (5.1)

onde R é a quantidade de restrições e V a quantidade de variáveis.

A equação 5.1 demonstra o limite máximo de variáveis e restrições que podem serusados sem que haja perda de desempenho, pois acima desse limite, acontece o problemada cache citada anteriormente. Substituindo, R pelos valores das restrições usadas nasdimensões dos problemas, isto é: 256, 384, 512, 768, 1024, 1536, 2048, 3072 e 4096; tem-secomo valores máximos de variáveis, respectivamente: 6144, 4096, 3072, 2048, 1536, 1024,768, 512 e 384. Ou seja, para 384 restrições a quantidade de variáveis não pode ultrapassar4096, caso contrário, a memória cache não irá comportar. Vale ressaltar que 256 restriçõestem como limite 6144 variáveis, e no caso, a quantidade máxima de variáveis é 4096. Ouseja, para 256 restrições ainda é possível aumentar a quantidade de variáveis.

A figura 36 apresenta um gráfico de eficiência para 24 threads. A linha ponteadamostra os valores de eficiência destacados que correspondem aos problemas limitantesdesignados pela equação 5.1. Esses valores, indicam onde ocorre a primeira queda deeficiência. Após a demarcação, note que a eficiência começa a diminuir, pois o tamanho doproblema ultrapassa o limite máximo de armazenamento da cache. Dessa forma, mostra-secom mais clareza a região em que há a queda de eficiência causada pelo limite de espaço


da cache L3. Destaca-se que essa análise foi baseada no gráfico de eficiência de 24 threads,porém pode ser estendida para os outros gráficos.

Figura 36: Gráfico de eficiência para 24 threads, mostrando o limite dos problemas desig-nados pela equação 5.1.

14

As figuras 37, 38, 39, 40 e 41 mostram os gráficos de eficiência para 2, 4, 8, 16 e 24threads, em relação ao desempenho do CPLEX R©. Inicialmente, observa-se que à medidaque aumenta o número de threads, a eficiência para todos os problemas diminui. Como foivisto na seção 2.3.2.1, isso é natural nos sistemas paralelos, devido a própria definição deeficiência (E = S/P). Note que para 2, 4 e 8 threads os valores de eficiência para algunsproblemas são maiores que 1, o que indica uma eficiência super linear. Enquanto, que para16 e 24 threads obteve uma eficiência sublinear, ou seja, valores abaixo de 1. Contudo, aeficiência com 16 threads obteve eficiência próximo de 1 e com 24 threads próximo de 0.6.

Figura 37: eficiência para 2 threads, em relação ao Simplex do CPLEX R©.

14Super Linear

Note que para todas as threads, o valor da eficiência escala com o aumento damagnitude dos problemas, até um certo valor de variáveis e restrições. Dessa forma, pode-sedizer que o algoritmo possui escalabilidade para esses conjuntos.



14Super Linear


14Super Linear


14Super Linear0.9



14Super Linear0.6

Pode-se analisar na figura 42, a variação de eficiência para problemas de diferentesdimensões. Fazendo uma análise por esse gráfico pode-se identificar em que momento émelhor executar o simplex paralelo. Por exemplo, claramente nota-se que para o problemacom 4096 variáveis e 2048 restrições possui maior eficiência que seu oposto. Ou seja, oproblema com 2048 variáveis e 4096 restrições é menos escalável. Outro exemplo é oproblema com 256 variáveis e 4096 restrições, a eficiência é maior que seu oposto. Logo,é preferível executar, para esse caso, o problema de menor variáveis que restrições. Essaanálise pode ser expandido para os outros gráficos com 2, 4, 8 e 16 threads, podendodiagnosticar as dimensões dos problemas que são mais escaláveis, ou seja, mais eficientes.


14Super Linear0.6

Importante observar que, o gráfico de eficiência relacionado ao CPLEX R©, perdeescalabilidade para problemas com poucas restrições, como mostrado no gráfico 43. Issoocorreu, pois, o tempo de execução do CPLEX R© foi menor para os problemas com maisvariáveis e poucas restrições, como pode ser visto na figura 25.



14Super Linear0.6

O algoritmo do Simplex Padrão sequencial na sua versão mais simples, sem oti-mização algorítmica, tem menor desempenho quando comparado ao CPLEX R©. Contudo,nossa implementação paralela do algoritmo Simplex Padrão obteve melhor performancequando comparado ao CPLEX R©. Isso nos leva crer que otimizações no algoritmo propostopossam levar a desempenho ainda melhores do que os registrados.

93

Conclusão

Este trabalho apresentou uma implementação paralela escalável e eficiente do algo-ritmo Simplex padrão na arquitetura de processadores multicore para resolver problemasde programação linear de grande escala. Na fundamentação teórica foi descrito o funciona-mento do método Simplex Padrão na forma tabular (tableau) para facilitar o entendimentoda nossa proposta de paralelização. Foi feito uma breve explanação sobre as arquiteturasparalelas as quais foram abordados nos trabalhos correlatos. E ainda, no capítulo defundamentação, foram apresentados os conceitos de escalabilidade e as métricas utilizadaspara medir escalabilidade paralela. Na revisão bibliográfica foi mostrado os trabalhosrelacionados ao tema desse texto e algumas ferramentas de otimização, destacando oCPLEX R©. Logo em seguida, explicou-se o esquema geral da paralelização, abordandoa ideia geral de como o algoritmo Simplex Tableau foi paralelizado. Conjuntamente, foidetalhado cada etapa da implementação paralela proposta em OpenMp.

Para realizar as analises, gerou-se problemas de teste, cujas dimensões são combina-ções de: 256, 384, 512, 768, 1024, 1536, 2048, 3072, 4096. Na solução desses problemas foiutilizado o Simplex paralelo proposto, o CPLEX R© e o Simplex Padrão na forma tabular.Na análise do speedup, realizou-se a comparação dos tempos sequenciais para a resoluçãodos problemas através dos algoritmos Simplex Padrão e do CPLEX R© com o número fixode variáveis e alteração na quantidade de restrições e, vice-versa. O CPLEX R©, teve melhordesempenho para todos os problemas, principalmente, devido a quantidade de iterações serbem menor que o Simplex Padrão sequencial. Vale salientar que foi limitado a quantidadede iterações imposta ao método Simplex Padrão. Isso foi feito devido ao tempo não práticopara resolução dos problemas de grande porte.

Com relação à análise da escalabilidade, todos os problemas foram executadosusando a implementação paralela proposta com 2, 4, 8, 16 e 24 threads, considerandoo desempenho do CPLEX R© e o do Simplex Padrão. Os gráficos da eficiência paralela,considerando o CPLEX R© para 2,4 e 8 threads apresentaram valores super lineares. Enquantopara 16 e 24 threads teve uma eficiência de 0.9 e 0.6, respectivamente. Em nenhum dosgráficos da eficiência paralela comparado ao Simplex Padrão apresentou super-linearidade.Embora que para 2 e 4 threads a eficiência é próxima do ideal.

Afirma-se também, com base nos conceitos de Gustafson (GUSTAFSON, 1988),que o algoritmo é escalável, pois, o valor da eficiência aumenta, com o crescimento damagnitude dos problemas. Entretanto, para os gráficos de eficiência do algoritmo paraleloem relação ao simplex Padrão com 8, 16 e 24 threads, quando aumenta o tamanho embytes do problema além da capacidade da cache (V ariáveis×Restrições× 8B ≤ 12MB),

94 Conclusão

ocorre uma queda no valor da eficiência. Isso foi causado pelo gargalo de Von Neumann,ou seja, insuficiência da memória cache para acomodar todos os valores dos problemas degrande dimensão.

Outra análise importante realizada foi identificar em que situação é melhor executara nossa aplicação do Simplex paralelo. Os gráficos de eficiência paralela, considerando odesempenho do CPLEX R©, mostraram que a maioria dos problemas com mais variáveisque restrições tem melhor desempenho. Isso indica que o tempo sequencial do CPLEX R©

foi maior para boa parte dos problemas com mais variáveis que restrições. Já a eficiênciaparalela considerando o Simplex Padrão mostrou que é sempre melhor resolver os problemascom mais variáveis que restrições. Isso aponta que o tempo sequencial do Simplex Padrãofoi maior para todos esses tipos de problemas.

Um outro resultado importante deste trabalho consiste no bom desempenho daimplementação paralela do Simplex, quando comparado com o CPLEX R©. O algoritmoparalelo proposto tem melhor eficiência ao resolver problemas de grande escala com maisvariáveis que restrições tanto comparado ao CPLEX R© quanto ao Simplex Padrão.

A importância desses resultados pode levar a escolha do problema de ProgramaçãoLinear na sua forma original ou dual para economizar o tempo de processamento.

95

Referências

ALMASI, G. S.; GOTTLIEB, A. Highly Parallel Computing. Redwood City, CA, USA:Benjamin-Cummings Publishing Co., Inc., 1989. ISBN 0-8053-0177-1. Citado na página49.

ARB, O. The OpenMP. 2013. Disponível em: <http://openmp.org/wp/about-openmp/>.Citado na página 53.

BORKAR, S. Thousand core chips: A technology perspective. In: Proceedings of the 44thAnnual Design Automation Conference. New York, NY, USA: ACM, 2007. (DAC ’07), p.746–749. ISBN 978-1-59593-627-1. Citado 4 vezes nas páginas 23, 55, 69 e 70.

CANTANE, D. R. Contribuição da Atualização da Decomposição LU no Método Simplex.Tese (Doutorado) — UNICAMP, São Paulo, SP, ago. 2009. Citado na página 23.

COIN-OR. COIN-OR Annual Report 2007. [S.l.], 2007. Citado na página 72.

COIN-OR Projects. 2013. Disponível em: <http://www.coin-or.org/projects/>. Citadona página 72.

CPLEX Optimizer. 2013. Disponível em: <http://www-01.ibm.com/software/commerce/optimization/cplex-optimizer/>. Citado na página 71.

CULLER, D. E.; GUPTA, A.; SINGH, J. P. Parallel Computer Architecture: AHardware/Software Approach. 1st. ed. San Francisco, CA, USA: Morgan KaufmannPublishers Inc., 1997. ISBN 1558603433. Citado na página 47.

DONGARRA, J.; SULLIVAN, F. Guest editors’ introduction: The top 10 algorithms.Computing in Science and Engg., IEEE Educational Activities Department, Piscataway,NJ, USA, v. 2, n. 1, p. 22–23, jan. 2000. ISSN 1521-9615. Citado na página 23.

ECKSTEIN, J. et al. Data-parallel implementations of dense simplex methods on theconnection machine cm-2. INFORMS Journal on Computing, v. 7, n. 4, p. 402–416, 1995.Citado na página 67.

FLYNN, M. J. Some computer organizations and their effectiveness. IEEE Trans.Comput., IEEE Computer Society, Washington, DC, USA, v. 21, n. 9, p. 948–960, set.1972. ISSN 0018-9340. Citado na página 43.

GOLDBARG, M.; LUNA, H. Otimização combinatória e programação linear: modelos ealgoritmos. [S.l.]: Campus, 2000. ISBN 9788535205411. Citado na página 23.

GRAMA, A. et al. Introduction to Parallel Computing: Design and Analysis of Algorithms.[S.l.]: Addison-Wesley, 2003. ISBN 0201648652. Citado 2 vezes nas páginas 58 e 60.

GUSTAFSON, J. L. Reevaluating amdahl’s law. Commun. ACM, ACM, New York,NY, USA, v. 31, n. 5, p. 532–533, maio 1988. ISSN 0001-0782. Disponível em:<http://doi.acm.org/10.1145/42411.42415>. Citado 2 vezes nas páginas 65 e 93.

http://openmp.org/wp/about-openmp/

http://www.coin-or.org/projects/

http://www-01.ibm.com/software/commerce/optimization/cplex-optimizer/

http://www-01.ibm.com/software/commerce/optimization/cplex-optimizer/

http://doi.acm.org/10.1145/42411.42415

96 Referências

HALL, J. Towards a practical parallelisation of the simplex method. ComputationalManagement Science, v. 7, n. 2, p. 139–170, 2010. Citado 2 vezes nas páginas 23 e 69.

HALL, J. A. J.; MCKINNON, K. Asynplex, an asynchronous parallel revised simplexalgorithm. APMOD95 Conference, 1998. Citado na página 68.

KOCH, G. Discovering multi-core: Extending the benefits of moore?s law. [S.l.], 2005.Citado 3 vezes nas páginas 24, 55 e 69.

LIN, Y. C.; SNYDER, L. Principles of Parallel Programming. Boston, Mass:Pearson/Addison Wesley, 2008. ISBN 978-0321487902. Citado 4 vezes nas páginas 40, 51,56 e 60.

LOWE, J. INFORMS Impact Prize. 2013. Disponível em: <https://www.informs.org/Recognize-Excellence/Award-Recipients/Janet-Lowe>. Citado na página 71.

MOORE, G. E. Cramming more components onto integrated circuits. Electronics, IEEE,v. 38, p. 114–117, abr. 1965. Citado 2 vezes nas páginas 24 e 54.

MORIMOTO, C. O fim da lei de Moore. 2012. Disponível em: <http://www.hardware.com.br/artigos/end-moore/>. Citado na página 55.

PACHECO, P. An Introduction to Parallel Programming. 1st. ed. San Francisco, CA,USA: Morgan Kaufmann Publishers Inc., 2011. ISBN 9780123742605. Citado 7 vezes naspáginas 40, 41, 61, 62, 64, 65 e 66.

PASSOS, A. N. dos. Estudos em Programação Linear. Dissertação (Mestrado) —Universidade Estadual de Campinas, Campinas, SP, 2009. Citado na página 23.

ROSARIO, D. A. N. do. Escalabilidade Paralela de um Algoritmo de Migração Reversa noTempo (RTM) Pré-Empilhamento. Dissertação (Mestrado) — Universidade Federal do RioGrande do Norte, UFRN, Natal, RN, 2012. Citado 2 vezes nas páginas 57 e 64.

TANENBAUM, A. S.; WOODHUL, A. S. Sistemas Operacionais: Projeto e Implementação.[S.l.]: BookMan, 2000. Citado na página 56.

TASOULIS, D. K. et al. Parallel differential evolution. In: In IEEE Congress onEvolutionary Computation (CEC. [S.l.: s.n.], 2004. Citado na página 24.

THOMADAKIS, E. M.; LIU, J.-C. Progress and challenges in high performance computertechnology. Computer Science and Technology, 2006. Citado na página 24.

THOMADAKIS, M. E.; LIU, J.-C. An efficient steepest-edge simplex algorithm for simdcomputers. In: International Conference on Supercomputing. [S.l.: s.n.], 1996. p. 286–293.Citado na página 68.

PLOSKAS, N.; SAMARAS, N.; SIFALERAS, A. (Ed.). A parallel implementation of anexterior point algorithm for linear programming problems. [S.l.]: University of Macedonia,2009. Citado 3 vezes nas páginas 24, 67 e 70.

YARMISH, G.; SLYKE, R. V. retroLP, An Implementation of the Standard SimplexMethod. [S.l.], 2003. Citado na página 69.

YARMISH, G.; SLYKE, R. V. A distributed, scaleable simplex method. Supercomputing,2009. Citado na página 69.

https://www.informs.org/Recognize-Excellence/Award-Recipients/Janet-Lowe

https://www.informs.org/Recognize-Excellence/Award-Recipients/Janet-Lowe

http://www.hardware.com.br/artigos/end-moore/

http://www.hardware.com.br/artigos/end-moore/

implementação paralela escalável e eficiente do algoritmo simplex

Documents