Balanceamento de Carga e Detec

1
Balanceamento de Carga e Detecção de Terminação
2
Balanceamento de carga e detecção de terminação

• Balanceamento de carga
• utilizado para distribuir o processamento entre
  os processadores (ou processos) de modo a obter
  a maior velocidade possível de execução
• Detecção de terminação
• utilizada para determinar quando um processamento
  chega ao seu fim e é especialmente mais difícil
  de implementar quando a computação é distribuída
  

3
Balanceamento estático

• Nesse tipo, a tentativa de balanceamento de carga
  ocorre antes da execução de qualquer processo
• Algumas técnicas potenciais
• algoritmo round-robin
• distribui as tarefas na ordem seqüencial dos
  processadores, voltando ao primeiro quando todos
  processadores tiverem recebido uma tarefa
• algoritmos aleatórios
• seleciona os processadores de forma aleatória
  para executar as tarefas
• bisecção recursiva
• divide recursivamente o problema em subproblemas
  de igal esforço computacional enquanto tenta
  minimizar a quantidade de troca de mensagens
• simulated annealing, genetic algoritms
• técnicas de otimização

4
Problemas com o balanceamento estático

• Difícil estimar com precisão os tempos de
  execução das várias partes de um programa sem
  realmente executá-las
• Atrasos de comunicação que variam sob
  circunstâncias diferentes
• Alguns problemas possuem um número indeterminado
  de passos para atingir a sua solução

5
Balanceamento dinâmico

• Realizado durante a execução do processo
• Os problemas indicados para o balanceamento
  estático são levados em consideração, fazendo-se
  com que a divisão da carga dependa da execução
  das partes do programa à medida que elas são
  executadas
• Provoca um overhead maior na execução do
  programa,mas geralmente é mais eficiente que o
  balanceamento estático

6
Processos e processadores

• A computação é dividida em tarefas a serem
  realizadas, que são executadas por processos
  mapeados em processadores
• O objetivo é manter os processadores ocupados a
  maior parte do tempo possível
• Geralmente mapeamos um único processo em um
  processador, então utilizaremos os termos
  processo e processador de alguma forma
  indiscriminada

7
Balanceamento dinâmico

• Duas classificações
• centralizado
• as tarefas são manipuladas de uma localização
  central
• existe uma clara estrutura mestre-escravo
• não-centralizado
• as tarefas são circuladas por entre processos
  arbitrários
• uma coleção de processos trabalhadores opera
  sobre um problema e interage entre eles,
  reportando o resultado final a um único processo
• um processo trabalhador pode receber tarefas de
  outros processos trabalhadores e pode enviar
  tarefas para outros processos trabalhadores

8
Balanceamento dinâmico centralizado

• Um processo mestre mantém a coleção de tarefas a
  serem executadas
• As tarefas são enviadas para os processos
  escravos pelo processo mestre
• Quando um processo mestre finaliza sua tarefa,
  pede uma nova para o processo mestre
• Termos utilizados repositório(pool) de trabalho,
  trabalhadores replicados, fazenda de
  processadores

9
Terminação

• A computação deve ser parada quando a solução for
  atingida
• Quando as tarefas são retiradas de uma fila de
  tarefas, a computação termina quando
• a fila de tarefas está vazia E
• todos os processos pediram uma nova tarefa e
  nenhuma nova tarefa foi gerada
• A condição da fila estar vazia não é suficiente
  porque podem existir processos sendo executados
  que podem gerar novas tarefas para a fila
• Em algumas aplicações, o escravo pode detectar a
  condição de término do programa por uma condição
  de término local, tal como encontrar um item em
  um algoritmo de procura

10
Mecanismos de transferência de tarefas - Iniciado
pelo receptor

• Um processo seleciona um outro processo e pede
  tarefas a ele
• Tipicamente, um processo pede tarefas a
  outro,quando ele tem poucas ou nenhuma tarefa a
  executar
• Se mostrou eficiente para sistemas com carga alta
• Pode ser muito custoso determinar a carga de cada
  processo

11
Mecanismos de transferência de tarefas - Iniciado
pelo processo que envia

• Um processo seleciona um outro processo e envia
  tarefas para ele
• Tipicamente, um processo com uma carga pesada
  passa algumas tarefas a outro, que estiver
  disposto a recebê-las
• Se mostrou eficiente para sistemas com carga leve
• Pode se misturar os dois métodos
• Mas é custoso determinar a carga dos processos
• Em sistemas muito carregados, o balanceamento de
  carga pode ser difícil de ser atingido por falta
  de processos disponíveis

12
Algoritmos para seleção de processo para método
descentralizado

