Baixe Resumo de todos os capitulos e outras Resumos em PDF para Sistemas Operacionais, somente na Docsity!
Processos:
Um processo é uma abstração para se representar uma atividade em execução acompanhado dos valores de PC, regs e variáveis. Cada processo possui um PC lógico, no qual o PC �ísico será salvo antes de realizar a troca de contexto.
Criação de um processo:
Há quatro situações onde um processo é criado:
- Início do sistema
- Execução de chamada de criação de processo por um processo em execução
- Requisição para criar novo processo
- Job em Lote: baseado em FIFO Independente da situação um novo processo é criado sempre por um processo existente executando uma chamada de sistema , em Unix, essa chamada de sistema é o fork(), que cria um clone do processo que o chamou, o qual é chamado de �ilho e possuía mesma imagem de memória, os mesmos arquivos abertos e as mesmas cadeias de caractere no ambiente , em um espaço de endereçamento distinto
Término de processos
Há quatro situações para o processo terminar:
- Saída normal (Voluntária)
- Saída por erro(Voluntária)
- Erro fatal (Involuntário)
- Cancelamento por outro processo(Involuntário) A primeira situação ocorre quando um processo realiza por completo seu trabalho realizando ao �inal uma chamada ao sistema para sinalizar que terminou, esta chamada de sistema em Unix é a exit. O segundo motivo é a presença de um erro fatal na execução do processo, como por exemplo, a tentativa de compilar um arquivo inexistente. O terceiro motivo é um erro causado pelo processo em si, como instrução ilegal, referencia inexistente ou divisão por zero.Em Unix, um processo pode sinalizar que deseja tratar alguns erros de forma que o processo é interrompido inves de �inalizado. O último motivo é quando um processo X executa uma chamada de sistema para cancelar um processo Y.Em Unix, a chamada para encerrar o processo Y feita pelo processo X, que deve possuir permissão para tal, é a kill()
Estados de Processos
Um processo possui três estados possíveis:
- Em execução
- Pronto
- Bloqueado
A transição um ocorre quando um processo não mais pode continuar sua execução.Em unix, quando um processo lê de um pipe ou um terminal e não há entrada ele é bloqueado. As transições 2 e 3 são resultados do escalonamento de processos.A segunda quando o escalonador decide que o processador já foi executado por tempo su�iciente e a terceira quando todos os outros processos já utilizaram a CPU e agora volta-se ao processo anteriormente interrompido A quarta transição ocorre devido a algum evento externo pelo qual o processo estava aguardando (chegada de uma entrada por exemplo)
Implementação de processos
A implementação de um processo se dá pelo bloco de controle de processo , uma entrada que contém informações sobre o estado do processo, contado PC, ponteiro para pilha,alocação de memória, estado de arquivos abertos, informação sobre contabilidade e escalonamento.
Threads:
Fluxo de controle pertencente a um processo, frequentemente utilizado de maneira a se ter múltiplos threads de controle no mesmo espaço de endereçamento.
Modelo
Difere-se um processo de thread uma vez que processos agrupam recursos e threads são as entidades escalonadas para execução sobre a CPU. Cada thread possui uma pilha própria com variáveis locais e endereçamento de retorno,no entanto, dividem o mesmo espaço de endereçamento e compartilham as mesmas variáveis globais, portanto um thread pode ler, escrever e até apagar completamente a pilha de outro thread.
Os processos normalmente iniciam com uma thread que realiza threade_create(), essa thread é criada no espaço de endereçamento do thread atual e não possui qualquer relação hierárquica.Para identi�icar o thread um identi�icador de thread e retornado para a thread em criação Ao terminar seu procedimento um thread pode sair chamando thread_exit(), não podendo mais ser escalonado, ou se for de interesse que esta thread termine após o término de outra thread especí�ica a chamada thread_wait() é utilizada bloqueando a thread. Diferente dos processos, as threads não possuem um compartilhamento de tempo por interrupção de relógio, tornando-se importante o uso de thread_yield que permite que uma thread desista voluntariamente da CPU para deixar outra executar.
Um problema inerente do modo usuário é que se alguma thread bloquear e realizar uma syscall( read,por exemplo) os outros threads também serão interrompidos. Para evitar o bloqueio algumas estratégias eram realizadas: ● Uma syscall select() antes de realizar um read(). A syscall select() veri�ica a disponibilidade de dados para ler em um determinado arquivo, de forma que se houver o read() ocorreria sem problemas, do contrário a troca de contexto pode ser realizada. Ao voltar nessa thread o teste seria realizado novamente. ● Tornar o arquivo não bloqueante de forma que ao realizar a chamada o retorna sucesso ou erro ● No caso de não haver leitura ou escrita instala-se uma rotina de tratamento de sinal para o timer e instaura um temporizador periódico
De Núcleo
Nesta implementação há uma tabela de thread no núcleo que acompanha todos os threads, tornando a criação e destruição mais e�iciente por serem via chamada ao núcleo Quando uma thread bloqueia o núcleo pode selecionar uma thread não pertencente ao processo da thread anterior para ser executada Há uma reciclagem de threads, marcando-as como não executável quando seu uso tiver sido encerrado
Linux:
Em linux a syscall para se criar tarefas( tanto processo quanto thread) é a clone(parâmetros) onde os parâmetros são os responsáveis por evidenciar se estamos criando um processo ou threads, pois os parâmetros serão compartilhados entre a task criada e a task que o chamou.
Escalonamento de tarefas
Processos e threads são estruturas criadas pelo SO para permitir a execução de blocos de código que compartilham recursos de um computador.Utilizando o contexto de execução , associado aos estado dos registradores de hardware na execução de uma tarefa, o SO capaz de alternar o uso do processador entre essas entidades.O uso de outros recursos, como unidades de armazenamento, é feito sob demanda.
O SO é capaz de promover que controladores de dispositivos de entrada e saída façam a leitura ou escrita necessária ao passo que direciona o processador para a execução de código de outra tarefa, a �im de diminuir a ociosidade do processador. Isso é possível por meio de técnicas de acesso direto à memória(DMA) , onde um controlador é capaz de transferir os dados lidos de um dispositivo( através de barramento) para a memória e enviar para um dispositivo dados lidos de áreas de memória usada como bu�er pelo SO.Ao realizar a transferência o controlador envia um sinal ao de interrupção ao processador para desviar a execução para uma rotina do SO Outra forma de compartilhar o uso da CPU é pela fatia de tempo, de�inida por um dispositivo de timer programável presente na placa mãe e usado pelo SO para geração de interrupções. Uma vez interrompido o processo que vinha sendo executado e transferido a execução para o SO, o SO deve ser capaz de selecionar qual o próximo processo a ser executado e para isso vários aspectos podem ser considerados para escolha: ● throughput: número de processos que completa execução por período de tempo ● latência: tempo entre submissão e conclusão (turnaround time) ou tempo entre submissão e resultado ( response time) ● Fairness:Uso balanceado do processador, evitando tarefas executando de maneira preterida inde�inidamente ● Cumprimento de prazos ● Ocupação de recursos ● … Também pode haver prioridades estáticas relacionadas a tarefas.
Em linux as entidades executáveis são denominadas tasks que dependendo dos recursos que compartilham podem ser uma thread ou um processo.Portanto o escalonamento é feito em função das tarefas. No entanto, em SOs que não suportem threads, o escalonador seleciona o próximo processo a executar, ao passo que SOS que suportem threads podem dividir o tempo atribuído para o processo entre as threads.
Resumidamente o escalonamento ocorre:
- Tarefa corrente terminou ( pede ao SO para terminar:_exit() )
- Tarefa precisa esperar por E/S ( pede pro SO, que ativa o controlador, e passa algo para o processador não �icar a toa)
- Interrupção mandada para o processador que passa a executar código do SO(preempção)
- Interrupção por fatia de tempo
- Quando a tarefa corrente retorna o processador ao SO por sched_yield() Todos os casos há uma troca de contexto, onde o SO salva o contexto da execução que está deixando o processador e restaura o contexto de execução da nova tarefa que voltará(ou iniciara) a ser executada.
A troca de contexto e custosa então a tarefa deve passar mais tempo executando do que o tempo gasto para a troca de contexto
Políticas
Fifo: primeiro a chegar primeiro a ser servido
Usado em processamento em lote e é não preemptivo de forma que só pode alterar via sched_yuield() ou término de processo.
coe�icientes de utilização do processador , se for menor ou igual a um a viabilidade é garantida .Nessa conta leva em consideração os intervalosde entre ocorrências e os piores casos.
Respeitado essa característica hpa diferentes políticas para o escalonamento: ● Earliest deadline �irst: tarefa com o prazo mais próximo primeiro ● Least slack: tarefa com menor folga entre prazo e tempo de execução primeiro ● rate monotonic:Menor período de execução, maior prioridade
Escalonamento no Linux
O escalonamento no linux é chamado de Completely fair Schedule e funciona com base no cálculo dinâmico do tempo que cada processo deveria executar com base na sua prioridade estativa (nice) e no número de processos em execução. O CFS usa uma árvore balanceada Rubro negra ordenada pelo tempo de execução virtual(vruntime) de cada tarefa, quanto menor o vruntime maior prioridade ele terá.O valor de Nice vai de -20 a +19 e de�ine o peso do processo, quanto menor mais CPU recebe.
Comunicação interprocessos:
Há uma necessidade de comunicação entre processos que deve ocorrer sem interrupções e de maneira bem estruturada. As soluções encontradas para a troca de informação entre processos - garantia que os processos não se invadam em atividades críticas e identi�icação da sequência adequada de execução- também podem ser estendidas para o tratamento de threads, com exceção da troca de informação visto que diferentes threads compartilham a heap de memória, contudo manter um afastamento entre as entidades e de�inir uma sequência adequada de execução possuem as mesmas lógicas de implementação.
Condições de disputa ocorrem em situações que dois ou mais processos estão lendo ou escrevendo algum dado compartilhado cujo resultado �inal depende das informações de quem e quando executa precisamente.Por exemplo, quando queremos imprimir um arquivo um processo entra com o nome do arquivo em diretório de spool e outro processo o daemon de impressão veri�ica se já algum arquivo para ser impresso, Considerando o cenário a seguir:
O processo A lê in e armazena o valor 7 na variável local responsável por dizer qual a próxima vaga livre.Imaginando que devido ao �im da fatia de tempo, passemos para o processo B que também lera o valor de IN e colocara em sua variável local, atualizará o diretório de spool e atualiza in, no entanto quando voltarmos para o processo A a variável local aponta para 7 e sobrescreve o nome do arquivo que o processo B mandou.
Região crítica
Para evitar condições de disputa deve-se impedir que mais de um processo leia e escreva em uma área de memória compartilhada( região crítica ) ao mesmo tempo, essa técnica chamasse exclusão mútua e baseia-se em um modo de impedir que outros processos usem uma variável ou arquivo compartilhado que está em uso por outro processo. Além de impedir a condições de disputa outras condições devem ser satisfeitas para que os processos paralelos ocorram de maneira e�icaz:
- Dois processos não podem estar em duas regiões críticas ao mesmo tempo
- Um processo fora da região crítica não pode bloquear outro processo
- Um processo não deve esperar inde�inidamente para entrar em sua região crítica
- Não podemos a�irmar nada sobre a velocidade ou número de CPU
Exclusão mútua com espera ocioso
A seguir exploraremos alternativas para realização da exclusão mútua de forma que enquanto um processo estiver acessando sua região crítica nenhum outro processo cause problemas invadindo-a
Desabilitando interrupções( disable() )
Essa solução é a mais simples e consiste em desabilitar qualquer tipo de interrupção logo depois de se acessar a região crítica e ativa-lo novamente antes de sair, desta forma nenhuma interrupção - seja gerada por fatia de tempo ou qualquer outro fator - irá alternar o processo a ser executado na CPU
Variáveis de impedimento
A solução de baseia no uso de uma variável chamada lock (global) responsável por sinalizar se há algum processo dentro de sua região crítica.Dessa forma quando um processo tenta acessar sua região crítica ele primeiro testa o valor dessa variável, se for igual a zero nenhum outro processo está dentro de sua região crítica se for igual a um algum processo está e o processo requisitante
No entanto a consulta e atualização de lock não ocorrem de maneira atômica,além disso, a lógica apresentada é sujeita a falhas de sincronização e algumas redundâncias. Por exemplo, na linha 11, há uma veri�icação se o outro processo estava dormindo. Se ele estiver sendo colocado para dormir, mas ainda não estiver, a condição falha. A variável de bloqueio pode ser liberada erroneamente.
Semáforos
Mecanismo de sincronização o qual tem associado um contador e uma �ila .O contador com valor positivo indica que alguma condição que estava sendo esperada está satisfeita e pode indicar também o número de recursos disponíveis.Por outro lado, a �ila possui em suas posições descritores de tarefas que estão a espera de alguma condição ser satisfeita para voltarem/iniciarem a ser executados. Os semáforos são manipulados através de duas operações lock() (sem_wait()), responsável por veri�icar que um recurso está disponível e decrementar o contador em caso a�irmativo, do contrário deve salvar o estado da tarefa e inserir o descritor na �ila do semáforo(bloqueando-a),por �im chamando o escalonar para selecionar outra tarefa.
Enquanto isso, a operação unlock()(sem_post()) deve incrementar o contador ou acordar uma tarefa que foi bloqueada.
O uso das primitivas do semáforo cabem nas aplicações, portanto, é esperado que elas sejam inseridas de maneira apropriada no decorrer de aplicações que utilizam recursos compartilhados. O contador do semáforo pode ser binário ou de contagem que informa a quantidade de recursos disponíveis. Ex.: um contador de semáforo pode indicar o número de posições num bu�er, que inicialmente é igual ao tamanho do bu�er.
Mutexes
Assim como o semáforo é um mecanismo para sincronização de tarefas.Operações são oferecidas pelo SO ou por alguma biblioteca em espaço de usuário que usa recursos do SO para bloqueios. A ideia é controlar o acesso mutuamente exclusivo(mutex) , garantindo que apenas uma tarefa acesse a sua região crítica de cada vez. Possui, como o semáforo, um contador e uma �ila, contudo, o contador SP assume valores de 0 e 1, indicando que a área de exclusão mútua está bloqueada ou liberada. Também como semáforos, só pode ser manipulado por primitivas especí�icas como o mutex_lock , responsável por checar se o acesso a região crítica está liberado - contador igual a 1 - e do contrário salvar o estado, bloquear a tarefa na �ila do mutex e chamar o escalonador.
Enquanto isso, o mutex_unlock é responsável por checar se há tarefa na �ila e acordá-la caso houver, se não houver seta o contador para 1.
A consulta e o ajuste do contador devem ser atômico, além disso precisa garantir que a tarefa que bloqueou seja capaz de liberar , ou seja, só quem fez mutex_lock com sucesso pode realizar mutex_unlock
Passagem de mensagem
A comunicação entre tasks pode ocorre por passagem de mensagem via uso de algumas primitivas, são estas ● send( DESTINO, &MENSAGEM) ● receive(ORIGEM,&MENSAGEM) Códigos podem implementar o recebimento de mensagens de origens diversas e comunicação em grupos, enquanto as mensagens podem ter tamanho �ixo ou variável ,desde que limitado.O formato da mensagem pode ser de�inido.
Barreiras
Mecanismo para sincronização de tarefas garantindo que todas as tarefas alcancem um ponto especí�ico antes de prosseguirem as execuções.Ela possui um contador e uma �ila de tarefas. Quando uma barreira é iniciada um contador e especi�icado de�inindo quantas tarefas vao participar da sincronização, já a �ila é iniciada vazia. A primitiva barrier_wait( barreira ) decrementa o contador , se o contador ainda for maior que zero o descritor da tarefa é bloqueado na �iala associada a barreira e o escalonador seleciona outra tarefa, caso o valor for 0, todas as tarefas que chamaram a primitiva e foram bloqueadas são acordadas e colocadas na �ila de prontas em condição de execução.A última tarefa que chegou na barreira também prossegue a execução.
Produtor/Consumidor
Uma tarefa produz algo e outra tarefa é responsável por processar os dados.A lógica do código �ica mais simples, além de podermos ter vários produtores e vários consumidores Inicialmente o produtor está ativo, produzindo ou aguardando a chegada do dado desejado, em contrapartida o consumidor se inicia bloqueado a espera dos dados serem produzidos.Quando o produtor �inalizar a produção uma noti�icação é passada ao consumidor que sera acordado e iniciará a execução.A partir daí o produtor aguarda o consumidor �inalizar o processamento para voltar a produzir, Para possibilitar que vários itens sejam produzidos que algum item seja consumido é comum o uso de um bu�er para comunicação entre o produtor e o consumidor. A medida que produz o produtor insere no bu�er compartilhado enquanto que o consumidor pega, se existir, os dados direto do bu�er. Como o bu�er tem tamanho limitado o produtor deve ser impedido de encher o bu�er,�icando bloqueado se necessário.Enquanto não houver dado no bu�er o consumidor pode ser bloqueado. Na solução normalmente se usa semáforos, mutexes e um bu�er circular. ● semáforo para indicar posição livre no bu�er, valor n = tamanho do bu�er ● semáforo para itens produzido e inseridos no bu�er, valor 0 no início ● 1 mutex para o acesso ao índice de escrita inicia com 0 = livre ● 1 mutex para o acesso ao índice de leitura iniciado com 0 = livre O código para um produtor pode ser:
Enquanto para um consumidor:
Impasses: deadlocks
O jantar dos �ilósofos é um problema onde temos 5 �ilósofos, representados por tasks e entre os pratos dos �ilósofos há um garfo em cada lado, representando os recursos que uma tasks pode utilizar.O problema aqui é que os �ilósofos devem alterar seu tempo entre pensar e comer, sendo que para comer o �ilósofo deve utilizar os dois garfos.
Para se resolver o problema da pra usar estratégias de exclusão mútua para garantir que dois �ilósofos não estejam usando o mesmo garfo nem comendo ao mesmo tempo. Além de sincronização e exclusão o problema evidencia a questões que vêm a ocorrer quando mais de um recurso é necessário dentro de região crítica Essas situações podem ser: ● deadlock: recursos distintos bloqueados por tarefas distintas a espera de outros recursos
○ desta forma as tarefas se bloqueiam, de forma que apenas uma poderia desbloquear a outra,entrando em um paradoxo ● livelocks: tarefa não bloqueada mas os recursos estão, de forma que impede a tarefa de completar o procedimento ● starvation: tarefas nunca conseguem alocar os recursos que necessitam de forma que a execução �ica inde�inidamente preterida *recurso: estrutura de dados,dispositivo,serviço e quaisquer estruturas �ísica ou lógica compartilhada
Inicialmente, foi utilizado um registrador de relocação, onde o SO via onde colocou o programa e armazena no registrador de base o endereço de onde esse código começava.Desta forma se somava o valor do registrador base para cada endereço referenciado pelo programa. No entanto, para evitar que fosse invadido a área de outro processo foi se desenvolvendo técnicas para veri�icação de limites. Ex.:Ver se o endereço calculado para um procedimento do Processo A está dentro do range de endereçamento de A, essa veri�icação é feita por meio do registrador de limite. Desenvolveu o swap área que funciona por meio da reserva de uma área auxiliar na memória do disco.De forma que o SO fazia uma alternância entre as áreas de memória, executando um processo por um tempo e então guardando-o no disco para poder utilizar o espaço de endereçamento para outro programa.
Se for esperado que um processo tenha seu espaço de endereçamento aumentado durante a execução é necessário que tenha-se espaço para esse crescimento, portanto podemos alocar um espaço de folga para permitir o crescimento.Se não for su�iciente e ao lado tiver outro processo, o processo que está crescendo deverá ser alocado para um outro espaço de memória grande o su�iciente, ou então a permutação entre processos será feita para a criaçã ode um espaço.No caso de um processo não conseguir crescer mais e o espaço de swap estiver cheio o processo será suspenso até haver espaço
a) considerando espaço único para dados; (b) considerando área para dados e área para pilha.
Até então o programa era armazenado de forma sequencial, então foi pensado usar um registrador de base e um registrador de limite para cada uma das três áreas do programa( código,dados e pilha) - Técnica de segmentação, em ordem CS,DS e SS para 32 bits-
Gerenciamento de memória com bitMap
No gerenciamento de memória com bitMap a memória é dividida em unidades de alocação, cada unidade é representada por um bit que apontado como 1 está preenchido, como 0 está livre. Quanto menor as unidades de alocação maior o tamanho do bitmap pois mais unidades existiram, no entanto em uma memória de 32n bits será sempre necessário um bitmap com n bits, assim o bitmap ocupa 1/33 da memória.A principal desvantagem do bitMap é que se para alocação de um processo por necessario k bits, na busca por espaço terá que ser encontado uma sequência de k bits 0, o que é uma consulta custoza.
(a) parte da memória com 5 segmentos alocados e 3 livres (b)mapa de bits correspondente
Gerenciamento de memória com Lista Encadeada
Aqui os segmentos de memória são representado por listas como apresentada em (c) , onde o primeiro campo determina se o segmento está livre (H) ou ocupado(P), o segundo o endereço de onde começa o segmento e após o ponteiro para o próximo elemento da lista. Alguns algoritmos para alocação de processos em lista encadeada são: ● �irst �it: menor busca possível, insere onde a tarefa couber ● next �it:igual ao anterior,mas memoriza a posição de um espaço livre sempre que encontra ● best �it:busca no inicio ao �im e escolhe o menor espaço que seja adequado ● worst-�it: o maior espaço livre ● quick-�it:mantém listas separados para os tamanhos mais comuns solicitados
Memória Virtual
Cada programa com seu próprio espaço de endereçamento virtual que é dividido em blocos chamados de páginas,dessa maneira o tamanho total do programa pode exceder a quantidade de memória �ísica disponível para ele.Para isso,o sistema operacional mantém as partes ativas do programa em memória principal,enquanto o restante �ica em disco, de forma que se um programa estiver esperando por outra parte de si, ele está consequentemente esperando por E/S e será bloqueado, onde o SO então escalonará outro processo.
Segmentação e paginação
Características da memória virtual incluem áreas de segmentação e mecanismos de paginação. Segmentação se refere a registradores que apontam para um endereço base seja de código,dados ou pilha.
Arquivos
Os arquivos são unidades lógicas de informação criadas por processos e armazenados em milhares no disco, cada um independente de outro.Suas informações devem ser persistentes, logo, não é desejável que sofra alterações devido a criação ou término de um processo. O sistema operacional é o responsável pelo gerenciamento dos arquivos, dando-se o nome de sistema de arquivos à parte do s.o que lida com estes, se preocupando com estruturação, nomeação, tipos, acesso e atributos.
Nomeação de Arquivos
No momento que um processo cria um arquivo lhe é dado um nome e uma vez concluído o processo o arquivo continuará existindo podendo ser acesso por aquele nome. As regras relativas a nomenclatura variam de acordo com o sistema operacional, no entanto todos permitem cadeias de uma a oito letras, dígitos e caracteres especiais. Os nomes de arquivos também podem possuir duas partes separadas por um ponto.A parte a posteriori do ponto é chamada de extensão e, a nível de sistema operacional, não traz nenhuma diferença servindo apenas como uma convenção ou lembrete ao usuário do tipo de informação presente no arquivo. No entanto, é possível que certos softwares, como compilador C, insistam em que os arquivos processados por ele sejam de alguma extensão especí�ica. Abaixo segue algumas extensões:
Estrutura de Arquivos
Os arquivos podem ser estruturados de três maneiras distintas, no entanto para o s.o o arquivo ainda será tratado como uma sequência de bytes garantindo uma máxima flexibilidade
No modelo por sequência de registros o fundamental é a ideia é que a operação de leitura retorna um registro e a operação de escrita sobreponha ou anexe um registro, estes possuem um tamanho �ixo. A árvore de registros contém em cada um de nós uma chave em uma posição �ixa,.A árvore é ordenada pela chave de nós, a �im de possibilitar uma busca efetiva por uma chave especí�ica, sendo assim, a operação básica para esse tipo de estruturação não é a busca pelo “próximo”, mas sim, pelo especi�ico.
Tipos de Arquivos
Os sistemas operacionais aceitam vários tipos de arquivos, alguns são: ● Arquivos Regulares: Possuem informações do usuário( os vistos em estrutura de arquivos são regulares ● Diretórios : Arquivos do sistema feitos para manter a estrutura do sistema de arquivos. ● Especialista de caracteres relacionados à entrada/saída , usado para modelos dos dispositivos de E/S. ● Especiais de Bloco: Usados para modelos disco Arquivos regulares normalmente são arquivos ASCII e Binários. Os arquivos ASCII consistem em linhas de textos e, em alguns sistemas, cada linha termina com um caractere de carro(carriage return), e em outros o caractere de próxima linha(line feed). A vantagem do ASCII é a facilidade para exibição, impressão e edição, além de que se vários programas usam arquivos ASCII para entrada e saída, é fácil conectar a saída de um programa a entrada de outro. Outros arquivos são binários, em geral listá-los em uma impressora resultaria em algo completamente incompreensível.Para correto funcionamento possui uma estrutura interna conhecida pelos programas que o usam. A seguir um exemplo de um arquivo binário executável tirado de uma versao inicial do Unix.Ele possui cinco seções: cabeçalho, texto, dados, bits de realocação e tabela de símbolos. O cabeçalho começa com o chamado número mágico, identi�icando o arquivo como executável. Ao lado há também um exemplo de um repositório(archive), consistindo de uma série de rotinas de biblioteca compiladas, mas não ligadas.
