Trabalho de SCD

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];