• Algoritmo round-robin
• o processo Pi pede tarefas ao processador Px ,
  onde x é dado por um contador que é incrementado
  depois de cada pedido, utilizando aritmética
  módulo n (quando existem n processos), excluindo
  x I
• Algoritmo de polling aleatório
• o processo Pi pede tarefas ao processo Px, onde x
  é um número selecionado aleatoriamente entre 0 e
  n-1 (excluindo i)

13
Balanceamento de carga utilizando um estrutura de
pipeline

• O processo mestre alimenta a fila com tarefas em
  uma extremidade e as tarefas são deslocadas para
  o final da fila
• Quando um processo trabalhador, Pi (1 lt i lt n)
  detecta uma tarefa na sua entrada da fila e o
  processo está inativo, ele pega a tarefa da fila
• As tarefas à esquerda são arrastadas ao longo da
  fila de modo a preencher o lugar deixado pela
  tarefa e uma nova tarefa é inserida na
  extremidade esquerda da fila
• Ao final, todos os processos pegarão uma tarefa e
  a fila será preenchida com novas tarefas
• Tarefas de maior prioridade ou tamanho podem ser
  colocadas em primeiro lugar na fila

14
Código utilizando compartilhamento de tempo entre
computação e comunicação

• Processo mestre
• for (i 0 i lt no_tasks i)
• recv(P1, request_tag)
• send(task, P1, task_tag)
• recv(P1 , request_tag)
• send (empty, P1 , task_tag)

15
Código utilizando compartilhamento de tempo entre
computação e comunicação

• Processo Pi (1ltiltn)
• if (buffer empty)
• send(Pi-1, request_tag)
• recv(buffer, Pi-1, task_tag)
• if ((buffer full) (!busy))
• task buffer
• buffer empty
• busy TRUE
• nrecv(Pi1, request_tag, request) / não
  bloqueante p/ testar mens. da direita /
• if (request (buffer full))
• send (buffer, Pi1)
• buffer empty
• if (busy)
• faça algum trabalho da tarefa
• se a tarefa acabou, atribua o valor false a
  busy

16
Rotinas de recebimento não bloqueantes PVM

• A rotina pvm_nrecv() retorna o valor zero se
  nenhuma mensagem foi recebida
• A rotina pvm_probe() pode ser utilizada para
  verificar se uma mensagem foi recebida sem ter
  que ler a mensagem
• Depois, utiliza-se a rotina recv() para ler a
  mensagem e desempacotá-la

17
Rotinas de recebimento não bloqueantes MPI

• A rotina não bloqueante MPI_Irecv() retorna um
  identificador de requisição, que pode ser
  utilizado em rotinas subseqüentes para esperar
  por mensagens ou para descobrir se a mensagem já
  foi realmente recebida no ponto de chamada da
  rotina (MPI_Wait() e MPI_Test(), respectivamente)
  
• Essa rotina coloca um pedido por uma mensagem e
  retorna imediatamente

18
Algoritmos distribuídos para detecção de
terminação - condições de terminação

• Condições de terminação em um determinado tempo t
  
• as condições locais de terminação específicas da
  aplicação existem em uma coleção de processos no
  tempo t
• não existem mensagens em trânsito entre os
  processo no tempo t
• A diferença entre essas condições de terminação e
  aquelas para o esquema centralizado é ter que
  levar em conta as mensagens em trânsito
• A segunda condição é necessária porque uma
  mensagem em trânsito pode reinicializar um
  processo terminado
• Mais difícil de ser reconhecida a terminação
• O tempo para o trânsito das mensagens entre
  processos não é previamente conhecido

19
Algoritmos distribuídos para detecção de
terminação - mensagens de confirmação

• Cada processo está em um dos dois estados
• inativo
• ativo
• O processo que enviou uma tarefa para um outro
  processo de modo que ele entrou no estado ativo
  se torna pai desse processo
• Quando um processo recebe uma tarefa de um outro
  processo, que não seja seu pai, ele envia uma
  mensagem de confirmação
• Ele só envia uma mensagem de confirmação para o
  pai quando ele estiver pronto para se tornar
  inativo, isto é
• existe a condição local de terminação
• as confirmações para todas as mensagens recebidas
  foram enviadas
• as confirmações de todas as mensagens enviadas
  foram recebidas

20
Algoritmos distribuídos para detecção de
terminação - algoritmo do anel em passo único

• Quando P0 termina, ele gera um sinal que é
  passado para P1
• Quando Pi (1lt i lt n) recebe o sinal e já
  terminou, ele passa o sinal para Pi1. Caso
  contrário, ele espera por sua condição de
  terminação local e quando a atinge passa o sinal
  para Pi1. Pn-1 passa o sinal para P0
