Commit db275071 authored by Franco García Cillero's avatar Franco García Cillero
Browse files

Ejercicios resueltos

parent cf603352
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>
int main()
{
char prog[1024];
char* line;
char* line1;
char sep[2] = "|";
char stringu[40];
for(;;){
printf("yes, master...");
int pip[2];
pipe(pip);
fgets(prog,sizeof(prog),stdin);
if (*prog == '\n') continue;
if(strcmp(prog,"fin\n") == 0) return 0;
line = strtok(prog,sep);
line1 = strtok(NULL, sep);
line1[strlen(line1)-1]=0; /* Sacamos el \n */
if(strcmp(prog,"fin") == 0) return 0;
if(fork() != 0){
wait(NULL);
}
else{
if(fork() == 0){
close(1); dup(pip[1]); close(pip[1]);
execl(line, line,NULL);
close(1);
exit(-1);
}
else{
close(pip[1]);
read(pip[0], stringu,sizeof(stringu));
//~ wait(NULL);
execl(line1, line1, stringu,NULL);
exit(-1);
}
}
//~ int pid, status;
//~ pid=wait(&status);
//~ if(WIFEXITED(status)){
//~ printf("%d normal, %d\n", pid, WEXITSTATUS(status));
//~ }
//~ else
//~ printf("%d anormal: %d\n", pid, WTERMSIG(status));
}
return 0;
}
#include <stdio.h>
#include <string.h>
int main(){
printf("mundo");
//~ char string[1024];
//~ fgets(string,sizeof(string),stdin);
//~ string[strlen(string)-1]=0;
//~ printf("%s", string);
return 0;
}
#include <stdio.h>
int main(int argc, char **argv){
printf("hola %s!\n", argv[1]);
return 0;
}
#include <stdio.h>
#include <pthread.h>
#include <time.h>
#define N_VISITANTES 10000000
clock_t start, end;
double cpu_time_used;
pthread_mutex_t s = PTHREAD_MUTEX_INITIALIZER;
int visitantes = 0;
//~ void *molinete(void *arg)
//~ {
//~ start = clock();
//~ pthread_mutex_lock(&s);
//~ int i;
//~ for (i=0;i<N_VISITANTES;i++)
//~ visitantes++;
//~ pthread_mutex_unlock(&s);
//~ end = clock();
//~ cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
//~ printf("%f\n", cpu_time_used);
//~ }
void *molinete(void *arg)
{
start = clock();
int i;
for (i=0;i<N_VISITANTES;i++){
pthread_mutex_lock(&s);
visitantes++;
pthread_mutex_unlock(&s);
}
end = clock();
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("%f\n", cpu_time_used);
}
int main()
{
pthread_t m1, m2;
pthread_create(&m1, NULL, molinete, NULL);
pthread_create(&m2, NULL, molinete, NULL);
pthread_join(m1, NULL);
pthread_join(m2, NULL);
printf("Hoy hubo %d visitantes!\n", visitantes);
return 0;
}
/* El problema es que los dos 2 threads utilizan la
* funcion molinete que modifica a visitantes pero no espera
* a que la ejecucion del otro termine por lo que trabajan con
* el valor sin las modificaciones hechas por el otro por lo que
* el resultado no representa la verdadera cantidad de visitantes.
* Es decir, visitantes++ en molinete es una region critica. */
/* Luego de ejecutarlo 5 veces con N_VISITANTES = 10, el resultado fue
* siempre correcto debido a que al haber menor cantidad de elementos
* un proceso llega a terminar antes de que se ejecute el otro y
* entonces el segundo proceso tiene el valor de visitantes con las
* modificaciones hechas por el primer proceso. */
/* El valor minimo que puede tomar es N_VISITANTES, cuando el primer thread
* aumenta en 1 a visitantes, el segundo lo hace poco despues y guarda 1 en
* visitantes y asi cada iteracion del primero es sobrescrita por el
* segundo y resulta en N_VISITANTES. */
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define N_FILOSOFOS 5
#define ESPERA 5
pthread_mutex_t tenedor[N_FILOSOFOS];
sem_t cant_fil;
void pensar(int i)
{
printf("Filosofo %d pensando...\n",i);
usleep(random() % ESPERA);
}
void comer(int i)
{
printf("Filosofo %d comiendo...\n",i);
usleep(random() % ESPERA);
}
void tomar_tenedores(int i)
{
sem_wait(&cant_fil);
pthread_mutex_lock(&tenedor[i]); /* Toma el tenedor a su derecha */
pthread_mutex_lock(&tenedor[(i+1)%N_FILOSOFOS]); /* Toma el tenedor a su izquierda */
}
//~ void tomar_tenedores_zurdo(int i) //Implementacion con N-1 filosofos comiendo
//~ {
//~ pthread_mutex_lock(&tenedor[(i+1)%N_FILOSOFOS]); /* Toma el tenedor a su izquierda */
//~ pthread_mutex_lock(&tenedor[i]); /* Toma el tenedor a su derecha */
//~ }
void dejar_tenedores(int i)
{
pthread_mutex_unlock(&tenedor[i]); /* Deja el tenedor de su derecha */
pthread_mutex_unlock(&tenedor[(i+1)%N_FILOSOFOS]); /* Deja el tenedor de su izquierda */
sem_post(&cant_fil);
}
//~ void dejar_tenedores_zurdo(int i) //Implementacion con N-1 filosofos comiendo
//~ {
//~ pthread_mutex_unlock(&tenedor[(i+1)%N_FILOSOFOS]); /* Deja el tenedor de su izquierda */
//~ pthread_mutex_unlock(&tenedor[i]); /* Deja el tenedor de su derecha */
//~ }
//~ void *filosofo(void *arg) //Implementacion con el filosofo zurdo
//~ {
//~ int i = (int)arg;
//~ for (;;)
//~ {
//~ if(i == N_FILOSOFOS/2){
//~ tomar_tenedores_zurdo(i);
//~ comer(i);
//~ dejar_tenedores_zurdo(i);
//~ pensar(i);
//~ }
//~ else{
//~ tomar_tenedores(i);
//~ comer(i);
//~ dejar_tenedores(i);
//~ pensar(i);
//~ }
//~ }
//~ }
void *filosofo(void *arg) //Implementacion con N-1 filosofos comiendo
{
int i = (int)arg;
for (;;)
{
tomar_tenedores(i);
comer(i);
dejar_tenedores(i);
pensar(i);
}
}
int main()
{
sem_init(&cant_fil,0,N_FILOSOFOS-1);
int i;
pthread_t filo[N_FILOSOFOS];
for (i=0;i<N_FILOSOFOS;i++)
pthread_mutex_init(&tenedor[i], NULL);
for (i=0;i<N_FILOSOFOS;i++)
pthread_create(&filo[i], NULL, filosofo, (void *)i);
pthread_join(filo[0], NULL);
return 0;
}
/* El deadlock ocurre cuando un filosofo toma el tenedor a su derecha,
* mientras que el filosofo a su izquierda toma el tenedor a la izquierda
* del primero y asi sucesivamente. Terminamos con que cada filosofo
* tiene el tenedor a su derecha y esta esperando que este disponible
* el tenedor a su izquierda, cosa que no puede ocurrir como todos los
* filosofos estan en esa situacion. */
/* Si uno de los filosofos fuera zurdo, no ocurrira el deadlock porque
* si tomaran el tenedor a la izquierda del filosofo zurdo, este esperaria
* hasta que este disponible mientras el resto toma el tenedor a su
* derecha, no puede ocurrir el deadlock porque el zurdo al no tomar
* el tenedor a la derecha un tenedor extra esta disponible y entonces
* otro filosofo puede empezar a comer. */
/* Si comieran solamente N-1 filosofos diestros, el deadlock no ocurriria
* como a lo sumo N-1 de los N filosofos tomarian el tenedor a su derecha
* el ultimo filosofo no puede tomar el tenedor a su derecha y entonces
* habra un tenedor disponible y otro filosofo podra comer. */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
sem_t tabacoPapel, papelFosforos, fosforosTabaco, otra_vez;
void agente()
{
for (;;) {
int caso = random() % 3;
sem_wait(&otra_vez);
//~ printf("%d\n", caso);
switch (caso) {
case 0:
sem_post(&tabacoPapel);
break;
case 1:
sem_post(&fosforosTabaco);
break;
case 2:
sem_post(&papelFosforos);
break;
}
}
}
void fumar(int fumador)
{
printf("Fumador %d: Puf! Puf! Puf!\n", fumador);
sleep(1);
}
void *fumador1(void *arg)
{
for (;;) {
sem_wait(&tabacoPapel);
fumar(1);
sem_post(&otra_vez);
}
}
void *fumador2(void *arg)
{
for (;;) {
sem_wait(&fosforosTabaco);
fumar(2);
sem_post(&otra_vez);
}
}
void *fumador3(void *arg)
{
for (;;) {
sem_wait(&papelFosforos);
fumar(3);
sem_post(&otra_vez);
}
}
int main()
{
pthread_t s1, s2, s3;
sem_init(&tabacoPapel, 0, 0);
sem_init(&papelFosforos, 0, 0);
sem_init(&fosforosTabaco, 0, 0);
sem_init(&otra_vez, 0, 1);
pthread_create(&s1, NULL, fumador1, NULL);
pthread_create(&s2, NULL, fumador2, NULL);
pthread_create(&s3, NULL, fumador3, NULL);
agente();
return 0;
}
/* El deadlock ocurre si por ejemplo el agente cae en el caso 0,
* provee de tabaco entonces fumador1 para del primer semaforo, luego
* el agente provee de papel pero fumador3 pasa su primer semaforo en
* vez de que fumador1 pase del segundo. Ahi quedan ambos esperando a
* pasar por sus respectivos segundos semaforos pero el agente no provee
* mas porque esta esperando en el semaforo "otra vez" */
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment