Foz do Iguaçu, 27 a 29 de Outubro de 2004
ESCALONAMENTO PARALELO DE TAREFAS:
Conceitos, Simulação e Análise de Desempenho
Luís Fabrício
W. Góes,
Carlos Augusto
P
.
S. Martins
Laboratório de
Sistemas Digitais
e Computacionais
Pontifícia
Universidade Católica de Minas Gerais
Av.
Dom José
Gaspar 500, 30535-610, Belo
Hori
zonte,
MG,
Bra
sil
lfwgoes@yahoo.com.br,capsm@pucminas.br.
Resumo
Neste texto, apresentamos os principais objetivos, público-alvo, trabalhos correlatos e a estrutura do minicurso. Os principais objetivos deste minicurso são: apresentar e difundir os conhecimentos relacionados ao escalonamento paralelo de tarefas (EPT) e discutir EPT dentro do contexto de processamento paralelo; apresentar os principais conceitos, simulação e análise de desempenho de EPT, por meio da ferramenta ClusterSim; comparar os diversos algoritmos de EPT; produzir e disponibilizar literatura em português sobre escalonamento paralelo de tarefas.
O nosso público-alvo é de alunos com formação nas áreas de ciência da computação e engenharias, interessados em processamento de alto desempenho, processamento paralelo, sistemas operacionais, arquiteturas de computadores, redes de computadores e escalonamento de tarefas.
Em {YamOJ ], publicado no ERAD 2001, existe uma pequena relação com a primeira parte do nosso mini-curso, na qual o enfoque é teórico. Mas no restante do mini-curso, a nossa proposta se diferencia por enfocar o escalonamento paralelo dinâmico e pelos aspectos práticos (simulação e análise de desempenho), nos quais simulamos diversos algoritmos de escalonamento e os analisamos por meio de métricas (dados quantitativos).
O minicurso está estruturado em seis capftulos: Introdução; Conceitos de Escalonamento Paralelo de Tarefas; Simulação de Escalonamento Paralelo de Tarefas; Análise de Desempenho de Escalonamento Paralelo de Tarefas; Conclusões e Referências Bibliográficas.
1. Introdução
Neste capítulo introdutório, apresentamos um histórico sobre escalonamento paralelo de tarefas, uma
introdução sobre processamento paralelo, descrevendo possíveis cargas de trabalho e arquiteturas de um sistema computacional paralelo. Além disso, discutimos diversas formas de modelagem da carga de trabalho.
1.1. Histórico
Na década de 50, as práticas de escalonamento já eram necessárias para a utilização apropriada de homens, máquinas e materiais em um programa de manufatura. O bom retorno de investimentos estava ligado ao atendimento das necessidades dos consumidores e à utilização ótima do equipamento [Gra57]. Em meados dos anos 50, surgiu o primeiro sistema operacional, o GM-NAA 1/0 (General Moror.1· - North American Aviation), desenvolvido para a arquitetura IBM 704 [Com03]. Nesse sistema, as tarefas (consumidores) eram executadas seqüencialmente sem interrupções (sistema em lote com mono-programação) no processador (recurso) do IBM 704 [Com03] [Hwa98] [Pat98]. Consideramos esse sistema como a forma mais simplificada de escalonamento, na qual os consumidores utilizam o recurso de forma exclusiva até executarem todo o trabalho. No final da década de 60, surgiu o primeiro sistema operacional de tempo compartilhado, no qual várias tarefas e usuários compartilhavam o mesmo recurso [Com03] [Hwa98]. Então, os escalonadores dos sistemas operacionais passaram a utilizar algoritmos mais complexos. Os algoritmos de escalonamento deveriam atender às necessidades dos usuários e ao mesmo tempo maximizarem a utilização do processador.
No início da década de 70 tornou-se operacional o primeiro computador vetorial, o ILLIAC IV, instalado no Ames Research Center da NASA. Ele atingia uma velocidade de 200 milhões de instruções por segundo com os seus 64 elementos de processamento lCom03]. Desde então, os algoritmos de escalonamento passaram a resolver um problema bidimensional envolvendo o
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
tempo e o espaço. O compartilhamento de tempo se refere à utilização de um recurso ao longo do tempo por vários consumidores. Já o compartilhamento de espaço se preocupa com a distribuição espacial dos consumidores sobre os recursos, independentemente do tempo [Fei94].
Com a evolução dos processadores, redes de interconexão, memórias, sistemas operacionais, linguagens e outros componentes de computador, surgiram novas arquiteturas paralelas, entre as quais destacamos: multiprocessadores, multicomputadores e principalmente aglomerados de computadores e arquiteturas em grade [Aim94] [Buy99] [Hwa98). A partir do final dos anos 80, iniciou-se uma competição entre Japão e Estados Unidos para a construção de arquiteturas cada vez mais poderosas, para a solução de problemas complexos. Desde 1993, essa competição vem sendo documentada pelo site TOP500, no qual, a cada ano, as arquiteturas são avaliadas através do benchmark Linpack e classificadas de acordo com a velocidade de processamento [Top03]. Os escalonadores têm um papel fundamental no desempenho dessas arquiteturas, tanto no aumento da utilização dos processadores, dispositivos de EIS etc., quanto na diminuição do tempo de resposta, tempo de reação e slowdown das tarefas, que podem ser requisições de busca, transações bancárias, programas paralelos etc [Buy99] [Hwa98] [El95].
Nos últimos anos, as necessidades dos usuários em relação ao custo, tempo e qualidade de serviço tornaram-se muito complexas. Da mesma forma, o investimento das empresas, indústrias e universidades em sistemas computacionais de alto desempenho (arquiteturas paralelas) tem aumentado. Entre esses dois lados estão os algoritmos de escalonamento, que tentam atender às necessidades dos usuários e das instituições. Seja em um sistema bancário, uma indústria automobilística, um laboratório de uma universidade ou um site de busca, sempre existirá o problema de escalonamento, no qual um algoritmo tem o compromisso de alocar recursos computacionais de forma eficiente às tarefas dos usuários [Buy99] [Hwa98] [EI95].
1.2. Processamento Paralelo
Atualmente, o processamento paralelo é amplamente utilizado na indústria e no meio acadêmico para a resolução de problemas complexos, que demandam alto desempenho computacional. Normalmente, um sistema computacional paralelo é composto uma arquitetura paralela (aglomerado de computadores, multiprocessador, etc.) e por uma carga de trabalho (tarefas paralelas, em lote e interativas).
As tarefas de uma carga de trabalho são executas em uma arquitetura paralela [Alm94] [Buy99] [Hwa98]. 1.2.1. Arquiteturas Paralelas
Dentre os modelos de computadores descritos pela taxonomia de Flynn, destacamos o modelo de computador paralelo MIMO (múltiplas instruções múltiplos dados), no qual múltiplas instruções são executadas por vários elementos de processamento, sobre diferentes conjuntos de dados. As arquiteturas paralelas MIMO podem ser classificadas em duas
classes principais: multiprocessador e
multicomputador. Um multiprocessador é composto por um conjunto de processadores que compartilham uma memória física e um mesmo espaço de endereçamento. Nessa classe de arquitetura, os processos de uma mesma tarefa se comunicam por meio de escritas e leituras em variáveis compartilhadas na memória [Alm94] [Buy99] [Hwa98]. Ao contrário dos multiprocessadores, os multicomputadores são compostos de nodos com memórias físicas independentes, ou seja, não compartilham um mesmo espaço de endereçamento. Para um processo acessar um dado na memória de um nodo remoto é necessária à troca de mensagens entre os nodos por meio de uma rede de interconexão [Buy99] [Hwa98].
Entre os multicomputadores, destacamos a arquitetura de aglomerado de computadores ou cluster. Todos os nodos de um aglomerado trabalham coletivamente como um sistema único para prover serviços ininterruptos e eficientes. Cada nodo pode ser um multiprocessador simétrico (SMP), estação de trabalho ou computador pessoal independente. Geralmente, aglomerados possuem um baixo custo financeiro, pois são construídos utilizando-se componentes de hardware COTS (commodity-off-th e-shelf) e software livre disponível [Buy99] [Hwa98]. Uma apresentação e análise mais detalhadas sobre arquiteturas paralelas podem ser encontradas em [Aim94] [Hwa98].
1.2.2. Carga de Trabalho
A carga de trabalho de um sistema computacional paralelo é composta basicamente de um conjunto de tarefas. Na literatura são encontradas algumas definições para tarefa (ou ''job") [Fei94] [TanOO). No contexto desta pesquisa, vamos definir tarefa como um conjunto de processos relacionados entre si para a solução de um ou vários problemas.
Estas tarefas são caracterizadas por um padrão de chegada, grau de paralelismo, estrutura interna (barreiras, número de instruções, número de bytes lidos e escritos na memória, requisitos de E/S, padrão de
comunicação etc.) etc [Fei97] [Fei02]. Uma tarefa pode ser modelada de duas formas: por um conjunto de equações que descrevem seu comportamento ou pela especificação de sua estrutura interna. Por meio de simulação ou métodos analíticos detalhados, as tarefas modeladas são executadas e então as métricas de desempenho (tempo de execução, tempo de reação etc.) são calculadas [Fei97].
Existem duas fontes para se obter os dados sobre as tarefas: por meio de logs de contabilidade ou pela coleta de dados específicos para um modelo de carga [Fei02]. Atualmente os logs são a fonte mais disponível desses dados. Em [Par03] são disponibilizados diversos logs de execução de diferentes cargas de trabalho em diferentes arquiteturas paralelas. Geralmente, esses logs possuem informações sobre o grau de paralelismo das tarefas, tempo de chegada das tarefas, consumo total de recursos, tempo de execução das tarefas etc. Apesar disso, existe muito pouca informação disponível sobre a estrutura interna dessas tarefas executadas [Fei97] [Fei02].
A partir de um log é possível usá-lo como um trace para dirigir uma simulação. O uso de um trace diretamente tem a vantagem de representar o sistema com maior fidelidade, incluindo eventos incomuns e outras complexidades. As principais desvantagens do trace são: reflete uma carga de trabalho específica, que geralmente não é representativa em outro sistema; nem sempre os traces disponíveis possuem todos os dados necessários; existem casos onde a carga de trabalho é dependente do sistema, não sendo representativa até mesmo para o próprio sistema com outras configurações [Fei02].
Uma alternativa ao uso de traces, é a coleta de dados para modelos de cargas de trabalho [Fei02b]. Se algum dado necessário não está disponível, é necessário coletá-lo ou medi-lo, geralmente por meio de instrumentação. O maior problema da instrumentação é ser intrusiva, interferindo no desempenho ou até modificando o comportamento do sistema [Fei02]. O mecanismo de instrumentação menos intrusivo e mais preciso é o uso de contadores de hardware.
Os modelos de carga de trabalho apresentam uma série de vantagens sobre os traces: é possível mudar os parâmetros do modelo um de cada vez, para investigação da influência de cada parâmetro, enquanto mantém os outros constantes; experimentos podem ser repetidos em situações estatísticas similares (executar com diferentes sementes); a própria modelagem aumenta o nosso entendimento, que pode levar a novos projetos. A abordagem mais comum utilizada na modelagem da carga de trabalho é criar um resumo estatístico (uma ou um conjunto de distribuições) da carga observada. Mas essa abordagem perde toda a
Foz do Iguaçu, 27 a 29 de Outubro de 2004
informação estrutural das tarefas. Um outro caminho é a modelagem da estrutura interna das tarefas para criação de tarefas sintéticas parametrizadas [BatOO] [Fei02] [Wis03] [Fra03]. As tarefas sintéticas são usadas para testar questões bem específicas, limitando fatores irrelevantes (neste contexto) que são encontrados em aplicações reais [BatOO].
Tanto os modelos de carga quanto os traces para sistemas paralelos apresentam alguns problemas: falta de dados sobre E/S; falta da descrição da estrutura interna das tarefas; não possuem feedback (seqüência de tarefas dependentes); as falhas e interrupções do sistema não estão disponíveis [Cha99]. Mas de uma maneira mais ampla, o principal problema é o alcance de uma alta representatividade, seja a modelagem mais complexa ou menos detalhada [Fei02].
2. Conceitos de Escalonamento Paralelo de
Tarefas
Neste capítulo, apresentamos os principais conceitos relacionados ao escalonamento paralelo de tarefas, considerando escalonamento estático e dinâmico de tarefas. Em seguida, apresentamos alguns dos principais algoritmos de EPT dinâmico, como escalonamento de gangues, backfilling, compartilhamento de espaço etc.
2.1. Escalonamento Paralelo de Tarefas
O escalonamento paralelo de tarefas é um problema no qual um algoritmo procura alocar, ao longo do tempo, as diversas tarefas pertencentes a uma carga de trabalho aos processadores de uma arquitetura paralela. Existem dois tipos principais de escalonamento paralelo: estático e dinâmico [Cam99] [EI95] [Fei94] [Kwo99] [YamOI].
2.1.1. Escalonamento Paralelo Estático
O escalonamento paralelo estático consiste em atribuir tarefas para elementos de processamento (mapeamento), de forma a minimizar o tempo total de execução das tarefas. No escalonamento estático, o mapeamento de tarefas na arquitetura ocorre antes do início da execução (em tempo de compilação). Uma vez iniciado o processamento, as tarefas permanecem nos processadores aos quais foram alocadas, até que a execução paralela seja encerrada, ou seja, as estratégias de escalonamento estático são não-preemptivas. Portanto, o algoritmo de escalonamento precisa ter um bom conhecimento sobre o tipo das tarefas, o tempo de execução das tarefas, as relações de dependência e os padrões de comunicação entre as mesmas. A decisão
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
de escalonamento neste caso é geralmente centralizada e não adaptativa [Cam99] [EI95] [Kwo99] [Yamül]. Neste minicurso não detalharemos o escalonamento paralelo estático, portanto o termo escalonamento paralelo será usado como sinônimo de escalonamento paralelo dinâmico no restante do texto.
2.1.2. Escalonamento Paralelo Dinâmico
No escalonamento paralelo dinâmico, poucas suposições podem ser feitas sobre as tarefas antes da execução, por esse motivo, as decisões de escalonamento devem ser tomadas em tempo de execução. A idéia básica do escalonamento paralelo de tarefas é realizar o ordenamento e a alocação dos processos de uma tarefa durante a execução da mesma. A meta de um algoritmo de escalonamento paralelo não inclui apenas a minimização do tempo de execução da tarefa, mas também a minimização da sobrecarga de escalonamento, ou seja, o tempo gasto para coleta de informações, distribuição ou até migração das tarefas. Nesse caso, o escalonamento pode ser preemptivo, distribuído e/ou adaptativo [Cam99] [Fei94] [Kwo99] [Yamül].
No escalonamento paralelo de tarefas, os processadores podem ser compartilhados por meio de compartilhamento de espaço e compartilhamento de tempo. Esses tipos de compartilhamento utilizam mecanismos amplamente independentes ou ortogonais, possibilitando uma combinação entre eles [Fei94] [Hwa98].
No compartilhamento de espaço, várias tarefas podem executar em partições disjuntas ou grupos de nodos simultaneamente. Esse particionamento da arquitetura paralela visa à diminuição da sobrecarga na troca de contexto, na qual no máximo um processo é atribuído a um nodo em um dado momento. Apesar da partição de nodos ser dedicada a apenas uma tarefa, a interconexão e o sistema de EIS podem ser compartilhados pelas tarefas [Fei94] [Hwa98]. Uma técnica de otimização de compartilhamento de espaço é chamada backfilling. Na técnica de backfilling
conservativa, tarefas são escalonadas para executar assim que possível, contanto que elas não retardem uma tarefa que chegou mais cedo, ou seja, ela tenta atribuir nodos inutilizados para tarefas que estão atrás na fila, ao invés de mantê-los desocupados [Fra99) [Hwa98] [ZhaOO] [ZhoOl]. Existe uma outra técnica chamada backfilling agressivo, na qual as tarefas, para serem escalonadas, só não podem atrasar o início da primeira tarefa da fila [Fra99). As principais vantagens do backfilling são: aumento da utilização do sistema e diminuição do tempo de resposta das tarefas. A principal desvantagem é que o escalonador necessita de uma estimativa de tempo de término da tarefa,
geralmente indicada pelo usuário (estimativas erradas podem levar a grandes erros no escalonamento) [Fra99] [ZhaOO].
No compartilhamento de tempo, várias tarefas são atribuídas para um mesmo nodo, ocorrendo troca de contexto entre elas [Fei94) [Hwa98]. O escalonamento de gangues (gang scheduling) é um tipo de combinação dos compartilhamentos de espaço e tempo [Fei94].
2.1.3. Escalonamento de Gangues
O escalonamento de gangues foi introduzido por Ousterhout [Ous82] com o nome de co-escalonamento. O seu objetivo era o uso eficiente de espera ocupada para tarefas de sincronização de grão fino. O escalonamento de gangues é uma combinação de três características: i) processos são agrupados em gangues; ii) os processos de uma tarefa executam simultaneamente em processadores distintos; iii) todos os processos de uma gangue são interrompidos
(preempted) e re-escalonados ao mesmo tempo,
utilizando-se compartilhamento de tempo. Um grupo de processos que se comunicam com muita freqüência deve ser escalonado ao mesmo tempo, portanto esses processos devem ser agrupados em uma gangue. Normalmente, todos os processos de uma tarefa são considerados uma gangue [Fei94].
As principais vantagens do escalonamento de gangues são: i) provê tempo de resposta interativo para tarefas com baixo tempo de execução, por meio de preempção; ii) evita que tarefas com alto tempo de execução monopolizem os processadores; iii) aumenta a utilização do sistema na alocação de recursos [Fei94) [Jet97]; iv) uma estimação do tempo de término de uma tarefa é desnecessária (ao contrário do backfilling) [ZhaOO]; v) tarefas podem ser iniciadas sem ter que esperar que todos os processadores requeridos sejam desocupados [Jet97].
Como principais desvantagens, podemos destacar: i) a preempção aumenta a sobrecarga na troca de contexto e pode reduzir o desempenho da cache [Fei94]; ii) necessidade de memória e disco adicional, porque várias tarefas compartilham os mesmos processadores [BatOO]; iii) fragmentação de tarefas [Fra99) [Zhou99); iv) enquanto processos realizam E/S ou comunicação bloqueante, os processadores ficam ociosos (escalonamento de gangues restrito) [Wis03]. 2.1.3.1. Aspectos de Implementação
Para representar a alocação das tarefas aos processadores ao longo do tempo, Ousterhout [Ous82] propôs uma matriz onde as colunas são os processadores e as linhas são as fatias de tempo
(Tabela 2.1 ). Durante cada fatia de tempo, os processos
de cada tarefa devem executar simultaneamente em
seus respectivos processadores. Portanto, devemos nos
preocupar com cincos aspectos: número de fatias de
tempo, coordenação dos processos, esquema de
empacotamento dos processos, esquema de
desfragmentação e pressão na memória [Fei94] [Fei96]
[Ous82] [ZhaOO].
Tabela 2 1
.
- Matriz de Ousterhout ~ Procemidor 1 Processlldor l Processador 3 Processador 4Fatia 1 Ttnl:e.l (lnc••• l) tv.le.l(lnctff•1) T--'• J (lr'Mttt• J) Tne.t(lrtc••••>
Faliltl Tlll'lld (lncMH I) T.CaJ(Inc•••l) T~a J (lnc••• J)
Falilt3 Ttnll:•"(lnc•••l) T.C•4(1nc•••1) T . . ... f(lncttttl) Td•6<b'M•••t)
Falilt4 T_..,ll,(lhc.tfMI) T.C•f(b"..c•Ht) T ... •4(1nc•••J) Tlnf•f(ln4• .. 4)
Cada fatia de tempo cria a ilusão de uma máquina
dedicada às tarefas. O número de fatias de tempo
determina o nível de multiprogramação, ou seja, o
número de máquinas virtuais dedicadas. Portanto, quanto maior o número de fatias, mais tarefas
concorrem por um mesmo processador e
conseqüentemente os tempos de resposta das tarefas se
tornam maiores que em uma máquina dedicada. Ao
mesmo tempo, uma tarefa demora menos tempo
esperando na fila para começar a ser executada. Dessa
forma, tarefas com baixo tempo de execução, que
esperariam por muito tempo na fila, podem ser
imediatamente executadas e terminadas em menor
tempo [Fei96] [ZhaOO].
A coordenação dos processos é realizada por meio
da troca de contexto múltipla, em que geralmente um
controlador central obriga todos os processadores a
realizarem troca de contexto ao mesmo tempo. Para
isso, é necessário que a diferença entre o tempo de
início da primeira e o tempo de término da última troca de contexto seja minimizada [Fei94]. Geralmente
existe um deamon local em cada nodo, que é
responsável por garantir a execução do escalonamento
necessário para a coordenação global [Fra03].
A troca de contexto múltipla pode ser
implementada através de diversos mecanismos: i)
hardware de propósito específico; ii) broadcast de
interrupções em software; iii) relógios sincronizados;
iv) sinais do sistema operacional; v) mudança de
prioridades dos processos [Fei92] [Fei94].
Ao longo do tempo, novas tarefas são inseridas na
matriz de Ousterhout, enquanto outras tarefas são
retiradas assim que terminam a execução. Essa
movimentação pode gerar fragmentação de tarefas nas
fatias de tempo, ou seja, as fatias de tempo
subutilizarem os processadores disponíveis. Por meio
de esquemas de empacotamento, as tarefas são
alocadas aos processadores (inseridas na matriz de
Ousterhout), procurando minimizar a fragmentação das
Foz do Iguaçu, 27 a 29 de Outubro de 2004
tarefas. Os algoritmos de empacotamento podem ser
divididos em cinco categorias: baseados na capacidadç,
baseados na esquerda-direita, baseados na carga,
baseados no companheiro (buddy) e baseados em
migração [Fei96]. Os dois algoritmos de
empacotamento mais difundidos são: primeiro encaixe
(first fit) e melhor encaixe (best fit). No primeiro
encaixe, as fatias de tempo (slots) são vasculhadas
seqüencialmente, a primeira fatia com capacidade
suficiente para executar a tarefa é escolhida. Já no
melhor encaixe, a fatia com a menor capacidade que
seja suficiente é escolhida. Outro algoritmo
interessante é o baseado no companheiro [Fei96]
[Zho99]. Ele é implementado por meios de um controle
hierárquico distribuído (DHC) composto por
controladores que organizam os processadores como
um sistema companheiro. Um controlador distinto é
associado com cada bloco de processadores. O
tamanho de cada bloco é uma potência de dois. Um controlador no nível i coordena atividades envolvendo
os processadores da sua sub-árvore. Existem conexões
laterais entre os controladores de um mesmo nível para balanceamento de carga [Fei90] [Fei95] [Fei96j.
Após ocorrer a fragmentação, existem alguns
esquemas de desfragmentação ou de re-empacotamento
que podem ser utilizados, como escalonamento
alternativo e unificação de fatias (slot unification)
[Fei94] [Fei96] [Zho99]. No escalonamento
alternativo uma tarefa é escolhida para executar em
mais de uma fatia, mas nos mesmos processadores,
diminuindo o tempo de resposta. Na unificação de
fatias, quando uma tarefa termina, existe a
possibilidade que outras tarefas na mesma fatia usem
processadores que são distintos daqueles que são
usados por tarefas de outras fatias. Isso possibilita a
unificação de duas fatias, reduzindo o número de fatias
usadas em um e melhorando a fração de execução de
cada tarefa [Fei96].
Outro problema com o escalonamento de gangues é
a pressão na memória, que causa paginação e degrada
o desempenho. A solução mais simples desse problema
é executar somente um subconjunto de tarefas,
deixando as demais esperando em uma fila [BatOO].
2.1.3.2. Tipos de Escalonamento de Gangues
Existem diversos tipos de escalonamento de
gangues além do tradicional ou restrito, dentre os quais
podemos destacar (Figura 2.1 ): escalonamento de
famílias, escalonamento preguiçoso de gangues,
escalonamento emparelhado de gangues,
co-escalonamento dinâmico, co-escalonamento implícito,
co-escalonamento flexível e outros [Fei94] [Wis03]
[Fra03] [Kar02]. O escalonamento de famílias é uma
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
número de processos pode ser maior que o número de processadores [Fei94]. Já no escalonamento preguiçoso de gangues cada tarefa possui um tempo de espera. Quando esse tempo é excedido, a prioridade da tarefa é aumentada e os processos de baixa prioridade são interrompidos, para que a tarefa execute. Após executar por um determinado tempo sem interrupções,
ela se torna candidata a ser interrompida, caso outra tarefa com alta prioridade esteja esperando [Fei94].
:.:if: rn.t I ma ,_, , . . M!!f! ,_, I ,..., ..., ,_ ~ rn.t ...., ...,, , _ rM~ n 1 n n n ~;
...
,..., ,_, ,_,...,
n. n. n.. n..,...,
n.. n.. n. ,...,....
....
....
-,
....
n.-
n..--
,.,
-,.,
,
....
TI lll nt" ,,..,. no no Tlt "12• 1'1 M ,_,...
,...,
,
,_
,
....
n n n l n-
,
....
5"'- -..
n n-
-~
~
-,
....
...
n,
....
TO " --IWI , ... d,...,
-
,...,,
....
TI., n .. n. n .. ,..., 'PrwJ n• n• n" ,.,.-...-
,...
,.,.
n• ~ w ~ n.. n ......
...
n• n•,.,..
n•-
,...
...-,...
,.-Figura 2.1 Exemplos de tipos de escalonamento de gangues: (a) escalonamentode gangues restrito; (b) escalonamento
emparelhado de gangues - CPU e E/S indicam o tipo da tarefa; (c) escalonamento de famílias- ex: P1 indica processo 1; (d) co-escalonamento explícito; (e) co-escalonamento implícito-REQ e EXE significam tarefa requisitante e em execução respectivamente; (f) co-escalonamento flexível.
O escalonamento emparelhado de gangues procura casar pares de gangues, ou seja, executar duas gangues nos mesmos processadores, sendo uma gangue caracterizada por um maior número de instruções de CPU e outra por instruções de E/S. Como instruções de CPU e EIS utilizam dispositivos diferentes, as duas
gangues não interferem nas suas execuções, aumentando a utilização do sistema [Wis03].
O co-escalonamento procura escalonar e coordenar um grupo de processos simultaneamente entre processadores distintos, mas se ele não consegue, ele escalona apenas um subgrupo de processos [Fei94] [PetOO] [SolOI]. No co-escalonamento dinâmico ou explícito, se uma mensagem chega para um processo
diferente do que está em execução, ele pode interromper o processo atual e escalonar o processo receptor da mensagem [PetOO] [SolO I]. Uma variação do co-escalonamento dinâmico, chamado co-escalonamento implícito, não se preocupa com a coordenação global dos processos de uma gangue, deixando cada escalonador local tomar as suas próprias
decisões [Fra03] [Fei94] [PetOO] [SolOl]. Nele, um processo que espera por mensagem, aguarda por um tempo determinado. Se a mensagem chegar dentro
desse tempo, o processo continua sua execução, senão ele é interrompido [PetOO] [SolO I].
Por último, o co-escalonamento flexível monitora a granularidade e atividade de comunicação de cada tarefa, usando escalonamento de gangues somente nas tarefas que necessitam dele. Os processos de outras tarefas, que podem ser escalonados sem restrições, são
usados em processadores ociosos, no intuito de diminuir a fragmentação [Fra03].
3. Simulação
de
Escalonamento Paralelo de
Tarefas
Neste capítulo, apresentamos alguns conceitos de
simulação de EPT, destacando a ferramenta ClusterSim e como utilizá-la para a simulação de EPT. O ClusterSim (Cluster Simulation Too[) é uma ferramenta de simulação paralela discreta por eventos de desempenho de escalonamento paralelo de tarefas,
em aglomerados de computadores, baseada em Java.
Ele suporta modelagem visual e simulação de aglomerados de computadores e das cargas de trabalho. Os aglomerados são compostos de nodos mono ou multiprocessados, algoritmos de escalol'}amento paralelo de tarefas, tecnologias e topologias de rede. As cargas de trabalho são representadas por usuários,
que submetem tarefas compostas por processos, que
são descritos por distribuições de probabilidades e
pelas suas estruturas internas. Então, mostramos alguns exemplos de utilização da ferramenta para criação e
simulação da carga de trabalho e aglomerados de computadores com seus respectivos algoritmos de escalonamento paralelo de tarefas. Por último, mostramos os resultados estatísticos e de desempenho disponibilizados pelo ClusterSim, para cada simulação
realizada. 3.1. ClusterSim
O ClusterSim (Cluster Simulation Tool) é uma
ferramenta de simulação paralela discreta por eventos de desempenho de escalonamento paralelo de tarefas,
em aglomerados de computadores, baseada em Java. Ele suporta modelagem visual e simulação de aglomerados de computadores e das cargas de trabalho. Os aglomerados são compostos de nados mono ou
multiprocessados, algoritmos de escalonamento paralelo de tarefas, tecnologias e topologias de rede. As cargas de trabalho são representadas por usuários,
que submetem tarefas compostas por processos, que são descritos por distribuições de probabilidades e pela estrutura interna deles.
As principais características do ClusterSim são: • Ambiente gráfico para modelagem de
aglomerados e cargas de trabalho.
• código fonte do ClusterSim é livre e suas classes
podem ser estendidas, provendo um mecanismo para a implementação de novos algoritmos de
escalonamento de tarefas, topologias de rede etc. • As tarefas são representadas por estruturas de
repetição e instruções de CPU, EIS e
comunicação. Dessa forma, a estrutura interna das
tarefas representa as das aplicações reais,
possibilitando a implementação de qualquer modelo de algoritmo paralelo e padrão de
comunicação.
• Modelagem de aglomerados e nados heterogêneos.
• As entidades de simulação (arquiteturas e
usuários) são threads independentes, provendo paralelismo.
• A maioria das funções de comunicação ponto a
ponto e coletivas do MPI são simuladas.
• A rede de interconexão entre os nodos é
representada pela topologia, latência, largura de banda, sobrecarga de protocolo, taxa de erro e
MSS (maximum segment size -tamanho máximo de segmento).
• Suporte a diversos algoritmos de escalonamento
paralelo (compartilhamento de espaço,
escalonamento de gangues etc.) do aglomerado e
também de cada nodo (First-Come-First-Served
(FCFS), etc.).
• Módulo estatístico e de desempenho que calcula
diversas métricas.
• Suporte a diversas distribuições de probabilidade:
normal, exponencial, hiper-exponencial Erlang,
uniforme etc. Elas são utilizadas para representar o
intervalo de chegada de tarefas e o grau de paralelismo dos processos.
• Tempo de duração da simulação e a semente podem ser especificados.
3.1.1. Arquitetura do ClusterSim
A arquitetura do ClusterSim é dividida em três
camadas: ambiente gráfico, entidades e núcleo (Figura
3.1). A primeira camada permite a modelagem e simulação do aglomerado e da carga de trabalho por meio de um ambiente gráfico. Além disso, ela provê
dados estatísticos e de desempenho sobre cada
simulação executada. A segunda camada é composta
por três entidades: usuário, aglomerado de computadores e nodo. Essas entidades se comunicam
por meio de troca de eventos suportada pela biblioteca
JSDESLib, que compõe o camada núcleo.
Foz do Iguaçu, 27 a 29 de Outubro de 2004
ú ú
Figura 3.1- Arquitetura em camadas do ClusterSim
3.1.1.1. Ambiente Gráfico
O ambiente gráfico foi implementado utilizando o
pacote swing do Java e o compilador NetBeans 3.4.1,
pela portabilidade e orientação por objetos providos
pela linguagem Java. Ele é composto de uma tela de
configuração e execução da simulação, três editores da
carga de trabalho (usuário, tarefa e processo) e três
editores da arquitetura (aglomerado, nodo e
processador). Por meio desse ambiente, é possível
modelar, executar, salvar e modificar diversos
experimentos e ambientes de simulação (Figura 3.2).
. .
...
Figura 3.2- Tela principal do ambiente gráfico do ClusterSim
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
Assim como os editores do ambiente gráfico, o modelo de simulação é dividido em carga de trabalho e arquitetura. No resto deste tópico, descrevem?s o
modelo de simulação juntamente com o ambiente
gráfico.
3.1.1.1.1. Carga de Trabalho
Baseado nos trabalhos relacionados já
apresentados, optamos por criar um modelo de carga
de trabalho híbrido usando distribuições probabilísticas
para representar certos parâmetros, como o ~r~u de
paralelismo e intervalo de chegada, e a descnçao da
estrutura interna das tarefas. Nós julgamos que o uso
do tempo de execução das tarefas como um. parâmetro,
apesar de encontrado nos Iogs, é restnto a uma
configuração de carga de trabalho e arquitetura. Além disso, ele é influenciado por diversos fatores como a carga, capacidade de processamento dos nodos,
sobrecarga na rede etc. Portanto, o tempo de execução
deve ser calculado durante a execução de uma
simulação, de acordo com a carga de trabalho e
arquitetura simulada, ao invés de ser amostrado com
base em outros contextos específicos. Suponha que em
uma determinada arquitetura, as tarefas gastam em
média 10 minutos de tempo de execução. Se
simularmos a execução das mesmas tarefas em uma
arquitetura teoricamente I O vezes mais rápida, esse valor não seria mais representativo.
No lugar do parâmetro tempo de execução,
utilizamos a representação explícita da estrutura
interna de cada tarefa. Essa abordagem possui diversas vantagens: i) as tarefas reais podem ser represent~~as
diretamente, sem modificação nas suas estruturas; n) o
tempo de execução de cada processo é calculado
dinamicamente, influenciado apenas pelo ambiente em teste; iii) o comportamento das tarefas se torna mais
determinístico; iv) vários padrões de comunicação e modelos de algoritmos paralelos podem ser implementados.
Diferentemente do tempo de execução, o grau de
paralelismo é geralmente indicado pelo programador
que submete a tarefa. Portanto, ele normalm:nte nã~ é
influenciado por fatores em tempo de execuçao. Entao, o uso de uma distribuição para representá-lo se torna bastante viável e representativo, apesar das variações
no número de nodos de um aglomerado.
Por último, o intervalo entre chegadas de tarefas
também é representado por uma distribuição de
probabilidade, para evitar o uso de trac~~ extenso~.
Além disso, as distribuições exponenc1a1s e ma1s recentemente a hiper-exponencial Erlang são bastante
utilizadas e aceitas pela comunidade acadêmica [Fei95]
[Jai91] [Jet97] [SoiOI] [Zho99].
e
e
Ot•~ ; • .,.,_,,,,., .. ~t~,r,."•'l"'.r~<f~·;_~.r ... #".4-"~"-1'" • .-;,·;~ ... • ~ ":.~ --
_
..._
-r
, ... """'... ....·-.-
-
w.c I ~---
~111 I-
11111 ... ~•·· .. ao.-l'
f """! •11---!.!J t::::;!j (, __ ,___ tOUtl - jl
-~.
...
.
-
.
.
...
""'-~-~ I·,
__
·[ ~ ' t.==._ ... ...._._ I L.Ohlltualonf~.. -·- __,..,.
I -·~-~~~ ~,·
'...,
_
_
e;; .... •I I, II
, _ , , _, . . . 0.
•JI'I
~•-!'"'*o •I I --~,~--··
::~:.-'_-,-,_ ".r..~-- j-Figura 3.3 - Editores de tarefa e processo
Para modelar a carga de trabalho é necessário
utilizar três editores: usuário, tarefa e processo. No editor de usuário é necessário especificar: o número de tarefas a serem submetidas, a distribuição do intervalo
de chegada e os tipos de tarefas. Para cada tipo de
tarefa deve-se especificar a sua probabilidade de submissão. A soma destas probabilidades precisa ser igual a 100%. Os tipos de tarefas são selecionados por
meio do método de Monte Carlo, no qual um número
aleatório entre O e I é sorteado, indicando a tarefa a ser
submetida. Para cada nova instância de um tipo de
tarefa submetida, novos valores são amostrados para o
grau de paralelismo de cada processo e intervalo de chegada.
O editor de tarefa (Figura 3.3) permite a especificação de uma tarefa por meio de um grafo, no
qual cada vértice é um processo e cada aresta
representa a comunicação entre dois processos. A partir do editor de tarefa, é possível. editar cada processo ativando o editor de processo (F1gura 3.3). No editor de processo são inseridas as instruções de CPU
(qualquer instrução que não seja para comunicação ou
entrada e saída), EIS e MPI (comunicação) em blocos
de instruções e especificada a distribuição do grau de
paralelismo. Cada instrução tem a opção de ser paralelizada automaticamente de acordo com o grau de paralelismo do processo ou dos processos com quem ele se comunica. Por exemplo, suponha uma tarefa
paralela que segue o modelo fazenda de processos. Ela
seria modelada com dois vértices: o processo mestre
(grau de paralelismo igual a I) e o processo escravo
(grau de paralelismo n). Se a opção de paralelização
estiver ativada na instrução de CPU do escravo, o
número de instruções de CPU de cada escravo seria
igual ao número de instruções de CPU dividido pelo
grau de paralelismo n. Com isso, é possível verificar o
ganho da paralelização de uma tarefa, sem ter que
implementar uma tarefa diferente para cada grau de
paralelismo.
3.1.1.1.2. Arquitetura
Um aglomerado é composto denodos homogêneos
ou heterogêneos, redes de interconexão, sistema de
gerenciamento de tarefas, imagem de sistema único e
gerenciadores de passagem de mensagens e, em alguns
casos, de memória compartilhada distribuída. Cada
nodo possui um ou mais processadores, uma hierarquia
de memórias, dispositivos de EIS e um sistema
operacional [Buy99] [Hwa98]. No nosso modelo de
arquitetura, um aglomerado é representado
basicamente por nodos, um escalonador e uma rede de
interconexão.
I
TamanhoMensagemlSobreCarga= x SobrecargaProtocolo
MSS (Equação 3.1)
1T rasm1ssao . _
=
La t + ...:...----'=---=--'---';--___;. (ramMsg + SobreCarga)x
(1 +TErra)LarguraBanda x I 06
(Equação 3.2)
O escalonador implementa políticas de
escalonamento paralelo como compartilhamento de
espaço, backfilling, escalonamento de gangues e
outros. A rede de interconexão é representada pelos
seguintes parâmetros: latência (ns), largura de banda (MB/s), sobrecarga de protocolo (bytes), taxa de erro
(%), máximo tamanho de segmento - MSS (bytes) e
topologia (Figura 3.4 - Editor de Aglomerado).
Algumas topologias são suportadas, dentre elas
destacamos: barramento e switch. As equações 3.1 e
3.2 mostram a relação entre os parâmetros da rede para
o cálculo do tempo de transmissão de uma mensagem
entre dois nodos [Men03] [Pat98].
No modelo de simulação do ClusterSim, cada nodo
é representado pelos seguintes parâmetros:
escalonador, taxa de transferência da memória
principal e secundária e processadores (Figura 3.4). O
escalonador implementa algoritmos básicos como
Round-Robin e FCFS. Além disso, ele implementa
Foz do Iguaçu, 27 a 29 de Outubro de 2004
.... _ 1 ... ,
h,.tttrfs..t&ea ..,J
Figura 3.4- Editores de aglomerado e nodo
A taxa de transferência da memória principal é
utilizada pelo gerenciador de MPI, ao receber e enviar
dados. Já a taxa de transferência da memória
secundária serve para calcular o tempo gasto nas
leituras e escritas das instruções de E/S.
TempoExecução = 1 . x CPI x Númerolnstruções
Frequencta (Equação 3.3)
Um nodo possui um ou mais processadores, em que
cada processador é representado pela freqüência do
relógio e o número de ciclos por instrução. Para
calcular o tempo gasto para executar n instruções de
um programa, o processador utiliza a Equação 3.3
[Hen98].
3.1.1.1.3. Módulo Estatístico e de Desempenho Para cada simulação executada, o ClusterSim
fornece um log com o cálculo de diversas métricas. As
principais métricas calculadas são: tempo de resposta
médio dos processos e das tarefas; tempo de espera,
submissão, início e finalização de cada processo;
slowdown médio das tarefas; utilização média por
Anais doso Workshop de Computação de Alto Desempenho, WSCAD 2004
3.1.1.2. Entidades do ClusterSim
Cada entidade possui funções específicas dentro da
simulação. As principais entidades do ClusterSim são:
usuário, aglomerado e nodo. O usuário é responsável
por submeter um determinado número de tarefas ao
aglomerado seguindo um padrão de intervalo de
chegada. Além disso, cada tipo de tarefa possui uma
determinada probabilidade de ser submetida ao
aglomerado. Essa submissão é efetuada por meio da
geração de um evento de chegada de tarefa. Ao receber
esse evento, o aglomerado deve decidir para quais
nodos os processos da tarefa devem ser encaminhados.
Para isso, existe o escalonador do sistema de
gerenciamento de tarefas, que implementa determinado
algoritmo de escalonamento paralelo. Outras classes ou
componentes importantes pertencentes à entidade
aglomerado são: o gerenciador de MPI, imagem de
sistema único e rede de interconexão.
A imagem de sistema único funciona como um
sistema operacional do aglomerado, recebendo e
encaminhando eventos para as classes responsáveis
pelo tratamento do evento. Além disso, ela gera
periodicamente o evento de fim de fatia de tempo, para
indicar aos escalonadores de cada nodo, que mais uma
fatia de tempo se esgotou.
Para suportar passagem de mensagens entre os
processos, as classes rede e gerenciador de MPI
implementam certos mecanismos básicos de
comunicação. Assim que um processo passa a executar
uma função MPI (MPI_Send(), MPI_Barrier() etc.), o gerenciador de MPI interpreta a função e caso seja uma
função de envio, ele aciona a classe rede, que gera um
evento de chegada de mensagem. O tempo gasto para a
mensagem trafegar de um nodo para o outro depende
da topologia, parâmetros da tecnologia de rede e
contenção. Quando um evento de chegada de
mensagem chega ao seu destino, o gerenciador de MPI
gera um evento de desbloqueio de processo, caso um
processo esteja esperando. Caso contrário, a mensagem
é armazenada em uma fila de mensagens. Ao receber
um evento de fim de tarefa, o escalonador do
aglomerado deve retirar a tarefa de execução. A Figura
3.5 mostra o diagrama de eventos do ClusterSim,
detalhando a interação entre as entidades usuário,
aglomerado e nodo. Algumas classes foram omitidas
no diagrama para sua simplificação.
Uma entidade aglomerado é composta de várias
entidades nodo. Ao receber um evento de chegada de
tarefa, pela classe escalonador de nodo, o nodo
acrescenta os processos destinados a ele em uma fila de
processos. A cada tique do relógio global de simulação
o escalonador é chamado para executar processos nos
processadores do nodo. Como cada processo é
composto de instruções de CPU, E/S e MPI
(comunicaçã0), ao final de cada uma dessas instruções
um evento é gerado. ~ Aglomerado __llllL<lo ca.., ... 'lwof• ~ &c-'onedor
...
T f Etc.aGn4Mior-
..
::(
7-::
J
G.,..-:ledor.
dcHPI~
ISU..
...
-<
Proces..ctor Rede....
_
..
.
.
.
, ... 4• ""...
Q--WM E/$Figura 3.5- Diagrama de troca de eventos
entre as entidades
A cada processo é atribuído um quantum (intervalo
de tempo), que quando esgotado, deve gerar um evento
de fim de quantum, para que o escalonador execute as
ações necessárias (trocar prioridades, retirar o processo da cabeça da fila etc.). Quando o processador executa todas as instruções de um processo, um evento de fim de processo é gerado para o escalonador.
3.1.1.3. Núcleo do ClusterSim
O núcleo é composto pela JSDESLib (Java Simple
Discrere Evenr Simulation Library), uma biblioteca
multithread de simulação discreta por eventos em Java,
que tem como principal objetivo simplificar o
desenvolvimento de ferramentas de simulação
baseadas em eventos.
3.2. Exemplo de Uso da Ferramenta ClusterSim Para mostrar o uso da ferramenta, simulamos uma carga de trabalho simples composta de duas tarefas. Na Figura 3.6, cada grafo representa uma tarefa, no qual os nodos são os processos e as arestas indicam troca de
mensagens entre os processos. O valor em cada nodo e
aresta indica o tempo gasto em segundos para realizar
o processamento (instruções de CPU) ou comunicação.
Por exemplo, a Tarefa 2 (Fig. 3.6 (b)) representa uma
fazenda de processos, na qual o processo mestre envia
dados para os escravos, que então processam esses
dados e os retornam para o processo mestre. Como o
ClusterSim não utiliza o tempo de execução como
parâmetro de entrada, os tempos das tarefas foram
convertidos para instruções de CPU e bytes enviados.
Como uma arquitetura exemplo, criamos um
aglomerado composto de 4 nodos homogêneos e um
barramento, com a variação do algoritmo de
escalonamento paralelo (escalonamento de gangues,
Round-Robin e FCFS). As mensagens enviadas ao
barramento são enfileiradas e enviadas uma a uma pela
(a) (b)
Figura 3.6-Tarefas da carga de trabalho para o
exemplo de uso do ClusterSim:
(a) Tarefa 1; (b) Tarefa 2
Nas Figuras 3.7, 3.8 e 3.9, podemos observar a
execução analítica, passo a passo, da carga de trabalho,
para cada algoritmo de escalonamento paralelo. Cada
linha representa a execução dos processos das tarefas
ao longo do tempo em um nodo. É importante ressaltar
que a rede de interconexão é um meio compartilhado e
permite que apenas uma mensagem seja enviada a cada
momento. P1 P2 P3 P4
.._
...
i!i ,__ ... RK ... CJ'"-.. u.-.. ou IJ-M· ... -I i I I • " Jl " . .Figura 3.7-Diagrama de execução das tarefas
usando o algoritmo Round-Robin
O algoritmo Round-Robin apresentou o menor
tempo de execução, pois ele permite uma maior
concorrência entre os processos de tarefas diferentes,
ou seja, quando um processo da tarefa I está
comunicando, um processo da tarefa 2 pode utilizar o
processador. Já o FCFS, permite que apenas uma tarefa
seja executada de cada vez no aglomerado, portanto os
recursos são pouco utilizados e as tarefas têm um
maior tempo de reação.
Figura 3.8 - Diagrama de execução das tarefas
usando o algoritmo FCFS
Foz do Iguaçu, 27 a 29 de Outubro de 2004
Por último, o algoritmo de escalonamento de gangues utilizou uma fatia de tempo igual a 5 segundos
e apresentou melhor resultado que o FCFS, mas pior
que o Round-Robin. O escalonamento de gangues
obtém alto desempenho no escalonamento de tarefas·
com baixa granularidade. As tarefas utilizadas no teste
e na verificação do ClusterSim se comunicam pouco e
são caracterizadas pela alta granularidade, mas apesar
disso, o tempo de execução total foi menor que o
FCFS, pois o escalonamento de gangues permite a
concorrência entre as tarefas, aumentando a utilização
dos recursos. l•g•nde iJ...,_ ........ _ .. _ ......... CJ .... v. .... aou IJ_ ,_.__ t I 11 1l H M H H • 4 M " ü U N IS H
Figura 3.9 - Diagrama de execução das tarefas
usando o algoritmo de escalonamento de gangues com primeiro encaixe
4.
Análise
de
Desempenho
de
Escalonamento Paralelo de Tarefas
Neste capítulo, enfocamos na análise de
desempenho de vários algoritmos de escalonamento
paralelo de tarefas, sob diferentes cargas de trabalho e
um aglomerado de computadores. Estudo dos vários
componentes dos algoritmos de EPT, apresentação de
tabelas e gráficos com os dados estatísticos e de
desempenho obtidos nas simulações. Além disso,
disponibilizamos um site com a ferramenta e diversos
exercícios práticos que podem ser resolvidos pelos alunos, utilizando o ClusterSim.
4.1. Aglomerado de Computadores
O modelo de arquitetura selecionado para a
simulação é um aglomerado consistido de 16 nodos
monoprocessados e um front-end com processadores
Intel Pentium III I GHz (freqüência real
=
0.938 GHz) interconectados por um switch Fast Ethernet. Essenúmero de nodos é comumente utilizado, além disso,
reduz-se o tempo de simulação para cada simulação.
Aglomerados heterogêneos e com maior número de nodos poderiam ser testados, mas aumentaria muito o número de experimentos e os tempos de simulação. Por isso, utilizaremos apenas uma arquitetura durante os
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
testes. Na Tabela 4.1, apresentamos as características, e
seus respectivos valores, da arquitetura utilizada nas
simulações. Esses valores foram obtidos por meio de
bibliotecas de desempenho e benchmarks (Sandra
2003, P API 2.3 etc.).
Tabela 4.1 -Características da arquitetura do
aglomerado de computadores.
4.2. Cargas de Trabalho
Uma carga de trabalho é composta de um conjunto
de tipos de tarefas, suas respectivas probabilidades de
serem submetidas e estruturas internas, o número total
de tarefas e o intervalo de chegada entre elas. Devido à
falta de informação sobre a estrutura interna das
tarefas, decidimos utilizar um conjunto sintético de
tarefas, mas ao mesmo tempo levando em consideração
alguns aspectos relacionados com as cargas de trabalho reais estudadas e analisadas.
Na literatura estudada não são encontrados dados a
respeito do número de instruções de cada tarefa, apenas
sobre o tempo de execução. Como as tarefas no
ClusterSim são representadas pelo número de
instruções ao invés do tempo de execução, realizamos
alguns testes preliminares. Para isso fixamos o modelo
de algoritmo como fazenda de processos
(mestre/escravo) e o tamanho da mensagem trocada entre o mestre e os escravos a cada iteração (16 KB). E
variando o número de instruções e a granularidade,
determinamos tarefas com baixo e alto tempo de
execução. É importante ressaltar que tanto o número de
instruções, quanto o tamanho da mensagem é dividido
pelo número de escravos e o processo mestre apenas
cuida da comunicação.
Na Tabela 4.2, apresentamos o tempo de execução
de diferentes tipos de tarefas utilizando os seguintes
parâmetros:
• Granularidade Alta= 10 milhões de instruções
• Granularidade Baixa = I milhão de instruções • Número de Instruções Alto = I bilhão de
instruções
• Número de Instruções Baixo = I 00 milhões de
instruções
• Modelo de Algoritmo = Mestre/Escravo
• Tamanho da Mensagem= 16 KBytes
Tabela 4.2-Tempo de execução dos tipos de
tarefas (segundo~.
'"'; Graa de Pü*llfiU ~-~;~,\.; ~4-=- !I - 16 N' Instruções I GraJIII!arihde Bal.w I Baixo 106.92 27.38 22.22 9.43 Baixo I Alto 106.61 26.71 21.4 6.93 Alto /Baixo 1069.22 273.88 222.24 94.39 Alto I Alto 1066.13 267.19 214.06 69.38
Como o grau de paralelismo é relativo ao número
de processadores de um aglomerado, fizemos uma
proporção. Em máquinas paralelas com 128 e 256
processadores, tarefas com menos que 32 processos
são consideradas pequenas. Baseado na nossa
arquitetura com 16 processadores, usando uma
proporção, consideramos tarefas com menos que 4
processos como pequenas e de 5 a 16 como grandes.
Como apresentado nos trabalhos relacionados,
utilizaremos uma distribuição uniforme para
representar o grau de paralelismo.
Para os próximos tópicos, utilizamos a seguinte
notação para cada tipo de tarefa: NI/Gr/GP, onde NI
(Número de Instruções), Gr (Granularidade) e GP
(Grau de Paralelismo), que podem ter valor igual a A
(Alto) ou B (Baixo). Com isso, temos uma combinação
de 8 tipos de tarefas diferentes.
Para testar as políticas de escalonamento paralelo
de tarefas, nós montamos 12 diferentes cargas de
trabalho. Existem dois principais aspectos em que uma
tarefa pode influenciar no escalonamento de gangues:
espaço e tempo. O espaço está ligado ao grau de
paralelismo de cada tarefa e o tempo ao resto dos
fatores. Então combinamos esses dois aspectos ortogonais para formar quatro tipos de carga de
trabalho, para tentar modelar a maior parte das cargas
de trabalho possíveis. O primeiro tipo é predominado
por (a maioria das 60%, 80% ou 100%) tarefas com alto grau de paralelismo e com uma estrutura que garanta um alto tempo de execução. O segundo possui
tarefas com alto grau de paralelismo e baixo tempo de
execução. Já o terceiro, possui a maioria das tarefas
com baixo grau de paralelismo e alto tempo de
execução. Por último, o quarto tipo de carga de
trabalho é predominado por tarefas com baixo grau de
paralelismo e com baixo tempo de execução. Cada um
desses tipos de carga de trabalho pode ser representado
por uma porcentagem de tarefas com as características
principais da carga. Para cada tipo de carga, variamos o
grau de predominância em 60%, 80% e I 00%. Por exemplo, a carga AA60 é composta por 60% de tarefas do tipo A/*/A e 40% de outros tipos de tarefas. Na Tabela 4.3, apresentamos as cargas de trabalho, as
tarefas que as compõem e suas respectivas
Tabela 4.3 - Descrição dos tipos de carga de trabalho. , . . . j.,. ( " ' ' ) .I "' ... - e • , .:(,'I~ 11 '1. l iã. ~ ~ ... t . . . . ... • ~~~lr5!:... úfui~ ~~·'*-~';:~.;~~:- ~ ,•!~.~~'11ff~ .. :1:~~-~~:·~~.::~ AM J()'!(, BBA J()'!(, ABA J()'!(, BA60 BM JO'lfo-AABJ BBB 20'!(, AAJ3 20'!(, 8AB 20'!(, ABB 20'!(, AM 40'!(, BBA 40'!(, ABA 40'!(, BABO BM 40'!(, AA.80 BBB 10'lb AAJ3 10'!(, 8AB 10'!(, ABB 10'!(, AM 50'!(, BAlOO BBA 50'!(, AAlOO ABA 50'!(, BM 50'!(,
AAJ3 JO'lb BBB JO'lb
AB8 JO'lb BB60 8AB 30'lb
AB60 BBA 20'lb AM 20'!(, BM 20'!(, ABA 20'!(, AAJ3 40'!(, BBB 40'!(, ABB 40'!(, BB30 8AB 40'!(, ABSO BBA 10'!(, AM 10'lb BM 10'!(, ABA 10'!(, AAJ3 50'!(, BBlOO 888 50'!(,
ABlOO ABB 50'!(, 8AB 50'!(, Em todas as cargas utilizamos o número total de tarefas igual a l 00 e o intervalo de chegada representado por uma distribuição hiper-exponencial Erlang de primeira ordem. Para simular uma carga mais pesada ou intensa, ou seja, maior número de
submissões de tarefas por intervalo de tempo,
utilizamos um fator de carga igual a I 00. O intervalo de chegada é dividido por esse fator, intensificando a submissão de tarefas. Este valor foi obtido através de testes preliminares.
4.3. Planejamento dos Experimentos
Para avaliar o desempenho dos algoritmos de escalonamento paralelo de tarefas, selecionamos
configurações do escalonamento de gangues. Uma
configuração é composta por um esquema de
empacotamento, esquema de desfragmentação, nível de
multiprogramação e uma política de remoção. A Tabela 4.4 apresenta algumas das configurações
possíveis de um algoritmo de escalonamento de
gangues. O valor do nível de multiprogramação
limitado foi 3. Quando o nível de multiprogramação é ilimitado, não faz sentido utilizar uma política de remoção, pois a fila de espera não é utilizada.
Cada uma das 12 configurações foi testada com cada uma das 12 cargas de trabalho utilizando lO diferentes sementes de simulação, para aumentar a confiabilidade estatística dos resultados. As sementes escolhidas foram: 51, 173, 19,531,211,739,413,967, 733 e 13. Com isso, ao todo, foram realizados 1440 simulações.
Foz do Iguaçu, 27 a 29 de Outubro de 2004 Tabela 4.4- Configurações de um algoritmo de
escalonamento de gangues.
~
~
1._~~~-''- -::i-1!~--I Coall
""""*
-
...
Ex ... ~'"""""eoarn
-
SJF ,_,..-eo.ro:
-
CFS 'rilooilo-
:ioFOI . .~ ~ SJF_ >FOI . .
...
u...» ... E.< ...'"-
""
-
u...»...
foFo! . .-
:FS -:...
:..
.
u.om ~ --4.4. Análise das Simulações
Esta seção foi organizada da seguinte maneira: para cada métrica utilizada, apresentamos os valores médios obtidos para cada simulação (carga x configuração) e também a análise de cada um dos componentes de um algoritmo de escalonamento de gangues em relação à métrica.
4.4.1. Análise da Utilização
A utilização é uma métrica muito importante do ponto de vista da utilização dos recursos (processadores) de um aglomerado. Portanto, quanto maior a utilização, menor a ociosidade do aglomerado.
Na Figura 4.1, apresentamos os valores médios da utilização do aglomerado para as diferentes cargas de trabalho e configurações.
Cada componente do escalonamento tem uma certa influência no desempenho do sistema. Por isso. cada
componente do algoritmo deve ser analisado
isoladamente. Para isso, comparamos as linhas da Figura 4.1 par a par. Por exemplo, para compararmos os esquemas de empacotamento, calculamos a diferença entre a utilização média da Confl e Conf7, Conf2 e Conf8 etc., para cada carga de trabalho.
Utilização x Carga de Trabalho
9.0 , - - - -- - , r.,::cc:-:-on::-::11:-:-2-::-:(U.ef=ISU)~-,
80
CConl11 (u.ef/AS)
~ Conll O (LJS.t' .eF ISU) •Conl9 (l*Cfs.et'ISU) Conl8 (USJF .eF /AS) ,.Cont7 (l*Cfs.et'/AS) c Cont6 (UA'f ISU) ,-.conts (UA'ftAS) cConl4 (USJFffiSU)
c~ContJ Cl*CFSffiSU)
• Cont2 (USJFff/AS)
t~COI\11 Cl*CFSff/AS)
Anais do 5° Workshop de Computação de Alto Desempenho, WSCAD 2004
Em relação ao esquema de empacotamento, quando o nível de multiprogramação é ilimitado, o primeiro encaixe é bem melhor para as cargas AB e BA. Em um primeiro momento, o esquema melhor encaixe
encontra o melhor espaço para uma tarefa, mas a longo prazo, essa decisão pode comprometer a entrada de novas tarefas em posições mais apropriadas e até mesmo a eficácia dos esquemas de desfragmentação.
No caso de uma carga composta por tarefas AB e BA, essa chance de insucesso aumenta, pois as tarefas demoradas (longas) com baixo grau de paralelismo,
que restarem após a execução das tarefas curtas e com
alto grau de paralelismo, provavelmente ocuparão
colunas em comum, dificultando a desfragmentação da
matriz. O primeiro encaixe, por sua vez, a princípio deixa a matriz com mais espaços ociosos, além de aumentar o número de linhas da matriz, mas a longo prazo isso facilitará a desfragmentação da matriz, pois
as tarefas terão menos colunas em comum.
Como observado na Figura 4.2, na média, quanto à utilização, o melhor encaixe é um pouco melhor nos outros casos. Mas de uma maneira geral, podemos
concluir que os dois esquemas de empacotamento possuem desempenho equivalente. Tal como a Figura 4.2, quando não especificado, o valor médio utilizado é calculado como a média para todas as 12 cargas de trabalho. Esquemas de Empacotamento 0.7 . , . . . - - - , 0.6 C01·07 C02.08 C03·09 C04·10 COS.-11 C06·12 Conflguraç6es I:IPrlmelro Encaixe • Melhor Encaixe
Figura 4.2-Utilização média em relação aos
esquemas de empacotamento.
Quanto ao esquema de desfragmentação, podemos
notar que não existe uma diferença significativa entre
os dois esquemas de desfragmentação (Figura 4.3). Nas
cargas com nível de multiprogramação ilimitado, na
média, o escalonamento alternativo apresenta uma pequena vantagem. Pelo número maior de fatias ou linhas da matriz, existe uma maior possibilidade de que uma tarefa seja executada em diversas fatias diferentes,
assim que outras tarefas forem terminando e deixando
espaços ociosos. Mas de uma maneira geral, podemos concluir que os esquemas de desfragmentação
utilizados são equivalentes, isso não quer dizer que eles não interfiram no resultado. Eles são importantes, mas em um nível de igualdade. 0.7 0.6
..
~ o.s :I 0.4·J
0.3 ~ 0.2 0.1 Esquemas de DesfragmentaçãoOll-03 C02·04 Ol5-06 C07·09 Ol8·10 C11·12
Conflguraç6u
Figura 4.3- Utilização média em relação aos
esquemas de desfragmentação.
Em relação ao nível de multiprogramação, tiramos duas conclusões: o ilimitado é melhor para cargas AA e BB (Figura 4.4), mas é péssimo para cargas AB e BA
(Figura 4.5). Com nível de programação ilimitado, para cada nova tarefa que não se encaixe na matriz, é criada uma linha nova. Como a taxa de chegada de tarefas é
alta, ao final da simulação, um número alto de linhas foi criado (É importante lembrar que em cargas com predominância AA, as tarefas restantes são BB, ou
seja, o caso oposto.). Neste caso, as tarefas grandes são
certamente as mais demoradas, portanto mesmo quando as tarefas pequenas terminam, o espaço ocioso deixado por elas é significativamente menor que o espaço ocupado pelas tarefas grandes, ou seja, a
fragmentação é bem pequena, maximizando a
utilização do sistema.
0.6
..
~ o.s :I 0.4 ·~..
0.3 ~ 0.2!i
0.1Nlveis de Multlprogramação Carga AA-BB
Ol1·02·05 C03·04·06 C07·08·11 Ol9·1D-12
Configurações
O Llmilado FCFS
• Liml1ado SJF
Olllmilado
Figura 4.4- Utilização média em relação ao nível de multiprogramação para cargas AA-BB.
Quando cargas compostas de tarefas AB e BA são
utilizadas, cada linha da matriz será ocupada por tarefas com longa e curta duração. Ao longo do tempo,
as tarefas de curta duração irão acabar, deixando espaços ociosos na matriz, ou seja, alta fragmentação. Esses espaços não serão preenchidos por novas tarefas,
pois todas já foram alocadas a matriz. Neste caso, as
tarefas grandes não são garantidamente as mais demoradas, por isso muito espaço na matriz pode ser