• Quando P0 recebe o sinal de volta, ele sabe que
  todos os processos do anel terminaram, e uma
  mensagem informando o término global pode ser
  enviada a todos os processos
• O algoritmo assume que um processo não pode ser
  reativado após ter atingido sua condição de
  terminação local (não se aplica a problemas com
  pool de trabalho)

21
Algoritmos distribuídos para detecção de
terminação - algoritmo do anel em dois passos

• Pode tratar processos reativados mas requer duas
  passagens pelo anel
• Caso um processo Pi passe uma tarefa para Pj,
  onde j lt i depois do sinal de terminação ter
  passado por Pj, necessita-se circular o sinal de
  terminação novamente ao longo do anel
• Para diferenciar as duas situações, colorem-se os
  sinais e os processos de branco e preto
• Quando um sinal preto é recebido significa que
  uma terminação global pode não ter ocorrido e o
  sinal tem que percorrer o anel novamente

22
Algoritmo do anel em dois passos

• P0 se torna branco quando termina e gera um sinal
  branco para P1
• O sinal é passado através do anel de um processo
  para outro assim que o processo termine. Se Pi
  passa uma tarefa para Pj onde jlti, ele se torna
  um processo preto, caso contrário ele é um
  processo branco. Um processo preto colore um
  sinal de preto e o passa a frente, e um processo
  branco passa o sinal para frente com a cor
  original recebida. Depois que Pi passa o sinal,
  ele se torna um processo branco. Pn-1 passa o
  sinal para P0
• Quando o processo P0 recebe um sinal preto, ele
  passa um sinal branco e se ele recebe um sinal
  branco, todos os processos terminaram

23
Algoritmo da energia fixa

• O sistema inicia com a energia toda em um
  processo denominado mestre
• O mestre passa partes da energia junto com as
  tarefas enviadas aos processos que pediram
  tarefas
• Se esses processos recebem pedidos de tarefas, a
  energia é dividida em mais partes e passada aos
  processos
• Quando um processo fica inativo, ele envia a
  energia de volta antes de pedir uma nova tarefa
• Um processo não envia de volta sua energia até
  que a energia que ele enviou seja retornada e
  combinada com a energia total que ele possui

24
Problema do caminho mínimo

• Dado um conjunto de nós conectados por ligações
  que possuem um peso associado a elas, encontre o
  caminho de um nó específico para outro nó
  específico de modo que ele apresente a menor soma
  acumulada de pesos
• Os nós conectados podem ser descritos por um
  grafo, onde os nós são chamados de vértices e as
  ligações de arestas
• Se as arestas só podem ser atravessadas em uma
  direção, denominamos o grafo de grafo direcionado

25
Problema do caminho mínimo - Aplicações

• A menor distância entre duas cidades ou outros
  pontos do mapa, onde os pesos representam
  distâncias
• A rota mais rápida para viajar, onde os pesos
  representam os tempos
• A maneira mais barata de viajar de avião, onde os
  pesos representam os custos dos vôos entre as
  cidades
• A melhor rota para enviar uma mensagem entre
  computadores de modo a se obter um atraso mínimo
  no envio
• O melhor modo de subir uma montanha dado um mapa
  do terreno com os seus contornos

26
Representação de grafos

• Matriz de adjacências
• um array bidimensional a, onde cada elemento
  aij armazena o peso associado à aresta entre
  o vértice i vértice j, se ela existir
• Lista de adjacências
• para cada vértice existe uma lista de vértices
  diretamente conectadas ao vértice por uma aresta
  e os pesos correspondentes de cada aresta
• Matriz de adjacências são utilizadas para grafos
  densos
• Lista de adjacências são utilizadas para grafos
  esparsos
• As duas estruturas podem requerer espaços de
  armazenamento diferentes
• Acesso à lista de adjacências mais lento que
  acesso à matriz de adjacências

27
Procura do menor caminho em grafos

• Dois algoritmos conhecidos com uma única fonte
• Moore (1957)
• Dijkstra (1959)
• Algoritmo de Moore mais fácil de paralelizar
• Os pesos devem ser todos positivos

28
Algoritmo de Moore

• Iniciando com um vértice fonte, utiliza-se o
  seguinte algoritmo para se avaliar um vértice i
• encontre a distância ao vértice j através do
  vértice i e a compare com a menor distância
  corrente ao vértice j
• troque a menor distância, caso a distância
  através do vértice i seja menor, ou seja,
  djmin(dj,diwi,j), onde di é a distância
  corrente do nó fonte para o vértice i e wi,j é o
  peso da aresta entre o vértice i e o vértice j

