void char void char @param void int int int int

Transcript

1 1 2 /** 3 file definition_ thread. c 4 * contiene l' implementazioni delle diverse funzioni 5 */ 6 7 /** 8 name elaborato Terzo 9 author Nicola Milani VR */ # include " definition_ thread. h" /** 16 brief Questa funzione fa qualcosa quando si genera un errore 17 param prog : nome programma ( funzione) che va in errore 18 param msg : messaggio di errore da stampare 19 */ void syserr ( char * prog, char * msg){ 22 fprintf ( stderr, "% s - error: % s\ n", prog, msg); 23 char buffer[ 40]; 24 sprintf( buffer," system error % s\ n", strerror( errno)); 25 write( 1, buffer, strlen( buffer)); 26 exit (1); 27 } 28 /** 29 brief Questa funzione stampa a video 30 param buffer : caratteri da stampare 31 */ 32 void mywrite ( char * buffer){ 33 int nread; 34 int length = strlen( buffer); 35 if(( nread=write( 0, buffer, length)) ==- 1) 36 syserr(" elaborato: mywrite", " write"); 37 } /** 40 brief Legge il file di configurazione e lo trasferisce in un buffer c har 41 param fd : file descriptor 42 param * nthread : numero di figli 43 param * numerorighe : numero di righe del file di configurazione 44 param * lnprimariga : lunghezza prima riga del file 45 * 46 **/ void leggiconfigurazionefile( int fd, int * nthread, int * numerorighe, int * l nprimariga){ 49 int nread; 50 char c; 51 char buffer[ BUFFER]; 52 char * start=buffer; 53 char * p=buffer; 54 while((nread = read (fd, &c, 1))== 1){ switch( c){ 57 case '\n': 58 if (* numerorighe == 0){ 59 *p='\0'; 60 p=start; 61 * nthread = atoi( p); 62 } 63 (* numerorighe) ++; - 1 -

