Troca de contexto

Tempo de CPU como um recurso compartilhado

Os sistemas operacionais modernos fazem malabarismos com dezenas ou centenas de threads ativos.
Existem apenas alguns núcleos de CPU, portanto, a maioria dos threads espera em filas enquanto um pequeno subconjunto é executado.

A troca de contexto permite que o agendador pause um thread em execução e retome outro.
Essa troca rápida cria a ilusão de paralelismo e também molda o que você vê mais tarde nos crash dumps.

Dentro do contexto de execução de um thread

Cada thread carrega mais do que apenas código e dados.
Ele também tem um contexto de execução completo que o kernel deve salvar e restaurar corretamente.

Esse contexto inclui:

• Registradores e sinalizadores de CPU de uso geral

• Ponteiro de instrução e ponteiro de pilha

• Registros de segmento e registros de controle, quando relevantes

• Pilhas do kernel e do usuário, além de alguns metadados do agendador

Quando o kernel se afasta de um thread, ele deve registrar esse estado.
Quando o planejador retorna ao mesmo thread, ele restaura tudo para que a execução continue como se nada tivesse sido pausado.

Etapas que o kernel executa durante uma troca de contexto

Em um nível baixo, uma troca de contexto segue uma sequência previsível.
Os detalhes mudam entre as arquiteturas, mas as ações principais permanecem semelhantes.

1. O thread em execução chega a um ponto de agendamento, como uma interrupção de cronômetro ou uma chamada de sistema de bloqueio.

2. O kernel salva os registros da CPU, os ponteiros da pilha e algumas informações de controle na pilha do kernel ou no bloco de controle do thread.

3. O agendador escolhe o próximo thread executável com base na prioridade, justiça e afinidade com o processador.

4. O kernel carrega o contexto salvo para o próximo thread, incluindo registros e ponteiros de pilha.

5. O controle retorna ao modo de usuário ou kernel no novo thread, que continua no ponteiro de instruções anterior.

Essa sequência ocorre milhões de vezes por segundo em sistemas ocupados.
Qualquer erro nessas etapas pode causar corrupção de dados, travamentos ou uma falha que produza um arquivo de despejo.

Acionadores que causam mudanças de contexto

As trocas de contexto não ocorrem aleatoriamente.
Eles surgem de eventos bem definidos dentro do sistema operacional e do hardware.

Gatilhos comuns:

• A thread em execução bloqueia em E/S, um bloqueio ou um objeto de espera

• Uma interrupção do temporizador de hardware indica que o thread usou sua fatia de tempo

• Um thread de prioridade mais alta fica pronto para ser executado

• O planejador recebe um sinal para reequilibrar o trabalho entre os núcleos

Os despejos de falhas capturam qualquer thread que tenha sido executado quando ocorreu uma condição fatal ou quando o kernel detectou uma inconsistência grave durante uma dessas transições.

Crash Dumps e estados de thread

Quando o Windows atinge uma verificação de erro, ele congela o agendamento e grava um instantâneo da memória no disco.
Esse instantâneo geralmente inclui detalhes sobre vários threads e os contextos que causaram ou detectaram o erro.

Normalmente, os crash dumps registram:

• O thread ativo em cada CPU no momento da falha

• Pilhas do kernel que mostram quais funções foram executadas imediatamente antes da falha

• Estruturas que descrevem filas prontas e estados de espera

Ao examinar esses threads e seus últimos eventos de troca de contexto, os analistas inferem qual driver, chamada de sistema ou ação do usuário contribuiu para a falha.

Considerações sobre desempenho e confiabilidade

A alternância de contexto permite a multitarefa, mas acarreta sobrecarga.
O kernel deve alternar entre os níveis de privilégio, liberar ou recarregar algum estado da CPU e alterar o conteúdo do cache.

Muitas trocas de contexto podem ocorrer:

• Aumentar o tempo de CPU gasto no agendador

• Prejudicar o cache e a localidade do TLB

• Reduzir a taxa de transferência para aplicativos com uso intensivo de E/S

Instável motoristas ou processos de usuário com comportamento inadequado podem criar padrões extremos de comutação, que às vezes aparecem em despejos de falhas como longas pilhas de operações de wait e wake.
Em casos graves, os erros durante essas transições causam corrupção de memória ou deadlocks.

Uso prático de informações de contexto na análise de despejos