29
Algoritmo de Moore - Estruturas de dados e código

• Uma fila do tipo primeiro-a-entrar-primeiro-a-sair
  para armazenar a lista de vértices a serem
  examinados (inicialmente somente o vértice fonte
  está na fila)
• A menor distância corrente do vértice fonte ao
  vértice i será armazenada em um array disti que
  são inicializadas com o valor infinito (onde
  temos n vértices, 1 lt i lt n e vértice 0 é o
  vértice fonte)
• Suponha que wij armazene o peso da aresta
  entre os vértices i e j e considere o código
  abaixo
• newdist_j disti wij
• if (new_dist_j lt distj) dist j newdist_j
• Quando uma menor distância é encontrada para o
  vértice j, adiciona-se esse vértice à fila (se
  já não estiver) que vai fazer com que esse
  vértice seja examinado novamente

30
Código seqüencial

• A rotina next_vertex () retorna o próximo vértice
  da fila ou o valor no_vertex, caso fila vazia
• Utiliza-se uma matriz de adjacências denominada
  w
• while ((i next_vertex()) ! no_vertex)
• for (j 0 j lt n j)
• if (wij ! infinity)
• newdist_j disti wij
• if (new_dist_j lt distj)
• dist j newdist_j
• append_queue(j)

31
Implementação paralela com pool centralizado de
trabalho

• O pool mantém a fila de vértices e envia vértices
  para cada escravo
• Cada escravo obtém vértices da fila de vértices e
  envia novos vértices
• Como a estrutura utilizada para armazenar os
  pesos das arestas do grafo é fixa, pode-se
  copiá-la para cada escravo

32
Código para o mestre

• while (vertex_queue() ! empty)
• recv (PANY, source Pi)
• v get_vertex_queue()
• send(v, Pi)
• send(dist, n, Pi)
• .
• recv(j, distj, PANY, sourcePi)
• append_queue(j, distj)
• recv(PANY, sourcePi)
• send(Pi, termination_tag)

33
Código para o escravo (processo i)

• send (Pmaster)
• recv(v, Pmaster, tag)
• if (tag ! termination_tag)
• recv(dist, n, Pmaster)
• for (j 0 j lt n j)
• if (wvj ! infinity)
• newdist_j distv wvj
• if (newdist_j lt distj)
• distj newdist_j
• send(j, distj, Pmaster)

34
Pool de trabalho descentralizado

• Cada processo escravo i procura somente em volta
  do vértice i e possui uma entrada para esse
  vértice na fila de vértices caso ele exista na
  fila
• O array dist será distribuído entre os
  processos de modo que o processo i mantenha a
  mínima distância corrente para o vértice i
• O processo i também armazena a matriz/lista de
  adjacências para o vértice i, para identificar as
  arestas que saem do vértice i

35
Algoritmo de procura

• O vértice fonte é carregado no processo
  apropriado
• O vértice A é o primeiro vértice a ser analisado
  e o processo a ele associado é ativado
• Esse processo procura menores distâncias aos
  vértices conectados a esse vértice
• A distância ao vértice j será enviada ao processo
  j para que ele compare com o seu valor
  correntemente armazenado e o atualize caso seja
  maior
• Todas as menores distâncias são atualizadas
  durante uma procura
• Se os conteúdos de di mudam, o processo i será
  reativado para realizar o processo de procura
  novamente

36
Código para escravo (processo i)

• recv(newdist, PANY)
• if (newdist lt dist)
• dist newdist
• vertex_queue TRUE
• else vertex_qeue TRUE
• if (vertex_queue TRUE)
• for (j 0 j lt n j)
• if (wj ! inifnity )
• d dist wj
• send (d, Pj)

37
Código para escravo simplificado (processo i)

• recv(newdist, PANY)
• if (newdist lt dist)
• dist newdist
• for (j 0 j lt n j)
• if (wj ! inifnity )
• d dist wj
• send (d, Pj)

38
Mecanismo de terminação

• Mecanismo necessário para repetir as ações e
  terminar quando todos os processos estiverem
  inativos e realizar o tratamento das mensagens em
  trânsito
• Solução simples utilize o envio de mensagens
  síncrono, no qual o processo não pode continuar
  enquanto o destino não tiver recebido a mensagem
• Um processo ó está ativo quando um vértice
  estiver na fila, e é possível que vários
  processos fiquem inativos levando a uma solução
  ineficiente
• O método é praticamente impraticável para um
  grafo muito grande se somente um vértice for
  alocado para cada processador, deve-se utilizar
  um grupo de vértices