Mecanismo de migração

O modelo de migração de tarefas no sistema de memórias distribuídas não- compartilhadas utilizado neste trabalho é baseado no modelo de migração por cópia. Este modelo é muito simples com alto custo de migração, já que todo o contexto (código, dados, pilha, e conteúdo de registradores internos) é migrado.

O sistema de simulação Serpens tem suporte para processadores de mesma ISA (Instruction Set Architecture) (embora eles possam ter diferentes organizações). Tradução binária entre os processadores não é exigida pelo fato da homogeneidade dos processadores (mesma ISA). No entanto, a plataforma utilizada neste trabalho é totalmente homogênea, ou seja, todos os processadores utilizados têm mesma organização.

Tarefas podem ser migradas de dois tipos de núcleos: núcleo de referência e núcleo mestre. A rede-em-chip sem a presença de núcleos mestres obrigatoriamente necessita de pelo menos um núcleo de referência. O núcleo de referência é um núcleo escravo qualquer, que aloca tarefas e este pode executar tarefas da aplicação. No entanto, os custos dos algoritmos de alocação (bin-packing) não são considerados. Por outro lado, o núcleo mestre é um núcleo dedicado a apenas executar o algoritmo de alocação. Todavia, os custos de gerenciamento são levados em conta. Em cada processador, existem mecanismos de comunicação inter-tarefas baseados em mensagens (uso das primitivas send e receive). Como mencionado na Seção 5.1.4, tais primitivas suportam três tipos de mensagens: mensagens de comunicação inter-tarefas; mensagens de migração de tarefas e mensagens de gerenciamento. Quando um evento de migração ocorre originado do processador mestre, a primitiva send escreve no cabeçalho de uma mensagem um identificador de serviço (MIG) (Figura 5.6) o valor “01” (o valor “00” indica uma mensagem de comunicação inter-tarefas e o valor “10” indica uma mensagem de gerenciamento conforme Tabela 5.2), determinando que a mensagem é o tipo de mensagem de migração. A primitiva receive é executada através do método

polling (varredura), tentando ler algum pacote enviado de algum outro processador do canal de entrada da rede. Se existir um pacote no canal de entrada do processador destino, a primitiva lê o cabeçalho. Se o identificador de serviço está ajustado como migração, outro campo é lido: o identificador da tarefa (remetente), como seu próprio nome se refere, identifica a tarefa que será instanciada no processador destino. Atualmente, o código e os dados da tarefa são então lidos do processador que enviou esta tarefa, através de mensagens que chegam ao processador destino. Depois deste passo, a tarefa então é instanciada completamente no processador destino e pronto para ser executada, sendo esta inserida em uma fila de execução, continuando do ponto em que esta parou de executar.

96 96

A Figura 5.15 apresenta a migração de tarefas em duas etapas: na primeira etapa, (a), todas as tarefas estão armazenadas em uma fila de tarefas a serem migradas do núcleo origem. Nesta mesma figura, a tarefa T1 é inserida na fila de tarefas a serem migradas. Quando o núcleo de origem (P0) decide migrar uma tarefa, (T1, por exemplo), é realizado um processo de encapsulamento da tarefa em diversos pacotes, dependendo do tamanho do código e dos dados da tarefa a serem migrados. Todo o contexto é transferido através dos canais de comunicação da rede-em-chip, como mostrado na Figura 5.15b. Quando o último pacote é recebido pelo núcleo destino (P3), então a tarefa migrada é inserida na fila de execução do P3, pronta para ser executada pelo escalonador local.

P0 P1

P2 P3

Tarefa a ser migrada

T0 inativo inativo inativo T1 _{P0 P1} P2 P3 T0 inativo inativo _T1 T1 a) _b) Processador origem Rota de migração Legenda

Figura 5.15: A migração de tarefas em dois passos: a) antes da carga da tarefa T1 do núcleo de origem; b) depois da carga da tarefa do núcleo de origem.

