/*-----------------------------------------------------*/
int main(){
pthread_t id;
sem_init(&mutex, 0, 1);
sem_init(&barr, 0, 0);
a = 3;
pthread_create(&id, NULL, funcao, NULL);
c = a + 1;
barreira();
d = b + c;
c = b + d;
barreira();
printf("Valores finais: %d %d %d %d\n", a, b, c, d);
sem_destroy(&mutex);
sem_destroy(&barr);
}
void * funcao (void * args){
b = a;
barreira();
a = a + 2;
barreira();
}
void * threads_integral (void* arg){
// Descobre o pid da thread
int* p = (int *) arg;
int pid = * p;
int particaoInicial,particaoFinal, i;
double inicioIntervalo, fimIntervalo;
//printf("-- Thread %d criada!\n", pid);
// Enquanto o erro da iteração for maior que o erro máximo, calcula a integral mais uma vez
while(erroIteracaoAtual > erroMaximo){
pthread_mutex_lock(&mutex);
// Verifica se existe alguma partição livre que alguma thread ainda não pegou
if( nParticoesParaCalcular > 0 ){
particaoFinal = vetorParticao[nParticoesParaCalcular - 1];
if( nParticoesParaCalcular == 1 ){
particaoInicial = 0;
}else{
particaoInicial = vetorParticao[nParticoesParaCalcular - 2] + 1;
}
nParticoesParaCalcular --;
pthread_mutex_unlock(&mutex);
vetorIntegral[pid] = 0;
for(i = particaoInicial ; i <= particaoFinal; i++){
inicioIntervalo = calcula_inicio_intervalo(i);
fimIntervalo = calcula_fim_intervalo(i);
// Descomente as linhas abaixo para ver passo a passo
//printf(" Thread %d Inicio intervalo %f \n", pid, inicioIntervalo);
//printf(" Thread %d Fim intervalo %f \n", pid, fimIntervalo);
vetorIntegral[pid] += calcula_integral(inicioIntervalo, fimIntervalo);
//printf(" Thread %d , particao %d, valor integral: %f\n", pid, i, vetorIntegral[pid]);
}
//printf("Thread %d calculou seu pedaço de integral!\n Sua particaoInicial foi: %d e a sua particaoFinal foi %d \n", pid,particaoInicial,particaoFinal);
}else{
pthread_mutex_unlock(&mutex);
vetorIntegral[pid] = 0;
// Descomente as linhas abaixo para ver passo a passo
//printf("Thread %d não fez nada nessa iteração!\n", pid);
}
barreira(pid);
}
pthread_exit(NULL);
}
void * threads_integral (void* arg){
// Descobre o pid da thread
int* p = (int *) arg;
int pid = * p;
int particaoInicial,particaoFinal, i;
double inicioIntervalo, fimIntervalo;
// Enquanto o erro da iteração for maior que o erro máximo, calcula a integral mais uma vez
while(erroIteracaoAtual > erroMaximo){
pthread_mutex_lock(&mutex);
// Verifica se existe alguma partição livre que alguma thread ainda não pegou
if( nParticoesParaCalcular > 0 ){
// Pega o valor da partição final do buffer de partições
particaoFinal = vetorParticao[nParticoesParaCalcular - 1];
// Calcula o valor da partição inicial baseada na partição final
if( nParticoesParaCalcular == 1 ){
particaoInicial = 0;
}else{
particaoInicial = vetorParticao[nParticoesParaCalcular - 2] + 1;
}
// Indica que foi removido um elemento do buffer
pthread_mutex_unlock(&mutex);
nParticoesParaCalcular --;
// Limpa o vetor de integrais da última iteração
vetorIntegral[pid] = 0;
// Faz o cálcula da integral para cada partição e salva no vetor de integrais parciais
for(i = particaoInicial ; i <= particaoFinal; i++){
inicioIntervalo = calcula_inicio_intervalo(i);
fimIntervalo = calcula_fim_intervalo(i);
vetorIntegral[pid] += calcula_integral(inicioIntervalo, fimIntervalo);
}
}else{
pthread_mutex_unlock(&mutex);
// Limpa o vetor de integrais da última iteração
vetorIntegral[pid] = 0;
}
barreira(pid);
}
pthread_exit(NULL);
}