2 64 break; 65 default : 66 if (* numerorighe == 0){ 67 *p=c; 68 p++; 69 } 70 break; 71 } } if (nread == -1) 76 syserr("elaborato: leggiconfigurazionefile", "read"); * lnprimariga=( strlen( p) +1); 79 (*numerorighe)--; } /** 84 brief Creo i figli che dovranno eseguire i lavori. 85 param thread : identifica le thread 86 param nthread : indica numero di figli 87 param data[] : struttura dati disponibile per ogni figlio 88 param first_ sinc : primo lucchetto 89 param second_ sinc : secondo lucchetto 90 param wait : stato del thread 91 param global_ condition : variabile condition 92 */ void creathreads ( pthread_ t threads[], int nthread, struct thread_ data data [], int * wait, pthread_ mutex_ t * first_ sinc, pthread_ mutex_ t * second_ sinc, pth read_ cond_ t * global_ condition){ 96 int i, rtrn; 97 pthread_ attr_ t attr; pthread_ attr_ init(& attr); 100 pthread_ attr_ setdetachstate(& attr, PTHREAD_ CREATE_ JOINABLE); /* inizializo le thread*/ for ( i=1; i<=nthread; i++){ data[i-1].id=i; 107 data[ i- 1]. ultimarigaassegnata=- 1; 108 data[i-1].dead='l'; 109 data[ i- 1]. wait=wait; 110 data[ i- 1]. first_ sinc=first_ sinc; 111 data[ i- 1]. second_ sinc=second_ sinc; 112 data[ i- 1]. global_ condition=global_ condition; 113 data[ i- 1]. ready=0; 114 data[ i- 1]. parentwaitme=0; pthread_mutex_init(&data[i-1].first_lock,null); 117 pthread_mutex_init(&data[i-1].second_lock,null); 118 pthread_cond_init(&data[i-1].condition,null); if(( rtrn= pthread_ create(& threads[ i- 1], & attr, calcolo, ( void *) & data[i-1] ))!=0) 121 syserr(" elaborato_ thread: creathread", " pthread_ create"); } pthread_ attr_ destroy(& attr); - 2 -

3 126 } /** 129 brief Questa funzione contiene il lavoro che devono fare le thread 130 param thread_ arg : faccio fare i lavori alle thread 131 */ void * calcolo( void * thread_ arg){ struct thread_ data * mydata = ( struct thread_ data *) thread_ arg; 136 pthread_ mutex_ lock(& mydata- >first_ lock); 137 int id = mydata- >id; 138 char buffer[ SIZE]; while ( 1) 141 { pthread_ mutex_ lock( mydata- >first_ sinc); 144 pthread_ mutex_ lock( mydata- >second_ sinc); 145 if(*(mydata->wait)==-1){ 146 *( mydata- >wait) =mydata- >id; 147 pthread_ cond_ signal( mydata- >global_ condition); 148 } 149 pthread_ mutex_ unlock( mydata- >second_ sinc); 150 pthread_ mutex_ unlock( mydata- >first_ sinc); sprintf( buffer," id : % d mi metto in attesa, \ n", id); 153 mywrite( buffer); mydata- >ready=1; if( mydata- >parentwaitme == 1){ 158 mydata- >parentwaitme=0; 159 pthread_ cond_ signal(& mydata- >condition); } 162 pthread_ cond_ wait(& mydata- >condition,& mydata- >first_ lock); sprintf( buffer," id :% d parto speriamo bene, \ n", id); 165 mywrite(buffer); if( mydata- >dead == ' K') 168 { 169 pthread_ mutex_ unlock(& mydata- >first_ lock); 170 sprintf( buffer," id: non servo più ciao ciao \ n"); 171 mywrite( buffer); 172 pthread_ exit(( void *) 0); 173 } switch( mydata- >operazione){ 176 case '-': 177 mydata- >risultato =( double) mydata- >op1 - mydata- >o p2; 178 sprintf(buffer,"id:\t%d ho calcolato:\t %d - %d = % f \ n", id, mydata- >op1, mydata- >op2, mydata- >risultato); 179 mywrite( buffer); 180 break; 181 case '+': 182 mydata- >risultato =( double) mydata- >op1 + mydata- >o p2; 183 sprintf(buffer,"id:\t%d ho calcolato:\t %d + %d = % f \ n", id, mydata- >op1, mydata- >op2, mydata- >risultato); 184 mywrite( buffer); 185 break; 186 case '*': - 3 -

4 187 mydata- >risultato =( double) mydata- >op1 * mydata ->op2; 188 sprintf(buffer,"id:\t%d ho calcolato:\t %d * %d = % f \ n", id, mydata- >op1, mydata- >op2, mydata- >risultato); 189 mywrite( buffer); 190 break; 191 case '/': 192 mydata- >risultato =( double) mydata- >op1 / mydata- >o p2; 193 sprintf(buffer,"id:\t%d ho calcolato:\t %d / %d = % f \ n", id, mydata- >op1, mydata- >op2, mydata- >risultato); 194 mywrite( buffer); 195 break; 196 } } } /** 203 brief Questa funzione assegna a ogni thread il lavoro da fare 204 param data[] : strutture dei figli 205 param risultato[] : array risultati 206 param id[] : identifico thread 207 param operazioni[][ 3] : matrice operazioni da assegnare n1 + codop + n2 208 param nthread : numero thread 209 param numerorighe : numero righe lette da file 210 *wait 211 param * second_ sinc : secondo lucchetto 212 param * global_ condition : condition variable 213 * */ void distribuiscilavoro( struct thread_ data data[], double risultato[], int id[], int operazioni[][ 3], int nthread, int numerorighe, int * wait, pthrea d_ mutex_ t * second_ sinc, pthread_ cond_ t * global_ condition){ int i; 218 char buffer[ SIZE]; 219 for(i=0;i<numerorighe;i++){ switch(id[i]){ 222 case 0: id[ i] = trovathreadlibera( data, nthread, wait, second_ sinc, glo bal_ condition); default: /* assegno le operazioni nella zona di memoria del processo i- esimo se il processo è libero */ sprintf( buffer," CONTROLLO SE LA % d THREAD È PRONTA SE NON L O È ATTENDO\n ", id[i]); 232 mywrite( buffer); 233 pthread_mutex_lock(&data[id[i]-1].first_lock); sprintf( buffer," IL LOCK DELL % d THREAD È LIBERO CONTROLLO S E LEI È PRONTA\n ", id[i]); 236 mywrite( buffer); if(data[id[i]-1].ready==0){ 239 data[ id[ i]- 1]. parentwaitme=1; 240 pthread_cond_wait(&data[id[i]-1].condition,&data[id[i]

5 ].first_lock); 241 } sprintf( buffer," LA % d THREAD È PRONTA ALLORA LE DO LAVORO \n", id[i]); 244 mywrite( buffer); if(data[id[i]-1].ultimarigaassegnata!= -1){ 248 /* 249 * se ho assegnato in precedenza un lavoro alla thread i- esima allora data[ i]. ultimarigaassegnata corrisponde 250 * alla riga che è stata eseguita dal processo 251 */ 252 risultato[ data[ id[ i]- 1]. ultimarigaassegnata] =data[ id[ i] -1].risultato; 253 /* 254 * segno che il risultato della riga data[ i]. ultimariga Assegnata elaborata dal processo id[ i] è gia stato registrato 255 * sul array risultati 256 */ 257 id[data[id[i]-1].ultimarigaassegnata]=-1; } sprintf( buffer," CARICO LE OPERAZIONI DELLA % d THREAD\ n", i d[i]); 262 mywrite( buffer); data[id[i]-1].op1 = operazioni[i][0]; 265 data[id[i]-1].op2 = operazioni[i][2]; switch( operazioni[ i][ 1]) 268 { 269 case 0: 270 data[id[i]-1].operazione = '-'; 271 break; 272 case 1: 273 data[id[i]-1].operazione = '+'; 274 break; 275 case 2: 276 data[id[i]-1].operazione = '*'; 277 break; 278 case 3: 279 data[id[i]-1].operazione = '/'; 280 break; 281 } 282 /* sblocco la thread i- esima e segno su data[ i]. ultimarigaa ggegnata la riga che li sto dando */ 283 data[ id[ i]- 1]. ultimarigaassegnata=i; data[id[i]-1].ready=0; 286 pthread_cond_signal(&data[id[i]-1].condition); 287 pthread_mutex_unlock(&data[id[i]-1].first_lock); break; 292 } 293 } } /** 298 brief Nel caso in cui il file di configurazione preveda di assegnare - 5 -

6 299 * un operazione al primo figlio che termina di lavorare, questa funzione restituisce 300 * il suo ID 301 param data[] : struttura dati del figlio 302 param ntherad : numero di figli 303 wait 304 param second_ sinc : secondo lucchetto 305 param global_ condition : variabile condition 306 */ int trovathreadlibera( struct thread_ data data[], int nthread, int * wait, pth read_ mutex_ t * second_ sinc, pthread_ cond_ t * global_ condition){ int i=0; 311 char buffer[ SIZE]; pthread_ mutex_ lock( second_ sinc); sprintf( buffer," STO PER CERCARE LA PRIMA THREAD LIBERA\ n"); 316 mywrite(buffer); for(i=0;i<nthread;i++){ 319 if(data[i].ready==1){ 320 pthread_ mutex_ unlock( second_ sinc); 321 return i+1; 322 } 323 } sprintf( buffer," NON HO TROVATO THREAD LIBERE QUINDI MI METTO IN ATT ESA\n"); 326 mywrite( buffer); * wait=- 1; 329 pthread_ cond_ wait( global_ condition, second_ sinc); 330 pthread_ mutex_ unlock( second_ sinc); return * wait; 334 } /** 337 brief Legge dal file di configurazione le singole righe delle operazi oni 338 * e le colloca in un array operazioni formato da NUM1 + OPERATORE + NUM2 per ogni riga 339 param fd : file descriptor 340 param lnprimariga : lunghezza prima riga 341 param id[] : identifica il figlio 342 param operazioni[][ 3] : matrice delle operazioni caricate sul file co nfiguarazione nel formato n1 + op + n2 343 */ void leggioperazioni( int fd, int lnprimariga, int id[], int operazioni[][ 3] ){ 346 int where, nread, numerorighe=0; 347 char c; 348 char buffer[ BUFFER]; 349 char * start=buffer; 350 char * p=buffer; 351 if (( where=lseek( fd, lnprimariga, SEEK_ SET)) == - 1){ 352 syserr("elaborato: leggioperazioni", "lseek"); 353 } while((nread = read(fd, &c, 1))== 1){

7 357 switch (c){ 358 case ' ': 359 *p='\0'; 360 p=start; 361 id[ numerorighe] = atoi( p); 362 scorririga( fd, operazioni[ numerorighe]); 363 numerorighe++; 364 break; 365 default : 366 *p=c; 367 p++; 368 break; 369 } 370 } if ( nread == - 1) 373 syserr("elaborato: leggioperazioni", "read"); 374 } /** 377 brief Questa funzione attende che figli finiscano di lavorare. 378 param threads[] : identifica i figli 379 param data[] : struttura dati del figlio 380 param nthread : numero figli 381 */ void attendifinelavorofigli( pthread_ t threads[], struct thread_ data data[], int nthread){ 384 int i; 385 char buffer[ 40]; 386 for( i=0; i<nthread; i++){ 387 sprintf( buffer," ASPETTO LA % d THREAD \ n", i+1); 388 mywrite( buffer); 389 pthread_mutex_lock(&data[i].first_lock); 390 if(data[i].ready==0){ 391 data[ i]. parentwaitme=1; 392 pthread_cond_wait(&data[i].condition,&data[i].first_loc k); 393 } 394 pthread_mutex_unlock(&data[i].first_lock); 395 sprintf( buffer," LA % d THREAD HA FINITO \ n", i+1); 396 mywrite(buffer); 397 } 398 } /** 401 brief I figli salvano il risultato in un' array. Ma se un figlio viene eseguito più volte? 402 * Questa funzione controlla che tutti i figli abbiano salvato nell' array i risultati 403 * depositati in memoria condivisa 404 param id[] : identifica figli 405 param risultato[] : contiene risultati 406 param numerorighe : numerorighe file 407 param data[] struttura dati del figlio i- esimo 408 */ void salvarisultatimancanti( int id[], double risultato[], int numerorighe, str uct thread_ data data[]){ 411 int i; for( i=0; i<numerorighe; i++){ if(id[i]>0){

8 417 risultato[ i] = data[ id[ i]- 1]. risultato; 418 } 419 } 420 } /** 423 brief Questa funzione scrive nell' apposita area di memoria il comando di 424 * terminazione dei figli, loro vedono e muoiono. 425 param threads[] : figli da uccidere 426 param data[] : struttura dati del figlio 427 param nthread : numero figli 428 */ void uccidifigli( pthread_ t threads[], struct thread_ data data[], int nthread ){ 431 char buffer[ SIZE]; 432 int j; for ( j=0; j<nthread ; j++){ 435 data[j].dead='k'; 436 } for( j=0 ; j<nthread ; j++){ 439 pthread_mutex_lock(&data[j].first_lock); 440 pthread_ cond_ signal(& data[ j]. condition); 441 pthread_mutex_unlock(&data[j].first_lock); 442 } /* aspetto che tutte le thread siano morti */ 445 int status; 446 int rtrn; 447 int i; for(i=0; i<nthread; i++){ 450 rtrn = pthread_ join( threads[ i],( void **) & status); // id processo ef fettivamente morto, status è lo stato di uscita del figlio if( rtrn){ 453 sprintf( buffer," CODICE DI ERRORE RITORNATO DALLA pthread_ join D ELLA THREAD CON ID: %d È: %d",i+1,rtrn); 454 syserr(" uccidifigli: ", buffer); 455 } 456 sprintf( buffer," JOIN SULLA % d THREAD COMPLETATO STATO= % d \ n", i, s tatus); 457 mywrite( buffer); 458 } } /** 463 brief Questa funzione passa alla riga successiva e codifica 464 * i simboli degli operatori matematici nel formato di operazione[] ( int) 465 param fd : file descriptor 466 param operazione : buffer della riga operazione 467 */ void scorririga ( int fd, int * operazione){ 470 int nread; 471 int fine = 0; 472 char buffer[ 30]; 473 char * p=buffer; 474 char * start=buffer; 475 char c; - 8 -

9 476 while((nread = read (fd, &c, 1)) == 1 &&!fine ){ switch (c){ 479 case '\n': 480 *p='\0'; 481 p=start; 482 * operazione=atoi( p); 483 fine = 1; 484 break; 485 case '-' : 486 *p='\0'; 487 p=start; 488 * operazione++=atoi( p); 489 * operazione++=0; 490 break; 491 case '+' : 492 *p='\0'; 493 p=start; 494 * operazione++=atoi( p); 495 * operazione++=1; 496 break; 497 case '*' : 498 *p='\0'; 499 p=start; 500 * operazione++=atoi( p); 501 * operazione++=2; 502 break; 503 case '/' : 504 *p='\0'; 505 p=start; 506 * operazione++=atoi( p); 507 * operazione++=3; 508 break; default : 511 *p=c; 512 p++; 513 break; 514 } } if ( nread == - 1) 519 syserr("elaborato: scorririga", "read"); int where; 522 if (( where=lseek( fd, - 1L, SEEK_ CUR)) == - 1){ 523 syserr("elaborato: scorririga", "lseek"); 524 } }