bhè, dentro a mess.mex c'è una sequenza di 10 numeri che arrivano da un thread.
il thread 1 crea delle stringhe e le invia al thread 2 utilizzando semafori privati.
il codice completo è questo :
codice:
#include <string.h>
#include <time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#define N 5
// dichiarazione var accesso al device (static)
static int devr;
struct msg {
char mex[11];
};
struct buffer {
struct msg messages[N];
sem_t m;
sem_t priv_read;
sem_t priv_write;
int count;
int head;
int tail;
int readers;
int writers;
int blocked_writers;
int blocked_readers;
};
struct buffer *buffer_init(void) {
struct buffer *b;
b = malloc(sizeof(struct buffer));
if (b == NULL) {
return b;
}
b->head=0;
b->tail=0;
b->count=0;
b->readers = 0;
b->writers = 0;
b->blocked_readers = 0;
b->blocked_writers = 0;
sem_init(&b->priv_write, 0, 0);
sem_init(&b->priv_read, 0, 0);
sem_init(&b->m, 0, 1);
return b;
}
void buffer_get_read(struct buffer *b, struct msg *str) {
// mutua esclusione
printf("read1\n");
sem_wait(&b->m);
// se non c'è nulla da leggere mi blocco sul semaforo privato
while (b->count==0) {
printf("read2\n");
b->blocked_readers++;
// libero il mutex (per eventuali altri processi che vogliono leggere/scrivere)
sem_post(&b->m);
printf("read3\n");
// blocco sul semaforo privato
sem_wait(&b->priv_read);
printf("read4\n");
b->blocked_readers--;
}
printf("read5\n");
// aumento numero lettori
b->readers++;
// leggo il messaggio nell'area condivisa
memcpy(str, &b->messages[b->head], sizeof(struct msg));
// decremento testa e count
b->head = (b->head + 1) % N;
b->count = b->count - 1;
// dormo per un pò (per far notare la ricezione)
usleep(500000);
sem_post(&b->m);
}
void buffer_put_read(struct buffer *b) {
// mutua esclusione
printf("R1\n");
sem_wait(&b->m);
// decremento numero di lettori (stò abbandonando la lettura)
b->readers--;
// se ci sono scrittori bloccati e non ci sono lettori risveglio gli scrittori bloccati
if (b->blocked_writers && ! b->readers) {
printf("R2\n");
sem_post(&b->priv_write);
} else {
printf("R3\n");
sem_post(&b->m);
}
}
void buffer_get_write(struct buffer *b, struct msg *str) {
// mutua esclusione
printf("write1\n");
sem_wait(&b->m);
// se la coda è piena devo bloccarmi
while (b->count==N) {
printf("write2\n");
b->blocked_writers++;
// libero il mutex (per eventuali altri processi che vogliono leggere/scrivere)
sem_post(&b->m);
printf("write3\n");
// mi blocco sul semaforo privato
sem_wait(&b->priv_write);
printf("write4\n");
b->blocked_writers--;
}
printf("write5\n");
// aumento numero scrittori
b->writers++;
// scrivo il messaggio nell'area condivisa
memcpy(&b->messages[b->tail], str, sizeof(struct msg));
// incremento la coda e il count
b->tail = (b->tail + 1) % N;
b->count = b->count + 1;
// dormo per un pò (per far notare l'invio)
usleep(500000);
sem_post(&b->m);
}
void buffer_put_write(struct buffer *b) {
// mutua esclusione
printf("W1\n");
sem_wait(&b->m);
// decremento numero di scrittori (stò abbandonando la scrittura)
b->writers--;
// se ci sono lettori bloccati li sblocco
if (b->blocked_readers) {
printf("W2\n");
sem_post(&b->priv_read);
// se ci sono scrittori bloccati li sblocco
} else if (b->blocked_writers) {
printf("W3\n");
sem_post(&b->priv_write);
} else {
printf("W4\n");
sem_post(&b->m);
}
}
// dichiarazione di alcune var
struct buffer *b, *q;
int passo=1;
// thread 1 : aspetta i dati dal device 1 e li manda al thread 2
void *th1_get(void *v) {
struct msg mess;
int j;
char message[40];
int i=1,cs=0;
for (i=0; i<10; i++) {
for (j=0; j<10; j++) {
if(j==90) {
mess.mex[j]='a';
} else {
sprintf(&mess.mex[j], "%c", 48+i);
}
}
buffer_get_write(b, &mess);
cs++;
printf("%d - T1 - Stringa n.%d inviata : %s\n", passo++, cs, mess.mex);
buffer_put_write(b);
}
sprintf(mess.mex, "%s", "end_of_tr1");
buffer_get_write(b, &mess);
buffer_put_write(b);
return NULL;
}
// thread 2 : riceve i dati dal thread 1, li elabora e li manda al thread 3
void *th2_order(void *v) {
struct msg mess;
int str_conv;
int i, valuediv, cs=0;
i=1;
while(i==1) {
buffer_get_read(b, &mess);
buffer_put_read(b);
if(strncmp(mess.mex, "end_of_tr1", 10)==0) {
i=2;
} else {
//str_conv=atoi(mess.mex);
valuediv=atoi(mess.mex)%2;
printf("valuediv : %d - %d\n", valuediv, atoi(mess.mex));
buffer_get_write(q, &mess);
cs++;
printf("%d - T2 - Stringa n.%d ricevuta e inviata : %s\n", passo++, cs, mess.mex);
buffer_put_write(q);
}
}
//sprintf(mess.mex, "%s", "end_of_tr2");
//buffer_get_write(q, &mess);
//buffer_put_write(q);
return NULL;
}
però ho i miei dubbi che abbiate voglia di leggerlo tutto heheh!
mess.mex contiene, per esempio, 0000000000 il primo giro, 1111111111 il secondo... ecc ecc
voglio fare il modulo perchè dovrò gestire se quel determinato numero è pari o dispari.
quando dico che non funziona intendo che al primo passo atoi(mess) è effettivamente 0000000000, poi è sempre 2147483647.
Permessi di invio
Rispondi quotando