Index: /trunk/guardiano.c
===================================================================
--- /trunk/guardiano.c	(revision 25)
+++ /trunk/guardiano.c	(revision 25)
@@ -0,0 +1,87 @@
+/* Copyright (C) 2009 by Mattia Monga <mattia.monga@unimi.it> */
+/* $Id$ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <pthread.h>
+
+pthread_t p1,p2,p3;
+
+pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t dodici = PTHREAD_COND_INITIALIZER;
+int contatore = 0;
+
+
+
+void* guardiano(void* x){
+        pthread_mutex_lock(&lock);
+        while ( contatore < 12){
+                printf("Going to block...........\n");
+                pthread_cond_wait(&dodici, &lock);
+                printf("Watcher alive...........\n");
+        }
+        pthread_mutex_unlock(&lock);
+        printf("Dodici!!!!!\n");
+        return NULL;
+}
+
+// Il corpo del ciclo viene eseguito mantenendo il lock
+void* incrementatore1(void* x){
+        while(pthread_mutex_lock(&lock), contatore < 12){
+                contatore += 1;
+                printf("Sono pippo e sto incrementando: %d\n ", 
+                       contatore);
+                if (contatore == 12) {
+                        printf("Sveglia da pippo!!!!!\n");
+                        pthread_cond_signal(&dodici);
+                }
+                pthread_mutex_unlock(&lock);
+                pthread_yield();
+        }
+        pthread_mutex_unlock(&lock);
+        return NULL;
+}
+
+// come il precedente ma scritto con do-while forse e` piu` chiaro
+void* incrementatore2(void* x){
+        do { 
+                pthread_mutex_lock(&lock);
+                contatore += 1;
+                printf("Sono pluto e sto incrementando: %d\n ", 
+                       contatore);
+                if (contatore == 12){
+                        printf("Sveglia da pluto!!!!!\n");
+                        pthread_cond_signal(&dodici);
+                }
+                pthread_mutex_unlock(&lock);
+                pthread_yield();
+        } while (contatore < 12);
+        return NULL;
+}
+
+
+
+
+int main(void){
+
+        pthread_create(&p1, NULL, incrementatore1, NULL);
+        pthread_create(&p2, NULL, incrementatore2, NULL);
+        pthread_create(&p3, NULL, guardiano, NULL);
+
+        pthread_join(p1, NULL);
+        pthread_join(p2, NULL);
+        pthread_join(p3, NULL);
+        
+        return 0;
+}
+
+    
+        
+  
+
+
+
+/* Local Variables: */
+/* compile-command: "make -k " */
+/* End: */
Index: /trunk/threads-sem.c
===================================================================
--- /trunk/threads-sem.c	(revision 24)
+++ /trunk/threads-sem.c	(revision 25)
@@ -9,5 +9,5 @@
 #include <semaphore.h>
 
-void enter_section(sem_t *s){ 
+void down(sem_t *s){ 
         if (sem_wait(s) < 0){
                 perror("Errore semaforo (down)");
@@ -16,8 +16,5 @@
 }
 
-        
-
-void leave_section(sem_t *s)
-{
+void up(sem_t *s){
         if (sem_post(s) < 0){
                 perror("Errore semaforo (up)");
@@ -26,76 +23,46 @@
 }
 
-int run(const int p, void* s)
-{
-        int* shared = (int*)s; /* alias per comodita` */
-        while (enter_section((sem_t*)shared[1]), 
-               shared[0] < 10) {
+int shared = 0;
+pthread_t p1, p2;
+sem_t ss;
+
+void* run(void* s){
+        while (down(&ss), 
+               shared < 10) {
                 sleep(1);
-                printf("Processo figlio (%d). s = %d\n", 
-                       getpid(), shared[0]);
-                if (!(shared[0] < 10)){
+                printf("Processo thread (%p). s = %d\n", 
+                       pthread_self(), shared);
+                if (!(shared < 10)){
                         printf("Corsa critica!!!!\n");
                         abort();
                 }
-                shared[0] += 1;
-                leave_section((sem_t*)shared[1]);
-                sched_yield();
+                shared += 1;
+                up(&ss);
+                pthread_yield();
         }
-        return 0;
+        up(&ss);
+        return NULL;
 }
 
-int run0(void*s){ return run(0, s); }
-int run1(void*s){ return run(1, s); }
-        
+
 
 int main(void){
- 
-        int shared[4] = {0 , 0, 0, 0};
 
-        sem_t *ss;
-        if (sem_init(ss, 
+        if (sem_init(&ss, 
                      0 /* thread local semaphore */,
-                     0 /* init value */
+                     1 /* init value */
                     ) < 0){
                 perror("Errore semaforo");
                 exit(1);
         }
-        shared[1] = (int)ss;
 
-        /* int clone(int (*fn)(void *), 
-         *           void *child_stack, 
-         *           int flags,
-         *           void *arg); 
-         * crea una copia del chiamante (con le caratteristiche 
-         * specificate da flags) e lo esegue partendo da fn */
-        if (clone(run0, /* il nuovo
-                         * processo esegue run(shared), vedi quarto
-                         * parametro */
-                  malloc(4096)+4096,  /* lo stack del nuovo processo 
-                                       *  (cresce verso il basso!) */
-                  CLONE_VM | SIGCHLD, /* la (virtual) memory e` condivisa */
-                  shared) < 0){
-                perror("Errore nella creazione");
-                exit(1);
-        } 
+        pthread_create(&p1, NULL, run, NULL);
+        pthread_create(&p2, NULL, run, NULL);
 
-        if (clone(run1, malloc(4096)+4096,  CLONE_VM | SIGCHLD, shared) < 0){
-                perror("Errore nella creazione");
-                exit(1);
-        } 
-
-        /* Memoria condivisa: i due figli nell'insieme eseguono 10 o
-         * 11 volte: e` possibile una corsa critica. Il padre
-         * condivide shared[0] con i figli */
-
-        while(shared[0] < 10) {
-                sleep(1);
-                printf("Processo padre. s = %d %d %d %d\n", 
-                       shared[0],
-                       shared[1],
-                       shared[2],
-                       shared[3]);
-        }
-        sem_destroy(ss);
+        pthread_join(p1, NULL);
+        pthread_join(p2, NULL);
+        
+        sem_destroy(&ss);
+        
         return 0;
 }