Multiplicidade

* Os relacionamentos têm uma multiplicidade, que especifica o número de elementos de cada entidade que participam neles

Exemplo anterior:
- Sabe -se que um aluno só se pode inscrever em um só um "curso"
- Sabe-se que num "curso" se podem inscrever nenhum ou N alunos

Modelo E R

Modelo E R

* Representa apenas aspectos estáticos( entidades , os seus relacionamentos e a as propriedades de ambas)
* Destina-se a melhorar o conhecimento do utilizador sobre os dados

Entidade: qualquer objecto indentificavel , por exemplo: aluno,curso, cliente....

Propriedade: é informação/dado sobre uma dada entidade, como por exemplo: idade, nome, morada,...

Relacionamento: entidade que serve para ligar dias ou mais entidades, como por exemplo: frequenta, tem....

* Existe um relacionamento "inscrito" entre as entidade "aluno" e "curso"

* Esse relacionamento é caracterizado pelo atributo "data"

* As entidades "aluno" e "curso" têm os atributos mostrados

Blogs

Venho com uma nova categoria no meu blog.

Em vez de só criar post relacionados com apontamentos sobre o meu curso(Engenharia Informática), decide que também é preciso divulgar novos blogs na minha área de eleição(Informática) e porque não começar com o Blog: "Pegada Digital" http://daft-hferreira.blogspot.pt/ .

O Blog "Pegada Digital" é um blog relacionado com área da informática mas com algumas pequenas curiosidades, também como alguns apontamentos de conteúdos relacionados com a Informática.

O Blog/Site "FU2ion" http://fu2ion.azurewebsites.net/é um site  de entretenimento sobre diversas áreas, com foco na área das Novas Tecnologias.

Por enquanto são estes blogs que eu tenho conhecimento. Mas gostava que vocês deixa-sem em comentário mais blogs/sites para eu fazer a sua divulgação. É desta maneira que todos nós conseguimos manter actualizados.

Gestor de Processos

Um processo pode executar-se no processador ou á espera de ter possibilidade de se executar. O ciclo de vida dos processos vai evoluir desde a sua criação por três estados fundamentais: o primeiro corresponde a deter o processador e portanto, estar em Execução; quando o processo não se pode executar por não ter acesso ao processador está no estado Executável. O terceiro estado, Bloqueado, corresponde a um situação diferente em que o processo mesmo que tivesse o processador não poderia avançar porque uma condição lógica o impedia (já anteriormente nos apareceram funções que esperam pela terminação de outro processo e situações em que um processo se bloqueia á espera de um acontecimento).

·         Em execução- Processo a usar o processador

·         Executável- Processo que pode prosseguir a sua execução e que tal necessita que lhe seja atribuído processador

·         Bloqueado- Processo que espera um acontecimento que enquanto não ocorrer o impede de continuar a executar-se.

As transições entre os três estados correspondem aos seguintes acontecimentos:

·         Executável-> Em execução- O processo foi seleccionado para execução pelo despacho porque é mais prioritário do que o processo corrente ou porque este ultimo deve abandonar o processador (terminou ou bloqueou-se)

·         Em execução-> Executável- Um outro processo na lista dos executáveis tem maior prioridade e o despacho efetua a comutação

·         Em execução-> Bloqueado- O processo tem de interromper a sua execução porque espera um acontecimento sem o qual não pode continuar a executar o respectivo programa.

·         Bloqueado-> Executável- O acontecimento que mantinha o processo bloqueado ocorreu e este passa novamente a poder executar-se. Passa para a lista de executáveis, podendo, se for o mais prioritário, passar de seguida a executar-se ou mais tarde quando for seleccionado pelo despacho.

Quatro objectivos diferentes relacionados com este tipo de gestão:

·         Optimizar a produtividade do sistema, executando o maior numero de programas possível num dado período de tempo (determinado throughput do sistema);

·         Procurar equilibrar a carga do sistema de forma a dar um serviço relativamente uniforme aos diversos clientes;

·         Dotar o sistema de grande reactividade as condições externas;

