O Unix Internal da Vahalia tem figuras mostrando as relações entre processos, threads do kernel, processos leves e threads do usuário. Este livro dá mais atenção ao SVR4.2 e também explora 4.4BSD, Solaris 2.x, Mach e Digital UNIX em detalhes. Observe que não estou perguntando sobre o Linux.
Para cada processo, sempre há um ou mais processos leves subjacentes ao processo? A Figura 3.4 parece dizer que sim.
Por que a Figura 3.5 (a) mostra processos diretamente sobre as CPUs, sem processos leves no meio?
Para cada processo leve, sempre há exatamente um thread do kernel subjacente ao processo leve? A Figura 3.4 parece dizer que sim.
Por que a Figura 3.5 (b) mostra processos leves diretamente sobre os processos, sem nenhum encadeamento do kernel no meio?
Os threads do kernel são as únicas entidades que podem ser agendadas?
Os processos leves são agendados apenas indiretamente por meio do agendamento dos threads do kernel subjacentes?
Os processos são agendados apenas indiretamente por meio do agendamento dos processos leves subjacentes?
Atualizar:
Fiz uma pergunta semelhante para o Linux Há um processo leve anexado a um thread do kernel no Linux? Eu imaginei que poderia ser porque o livro Operating System Concepts apresenta os conceitos implicitamente usando o Unix, e o Unix e o Linux podem diferir, então li sobre o kernel do Unix.
Agradeço a resposta atual, mas espero reabrir a postagem para poder aceitar outras respostas.
Respostas:
Veja: Entendendo o Linux Kernel , 3ª Edição por Daniel P. Bovet, Marco Cesati
Em sua introdução, Daniel P. Bovet e Marco Cesati disseram:
Nos próximos parágrafos, tentarei abordar seus pontos de vista com base no meu entendimento dos fatos apresentados em "Entendendo o kernel do Linux", que são em grande parte semelhantes aos do Unix.
O que significa um processo? :
Os processos são como seres humanos, são gerados, têm uma vida mais ou menos significativa, opcionalmente geram um ou mais processos filhos e, eventualmente, morrem. Um processo possui cinco partes fundamentais: tabelas de código ("texto"), dados (VM), pilha, E / S de arquivo e sinal
O objetivo de um processo no Kernel é atuar como uma entidade à qual os recursos do sistema (tempo da CPU, memória, etc.) são alocados. Quando um processo é criado, é quase idêntico ao seu pai. Ele recebe uma cópia (lógica) do espaço de endereço do pai e executa o mesmo código que o pai, começando na próxima instrução após a chamada do sistema de criação de processos. Embora o pai e o filho possam compartilhar as páginas que contêm o código do programa (texto), eles têm cópias separadas dos dados (pilha e pilha), para que as alterações do filho em um local de memória sejam invisíveis para o pai (e vice-versa) .
Como funcionam os processos?
Um programa em execução precisa mais do que apenas o código binário que informa ao computador o que fazer. O programa precisa de memória e vários recursos do sistema operacional para ser executado. Um "processo" é o que chamamos de programa carregado na memória, juntamente com todos os recursos necessários para operar. Um encadeamento é a unidade de execução dentro de um processo. Um processo pode ter de apenas um segmento a vários segmentos. Quando um processo é iniciado, ele recebe memória e recursos. Cada encadeamento no processo compartilha essa memória e recursos. Nos processos de thread único, o processo contém um thread. O processo e o encadeamento são o mesmo e há apenas uma coisa acontecendo. Nos processos multithread, o processo contém mais de um thread, e o processo está realizando várias coisas ao mesmo tempo.
A mecânica de um sistema de multiprocessamento inclui processos leves e pesados:
Em um processo pesado, vários processos estão sendo executados juntos em paralelo. Cada processo pesado em paralelo possui seu próprio espaço de endereço de memória. A comunicação entre processos é lenta, pois os processos têm diferentes endereços de memória. A alternância de contexto entre processos é mais cara. Os processos não compartilham memória com outros processos. A comunicação entre esses processos envolveria mecanismos de comunicação adicionais, como soquetes ou tubos.
Em um processo leve, também chamado de threads. Os encadeamentos são usados para compartilhar e dividir a carga de trabalho. Threads usam a memória do processo ao qual pertencem. A comunicação entre encadeamentos pode ser mais rápida que a comunicação entre processos, porque os encadeamentos do mesmo processo compartilham memória com o processo ao qual pertencem. Como resultado, a comunicação entre os threads é muito simples e eficiente. A alternância de contexto entre threads do mesmo processo é menos dispendiosa. Threads compartilham memória com outros threads do mesmo processo
Existem dois tipos de threads: threads no nível do usuário e threads no nível do kernel. Os threads no nível do usuário evitam o kernel e gerenciam o trabalho por conta própria. Os encadeamentos no nível do usuário têm um problema de que um único encadeamento possa monopolizar o intervalo de tempo, deixando os outros encadeamentos com fome na tarefa. Os encadeamentos no nível do usuário geralmente são suportados acima do kernel no espaço do usuário e são gerenciados sem o suporte ao kernel. O kernel não sabe nada sobre threads no nível do usuário e os gerencia como se fossem processos de thread único. Como tal, os threads no nível do usuário são muito rápidos, operam 100 vezes mais rápido que os threads do kernel.
Os threads no nível do kernel geralmente são implementados no kernel usando várias tarefas. Nesse caso, o kernel agenda cada thread no intervalo de tempo de cada processo. Aqui, como o tiquetaque do relógio determinará os horários de alternância, é menos provável que uma tarefa consiga a fatia do tempo dos outros threads da tarefa. Os threads no nível do kernel são suportados e gerenciados diretamente pelo sistema operacional. O relacionamento entre os encadeamentos no nível do usuário e no nível do Kernel não é completamente independente; na verdade, há uma interação entre esses dois níveis. Em geral, os encadeamentos no nível do usuário podem ser implementados usando um dos quatro modelos: modelos muitos para um, um para um, muitos para muitos e dois níveis. Todos esses modelos mapeiam encadeamentos no nível do usuário para encadeamentos no kernel e causam uma interação em diferentes graus entre os dois níveis.
Threads vs. Processos
Referências:
Compreendendo o kernel do Linux, 3ª edição
Mais 1 2 3 4 5
...............................................
Agora, vamos simplificar todos esses termos ( este parágrafo é da minha perspectiva ). Kernel é uma interface entre software e hardware. Em outras palavras, o núcleo age como um cérebro. Manipula uma relação entre o material genético (isto é, códigos e seu software derivado) e os sistemas corporais (isto é, hardware ou músculos).
Esse cérebro (isto é, núcleo) envia sinais para processos que agem de acordo. Alguns desses processos são como músculos (ou seja, fios), cada músculo tem sua própria função e tarefa, mas todos trabalham juntos para terminar a carga de trabalho. A comunicação entre esses fios (ou seja, músculos) é muito eficiente e simples, para que eles realizem seu trabalho de maneira suave, rápida e eficaz. Alguns dos fios (ou seja, músculos) estão sob controle do usuário (como os músculos de nossas mãos e pernas). Outros estão sob o controle do cérebro (como os músculos do estômago, olhos, coração que não controlamos).
Os encadeamentos de espaço do usuário evitam o kernel e gerencia as próprias tarefas. Muitas vezes, isso é chamado de "multitarefa cooperativa" e, de fato, é como nossas extremidades superior e inferior, está sob nosso próprio controle e trabalha em conjunto para realizar trabalho (ou seja, exercícios ou ...) e não precisa de ordens diretas de o cérebro. Por outro lado, os threads do Kernel-Space são completamente controlados pelo kernel e seu planejador.
...............................................
Em resposta às suas perguntas:
Um processo é sempre implementado com base em um ou mais processos leves? A Figura 3.4 parece dizer que sim. Por que a Figura 3.5 (a) mostra processos diretamente sobre as CPUs?
Sim, existem processos leves chamados threads e processos pesados.
Um processo pesado (você pode chamá-lo de processo de encadeamento de sinal) exige que o próprio processador faça mais trabalho para ordenar sua execução, é por isso que a Figura 3.5 (a) mostra os processos diretamente na parte superior das CPUs.
Um processo leve é sempre implementado com base em um thread do kernel? A Figura 3.4 parece dizer que sim. Por que a Figura 3.5 (b) mostra processos leves diretamente sobre os processos?
Não, os processos leves são divididos em duas categorias: processos no nível do usuário e no nível do kernel, conforme mencionado acima. O processo no nível do usuário depende de sua própria biblioteca para processar suas tarefas. O próprio kernel agenda o processo no nível do kernel. Os encadeamentos no nível do usuário podem ser implementados usando um dos quatro modelos: muitos para um, um para um, muitos para muitos e dois níveis. Todos esses modelos mapeiam encadeamentos no nível do usuário para encadeamentos no nível do kernel.
Os threads do kernel são as únicas entidades que podem ser agendadas?
Não, os threads no nível do kernel são criados pelo próprio kernel. Eles são diferentes dos encadeamentos no nível do usuário, pois os encadeamentos no nível do kernel não possuem um espaço de endereço limitado. Eles vivem apenas no espaço do kernel, nunca mudando para o reino da terra do usuário. No entanto, eles são entidades totalmente agendáveis e preemptivas, assim como processos normais (nota: é possível desativar quase todas as interrupções para ações importantes do kernel). O objetivo dos threads do próprio kernel é principalmente executar tarefas de manutenção no sistema. Somente o kernel pode iniciar ou parar um thread do kernel. Por outro lado, o processo no nível do usuário pode agendar-se com base em sua própria biblioteca e, ao mesmo tempo, pode ser agendado pelo kernel com base nos modelos de dois níveis e muitos para muitos (mencionados acima),
Os processos leves são agendados apenas indiretamente através do agendamento dos threads do kernel subjacentes?
Os threads do kernel são controlados pelo próprio planejador do kernel. O suporte a threads no nível do usuário significa que existe uma biblioteca no nível do usuário vinculada ao aplicativo e essa biblioteca (não a CPU) fornece todo o gerenciamento no suporte de tempo de execução para threads. Ele oferecerá suporte a estruturas de dados necessárias para implementar a abstração de encadeamentos e fornecerá toda a sincronização de agendamento e outros mecanismos necessários para tomar decisões de gerenciamento de recursos para esses encadeamentos. Agora, alguns dos processos de encadeamento no nível do usuário podem ser mapeados nos encadeamentos no nível do kernel subjacentes e isso inclui mapeamento um para um, um para muitos e muitos para muitos.
Os processos são agendados apenas indiretamente por meio do agendamento dos processos leves subjacentes?
Depende se é um processo pesado ou leve. Pesados são processos agendados pelo próprio kernel. Um processo leve pode ser gerenciado no nível do kernel e no nível do usuário.
fonte