Como foi dito anteriormente, na Seção 5.1.1, cada processador tem seu próprio escalonador baseado em EDF. A Figura 5.16 apresenta o escalonamento de tarefas para quatro processadores mostrados na Figura 5.15. O primeiro processador (núcleo origem) P0 está executando a tarefa T0. Uma interrupção acontece subitamente pelo processador mestre e então o núcleo de origem decide migrar uma tarefa (T1). A tarefa T1 é enviada para o processador P3. O rótulo “MS” no escalonamento indica que o P0 (núcleo origem) está enviando T1 para P3. O processador P3 está inativo (idle). Ele ficará neste estado até no momento em que receber todos os pacotes enviados por P0. Esta recepção está rotulada por “MR”. Quando o último pacote for recebido por P3, o escalonador rotulado como “S” em P3 realiza o monitoramento se existe uma nova tarefa. Como a tarefa T1 é uma nova tarefa a ser executada, ela é inserida na fila de liberação, pois é a primeira vez que ela será executada neste processador P3. Então, o rótulo “R” na figura sinaliza que o escalonador libera a tarefa para execução, e a tarefa T1 é inserida na fila de execução de P3. A tarefa migrada T1 então começa a sua execução em P3.

97 97 Processador Tempo P0 P1 P2 P3 R S T0 S MS S T0 S T0 S I S I MR S R S T1 S S Legenda R liberação S escalonamento Tx tarefa em execução I inativo

Tx tarefa migrada em execução

MS processador envia tarefa

MR processador recebe tarefa

S I

Figura 5.16: Escalonamento de tarefas nos processadores apresentados na Figura 5.15.

A Figura 5.17 apresenta o método de migração de tarefas. Este método sempre verificará se existe uma tarefa na fila de migração originada pela leitura desta tarefa da memória do núcleo mestre. Esta fila de migração armazena tarefas a serem migradas. Se a tarefa que estiver na fila tiver seu campo de destinatário apontado para o processador local, então significa que a tarefa encontrou seu destino e desta forma ela será alocada no processador através do método AddTaskToLoad. Como foi mencionado na Seção 5.1.8, este método é responsável também pelo envio de mensagens de gerenciamento para o núcleo mestre. Se o destinatário for outro processador, então a tarefa é encapsulada na estrutura chamada taskMigrationInfoList e é enviada pela rede através da API sendMigrationData. Esta API fragmenta os dados e o código da tarefa em pacotes e então estes são enviados pela rede utilizando a primitiva send que envia pacotes pela rede para um destinatário.

void Sim_pe::migrate(){

while (!m_tasks_migration_list.empty()){ tMigration

taskMigrationInfoList = m_tasks_migration_list.front(); m_tasks_migration_list.pop_front(); // remove first element if (taskMigrationInfoList.target == local_position){ AddTaskToLoad(taskMigrationInfoList.task); }else sendMigrationData(taskMigrationInfoList); } }

Figura 5.17: Método implementado no simulador Serpens para migração de uma determinada tarefa.

98 98

Por outro lado, a Figura 5.18 apresenta o método receivePack, já mencionado na Seção 5.1.8, porém no contexto de gerenciamento e monitoramento dos processadores. A Figura 5.18 apresenta o método receivePack no contexto de migração de tarefas. Este método é responsável por receber dados relativos à migração de tarefas, dados de comunicação entre as tarefas e recepção de dados relativos ao gerenciamento dos processadores em termos de ocupação de processadores e memória, como foi mencionado na Seção 5.1.8. Este método sempre faz a análise se o pacote que chegou é do tipo de migração ou não. Se for, então ele extrai os dados do cabeçalho do pacote e monta a tarefa. Esta então é instalada no núcleo local para sua execução. Caso contrário, dados de comunicação são recebidos normalmente e então são contabilizados pela biblioteca Orion ou dados de gerenciamento são recebidos para atualização do núcleo mestre. bool Sim_pe::receivePack() {… p = in.read(); fields = phitFactory.WritePhit(&p); if (fields->mig==1){

task=receive_Migration_data();// in.read() aqui dentro installTaskOntoCore(task);

}

if (fields->mig==2){

...// Tratamento das mensagens de gerenciamento }else{

data = receiveData(); // mais in.read aqui dentro }

Figura 5.18: Método receivePack no contexto de migração de tarefas.