·         Minimizar o tempo médio para completar a execução de vários programas 

Processos: modo computacional

A multi programação consiste na execução em pseudoparalelismo de vários programas na mesma máquina, onde os vários fluxos de execução são multiplexados no tempo, cada fluxo é designado por processo.

Os elementos principais que constituem um processo são um espaço de endereçamento, que normalmente se divide numa região para o código, outra para a pilha e outra para os dados globais e alocados dinamicamente (heap). Cada processo tem um estado que pode ser salvaguardado e posteriormente reposto, de forma a permitir a comutação entre processos. Um processo tem ao seu dispor um reportório de operações, que consiste nas instruções máquina do processador e nas operações exportadas pelo sistema operativo (chamadas de sistema).

O modelo de segurança baseia-se no isolamento entre processos, o que significa que os processos não podem interferir uns com os outros e na existência de um utilizador que é o dono do processo, em função do qual são definidas as acções que o processo pode executar sobre os restantes recursos do sistema operativo, uma vez que estes acessos são sempre mediados pelo núcleo.

Os processos organizam-se normalmente de forma hierárquica, em que um processo ao criar outro estabelece uma relação de pai-filho nessa hierarquia. Algumas informações são herdadas do processo pai para os processos filhos.

pid_t fork(void)- chamada ao sistema para a criação de um novo processo

1- Quando um processo invoca a chamada ao sistema fork() o sistema operativo vai executa-la em modo protegido (modo sem restrições de execução)

2- O Sistema Operativo verifica se o processo que invoca o fork() ainda não esgotou o número máximo de processos filhos e em caso afirmativo executa o fork()

3- O processo inicial é duplicado (estruturas de dados do núcleo, zonas de memória, etc..) e ao novo processo é atribuído um novo PID

4- O novo processo integra a lista de processos candidatos a usar o  CPU

5- O Sistema Operativo retorna o PID do filho ao Pai e zero ao filho. A execução de cada um destes processos é retornada na instrução seguinte ao fork()

Um processo pode ser visto como objecto, com propriedades e operações. As propriedades fundamentais são um identificador, o ficheiro com o programa executável, o seu espaço de endereçamento, prioridade, estado de execução, processo pau, canais de E/S, ficheiros abertos quotas de utilização de recursos, contexto de segurança e ambiente utilizador

As operações definem a interface do sistema operativo para manipular processos e incluem operações para criar um novo processo auto – terminar, para eliminar outro processo, para esperar pela terminação de outro processo, para suspender a execução de um processo, ou auto suspender-se e para ler o estado do processo.

            A operação sobre processos que se desvia mais do modelo computacional genérico é a operação de criação de processos Unix (fork), que cria um novo processo absolutamente idêntico ao processo pai. Para o processo filho executar um programa diferente do pai, é necessário que este invoque uma segunda função (exec) que altera o programa a ser executado.

exec():
Quando um processo invoca a chamada ao sistema execxx o núcleo do Sistema Operativo vai reescrever as zonas de memória associadas ao processo (filho zona estática e dinâmica de dados e código) com a informação existente no ficheiro executável indicado como parâmetro. A execução do processo é iniciado no main() do novo código.

Em Unix, o tratamento das excepções e de acontecimentos assíncronos tem particular importância. Os signals são muito semelhantes ao modelo de rotinas assíncronas e foram a ideia original desta extensão ao modelo de programação estruturado. Os acontecimentos assíncronos podem ser analisados a um processo em execução através da activação de um signal. Os acontecimentos susceptíveis de gerarem um signal tem origens muitos diversas, e são referenciados num ficheiro de texto (signal.h) que indica o respectivo nome lógico e o valor inteiro que é usado para codifica-lo internamente no núcleo.

Organização do Sistema Operativo

O sistema operativo é usualmente composto por três entidades: o núcleo, as bibliotecas de chamadas sistema e os processos de sistema.

O núcleo implementa o mecanismo de base do sistema operativo. Em particular, a gestão dos processos, da memória, dos ficheiros, das E/S e a comunicação entre processos.

