A maior rede de estudos do Brasil

Grátis
11 pág.
Trabalho de SCD

Pré-visualização | Página 2 de 2

for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando4(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando5(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando6(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando7(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando8(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
void *somando9(void * varpg){
	int i=0; //vamos usar somente para realizar a espera ocupada
	thread_arg *a = (thread_arg *) varpg;
	matriz1[a->id]+=matriz2[a->id];
	for(i=0;i<1000;i++); //simulando a espera ocupada
	printf("Thread %d finalizada\n",a->id);
}
Questão 7 - Criar 4 threads que achem multipliquem todos os elementos de um vetor por um escalar e depois achem o maior elemento. Primeiro fazem a multiplicação e depois acham o maior.
#include<stdlib.h>
#include<stdio.h>
#include<pthread.h>
int n_threads=4;
int vetor[]={5,2,7,1};
typedef struct{
	int id;
	}thread_arg;
void *thread(void * varpg);
int main(){
	int i=0;
	int numero=0;
	pthread_t tid[n_threads];
	thread_arg a[n_threads];
	for(i=0;i<n_threads;i++){
		a[i].id=i;
		pthread_create(&(tid[i]),NULL,thread,(void *)&(a[i]));
		 }
 for(i=0;i<n_threads;i++){
		pthread_join(tid[i],NULL);
	 }
	for(i=0;i<n_threads;i++){ //nesse for é onde vou verificar o maior elemento depois dele ter sido multiplicado por um valor escalar
		if(vetor[i]>numero){
			numero=vetor[i];
		 }
					 }
	printf("Maior número que contém dentro do vetor eh %d\n",numero);
	printf("\n");
	pthread_exit((void*)NULL);
	return 0;	 
	 } 
	
void *thread(void *varpg){
	int i = 0;
	thread_arg *a = (thread_arg *) varpg;
	vetor[a->id] = vetor[a->id] * 3;
	for(i=0;i<n_threads;i++);
	printf("\n Thread finalizada %d\n",a->id);
	 }
2 - EXERCÍCIO DO CAPÍTULO 1 DO LIVRO
Exercício 1.1 - De Exemplos de como um Sistema Operacionais torna a utilização do computador: (a) mais facíl, (b) mais eficiente, (c) mai confiavél.
a) O mais fácil de usar são os SO para computadores pessoais.
b) O mais eficientes seriam SO’s para aplicações de tempo real
c) Os mais confiáveis são SO’s para computadores embarcados.
Exercício 1.2 – Caracterize os SOs para processamento de batches, time-sharing e real-time. 
Os SO’s batches, time-sharing e real-time fazem parte dos SO’s clássicos. 
O SO’s batches mais conhecido como SO de processamento em lotes, é um tipo de SO que processa o job do usuário não ocorrendo interação nenhuma com o usuário, o processamento é divido em lotes, para que assim seja executado uma grande quantidade de dados.
O SO time-sharing é o tipo de SO que atende vários usuários simultanemente, de forma online, permitindo que cada usuário intereja com sua computação
O SO real-time são SO’s ligados a processos externos, por exemplo, processos industriais, processos de equipamentos médicos, etc. Esse SO trabalha com sistema de interrupção, no qual acionam o computador com um sinal de interrupção caso algum erro tenha acontecido, se esse sinal de interrupção não for atendido ou respondidos, os processos vão continuar executando, porém de forma errada e degradada.
Exercício 1.3 - Caracterize os SOs para Redes e os SOs Distribuídos. 
Antes de detalhar os SO’s de redes e SO’s distribuídos, temos que entender o conceito de sistemas fortemente acoplados e sistemas fracamente acoplados. O sistema fortemente acoplado é um tipo de sistema que utiliza memória compartilhada, onde o hardware não é distribuído e todos os processos se compartilham, tanto memória quanto relógio. Já o fracamente acoplado é o inverso, onde o hardware não compartilha a memória, aqui cada um tem sua memória privativa e relógio, e o hardware se comunica através de linhas de comunicação, como barramento, redes, etc.
Logo, os SO’s de rede são considerados fracamente acoplado, onde cada componente de nó desse sistema pode ser distindo. E os SO’s Distruibuídos são fortemente acoplados, onde cada nó do sistema são os mesmos.
3 - EXERCÍCIO DO CAPÍTULO 2 DO LIVRO
Exercício 2.1 - No Sistema de interrupção típico descrito na seção 2.1, a instrução RTI precisa ser protegida?
Precisa sim, porque é ela que carrega os registradores PC e PSW. Quando ocorre uma interrupção ou uma trap, o PC é um registrador que armazena o endereço da rotina correspondente a rotina. E o PSW armazena um campo para mascarar a interrupção para a UCP. 
Exercício 2.2 – Conceitue interrução, trap, processo e co-rotina.
Interrupção – é um sinal gerado por um hardware para suspender a execução de um programa.
Trap – é um sinal gerado por um software para suspender a execução de um programa.
Processo – Um processo é um programa em execução, o qual é constituido por uma sequência de instruções, um conjusnto de dados e um rigistrador descritor. Isso que dizer que um processo é uma lista de instruções, a qual informa ao processador que passos devem ser executados e em quis momentos isso deve acontecer.
Co-rotina – são processos especiais que só perdem a CPU por vontade própia, quando executam uma operação para passer adiante o controle da execução.
Exercício 2.3 - Explique porque pode-se dizer que um processo é uma entidade que define e controla um processo virtual.
Quando se tem um uma instação com um único processador executando de forma multiplexada N processos pode ser vista como se possuísse N processadores processadores virtuais, um para casa processo em execução. Cada processador virtual tem 1/N de velocidade do processador real. Por isso que uma das definições é, “um processo é uma entidade que define e controla um processador virtual”.
Exercício 2.4 - Destinga processo limitado por E/S (IO/bound) de processo limitado por computação (CPU-bound). Qual dos dois deve receber prioridade de escalonamento?
Se um processo passa a maior parte do tempo esperando por disposistivos de E/S (Ex: rede de impressoras), diz-se que o processo é limitado por E/S(IO-bound). Se ao contrário, o processo gastar a maior parte do seu tempo usando a UCP ele é ditto limitado por computação (CPU-bound). 
Exercício 2.5 – Explique se consegue maior eficiência na utilização do equipamento quando se dá prioridade para os processos IO-bound.
Dando-se prioridade aos processos IO-bound consegue-se maior eficiência na utilização dos componetes de hardware. Ou seja, durante as execuações de um processo, os usuários fazem requisiçoes ao SO através de traps, para ler teclado, graver um setor de disco, etc, nesse momento o SO bloqueia o processo, isto é, coloca seu descritor em uma fila de espera e deixa de dar tempo de UCP a ele. Dessa forma consegue maior eficiência.