SHARE
TWEET

tostas

a guest Jul 19th, 2019 101 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /**
  2. * @file main.c
  3. * @brief Description
  4. * @date 2018-1-1
  5. * @author name of author
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <unistd.h>
  11. #include <errno.h>
  12. #include <string.h>
  13. #include <sys/types.h>
  14. #include <sys/wait.h>
  15. #include <pthread.h>
  16.  
  17. #include "debug.h"
  18. #include "memory.h"
  19. #include "args.h"
  20.  
  21. #define MODE_SLICE 0
  22. #define MODE_FIAMBRE 1
  23. #define MODE_QUEIJO_1 2
  24. #define MODE_FINALIZADOR 3
  25. #define MODE_TOSTAR 6
  26. #define MODE_QUEIJO_2 4
  27. #define MODE_MESA 10
  28.  
  29. #define ERR_THREADS 5
  30.  
  31. void *task(void *arg);
  32. struct gengetopt_args_info args;
  33. typedef struct
  34. {
  35.     int mode; // slice, fiambre, etc..
  36.     pthread_mutex_t mutex;
  37.     pthread_cond_t cond;
  38. }shared_t;
  39.  
  40. void *slice(void *);
  41. void *fiambre(void *);
  42. void *queijo(void *);
  43. void *finalizador(void *);
  44.  
  45.  
  46.  
  47. int main(int argc, char *argv[]){
  48.     /* Disable warnings */
  49.     (void)argc; (void)argv;
  50.  
  51. if(cmdline_parser(argc, argv, &args))
  52.         ERROR(1, "Erro: execução de cmdline_parser\n");
  53.  
  54.     shared_t shared;
  55.     shared.mode = MODE_SLICE;
  56.    
  57.     if ((errno = pthread_mutex_init(&shared.mutex, NULL)) != 0) {
  58.         ERROR(ERR_THREADS, "pthread_mutex_init() failed");
  59.     }
  60.     if ((errno = pthread_cond_init(&shared.cond, NULL)) != 0) {
  61.         ERROR(ERR_THREADS, "pthread_cond_init() failed");
  62.     }
  63.  
  64.     pthread_t tid1,tid2,tid3,tid4;
  65.  
  66.     if ((errno = pthread_create(&tid1, NULL, slice, &shared)) != 0) {
  67.         ERROR(ERR_THREADS, "pthread_create() failed");
  68.     }
  69.     if ((errno = pthread_create(&tid2, NULL, fiambre, &shared)) != 0) {
  70.         ERROR(ERR_THREADS, "pthread_create() failed");
  71.     }
  72.     if ((errno = pthread_create(&tid3, NULL, queijo, &shared)) != 0) {
  73.         ERROR(ERR_THREADS, "pthread_create() failed");
  74.     }
  75.     if ((errno = pthread_create(&tid4, NULL, finalizador, &shared)) != 0) {
  76.         ERROR(ERR_THREADS, "pthread_create() failed");
  77.     }
  78.  
  79.     if ((errno = pthread_join(tid1, NULL)) != 0) {
  80.         ERROR(ERR_THREADS, "pthread_join() failed");
  81.     }
  82.     if ((errno = pthread_join(tid2, NULL)) != 0) {
  83.         ERROR(ERR_THREADS, "pthread_join() failed");
  84.     }
  85.     if ((errno = pthread_join(tid3, NULL)) != 0) {
  86.         ERROR(ERR_THREADS, "pthread_join() failed");
  87.     }
  88.     if ((errno = pthread_join(tid4, NULL)) != 0) {
  89.         ERROR(ERR_THREADS, "pthread_join() failed");
  90.     }
  91.  
  92.     if ((errno = pthread_mutex_destroy(&shared.mutex)) != 0) {
  93.         ERROR(ERR_THREADS, "pthread_mutex_destroy() failed");
  94.     }
  95.     if ((errno = pthread_cond_destroy(&shared.cond)) != 0) {
  96.         ERROR(ERR_THREADS, "pthread_cond_destroy() failed");
  97.     }
  98.     cmdline_parser_free(&args);
  99.  
  100.     return 0;
  101. }
  102. void *slice(void *arg)
  103. {
  104.     shared_t * param = arg;
  105.  
  106.     if ((errno = pthread_mutex_lock(&(param->mutex))) != 0)
  107.         {
  108.             WARNING("pthread_mutex_lock() failed\n");
  109.             return NULL;
  110.         }
  111.  
  112.     if(param->mode!=MODE_SLICE)
  113.         {
  114.            
  115.             if ((errno = pthread_cond_wait(&(param->cond), &(param->mutex))) != 0)
  116.             {
  117.                 WARNING("pthread_cond_wait() failed");
  118.                 return NULL;
  119.             }
  120.         }
  121.         printf("Bread Sliced!!\n");
  122.         param->mode = MODE_QUEIJO_1;
  123.        
  124.  
  125.  
  126.         if ((errno = pthread_cond_signal(&(param->cond))) != 0)
  127.         {
  128.             WARNING("pthread_cond_signal() failed");
  129.             return NULL;
  130.         }
  131.  
  132.         if ((errno = pthread_mutex_unlock(&(param->mutex))) != 0)
  133.         {
  134.             WARNING("pthread_mutex_unlock() failed");
  135.             return NULL;
  136.         }
  137.     return NULL;
  138.    
  139. }
  140. void *fiambre(void *arg)
  141. {
  142.     shared_t * param = arg;
  143.  
  144.     if ((errno = pthread_mutex_lock(&(param->mutex))) != 0)
  145.         {
  146.             WARNING("pthread_mutex_lock() failed\n");
  147.             return NULL;
  148.         }
  149.  
  150.     while(param->mode!=MODE_FIAMBRE )
  151.         {
  152.             if ((errno = pthread_cond_wait(&(param->cond), &(param->mutex))) != 0)
  153.             {
  154.                 WARNING("pthread_cond_wait() failed");
  155.                 return NULL;
  156.             }
  157.         }
  158.  
  159.         printf("Putting ham slice!!\n");
  160.         param->mode = MODE_QUEIJO_2;
  161.      
  162.  
  163.  
  164.         if ((errno = pthread_cond_broadcast(&(param->cond))) != 0)
  165.         {
  166.             WARNING("pthread_cond_signal() failed");
  167.             return NULL;
  168.         }
  169.  
  170.         if ((errno = pthread_mutex_unlock(&(param->mutex))) != 0)
  171.         {
  172.             WARNING("pthread_mutex_unlock() failed");
  173.             return NULL;
  174.         }
  175.  
  176.     return NULL;
  177. }
  178.  
  179. void *queijo(void *arg)
  180. {
  181.     shared_t * param = arg;
  182.  
  183.     if ((errno = pthread_mutex_lock(&(param->mutex))) != 0)
  184.         {
  185.             WARNING("pthread_mutex_lock() failed\n");
  186.             return NULL;
  187.         }
  188.    
  189.     while(param->mode!=MODE_QUEIJO_1){
  190.     if((errno = pthread_cond_wait(&(param->cond), &(param->mutex))) != 0)
  191.         {
  192.             WARNING("pthread_cond_wait() failed");
  193.             return NULL;
  194.         }
  195.        
  196.        
  197.             printf("Putting cheese slice #1\n");
  198.             param->mode=MODE_FIAMBRE;
  199.  
  200.             pthread_cond_broadcast(&(param->cond));
  201.  
  202.  
  203.             if ((errno = pthread_mutex_unlock(&(param->mutex))) != 0)
  204.         {
  205.             WARNING("pthread_mutex_unlock() failed");
  206.             return NULL;
  207.         }
  208.     }
  209.            
  210.     while(param->mode!=MODE_QUEIJO_2){
  211.     if((errno = pthread_cond_wait(&(param->cond), &(param->mutex))) != 0)
  212.         {
  213.             WARNING("pthread_cond_wait() failed");
  214.             return NULL;
  215.         }
  216.        
  217.        
  218.             printf("Putting cheese slice #2\n");
  219.             param->mode=MODE_FINALIZADOR;
  220.  
  221.             pthread_cond_broadcast(&(param->cond));
  222.  
  223.  
  224.             if ((errno = pthread_mutex_unlock(&(param->mutex))) != 0)
  225.         {
  226.             WARNING("pthread_mutex_unlock() failed");
  227.             return NULL;
  228.         }
  229.     }
  230.        
  231.     return NULL;
  232. }
  233.  
  234. void *finalizador(void *arg)
  235. {
  236.     shared_t * param = arg;
  237.  
  238.  
  239.     if ((errno = pthread_mutex_lock(&(param->mutex))) != 0)
  240.         {
  241.             WARNING("pthread_mutex_lock() failed\n");
  242.             return NULL;
  243.         }
  244.  
  245.     if(param->mode!=MODE_FINALIZADOR || param->mode!=MODE_TOSTAR )
  246.         {
  247.             if ((errno = pthread_cond_wait(&(param->cond), &(param->mutex))) != 0)
  248.             {
  249.                 WARNING("pthread_cond_wait() failed");
  250.                 return NULL;
  251.             }
  252.         }
  253.     else if (param->mode==MODE_TOSTAR)
  254.     {
  255.         printf("Toasting!!\n");
  256.         param->mode=MODE_FIAMBRE;
  257.     }
  258.     else if (param->mode==MODE_FINALIZADOR)
  259.     {
  260.         printf("A tosta está pronta\n");
  261.         param->mode=MODE_SLICE;
  262.         sleep(3);
  263.     }
  264.  
  265.     if ((errno = pthread_cond_signal(&(param->cond))) != 0)
  266.         {
  267.             WARNING("pthread_cond_signal() failed");
  268.             return NULL;
  269.         }
  270.  
  271.         if ((errno = pthread_mutex_unlock(&(param->mutex))) != 0)
  272.         {
  273.             WARNING("pthread_mutex_unlock() failed");
  274.             return NULL;
  275.         }
  276.  
  277.     return NULL;
  278. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top