home *** CD-ROM | disk | FTP | other *** search
/ ftp.disi.unige.it / 2015-02-11.ftp.disi.unige.it.tar / ftp.disi.unige.it / pub / .person / GianuzziV / SO1 / thread2.c < prev    next >
C/C++ Source or Header  |  2005-03-20  |  4KB  |  163 lines
  1. #include <pthread.h>
  2. #include <sys/types.h>
  3. #include <stdio.h>
  4. #include <sys/stat.h>
  5. #include <fcntl.h>
  6. #include <unistd.h>
  7. #include <sys/times.h>
  8.  
  9. /********************************************************
  10. *  file thread2.c                                       *
  11. *  legge 10 volte dei blocchi da 10 MB dal file         *
  12. *  mega.dat (deve gia'esistere) usando un buffer di     *
  13. *  memoria da 2MB e 2 thread che leggono e calcolano    *
  14. *  in interleaving                                      *
  15. *  Scrive i tempi                                       *
  16. *                                                       *
  17. *  Provare anche ad usare un buffer con 2 indici        *
  18. *     buffer[2][10000000] invece di buffer[20000000]    *
  19. *  e verificare i tempi                                 *
  20. *                                                       *
  21. *  gcc -D_REENTRANT thread2.c -o thread2.exe -lpthread  *
  22. *********************************************************/
  23.  
  24. int   fd, valC, valD;
  25. char  buffer[20000000]; 
  26. int   ini[10], fin[10], calc[10], calcini[10];
  27.  
  28. clock_t t1, t2;
  29. struct tms buf;
  30.  
  31. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  32. pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  33. int flag=0;
  34.  
  35. pthread_t  reader;
  36. pthread_t  eval;
  37.  
  38. void reader_function(void);
  39. void eval_function(void);
  40.  
  41. main ()
  42. {
  43.   int i;
  44.  
  45.   t1=times(&buf);
  46.   printf("valore times %d\n", t1);
  47.   fd=open("mega.dat", O_RDONLY);
  48.  
  49.   ini[0]=times(&buf);
  50.   read(fd, &buffer[0], (sizeof(buffer)/2));
  51.   fin[0]=times(&buf);
  52. //  printf("reader 0,  inizio %d,  fine %d,  tot %d\n", ini[0], fin[0],
  53. //          fin[0]-ini[0]);
  54.   
  55.   pthread_create(&reader, NULL, (void*)&reader_function, NULL);
  56.   pthread_create(&eval, NULL, (void*)&eval_function, NULL);
  57.  
  58.   pthread_join(reader, NULL);
  59.   pthread_join(eval, NULL);
  60.  
  61.   t2=times(&buf);
  62.   printf("fine times %d\n", t2);
  63.   printf("times totale %d\n", t2-t1);
  64.  
  65.   valD=0;
  66.   for (i=0; i<10; i++)
  67.     valD=valD+fin[i]-ini[i];
  68.   valC=0;
  69.   for (i=0; i<10; i++)
  70.     valC=valC+calc[i]-calcini[i];
  71.  
  72.   printf("tempo lettura disco %d,    tempo calcolo %d\n", valD, valC);
  73. }
  74.  
  75. void reader_function(void)
  76. {
  77.   int i, start;
  78.  
  79.   for (i=1; i<10; i++)
  80.   {
  81.     pthread_mutex_lock(&mutex);
  82.     flag=flag+1;
  83.     if (flag==2)
  84.     {
  85.       flag=0;
  86.       pthread_cond_broadcast(&cond);
  87.     }
  88.     else pthread_cond_wait(&cond, &mutex);
  89.  
  90.     pthread_mutex_unlock(&mutex);
  91.  
  92.     if ((i%2)==1)
  93.     {
  94.       ini[i]=times(&buf);
  95.       read(fd, &buffer[10000000], (sizeof(buffer)/2));
  96.       fin[i]=times(&buf);      
  97.     }
  98.     else
  99.     {
  100.       ini[i]=times(&buf);
  101.       read(fd, &buffer[0], (sizeof(buffer)/2));
  102.       fin[i]=times(&buf);
  103.     }
  104. //  printf("reader %d,  inizio %d,  fine %d,  tot %d\n", i, 
  105. //          ini[i], fin[i], fin[i]-ini[i]);
  106.   }
  107. }
  108.  
  109. void eval_function(void)
  110. {
  111.   int  i, j, k, start, fine;
  112.   char max;
  113.  
  114.   for (i=0; i<9; i++)
  115.   {
  116.     pthread_mutex_lock(&mutex);
  117.     flag=flag+1;
  118.     if (flag==2) 
  119.     {
  120.       flag=0;
  121.       pthread_cond_broadcast(&cond);
  122.       pthread_mutex_unlock(&mutex);
  123.     }
  124.     else 
  125.     {
  126.        pthread_cond_wait(&cond, &mutex);
  127.        pthread_mutex_unlock(&mutex);
  128.     }
  129.  
  130.     if ((i%2)==0)
  131.     {
  132.       calcini[i]=times(&buf);
  133.       max=0;
  134.       for (k=0; k<20; k++)
  135.         for (j=0; j<10000000; j++)
  136.           if (max<=buffer[j]) max=buffer[j];
  137.       calc[i]=times (&buf);
  138.     }
  139.     else
  140.     {
  141.       calcini[i]=times(&buf);
  142.       max=0;
  143.       for (k=0; k<20; k++)
  144.         for (j=10000000; j<20000000; j++)
  145.           if (max<=buffer[j]) max=buffer[j];
  146.       calc[i]=times (&buf);
  147.     }
  148. //    printf("eval %d,  inizio %d,  fine %d,  tot %d\n", i, calcini[i], 
  149. //            calc[i], calc[i]-calcini[i]);
  150.  
  151.   }
  152.  
  153.   calcini[9]=times(&buf);
  154.   max=0;
  155.   for (k=0; k<20; k++)
  156.     for (j=10000000; j<20000000; j++)
  157.       if (max<=buffer[j]) max=buffer[j];
  158.   calc[9]=times (&buf);
  159. //  printf("eval 9,  inizio %d,  fine %d,  tot %d\n", calcini[9], calc[9],
  160. //          calc[9]-calcini[9]);
  161. }
  162.  
  163.