Buscar

Trabalho de SCD

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 3, do total de 11 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 6, do total de 11 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Você viu 9, do total de 11 páginas

Faça como milhares de estudantes: teste grátis o Passei Direto

Esse e outros conteúdos desbloqueados

16 milhões de materiais de várias disciplinas

Impressão de materiais

Agora você pode testar o

Passei Direto grátis

Prévia do material em texto

FACULDADE INDEPENDENTE DO NORDESTE - FAINOR
BACHARELADO DE ENGEHARIA DA COMPUTAÇÃO
RESOLUÇÕES DE LISTA DE EXERCÍCIO– 1ª Unidade
Vitória da Conquista – Bahia
2018.2
FACULDADE INDEPENDENTE DO NORDESTE - FAINOR
Alunos: Bruno Oliveira Caires Souza, Lucas Gomes Santos
 
Trabalho realizado como avaliação parcial do VIII Semestre do curso de Engenharia da Computação, FAINOR, da disciplina Sistemas Concorrentes e Distribuídos, a pedido do professor Joaquim Júnior Lacerda.
Vitória da conquista- Bahia
2018.2
1 - LISTA DE EXERCÍCIO 
Questão 1 - O que muda do modelo de programação tradicional para o modelo de programação concorrente?
A programação tradicional ela terá seus métodos, classes e variáveis, tendo o acesso aos dados do programa em execução. E para compilar o código, não existirá concorrência no código e sendo até mais pesado de se executar. Já as threads, além de serem mais leves que os processos, elas apresentam paralelismo e concorrência, sempre compartilhando o mesmo registro descritor.
Questão 2 - Explique qual funcionalidade na biblioteca Pthread, do tipo pthread_t e das funções pthread_create, pthread_join e pthread_exit.
A biblioteca pthread é a biblioteca que disponibilizará as funções para se programar thread em c, nela teremos as condições de utilizar os comandos pthread_create (que significa criar uma thread), pthread_join (que significa unir as threads), pthread_exit(depois de criar, juntar, temos que finalizar a thread, e é isso que esse comando faz). A função pthread_t será um indicador da nossa thread.
Questão 3 - Faça um programa em pthread que crie 10 threads e imprima na tela a ordem de execução de cada thread com um id representando a ordem de criação.
#include<stdlib.h>
#include<stdio.h>
#include<pthread.h>
int n_threads=10; //quantidade de threads que vou criar
typedef struct
{
	int id;
	
}thread_arg;
void *thread(void *vargp);
int main(){
 pthread_t tid[n_threads];
 thread_arg a[n_threads];
 int i = 0;
 
 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);
 }	
 printf("\n");		 
 pthread_exit((void *)NULL);
 return 0;
 }
 
void *thread(void *vargp){
	 thread_arg *a = (thread_arg *)	vargp;
	 int i = 0;
		printf("Eu sou a thread de numero %d\n",a->id);
		for(i=0;i<n_threads;i++);
		printf("Agora sou a thread %d finalizando\n",a->id);
		pthread_exit((void *)NULL);
 } 
