Sistemas

Operacionais de Redes

Threads
(adaptado das notas de aula de Tanenbaum e
Silberschatz)
 Relembrando...
nom e
PID r e g is tr a d o r e s
g e r a is
o w n e r (U I D )

p r io r id a d e d e
e xe cu çã o r e g is tr a d o r P C

d a ta /h o r a
d e cr ia çã o C o n te xto d e C o n te xto d e
S o ftw a re H a rd w a re

te m p o d e r e g is tr a d o r S P
p r o ce s s a d o r

q u o ta s
Pro g ra m a r e g is tr a d o r
p r iv ilé g io s d e s ta tu s
E sp a ço d e
E n d e re ça m e n to

e n d e r e ço s d e m e m ó r ia
p r in cip a l a lo ca d o s
3-18
2
 Threads
•  Processos
–  Agrupamento de recursos e execução
•  Threads
–  Conceito exclusivo para a execução
–  Envolve o fluxo de controle: mesmo espaço de
endereçamento, mas com seu próprio PC, pilha e
registradores para variáveis de trabalho
•  Uma CPU com múlIplos processos ßà Um
processo com múlIplas threads
 Threads
O modelo de threads (1)

(a) 3 processos com uma thread cada um

(b) 1 processo com 3 threads

4
 Múltiplas Threads

C o n te xto C o n te xto C o n te xto

d e h a rd w a re d e h a rd w a re d e h a rd w a re
C o n te xto d e
so ftw a re

Th re a d 1 Th re a d 2 Th re a d 3

E sp a ço d e
e n d e re ça m e n to

3-18
5
 O modelo de threads (2)

•  Esquerda: itens comparIlhados por todas as threads de um processo

•  Direita: itens privaIvos de cada thread
•  Não há proteção entre threads

6
 O modelo de threads (3)

Cada thread tem a sua própria pilha

7
 Uso de threads (1)

Um processador de texto com 3 threads

8
 Uso de threads (2)

Um servidor Web mulIthread

9
 Uso de threads (3)

•  Código simplificado do slide anterior

(a) Thread despachante
(b) Thread operário

10
 Benefícios
•  Capacidade de resposta: permite que um programa
continue a ser executado mesmo se parte dele
estiver bloqueada ou executando uma operação
demorada
•  Compartilhamento de recursos: por default, threads
compartilham memória e os recursos do processo ao
qual pertencem
•  Economia
•  Escalabilidade
•  Eficiência: troca rápida de contexto
3-18
 Benefícios (cont.)
•  Economia: alocação de memória e recursos para a
criação de processos é cara. Threads são baratas. Ex:
criar um processo no Solaris é cerca de 30x mais
lento do que a criação de um thread. A mudança de
contexto de processos é cerca de 5x mais lenta.
•  Escalabilidade: o uso de vários threads em uma
máquina com muitos núcleos aumenta o
paralelismo.

3-18
12
 Threads em modo usuário e modo
kernel
•  Modo usuário
–  Implementado pela aplicação
–  Bibliotecas
–  Não precisa de suporte de SO
–  Chamadas de manipulação de threads não são chamadas de
sistema
–  Thread bloqueia o processo
•  Modo kernel
–  Implementado pelo SO
–  Maior custo (chamadas de sistema)
–  Maior paralelismo

3-18
13
Implementação de threads de usuário

Um pacote de threads de usuário

14
Implementação de threads de núcleo

Um pacote de threads de núcleo (Pthreads - Linux)

15
 Implementações híbridas

MulIplexação de threads de usuário sobre threads de núcleo (Win7)

16
 Exemplo (1)

Criação de processos em sistemas Unix / POSIX:

fork() e execve()

17
 Exemplo (2) – POSIX threads
(Pthreads)
•  pthread_create(pthread_t *thread, const pthread_a7r_t *a7r, void
*(*start_rou:ne) (void*), void *arg)
–  inicia uma nova linha de execução no processo que
originou a chamada pthread_create
•  pthread_join(pthread_t thread, void **retval)
–  aguarda o término da thread especificada
•  pthread_exit(void *retval)
–  finaliza a thread que originou a chamada pthread_exit
Exemplo (3) – POSIX threads
(Pthreads)
 APIs de Threads
•  Pthreads (POSIX Threads)
•  Win32
•  Java
•  OpenMP
•  Intel TBB (Thread Building Blocks)

3-18
20
 OpenMP
•  Escassez de padrões para compartilhamento de
memória
•  Fórum Open MP iniciado por IBM, Digital, Intel,
SGI e KAY
•  Open MP para FORTRAN – 1997
•  Open MP para C/C++ – 1998
•  Open MP 2.0 para FORTRAN – 2000
•  Open MP 2.0 para C/C++ – 2000

3-18
21
 Compilador
•  Diretiva
–  Comando que faz sentido apenas para alguns
compiladores
•  Sentinela
–  Caracter(es) que distingue(m) uma diretiva
–  FORTRAN – !$OMP, C$OMP, *$OMP
–  C/C++ – #pragma omp
–  Ignora a diretiva caso não reconheça a sentinela
–  Parallel OMP se refere ao bloco (em C/C++)

3-18
22
 Hello World
#include <stdio.h>
int main (void)
{
#pragma omp parallel
{
printf("Hello, world!\n");
}
return 0;
}

3-18
23
 Multiplicação de vetor por escalar
int main(int argc, char **argv) {
const int N = 100000;
int i, a[N];
#pragma omp parallel for
for (i = 0; i < N; i++)
a[i] = 2 * a[i];
return 0;
}
3-18
24
 Compartilhamento de Dados
•  shared(var)
•  private(var) – não inicializado
•  default(shared | private | none)
•  firstprivate(var) –  como private exceto ao inicializar
pelo valor original
•  lastprivate(var) –  como private exceto que o valor
original é atualizado depois da construção
•  reduction(operation:var)

3-18
25
 Clausulas de sincronização
•  critical section: o código incluso será executado por somente um thread por vez e não
simultaneamente executado por múltiplos threads. É frequentemente usado para proteger os dados
compartilhados das condições de corrida.
•  atomic: semelhante à critical section, mas informamos ao compilador para usar instruções especias de
hardware para um melhor desempenho. Os compiladores podem optar por ignorar essa sugestão
dos usuários e usar a critical section ao invés da atomic.
•  ordered: o bloco estruturado é executado na ordem em que as iterações seriam executadas em um
loop sequencial.
•  barrier: cada thread espera até que todos os outros threads de um grupo tenham alcançado este
ponto. Uma construção de partilha tem uma barreira de sincronização implícita no final.
•  nowait: especifica quais threads podem completar sua instrução sem esperar todos os outros threads
do grupo para concluir. Na ausência de tal cláusula acontece o mesmo da barrier.

3-18
26
 Clausulas de escalonamento
•  schedule(type, chunk)
•  static
–  dynamic
–  guided – chunk diminui exponencialmente

Controle do Número de Threads

•  Variável de ambiente OMP_NUM_THREADS

3-18
27
 Exemplo
#include <omp.h>
int main (int argc, char *argv[]) {
int th_id, nthreads;
#pragma omp parallel private(th_id) {
th_id = omp_get_thread_num();
printf("Hello World from thread %d\n", th_id);
#pragma omp barrier
if ( th_id == 0 ) // #pragma omp master{
nthreads = omp_get_num_threads();
printf("There are %d threads\n",nthreads);
}}}

3-18
28