O funcionamento do núcleo é fortemente influenciado por mecanismos de hardware que permitem garantir o seu funcionamento seguro. A segurança do sistema operativo advém da existência de um isolamento entre os processos dos utilizadores, e entre estes e o núcleo do sistema operativo.

O isolamento é garantido pela gestão da memória que só permite determinadas posições de memória sejam acessíveis por um utilizador. Mas como o funcionamento do núcleo tem de ser partilhado por todos os processos é forçado que exista um mecanismo não controlado directamente pelos programas utilizador para gerir estas alterações do espaço de endereçamento.

Esta componente de hardware gere a dualidade de execução do processador em modo de utilizador e modo núcleo: o modo utilizador restringe o acesso a determinadas posições de memória e certas instruções que podem ultrapassar o isolamento como as que interagem directamente como os periféricos ou com as instruções; em modo núcleo não existem tais restrições, sendo este o modo que o núcleo do sistema operativo se executa.

As chamadas sistema são implementadas por um função que invoca a excepção (trap) que transfere o controlo para o núcleo e automaticamente coloca o processador no modo de execução núcleo.

No núcleo é feita a escolha do código apropriado que implementa a chamada ao sistema em causa. No final da chamada, a instrução de retorno de interrupção devolve o controlo para a função de biblioteca que, por sua vez retorna para o código do utilizador.

Os processos sistema executam funções que podem ser delegas em processos autónomos, de forma a reduzir a complexidade do núcleo ou aumentar a sua robustez. Estes processos executam-se em modo utilizador mas pertencem ao sistema operativo pelo que tem privilégios de administrador, contudo, para invocar funções do sistema tem de o fazer através das chamadas ao sistema, o que é menos eficiente do que se a execução fosse directamente do núcleo.

Uma organização do núcleo em camadas generaliza o conceito de protecção entre modo núcleo e modo utilizador, dividindo o núcleo em várias camadas que implementam diferentes funcionalidades e obrigando as camadas mais externas a invocar funções das camadas internas através do mecanismo semelhante aos das chamadas do sistema.

Chamadas de sistemas

-> fork()
pid_t fork(void)- chamada ao sistema para a criação de um novo processo

1- Quando um processo invoca a chamada ao sistema fork() o sistema operativo vai executa-la em modo protegido (modo sem restrições de execução)
2- O Sistema Operativo verifica se o processo que invoca o fork() ainda não esgotou o número máximo de processos filhos e em caso afirmativo executa o fork()
3- O processo inicial é duplicado (estruturas de dados do núcleo, zonas de memória, etc..) e ao novo processo é atribuído um novo PID
4- O novo processo integra a lista de processos candidatos a usar o CPU
5- O Sistema Operativo retorna o PID do filho ao Pai e zero ao filho. A execução de cada um destes processos é retornada na instrução seguinte ao fork()

->exit()
void exit(int estado)

1- Quando um processo invoca a chamada exit() o núcleo do Sistema Operativo recolhe todos os recursos associados com o processo em causa
2- No entanto, o núcleo do Sistema Operativo preserva o código de finalização enviado como argumento da chamada exit() para terminar a sua recolha pelo processo que termina
3- Só se perde referência completa a um processo desde o seu pai recolher o seu código de finalização

-> exec():

Quando um processo invoca a chamada ao sistema execxx o núcleo do Sistema Operativo vai reescrever as zonas de memória associadas ao processo (filho zona estática e dinâmica de dados e código) com a informação existente no ficheiro executável indicado como parâmetro. A execução do processo é iniciado no main() do novo código

-> wait()

1-Verifica se contêm algum filho a executar (caso falhe, retorna <0)
2- Verifica se algum filho terminou
3- Se nenhum dos filhos terminou o processo fica bloqueado até que algum destes termine
4- Recolhe o estado do primeiro processo filho que terminar
5- Retorna o PID do processo que terminou

-> waitpid()

Contêm um comportamento semelhante á chamada wait(), no entanto bloqueia somente para aguardar por um PID especifico(passado como argumento) termine.