A Arquitetura Multithreaded

O que é uma Thread?

Uma Thread é uma sequencia de instruções sendo executadas em um programa.

Antes, observaremos a arquitetura do servidor, pois é útil examinar o conceito usual de uma thread.

Uma thread pode ser interpretada como uma sequencia de instruções sendo executadas em um programa. Quando múltiplas thread são executadas em uma mesma entidade (no nosso caso, um processo), ela é chamada de multithreading.

Single-Threaded vs. Multithreaded

 

Um processo regular UNIX que não implementa threads pode ser pensado como um processo single-threaded, apesar de não ser chamado assim. Uma sequencia de instruções é executada para este processo, e o sistema operacional é responsável por agendar e executar esses processos.

Multithreading é um método de muitas execuções repetidas de um processo para diferentes usuários sem ter que formar muitas instancias daquele processo ao nível do sistema operacional.

Um processo multhreaded pode ter threads múltiplas pesquisando dentro de um processo UNIX, cada um executando sequencialmente e dando o controle para outras threads em um ponto especifico de tempo. A forma como uma arquitetura multithread é executada é o que difere de uma arquitetura de single-thread recebendo e executando solicitações de um processo de um único usuário.

Multithreading é um conceito ao nível do sistema por onde os programas realmente executam instruções ao nível da maquina para manipular os processos, então esse é executado para vários usuários ao invés de apenas um. O programa executa estas instruções totalmente ao nível do usuário, e não nível do Kernel do UNIX. Longe de afetar o UNIX, um processo em arquitetura multithread é um processo único, como qualquer outro processo.

Um programa Single-Threaded

Considerar como o UNIX trabalha com multiprocessamento.

Cada processo UNIX tem um espaço de endereço consistindo em três segmentos: text, data e stack. O segmento text contem a instrução da maquina que gera o programa de codificação executável. Os segmentos stack contem variáveis locais usada pelos programas funcionais. Finalmente, o segmento data contem o programa global e as variáveis estáticas, strings, array e outros dados.

Em uma maquina monoprocessada que esteja executando 1000 processos, somente um processo esta sendo executado pelo UNIX em algum momento. Cada processo esta sendo executado dentro de uma quantidade especifica de tempo antes dele ser pré-desocupado (interrompido) pelo kernel de maneira que o próximo processo agendado possa ser executado. Quando um processo em execução é pré-desocupado, devem ser salvas informações suficientes de maneira que o processo possa ser reiniciado mais tarde. Esta informação é chamada de context do processo. O context consiste basicamente dos seguintes componentes:

• O program counter, o qual especifica o endereço das próximas instruções a serem executadas.
• O stack pointer, o qual contem o endereço atual da próxima entrada no stack.
• O general purpose registers, os quais contem os dados gerados pelo processo durante essa execução.

Existem outros componentes do context do processo UNIX, chamado de system level context, porem não vamos abortar, pois não são críticos para a compreensão de multithreading.

Um Context Switch (Alternância de Contexto)

Em UNIX, um context switch ocorre quando um processo em execução é interrompido pelo sistema operacional. Para fazer isto, o sistema operacional salva, correntemente, o context do processo em execução em estruturas de dados pré-alocadas em memoria e carrega o contexto do próximo processo agendado.

Carregar o context envolve restauração do program counter, o stack pointer e todos os general purpose registers para os valores salvos pelo sistema operacional na ultima vez que o processo em execução foi pré-desocupado. Uma vez completo, o processo continua sua execução a partir da linha de código especificada pelo program counter.

Um processo Multithreaded

O processo multithread, cada thread tem o seu próprio context, isto é, seu próprio local no código ( program counter ) e suas próprias variáveis de dados. Um processo multithread trabalha muito parecido com o sistema operacional na maneira da troca de um context de uma thread para outra.

O próprio processo executa instruções de maquinas para realizar uma copia da thread executada no momento e trazer a próxima thread agendada. Isto permite basicamente o mesmo resultado que o sistema operacional alcança fazendo um context switch. O resultado é que o program counter aponta para uma nova instrução dentro do segmento text, o stack pointer aponta para uma diferente área de memoria  e os general purpose register são restaurados para os valores previamente salvados por este context. No caso do IDS Multithreading, o stack de uma thread é mantido em shared memory para se mover entre os processos do servidor (virtual processors). O tamanho padrão de stack é 32 kilobytes por cada userthread. O servidor verifica o overflow do stack e automaticamente expande o tamanho stack.

Uma vez que o processo multithread age como um mini sistema operacional, ele é responsável por manter coisas do tipo:

• Agendamento: a thread  atual decide quando ceder controle de um processo e transferir controle para outra thread. A thread atual tambem decide qual a próxima thread que será executada baseado em mecanismo de prioridade interno.
• Troca de Context: quando a thread atual decide que é a hora de executar outra thread, ele deve executar instruções de maquina para efetuar a troca de context entre as threads.

Agendamentos e a troca de context ainda são efetuados pelo UNIX normalmente. O processo multithread efetua agendamento e a troca de context de threads. Mantenha estes dois conceitos separados.

Virtual Processors

Os processos que compõe o database server são conhecidos para Virtual Processors. Cada VP pertence a um virtual processor class. Um VP class é um grupo de processos responsáveis por um conjunto especifico de tarefas (na forma de threads), como, por exemplo, gravar para o logical log ou ler dados do disco. Isto quer dizer que um VP de uma certa classe pode somente pesquisar thread de uma mesma classe. Uma classe de VP pode ter um ou mais VPs, a qual na maior parte dos casos é configurada pelo administrador do sistema. O nome de um VP executável é oninit. Todos os VPs de todas as classes são exemplos de mesmo programa, oninit.

Executando uma Thread

Uma Thread esta sendo executada em um processador particular, ou esta em uma de uma serie de filas. As filas ready (ready queues) mantem os contexts de threads esperando para executa-los em um processador. Quando um processador esta livre, ele obterá o context de uma thread de uma ready queue. Ha um mecanismo de prioridade interno que determina qual thread o processador obterá da fila. O processador os substitui o context atual com o context da nova thread e continua o processamento daquela thread.

As ready queues são compartilhadas entre processadores de mesma classe de modo que uma thread possa migrar entre vários processadores durante sua existência (apesar do server tender em manter a execução de uma thread em um mesmo processo). Este mecanismo mentem o trabalho balanceado entre os processos e garante que uma thread será executada se algum processador estiver disponível.

Passando o controle para outra Thread

A um ponto especifico de execução, a thread cede o controle do processador para outra thread. Algumas ações comuns que poderiam fazer a thread ceder são:

• Aguardando por uma operação de leitura ou de gravação no disco;
• Aguardando por uma solicitação do processo de aplicação;
• Aguardando por um lock ou outro recurso;
• Não há mais trabalho a fazer.

Uma thread tambem poderia ceder o controle por nenhuma razão, além de dar a uma outra thread uma chance de ser executada.

Quando um thread cede controle, ela é responsável pela colocação de seu próprio context em uma de muitas filas de espera (wait queue) ou uma fila de aguardo (sleep queue). As wait queue são usadas basicamente para esperar uma operação. As sleep queues são usadas por threads que necessitam ser reativadas depois de um período de tempo.

O processador, então, pega o context de uma thread qualquer de uma ready queue e a substitui seu context com a nova thread. O processador continua a execução com o novo context.

Vantagens das Threads do Servidor

Algumas das vantagens do server threads são listadas abaixo:

• São necessários poucos processos para fazer o mesmo trabalho. Este é particularmente eficiente em um ambiente OLTP quando há um grande numero de usuários. Você pode pensar nisto como fan-in, onde há um grande numero de processos de aplicação com um pequeno numero de processos do database server suportando suas solicitações. Uma vantagem adicional é que um sistema que pode suportar mais usuários porque ha menos processos que necessitam ser suportados pelo sistema operacional.
• Além das capacidades fan-in, o server tambem oferece uma capacidade fan-out. Múltiplos processos do database server podem fazer o trabalho por uma aplicação.
• A arquitetura multithreaded substitui muito a troca do context feito pelo sistema operacional com a troca do context feitos pelos processos dentro do database server. Uma troca de context é mais rápido quando feito dentro de um processo porque ha menos informações para trocar.
• O processo do database server faz o seu próprio agendamento de thread. Isto dignifica que o DBMS, a frente do que o sistema operacional determina a prioridade de tarefas.
• Algumas características oferecidas por um sistema multi-processado fazem deste tipo de arquitetura, muito mais eficiente. Por exemplo, nós poderíamos dar um importante processo do database server direitos exclusivos para usar um processador em partilhar.

Fan-out

Uma das vantagens do server está em suas capacidades fan-out. Isto significa que usuários podem levar vantagens de múltiplos processadores do database server (e múltiplos CPUs, se disponível) trabalhando simultaneamente para fazer o trabalho deles.

o Server criará múltiplas threads que farão o trabalho de um usuário para as operações seguintes:

• Ordenação
• Indexação
• Recuperação