Advertisement
Guest User

Untitled

a guest
Jan 19th, 2020
116
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 4.88 KB | None | 0 0
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<pthread.h>
  4. #include<unistd.h>
  5.  
  6. typedef int buffer_type;
  7. int buffer_size;
  8. int number_of_readers;
  9. int number_of_items;
  10. int number_of_places=0;
  11. int MAX;
  12.  
  13. buffer_type * buffer;
  14. pthread_mutex_t * mutex;
  15. pthread_mutex_t mutex_print;
  16.  
  17. int * items_unread;
  18. int ** reader_item;
  19. int * indexes;
  20.  
  21. pthread_t * readers;
  22. pthread_t writer;
  23. buffer_type get_buffer_item()
  24. {
  25. return rand()%1000;
  26. }
  27. void display_buffer_item(buffer_type item)
  28. {
  29. printf("item is : %d\n", item);
  30. }
  31.  
  32. void initialize()
  33. {
  34. buffer = (buffer_type*) malloc( sizeof(buffer_type) * buffer_size );
  35. mutex = (pthread_mutex_t*) malloc( sizeof(pthread_mutex_t) * buffer_size );
  36. pthread_mutex_init(&mutex_print, NULL);
  37. items_unread = (int*) malloc( sizeof(int) * buffer_size );
  38. for(int i=0; i<buffer_size; i++)
  39. {
  40. items_unread[i] = 0;
  41. buffer[i] = -1;
  42. pthread_mutex_init( &mutex[i], NULL );
  43. }
  44.  
  45. readers = (pthread_t*) malloc( sizeof(pthread_t) * number_of_readers );
  46. indexes = (int*) malloc( sizeof(int) * number_of_readers );
  47.  
  48. for(int i=0; i<number_of_readers; i++)
  49. indexes[i] = i;
  50.  
  51. reader_item = (int**) malloc( sizeof(int*) * number_of_readers );
  52. for(int i=0; i<number_of_readers; i++)
  53. reader_item[i] = (int*) malloc( sizeof(int) * buffer_size );
  54.  
  55. for(int i=0; i<number_of_readers; i++)
  56. for(int j=0; j<buffer_size; j++)
  57. reader_item[i][j] = 0;
  58. }
  59. void color(int i) {
  60. printf("\x1B[%dm",i+31);
  61. }
  62. void read_it(int reader_id, int item_id, int* unread)
  63. {
  64. int old_cancel_state;
  65. pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &old_cancel_state);
  66. printf("reader nmbr - %d reads id = %d , item = %d\n", reader_id, item_id, buffer[item_id]);
  67. pthread_setcancelstate (old_cancel_state, NULL);
  68. reader_item[reader_id][item_id] = 1;
  69. items_unread[item_id]--;
  70. (*unread)--;
  71.  
  72. }
  73.  
  74. void* reader_thread(void* args)
  75. {
  76.  
  77. int idx = *(int*)args;
  78. int unread = number_of_items;
  79. if(number_of_places>0)printf("readers in library %d \n",number_of_places);
  80. while(unread)
  81. {
  82. int item_idx = rand()%buffer_size;
  83. pthread_mutex_lock(&mutex[item_idx]);
  84. if(buffer[item_idx]!=-1 && !reader_item[idx][item_idx])
  85. read_it(idx, item_idx, &unread);
  86. pthread_mutex_unlock(&mutex[item_idx]);
  87. }
  88.  
  89. if(unread==0){printf("reader exits %d\n", idx);
  90. number_of_places--;}
  91. return NULL;
  92. }
  93.  
  94. void insert_into_buffer(int idx, int * items_remainig)
  95. {
  96. printf("writer enters - %d \t",idx);
  97. int old_cancel_state;
  98. buffer_type item = get_buffer_item();
  99. buffer[idx] = item;
  100. items_unread[idx] = number_of_readers;
  101. for(int i=0; i<number_of_readers; i++)
  102. reader_item[i][idx] = 0;
  103. (*items_remainig)--;
  104. pthread_setcancelstate (PTHREAD_CANCEL_DISABLE, &old_cancel_state);
  105. printf("writer writes id = %d : item = %d\t", idx, item);
  106. pthread_setcancelstate (old_cancel_state, NULL);
  107. printf("writer exits - %d \n" ,idx);
  108. }
  109.  
  110. void* writer_thread(void* no)
  111. {
  112. int j, items_remainig = number_of_items;
  113. while(items_remainig)
  114. {
  115. for(int i=0; i<buffer_size; i++)
  116. {
  117. j = 0;
  118. pthread_mutex_lock(&mutex[i]);
  119. if(items_unread[i]==0)
  120. {
  121. insert_into_buffer(i, &items_remainig);
  122. j = 1;
  123. }
  124. pthread_mutex_unlock(&mutex[i]);
  125. if(j)break;
  126. }
  127. }
  128.  
  129. return NULL;
  130. }
  131.  
  132. void start_threads() {
  133. int flag=0;
  134. pthread_create( &writer, NULL, writer_thread, NULL);
  135. for(int i=0; i<number_of_readers; i++){
  136. if(MAX>number_of_places){
  137. if(number_of_places<=MAX)color(i);
  138. pthread_create(&readers[i], NULL, reader_thread, &indexes[flag]);
  139. number_of_places++;
  140.  
  141. flag++;
  142. }
  143. else {i--;}}
  144.  
  145. for(int i=0; i<number_of_readers; i++)
  146. pthread_join(readers[i], 0);
  147. pthread_join(writer, 0);
  148. }
  149.  
  150. void cleanout()
  151. {
  152. free(buffer);
  153. free(mutex);
  154. free(indexes);
  155. free(readers);
  156. free(items_unread);
  157. for(int i=0; i<number_of_readers; i++)
  158. free(reader_item[i]);
  159. free(reader_item);
  160. }
  161.  
  162. int getNum(char * str)
  163. {
  164. if(str==NULL)return -1;
  165. int a=0, i=0;
  166. while(1)
  167. {
  168. if(str[i]=='\0')break;
  169. if(str[i]<'0' || str[i]>'9')
  170. {
  171. a=-1;
  172. break;
  173. }
  174. a = a*10 + str[i]-'0';
  175. i++;
  176. }
  177. return a;
  178. }
  179.  
  180. int main(int argc, char *argv[])
  181. {
  182. if(argc != 4)
  183. {
  184. printf("give correct args.\n");
  185. printf("./[programname] num_readers number_of_items\n");
  186. return 0;
  187. }
  188. int numReaders = getNum(argv[1]);
  189. int buffSize = getNum(argv[2]);
  190. int numItems = getNum(argv[2]);
  191. int places = getNum(argv[3]);
  192. MAX=places;
  193. if(numReaders<0 || numItems<0 || places<0)
  194. {
  195. printf("give correct args.\n");
  196. printf("./[programname] num_readers number_of_writers number_of_places\n");
  197. return 0;
  198. }
  199.  
  200. number_of_items = numItems;
  201. buffer_size = buffSize;
  202. number_of_readers = numReaders;
  203. initialize();
  204. start_threads();
  205. cleanout();
  206. return 0;
  207. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement