Analisando esquemas de balanceamento de carga para minimizar o tempo geral de execução

Suponha que um determinado aplicativo paralelo use um design mestre-escravo para processar um grande número de cargas de trabalho. Cada carga de trabalho leva algum número de ciclos para ser concluída; o número de ciclos que uma determinada carga de trabalho levará é dado por uma variável aleatória conhecida$X$. Suponha que existem$n$ cargas de trabalho e $m$escravos equivalentes (nós de processamento). Naturalmente, uma versão mais geral dessa questão aborda o caso de escravos de diferentes capacidades, mas ignoramos isso por enquanto.

O mestre não pode processar cargas de trabalho, mas pode distribuir cargas de trabalho para nós escravos e monitorar o progresso dos nós escravos. Especificamente, o mestre pode executar as seguintes ações:

1. Comece instantaneamente o processamento de qualquer $k$ cargas de trabalho em qualquer nó livre.
2. Receba instantaneamente a confirmação da conclusão por um nó de um lote iniciado anteriormente $k$ cargas de trabalho.
3. A qualquer momento e instantaneamente, determine o estado de todos os nós (livre ou ocupado), bem como o número de cargas de trabalho concluídas e o número de cargas de trabalho restantes.

Por uma questão de simplicidade, assuma $k$ divide $n$.

Existem pelo menos duas categorias de estratégias de balanceamento de carga para minimizar o tempo total de execução de todas as cargas de trabalho usando todos os escravos (para esclarecer, estou falando sobre o tempo do makepan ou do relógio de parede, não o tempo agregado do processo, independente do tempo de execução). estratégia de balanceamento de carga usada sob as suposições simplificadoras feitas nesta pergunta): estática e dinâmica. Em um esquema estático, todas as decisões de posicionamento são tomadas no momento$t = 0$. Em um esquema dinâmico, o mestre pode tomar decisões de posicionamento usando informações sobre o progresso que está sendo feito por alguns escravos e, como tal, pode ser obtida uma melhor utilização (na prática, existem custos indiretos associados ao planejamento dinâmico em comparação ao planejamento estático, mas nós ignore-os). Agora, para algumas perguntas:

1. Existe uma maneira melhor de planejar estaticamente cargas de trabalho do que dividir lotes de $k$ cargas de trabalho entre os $m$ escravos o mais uniformemente possível (também podemos assumir, por uma questão de simplicidade, que $m$ divide $n/k$, para que os lotes possam ser programados estaticamente de maneira completamente uniforme)? Se sim, como?
2. Usando a melhor política de planejamento estático, qual deve ser a média e o desvio padrão para o tempo total de execução, em termos da média $\mu$ e desvio padrão $\sigma$ do $X$?

Um balanceador de carga dinâmico simples pode agendar $i$ lotes de $k$ cargas de trabalho para cada escravo inicialmente e, em seguida, quando os nós concluírem o $i$ lotes, programe um lote adicional de $k$cargas de trabalho para cada escravo por ordem de chegada. Portanto, se dois nós escravos são inicialmente agendados com 2 lotes de 2 cargas de trabalho e o primeiro escravo termina seus dois lotes, um lote adicional é agendado para o primeiro escravo, enquanto o segundo escravo continua trabalhando. Se o primeiro escravo concluir o novo lote antes que o segundo lote termine seu trabalho inicial, o mestre continuará agendando para o primeiro escravo. Somente quando o segundo escravo concluir a execução de seu trabalho, será emitido um novo lote de cargas de trabalho. Exemplo:

         DYNAMIC           STATIC
         POLICY            POLICY

     slave1  slave2    slave1  slave2
     ------  ------    ------  ------

t<0    --      --        --      --

t<1  batch1  batch3    batch1  batch3
     batch2  batch4    batch2  batch4
                       batch5  batch7
                       batch6  batch8

t=1    --    batch3    batch5  batch3
             batch4    batch6  batch4
                               batch7
                               batch8

t<2  batch5  batch3    batch5  batch3
             batch4    batch6  batch4
                               batch7
                               batch8

t=2    --    batch4    batch6  batch4
                               batch7
                               batch8

t<3  batch6  batch4    batch6  batch4
                               batch7
                               batch8

t=3    --      --        --    batch7
                               batch8

t<4  batch7  batch8      --    batch7
                               batch8

t=4    --      --        --    batch8

t<5      -DONE-          --    batch8

t=5                      --      --

t < 6                      -DONE-

Para esclarecimento, os lotes 1 e 2 levam 1/2 segundo cada para serem processados, o lote 3 leva 2 segundos para serem processados ​​e os lotes 4-8 levam 1 segundo para serem processados. Esta informação não é conhecida a priori; no esquema estático, todos os trabalhos são distribuídos em t = 0, enquanto no esquema dinâmico, a distribuição pode levar em consideração quais são os tempos de execução reais dos trabalhos. Notamos que o esquema estático leva um segundo a mais que o esquema dinâmico, com o slave1 trabalhando 3 segundos e o slave2 trabalhando 5 segundos. No esquema dinâmico, os dois escravos trabalham por 4 segundos completos.

Agora, a pergunta que motivou a escrever isso:

1. Usando a política de balanceamento de carga dinâmico descrita acima, qual deve ser a média e o desvio padrão para o tempo total de execução, em termos da média $\mu$ e desvio padrão $\sigma$ do $X$?

Os leitores interessados ​​têm minhas garantias de que isso não é lição de casa, embora provavelmente não seja muito mais difícil do que se poderia esperar obter como lição de casa em determinados cursos. Dado que, se alguém se opuser a isso e exigir que eu mostre algum trabalho, ficarei feliz em obrigar (embora não saiba quando terei tempo no futuro próximo). Essa questão é, na verdade, baseada em algum trabalho que eu nunca cheguei a fazer um semestre ou dois atrás, e os resultados empíricos foram onde a deixamos. Obrigado pela ajuda e / ou esforço, ficarei interessado em ver o que vocês montaram.

Atualizar:

Para a nova versão em que você tenta minimizar o makepan, sua programação estática ainda possui o valor esperado ideal.

Deixei $M$seja a variável aleatória para o makespan. Deixei$F_i$ seja o escravo do tempo $i$está terminado. Nós então temos isso$M = \max_i(X_i)$. Deixei$c_i$ ser o número de trabalhos alocados ao escravo $i$. Então nós temos isso$X_i = \sum_{i=1}^{c_i} X = c_i X$.

E se $F_i(x)$ é a função cumulativa de distribuição de probabilidade para $X$, então $P(M < m)$ $= P(\max_i(X_i) < m)$ $= \prod_i P(X_i < m)$ $= \prod_i P(c_i X < m)$ $= \prod_i P(X < \frac{m}{c_i})$ $= \prod_i F(\frac{m}{c_i})$ é a função cumulativa de distribuição de probabilidade para $M$. Isso significa que$EM = \int_{-\infty}^{\infty} x (\prod_i F(\frac{x}{c_i}))' dx$ e $stddev(M) = \sqrt{\int_{-\infty}^{\infty} (x - EM)^2 (\prod_i F(\frac{x}{c_i}))' dx}$, como normal.

Minimizando $EM$ equivale a minimizar $\prod_i F(\frac{x}{c_i})$, o que significa que queremos manter tudo $c_i$s igualmente baixo (como $F$está aumentando monotonicamente e entre 0 e 1). Isso significa que devemos distribuir igualmente todas as tarefas entre os escravos, exatamente o que sua agenda estática alcança.