Questão 4 - Explique como funciona a passagem de parâmetros para a thread em pthread.
Para se programar com paralelismo e concorrência com threads, temos a passagem de parâmetros. Por exemplo:
int soma(int a, int b); //passagem por valor
int soma(int *a, int *b); //aqui é passagem por referencia
Nesse caso, são duas variáveis diferentes, onde a receberá um valor, e *a pode ser uma variável de saída. Sendo que, o que muda dentro do código, muda para fora.
Outro exemplo, quando fazermos:
int x = 1;
int y = 2;
soma(&x,&y);
Os valores declarados em x e y, ao passar por soma, estamos levando esses valores para memória.
Questão 5 - Faça um programa em pthread com duas threads, uma thread deve somar os elementos em índices pares de uma matriz e a outra thread deve somar os elementos em índices ímpares. Matriz = {1, 2, 3, 4, 5, 6, 7, 8, 9}
#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
int n_threads = 2; //qtd de threads que quero
int tam=9;
int matriz[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
typedef struct //é como se fosse uma classe, mas nao é, e tudo é publico
{
 int id;
 int resultado;
	
} thread_arg; //argumento padrao para thread
void *soma(void *vargp); //void * ele pode receber qualquer ponteiros, funcao que vai ter o comportamento concorrente
int main() 
{
 pthread_t tid[n_threads]; //é aqui que te dar o identificador da thread 
 thread_arg a[n_threads]; //matriz de argumentos que se chama 'a', e será 2 threads
 int i = 0;
 //int n_threads = 2000;
 //Cria as threads
 for(i=0; i < n_threads; i++)
 {
 a[i].id = i; // ele está indo de 0 até 3, para saber tbm a ordem de criação
 a[i].resultado=0;
 pthread_create(&(tid[i]), NULL, soma, (void *)&(a[i])); // e vou criando as threads, onde tenho o a que é "a" matriz, ela já cria a thread e ja executa
 }
 // Espera que as threads terminem
 for(i=0; i<n_threads; i++)
 {
 pthread_join(tid[i], NULL); // depois de criar as threads, eu tenho que agora que juntar as threads, e o meu NULL seria um ponteiro para passar o valor de return caso a função tivesse o return
 }
 
 printf("Thread0,resultado=%d\n", a[0].resultado);
 printf("Thread1,resultado=%d\n", a[1].resultado);
	
 pthread_exit((void *)NULL); //ele desabilita a biblioteca, pois recursos são gastos para usar essas threads, logo ele finaliza
 
 return 0;
}
void *soma(void *vargp) 
{
 int i = 0;
 thread_arg *a = (thread_arg *) vargp; //convertendo de void * para o que era antes
 for(i = a->id; i < tam; i+=2)
 {
		a->resultado+=matriz[i];
	}
 
 pthread_exit((void *)NULL);
}
Questão 6 - Implemente um programa em pthreads que some duas matrizes, onde deve existir uma thread para somar cada dois elementos, ou seja, com duas matrizes de 10 posições deve ser usado 10 threads.
 Matriz1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
 Matriz2 = {2, 2, 2, 2, 3, 3, 3, 3, 3}
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
int n_threads=9;
int matriz1[]={1,2,3,4,5,6,7,8,9};
int matriz2[]={2,2,2,2,5,5,5,5,5};
typedef struct{
	int id;
}thread_arg;
void *somando1(void *varpg);
void *somando2(void *varpg);
void *somando3(void *varpg);
void *somando4(void *varpg);
void *somando5(void *varpg);
void *somando6(void *varpg);
void *somando7(void *varpg);
void *somando8(void *varpg);
void *somando9(void *varpg);		
	
int main(){
	int i=0;
	pthread_t tid[n_threads];
	thread_arg a[n_threads];
	a[0].id=0;
	pthread_create(&(tid[0]),NULL,somando1,(void *)&(a[0]));
	a[1].id=1;
	pthread_create(&(tid[1]),NULL,somando2,(void *)&(a[1]));
	a[2].id=2;
	pthread_create(&(tid[2]),NULL,somando3,(void *)&(a[2]));
	a[3].id=3;
	pthread_create(&(tid[3]),NULL,somando4,(void *)&(a[3]));
	a[4].id=4;
	pthread_create(&(tid[4]),NULL,somando5,(void *)&(a[4]));
	a[5].id=5;
	pthread_create(&(tid[5]),NULL,somando6,(void *)&(a[5]));
	a[6].id=6;
	pthread_create(&(tid[6]),NULL,somando7,(void *)&(a[6]));
	a[7].id=7;
	pthread_create(&(tid[7]),NULL,somando8,(void *)&(a[7]));
	a[8].id=8;
	pthread_create(&(tid[8]),NULL,somando9,(void *)&(a[8]));
 
 for(i=0;i<n_threads;i++){
		pthread_join(tid[i],NULL);
	 }
	for(i=0;i<n_threads;i++){
		printf("%d, ",matriz1[i]);
		 }
	printf("\n");	 
	pthread_exit((void *)NULL);
	return 0; 
	 }
void *somando1(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 *somando2(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 *somando3(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 *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.